go-bouquins/bouquins/bouquins.go

package bouquins

import (
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"github.com/c2h5oh/datasize"
)

const (
	TPL_BOOKS   = "book.html"
	TPL_AUTHORS = "author.html"
	TPL_SERIES  = "series.html"
	TPL_INDEX   = "index.html"

	PARAM_LIST   = "list"
	PARAM_ORDER  = "order"
	PARAM_SORT   = "sort"
	PARAM_LIMIT  = "limit"
	PARAM_OFFSET = "offset"

	LIST_AUTHORS = "authors"
	LIST_SERIES  = "series"
	LIST_BOOKS   = "books"

	URL_INDEX   = "/"
	URL_BOOKS   = "/books/"
	URL_AUTHORS = "/authors/"
	URL_SERIES  = "/series/"
	URL_JS      = "/js/"
	URL_CSS     = "/css/"
	URL_FONTS   = "/fonts/"
	URL_CALIBRE = "/calibre/"
)

type Bouquins struct {
	*template.Template
	*sql.DB
}

/*
 * A book series.
 */
type Series struct {
	Id   int64  `json:"id,omitempty"`
	Name string `json:"name,omitempty"`
}

/*
 * A book. Generic data.
 */
type Book struct {
	Id          int64   `json:"id,omitempty"`
	Title       string  `json:"title,omitempty"`
	SeriesIndex float64 `json:"series_idx,omitempty"`
	Series      *Series `json:"series,omitempty"`
}

/*
 * An author.
 */
type Author struct {
	Id   int64  `json:"id,omitempty"`
	Name string `json:"name,omitempty"`
}

/*
 * Author and number of books.
 */
type AuthorAdv struct {
	Author
	Count int `json:"count,omitempty"`
}

/*
 * Downloadable book data.
 */
type BookData struct {
	Size   int64  `json:"size,omitempty"`
	Format string `json:"format,omitempty"`
	Name   string `json:"name,omitempty"`
}

/*
 * A book. Advanced data: authors, tags.
 */
type BookAdv struct {
	Book
	Authors []*Author `json:"authors,omitempty"`
	Tags    []string  `json:"tags,omitempty"`
}

type AuthorFull struct {
	Author
	Books     []*Book   `json:"books,omitempty"`
	Series    []*Series `json:"series,omitempty"`
	CoAuthors []*Author `json:"coauthors,omitempty"`
}

type BookFull struct {
	BookAdv
	Data      []*BookData `json:"data,omitempty"`
	Timestamp int64       `json:"timestamp,omitempty"`
	Pubdate   int64       `json:"pubdate,omitempty"`
	Isbn      string      `json:"isbn,omitempty"`
	Lccn      string      `json:"lccn,omitempty"`
	Path      string      `json:"path,omitempty"`
	Uuid      string      `json:"uuid,omitempty"`
	Has_cover bool        `json:"has_cover,omitempty"`
	Lang      string      `json:"lang,omitempty"`
	Publisher string      `json:"publisher,omitempty"`
}

type SeriesAdv struct {
	Series
	Count   int64     `json:"count,omitempty"`
	Authors []*Author `json:"authors,omitempty"`
}

type SeriesFull struct {
	SeriesAdv
	Books []*Book `json:"books,omitempty"`
}

type BouquinsModel struct {
	Title  string `json:"title,omitempty"`
	PageJs string `json:"-"`
}

// Constructor BouquinsModel
func NewBouquinsModel(title string) *BouquinsModel {
	return NewBouquinsModelJs(title, "")
}
func NewBouquinsModelJs(title, js string) *BouquinsModel {
	return &BouquinsModel{
		title,
		js,
	}
}

type IndexModel struct {
	BouquinsModel
	BooksCount int64 `json:"count"`
}

// Constructor IndexModel
func NewIndexModel(title, js string, count int64) *IndexModel {
	return &IndexModel{
		*NewBouquinsModelJs(title, js),
		count,
	}
}

type ResultsModel struct {
	Type string `json:"type,omitempty"`
}
type BooksResultsModel struct {
	ResultsModel
	Results []*BookAdv `json:"results,omitempty"`
}

func NewBooksResultsModel(books []*BookAdv) *BooksResultsModel {
	return &BooksResultsModel{ResultsModel{"books"}, books}
}

type AuthorsResultsModel struct {
	ResultsModel
	Results []*AuthorAdv `json:"results,omitempty"`
}

func NewAuthorsResultsModel(authors []*AuthorAdv) *AuthorsResultsModel {
	return &AuthorsResultsModel{ResultsModel{"authors"}, authors}
}

type SerieResultsModel struct {
	ResultsModel
	Results []*SeriesAdv `json:"results,omitempty"`
}

func NewSerieResultsModel(series []*SeriesAdv) *SerieResultsModel {
	return &SerieResultsModel{ResultsModel{"series"}, series}
}

type BookModel struct {
	BouquinsModel
	*BookFull
}

type SeriesModel struct {
	BouquinsModel
	*SeriesFull
}

type AuthorModel struct {
	BouquinsModel
	*AuthorFull
}

func (app *Bouquins) render(res http.ResponseWriter, tpl string, model interface{}) error {
	return app.Template.ExecuteTemplate(res, tpl, model)
}
func TemplatesFunc() *template.Template {
	tpl := template.New("")
	tpl.Funcs(template.FuncMap{
		"humanSize": func(sz int64) string {
			return datasize.ByteSize(sz).HumanReadable()
		},
		"bookCover": func(book *BookFull) string {
			fmt.Println(book.Path)
			return "/calibre/" + url.PathEscape(book.Path) + "/cover.jpg"
		},
		"bookLink": func(data *BookData, book *BookFull) string {
			return "/calibre/" + url.PathEscape(book.Path) + "/" + url.PathEscape(data.Name) + "." + strings.ToLower(data.Format)
		},
	})
	return tpl
}

func writeJson(res http.ResponseWriter, model interface{}) error {
	res.Header().Set("Content-Type", "application/json")
	enc := json.NewEncoder(res)
	return enc.Encode(model)
}
func isJson(req *http.Request) bool {
	return req.Header.Get("Accept") == "application/json"
}
func paramInt(name string, req *http.Request) int {
	val := req.URL.Query().Get(name)
	valInt, err := strconv.Atoi(val)
	if err != nil {
		log.Println("Invalid  value for", name, ":", val)
		return 0
	}
	return valInt
}
func paramOrder(req *http.Request) string {
	val := req.URL.Query().Get(PARAM_ORDER)
	if val == "desc" || val == "asc" {
		return val
	}
	return ""
}

// ROUTES //

func (app *Bouquins) IndexPage(res http.ResponseWriter, req *http.Request) {
	count, err := app.BookCount()
	if err != nil {
		log.Print(err)
	}
	model := NewIndexModel("", "index.js", count)
	/*
		order, sort := paramOrder(req), req.URL.Query().Get(PARAM_SORT)
		limit, offset := paramInt(PARAM_LIMIT, req), paramInt(PARAM_OFFSET, req)
			switch req.URL.Query().Get(PARAM_LIST) {
			case LIST_AUTHORS:
				model.Authors, err = app.AuthorsAdv(limit, offset, sort, order)
			case LIST_SERIES:
				model.Series, err = app.SeriesAdv(limit, offset, sort, order)
			case LIST_BOOKS:
				fallthrough
			default:
				model.Books, err = app.BooksAdv(limit, offset, sort, order)
			}
			if err != nil {
				log.Print(err)
			}
	*/
	if isJson(req) {
		err := writeJson(res, model)
		if err != nil {
			log.Println(err)
			http.Error(res, err.Error(), 500)
		}
	} else {
		app.render(res, TPL_INDEX, model)
	}
}
func (app *Bouquins) BooksListPage(res http.ResponseWriter, req *http.Request) error {
	if isJson(req) {
		books, err := app.BooksAdv(10, 0, "", "")
		if err != nil {
			return err
		}
		return writeJson(res, NewBooksResultsModel(books))
	}
	return errors.New("Invalid mime")
}
func (app *Bouquins) BookPage(idParam string, res http.ResponseWriter, req *http.Request) error {
	id, err := strconv.Atoi(idParam)
	if err != nil {
		return nil
	}
	book, err := app.BookFull(int64(id))
	if err != nil {
		return nil
	}
	return app.render(res, TPL_BOOKS, &BookModel{*NewBouquinsModel(book.Title), book})
}
func (app *Bouquins) BooksPage(res http.ResponseWriter, req *http.Request) {
	var err error
	var idParam = ""
	if strings.HasPrefix(req.URL.Path, URL_BOOKS) {
		idParam = req.URL.Path[len(URL_BOOKS):]
	} else {
		err = errors.New("Invalid URL") // FIXME 404
	}
	if len(idParam) == 0 {
		err = app.BooksListPage(res, req)
	} else {
		err = app.BookPage(idParam, res, req)
	}
	if err != nil {
		log.Println(err)
		http.Error(res, err.Error(), 500)
	}
}
func (app *Bouquins) AuthorsListPage(res http.ResponseWriter, req *http.Request) error {
	if isJson(req) {
		authors, err := app.AuthorsAdv(10, 0, "", "")
		if err != nil {
			return err
		}
		return writeJson(res, NewAuthorsResultsModel(authors))
	}
	return errors.New("Invalid mime")
}
func (app *Bouquins) AuthorPage(idParam string, res http.ResponseWriter, req *http.Request) error {
	id, err := strconv.Atoi(idParam)
	if err != nil {
		return err
	}
	author, err := app.AuthorFull(int64(id))
	if err != nil {
		return err
	}
	return app.render(res, TPL_AUTHORS, &AuthorModel{*NewBouquinsModelJs(author.Name, "author.js"), author})
}
func (app *Bouquins) AuthorsPage(res http.ResponseWriter, req *http.Request) {
	var err error
	var idParam = ""
	if strings.HasPrefix(req.URL.Path, URL_AUTHORS) {
		idParam = req.URL.Path[len(URL_AUTHORS):]
	} else {
		err = errors.New("Invalid URL") // FIXME 404
	}
	if len(idParam) == 0 {
		err = app.AuthorsListPage(res, req)
	} else {
		err = app.AuthorPage(idParam, res, req)
	}
	if err != nil {
		log.Println(err)
		http.Error(res, err.Error(), 500)
	}
}
func (app *Bouquins) SeriesPage(res http.ResponseWriter, req *http.Request) {
	if !strings.HasPrefix(req.URL.Path, URL_SERIES) {
		// FIXME 404
		log.Fatalln("Invalid URL")
	}
	id, err := strconv.Atoi(req.URL.Path[len(URL_SERIES):])
	if err != nil {
		// FIXME 404
		log.Fatalln(err)
	}
	series, err := app.SeriesFull(int64(id))
	if err != nil {
		// FIXME 500
		log.Fatalln(err)
	}
	app.render(res, TPL_SERIES, &SeriesModel{
		*NewBouquinsModel(series.Name),
		series,
	})
}