gowiki/pkg/db/page.go

// Copyright (C) 2019 Marius Schellenberger

package db

import (
	"errors"
	"git.giftfish.de/ston1th/gowiki/pkg/core"
	"git.giftfish.de/ston1th/gowiki/pkg/render"
	"git.giftfish.de/ston1th/gowiki/pkg/store"
	"sort"
	"strings"
)

const pagePrefix = "page/"

var (
	errPageNotFound       = store.ErrKeyNotFound
	errPermissionDenied   = errors.New("db: permission denied")
	errInvalidPermission  = errors.New("db: invalid permission")
	errPrivateWikiPage    = errors.New("db: private wiki pages are not allowed")
	errNonPublicIndexPage = errors.New("db: internal/private index page is not allowed")
	errDeleteIndexPage    = errors.New("db: index page can not be deleted")
)

func (db *DB) GetAllSections(username string) (sections core.Sections) {
	m := make(map[string]core.UpdatedPages)
	db.store.ForEach(func(k string, _ []byte) error {
		if trim, ok := hasTrimPrefix(k, pagePrefix); ok {
			if trim == core.IndexURI {
				return nil
			}
			p, err := db.getPage(trim, username)
			if err == nil {
				s := trim[:strings.Index(trim, "/")]
				if _, ok := m[s]; !ok {
					m[s] = core.UpdatedPages{}
				}
				m[s] = append(m[s], *p)
			}
		}
		return nil
	})
	for s, p := range m {
		sort.Sort(p)
		l := len(p)
		if l > 5 {
			l = 5
		}
		sections = append(sections, core.Section{s, p[:l]})
	}
	sort.Sort(sections)
	return
}

func (db *DB) GetAllSectionPages(section, username string) (pages core.Pages, err error) {
	db.store.ForEach(func(k string, _ []byte) error {
		if trim, ok := hasTrimPrefix(k, pagePrefix); ok {
			if !strings.HasPrefix(trim, section+"/") {
				return nil
			}
			if trim == core.IndexURI {
				return nil
			}
			p, err := db.getPage(trim, username)
			if err == nil {
				pages = append(pages, *p)
			}
		}
		return nil
	})
	if len(pages) == 0 {
		err = errPageNotFound
		return
	}
	sort.Sort(pages)
	return
}

func (db *DB) ValidatePage(st, username string) bool {
	p := db.cache.Get(st)
	if p == nil {
		p, err := db.getPage(st, username)
		if err != nil {
			return false
		}
		db.cache.Add(st, p)
		return true
	}
	return core.ReadPerm(username, p)
}

func (db *DB) GetPage(section, title, username string) (p *core.Page, err error) {
	st := render.StoreTitle(section, title)
	p = db.cache.Get(st)
	if p == nil {
		p, err = db.getPage(st, username)
		db.cache.Add(st, p)
		return
	}
	if !core.ReadPerm(username, p) {
		err = errPageNotFound
	}
	return
}

func (db *DB) getPage(title, username string) (p *core.Page, err error) {
	p = new(core.Page)
	err = db.store.Get(pagePrefix+title, p)
	if err != nil {
		return
	}
	if !core.ReadPerm(username, p) {
		err = errPageNotFound
	}
	return
}

func (db *DB) CreatePage(title, section, markdown, username string, p core.Permission) (page *core.Page, err error) {
	if p == core.Invalid {
		err = errInvalidPermission
		return
	}
	owner := username
	if section == core.WikiSection {
		owner = core.WikiSection
		if p == core.Private {
			err = errPrivateWikiPage
			return
		}
	}
	st := render.StoreTitle(section, render.Title(title))
	_, err = db.getPage(st, username)
	if err != store.ErrKeyNotFound {
		return
	}

	page = &core.Page{
		Title:      title,
		StoreTitle: st,
		Markdown:   markdown,
		Created:    created(username),
		Owner:      owner,
		Perm:       p,
	}
	search := render.Render(page)

	err = db.store.Set(pagePrefix+st, page)
	if err != nil {
		return
	}

	err = db.Index.Add(title, st, search)
	if err != nil {
		return
	}
	db.cache.Add(st, page)
	return
}

func (db *DB) UpdatePage(title, section, markdown, username string, p core.Permission) (err error) {
	if p == core.Invalid {
		err = errInvalidPermission
		return
	}
	if section == core.WikiSection && p == core.Private {
		err = errPrivateWikiPage
		return
	}
	if section == core.WikiSection && title == core.IndexPage &&
		(p == core.Internal || p == core.Private) {
		err = errNonPublicIndexPage
		return
	}
	st := render.StoreTitle(section, title)
	page, err := db.getPage(st, username)
	if err != nil {
		return
	}
	if !core.WritePerm(username, section, page) {
		return errPermissionDenied
	}

	page.Markdown = markdown
	page.Updated = created(username)
	page.Perm = p
	search := render.Render(page)

	err = db.store.Set(pagePrefix+st, page)
	if err != nil {
		return
	}

	err = db.Index.Add(page.Title, st, search)
	if err != nil {
		return
	}
	db.cache.Add(st, page)
	return
}

func (db *DB) deletePage(st string) (err error) {
	if err = db.store.Delete(pagePrefix + st); err != nil {
		return
	}
	db.cache.Delete(st)
	return db.Index.Delete(st)
}

func (db *DB) DeletePage(title, section, username string) (err error) {
	var page *core.Page
	if section == core.WikiSection && title == core.IndexPage {
		err = errDeleteIndexPage
		return
	}
	st := render.StoreTitle(section, title)
	if page, err = db.getPage(st, username); err != nil {
		return
	}
	if !core.WritePerm(username, section, page) {
		return errPermissionDenied
	}
	return db.deletePage(st)
}