camper/pkg/invoice/admin.go

1271 lines
38 KiB
Go
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package invoice
import (
"context"
"fmt"
"net/http"
"sort"
"strconv"
"strings"
"time"
"github.com/jackc/pgtype"
"dev.tandem.ws/tandem/camper/pkg/auth"
"dev.tandem.ws/tandem/camper/pkg/customer"
"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/ods"
"dev.tandem.ws/tandem/camper/pkg/template"
"dev.tandem.ws/tandem/camper/pkg/uuid"
)
const (
removedProductSuffix = ".removed"
defaultPaymentMethod = 1
)
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:
serveInvoiceIndex(w, r, user, company, conn)
case http.MethodPost:
addInvoice(w, r, user, company, conn)
default:
httplib.MethodNotAllowed(w, r, http.MethodGet, http.MethodPost)
}
case "batch":
switch r.Method {
case http.MethodPost:
handleBatchAction(w, r, user, company, conn)
default:
httplib.MethodNotAllowed(w, r, http.MethodPost)
}
case "new":
switch r.Method {
case http.MethodGet:
f := newInvoiceForm(r.Context(), conn, company, user.Locale)
query := r.URL.Query()
if invoiceToDuplicate := query.Get("duplicate"); uuid.Valid(invoiceToDuplicate) {
f.MustFillFromDatabase(r.Context(), conn, user.Locale, invoiceToDuplicate)
f.Slug = ""
f.InvoiceStatus.Selected = []string{"created"}
} else if bookingToInvoice, err := strconv.Atoi(query.Get("booking")); err == nil {
f.MustFillFromBooking(r.Context(), conn, user.Locale, bookingToInvoice)
} else if customerSlug := query.Get("customer"); uuid.Valid(customerSlug) {
if err := f.Customer.FillFromDatabase(r.Context(), conn, customerSlug); err != nil {
panic(err)
}
}
f.Date.Val = time.Now().Format("2006-01-02")
f.MustRender(w, r, user, company, conn)
case http.MethodPost:
handleInvoiceAction(w, r, user, company, conn, "", "/invoices/new")
default:
httplib.MethodNotAllowed(w, r, http.MethodGet, http.MethodPost)
}
case "product-form":
switch r.Method {
case http.MethodGet:
query := r.URL.Query()
index, _ := strconv.Atoi(query.Get("index"))
f := newInvoiceProductForm(index, company, user.Locale, mustGetTaxOptions(r.Context(), conn, company))
productSlug := query.Get("slug")
if len(productSlug) > 0 {
if !f.MustFillFromDatabase(r.Context(), conn, productSlug) {
http.NotFound(w, r)
return
}
quantity, _ := strconv.Atoi(query.Get("product.quantity." + strconv.Itoa(index)))
if quantity > 0 {
f.Quantity.Val = strconv.Itoa(quantity)
}
httplib.TriggerAfterSettle(w, "recompute")
}
template.MustRenderAdminNoLayout(w, r, user, company, "invoice/product-form.gohtml", f)
default:
httplib.MethodNotAllowed(w, r, http.MethodGet)
}
default:
h.invoiceHandler(user, company, conn, head).ServeHTTP(w, r)
}
})
}
func (h *AdminHandler) invoiceHandler(user *auth.User, company *auth.Company, conn *database.Conn, slug string) 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:
serveInvoice(w, r, user, company, conn, slug)
case http.MethodPut:
handleUpdateInvoice(w, r, user, company, conn, slug)
default:
httplib.MethodNotAllowed(w, r, http.MethodGet, http.MethodPut)
}
case "edit":
switch r.Method {
case http.MethodGet:
serveEditInvoice(w, r, user, company, conn, slug)
case http.MethodPost:
handleEditInvoiceAction(w, r, user, company, conn, slug)
default:
httplib.MethodNotAllowed(w, r, http.MethodGet, http.MethodPost)
}
default:
http.NotFound(w, r)
}
})
}
type IndexEntry struct {
ID int
Slug string
Date time.Time
Number string
Total string
CustomerName string
Status string
StatusLabel string
}
func serveInvoiceIndex(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn) {
filters := newFilterForm(r.Context(), conn, company, user.Locale)
if err := filters.Parse(r); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
page := &invoiceIndex{
Invoices: filters.buildCursor(mustCollectInvoiceEntries(r.Context(), conn, user.Locale, filters)),
Filters: filters,
InvoiceStatuses: mustCollectInvoiceStatuses(r.Context(), conn, user.Locale),
}
page.MustRender(w, r, user, company)
}
type invoiceIndex struct {
Invoices []*IndexEntry
Filters *filterForm
InvoiceStatuses map[string]string
}
func (page *invoiceIndex) MustRender(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company) {
if httplib.IsHTMxRequest(r) && page.Filters.Paginated() {
template.MustRenderAdminNoLayout(w, r, user, company, "invoice/results.gohtml", page)
} else {
template.MustRenderAdminFiles(w, r, user, company, page, "invoice/index.gohtml", "invoice/results.gohtml")
}
}
func mustCollectInvoiceEntries(ctx context.Context, conn *database.Conn, locale *locale.Locale, filters *filterForm) []*IndexEntry {
where, args := filters.BuildQuery([]interface{}{locale.Language.String()})
rows, err := conn.Query(ctx, fmt.Sprintf(`
select invoice_id
, invoice.slug
, invoice_date
, invoice_number
, contact.name
, invoice.invoice_status
, isi18n.name
, to_price(total, decimal_digits)
from invoice
join contact using (contact_id)
join invoice_status_i18n isi18n on invoice.invoice_status = isi18n.invoice_status and isi18n.lang_tag = $1
join invoice_amount using (invoice_id)
join currency using (currency_code)
where (%s)
order by invoice_date desc
, invoice_number desc
limit %d
`, where, filters.PerPage()+1), args...)
if err != nil {
panic(err)
}
defer rows.Close()
var entries []*IndexEntry
for rows.Next() {
entry := &IndexEntry{}
if err := rows.Scan(&entry.ID, &entry.Slug, &entry.Date, &entry.Number, &entry.CustomerName, &entry.Status, &entry.StatusLabel, &entry.Total); err != nil {
panic(err)
}
entries = append(entries, entry)
}
if rows.Err() != nil {
panic(rows.Err())
}
return entries
}
func mustCollectInvoiceStatuses(ctx context.Context, conn *database.Conn, locale *locale.Locale) map[string]string {
rows, err := conn.Query(ctx, `
select invoice_status.invoice_status
, isi18n.name
from invoice_status
join invoice_status_i18n isi18n using(invoice_status)
where isi18n.lang_tag = $1
order by invoice_status
`, locale.Language)
if err != nil {
panic(err)
}
defer rows.Close()
statuses := map[string]string{}
for rows.Next() {
var key, name string
if err := rows.Scan(&key, &name); err != nil {
panic(err)
}
statuses[key] = name
}
if rows.Err() != nil {
panic(rows.Err())
}
return statuses
}
func serveInvoice(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, slug string) {
pdf := false
if strings.HasSuffix(slug, ".pdf") {
pdf = true
slug = slug[:len(slug)-len(".pdf")]
}
if !uuid.Valid(slug) {
http.NotFound(w, r)
return
}
inv := mustGetInvoice(r.Context(), conn, company, slug)
if inv == nil {
http.NotFound(w, r)
return
}
if pdf {
w.Header().Set("Content-Type", "application/pdf")
mustWriteInvoicePdf(w, r, user, company, inv)
} else {
template.MustRenderAdmin(w, r, user, company, "invoice/view.gohtml", inv)
}
}
type invoice struct {
Number string
Slug string
Date time.Time
Invoicer taxDetails
Invoicee taxDetails
Notes string
PaymentInstructions string
Products []*invoiceProduct
Subtotal string
Taxes [][]string
TaxClasses []string
HasDiscounts bool
Total string
LegalDisclaimer string
}
type taxDetails struct {
Name string
VATIN string
Address string
City string
PostalCode string
Province string
Email string
Phone string
}
type invoiceProduct struct {
Name string
Description string
Price string
Discount int
Quantity int
Taxes map[string]int
Subtotal string
Total string
}
func mustGetInvoice(ctx context.Context, conn *database.Conn, company *auth.Company, slug string) *invoice {
inv := &invoice{
Slug: slug,
}
var invoiceId int
var decimalDigits int
if err := conn.QueryRow(ctx, `
select invoice_id
, decimal_digits
, invoice_number
, invoice_date
, notes
, instructions
, contact.name
, id_document_number
, address
, city
, province
, postal_code
, to_price(subtotal, decimal_digits)
, to_price(total, decimal_digits)
from invoice
join payment_method using (payment_method_id)
join contact using (contact_id)
join invoice_amount using (invoice_id)
join currency using (currency_code)
where invoice.slug = $1`, slug).Scan(
&invoiceId,
&decimalDigits,
&inv.Number,
&inv.Date,
&inv.Notes,
&inv.PaymentInstructions,
&inv.Invoicee.Name,
&inv.Invoicee.VATIN,
&inv.Invoicee.Address,
&inv.Invoicee.City,
&inv.Invoicee.Province,
&inv.Invoicee.PostalCode,
&inv.Subtotal,
&inv.Total,
); err != nil {
if database.ErrorIsNotFound(err) {
return nil
}
panic(err)
}
if err := conn.QueryRow(ctx, `
select business_name
, vatin
, phone
, email
, address
, city
, province
, postal_code
, legal_disclaimer
from company
where company_id = $1
`, company.ID).Scan(
&inv.Invoicer.Name,
&inv.Invoicer.VATIN,
&inv.Invoicer.Phone,
&inv.Invoicer.Email,
&inv.Invoicer.Address,
&inv.Invoicer.City,
&inv.Invoicer.Province,
&inv.Invoicer.PostalCode,
&inv.LegalDisclaimer); err != nil {
panic(err)
}
if err := conn.QueryRow(ctx, `
select array_agg(array[name, to_price(amount, $2)])
from invoice_tax_amount
join tax using (tax_id)
where invoice_id = $1
`, invoiceId, decimalDigits).Scan(&inv.Taxes); err != nil {
panic(err)
}
rows, err := conn.Query(ctx, `
select invoice_product.name
, description
, to_price(price, $2)
, (discount_rate * 100)::integer
, quantity
, to_price(subtotal, $2)
, to_price(total, $2)
, array_agg(array[tax_class.name, (tax_rate * 100)::integer::text]) filter (where tax_rate is not null)
from invoice_product
join invoice_product_amount using (invoice_product_id)
left join invoice_product_tax using (invoice_product_id)
left join tax using (tax_id)
left join tax_class using (tax_class_id)
where invoice_id = $1
group by invoice_product_id
, invoice_product.name
, description
, discount_rate
, price
, quantity
, subtotal
, total
order by invoice_product_id
`, invoiceId, decimalDigits)
if err != nil {
panic(err)
}
defer rows.Close()
taxClasses := map[string]bool{}
for rows.Next() {
product := &invoiceProduct{
Taxes: make(map[string]int),
}
var taxes [][]string
if err := rows.Scan(
&product.Name,
&product.Description,
&product.Price,
&product.Discount,
&product.Quantity,
&product.Subtotal,
&product.Total,
&taxes); err != nil {
panic(err)
}
for _, tax := range taxes {
taxClass := tax[0]
taxClasses[taxClass] = true
product.Taxes[taxClass], _ = strconv.Atoi(tax[1])
}
if product.Discount > 0 {
inv.HasDiscounts = true
}
inv.Products = append(inv.Products, product)
}
for taxClass := range taxClasses {
inv.TaxClasses = append(inv.TaxClasses, taxClass)
}
sort.Strings(inv.TaxClasses)
if rows.Err() != nil {
panic(rows.Err())
}
return inv
}
func mustRenderNewInvoiceProductsForm(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, action string, form *invoiceForm) {
page := newInvoiceProductsPage{
Action: "/admin/" + action,
Form: form,
Products: mustGetProductChoices(r.Context(), conn, company),
}
template.MustRenderAdmin(w, r, user, company, "invoice/products.gohtml", page)
}
func mustGetProductChoices(ctx context.Context, conn *database.Conn, company *auth.Company) []*productChoice {
rows, err := conn.Query(ctx, "select product.slug, product.name, to_price(price, decimal_digits) from product join company using (company_id) join currency using (currency_code) where company_id = $1 order by name", company.ID)
if err != nil {
panic(err)
}
defer rows.Close()
var choices []*productChoice
for rows.Next() {
entry := &productChoice{}
if err := rows.Scan(&entry.Slug, &entry.Name, &entry.Price); err != nil {
panic(err)
}
choices = append(choices, entry)
}
if rows.Err() != nil {
panic(rows.Err())
}
return choices
}
type newInvoiceProductsPage struct {
Action string
Form *invoiceForm
Products []*productChoice
}
type productChoice struct {
Slug string
Name string
Price string
}
func addInvoice(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn) {
f := newInvoiceForm(r.Context(), conn, company, user.Locale)
if err := f.Parse(r, conn, user.Locale); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if err := user.VerifyCSRFToken(r); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if ok, err := f.Validate(r.Context(), conn, user.Locale); err != nil {
panic(err)
} else if !ok {
if !httplib.IsHTMxRequest(r) {
w.WriteHeader(http.StatusUnprocessableEntity)
}
f.MustRender(w, r, user, company, conn)
return
}
tx := conn.MustBegin(r.Context())
defer tx.Rollback(r.Context())
customerID, err := f.Customer.UpdateOrCreate(r.Context(), company, tx)
if err != nil {
panic(err)
}
slug, err := tx.AddInvoice(r.Context(), company.ID, f.Date.Val, customerID, f.Notes.Val, defaultPaymentMethod, newInvoiceProducts(f.Products))
if err != nil {
panic(err)
}
if bookingID, err := strconv.Atoi(f.BookingID.Val); err == nil {
if _, err := tx.Exec(r.Context(),
"insert into booking_invoice (booking_id, invoice_id) select $1, invoice_id from invoice where slug = $2",
bookingID,
slug,
); err != nil {
panic(err)
}
if _, err := tx.Exec(r.Context(),
"update booking set booking_status = 'invoiced' where booking_id = $1",
bookingID,
); err != nil {
panic(err)
}
}
tx.MustCommit(r.Context())
httplib.Redirect(w, r, "/admin/invoices/"+slug, http.StatusSeeOther)
}
func newInvoiceProducts(src []*invoiceProductForm) database.NewInvoiceProductArray {
dst := make(database.NewInvoiceProductArray, 0, len(src))
for _, p := range src {
dst = append(dst, p.newInvoiceProduct())
}
return dst
}
func editedInvoiceProducts(src []*invoiceProductForm) database.EditedInvoiceProductArray {
dst := make(database.EditedInvoiceProductArray, 0, len(src))
for _, p := range src {
dst = append(dst, p.editedInvoiceProduct())
}
return dst
}
func handleBatchAction(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn) {
if err := r.ParseForm(); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if err := user.VerifyCSRFToken(r); err != nil {
http.Error(w, err.Error(), http.StatusForbidden)
return
}
switch r.Form.Get("action") {
case "download":
slugs := r.Form["invoice"]
if len(slugs) == 0 {
http.Redirect(w, r, "/admin/invoices", http.StatusSeeOther)
return
}
invoices := mustWriteInvoicesPdf(r, user, company, conn, slugs)
w.Header().Set("Content-Type", "application/zip")
w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", user.Locale.Pgettext("invoices.zip", "filename")))
w.WriteHeader(http.StatusOK)
if _, err := w.Write(invoices); err != nil {
panic(err)
}
case "export":
filters := newFilterForm(r.Context(), conn, company, user.Locale)
if err := filters.Parse(r); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
entries := mustCollectInvoiceEntries(r.Context(), conn, user.Locale, filters)
taxes := mustCollectInvoiceEntriesTaxes(r.Context(), conn, entries)
taxColumns := mustCollectTaxColumns(r.Context(), conn, company)
table := mustWriteInvoicesOds(entries, taxes, taxColumns, company, user.Locale)
ods.MustWriteResponse(w, table, user.Locale.Pgettext("invoices.ods", "filename"))
default:
http.Error(w, user.Locale.Gettext("Invalid action"), http.StatusBadRequest)
}
}
func mustCollectTaxColumns(ctx context.Context, conn *database.Conn, company *auth.Company) map[int]string {
rows, err := conn.Query(ctx, `
select tax_id
, name
from tax
where company_id = $1
`, company.ID)
if err != nil {
panic(err)
}
defer rows.Close()
columns := make(map[int]string)
for rows.Next() {
var taxID int
var name string
err = rows.Scan(&taxID, &name)
if err != nil {
panic(err)
}
columns[taxID] = name
}
return columns
}
type taxMap map[int]string
func mustCollectInvoiceEntriesTaxes(ctx context.Context, conn *database.Conn, entries []*IndexEntry) map[int]taxMap {
ids := mustMakeIDArray(entries, func(entry *IndexEntry) int {
return entry.ID
})
return mustMakeTaxMap(ctx, conn, ids, `
select invoice_id
, tax_id
, to_price(amount, decimal_digits)
from invoice_tax_amount
join invoice using (invoice_id)
join currency using (currency_code)
where invoice_id = any ($1)
`)
}
func mustMakeIDArray[T any](entries []*T, id func(entry *T) int) *pgtype.Int4Array {
ids := make([]int, len(entries))
i := 0
for _, entry := range entries {
ids[i] = id(entry)
i++
}
idArray := &pgtype.Int4Array{}
if err := idArray.Set(ids); err != nil {
panic(err)
}
return idArray
}
func mustMakeTaxMap(ctx context.Context, conn *database.Conn, ids *pgtype.Int4Array, sql string) map[int]taxMap {
rows, err := conn.Query(ctx, sql, ids)
if err != nil {
panic(err)
}
defer rows.Close()
taxes := make(map[int]taxMap)
for rows.Next() {
var entryID int
var taxID int
var amount string
err := rows.Scan(&entryID, &taxID, &amount)
if err != nil {
panic(err)
}
entryTaxes := taxes[entryID]
if entryTaxes == nil {
entryTaxes = make(taxMap)
taxes[entryID] = entryTaxes
}
entryTaxes[taxID] = amount
}
if rows.Err() != nil {
panic(rows.Err())
}
return taxes
}
type invoiceForm struct {
company *auth.Company
Slug string
Number string
BookingID *form.Input
InvoiceStatus *form.Select
Customer *customer.ContactForm
Date *form.Input
Notes *form.Input
Products []*invoiceProductForm
RemovedProduct *invoiceProductForm
Subtotal string
Taxes [][]string
Total string
}
func newInvoiceForm(ctx context.Context, conn *database.Conn, company *auth.Company, l *locale.Locale) *invoiceForm {
return &invoiceForm{
company: company,
BookingID: &form.Input{
Name: "booking_id",
},
InvoiceStatus: &form.Select{
Name: "invoice_status",
Selected: []string{"created"},
Options: mustGetInvoiceStatusOptions(ctx, conn, l),
},
Customer: customer.NewContactForm(ctx, conn, l),
Date: &form.Input{
Name: "date",
},
Notes: &form.Input{
Name: "notes",
},
}
}
func mustGetInvoiceStatusOptions(ctx context.Context, conn *database.Conn, locale *locale.Locale) []*form.Option {
return form.MustGetOptions(ctx, conn, `
select invoice_status.invoice_status
, isi18n.name
from invoice_status
join invoice_status_i18n isi18n using(invoice_status)
where isi18n.lang_tag = $1
order by invoice_status`, locale.Language)
}
func (f *invoiceForm) Parse(r *http.Request, conn *database.Conn, l *locale.Locale) error {
if err := r.ParseForm(); err != nil {
return err
}
f.BookingID.FillValue(r)
f.InvoiceStatus.FillValue(r)
f.Date.FillValue(r)
f.Notes.FillValue(r)
if _, ok := r.Form["product.id.0"]; ok {
taxOptions := mustGetTaxOptions(r.Context(), conn, f.company)
for index := 0; true; index++ {
if _, ok := r.Form["product.id."+strconv.Itoa(index)]; !ok {
break
}
productForm := newInvoiceProductForm(index, f.company, l, taxOptions)
if err := productForm.Parse(r); err != nil {
return err
}
f.Products = append(f.Products, productForm)
}
}
return f.Customer.Parse(r)
}
func (f *invoiceForm) Validate(ctx context.Context, conn *database.Conn, l *locale.Locale) (bool, error) {
v := form.NewValidator(l)
v.CheckSelectedOptions(f.InvoiceStatus, l.GettextNoop("Selected invoice status is not valid."))
if v.CheckRequired(f.Date, l.GettextNoop("Invoice date can not be empty.")) {
v.CheckValidDate(f.Date, l.GettextNoop("Invoice date must be a valid date."))
}
allOK := v.AllOK
for _, product := range f.Products {
allOK = product.Validate(l) && allOK
}
if ok, err := f.Customer.Valid(ctx, conn, l); err != nil {
return false, err
} else if !ok {
allOK = false
}
return allOK, nil
}
func (f *invoiceForm) Update(l *locale.Locale) {
products := f.Products
f.Products = nil
for n, product := range products {
if product.Quantity.Val != "0" {
product.Update(l)
if n != len(f.Products) {
product.Index = len(f.Products)
product.Rename()
}
f.Products = append(f.Products, product)
}
}
}
func (f *invoiceForm) RemoveProduct(index int) {
products := f.Products
f.Products = nil
for n, product := range products {
if n == index {
f.RemovedProduct = product
} else {
if n != len(f.Products) {
product.Index = len(f.Products)
product.Rename()
}
f.Products = append(f.Products, product)
}
}
if f.RemovedProduct != nil {
f.RemovedProduct.RenameWithSuffix(removedProductSuffix)
}
}
func (f *invoiceForm) MustRender(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn) {
err := conn.QueryRow(r.Context(), "select subtotal, taxes, total from compute_new_invoice_amount($1, $2)", company.ID, newInvoiceProducts(f.Products)).Scan(&f.Subtotal, &f.Taxes, &f.Total)
if err != nil {
panic(err)
}
if len(f.Products) == 0 {
f.Products = append(f.Products, newInvoiceProductForm(0, company, user.Locale, mustGetTaxOptions(r.Context(), conn, company)))
}
template.MustRenderAdminFiles(w, r, user, company, f, "invoice/form.gohtml", "invoice/product-form.gohtml", "customer/contact.gohtml")
}
const selectProductBySlug = `
select ''
, product_id::text
, name
, description
, to_price(price, decimal_digits)
, '1' as quantity
, '0' as discount
, array_remove(array_agg(tax_id), null)
from product
join company using (company_id)
join currency using (currency_code)
left join product_tax using (product_id)
where product.slug = any ($1)
group by product_id
, name
, description
, price
, decimal_digits
`
func (f *invoiceForm) AddProducts(ctx context.Context, conn *database.Conn, l *locale.Locale, productsSlug []string) {
f.mustAddProductsFromQuery(ctx, conn, l, selectProductBySlug, productsSlug)
}
func (f *invoiceForm) mustAddProductsFromQuery(ctx context.Context, conn *database.Conn, l *locale.Locale, sql string, args ...interface{}) {
index := len(f.Products)
taxOptions := mustGetTaxOptions(ctx, conn, f.company)
rows, err := conn.Query(ctx, sql, args...)
if err != nil {
panic(err)
}
defer rows.Close()
for rows.Next() {
product := newInvoiceProductForm(index, f.company, l, taxOptions)
if err := rows.Scan(&product.InvoiceProductId.Val, &product.ProductId.Val, &product.Name.Val, &product.Description.Val, &product.Price.Val, &product.Quantity.Val, &product.Discount.Val, &product.Tax.Selected); err != nil {
panic(err)
}
f.Products = append(f.Products, product)
index++
}
if rows.Err() != nil {
panic(rows.Err())
}
}
func (f *invoiceForm) InsertProduct(product *invoiceProductForm) {
replaced := false
for n, existing := range f.Products {
if existing.Quantity.Val == "" || existing.Quantity.Val == "0" {
product.Index = n
f.Products[n] = product
replaced = true
break
}
}
if !replaced {
product.Index = len(f.Products)
f.Products = append(f.Products, product)
}
product.Rename()
}
func (f *invoiceForm) MustFillFromDatabase(ctx context.Context, conn *database.Conn, l *locale.Locale, slug string) bool {
var invoiceId int
var contactSlug string
selectedInvoiceStatus := f.InvoiceStatus.Selected
f.InvoiceStatus.Selected = nil
err := conn.QueryRow(ctx, `
select invoice_id
, array[invoice_status]
, contact.slug
, invoice_number
, invoice_date::text
, notes
from invoice
join contact using (contact_id)
where invoice.slug = $1
`, slug).Scan(&invoiceId, &f.InvoiceStatus.Selected, &contactSlug, &f.Number, &f.Date.Val, &f.Notes.Val)
if err != nil {
if database.ErrorIsNotFound(err) {
f.InvoiceStatus.Selected = selectedInvoiceStatus
return false
}
panic(err)
}
f.Slug = slug
f.Products = []*invoiceProductForm{}
f.mustAddProductsFromQuery(ctx, conn, l, "select invoice_product_id::text, coalesce(product_id, 0)::text, name, description, to_price(price, $2), quantity::text, (discount_rate * 100)::integer::text, array_remove(array_agg(tax_id::text), null) from invoice_product left join invoice_product_product using (invoice_product_id) left join invoice_product_tax using (invoice_product_id) where invoice_id = $1 group by invoice_product_id, coalesce(product_id, 0), name, description, discount_rate, price, quantity", invoiceId, f.company.DecimalDigits)
if err := f.Customer.FillFromDatabase(ctx, conn, contactSlug); err != nil {
panic(err)
}
return true
}
func (f *invoiceForm) MustFillFromBooking(ctx context.Context, conn *database.Conn, l *locale.Locale, bookingID int) bool {
note := l.Gettext("Re: booking #%s of %s%s")
dateFormat := l.Pgettext("MM/DD/YYYY", "to_char")
err := conn.QueryRow(ctx, `
select format($2, left(slug::text, 10), to_char(lower(stay), $3), to_char(upper(stay), $3))
from booking
where booking_id = $1
`, bookingID, note, dateFormat).Scan(&f.Notes.Val)
if err != nil {
if database.ErrorIsNotFound(err) {
return false
}
panic(err)
}
f.BookingID.Val = strconv.Itoa(bookingID)
f.Products = []*invoiceProductForm{}
f.mustAddProductsFromQuery(ctx, conn, l, `
select '', '', quantity || ' × ' || product.name, '', to_price(round(price / (1 + rate))::integer, $2), '1', '0', array[tax_id::text] from (
select $4 as name, subtotal_nights as price, upper(stay) - lower(stay) as quantity, 2 as tax_id from booking where booking_id = $1
union all
select $5, subtotal_adults, number_adults, 2 from booking where booking_id = $1
union all
select $6, subtotal_teenagers, number_teenagers, 2 from booking where booking_id = $1
union all
select $7, subtotal_children, number_children, 2 from booking where booking_id = $1
union all
select $8, subtotal_dogs, number_dogs, 2 from booking where booking_id = $1
union all
select coalesce(i18n.name, type_option.name), subtotal, units, 2
from booking_option
join campsite_type_option as type_option using (campsite_type_option_id)
left join campsite_type_option_i18n as i18n on i18n.campsite_type_option_id = type_option.campsite_type_option_id and lang_tag = $3
union all
select $9, subtotal_tourist_tax, number_adults, 4 from booking where booking_id = $1
) as product
join tax using (tax_id)
where quantity > 0
`,
bookingID,
f.company.DecimalDigits,
l.Language,
l.Pgettext("Night", "cart"),
l.Pgettext("Adults aged 17 or older", "input"),
l.Pgettext("Teenagers from 11 to 16 years old", "input"),
l.Pgettext("Children from 2 to 10 years old", "input"),
l.Pgettext("Dogs", "input"),
l.Pgettext("Tourist tax", "cart"),
)
if err := f.Customer.FillFromBooking(ctx, conn, bookingID); err != nil && !database.ErrorIsNotFound(err) {
panic(err)
}
return true
}
func mustGetTaxOptions(ctx context.Context, conn *database.Conn, company *auth.Company) []*form.Option {
return form.MustGetOptions(ctx, conn, "select tax_id::text, tax.name from tax where tax.company_id = $1 order by tax.rate desc", company.ID)
}
func mustGetContactOptions(ctx context.Context, conn *database.Conn, company *auth.Company) []*form.Option {
return form.MustGetOptions(ctx, conn, "select contact_id::text, name from contact where company_id = $1 order by name", company.ID)
}
type invoiceProductForm struct {
locale *locale.Locale
company *auth.Company
Index int
InvoiceProductId *form.Input
ProductId *form.Input
Name *form.Input
Description *form.Input
Price *form.Input
Quantity *form.Input
Discount *form.Input
Tax *form.Select
}
func newInvoiceProductForm(index int, company *auth.Company, locale *locale.Locale, taxOptions []*form.Option) *invoiceProductForm {
f := &invoiceProductForm{
locale: locale,
company: company,
Index: index,
InvoiceProductId: &form.Input{},
ProductId: &form.Input{},
Name: &form.Input{},
Description: &form.Input{},
Price: &form.Input{},
Quantity: &form.Input{},
Discount: &form.Input{},
Tax: &form.Select{
Options: taxOptions,
},
}
f.Rename()
return f
}
func (f *invoiceProductForm) Rename() {
f.RenameWithSuffix("." + strconv.Itoa(f.Index))
}
func (f *invoiceProductForm) RenameWithSuffix(suffix string) {
f.InvoiceProductId.Name = "product.invoice_product_id" + suffix
f.ProductId.Name = "product.id" + suffix
f.Name.Name = "product.name" + suffix
f.Description.Name = "product.description" + suffix
f.Price.Name = "product.price" + suffix
f.Quantity.Name = "product.quantity" + suffix
f.Discount.Name = "product.discount" + suffix
f.Tax.Name = "product.tax" + suffix
}
func (f *invoiceProductForm) Parse(r *http.Request) error {
if err := r.ParseForm(); err != nil {
return err
}
f.InvoiceProductId.FillValue(r)
f.ProductId.FillValue(r)
f.Name.FillValue(r)
f.Description.FillValue(r)
f.Price.FillValue(r)
f.Quantity.FillValue(r)
f.Discount.FillValue(r)
f.Tax.FillValue(r)
return nil
}
func (f *invoiceProductForm) Validate(l *locale.Locale) bool {
v := form.NewValidator(l)
if f.InvoiceProductId.Val != "" {
if v.CheckValidInteger(f.InvoiceProductId, l.GettextNoop("Invoice product ID must be an integer.")) {
v.CheckMinInteger(f.InvoiceProductId, 1, l.GettextNoop("Invoice product ID one or greater."))
}
}
if f.ProductId.Val != "" {
if v.CheckValidInteger(f.ProductId, l.GettextNoop("Product ID must be an integer.")) {
v.CheckMinInteger(f.ProductId, 0, l.GettextNoop("Product ID must zero or greater."))
}
}
v.CheckRequired(f.Name, l.GettextNoop("Name can not be empty."))
if v.CheckRequired(f.Price, l.GettextNoop("Price can not be empty.")) {
if v.CheckValidDecimal(f.Price, l.GettextNoop("Price must be a decimal number.")) {
v.CheckMinDecimal(f.Price, 0, l.GettextNoop("Price must be zero or greater."))
}
}
if v.CheckRequired(f.Quantity, l.GettextNoop("Quantity can not be empty.")) {
if v.CheckValidInteger(f.Quantity, l.GettextNoop("Quantity must be an integer.")) {
v.CheckMinInteger(f.Quantity, 1, l.GettextNoop("Quantity must one or greater."))
}
}
if v.CheckRequired(f.Discount, l.GettextNoop("Discount can not be empty.")) {
if v.CheckValidInteger(f.Discount, l.GettextNoop("Discount must be an integer.")) {
if v.CheckMinInteger(f.Discount, 0, l.GettextNoop("Discount must be a percentage between 0 and 100.")) {
v.CheckMaxInteger(f.Discount, 100, l.GettextNoop("Discount must be a percentage between 0 and 100."))
}
}
}
v.CheckSelectedOptions(f.Tax, l.GettextNoop("Selected tax is not valid."))
return v.AllOK
}
func (f *invoiceProductForm) Update(l *locale.Locale) {
v := form.NewValidator(l)
if !v.CheckValidDecimal(f.Price, "") || !v.CheckMinDecimal(f.Price, 0, "") {
f.Price.Val = "0.0"
f.Price.Error = nil
}
if !v.CheckValidInteger(f.Quantity, "") || !v.CheckMinInteger(f.Quantity, 0, "") {
f.Quantity.Val = "1"
f.Quantity.Error = nil
}
if !v.CheckValidInteger(f.Discount, "") || !v.CheckMinInteger(f.Discount, 0, "") || !v.CheckMaxInteger(f.Discount, 100, "") {
f.Discount.Val = "0"
f.Discount.Error = nil
}
}
func (f *invoiceProductForm) MustFillFromDatabase(ctx context.Context, conn *database.Conn, slug string) bool {
err := conn.QueryRow(ctx, selectProductBySlug, []string{slug}).Scan(
f.InvoiceProductId,
f.ProductId,
f.Name,
f.Description,
f.Price,
f.Quantity,
f.Discount,
f.Tax)
if err != nil {
if database.ErrorIsNotFound(err) {
return false
}
panic(err)
}
return true
}
func (f *invoiceProductForm) newInvoiceProduct() *database.NewInvoiceProduct {
productId := 0
if f.ProductId.Val != "" {
productId = f.ProductId.Int()
}
var taxes []int
if len(f.Tax.Selected) > 0 {
taxes = make([]int, 0, len(f.Tax.Selected))
for _, t := range f.Tax.Selected {
id, _ := strconv.Atoi(t)
taxes = append(taxes, id)
}
}
return &database.NewInvoiceProduct{
ProductId: productId,
Name: f.Name.Val,
Description: f.Description.Val,
Price: f.Price.Val,
Quantity: f.Quantity.Int(),
Discount: float64(f.Discount.Int()) / 100.0,
Taxes: taxes,
}
}
func (f *invoiceProductForm) editedInvoiceProduct() *database.EditedInvoiceProduct {
invoiceProductId := 0
if f.InvoiceProductId.Val != "" {
invoiceProductId = f.InvoiceProductId.Int()
}
return &database.EditedInvoiceProduct{
NewInvoiceProduct: f.newInvoiceProduct(),
InvoiceProductId: invoiceProductId,
}
}
func handleUpdateInvoice(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, slug string) {
if !uuid.Valid(slug) {
http.NotFound(w, r)
return
}
f := newInvoiceForm(r.Context(), conn, company, user.Locale)
if err := f.Parse(r, conn, user.Locale); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if err := user.VerifyCSRFToken(r); err != nil {
http.Error(w, err.Error(), http.StatusForbidden)
return
}
if r.FormValue("quick") == "status" {
slug = conn.MustGetText(r.Context(), "update invoice set invoice_status = $1 where slug = $2 returning slug", f.InvoiceStatus, slug)
if slug == "" {
http.NotFound(w, r)
return
}
httplib.Relocate(w, r, "/admin/invoices", http.StatusSeeOther)
} else {
if ok, err := f.Validate(r.Context(), conn, user.Locale); err != nil {
panic(err)
} else if !ok {
if !httplib.IsHTMxRequest(r) {
w.WriteHeader(http.StatusUnprocessableEntity)
}
f.MustRender(w, r, user, company, conn)
return
}
tx := conn.MustBegin(r.Context())
defer tx.Rollback(r.Context())
customerID, err := f.Customer.UpdateOrCreate(r.Context(), company, tx)
if err != nil {
panic(err)
}
slug, err = tx.EditInvoice(r.Context(), slug, f.InvoiceStatus.String(), customerID, f.Notes.Val, defaultPaymentMethod, editedInvoiceProducts(f.Products))
if err != nil {
panic(err)
}
tx.MustCommit(r.Context())
if slug == "" {
http.NotFound(w, r)
return
}
httplib.Redirect(w, r, "/admin/invoices/"+slug, http.StatusSeeOther)
}
}
func serveEditInvoice(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, slug string) {
if !uuid.Valid(slug) {
http.NotFound(w, r)
return
}
f := newInvoiceForm(r.Context(), conn, company, user.Locale)
if !f.MustFillFromDatabase(r.Context(), conn, user.Locale, slug) {
http.NotFound(w, r)
return
}
f.MustRender(w, r, user, company, conn)
}
func handleEditInvoiceAction(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, slug string) {
if !uuid.Valid(slug) {
http.NotFound(w, r)
return
}
actionUri := fmt.Sprintf("/invoices/%s/edit", slug)
handleInvoiceAction(w, r, user, company, conn, slug, actionUri)
}
func handleInvoiceAction(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, slug string, action string) {
f := newInvoiceForm(r.Context(), conn, company, user.Locale)
if err := f.Parse(r, conn, user.Locale); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if err := user.VerifyCSRFToken(r); err != nil {
http.Error(w, err.Error(), http.StatusForbidden)
return
}
f.Slug = slug
actionField := r.Form.Get("action")
switch actionField {
case "update":
f.Update(user.Locale)
w.WriteHeader(http.StatusOK)
f.MustRender(w, r, user, company, conn)
case "select-products":
mustRenderNewInvoiceProductsForm(w, r, user, company, conn, action, f)
case "add-products":
f.AddProducts(r.Context(), conn, user.Locale, r.Form["slug"])
f.MustRender(w, r, user, company, conn)
case "restore-product":
restoredProduct := newInvoiceProductForm(0, company, user.Locale, mustGetTaxOptions(r.Context(), conn, company))
restoredProduct.RenameWithSuffix(removedProductSuffix)
if err := restoredProduct.Parse(r); err != nil {
panic(err)
}
f.InsertProduct(restoredProduct)
f.Update(user.Locale)
f.MustRender(w, r, user, company, conn)
default:
prefix := "remove-product."
if strings.HasPrefix(actionField, prefix) {
index, err := strconv.Atoi(actionField[len(prefix):])
if err != nil {
http.Error(w, user.Locale.Gettext("Invalid action"), http.StatusBadRequest)
} else {
f.RemoveProduct(index)
f.Update(user.Locale)
f.MustRender(w, r, user, company, conn)
}
} else {
http.Error(w, user.Locale.Gettext("Invalid action"), http.StatusBadRequest)
}
}
}