code simplification

models/data.go

@@ -1,7 +1,7 @@
 package models
 
 import (
-	"fmt"
+	"strings"
 	"time"
 )
 
@@ -49,15 +49,7 @@ func (s SpecialCake) Detail() string {
 	if len(parts) == 0 {
 		return ""
 	}
-	return fmt.Sprintf("(%s)", joinParts(parts))
+	return "(" + strings.Join(parts, ", ") + ")"
-}
-
-func joinParts(parts []string) string {
-	out := parts[0]
-	for i := 1; i < len(parts); i++ {
-		out += ", " + parts[i]
-	}
-	return out
 }
 
 type Order struct {

server/get.go

@@ -13,7 +13,7 @@ import (
 	"git.bronku.xyz/bronku/cake-order-tracker/server/templates"
 )
 
-func weekInterval(t time.Time) (firstDay, lastDay time.Time) {
+func weekInterval(t time.Time) (time.Time, time.Time) {
 	monday := t.AddDate(0, 0, -((int(t.Weekday()) + 6) % 7))
 	sunday := monday.AddDate(0, 0, 6)
 	return monday, sunday
@@ -154,14 +154,6 @@ func (h *Server) blocked(r *http.Request) (templ.Component, int, error) {
 	return templates.BlockedPage(dates), http.StatusOK, nil
 }
 
-func loadBlockedDates(h *Server) []models.BlockedDate {
-	dates, err := h.s.GetBlockedDates()
-	if err != nil {
-		return nil
-	}
-	return dates
-}
-
 func (h *Server) order(r *http.Request) (templ.Component, int, error) {
 	catalogue, err := h.s.GetCakes()
 	if err != nil {
@@ -171,7 +163,10 @@ func (h *Server) order(r *http.Request) (templ.Component, int, error) {
 	if err != nil {
 		return nil, http.StatusInternalServerError, err
 	}
-	blockedDates := loadBlockedDates(h)
+	blockedDates, err := h.s.GetBlockedDates()
+	if err != nil {
+		return nil, http.StatusInternalServerError, err
+	}
 
 	url := strings.Split(r.URL.Path, "/")
 	if len(url) < 3 || url[2] == "" {

server/templates/helpers.go

@@ -22,21 +22,6 @@ func OrderTitle(order models.Order) string {
 	return "Nowe zamówienie"
 }
 
-func specialCakeDetail(sc models.SpecialCake) string {
-	return sc.Detail()
-}
-
-func cakeItemsDesc(cakes []models.Cake) string {
-	desc := ""
-	for i, c := range cakes {
-		if i > 0 {
-			desc += ", "
-		}
-		desc += c.Name + " (x" + strconv.Itoa(c.Amount) + ")"
-	}
-	return desc
-}
-
 func cakeHasTag(tags []models.Tag, id int) bool {
 	for _, t := range tags {
 		if t.ID == id {
@@ -63,7 +48,13 @@ func tagNames(tags []models.Tag) string {
 }
 
 func orderItemsDesc(order models.Order) string {
-	desc := cakeItemsDesc(order.Cakes)
+	desc := ""
+	for i, c := range order.Cakes {
+		if i > 0 {
+			desc += ", "
+		}
+		desc += c.Name + " (x" + strconv.Itoa(c.Amount) + ")"
+	}
 	for _, s := range order.SpecialCakes {
 		if desc != "" {
 			desc += ", "

server/templates/order.templ

@@ -142,7 +142,7 @@ templ OrderForm(order models.Order, catalogue []models.Cake, allTags []models.Ta
 						<li data-special-id={ strconv.Itoa(s.ID) }>
 							<div class="basket-item-body">
 								<div class="name">{ s.Name }</div>
-								<div class="detail">{ specialCakeDetail(s) }</div>
+								<div class="detail">{ s.Detail() }</div>
 								if len(s.Tags) > 0 {
 									<div class="basket-item-tags">
 										for _, t := range s.Tags {

store/cake.go

@@ -45,19 +45,19 @@ func (s *Store) GetCakes() ([]models.Cake, error) {
 	return out, rows.Err()
 }
 
-func (s *Store) SaveCake(newCake models.Cake) (int, error) {
+func (s *Store) SaveCake(cake models.Cake) (int, error) {
-	if newCake.ID != 0 {
+	if cake.ID != 0 {
 		q := "update cake set name = ?, price = ? where id = ?;"
-		_, err := s.db.Exec(q, newCake.Name, newCake.Price, newCake.ID)
+		_, err := s.db.Exec(q, cake.Name, cake.Price, cake.ID)
 		if err != nil {
 			return 0, err
 		}
-		log.Printf("UPDATE cake id=%d name=%q price=%d", newCake.ID, newCake.Name, newCake.Price)
+		log.Printf("UPDATE cake id=%d name=%q price=%d", cake.ID, cake.Name, cake.Price)
-		return newCake.ID, s.SaveCakeTags(newCake.ID, tagIDs(newCake.Tags))
+		return cake.ID, s.SaveCakeTags(cake.ID, tagIDs(cake.Tags))
 	}
 
 	q := "insert into cake(name, price) values (?, ?);"
-	result, err := s.db.Exec(q, newCake.Name, newCake.Price)
+	result, err := s.db.Exec(q, cake.Name, cake.Price)
 	if err != nil {
 		return 0, err
 	}
@@ -66,9 +66,9 @@ func (s *Store) SaveCake(newCake models.Cake) (int, error) {
 	if err != nil {
 		return 0, err
 	}
-	newCake.ID = int(id)
+	cake.ID = int(id)
-	log.Printf("INSERT cake id=%d name=%q price=%d", newCake.ID, newCake.Name, newCake.Price)
+	log.Printf("INSERT cake id=%d name=%q price=%d", cake.ID, cake.Name, cake.Price)
-	return newCake.ID, s.SaveCakeTags(newCake.ID, tagIDs(newCake.Tags))
+	return cake.ID, s.SaveCakeTags(cake.ID, tagIDs(cake.Tags))
 }
 
 func tagIDs(tags []models.Tag) []int {

store/order.go

@@ -142,59 +142,59 @@ func (s *Store) GetCakeCounts(from, to time.Time) ([]models.CakeCount, error) {
 	return out, rows.Err()
 }
 
-func (s *Store) UpdateOrderContents(tx *sql.Tx, newOrder models.Order) error {
+func (s *Store) UpdateOrderContents(tx *sql.Tx, order models.Order) error {
 	q := "delete from ordered_cake where customer_order = ?;"
-	_, err := tx.Exec(q, newOrder.ID)
+	_, err := tx.Exec(q, order.ID)
 	if err != nil {
 		return err
 	}
 
 	q = "insert into ordered_cake(customer_order, cake, amount) values (?,?,?);"
-	for _, e := range newOrder.Cakes {
+	for _, e := range order.Cakes {
-		_, err := tx.Exec(q, newOrder.ID, e.ID, e.Amount)
+		_, err := tx.Exec(q, order.ID, e.ID, e.Amount)
 		if err != nil {
 			return err
 		}
 	}
 
-	return s.SaveSpecialCakes(tx, newOrder.ID, newOrder.SpecialCakes)
+	return s.SaveSpecialCakes(tx, order.ID, order.SpecialCakes)
 }
 
-func (s *Store) UpdateOrder(newOrder models.Order) error {
+func (s *Store) UpdateOrder(order models.Order) error {
-	_, err := s.GetOrder(newOrder.ID)
+	_, err := s.GetOrder(order.ID)
 	if err != nil {
 		return err
 	}
 	q := "update customer_order set name = ?, surname = ?, phone = ?, location = ?, order_date = ?, delivery_date = ?, status = ?, paid = ? where id = ?;"
 
-	accepted := newOrder.Accepted.Format(config.DateTimeFormat)
+	accepted := order.Accepted.Format(config.DateTimeFormat)
-	date := newOrder.Date.Format(config.DateTimeFormat)
+	date := order.Date.Format(config.DateTimeFormat)
 
 	tx, err := s.db.Begin()
 	if err != nil {
 		return err
 	}
 
-	_, err = tx.Exec(q, newOrder.Name, newOrder.Surname, newOrder.Phone, newOrder.Location, accepted, date, newOrder.Status, newOrder.Paid, newOrder.ID)
+	_, err = tx.Exec(q, order.Name, order.Surname, order.Phone, order.Location, accepted, date, order.Status, order.Paid, order.ID)
 	if err != nil {
 		_ = tx.Rollback()
 		return err
 	}
 
-	err = s.UpdateOrderContents(tx, newOrder)
+	err = s.UpdateOrderContents(tx, order)
 	if err != nil {
 		_ = tx.Rollback()
 		return err
 	}
 
 	err = tx.Commit()
-	log.Printf("UPDATE order id=%d name=%q status=%q", newOrder.ID, newOrder.Name, newOrder.Status)
+	log.Printf("UPDATE order id=%d name=%q status=%q", order.ID, order.Name, order.Status)
 	return nil
 }
 
-func (s *Store) SaveOrder(newOrder models.Order) (int, error) {
+func (s *Store) SaveOrder(order models.Order) (int, error) {
-	if newOrder.ID != 0 {
+	if order.ID != 0 {
-		return newOrder.ID, s.UpdateOrder(newOrder)
+		return order.ID, s.UpdateOrder(order)
 	}
 	q := "insert into customer_order(name, surname, phone, location, order_date, delivery_date, status, paid) values (?, ?, ?, ?, ?, ?, ?, ?);"
 
@@ -203,9 +203,9 @@ func (s *Store) SaveOrder(newOrder models.Order) (int, error) {
 		return 0, err
 	}
 
-	accepted := newOrder.Accepted.Format(config.DateTimeFormat)
+	accepted := order.Accepted.Format(config.DateTimeFormat)
-	date := newOrder.Date.Format(config.DateTimeFormat)
+	date := order.Date.Format(config.DateTimeFormat)
-	result, err := tx.Exec(q, newOrder.Name, newOrder.Surname, newOrder.Phone, newOrder.Location, accepted, date, newOrder.Status, newOrder.Paid)
+	result, err := tx.Exec(q, order.Name, order.Surname, order.Phone, order.Location, accepted, date, order.Status, order.Paid)
 	if err != nil {
 		_ = tx.Rollback()
 		return 0, err
@@ -216,15 +216,15 @@ func (s *Store) SaveOrder(newOrder models.Order) (int, error) {
 		_ = tx.Rollback()
 		return 0, err
 	}
-	newOrder.ID = int(id)
+	order.ID = int(id)
 
-	err = s.UpdateOrderContents(tx, newOrder)
+	err = s.UpdateOrderContents(tx, order)
 	if err != nil {
 		_ = tx.Rollback()
 		return 0, err
 	}
 
 	err = tx.Commit()
-	log.Printf("INSERT order id=%d name=%q status=%q", newOrder.ID, newOrder.Name, newOrder.Status)
+	log.Printf("INSERT order id=%d name=%q status=%q", order.ID, order.Name, order.Status)
-	return newOrder.ID, err
+	return order.ID, err
 }

store/special_cake.go

@@ -85,11 +85,7 @@ func (s *Store) SaveSpecialCakes(tx *sql.Tx, orderID int, cakes []models.Special
 		if err != nil {
 			return err
 		}
-		tagIDs := make([]int, len(sc.Tags))
+		if err := s.saveSpecialCakeTags(tx, int(id), tagIDs(sc.Tags)); err != nil {
-		for i, t := range sc.Tags {
-			tagIDs[i] = t.ID
-		}
-		if err := s.saveSpecialCakeTags(tx, int(id), tagIDs); err != nil {
 			return err
 		}
 	}