341 lines
6.8 KiB
Go
341 lines
6.8 KiB
Go
package entry
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"os/exec"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/jmoiron/sqlx"
|
|
"github.com/rs/zerolog/log"
|
|
|
|
"code.chrissexton.org/cws/cabinet/db"
|
|
)
|
|
|
|
type Entry struct {
|
|
db *db.Database
|
|
ID int64
|
|
Slug string
|
|
Title string
|
|
Content string
|
|
Tags []string
|
|
Created time.Time
|
|
Updated time.Time
|
|
AuthorID int64 `db:"author_id"`
|
|
}
|
|
|
|
func PrepareTable(tx *sqlx.Tx) error {
|
|
q := `create table if not exists entries (
|
|
id integer primary key,
|
|
slug text unique not null,
|
|
content text not null,
|
|
created datetime not null,
|
|
updated datetime not null,
|
|
author_id integer
|
|
)`
|
|
_, err := tx.Exec(q)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
q = `create table if not exists tags (
|
|
id integer primary key,
|
|
name text not null,
|
|
entry_id integer,
|
|
foreign key(entry_id) references entries(id),
|
|
constraint unique_name_id unique (name, entry_id)
|
|
)`
|
|
_, err = tx.Exec(q)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewFromAdoc(db *db.Database, body string) *Entry {
|
|
e := New(db)
|
|
e.Content = body
|
|
e.Title = e.GenerateTitle()
|
|
e.Slug = e.UniqueSlug()
|
|
return e
|
|
}
|
|
|
|
func pandocMdToAdoc(body string) string {
|
|
log.Debug().Str("input", body).Msgf("converting md->adoc")
|
|
cmd := exec.Command("pandoc", "-f", "commonmark", "-t", "asciidoctor")
|
|
stdin, err := cmd.StdinPipe()
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("could not get stdin")
|
|
}
|
|
|
|
go func() {
|
|
defer stdin.Close()
|
|
io.WriteString(stdin, body)
|
|
}()
|
|
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("could not get stdout")
|
|
}
|
|
|
|
log.Debug().Msgf("md->adoc: %s", out)
|
|
return string(out)
|
|
}
|
|
|
|
func NewFromMd(db *db.Database, body string) *Entry {
|
|
body = pandocMdToAdoc(body)
|
|
return NewFromAdoc(db, body)
|
|
}
|
|
|
|
func New(db *db.Database) *Entry {
|
|
e := Entry{
|
|
db: db,
|
|
ID: -1,
|
|
Created: time.Now(),
|
|
Updated: time.Now(),
|
|
Tags: []string{},
|
|
}
|
|
e.Title = e.GenerateTitle()
|
|
e.Slug = e.UniqueSlug()
|
|
e.Content = "= " + e.Title
|
|
return &e
|
|
}
|
|
|
|
func GetBySlug(db *db.Database, slug string) (Entry, error) {
|
|
e := Entry{db: db}
|
|
q := `select * from entries where slug = ?`
|
|
if err := db.Get(&e, q, slug); err != nil {
|
|
return e, err
|
|
}
|
|
e.Title = e.GenerateTitle()
|
|
return e, e.populateTags()
|
|
}
|
|
|
|
func GetByID(db *db.Database, id int64) (Entry, error) {
|
|
e := Entry{db: db}
|
|
q := `select * from entries where id = ?`
|
|
if err := db.Get(&e, q, id); err != nil {
|
|
return e, err
|
|
}
|
|
e.Title = e.GenerateTitle()
|
|
return e, e.populateTags()
|
|
}
|
|
|
|
func SearchByTag(db *db.Database, query string, tags []string) ([]*Entry, error) {
|
|
entries := []*Entry{}
|
|
query = fmt.Sprintf("%%%s%%", query)
|
|
log.Debug().Str("tag query", query).Int("len(tags)", len(tags)).Msg("searching")
|
|
|
|
if len(tags) > 0 {
|
|
q := `select e.*
|
|
from entries e
|
|
inner join tags t
|
|
on e.id=t.entry_id
|
|
where
|
|
t.name in (?)
|
|
AND content like ?
|
|
order by updated desc`
|
|
|
|
q, args, err := sqlx.In(q, tags, query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = db.Select(&entries, q, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
q := `select e.*
|
|
from entries e
|
|
where
|
|
content like ?
|
|
order by updated desc`
|
|
|
|
err := db.Select(&entries, q, query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
for _, e := range entries {
|
|
e.db = db
|
|
e.Title = e.GenerateTitle()
|
|
e.populateTags()
|
|
}
|
|
|
|
return entries, nil
|
|
}
|
|
|
|
func RemoveBySlug(db *db.Database, slug string) error {
|
|
tx, err := db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
e, err := GetBySlug(db, slug)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
q := `delete from tags where entry_id = ?`
|
|
if _, err := tx.Exec(q, e.ID); err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
q = `delete from entries where id = ?`
|
|
if _, err := tx.Exec(q, e.ID); err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (e *Entry) populateTags() error {
|
|
q := `select name from tags where entry_id = ?`
|
|
err := e.db.Select(&e.Tags, q, e.ID)
|
|
log.Debug().Interface("entry", e).Msg("populating tags")
|
|
return err
|
|
}
|
|
|
|
func (e *Entry) addTag(tag string) error {
|
|
q := `insert into tags (name,entry_id) values (?,?)`
|
|
_, err := e.db.Exec(q, tag, e.ID)
|
|
return err
|
|
}
|
|
|
|
func (e *Entry) removeTag(tag string) error {
|
|
q := `delete from tags where name=? and entry_id=?`
|
|
_, err := e.db.Exec(q, tag, e.ID)
|
|
return err
|
|
}
|
|
|
|
func (e *Entry) GenerateTitle() string {
|
|
candidate := strings.Split(e.Content, "\n")[0]
|
|
candidateNumber := 0
|
|
|
|
r := regexp.MustCompile(`[^a-zA-Z0-9 -]`)
|
|
candidate = r.ReplaceAllString(candidate, "")
|
|
candidate = strings.TrimSpace(candidate)
|
|
if len(candidate) == 0 {
|
|
candidate = "untitled"
|
|
}
|
|
|
|
q := `select slug from entries where slug like ?`
|
|
slugs := []string{}
|
|
if err := e.db.Select(&slugs, q, candidate+"%"); err != nil {
|
|
log.Debug().Err(err).Msgf("Could not get candidate slugs: %s", err)
|
|
return candidate
|
|
}
|
|
|
|
contains := func(s string, ss []string) bool {
|
|
for _, e := range ss {
|
|
if s == e {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
tmpCandidate := candidate
|
|
for contains(tmpCandidate, slugs) {
|
|
candidateNumber++
|
|
tmpCandidate = fmt.Sprintf("%s-%d", candidate, candidateNumber)
|
|
}
|
|
|
|
return tmpCandidate
|
|
}
|
|
|
|
func (e *Entry) UniqueSlug() string {
|
|
if e.Title == "" {
|
|
e.Title = e.GenerateTitle()
|
|
}
|
|
candidate := e.Title
|
|
|
|
r := regexp.MustCompile(`[^a-zA-Z0-9 -]`)
|
|
candidate = r.ReplaceAllString(candidate, "")
|
|
candidate = strings.TrimSpace(candidate)
|
|
candidate = strings.ReplaceAll(candidate, " ", "-")
|
|
candidate = strings.ToLower(candidate)
|
|
return candidate
|
|
}
|
|
|
|
func (e *Entry) Update() error {
|
|
if e.ID == -1 {
|
|
return e.Create()
|
|
}
|
|
old, err := GetByID(e.db, e.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
e.Slug = e.UniqueSlug()
|
|
|
|
q := `update entries set slug=?, content=?, updated=?, author_id=? where id=?`
|
|
if _, err = e.db.Exec(q, e.Slug, e.Content, e.Updated.Unix(), e.AuthorID, e.ID); err != nil {
|
|
return err
|
|
}
|
|
for _, t := range e.Tags {
|
|
if !contains(old.Tags, t) {
|
|
e.addTag(t)
|
|
}
|
|
}
|
|
for _, t := range old.Tags {
|
|
if !contains(e.Tags, t) {
|
|
e.removeTag(t)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func contains(items []string, entry string) bool {
|
|
for _, e := range items {
|
|
if e == entry {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (e *Entry) Create() error {
|
|
if e.ID != -1 {
|
|
return e.Update()
|
|
}
|
|
tx, err := e.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
q := `insert into entries (slug,content,created,updated,author_id)
|
|
values (?,?,?,?,?)`
|
|
res, err := tx.Exec(q, e.Slug, e.Content, e.Created.Unix(), e.Updated.Unix(), e.AuthorID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
e.ID, err = res.LastInsertId()
|
|
if err != nil {
|
|
tx.Rollback()
|
|
e.ID = -1
|
|
return err
|
|
}
|
|
for _, t := range e.Tags {
|
|
q = `insert into tags (name,entry_id) values (?,?)`
|
|
_, err = tx.Exec(q, t, e.ID)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
}
|
|
tx.Commit()
|
|
return nil
|
|
}
|
|
|
|
func (e *Entry) HasTag(tag string) bool {
|
|
for _, t := range e.Tags {
|
|
if strings.ToLower(tag) == strings.ToLower(t) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|