bronku/cake-order-tracker
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

small improvements

Browse source
This commit is contained in:
bronku 2026-06-11 09:10:27 +02:00
parent bb32802324
commit 5f2d6f00bc
10 changed files with 117 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

6
config/config.go Normal file
View file

@ -0,0 +1,6 @@
package config
const (
DateFormat = "2006-01-02"
DateTimeFormat = "2006-01-02 15:04"
)

9
server/fetcher.go
View file

@ -1,9 +0,0 @@
package server
import (
"net/http"
"github.com/a-h/templ"
)
type fetcher func(r *http.Request) (templ.Component, int, error)

11
server/get.go
View file

@ -8,6 +8,7 @@ import (
"github.com/a-h/templ"
"git.bronku.xyz/bronku/cake-order-tracker/config"
"git.bronku.xyz/bronku/cake-order-tracker/models"
"git.bronku.xyz/bronku/cake-order-tracker/server/templates"
)
@ -26,15 +27,15 @@ func (h *Server) orders(_ *http.Request) (templ.Component, int, error) {
y, m, _ = time.Now().Date()
first, last := monthInterval(y, m)
orders, err := h.s.GetOrders(first, last)
return templates.OrdersPage(first.Format("2006-01-02"), last.Format("2006-01-02"), orders), http.StatusOK, err
return templates.OrdersPage(first.Format(config.DateFormat), last.Format(config.DateFormat), orders), http.StatusOK, err
}
func (h *Server) ordersSearch(r *http.Request) (templ.Component, int, error) {
from, err := time.Parse("2006-01-02", r.URL.Query().Get("from"))
from, err := time.Parse(config.DateFormat, r.URL.Query().Get("from"))
if err != nil {
from = time.Time{}
}
to, err := time.Parse("2006-01-02", r.URL.Query().Get("to"))
to, err := time.Parse(config.DateFormat, r.URL.Query().Get("to"))
if err != nil {
to = time.Time{}
}
@ -48,7 +49,7 @@ func (h *Server) cakes(_ *http.Request) (templ.Component, int, error) {
}
func (h *Server) cake(r *http.Request) (templ.Component, int, error) {
url := strings.Split(r.URL.String(), "/")
url := strings.Split(r.URL.Path, "/")
if len(url) < 3 || url[2] == "" {
return templates.CakePage(models.Cake{}), http.StatusOK, nil
}
@ -73,7 +74,7 @@ func (h *Server) order(r *http.Request) (templ.Component, int, error) {
return nil, http.StatusInternalServerError, err
}
url := strings.Split(r.URL.String(), "/")
url := strings.Split(r.URL.Path, "/")
if len(url) < 3 || url[2] == "" {
return templates.OrderPage(models.Order{Date: time.Now()}, catalogue), http.StatusOK, nil
}

9
server/http.go
View file

@ -1,9 +0,0 @@
package server
import "net/http"
func (h *Server) redirect(path string, code int) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, path, code)
}
}

9
server/post.go
View file

@ -1,7 +1,6 @@
package server
import (
"fmt"
"net/http"
"strconv"
"strings"
@ -9,6 +8,7 @@ import (
"github.com/a-h/templ"
"git.bronku.xyz/bronku/cake-order-tracker/config"
"git.bronku.xyz/bronku/cake-order-tracker/models"
"git.bronku.xyz/bronku/cake-order-tracker/server/templates"
)
@ -30,7 +30,6 @@ func (h *Server) postCake(r *http.Request) (templ.Component, int, error) {
return nil, http.StatusBadRequest, err
}
n.ID, err = h.s.SaveCake(n)
fmt.Println(err)
return templates.Confirmation("Potwierdzone", n.ID), http.StatusAccepted, err
}
@ -41,7 +40,6 @@ func (h *Server) postOrder(r *http.Request) (templ.Component, int, error) {
}
err = r.ParseForm()
fmt.Println(r.PostForm)
if err != nil {
return nil, http.StatusBadRequest, err
}
@ -55,14 +53,14 @@ func (h *Server) postOrder(r *http.Request) (templ.Component, int, error) {
if err != nil {
return nil, http.StatusBadRequest, err
}
n.Date, err = time.Parse("2006-01-02", r.FormValue("date"))
n.Date, err = time.Parse(config.DateFormat, r.FormValue("date"))
if err != nil {
return nil, http.StatusBadRequest, err
}
n.Cakes = make([]models.Cake, 0)
for _, e := range cakes {
e.Amount, err = strconv.Atoi(r.FormValue(fmt.Sprintf("cake[%d]", e.ID)))
e.Amount, err = strconv.Atoi(r.FormValue("cake[" + strconv.Itoa(e.ID) + "]"))
if err != nil {
continue
}
@ -77,6 +75,5 @@ func (h *Server) postOrder(r *http.Request) (templ.Component, int, error) {
n.Status = strings.TrimSpace(r.FormValue("status"))
n.ID, err = h.s.SaveOrder(n)
fmt.Println(n)
return templates.Confirmation("Potwierdzone", n.ID), http.StatusAccepted, err
}

50
server/server.go
View file

@ -4,52 +4,44 @@ import (
"embed"
"net/http"
"github.com/a-h/templ"
"git.bronku.xyz/bronku/cake-order-tracker/store"
)
type fetcher func(r *http.Request) (templ.Component, int, error)
type Server struct {
s *store.Store
routes map[string]route
http.Handler
}
type route struct {
function fetcher
}
//go:embed static/*
var static embed.FS
func (h *Server) loadHandler() {
mux := http.NewServeMux()
for i, e := range h.routes {
mux.HandleFunc(i, h.render(e.function))
func redirect(path string, code int) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, path, code)
}
mux.HandleFunc("GET /", h.redirect("/orders", http.StatusSeeOther))
fs := http.FileServerFS(static)
mux.Handle("GET /static/", fs)
h.Handler = mux
}
func New(store *store.Store) *Server {
var server Server
server.routes = map[string]route{
"GET /order/": {server.order},
"GET /orders": {server.orders},
"GET /orders/search/": {server.ordersSearch},
"GET /cake/": {server.cake},
"GET /cakes": {server.cakes},
"POST /order/": {server.postOrder},
"POST /cake/": {server.postCake},
}
server.s = store
server.loadHandler()
mux := http.NewServeMux()
mux.HandleFunc("GET /", redirect("/orders", http.StatusSeeOther))
mux.HandleFunc("GET /order/", server.render(server.order))
mux.HandleFunc("GET /orders", server.render(server.orders))
mux.HandleFunc("GET /orders/search/", server.render(server.ordersSearch))
mux.HandleFunc("GET /cake/", server.render(server.cake))
mux.HandleFunc("GET /cakes", server.render(server.cakes))
mux.HandleFunc("POST /order/", server.render(server.postOrder))
mux.HandleFunc("POST /cake/", server.render(server.postCake))
fs := http.FileServerFS(static)
mux.Handle("GET /static/", fs)
server.Handler = mux
return &server
}

95
store/cake.go
View file

@ -2,94 +2,56 @@ package store
import (
"errors"
"fmt"
"log"
"git.bronku.xyz/bronku/cake-order-tracker/models"
)
func (s *Store) cakeCount() int {
out := 0
rows, err := s.db.Query("select count(*) from cake;")
if err != nil {
return out
}
defer rows.Close()
_ = rows.Next()
_ = rows.Scan(&out)
return out
}
func (s *Store) loadCakes() ([]models.Cake, error) {
out := make([]models.Cake, 0, s.cakeCount())
rows, err := s.db.Query("select id, name, price from cake order by id;")
if err != nil {
return out, err
}
defer rows.Close()
for rows.Next() {
var cake models.Cake
err = rows.Scan(&cake.ID, &cake.Name, &cake.Price)
if err != nil {
continue
}
out = append(out, cake)
}
return out, nil
}
func (s *Store) searchCakes(id int) (int, error) {
for i, e := range s.cakes {
if e.ID != id {
continue
}
return i, nil
}
return 0, errors.New("cake not found")
}
func (s *Store) GetCake(id int) (models.Cake, error) {
if id <= 0 {
return models.Cake{}, errors.New("invalid cake id")
}
i, err := s.searchCakes(id)
row := s.db.QueryRow("select id, name, price from cake where id = ?;", id)
var out models.Cake
err := row.Scan(&out.ID, &out.Name, &out.Price)
if err != nil {
return models.Cake{}, err
return models.Cake{}, errors.New("cake not found")
}
return s.cakes[i], err
return out, nil
}
func (s *Store) GetCakes() ([]models.Cake, error) {
result := make([]models.Cake, len(s.cakes))
copy(result, s.cakes)
return result, nil
}
func (s *Store) updateCake(newCake models.Cake) error {
query := "update cake set name = ? , price = ? where id = ?"
_, err := s.db.Exec(query, newCake.Name, newCake.Price, newCake.ID)
rows, err := s.db.Query("select id, name, price from cake order by id;")
if err != nil {
return err
return nil, err
}
defer rows.Close()
i, err := s.searchCakes(newCake.ID)
if err != nil {
return err
var out []models.Cake
for rows.Next() {
var cake models.Cake
if err := rows.Scan(&cake.ID, &cake.Name, &cake.Price); err != nil {
return nil, err
}
s.cakes[i] = newCake
return nil
out = append(out, cake)
}
return out, rows.Err()
}
func (s *Store) SaveCake(newCake models.Cake) (int, error) {
if newCake.ID != 0 {
return newCake.ID, s.updateCake(newCake)
q := "update cake set name = ?, price = ? where id = ?;"
_, err := s.db.Exec(q, newCake.Name, newCake.Price, newCake.ID)
if err != nil {
return 0, err
}
fmt.Println("adding a new cake", newCake)
query := "insert into cake(name, price) values (?, ? );"
result, err := s.db.Exec(query, newCake.Name, newCake.Price)
log.Printf("UPDATE cake id=%d name=%q price=%d", newCake.ID, newCake.Name, newCake.Price)
return newCake.ID, nil
}
q := "insert into cake(name, price) values (?, ?);"
result, err := s.db.Exec(q, newCake.Name, newCake.Price)
if err != nil {
return 0, err
}
@ -99,7 +61,6 @@ func (s *Store) SaveCake(newCake models.Cake) (int, error) {
return 0, err
}
newCake.ID = int(id)
s.cakes = append(s.cakes, newCake)
log.Printf("INSERT cake id=%d name=%q price=%d", newCake.ID, newCake.Name, newCake.Price)
return newCake.ID, nil
}

85
store/order.go
View file

@ -3,46 +3,52 @@ package store
import (
"database/sql"
"errors"
"fmt"
"log"
"time"
"git.bronku.xyz/bronku/cake-order-tracker/config"
"git.bronku.xyz/bronku/cake-order-tracker/models"
)
// #todo update labels in templates
func (s *Store) parseOrderRow(row *sql.Rows) (models.Order, error) {
func (s *Store) scanOrderRow(row *sql.Rows) (models.Order, error) {
var out models.Order
var orderDate, deliveryDate string
err := row.Scan(&out.ID, &out.Name, &out.Surname, &out.Phone, &out.Location, &orderDate, &deliveryDate, &out.Status, &out.Paid)
if err != nil {
return out, err
}
out.Accepted, _ = time.Parse("2006-01-02 15:04", orderDate)
out.Date, _ = time.Parse("2006-01-02 15:04", deliveryDate)
out.Cakes = make([]models.Cake, 0)
rows, err := s.db.Query("select cake, amount from ordered_cake where customer_order = ?;", out.ID)
out.Accepted, err = time.Parse(config.DateTimeFormat, orderDate)
if err != nil {
return out, err
}
out.Date, err = time.Parse(config.DateTimeFormat, deliveryDate)
if err != nil {
return out, err
}
return out, nil
}
func (s *Store) loadOrderCakes(orderID int) ([]models.Cake, error) {
var cakes []models.Cake
rows, err := s.db.Query("select cake, amount from ordered_cake where customer_order = ?;", orderID)
if err != nil {
return cakes, err
}
defer rows.Close()
for rows.Next() {
var newCake models.Cake
err = rows.Scan(&newCake.ID, &newCake.Amount)
if err != nil {
return out, err
var c models.Cake
if err := rows.Scan(&c.ID, &c.Amount); err != nil {
return cakes, err
}
cakeData, err := s.GetCake(newCake.ID)
cakeData, err := s.GetCake(c.ID)
if err != nil {
continue
}
newCake.Name = cakeData.Name
newCake.Price = cakeData.Price
out.Cakes = append(out.Cakes, newCake)
c.Name = cakeData.Name
c.Price = cakeData.Price
cakes = append(cakes, c)
}
return out, nil
return cakes, rows.Err()
}
func (s *Store) getOrdersFromQuery(query string, args ...any) ([]models.Order, error) {
@ -54,9 +60,12 @@ func (s *Store) getOrdersFromQuery(query string, args ...any) ([]models.Order, e
defer rows.Close()
for rows.Next() {
order, err := s.parseOrderRow(rows)
order, err := s.scanOrderRow(rows)
if err != nil {
continue
}
order.Cakes, err = s.loadOrderCakes(order.ID)
if err != nil {
fmt.Println(err)
continue
}
out = append(out, order)
@ -78,8 +87,8 @@ func (s *Store) GetOrder(id int) (models.Order, error) {
}
func (s *Store) GetOrders(from, to time.Time) ([]models.Order, error) {
start := from.Format("2006-01-02") + " 00:00"
end := to.Format("2006-01-02") + " 99:99"
start := from.Format(config.DateFormat) + " 00:00"
end := to.Format(config.DateFormat) + " 99:99"
if to.IsZero() {
end = "9999-99-99 99:99"
}
@ -88,15 +97,15 @@ func (s *Store) GetOrders(from, to time.Time) ([]models.Order, error) {
}
func (s *Store) UpdateOrderContents(tx *sql.Tx, newOrder models.Order) error {
query := "delete from ordered_cake where customer_order = ?;"
_, err := tx.Exec(query, newOrder.ID)
q := "delete from ordered_cake where customer_order = ?;"
_, err := tx.Exec(q, newOrder.ID)
if err != nil {
return err
}
query = "insert into ordered_cake(customer_order, cake, amount) values (?,?,?);"
q = "insert into ordered_cake(customer_order, cake, amount) values (?,?,?);"
for _, e := range newOrder.Cakes {
_, err := tx.Exec(query, newOrder.ID, e.ID, e.Amount)
_, err := tx.Exec(q, newOrder.ID, e.ID, e.Amount)
if err != nil {
return err
}
@ -109,17 +118,17 @@ func (s *Store) UpdateOrder(newOrder models.Order) error {
if err != nil {
return err
}
query := "update customer_order set name = ?, surname = ?, phone = ?, location = ?, order_date = ?, delivery_date = ?, status = ?, paid = ? where id = ?;"
q := "update customer_order set name = ?, surname = ?, phone = ?, location = ?, order_date = ?, delivery_date = ?, status = ?, paid = ? where id = ?;"
accepted := newOrder.Accepted.Format("2006-01-02 15:04")
date := newOrder.Date.Format("2006-01-02 15:04")
accepted := newOrder.Accepted.Format(config.DateTimeFormat)
date := newOrder.Date.Format(config.DateTimeFormat)
tx, err := s.db.Begin()
if err != nil {
return err
}
_, err = tx.Exec(query, newOrder.Name, newOrder.Surname, newOrder.Phone, newOrder.Location, accepted, date, newOrder.Status, newOrder.Paid, newOrder.ID)
_, err = tx.Exec(q, newOrder.Name, newOrder.Surname, newOrder.Phone, newOrder.Location, accepted, date, newOrder.Status, newOrder.Paid, newOrder.ID)
if err != nil {
_ = tx.Rollback()
return err
@ -132,6 +141,7 @@ func (s *Store) UpdateOrder(newOrder models.Order) error {
}
err = tx.Commit()
log.Printf("UPDATE order id=%d name=%q status=%q", newOrder.ID, newOrder.Name, newOrder.Status)
return nil
}
@ -139,16 +149,16 @@ func (s *Store) SaveOrder(newOrder models.Order) (int, error) {
if newOrder.ID != 0 {
return newOrder.ID, s.UpdateOrder(newOrder)
}
query := "insert into customer_order(name, surname, phone, location, order_date, delivery_date, status, paid) values (?, ?, ?, ?, ?, ?, ?, ?);"
q := "insert into customer_order(name, surname, phone, location, order_date, delivery_date, status, paid) values (?, ?, ?, ?, ?, ?, ?, ?);"
tx, err := s.db.Begin()
if err != nil {
return 0, err
}
accepted := newOrder.Accepted.Format("2006-01-02 15:04")
date := newOrder.Date.Format("2006-01-02 15:04")
result, err := tx.Exec(query, newOrder.Name, newOrder.Surname, newOrder.Phone, newOrder.Location, accepted, date, newOrder.Status, newOrder.Paid)
accepted := newOrder.Accepted.Format(config.DateTimeFormat)
date := newOrder.Date.Format(config.DateTimeFormat)
result, err := tx.Exec(q, newOrder.Name, newOrder.Surname, newOrder.Phone, newOrder.Location, accepted, date, newOrder.Status, newOrder.Paid)
if err != nil {
_ = tx.Rollback()
return 0, err
@ -157,16 +167,17 @@ func (s *Store) SaveOrder(newOrder models.Order) (int, error) {
id, err := result.LastInsertId()
if err != nil {
_ = tx.Rollback()
return newOrder.ID, err
return 0, err
}
newOrder.ID = int(id)
err = s.UpdateOrderContents(tx, newOrder)
if err != nil {
_ = tx.Rollback()
return newOrder.ID, err
return 0, err
}
err = tx.Commit()
log.Printf("INSERT order id=%d name=%q status=%q", newOrder.ID, newOrder.Name, newOrder.Status)
return newOrder.ID, err
}

7
store/store.go
View file

@ -4,13 +4,11 @@ import (
"database/sql"
"log"
"git.bronku.xyz/bronku/cake-order-tracker/models"
_ "github.com/mattn/go-sqlite3"
)
type Store struct {
db *sql.DB
cakes []models.Cake
}
func OpenStore(filename string) *Store {
@ -23,11 +21,6 @@ func OpenStore(filename string) *Store {
}
out.loadMigrations()
out.cakes, err = out.loadCakes()
log.Println(out.cakes)
if err != nil {
log.Fatal(err)
}
return &out
}

8
store/store_test.go
View file

@ -1,6 +1,7 @@
package store
import (
"slices"
"testing"
"time"
@ -284,10 +285,5 @@ mainLoop:
}
}
}
for _, e := range matched {
if e == false {
return false
}
}
return true
return !slices.Contains(matched, false)
}