|
|
package model
import ( "errors" "fmt" "strings"
"git.aiterp.net/AiteRP/aitestory/server" "git.aiterp.net/gisle/wrouter/generate" )
// TagTypes are the allowed values for Tag.Type
var TagTypes = []string{ "Location", "Character", "Event", "Organization", "Series", }
// TagTitles are the titles to use when listing tags
var TagTitles = map[string]string{ "Location": "Locations", "Character": "Characters", "Event": "Plots & Events", "Organization": "Organizations", "Series": "Series", }
// Tag describes a tag
type Tag struct { ID string Type string Name string }
// Icon is the API used to get the icon for the tag.
func (tag Tag) Icon() string { return tag.Type[0:1] }
// CSSCLass gets the CSS class that colors the tag on the
// page list
func (tag Tag) CSSCLass() string { return fmt.Sprintf("ttype-%s", strings.ToLower(tag.Type)) }
// Insert adds the tag to the database, giving it a new unique ID
func (tag *Tag) Insert() error { db := server.Main.DB
// Validate tag type
if err := tag.Validate(); err != nil { return err }
// Generate an ID if none exists
if tag.ID == "" { tag.ID = generate.ID() }
// Do the thing
_, err := db.Exec("INSERT INTO `tag` (id,type,name,disabled) VALUES (?,?,?,false)", tag.ID, tag.Type, tag.Name) if err != nil { return err }
return nil }
// Update saves the entry for the tag in the database
func (tag *Tag) Update() error { db := server.Main.DB
// Validate tag type
if err := tag.Validate(); err != nil { return err }
// Do the thing
_, err := db.Exec("UPDATE `tag` SET type=?,name=? WHERE id=?", tag.Type, tag.Name, tag.ID) if err != nil { return err }
return nil }
// Delete removes a tag from the database
func (tag *Tag) Delete() error { db := server.Main.DB
// Do the thing
results, err := db.Exec("DELETE FROM `tag` WHERE id=? LIMIT 1", tag.ID) if err != nil { return err }
// Count the stuffs that were done things to
affected, err := results.RowsAffected() if err != nil { return err } if affected == 0 { return errors.New("tag not found") }
return nil }
// Validate checks the name and type, and returns an error if they're not valid. It's
// ran by Update and Insert before doing anything
func (tag *Tag) Validate() error { validType := false for _, tagType := range TagTypes { if tagType == tag.Type { validType = true break } } if !validType { return errors.New("invalid tag type") }
// Validate tag name
if len(tag.Name) == 0 || len(tag.Name) > 64 { return errors.New("invalid length") }
return nil }
// Path returns a path used for the tag's list page
func (tag Tag) Path() string { return fmt.Sprintf("/%s/%s", strings.ToLower(tag.Type), strings.Replace(tag.Name, " ", "_", -1)) }
// CSSClass gets the tag's css class, which determines its color.
func (tag Tag) CSSClass() string { return fmt.Sprintf("ttype-%s", strings.ToLower(tag.Type)) }
// FindTag finds a tag by ID. Leave tagtype blank to ignore it. Both key and
// id are checked against their respective lists to prevent SQL injection attacks.
func FindTag(key string, id string, tagType string) (*Tag, error) { db := server.Main.DB
// Make damn sure that – should this take user data as key – it
// does not open up for a SQL injection attack
if key != "name" && key != "id" { return nil, errors.New("invalid key") }
query := "SELECT id,type,name FROM `tag` WHERE " + key + "=? AND disabled=false" if tagType != "" { // Prevent more shenanigans
found := false for _, existing := range TagTypes { if existing == tagType { found = true break } } if !found { return nil, errors.New("invalid tag type") }
query += fmt.Sprintf(` AND type="%s"`, tagType) }
rows, err := db.Query(query, id) if err != nil { return nil, err } defer rows.Close() if !rows.Next() { return nil, errors.New("not found") }
tag := new(Tag) rows.Scan(&tag.ID, &tag.Type, &tag.Name) return tag, nil }
// EnsureTag finds or creates a tag.
func EnsureTag(tagType, tagName string) (*Tag, error) { // Try to find it first
tag, err := FindTag("name", tagName, tagType) if err != nil && err.Error() != "not found" { // You saw nothing
return nil, err }
// Failing that, make it
if tag == nil { tag = new(Tag) tag.Type = tagType tag.Name = tagName err = tag.Insert() if err != nil { return nil, err } }
return tag, nil }
// ListTags finds all the tags, without filter.
func ListTags() ([]Tag, error) { db := server.Main.DB
query := ` SELECT id,type,name,count(pt.page_id) FROM tag LEFT JOIN page_tag AS pt ON (pt.tag_id = tag.id) WHERE disabled=false GROUP BY pt.tag_id ORDER BY type,name `
rows, err := db.Query(query) if err != nil { return nil, err } defer rows.Close()
results := make([]Tag, 0, 64) for rows.Next() { count := 0 tag := Tag{} rows.Scan(&tag.ID, &tag.Type, &tag.Name, &count)
// Let's pretend unused tags don't exist. >_>
if count > 0 { results = append(results, tag) } }
return results, nil }
|