Library/models/book.go

package models

import (
	"fmt"
)

// Book holds a book
type Book struct {
	ID        int64   `xorm:"int(11) autoincr not null unique pk"`
	Title     string  `xorm:"varchar(250) not null"`
	Isbn      string  `xorm:"varchar(30)"`
	Year      int64   `xorm:"int(11)"`
	Price     float64 `xorm:"double"`
	Status    int64   `xorm:"int(11)"`
	Publisher int64   `xorm:"int(11)"`
	Created   int64   `xorm:"created"`
	Updated   int64   `xorm:"updated"`

	Quantity      int64     `xorm:"-"`
	PublisherFull Publisher `xorm:"-"`
	Authors       []Author  `xorm:"-"`
}

// TableName returns the name for the books table
func (Book) TableName() string {
	return "books"
}

// Quantity is the quantity for a book
type Quantity struct {
	ID       int64 `xorm:"int(11) autoincr not null unique pk"`
	BookID   int64 `xorm:"int(11) not null"`
	Quantity int64 `xorm:"int(11) not null"`
	Created  int64 `xorm:"created"`
}

// TableName returns the name for the quantites table
func (Quantity) TableName() string {
	return "books_quantities"
}

// GetQuantityByBook returns the current quantity for a book
func GetQuantityByBook(bookID int64) (quantity int64, err error) {
	bq := Quantity{BookID: bookID}
	has, err := x.Desc("id").Get(&bq)
	if err != nil {
		return 0, err
	}

	if has {
		quantity = bq.Quantity
	}

	return quantity, nil
}

// SetBookQuantity sets a new quantity for a book
func (book Book) setBookQuantity(quantity int64) (err error) {
	q := Quantity{BookID: book.ID, Quantity: quantity}
	_, err = x.Insert(q)
	return err
}

// GetBookByID gets a Book by its ID
func GetBookByID(ID int64) (book Book, exists bool, err error) {
	// Get the Book
	has, err := x.ID(ID).Get(&book)

	if has {
		// Get the books quantity. We can't join it because xorm ignores the Quantity option in struc
		qt := Quantity{BookID: ID}
		has, err = x.Desc("id").Get(&qt)
		if err != nil {
			fmt.Println("Error getting quantity:", err)
		}
		book.Quantity = qt.Quantity

		// Get publisher. We can't join it because xorm ignores the PublisherID option in struct
		publisher := Publisher{ID: book.Publisher}
		_, err = x.Get(&publisher)
		if err != nil {
			fmt.Println("Error getting publisher:", err)
		}
		book.PublisherFull = publisher

		// Get all authors
		var authors []Author
		err = x.
			Table("authors_books").
			Select("authors.*").
			Join("INNER", "authors", "authors_books.author_id = authors.id").
			Where("book_id = ?", book.ID).
			Find(&authors)

		if err != nil {
			fmt.Println("Error getting authors:", err)
		}

		book.Authors = authors
	}

	return book, has, err
}