go-bouquins/bouquins/bouquins.go
2017-09-08 20:29:01 +02:00

468 lines
12 KiB
Go

package bouquins
import (
"database/sql"
"encoding/json"
"errors"
"fmt"
"html/template"
"log"
"net/http"
"net/url"
"strconv"
"strings"
"golang.org/x/oauth2"
"github.com/c2h5oh/datasize"
"github.com/gorilla/sessions"
)
const (
Version = "master"
tplBooks = "book.html"
tplAuthors = "author.html"
tplSeries = "series.html"
tplIndex = "index.html"
tplSearch = "search.html"
tplAbout = "about.html"
tplProvider = "provider.html"
pList = "list"
pOrder = "order"
pSort = "sort"
pPage = "page"
pPerPage = "perpage"
pTerm = "term"
// URLIndex url of index page
URLIndex = "/"
// URLLogin url of login page (OAuth 2)
URLLogin = "/login"
// URLLogout url of logout page
URLLogout = "/logout"
// URLCallback url of OAuth callback
URLCallback = "/callback"
// URLBooks url of books page
URLBooks = "/books/"
// URLAuthors url of authors page
URLAuthors = "/authors/"
// URLSeries url of series page
URLSeries = "/series/"
// URLSearch url of search page
URLSearch = "/search/"
// URLAbout url of about page
URLAbout = "/about/"
// URLJs url of js assets
URLJs = "/" + Version + "/js/"
// URLCss url of css assets
URLCss = "/" + Version + "/css/"
// URLFonts url of fonts assets
URLFonts = "/" + Version + "/fonts/"
// URLCalibre url of calibre resources (covers, ebooks files)
URLCalibre = "/calibre/"
)
type GitHubEmail struct {
Email string `json:"email"`
Primary bool `json:"primary"`
Verified bool `json:"verified"`
Visibility string `json:"visibility"`
}
// Bouquins contains application common resources: templates, database
type Bouquins struct {
Tpl *template.Template
DB *sql.DB
OAuthConf map[string]*oauth2.Config
Cookies *sessions.CookieStore
}
// Series is a book series.
type Series struct {
ID int64 `json:"id,omitempty"`
Name string `json:"name,omitempty"`
}
// Book contains basic data on book
type Book struct {
ID int64 `json:"id,omitempty"`
Title string `json:"title,omitempty"`
SeriesIndex float64 `json:"series_idx,omitempty"`
Series *Series `json:"series,omitempty"`
}
// Author contains basic data on author
type Author struct {
ID int64 `json:"id,omitempty"`
Name string `json:"name,omitempty"`
}
// AuthorAdv extends Author with number of books
type AuthorAdv struct {
Author
Count int `json:"count,omitempty"`
}
// BookData contains data for dowloadable book
type BookData struct {
Size int64 `json:"size,omitempty"`
Format string `json:"format,omitempty"`
Name string `json:"name,omitempty"`
}
// BookAdv extends Book with authors and tags
type BookAdv struct {
Book
Authors []*Author `json:"authors,omitempty"`
Tags []string `json:"tags,omitempty"`
}
// AuthorFull extends Author with books, series and co-authors
type AuthorFull struct {
Author
Books []*Book `json:"books,omitempty"`
Series []*Series `json:"series,omitempty"`
CoAuthors []*Author `json:"coauthors,omitempty"`
}
// BookFull extends BookAdv with all available data
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"`
HasCover bool `json:"has_cover,omitempty"`
Lang string `json:"lang,omitempty"`
Publisher string `json:"publisher,omitempty"`
}
// SeriesAdv extends Series with count of books and authors
type SeriesAdv struct {
Series
Count int64 `json:"count,omitempty"`
Authors []*Author `json:"authors,omitempty"`
}
// SeriesFull extends SeriesAdv with related books
type SeriesFull struct {
SeriesAdv
Books []*Book `json:"books,omitempty"`
}
// Model is basic page model
type Model struct {
Title string
Page string
Version string
Username string
}
// NewModel constuctor for Model
func (app *Bouquins) NewModel(title, page string, req *http.Request) *Model {
return &Model{
Title: title,
Page: page,
Version: Version,
Username: app.Username(req),
}
}
// IndexModel is the model for index page
type IndexModel struct {
Model
BooksCount int64 `json:"count"`
}
// NewIndexModel constructor IndexModel
func (app *Bouquins) NewIndexModel(title string, count int64, req *http.Request) *IndexModel {
return &IndexModel{*app.NewModel(title, "index", req), count}
}
// NewSearchModel constuctor for search page
func (app *Bouquins) NewSearchModel(req *http.Request) *Model {
return app.NewModel("Recherche", "search", req)
}
// ResultsModel is a generic model for list pages
type ResultsModel struct {
Type string `json:"type,omitempty"`
More bool `json:"more"`
CountResults int `json:"count,omitempty"`
}
// BooksResultsModel is the model for list of books
type BooksResultsModel struct {
ResultsModel
Results []*BookAdv `json:"results,omitempty"`
}
// NewBooksResultsModel constuctor for BooksResultsModel
func NewBooksResultsModel(books []*BookAdv, more bool, count int) *BooksResultsModel {
return &BooksResultsModel{ResultsModel{"books", more, count}, books}
}
// AuthorsResultsModel is the model for list of authors
type AuthorsResultsModel struct {
ResultsModel
Results []*AuthorAdv `json:"results,omitempty"`
}
// NewAuthorsResultsModel constuctor for AuthorsResultsModel
func NewAuthorsResultsModel(authors []*AuthorAdv, more bool, count int) *AuthorsResultsModel {
return &AuthorsResultsModel{ResultsModel{"authors", more, count}, authors}
}
// SeriesResultsModel is the model for list of series
type SeriesResultsModel struct {
ResultsModel
Results []*SeriesAdv `json:"results,omitempty"`
}
// NewSeriesResultsModel constuctor for SeriesResultsModel
func NewSeriesResultsModel(series []*SeriesAdv, more bool, count int) *SeriesResultsModel {
return &SeriesResultsModel{ResultsModel{"series", more, count}, series}
}
// BookModel is the model for single book page
type BookModel struct {
Model
*BookFull
}
// SeriesModel is the model for single series page
type SeriesModel struct {
Model
*SeriesFull
}
// AuthorModel is the model for single author page
type AuthorModel struct {
Model
*AuthorFull
}
// ReqParams contains request parameters for searches and lists
type ReqParams struct {
Limit int
Offset int
Sort string
Order string
Terms []string
AllWords bool
}
// TemplatesFunc adds functions to templates
func TemplatesFunc(prod bool) *template.Template {
return template.New("").Funcs(template.FuncMap{
"assetUrl": func(name string, ext string) string {
sep := "."
if prod {
sep = ".min."
}
return "/" + Version + "/" + ext + "/" + name + sep + ext
},
"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)
},
})
}
// RedirectHome redirects to home page
func RedirectHome(res http.ResponseWriter, req *http.Request) error {
http.Redirect(res, req, "/", http.StatusTemporaryRedirect)
return nil
}
// output page with template
func (app *Bouquins) render(res http.ResponseWriter, tpl string, model interface{}) error {
return app.Tpl.ExecuteTemplate(res, tpl, model)
}
// output as JSON
func writeJSON(res http.ResponseWriter, model interface{}) error {
res.Header().Set("Content-Type", "application/json")
enc := json.NewEncoder(res)
return enc.Encode(model)
}
// test if JSON requested
func isJSON(req *http.Request) bool {
return req.Header.Get("Accept") == "application/json"
}
// get integer parameter
func paramInt(name string, req *http.Request) int {
val := req.URL.Query().Get(name)
if val == "" {
return 0
}
valInt, err := strconv.Atoi(val)
if err != nil {
log.Println("Invalid value for", name, ":", val)
return 0
}
return valInt
}
// get order parameter
func paramOrder(req *http.Request) string {
val := req.URL.Query().Get(pOrder)
if val == "desc" || val == "asc" {
return val
}
return ""
}
// get common request parameters
func params(req *http.Request) *ReqParams {
page, perpage := paramInt(pPage, req), paramInt(pPerPage, req)
limit := perpage
if perpage == 0 {
limit = defaultLimit
}
offset := perpage * (page - 1)
if offset < 0 {
offset = 0
}
sort := req.URL.Query().Get(pSort)
order := paramOrder(req)
terms := req.URL.Query()[pTerm]
return &ReqParams{limit, offset, sort, order, terms, false}
}
// single element or list elements page
func listOrID(res http.ResponseWriter, req *http.Request, url string,
listFunc func(res http.ResponseWriter, req *http.Request) error,
idFunc func(idParam string, res http.ResponseWriter, req *http.Request) error) error {
if !strings.HasPrefix(req.URL.Path, url) {
return errors.New("Invalid URL") // FIXME 404
}
idParam := req.URL.Path[len(url):]
if len(idParam) == 0 {
return listFunc(res, req)
}
return idFunc(idParam, res, req)
}
// LIST ELEMENTS PAGES //
func (app *Bouquins) booksListPage(res http.ResponseWriter, req *http.Request) error {
if isJSON(req) {
books, count, more, err := app.BooksAdv(params(req))
if err != nil {
return err
}
return writeJSON(res, NewBooksResultsModel(books, more, count))
}
return errors.New("Invalid mime")
}
func (app *Bouquins) authorsListPage(res http.ResponseWriter, req *http.Request) error {
if isJSON(req) {
authors, count, more, err := app.AuthorsAdv(params(req))
if err != nil {
return err
}
return writeJSON(res, NewAuthorsResultsModel(authors, more, count))
}
return errors.New("Invalid mime")
}
func (app *Bouquins) seriesListPage(res http.ResponseWriter, req *http.Request) error {
if isJSON(req) {
series, count, more, err := app.SeriesAdv(params(req))
if err != nil {
return err
}
return writeJSON(res, NewSeriesResultsModel(series, more, count))
}
return errors.New("Invalid mime")
}
// SINGLE ELEMENT PAGES //
func (app *Bouquins) bookPage(idParam string, res http.ResponseWriter, req *http.Request) error {
id, err := strconv.Atoi(idParam)
if err != nil {
return err
}
book, err := app.BookFull(int64(id))
if err != nil {
return err
}
return app.render(res, tplBooks, &BookModel{*app.NewModel(book.Title, "book", req), book})
}
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, tplAuthors, &AuthorModel{*app.NewModel(author.Name, "author", req), author})
}
func (app *Bouquins) seriePage(idParam string, res http.ResponseWriter, req *http.Request) error {
id, err := strconv.Atoi(idParam)
if err != nil {
return err
}
series, err := app.SeriesFull(int64(id))
if err != nil {
return err
}
return app.render(res, tplSeries, &SeriesModel{*app.NewModel(series.Name, "series", req), series})
}
// ROUTES //
// BooksPage displays a single books or a returns a list of books
func (app *Bouquins) BooksPage(res http.ResponseWriter, req *http.Request) error {
return listOrID(res, req, URLBooks, app.booksListPage, app.bookPage)
}
// AuthorsPage displays a single author or returns a list of authors
func (app *Bouquins) AuthorsPage(res http.ResponseWriter, req *http.Request) error {
return listOrID(res, req, URLAuthors, app.authorsListPage, app.authorPage)
}
// SeriesPage displays a single series or returns a list of series
func (app *Bouquins) SeriesPage(res http.ResponseWriter, req *http.Request) error {
return listOrID(res, req, URLSeries, app.seriesListPage, app.seriePage)
}
// SearchPage displays search form and results
func (app *Bouquins) SearchPage(res http.ResponseWriter, req *http.Request) error {
return app.render(res, tplSearch, app.NewSearchModel(req))
}
// AboutPage displays about page
func (app *Bouquins) AboutPage(res http.ResponseWriter, req *http.Request) error {
return app.render(res, tplAbout, app.NewModel("A propos", "about", req))
}
// IndexPage displays index page: list of books/authors/series
func (app *Bouquins) IndexPage(res http.ResponseWriter, req *http.Request) error {
count, err := app.BookCount()
if err != nil {
return err
}
model := app.NewIndexModel("", count, req)
if isJSON(req) {
return writeJSON(res, model)
}
return app.render(res, tplIndex, model)
}