264 lines
7.2 KiB
Go
264 lines
7.2 KiB
Go
package legal
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
|
|
"github.com/jackc/pgx/v4"
|
|
|
|
"dev.tandem.ws/tandem/camper/pkg/auth"
|
|
"dev.tandem.ws/tandem/camper/pkg/database"
|
|
"dev.tandem.ws/tandem/camper/pkg/form"
|
|
httplib "dev.tandem.ws/tandem/camper/pkg/http"
|
|
"dev.tandem.ws/tandem/camper/pkg/locale"
|
|
"dev.tandem.ws/tandem/camper/pkg/template"
|
|
)
|
|
|
|
type AdminHandler struct {
|
|
}
|
|
|
|
func NewAdminHandler() *AdminHandler {
|
|
return &AdminHandler{}
|
|
}
|
|
|
|
func (h *AdminHandler) Handler(user *auth.User, company *auth.Company, conn *database.Conn) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var head string
|
|
head, r.URL.Path = httplib.ShiftPath(r.URL.Path)
|
|
|
|
switch head {
|
|
case "":
|
|
switch r.Method {
|
|
case http.MethodGet:
|
|
serveLegalIndex(w, r, user, company, conn)
|
|
case http.MethodPost:
|
|
addLegal(w, r, user, company, conn)
|
|
default:
|
|
httplib.MethodNotAllowed(w, r, http.MethodGet, http.MethodPost)
|
|
}
|
|
case "new":
|
|
switch r.Method {
|
|
case http.MethodGet:
|
|
f := newLegalForm(company)
|
|
f.MustRender(w, r, user, company)
|
|
default:
|
|
httplib.MethodNotAllowed(w, r, http.MethodGet)
|
|
}
|
|
default:
|
|
f := newLegalForm(company)
|
|
if err := f.FillFromDatabase(r.Context(), conn, head); err != nil {
|
|
if database.ErrorIsNotFound(err) {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
panic(err)
|
|
}
|
|
h.legalHandler(user, company, conn, f).ServeHTTP(w, r)
|
|
}
|
|
})
|
|
}
|
|
|
|
func (h *AdminHandler) legalHandler(user *auth.User, company *auth.Company, conn *database.Conn, f *legalForm) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var head string
|
|
head, r.URL.Path = httplib.ShiftPath(r.URL.Path)
|
|
|
|
switch head {
|
|
case "":
|
|
switch r.Method {
|
|
case http.MethodGet:
|
|
f.MustRender(w, r, user, company)
|
|
case http.MethodPut:
|
|
editLegal(w, r, user, company, conn, f)
|
|
default:
|
|
httplib.MethodNotAllowed(w, r, http.MethodGet, http.MethodPut)
|
|
}
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
})
|
|
}
|
|
|
|
func serveLegalIndex(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn) {
|
|
legals, err := collectLegalEntries(r.Context(), conn, company)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
page := &legalIndex{
|
|
Texts: legals,
|
|
}
|
|
page.MustRender(w, r, user, company)
|
|
}
|
|
|
|
func collectLegalEntries(ctx context.Context, conn *database.Conn, company *auth.Company) ([]*legalEntry, error) {
|
|
rows, err := conn.Query(ctx, `
|
|
select '/admin/legal/' || slug
|
|
, name
|
|
from legal_text
|
|
where company_id = $1
|
|
order by name
|
|
`, company.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var legals []*legalEntry
|
|
for rows.Next() {
|
|
legal := &legalEntry{}
|
|
if err = rows.Scan(&legal.URL, &legal.Name); err != nil {
|
|
return nil, err
|
|
}
|
|
legals = append(legals, legal)
|
|
}
|
|
|
|
return legals, nil
|
|
}
|
|
|
|
type legalEntry struct {
|
|
URL string
|
|
Name string
|
|
}
|
|
|
|
type legalIndex struct {
|
|
Texts []*legalEntry
|
|
}
|
|
|
|
func (page *legalIndex) MustRender(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company) {
|
|
template.MustRenderAdmin(w, r, user, company, "legal/index.gohtml", page)
|
|
}
|
|
|
|
func addLegal(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn) {
|
|
f := newLegalForm(company)
|
|
processLegalForm(w, r, user, company, conn, f, func(ctx context.Context, tx *database.Tx) error {
|
|
_, err := tx.Exec(ctx, `
|
|
insert into legal_text (company_id, slug, name, content)
|
|
values ($1, $2, $3, xmlparse(content $4))
|
|
`, company.ID, f.Slug.Val, f.Name[company.DefaultLanguage.String()].Val, f.Content[company.DefaultLanguage.String()])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for lang := range company.Locales {
|
|
if err := tx.TranslateLegalText(ctx, company.ID, f.Slug.Val, lang, f.Name[lang.String()].Val, f.Content[lang.String()].Val); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func editLegal(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, f *legalForm) {
|
|
processLegalForm(w, r, user, company, conn, f, func(ctx context.Context, tx *database.Tx) error {
|
|
_, err := tx.Exec(ctx, `
|
|
update legal_text
|
|
set name = $3
|
|
, content = xmlparse(content $4)
|
|
where company_id = $1
|
|
and slug = $2
|
|
`, company.ID, f.Slug.Val, f.Name[company.DefaultLanguage.String()].Val, f.Content[company.DefaultLanguage.String()])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for lang := range company.Locales {
|
|
if err := tx.TranslateLegalText(ctx, company.ID, f.Slug.Val, lang, f.Name[lang.String()].Val, f.Content[lang.String()].Val); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func processLegalForm(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, f *legalForm, act func(ctx context.Context, tx *database.Tx) error) {
|
|
if ok, err := form.Handle(f, w, r, user); err != nil {
|
|
return
|
|
} else if !ok {
|
|
f.MustRender(w, r, user, company)
|
|
return
|
|
}
|
|
|
|
tx := conn.MustBegin(r.Context())
|
|
if err := act(r.Context(), tx); err == nil {
|
|
if err := tx.Commit(r.Context()); err != nil {
|
|
panic(err)
|
|
}
|
|
} else {
|
|
if err := tx.Rollback(r.Context()); err != nil {
|
|
panic(err)
|
|
}
|
|
panic(err)
|
|
}
|
|
httplib.Redirect(w, r, "/admin/legal/"+f.Slug.Val, http.StatusSeeOther)
|
|
}
|
|
|
|
type legalForm struct {
|
|
company *auth.Company
|
|
URL string
|
|
Slug *form.Input
|
|
Name form.I18nInput
|
|
Content form.I18nInput
|
|
}
|
|
|
|
func newLegalForm(company *auth.Company) *legalForm {
|
|
f := &legalForm{
|
|
company: company,
|
|
Slug: &form.Input{
|
|
Name: "slug",
|
|
},
|
|
Name: form.NewI18nInput(company.Locales, "name"),
|
|
Content: form.NewI18nInput(company.Locales, "content"),
|
|
}
|
|
return f
|
|
}
|
|
|
|
func (f *legalForm) FillFromDatabase(ctx context.Context, conn *database.Conn, slug string) error {
|
|
var name database.RecordArray
|
|
var content database.RecordArray
|
|
row := conn.QueryRow(ctx, `
|
|
select '/admin/legal/' || text.slug
|
|
, text.slug
|
|
, text.name
|
|
, text.content::text
|
|
, array_agg((lang_tag, i18n.name))
|
|
, array_agg((lang_tag, i18n.content::text))
|
|
from legal_text as text
|
|
left join legal_text_i18n as i18n using (company_id, slug)
|
|
where text.company_id = $1
|
|
and text.slug = $2
|
|
group by text.slug
|
|
, text.name
|
|
, text.content::text
|
|
`, pgx.QueryResultFormats{pgx.BinaryFormatCode}, f.company.ID, slug)
|
|
if err := row.Scan(&f.URL, &f.Slug.Val, &f.Name[f.company.DefaultLanguage.String()].Val, &f.Content[f.company.DefaultLanguage.String()].Val, &name, &content); err != nil {
|
|
return err
|
|
}
|
|
if err := f.Name.FillArray(name); err != nil {
|
|
return err
|
|
}
|
|
if err := f.Content.FillArray(content); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *legalForm) Parse(r *http.Request) error {
|
|
if err := r.ParseForm(); err != nil {
|
|
return err
|
|
}
|
|
f.Slug.FillValue(r)
|
|
f.Name.FillValue(r)
|
|
f.Content.FillValue(r)
|
|
return nil
|
|
}
|
|
|
|
func (f *legalForm) Valid(l *locale.Locale) bool {
|
|
v := form.NewValidator(l)
|
|
if v.CheckRequired(f.Name[f.company.DefaultLanguage.String()], l.GettextNoop("Name can not be empty.")) {
|
|
v.CheckMinLength(f.Name[f.company.DefaultLanguage.String()], 1, l.GettextNoop("Name must have at least one letter."))
|
|
}
|
|
return v.AllOK
|
|
}
|
|
|
|
func (f *legalForm) MustRender(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company) {
|
|
template.MustRenderAdmin(w, r, user, company, "legal/form.gohtml", f)
|
|
}
|