From 992bb04816699f21c60168a46aa3d7e946e06657 Mon Sep 17 00:00:00 2001 From: efrilm Date: Sun, 6 Sep 2026 17:14:42 +0700 Subject: [PATCH] feat(order): support weight-based products MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Products like fish are sold per weighing (4.2 ons, 5.6 ons), which the order line could not represent: quantity is INTEGER and prices are always computed as quantity * unit_price. Model one weighing as one order line. quantity stays INTEGER and keeps meaning "how many items"; the measured amount goes into a new nullable order_items.weight, and the line is priced weight * unit_price. Two weighings of the same product are two lines, never merged into one. Keeping quantity integral avoids float comparisons in void, refund and split bill, where accumulated rounding error would silently misbehave — "1.4 + 1.4 + 1.4" is not 4.2 in float64, which would leave a fully paid split-bill item marked unpaid. BillableQuantity() is now the single place that decides between weight and count; every price and cost calculation goes through it. Missing one would bill a 4.2 ons fish as a single ons — wrong money, no error. Two database constraints back the design: a weighed line always carries a positive weight, and its quantity is pinned to 1. The latter also makes void all-or-nothing for weighed lines, so the row-splitting branch can never produce a zero-weight remainder row. Also wires product.unit_id through the API, which was previously not settable at all, and corrects the misleading comment on the request's unit_price field — that value has never been used; price always comes from the database. Design notes and the audit of every price multiplication site are in docs/rfc-weight-based-products.md. Co-Authored-By: Claude Opus 5 (1M context) --- docs/rfc-weight-based-products.md | 362 ++++++++++++++++++ internal/constants/product.go | 17 + internal/contract/analytics_contract.go | 2 + internal/contract/order_contract.go | 62 +-- internal/contract/product_contract.go | 6 + internal/contract/self_order_contract.go | 1 + internal/entities/analytics.go | 1 + internal/entities/order_item.go | 55 ++- internal/entities/order_item_test.go | 104 +++++ internal/entities/product.go | 1 + internal/handler/self_order_handler.go | 1 + internal/mappers/order_mapper.go | 11 + internal/mappers/product_mapper.go | 18 + internal/models/analytics.go | 2 + internal/models/order.go | 9 +- internal/models/product.go | 4 + internal/processor/analytics_processor.go | 2 + internal/processor/order_processor.go | 85 ++-- internal/processor/order_weight_test.go | 106 +++++ internal/processor/split_bill_processor.go | 6 +- internal/repository/analytics_repository.go | 7 +- internal/repository/order_item_repository.go | 21 +- internal/repository/order_repository.go | 3 + internal/service/report_service.go | 12 + internal/transformer/analytics_transformer.go | 3 + internal/transformer/order_transformer.go | 8 + internal/transformer/product_transformer.go | 11 + .../000089_add_weight_to_order_items.down.sql | 15 + .../000089_add_weight_to_order_items.up.sql | 30 ++ templates/daily_transaction.html | 2 + 30 files changed, 901 insertions(+), 66 deletions(-) create mode 100644 docs/rfc-weight-based-products.md create mode 100644 internal/constants/product.go create mode 100644 internal/entities/order_item_test.go create mode 100644 internal/processor/order_weight_test.go create mode 100644 migrations/000089_add_weight_to_order_items.down.sql create mode 100644 migrations/000089_add_weight_to_order_items.up.sql diff --git a/docs/rfc-weight-based-products.md b/docs/rfc-weight-based-products.md new file mode 100644 index 0000000..2a0f299 --- /dev/null +++ b/docs/rfc-weight-based-products.md @@ -0,0 +1,362 @@ +# RFC: Produk Timbangan (Weight-Based Products) + +**Status:** Diimplementasikan (migrasi `000089`) +**Tanggal:** 2026-09-05, diperbarui 2026-09-06 +**Scope:** Product, Order, Void/Refund, Report +**Out of scope:** Inventory / pengurangan stok otomatis (lihat §8) + +--- + +## 1. Masalah + +Sistem mengasumsikan setiap produk dijual dalam satuan diskrit. `order_items.quantity` +bertipe `INTEGER` dengan `CHECK (quantity > 0)`, dan harga dihitung +`quantity × unit_price` di seluruh jalur order, void, refund, dan split bill. + +Produk seperti Ikan Tude dijual per timbangan. Pelanggan memesan Ikan Tude 4,2 ons, +lalu memesan Ikan Tude lagi 5,6 ons. Keduanya adalah **dua ikan berbeda yang ditimbang +terpisah** — bukan satu baris berisi 9,8. + +Angka 4,2 itu **berat**, bukan cacah. Sistem belum punya tempat untuk menyimpannya. + +> **Catatan satuan.** RFC ini tidak mengasumsikan satuan tertentu. Satuan produk +> ditentukan `products.unit_id` yang merujuk tabel `units` — bisa ons, kg, gram, atau +> apa pun yang didefinisikan organisasi. Contoh memakai **ons** karena itu kasus yang +> sedang dikerjakan; tidak ada bagian desain ini yang bergantung padanya. + +--- + +## 2. Keputusan Inti + +**Satu penimbangan = satu baris `order_items`.** + +| | Baris 1 | Baris 2 | +|---|---|---| +| Ikan Tude 4,2 ons | `quantity = 1`, `weight = 4.2` | | +| Ikan Tude 5,6 ons | | `quantity = 1`, `weight = 5.6` | + +`quantity` tetap `INTEGER` dan tetap berarti "berapa banyak barang". Berat masuk ke +kolom baru. Dua baris tidak pernah digabung menjadi `9.8`, karena keduanya memang dua +ikan yang berbeda. + +### Kenapa bukan `quantity = 4.2` + +Alternatif yang sempat dipertimbangkan adalah mengubah `quantity` menjadi +`DECIMAL(12,3)`. Model itu ditolak karena tiga alasan: + +1. **Menghapus jejak barang.** `4.2` dan `5.6` yang digabung jadi `9.8` kehilangan + informasi bahwa ada dua ikan. Tidak bisa direkonstruksi. +2. **Merusak agregasi lintas produk.** `SUM(quantity)` untuk laporan + "total item terjual" akan menjumlahkan ons dengan porsi — angka tanpa arti, yang + bahkan berubah nilainya bila satuan produk diganti dari ons ke kg tanpa ada apa pun + yang berubah di dunia nyata. +3. **Membawa masalah presisi float ke seluruh sistem.** Perbandingan quantity dipakai + di void, refund, dan split bill. Dengan float, `1,4 + 1,4 + 1,4` tidak sama dengan + `4,2` — split bill "bagi rata bertiga" akan gagal menandai item lunas meski uang + sudah diterima penuh. Semua itu tidak terjadi bila `quantity` tetap integer. + +Konsekuensi langsung dari keputusan ini: **tidak diperlukan helper perbandingan +epsilon.** Berat tidak pernah dibandingkan, hanya dikalikan. + +--- + +## 3. Prinsip + +**P1 — Baris transaksi adalah snapshot yang beku.** +`order_items` sudah menyimpan `unit_price` dan `unit_cost` sebagai salinan, bukan join +ke `products`. Satuan mendapat perlakuan sama: mengubah master data tidak boleh +mengubah arti transaksi yang sudah terjadi. + +**P2 — Perhitungan harga baris hanya ada di satu tempat.** +Setelah RFC ini ada dua rumus (`quantity × harga` dan `weight × harga`). Tidak boleh +ada perkalian harga yang tersebar; semuanya memanggil satu fungsi. + +**P3 — Harga tetap otoritas backend.** +Klien tidak pernah mengirim harga. Backend membacanya dari `products` / +`product_outlet_prices` seperti sekarang. + +**P4 — Berat boleh dijumlahkan dalam satu produk, tidak boleh antar produk.** +`SUM(weight)` untuk satu produk bermakna ("terjual 47,3 ons"). Lintas produk dengan +satuan berbeda tidak bermakna. + +--- + +## 4. Perubahan Skema + +```sql +-- Products: cara jual +ALTER TABLE products + ADD COLUMN sell_by VARCHAR(20) NOT NULL DEFAULT 'unit' + CHECK (sell_by IN ('unit', 'weight')); + +-- Order items: berat + snapshot satuan +ALTER TABLE order_items + ADD COLUMN weight DECIMAL(12,3), + ADD COLUMN unit_id UUID REFERENCES units(id) ON DELETE RESTRICT; + +ALTER TABLE order_items + ADD CONSTRAINT chk_order_items_weight_positive + CHECK (weight IS NULL OR weight > 0), + ADD CONSTRAINT chk_order_items_weight_single_line + CHECK (weight IS NULL OR quantity = 1); +``` + +**Catatan:** + +- `weight` **nullable**. `NULL` berarti produk satuan biasa — seluruh data lama valid + tanpa backfill, dan perilakunya tidak berubah sama sekali. +- `chk_order_items_weight_single_line` menegakkan keputusan §2 di level database: + baris berbobot selalu `quantity = 1`. Ini yang membuat `BillableQuantity()` tidak + ambigu dan membuat void otomatis bersifat utuh (§6). +- `quantity` **tidak berubah tipe**. `CHECK (quantity > 0)` yang sudah ada tetap + berlaku. +- `DECIMAL(12,3)` konsisten dengan `inventory_movements.quantity` yang sudah memakai + presisi sama. +- Tidak ada `weighed_unit`. Karena satu baris memang satu barang, "ikan curah" dan + "ikan per ekor" berperilaku identik — pembedaan itu tidak punya konsekuensi. + +--- + +## 5. Perhitungan Harga + +Satu-satunya tempat yang boleh mengalikan harga (P2): + +```go +// BillableQuantity mengembalikan pengali harga untuk baris ini: +// berat bila produk dijual per timbangan, jumlah bila dijual per satuan. +// Baris berbobot dijamin quantity = 1 oleh constraint DB. +func (oi *OrderItem) BillableQuantity() float64 { + if oi.Weight != nil { + return *oi.Weight + } + return float64(oi.Quantity) +} + +func (oi *OrderItem) CalculateTotalPrice() { + oi.TotalPrice = RoundMoney(oi.BillableQuantity() * oi.UnitPrice) +} + +func (oi *OrderItem) CalculateTotalCost() { + oi.TotalCost = RoundMoney(oi.BillableQuantity() * oi.UnitCost) +} +``` + +`unit_price` tetap berarti **harga per satu satuan produk** (per ons). Tidak ada faktor +konversi yang menyelinap ke perhitungan uang. + +### Titik yang harus diganti + +Ini bagian paling berisiko dari RFC. Setiap perkalian harga yang terlewat akan +menghitung `1 × harga_per_ons` — ikan 4,2 ons ditagih seharga 1 ons. **Salah uang, +bukan salah tampilan**, dan tidak memicu error apa pun. + +| Lokasi | Sekarang | +|---|---| +| `processor/order_processor.go:197-198` | buat order | +| `processor/order_processor.go:330-331` | tambah item ke order | +| `processor/order_processor.go:605-606` | jumlah & HPP yang di-void | +| `processor/order_processor.go:723` | jumlah refund | +| `processor/split_bill_processor.go:143` | hitung jumlah split | +| `processor/split_bill_processor.go:189` | catat pembayaran | +| `processor/split_bill_processor.go:231` | metadata pembayaran | +| `repository/order_item_repository.go:113` | jumlah void penuh | + +Implementasi menemukan **lima titik tambahan** di luar daftar di atas, semuanya di jalur +inventory movement dan resep bahan yang tidak terlihat saat RFC ini ditulis: + +| Lokasi | Status | +|---|---| +| `order_processor.go:1056` `createInventoryMovement` | mati (0 pemanggil), tetap diperbaiki | +| `order_processor.go:1354` `prepareProductInventoryMovement` | **hidup** | +| `order_processor.go:1420` `prepareIngredientRecipeItem` | **hidup** | +| `order_processor.go:1518` `prepareRefundProductInventoryMovement` | mati (0 pemanggil), tetap diperbaiki | +| `order_processor.go:1584` `prepareRefundedIngredientRecipeItem` | **hidup** | + +Tiga yang hidup penting: tanpa perbaikan, konsumsi bahan untuk ikan 4,2 ons akan +dihitung sebagai 1 satuan resep. + +### Verifikasi + +```bash +grep -rn "Quantity) \* \|Quantity \* " --include=*.go internal/ \ + | grep -iE "price|cost" | grep -v BillableQuantity | grep -v totalIngredientQuantity +``` + +Hasilnya **tidak kosong** — tersisa tujuh baris, semuanya sudah diperiksa dan aman: + +- `mappers/inventory_movement_mapper.go:129` dan + `processor/inventory_movement_processor.go:69` — penyesuaian stok manual, bukan + baris order. +- `repository/order_item_repository.go:144,146,147,165,166` — cabang void sebagian, + yang baris berbobot tidak pernah jangkau karena dijaga `orderItem.IsWeighed()`. + +Bila daftar ini bertambah di kemudian hari, baris barunya harus diperiksa satu per satu. + +--- + +## 6. Void, Refund, Split Bill + +**Tidak ada perubahan logika.** Ini konsekuensi menyenangkan dari `quantity` yang tetap +integer. + +**Void.** `VoidOrderItem` (`repository/order_item_repository.go:104`) bercabang pada +`voidQuantity >= orderItem.Quantity`. Untuk baris berbobot, `quantity` dijamin `1` dan +`voidQuantity` minimal `1`, sehingga **selalu** masuk cabang void penuh. Cabang +pemecahan baris tidak pernah tersentuh, sehingga tidak mungkin lahir baris sisa +berbobot nol. Yang berubah hanya perhitungan `voidedAmount` di baris 113 (§5). + +**Refund.** Sama — refund baris berbobot bersifat utuh. Hanya `refundAmount` di +`order_processor.go:723` yang perlu memakai `BillableQuantity()`. + +**Split bill.** `payment_order_items.quantity` tetap `INTEGER`. Untuk baris berbobot +nilainya `0` atau `1` — bayar penuh atau tidak sama sekali. Seluruh perbandingan di +`split_bill_processor.go` tetap aritmatika bilangan bulat, sehingga masalah presisi +float tidak pernah muncul. Hanya perhitungan `itemAmount` (baris 143 dan 189) yang +berubah. + +**Batasan yang diterima:** refund atau void **sebagian berat** (mengembalikan 1 ons +dari baris 4,2 ons) tidak didukung. Untuk barang yang sudah ditimbang dan diserahkan, +koreksi sebagian pada praktiknya berarti salah timbang — yang penanganan benarnya +adalah void baris itu lalu input ulang, bukan mengubah berat baris yang sudah tercatat. +Ini menjaga jejak audit tetap jujur. + +--- + +## 7. Validasi & Tampilan + +### 7.1 Aturan validasi + +Divalidasi di processor saat membuat / menambah item, di mana produk sudah dimuat: + +| `products.sell_by` | Aturan | +|---|---| +| `unit` | `weight` harus kosong. Bila dikirim → tolak. | +| `weight` | `weight` wajib ada dan `> 0`. `quantity` dipaksa `1`. | + +`unit_id` di `order_items` diisi dari `products.unit_id` saat baris dibuat (P1) — +bukan dibaca lewat join saat ditampilkan. + +Berat dibulatkan ke 3 desimal saat masuk, agar nilai tersimpan selalu sama dengan +nilai yang divalidasi. + +### 7.2 Tampilan + +`templates/daily_transaction.html:539` mencetak `{{$item.Quantity}}`. Untuk baris +berbobot ini akan menampilkan `1`, bukan `4,2 ons`. Perlu bercabang pada `weight`. + +Response API menambah `weight` dan `unit` pada item, agar frontend dan struk dapat +menampilkan `4,2 ons × Rp 4.500` alih-alih `1 × Rp 4.500`. + +--- + +## 8. Report + +**Tidak ada perubahan yang wajib.** Karena `quantity` tetap integer dan tetap berarti +"berapa banyak barang": + +- `SUM(oi.quantity)` sebagai `total_items` tetap bermakna dan tetap konsisten lintas + produk — 2 ikan tetap dihitung 2, bukan 9,8 ons. +- `QuantitySold` tetap `int64`. Tidak ada pemotongan pecahan. +- `average_price = SUM(total_price) / SUM(quantity)` menjadi "rata-rata harga per + ekor", yang tetap merupakan angka bermakna. + +**Tambahan opsional** — melaporkan berat terjual, hanya pada laporan **per produk** +(P4): + +```sql +COALESCE(SUM(oi.weight), 0) AS weight_sold +``` + +Tidak boleh dipakai pada agregat lintas produk, karena akan menjumlahkan satuan yang +berbeda. + +--- + +## 9. Di Luar Scope + +**Pengurangan stok otomatis.** `adjustInventoryWithTransaction` +(`order_processor.go:1177`) dan `adjustIngredientInventoryWithTransaction` +(`order_processor.go:920`) terdefinisi tetapi **tidak pernah dipanggil dari mana pun** — +sudah diverifikasi se-repo. Endpoint CRUD inventory berfungsi; pengurangan stok saat +penjualan tidak tersambung. + +Konsekuensi untuk RFC ini: `inventory.quantity` yang masih `int` tidak menghalangi +apa pun. + +Catatan untuk nanti bila jalur stok disambungkan: + +- Stok produk timbangan harus berkurang sebesar `weight`, bukan `quantity` — kalau + tidak, menjual ikan 4,2 ons hanya mengurangi stok sebanyak 1. +- `inventory.quantity` perlu menjadi `DECIMAL(12,3)` lebih dulu. Biayanya hampir nol + sekarang (3 call site, tanpa data historis); jauh lebih mahal setelah berjalan. +- `order_processor.go:946` berisi `deltaInt := int(delta)` yang memotong pecahan. + Kode ini mati, jadi bukan kebocoran aktif — tetapi bila disambungkan tanpa + diperbaiki, konsumsi bahan di bawah 1 unit akan hilang diam-diam. + +Kedua fungsi mati itu sebaiknya **dihapus atau disambungkan**, jangan dibiarkan +menggantung — komentar di dalamnya ditulis seolah-olah aktif. + +--- + +## 10. Temuan Sampingan: `unit_price` pada request diabaikan + +`CreateOrderItemRequest.UnitPrice` (`contract/order_contract.go:46`) berkomentar +*"Optional, will use database price if not provided"*. Kenyataannya field ini **tidak +pernah dipakai** — satu-satunya yang menyentuhnya adalah validasi `< 0` di +`service/order_service.go:431` dan `:474`. Processor selalu membaca harga dari +`products` / `product_outlet_prices`. + +Perilaku sekarang sudah benar dan sesuai P3. Yang salah hanya komentarnya, yang +menyiratkan klien bisa mengirim harga. Sebaiknya field itu **dihapus** dari contract, +atau komentarnya dikoreksi menjadi keterangan bahwa harga selalu diambil dari database. + +Dibiarkan seperti sekarang, ini mengundang frontend mengirim harga dan menyangka +berhasil, padahal diabaikan diam-diam. + +--- + +## 11. Urutan Implementasi + +1. **Migrasi skema** (§4). Aman: semua kolom nullable atau ber-default, data lama + tidak tersentuh. +2. **`BillableQuantity()` + `CalculateTotalPrice()` / `CalculateTotalCost()`** (§5). +3. **Ganti 8 titik perkalian harga** (§5) lalu jalankan dua `grep` verifikasi. +4. **Field kontrak**: `weight` pada request order & self-order, `weight` + `unit` pada + response. +5. **Validasi `sell_by`** (§7.1). +6. **Template & tampilan struk** (§7.2). +7. *(Opsional)* `weight_sold` pada laporan per produk (§8). + +Langkah 1-4 membuat produk timbangan dapat dijual dengan harga yang benar. Langkah 5 +mencegah data tidak konsisten masuk. Langkah 6 membuat struk terbaca benar. + +--- + +## 12. Risiko + +| Risiko | Dampak | Mitigasi | +|---|---|---| +| Satu titik perkalian harga terlewat | Ikan 4,2 ons ditagih seharga 1 ons — salah uang, tanpa error | Dua `grep` verifikasi di §5; uji satu order timbangan lewat setiap jalur (create, tambah item, void, refund, split bill) | +| `weight` dikirim untuk produk `unit` | Harga baris salah total | Validasi §7.1 + constraint DB | +| `quantity > 1` pada baris berbobot | `BillableQuantity()` ambigu | Dicegah `chk_order_items_weight_single_line` di level DB | +| Klien lama tidak mengirim `weight` | Produk timbangan ditagih 1 satuan | Validasi §7.1 menolak, bukan mendiamkan | +| Struk menampilkan `1` alih-alih `4,2 ons` | Pelanggan bingung, kasir kehilangan kepercayaan | §7.2 | + +--- + +## 13. Pertanyaan Terbuka + +1. **Pembulatan uang — diputuskan sementara, perlu konfirmasi.** `RoundMoney` + membulatkan ke **2 desimal**, mengikuti presisi kolom `decimal(10,2)` yang sudah + dipakai semua nilai uang. Jadi `4,237 ons × Rp 4.500` tersimpan `Rp 19.066,50`. + + Ini pilihan paling tidak mengejutkan dan konsisten dengan data lama, tetapi **bukan** + pembulatan ke rupiah utuh. Bila kasir harus menerima uang dalam rupiah penuh (atau + kelipatan Rp 100/500), ubah `RoundMoney` di `entities/order_item.go` — satu tempat, + dan lakukan **sebelum** ada transaksi timbangan, karena setelahnya data lama dan + baru akan mengikuti aturan berbeda. +2. **Presisi input berat.** Apakah `4,237 ons` (resolusi 0,1 gram) valid, atau input + harus dibatasi ke kelipatan tertentu sesuai resolusi timbangan? Bila perlu dibatasi, + tambahkan `products.min_weight_increment`. +3. **Sumber angka timbangan** — kasir mengetik manual atau timbangan tersambung? Bila + tersambung, ada urusan tara dan pembacaan stabil yang berada di luar RFC ini. diff --git a/internal/constants/product.go b/internal/constants/product.go new file mode 100644 index 0000000..cb79eaf --- /dev/null +++ b/internal/constants/product.go @@ -0,0 +1,17 @@ +package constants + +// SellBy describes how a product's quantity is expressed on an order line. +type SellBy = string + +const ( + // SellByUnit is the default: the line counts discrete items (2 portions, 3 bottles). + SellByUnit SellBy = "unit" + // SellByWeight means the line carries a weighed amount. One weighing is one line, + // so quantity stays 1 and the measured value lives in order_items.weight. + SellByWeight SellBy = "weight" +) + +// IsValidSellBy reports whether s is a supported sell_by value. +func IsValidSellBy(s string) bool { + return s == SellByUnit || s == SellByWeight +} diff --git a/internal/contract/analytics_contract.go b/internal/contract/analytics_contract.go index 918be35..1d2045f 100644 --- a/internal/contract/analytics_contract.go +++ b/internal/contract/analytics_contract.go @@ -198,6 +198,7 @@ type ProductAnalyticsData struct { CategoryName string `json:"category_name"` CategoryOrder int `json:"category_order"` QuantitySold int64 `json:"quantity_sold"` + WeightSold float64 `json:"weight_sold"` Revenue float64 `json:"revenue"` AveragePrice float64 `json:"average_price"` OrderCount int64 `json:"order_count"` @@ -324,6 +325,7 @@ type ParentCategoryAnalyticsProductData struct { ProductSku string `json:"product_sku"` ProductPrice float64 `json:"product_price"` QuantitySold int64 `json:"quantity_sold"` + WeightSold float64 `json:"weight_sold"` Revenue float64 `json:"revenue"` AveragePrice float64 `json:"average_price"` OrderCount int64 `json:"order_count"` diff --git a/internal/contract/order_contract.go b/internal/contract/order_contract.go index 237874f..80ea44f 100644 --- a/internal/contract/order_contract.go +++ b/internal/contract/order_contract.go @@ -40,13 +40,16 @@ type UpdateOrderRequest struct { } type CreateOrderItemRequest struct { - ProductID uuid.UUID `json:"product_id" validate:"required"` - ProductVariantID *uuid.UUID `json:"product_variant_id,omitempty"` - Quantity int `json:"quantity" validate:"required,min=1"` - UnitPrice *float64 `json:"unit_price,omitempty" validate:"omitempty,min=0"` // Optional, will use database price if not provided - Modifiers []map[string]interface{} `json:"modifiers,omitempty"` - Notes *string `json:"notes,omitempty" validate:"omitempty,max=500"` - Metadata map[string]interface{} `json:"metadata,omitempty"` + ProductID uuid.UUID `json:"product_id" validate:"required"` + ProductVariantID *uuid.UUID `json:"product_variant_id,omitempty"` + Quantity int `json:"quantity" validate:"required,min=1"` + // Weight is required for products with sell_by = "weight" and must be absent otherwise. + // One weighing is one line, so quantity stays 1 and the line is priced weight * unit_price. + Weight *float64 `json:"weight,omitempty" validate:"omitempty,gt=0"` + UnitPrice *float64 `json:"unit_price,omitempty" validate:"omitempty,min=0"` // Ignored: price always comes from the database + Modifiers []map[string]interface{} `json:"modifiers,omitempty"` + Notes *string `json:"notes,omitempty" validate:"omitempty,max=500"` + Metadata map[string]interface{} `json:"metadata,omitempty"` } type UpdateOrderItemRequest struct { @@ -92,26 +95,31 @@ type OrderResponse struct { } type OrderItemResponse struct { - ID uuid.UUID `json:"id"` - OrderID uuid.UUID `json:"order_id"` - ProductID uuid.UUID `json:"product_id"` - ProductName string `json:"product_name"` - ProductVariantID *uuid.UUID `json:"product_variant_id"` - ProductVariantName *string `json:"product_variant_name,omitempty"` - CategoryID *uuid.UUID `json:"category_id,omitempty"` - CategoryName *string `json:"category_name,omitempty"` - Quantity int `json:"quantity"` - UnitPrice float64 `json:"unit_price"` - TotalPrice float64 `json:"total_price"` - Modifiers []map[string]interface{} `json:"modifiers"` - Notes *string `json:"notes,omitempty"` - Metadata map[string]interface{} `json:"metadata,omitempty"` - Status string `json:"status"` - CreatedAt time.Time `json:"created_at"` - UpdatedAt time.Time `json:"updated_at"` - PrinterType string `json:"printer_type"` - PrintToChecker bool `json:"print_to_checker"` - PaidQuantity int `json:"paid_quantity"` + ID uuid.UUID `json:"id"` + OrderID uuid.UUID `json:"order_id"` + ProductID uuid.UUID `json:"product_id"` + ProductName string `json:"product_name"` + ProductVariantID *uuid.UUID `json:"product_variant_id"` + ProductVariantName *string `json:"product_variant_name,omitempty"` + CategoryID *uuid.UUID `json:"category_id,omitempty"` + CategoryName *string `json:"category_name,omitempty"` + Quantity int `json:"quantity"` + // Weight is set only for products sold by weight; the line is priced weight * unit_price. + Weight *float64 `json:"weight,omitempty"` + UnitID *uuid.UUID `json:"unit_id,omitempty"` + UnitName *string `json:"unit_name,omitempty"` + UnitAbbreviation *string `json:"unit_abbreviation,omitempty"` + UnitPrice float64 `json:"unit_price"` + TotalPrice float64 `json:"total_price"` + Modifiers []map[string]interface{} `json:"modifiers"` + Notes *string `json:"notes,omitempty"` + Metadata map[string]interface{} `json:"metadata,omitempty"` + Status string `json:"status"` + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` + PrinterType string `json:"printer_type"` + PrintToChecker bool `json:"print_to_checker"` + PaidQuantity int `json:"paid_quantity"` } type ListOrdersQuery struct { diff --git a/internal/contract/product_contract.go b/internal/contract/product_contract.go index 61c9e90..90a90ea 100644 --- a/internal/contract/product_contract.go +++ b/internal/contract/product_contract.go @@ -18,6 +18,8 @@ type CreateProductRequest struct { ImageURL *string `json:"image_url,omitempty" validate:"omitempty,max=500"` PrinterType *string `json:"printer_type,omitempty" validate:"omitempty,max=50"` PrintToChecker *bool `json:"print_to_checker,omitempty"` + UnitID *uuid.UUID `json:"unit_id,omitempty"` + SellBy *string `json:"sell_by,omitempty" validate:"omitempty,oneof=unit weight"` Metadata map[string]interface{} `json:"metadata,omitempty"` IsActive *bool `json:"is_active,omitempty"` Variants []CreateProductVariantRequest `json:"variants,omitempty"` @@ -38,6 +40,8 @@ type UpdateProductRequest struct { ImageURL *string `json:"image_url,omitempty" validate:"omitempty,max=500"` PrinterType *string `json:"printer_type,omitempty" validate:"omitempty,max=50"` PrintToChecker *bool `json:"print_to_checker,omitempty"` + UnitID *uuid.UUID `json:"unit_id,omitempty"` + SellBy *string `json:"sell_by,omitempty" validate:"omitempty,oneof=unit weight"` Metadata map[string]interface{} `json:"metadata,omitempty"` IsActive *bool `json:"is_active,omitempty"` ReorderLevel *int `json:"reorder_level,omitempty" validate:"omitempty,min=0"` @@ -73,6 +77,8 @@ type ProductResponse struct { BusinessType string `json:"business_type"` ImageURL *string `json:"image_url"` PrinterType string `json:"printer_type"` + UnitID *uuid.UUID `json:"unit_id,omitempty"` + SellBy string `json:"sell_by"` PrintToChecker bool `json:"print_to_checker"` Metadata map[string]interface{} `json:"metadata"` IsActive bool `json:"is_active"` diff --git a/internal/contract/self_order_contract.go b/internal/contract/self_order_contract.go index 8a4e7fd..7e97c7c 100644 --- a/internal/contract/self_order_contract.go +++ b/internal/contract/self_order_contract.go @@ -58,6 +58,7 @@ type SelfOrderCreateOrderItem struct { ProductID uuid.UUID `json:"product_id" validate:"required"` ProductVariantID *uuid.UUID `json:"product_variant_id,omitempty"` Quantity int `json:"quantity" validate:"required,min=1"` + Weight *float64 `json:"weight,omitempty" validate:"omitempty,gt=0"` Notes *string `json:"notes,omitempty"` } diff --git a/internal/entities/analytics.go b/internal/entities/analytics.go index fc38018..87b9644 100644 --- a/internal/entities/analytics.go +++ b/internal/entities/analytics.go @@ -114,6 +114,7 @@ type ProductAnalytics struct { CategoryName string `json:"category_name"` CategoryOrder int `json:"category_order"` QuantitySold int64 `json:"quantity_sold"` + WeightSold float64 `json:"weight_sold"` Revenue float64 `json:"revenue"` AveragePrice float64 `json:"average_price"` OrderCount int64 `json:"order_count"` diff --git a/internal/entities/order_item.go b/internal/entities/order_item.go index 72cbf58..189bcc3 100644 --- a/internal/entities/order_item.go +++ b/internal/entities/order_item.go @@ -4,6 +4,7 @@ import ( "database/sql/driver" "encoding/json" "errors" + "math" "time" "github.com/google/uuid" @@ -47,6 +48,8 @@ type OrderItem struct { ProductID uuid.UUID `gorm:"type:uuid;not null;index" json:"product_id" validate:"required"` ProductVariantID *uuid.UUID `gorm:"type:uuid;index" json:"product_variant_id"` Quantity int `gorm:"not null" json:"quantity" validate:"required,min=1"` + Weight *float64 `gorm:"type:decimal(12,3)" json:"weight,omitempty"` + UnitID *uuid.UUID `gorm:"type:uuid;index" json:"unit_id,omitempty"` UnitPrice float64 `gorm:"type:decimal(10,2);not null" json:"unit_price" validate:"required,min=0"` TotalPrice float64 `gorm:"type:decimal(10,2);not null" json:"total_price" validate:"required,min=0"` UnitCost float64 `gorm:"type:decimal(10,2);default:0.00" json:"unit_cost"` @@ -68,6 +71,7 @@ type OrderItem struct { Order Order `gorm:"foreignKey:OrderID" json:"order,omitempty"` Product Product `gorm:"foreignKey:ProductID" json:"product,omitempty"` ProductVariant *ProductVariant `gorm:"foreignKey:ProductVariantID" json:"product_variant,omitempty"` + Unit *Unit `gorm:"foreignKey:UnitID" json:"unit,omitempty"` } func (oi *OrderItem) BeforeCreate(tx *gorm.DB) error { @@ -81,8 +85,57 @@ func (OrderItem) TableName() string { return "order_items" } +// IsWeighed reports whether this line was sold by weight rather than by count. +func (oi *OrderItem) IsWeighed() bool { + return oi.Weight != nil +} + +// BillableQuantity is the multiplier for unit price and unit cost on this line: +// the weighed amount for weight-based products, the item count otherwise. +// +// This is the ONLY place that decides between the two. Every price or cost +// calculation must go through it — multiplying by Quantity directly would bill a +// 4.2 ons fish as a single ons. +// +// Weighed lines are pinned to quantity = 1 by chk_order_items_weight_single_line, +// so there is no ambiguity between counting and weighing. +func (oi *OrderItem) BillableQuantity() float64 { + if oi.Weight != nil { + return *oi.Weight + } + return float64(oi.Quantity) +} + +// BillableQuantityFor is BillableQuantity for a partial action on this line, such as +// voiding or refunding `units` of it. +// +// Weighed lines are always acted on in full — quantity is 1, so any void or refund +// covers the whole weighing — hence the full weight is returned regardless of units. +func (oi *OrderItem) BillableQuantityFor(units int) float64 { + if oi.Weight != nil { + return *oi.Weight + } + return float64(units) +} + +// RoundMoney rounds to the 2 decimals that every monetary column stores, so the +// value written back always matches what the database keeps. +func RoundMoney(amount float64) float64 { + return math.Round(amount*100) / 100 +} + +// RoundWeight rounds to the 3 decimals of order_items.weight, so a validated value +// is identical to the stored one. +func RoundWeight(weight float64) float64 { + return math.Round(weight*1000) / 1000 +} + func (oi *OrderItem) CalculateTotalPrice() { - oi.TotalPrice = float64(oi.Quantity) * oi.UnitPrice + oi.TotalPrice = RoundMoney(oi.BillableQuantity() * oi.UnitPrice) +} + +func (oi *OrderItem) CalculateTotalCost() { + oi.TotalCost = RoundMoney(oi.BillableQuantity() * oi.UnitCost) } func (oi *OrderItem) CanBeModified() bool { diff --git a/internal/entities/order_item_test.go b/internal/entities/order_item_test.go new file mode 100644 index 0000000..0292693 --- /dev/null +++ b/internal/entities/order_item_test.go @@ -0,0 +1,104 @@ +package entities + +import "testing" + +func weightPtr(v float64) *float64 { return &v } + +func TestBillableQuantity(t *testing.T) { + tests := []struct { + name string + item OrderItem + want float64 + }{ + {"unit line counts items", OrderItem{Quantity: 3}, 3}, + {"weighed line uses the weight", OrderItem{Quantity: 1, Weight: weightPtr(4.2)}, 4.2}, + {"weight of zero is still a weighed line", OrderItem{Quantity: 1, Weight: weightPtr(0)}, 0}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.item.BillableQuantity(); got != tt.want { + t.Errorf("BillableQuantity() = %v, want %v", got, tt.want) + } + }) + } +} + +// A weighed line is voided or refunded whole, so the units asked for must not shrink +// the amount: refunding "1" of a 4.2 ons line refunds all 4.2 ons. +func TestBillableQuantityForIgnoresUnitsOnWeighedLines(t *testing.T) { + weighed := OrderItem{Quantity: 1, Weight: weightPtr(5.6)} + if got := weighed.BillableQuantityFor(1); got != 5.6 { + t.Errorf("weighed BillableQuantityFor(1) = %v, want 5.6", got) + } + + counted := OrderItem{Quantity: 3} + if got := counted.BillableQuantityFor(2); got != 2 { + t.Errorf("unit BillableQuantityFor(2) = %v, want 2", got) + } +} + +// The regression this whole feature exists to prevent: a 4.2 ons fish priced per ons +// must not be billed as a single ons. +func TestCalculateTotalPriceForWeighedLine(t *testing.T) { + item := OrderItem{Quantity: 1, Weight: weightPtr(4.2), UnitPrice: 4500, UnitCost: 3000} + item.CalculateTotalPrice() + item.CalculateTotalCost() + + if item.TotalPrice != 18900 { + t.Errorf("TotalPrice = %v, want 18900", item.TotalPrice) + } + if item.TotalCost != 12600 { + t.Errorf("TotalCost = %v, want 12600", item.TotalCost) + } +} + +func TestCalculateTotalPriceForUnitLine(t *testing.T) { + item := OrderItem{Quantity: 3, UnitPrice: 25000, UnitCost: 10000} + item.CalculateTotalPrice() + item.CalculateTotalCost() + + if item.TotalPrice != 75000 { + t.Errorf("TotalPrice = %v, want 75000", item.TotalPrice) + } + if item.TotalCost != 30000 { + t.Errorf("TotalCost = %v, want 30000", item.TotalCost) + } +} + +// Sub-rupiah residue must not survive into a decimal(10,2) column. +func TestCalculateTotalPriceRoundsToStoredPrecision(t *testing.T) { + item := OrderItem{Quantity: 1, Weight: weightPtr(4.237), UnitPrice: 4500} + item.CalculateTotalPrice() + + if item.TotalPrice != 19066.5 { + t.Errorf("TotalPrice = %v, want 19066.5", item.TotalPrice) + } +} + +func TestIsWeighed(t *testing.T) { + if (&OrderItem{Quantity: 1}).IsWeighed() { + t.Error("unit line reported as weighed") + } + if !(&OrderItem{Quantity: 1, Weight: weightPtr(1.5)}).IsWeighed() { + t.Error("weighed line reported as unit") + } +} + +func TestRoundWeight(t *testing.T) { + tests := []struct { + in float64 + want float64 + }{ + {4.2, 4.2}, + {4.2374, 4.237}, + {4.2375, 4.238}, + {0.0004, 0}, + } + + for _, tt := range tests { + if got := RoundWeight(tt.in); got != tt.want { + t.Errorf("RoundWeight(%v) = %v, want %v", tt.in, got, tt.want) + } + } +} diff --git a/internal/entities/product.go b/internal/entities/product.go index dc8c524..22d3f6d 100644 --- a/internal/entities/product.go +++ b/internal/entities/product.go @@ -20,6 +20,7 @@ type Product struct { ImageURL *string `gorm:"size:500" json:"image_url"` PrinterType string `gorm:"size:50;default:'kitchen'" json:"printer_type"` UnitID *uuid.UUID `gorm:"type:uuid;index" json:"unit_id"` + SellBy string `gorm:"size:20;default:'unit'" json:"sell_by"` HasIngredients bool `gorm:"default:false" json:"has_ingredients"` Metadata Metadata `gorm:"type:jsonb;default:'{}'" json:"metadata"` IsActive bool `gorm:"default:true" json:"is_active"` diff --git a/internal/handler/self_order_handler.go b/internal/handler/self_order_handler.go index ebbfdcb..1d7c576 100644 --- a/internal/handler/self_order_handler.go +++ b/internal/handler/self_order_handler.go @@ -344,6 +344,7 @@ func (h *SelfOrderHandler) CreateOrder(c *gin.Context) { ProductID: item.ProductID, ProductVariantID: item.ProductVariantID, Quantity: item.Quantity, + Weight: item.Weight, Notes: item.Notes, }) } diff --git a/internal/mappers/order_mapper.go b/internal/mappers/order_mapper.go index b4c84da..5f68ce2 100644 --- a/internal/mappers/order_mapper.go +++ b/internal/mappers/order_mapper.go @@ -115,12 +115,23 @@ func OrderItemEntityToResponse(item *entities.OrderItem, outletID uuid.UUID) *mo } } + // Unit is only meaningful for weighed lines, but carry it whenever it was captured. + var unitName, unitAbbreviation *string + if item.Unit != nil { + unitName = &item.Unit.Name + unitAbbreviation = item.Unit.Abbreviation + } + response := &models.OrderItemResponse{ ID: item.ID, OrderID: item.OrderID, ProductID: item.ProductID, ProductVariantID: item.ProductVariantID, Quantity: item.Quantity, + Weight: item.Weight, + UnitID: item.UnitID, + UnitName: unitName, + UnitAbbreviation: unitAbbreviation, UnitPrice: item.UnitPrice, TotalPrice: item.TotalPrice, UnitCost: item.UnitCost, diff --git a/internal/mappers/product_mapper.go b/internal/mappers/product_mapper.go index e91c3ef..57f92ba 100644 --- a/internal/mappers/product_mapper.go +++ b/internal/mappers/product_mapper.go @@ -25,6 +25,7 @@ func ProductEntityToModel(entity *entities.Product) *models.Product { BusinessType: constants.BusinessType(entity.BusinessType), ImageURL: entity.ImageURL, PrinterType: entity.PrinterType, + SellBy: entity.SellBy, Metadata: map[string]interface{}(entity.Metadata), IsActive: entity.IsActive, CreatedAt: entity.CreatedAt, @@ -76,6 +77,11 @@ func CreateProductRequestToEntity(req *models.CreateProductRequest) *entities.Pr printerType = *req.PrinterType } + sellBy := constants.SellByUnit + if constants.IsValidSellBy(req.SellBy) { + sellBy = req.SellBy + } + metadata := entities.Metadata{} if req.Metadata != nil { metadata = entities.Metadata(req.Metadata) @@ -92,6 +98,8 @@ func CreateProductRequestToEntity(req *models.CreateProductRequest) *entities.Pr BusinessType: businessType, ImageURL: req.ImageURL, PrinterType: printerType, + UnitID: req.UnitID, + SellBy: sellBy, Metadata: metadata, IsActive: true, // Default to active } @@ -140,6 +148,8 @@ func ProductEntityToResponse(entity *entities.Product) *models.ProductResponse { BusinessType: constants.BusinessType(entity.BusinessType), ImageURL: entity.ImageURL, PrinterType: entity.PrinterType, + UnitID: entity.UnitID, + SellBy: entity.SellBy, Metadata: map[string]interface{}(entity.Metadata), IsActive: entity.IsActive, CreatedAt: entity.CreatedAt, @@ -185,6 +195,14 @@ func UpdateProductEntityFromRequest(entity *entities.Product, req *models.Update entity.PrinterType = *req.PrinterType } + if req.UnitID != nil { + entity.UnitID = req.UnitID + } + + if req.SellBy != nil && constants.IsValidSellBy(*req.SellBy) { + entity.SellBy = *req.SellBy + } + if req.Metadata != nil { if entity.Metadata == nil { entity.Metadata = make(entities.Metadata) diff --git a/internal/models/analytics.go b/internal/models/analytics.go index d3aaa07..109a65b 100644 --- a/internal/models/analytics.go +++ b/internal/models/analytics.go @@ -233,6 +233,7 @@ type ProductAnalyticsData struct { CategoryName string `json:"category_name"` CategoryOrder int `json:"category_order"` QuantitySold int64 `json:"quantity_sold"` + WeightSold float64 `json:"weight_sold"` Revenue float64 `json:"revenue"` AveragePrice float64 `json:"average_price"` OrderCount int64 `json:"order_count"` @@ -359,6 +360,7 @@ type ParentCategoryAnalyticsProductData struct { ProductSku string `json:"product_sku"` ProductPrice float64 `json:"product_price"` QuantitySold int64 `json:"quantity_sold"` + WeightSold float64 `json:"weight_sold"` Revenue float64 `json:"revenue"` AveragePrice float64 `json:"average_price"` OrderCount int64 `json:"order_count"` diff --git a/internal/models/order.go b/internal/models/order.go index 313c496..d18e2a9 100644 --- a/internal/models/order.go +++ b/internal/models/order.go @@ -44,6 +44,8 @@ type OrderItem struct { ProductID uuid.UUID ProductVariantID *uuid.UUID Quantity int + Weight *float64 + UnitID *uuid.UUID UnitPrice float64 TotalPrice float64 UnitCost float64 @@ -99,7 +101,8 @@ type CreateOrderItemRequest struct { ProductID uuid.UUID `validate:"required"` ProductVariantID *uuid.UUID `validate:"omitempty"` Quantity int `validate:"required,min=1"` - UnitPrice *float64 `validate:"omitempty,min=0"` // Optional, will use database price if not provided + Weight *float64 `validate:"omitempty,gt=0"` + UnitPrice *float64 `validate:"omitempty,min=0"` // Ignored: price always comes from the database Modifiers []map[string]interface{} `validate:"omitempty"` Notes *string `validate:"omitempty,max=500"` Metadata map[string]interface{} `validate:"omitempty"` @@ -191,6 +194,10 @@ type OrderItemResponse struct { CategoryID *uuid.UUID CategoryName *string Quantity int + Weight *float64 + UnitID *uuid.UUID + UnitName *string + UnitAbbreviation *string UnitPrice float64 TotalPrice float64 UnitCost float64 diff --git a/internal/models/product.go b/internal/models/product.go index 0e0b6a1..1d2142b 100644 --- a/internal/models/product.go +++ b/internal/models/product.go @@ -19,6 +19,7 @@ type Product struct { BusinessType constants.BusinessType ImageURL *string PrinterType string + SellBy string UnitID *uuid.UUID HasIngredients bool Metadata map[string]interface{} @@ -52,6 +53,7 @@ type CreateProductRequest struct { PrinterType *string `validate:"omitempty,max=50"` PrintToChecker *bool `validate:"omitempty"` UnitID *uuid.UUID `validate:"omitempty"` + SellBy string `validate:"omitempty,oneof=unit weight"` HasIngredients bool `validate:"omitempty"` Metadata map[string]interface{} Variants []CreateProductVariantRequest `validate:"omitempty,dive"` @@ -73,6 +75,7 @@ type UpdateProductRequest struct { PrinterType *string `validate:"omitempty,max=50"` PrintToChecker *bool `validate:"omitempty"` UnitID *uuid.UUID `validate:"omitempty"` + SellBy *string `validate:"omitempty,oneof=unit weight"` HasIngredients *bool `validate:"omitempty"` Metadata map[string]interface{} IsActive *bool @@ -110,6 +113,7 @@ type ProductResponse struct { BusinessType constants.BusinessType ImageURL *string PrinterType string + SellBy string PrintToChecker bool UnitID *uuid.UUID HasIngredients bool diff --git a/internal/processor/analytics_processor.go b/internal/processor/analytics_processor.go index 37ad289..1297e90 100644 --- a/internal/processor/analytics_processor.go +++ b/internal/processor/analytics_processor.go @@ -322,6 +322,7 @@ func (p *AnalyticsProcessorImpl) GetProductAnalytics(ctx context.Context, req *m CategoryName: data.CategoryName, CategoryOrder: data.CategoryOrder, QuantitySold: data.QuantitySold, + WeightSold: data.WeightSold, Revenue: data.Revenue, AveragePrice: data.AveragePrice, OrderCount: data.OrderCount, @@ -447,6 +448,7 @@ func (p *AnalyticsProcessorImpl) GetParentCategoryAnalyticsDetail(ctx context.Co ProductSku: product.ProductSku, ProductPrice: product.ProductPrice, QuantitySold: product.QuantitySold, + WeightSold: product.WeightSold, Revenue: product.Revenue, AveragePrice: product.AveragePrice, OrderCount: product.OrderCount, diff --git a/internal/processor/order_processor.go b/internal/processor/order_processor.go index 6065005..3e14e23 100644 --- a/internal/processor/order_processor.go +++ b/internal/processor/order_processor.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" + "apskel-pos-be/internal/constants" "apskel-pos-be/internal/entities" "apskel-pos-be/internal/mappers" "apskel-pos-be/internal/models" @@ -149,6 +150,33 @@ func NewOrderProcessorImpl( } } +// resolveLineQuantity reconciles the requested quantity and weight against how the +// product is sold, returning the values to store on the order line. +// +// For weight-based products a line is exactly one weighing, so quantity is pinned to 1 +// and the weighed amount is what gets priced. This mirrors +// chk_order_items_weight_single_line in the database. +func resolveLineQuantity(product *entities.Product, quantity int, weight *float64) (int, *float64, error) { + if product.SellBy == constants.SellByWeight { + if weight == nil { + return 0, nil, fmt.Errorf("product %s is sold by weight and requires a weight", product.Name) + } + rounded := entities.RoundWeight(*weight) + if rounded <= 0 { + return 0, nil, fmt.Errorf("weight for product %s must be greater than 0", product.Name) + } + return 1, &rounded, nil + } + + if weight != nil { + return 0, nil, fmt.Errorf("product %s is not sold by weight and must not carry a weight", product.Name) + } + if quantity < 1 { + return 0, nil, fmt.Errorf("quantity for product %s must be at least 1", product.Name) + } + return quantity, nil, nil +} + func (p *OrderProcessorImpl) CreateOrder(ctx context.Context, req *models.CreateOrderRequest, organizationID uuid.UUID) (*models.OrderResponse, error) { orderNumber, err := p.orderRepo.GetNextOrderNumber(ctx, organizationID, req.OutletID) if err != nil { @@ -194,25 +222,29 @@ func (p *OrderProcessorImpl) CreateOrder(ctx context.Context, req *models.Create } } - itemTotalPrice := float64(itemReq.Quantity) * unitPrice - itemTotalCost := float64(itemReq.Quantity) * unitCost - - subtotal += itemTotalPrice - totalCost += itemTotalCost + quantity, weight, err := resolveLineQuantity(product, itemReq.Quantity, itemReq.Weight) + if err != nil { + return nil, err + } orderItem := &entities.OrderItem{ ProductID: itemReq.ProductID, ProductVariantID: itemReq.ProductVariantID, - Quantity: itemReq.Quantity, + Quantity: quantity, + Weight: weight, + UnitID: product.UnitID, UnitPrice: unitPrice, - TotalPrice: itemTotalPrice, UnitCost: unitCost, - TotalCost: itemTotalCost, Modifiers: entities.Modifiers(itemReq.Modifiers), Notes: itemReq.Notes, Metadata: entities.Metadata(itemReq.Metadata), Status: entities.OrderItemStatusPending, } + orderItem.CalculateTotalPrice() + orderItem.CalculateTotalCost() + + subtotal += orderItem.TotalPrice + totalCost += orderItem.TotalCost orderItems = append(orderItems, orderItem) } @@ -327,26 +359,30 @@ func (p *OrderProcessorImpl) AddToOrder(ctx context.Context, orderID uuid.UUID, } } - itemTotalPrice := float64(itemReq.Quantity) * unitPrice - itemTotalCost := float64(itemReq.Quantity) * unitCost - - newSubtotal += itemTotalPrice - newTotalCost += itemTotalCost + quantity, weight, err := resolveLineQuantity(product, itemReq.Quantity, itemReq.Weight) + if err != nil { + return nil, err + } orderItem := &entities.OrderItem{ OrderID: orderID, ProductID: itemReq.ProductID, ProductVariantID: itemReq.ProductVariantID, - Quantity: itemReq.Quantity, + Quantity: quantity, + Weight: weight, + UnitID: product.UnitID, UnitPrice: unitPrice, - TotalPrice: itemTotalPrice, UnitCost: unitCost, - TotalCost: itemTotalCost, Modifiers: entities.Modifiers(itemReq.Modifiers), Notes: itemReq.Notes, Metadata: entities.Metadata(itemReq.Metadata), Status: entities.OrderItemStatusPending, } + orderItem.CalculateTotalPrice() + orderItem.CalculateTotalCost() + + newSubtotal += orderItem.TotalPrice + newTotalCost += orderItem.TotalCost addedOrderItems = append(addedOrderItems, orderItem) } @@ -602,8 +638,9 @@ func (p *OrderProcessorImpl) VoidOrder(ctx context.Context, req *models.VoidOrde return fmt.Errorf("void quantity cannot exceed original quantity for item %d", itemVoid.OrderItemID) } - voidedAmount := float64(itemVoid.Quantity) * orderItem.UnitPrice - voidedCost := float64(itemVoid.Quantity) * orderItem.UnitCost + billable := orderItem.BillableQuantityFor(itemVoid.Quantity) + voidedAmount := entities.RoundMoney(billable * orderItem.UnitPrice) + voidedCost := entities.RoundMoney(billable * orderItem.UnitCost) totalVoidedAmount += voidedAmount totalVoidedCost += voidedCost @@ -720,7 +757,7 @@ func (p *OrderProcessorImpl) RefundOrder(ctx context.Context, id uuid.UUID, req return fmt.Errorf("refund quantity cannot exceed original quantity") } - refundAmount := float64(refundQuantity) * orderItem.UnitPrice + refundAmount := entities.RoundMoney(orderItem.BillableQuantityFor(refundQuantity) * orderItem.UnitPrice) if itemRefund.RefundAmount != nil { refundAmount = *itemRefund.RefundAmount } @@ -1016,7 +1053,7 @@ func (p *OrderProcessorImpl) createInventoryMovement(ctx context.Context, item * PreviousQuantity: float64(updatedInventory.Quantity + item.Quantity), // Add back the quantity that was subtracted NewQuantity: float64(updatedInventory.Quantity), UnitCost: item.UnitCost, - TotalCost: float64(item.Quantity) * item.UnitCost, + TotalCost: entities.RoundMoney(item.BillableQuantity() * item.UnitCost), ReferenceType: func() *entities.InventoryMovementReferenceType { t := entities.InventoryMovementReferenceTypePayment return &t @@ -1314,7 +1351,7 @@ func (p *OrderProcessorImpl) prepareProductInventoryMovement(item *entities.Orde PreviousQuantity: float64(previousQuantity), NewQuantity: float64(updatedInventory.Quantity), UnitCost: item.UnitCost, - TotalCost: float64(item.Quantity) * item.UnitCost, + TotalCost: entities.RoundMoney(item.BillableQuantity() * item.UnitCost), ReferenceType: func() *entities.InventoryMovementReferenceType { t := entities.InventoryMovementReferenceTypePayment return &t @@ -1380,7 +1417,7 @@ type ingredientRecipeItem struct { // prepareIngredientRecipeItem prepares data for a single ingredient recipe without making database calls func (p *OrderProcessorImpl) prepareIngredientRecipeItem(ctx context.Context, recipe *entities.ProductRecipe, item *entities.OrderItem, order *entities.Order, payment *entities.Payment) (*ingredientRecipeItem, error) { - totalIngredientQuantity := recipe.Quantity * float64(item.Quantity) + totalIngredientQuantity := recipe.Quantity * item.BillableQuantity() currentIngredient, err := p.ingredientRepo.GetByID(ctx, recipe.IngredientID, order.OrganizationID) if err != nil { @@ -1478,7 +1515,7 @@ func (p *OrderProcessorImpl) prepareRefundProductInventoryMovement(item *entitie PreviousQuantity: float64(previousQuantity), NewQuantity: float64(updatedInventory.Quantity), UnitCost: item.UnitCost, - TotalCost: float64(refundedQuantity) * item.UnitCost, + TotalCost: entities.RoundMoney(item.BillableQuantityFor(refundedQuantity) * item.UnitCost), ReferenceType: func() *entities.InventoryMovementReferenceType { t := entities.InventoryMovementReferenceTypeRefund return &t @@ -1544,7 +1581,7 @@ func (p *OrderProcessorImpl) prepareRefundedIngredientRecipeData(ctx context.Con // prepareRefundedIngredientRecipeItem prepares data for a single ingredient recipe restoration func (p *OrderProcessorImpl) prepareRefundedIngredientRecipeItem(ctx context.Context, recipe *entities.ProductRecipe, item *entities.OrderItem, order *entities.Order, payment *entities.Payment, refundRatio float64, reason string, refundedBy uuid.UUID, refundAmount float64) (*ingredientRecipeItem, error) { // Calculate total ingredient quantity needed based on order item quantity - totalIngredientQuantity := recipe.Quantity * float64(item.Quantity) + totalIngredientQuantity := recipe.Quantity * item.BillableQuantity() // Get current ingredient details currentIngredient, err := p.ingredientRepo.GetByID(ctx, recipe.IngredientID, order.OrganizationID) diff --git a/internal/processor/order_weight_test.go b/internal/processor/order_weight_test.go new file mode 100644 index 0000000..1558707 --- /dev/null +++ b/internal/processor/order_weight_test.go @@ -0,0 +1,106 @@ +package processor + +import ( + "testing" + + "apskel-pos-be/internal/constants" + "apskel-pos-be/internal/entities" +) + +func fPtr(v float64) *float64 { return &v } + +func TestResolveLineQuantity(t *testing.T) { + weightProduct := &entities.Product{Name: "Ikan Tude", SellBy: constants.SellByWeight} + unitProduct := &entities.Product{Name: "Nasi Goreng", SellBy: constants.SellByUnit} + + tests := []struct { + name string + product *entities.Product + quantity int + weight *float64 + wantQuantity int + wantWeight *float64 + wantErr bool + }{ + { + name: "weighed line is pinned to quantity 1", + // Mirrors chk_order_items_weight_single_line: even if a client sends 3, + // one weighing is one line. + product: weightProduct, quantity: 3, weight: fPtr(4.2), + wantQuantity: 1, wantWeight: fPtr(4.2), + }, + { + name: "weight is rounded to stored precision", + product: weightProduct, quantity: 1, weight: fPtr(5.6004), + wantQuantity: 1, wantWeight: fPtr(5.6), + }, + { + name: "weight product without a weight is rejected", + product: weightProduct, quantity: 1, weight: nil, + wantErr: true, + }, + { + name: "weight that rounds away to zero is rejected", + product: weightProduct, quantity: 1, weight: fPtr(0.0004), + wantErr: true, + }, + { + name: "unit line keeps its quantity and carries no weight", + product: unitProduct, quantity: 3, weight: nil, + wantQuantity: 3, wantWeight: nil, + }, + { + name: "weight on a unit product is rejected", + // Otherwise the line would silently be priced by weight. + product: unitProduct, quantity: 1, weight: fPtr(4.2), + wantErr: true, + }, + { + name: "non-positive quantity on a unit product is rejected", + product: unitProduct, quantity: 0, weight: nil, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + gotQty, gotWeight, err := resolveLineQuantity(tt.product, tt.quantity, tt.weight) + + if tt.wantErr { + if err == nil { + t.Fatalf("expected an error, got quantity=%v weight=%v", gotQty, gotWeight) + } + return + } + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + if gotQty != tt.wantQuantity { + t.Errorf("quantity = %v, want %v", gotQty, tt.wantQuantity) + } + switch { + case tt.wantWeight == nil && gotWeight != nil: + t.Errorf("weight = %v, want nil", *gotWeight) + case tt.wantWeight != nil && gotWeight == nil: + t.Errorf("weight = nil, want %v", *tt.wantWeight) + case tt.wantWeight != nil && *gotWeight != *tt.wantWeight: + t.Errorf("weight = %v, want %v", *gotWeight, *tt.wantWeight) + } + }) + } +} + +// A product created before this feature has sell_by defaulted to 'unit' by the +// migration, but a zero-valued struct must behave the same way. +func TestResolveLineQuantityTreatsEmptySellByAsUnit(t *testing.T) { + legacy := &entities.Product{Name: "Legacy"} + + quantity, weight, err := resolveLineQuantity(legacy, 2, nil) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if quantity != 2 || weight != nil { + t.Errorf("got quantity=%v weight=%v, want quantity=2 weight=nil", quantity, weight) + } +} diff --git a/internal/processor/split_bill_processor.go b/internal/processor/split_bill_processor.go index 5559125..d527a89 100644 --- a/internal/processor/split_bill_processor.go +++ b/internal/processor/split_bill_processor.go @@ -140,7 +140,7 @@ func calculateSplitAmounts(req *models.SplitBillRequest, validation *SplitBillVa for _, item := range req.Items { orderItem := validation.OrderItems[item.OrderItemID] - itemAmount := float64(item.Quantity) * orderItem.UnitPrice + itemAmount := entities.RoundMoney(orderItem.BillableQuantityFor(item.Quantity) * orderItem.UnitPrice) itemTaxAmount := itemAmount * validation.Outlet.TaxRate totalItemAmount := itemAmount + itemTaxAmount @@ -186,7 +186,7 @@ func (p *SplitBillProcessorImpl) createSplitPayment(ctx context.Context, req *mo func (p *SplitBillProcessorImpl) createPaymentOrderItems(ctx context.Context, splitPayment *entities.Payment, req *models.SplitBillRequest, validation *SplitBillValidation) error { for _, item := range req.Items { orderItem := validation.OrderItems[item.OrderItemID] - itemAmount := float64(item.Quantity) * orderItem.UnitPrice + itemAmount := entities.RoundMoney(orderItem.BillableQuantityFor(item.Quantity) * orderItem.UnitPrice) itemTaxAmount := itemAmount * validation.Outlet.TaxRate totalItemAmount := itemAmount + itemTaxAmount @@ -228,7 +228,7 @@ func (p *SplitBillProcessorImpl) updateOrderAfterSplit(ctx context.Context, orde quantityInfo[item.OrderItemID.String()] = map[string]interface{}{ "quantity": item.Quantity, "unit_price": orderItem.UnitPrice, - "total_amount": float64(item.Quantity) * orderItem.UnitPrice, + "total_amount": entities.RoundMoney(orderItem.BillableQuantityFor(item.Quantity) * orderItem.UnitPrice), } } order.Metadata[MetadataKeyLastSplitQuantities] = quantityInfo diff --git a/internal/repository/analytics_repository.go b/internal/repository/analytics_repository.go index 9d83d16..fe23ebc 100644 --- a/internal/repository/analytics_repository.go +++ b/internal/repository/analytics_repository.go @@ -461,6 +461,7 @@ func (r *AnalyticsRepositoryImpl) GetProductAnalytics(ctx context.Context, organ c.name as category_name, c.order as category_order, COALESCE(SUM(oi.quantity), 0) as quantity_sold, + COALESCE(SUM(oi.weight), 0) as weight_sold, COALESCE(SUM(oi.total_price), 0) as revenue, CASE WHEN SUM(oi.quantity) > 0 THEN COALESCE(SUM(oi.total_price), 0) / SUM(oi.quantity) @@ -1167,9 +1168,9 @@ func (r *AnalyticsRepositoryImpl) getPurchaseOrderRawMaterialTotal(ctx context.C } type purchasingTotals struct { - Total float64 - RawMaterial float64 - Expense float64 + Total float64 + RawMaterial float64 + Expense float64 } func (r *AnalyticsRepositoryImpl) getPurchaseOrderTotals(ctx context.Context, organizationID uuid.UUID, dateFrom, dateTo time.Time) (purchasingTotals, error) { diff --git a/internal/repository/order_item_repository.go b/internal/repository/order_item_repository.go index d983b6b..6f31acc 100644 --- a/internal/repository/order_item_repository.go +++ b/internal/repository/order_item_repository.go @@ -50,6 +50,7 @@ func (r *OrderItemRepositoryImpl) GetByOrderID(ctx context.Context, orderID uuid err := r.db.WithContext(ctx). Preload("Product"). Preload("ProductVariant"). + Preload("Unit"). Where("order_id = ?", orderID). Find(&orderItems).Error return orderItems, err @@ -109,8 +110,12 @@ func (r *OrderItemRepositoryImpl) VoidOrderItem(ctx context.Context, id uuid.UUI return err } - if voidQuantity >= orderItem.Quantity { - voidedAmount := float64(voidQuantity) * orderItem.UnitPrice + // A weighed line is one weighing, so it is voided whole — never split into a + // remainder row. chk_order_items_weight_single_line pins its quantity to 1, which + // already sends it down this branch; the explicit check keeps that guarantee + // visible and independent of the comparison below. + if orderItem.IsWeighed() || voidQuantity >= orderItem.Quantity { + voidedAmount := entities.RoundMoney(orderItem.BillableQuantityFor(voidQuantity) * orderItem.UnitPrice) updates := map[string]interface{}{ "refund_quantity": voidQuantity, @@ -128,16 +133,18 @@ func (r *OrderItemRepositoryImpl) VoidOrderItem(ctx context.Context, id uuid.UUI Updates(updates).Error } + // Only unit-priced lines reach here: weighed lines were voided whole above. voidedOrderItem := entities.OrderItem{ OrderID: orderItem.OrderID, ProductID: orderItem.ProductID, ProductVariantID: orderItem.ProductVariantID, Quantity: voidQuantity, + UnitID: orderItem.UnitID, UnitPrice: orderItem.UnitPrice, - TotalPrice: float64(voidQuantity) * orderItem.UnitPrice, + TotalPrice: entities.RoundMoney(float64(voidQuantity) * orderItem.UnitPrice), UnitCost: orderItem.UnitCost, - TotalCost: float64(voidQuantity) * orderItem.UnitCost, - RefundAmount: float64(voidQuantity) * orderItem.UnitPrice, + TotalCost: entities.RoundMoney(float64(voidQuantity) * orderItem.UnitCost), + RefundAmount: entities.RoundMoney(float64(voidQuantity) * orderItem.UnitPrice), RefundQuantity: voidQuantity, IsPartiallyRefunded: false, IsFullyRefunded: true, @@ -155,8 +162,8 @@ func (r *OrderItemRepositoryImpl) VoidOrderItem(ctx context.Context, id uuid.UUI } remainingQuantity := orderItem.Quantity - voidQuantity - remainingTotalPrice := float64(remainingQuantity) * orderItem.UnitPrice - remainingTotalCost := float64(remainingQuantity) * orderItem.UnitCost + remainingTotalPrice := entities.RoundMoney(float64(remainingQuantity) * orderItem.UnitPrice) + remainingTotalCost := entities.RoundMoney(float64(remainingQuantity) * orderItem.UnitCost) updates := map[string]interface{}{ "quantity": remainingQuantity, diff --git a/internal/repository/order_repository.go b/internal/repository/order_repository.go index 9d13a48..341ce14 100644 --- a/internal/repository/order_repository.go +++ b/internal/repository/order_repository.go @@ -63,6 +63,7 @@ func (r *OrderRepositoryImpl) GetWithRelations(ctx context.Context, id uuid.UUID Preload("OrderItems.Product.Category"). Preload("OrderItems.Product.ProductOutletPrices"). Preload("OrderItems.ProductVariant"). + Preload("OrderItems.Unit"). Preload("Payments"). Preload("Payments.PaymentMethod"). Preload("Payments.PaymentOrderItems"). @@ -144,6 +145,7 @@ func (r *OrderRepositoryImpl) List(ctx context.Context, filters map[string]inter Preload("OrderItems.Product.Category"). Preload("OrderItems.Product.ProductOutletPrices"). Preload("OrderItems.ProductVariant"). + Preload("OrderItems.Unit"). Preload("Payments"). Preload("Payments.PaymentMethod"). Preload("Payments.PaymentOrderItems"). @@ -162,6 +164,7 @@ func (r *OrderRepositoryImpl) ListBySessionID(ctx context.Context, sessionID str Preload("OrderItems.Product.Category"). Preload("OrderItems.Product.ProductOutletPrices"). Preload("OrderItems.ProductVariant"). + Preload("OrderItems.Unit"). Preload("Payments"). Preload("Payments.PaymentMethod"). Preload("Payments.PaymentOrderItems"). diff --git a/internal/service/report_service.go b/internal/service/report_service.go index 7c113ff..8ba124f 100644 --- a/internal/service/report_service.go +++ b/internal/service/report_service.go @@ -64,6 +64,7 @@ type reportSummary struct { type reportItem struct { Name string Quantity int64 + Weight string GrossSales string Discount string NetSales string @@ -161,6 +162,7 @@ func (s *ReportServiceImpl) GenerateDailyTransactionPDF(ctx context.Context, org items = append(items, reportItem{ Name: p.ProductName, Quantity: p.QuantitySold, + Weight: formatWeight(p.WeightSold), GrossSales: formatCurrency(p.Revenue), Discount: formatCurrency(0), NetSales: formatCurrency(p.Revenue), @@ -489,6 +491,16 @@ func buildProfitLossSummaryRows(rows []models.ProfitLossSummaryRow) []profitLoss return result } +// formatWeight renders the weight sold for a product, or a dash when the product is +// not sold by weight. Trailing zeros are trimmed so 4.200 prints as "4,2". +func formatWeight(weight float64) string { + if weight <= 0 { + return "-" + } + s := strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.3f", weight), "0"), ".") + return strings.Replace(s, ".", ",", 1) +} + func formatCurrencyOrDash(amount float64) string { if amount == 0 { return "-" diff --git a/internal/transformer/analytics_transformer.go b/internal/transformer/analytics_transformer.go index d9214eb..8590c18 100644 --- a/internal/transformer/analytics_transformer.go +++ b/internal/transformer/analytics_transformer.go @@ -291,6 +291,7 @@ func ProductAnalyticsModelToContract(resp *models.ProductAnalyticsResponse) *con CategoryName: item.CategoryName, CategoryOrder: item.CategoryOrder, QuantitySold: item.QuantitySold, + WeightSold: item.WeightSold, Revenue: item.Revenue, AveragePrice: item.AveragePrice, OrderCount: item.OrderCount, @@ -506,6 +507,7 @@ func ParentCategoryAnalyticsDetailModelToContract(resp *models.ParentCategoryAna ProductSku: product.ProductSku, ProductPrice: product.ProductPrice, QuantitySold: product.QuantitySold, + WeightSold: product.WeightSold, Revenue: product.Revenue, AveragePrice: product.AveragePrice, OrderCount: product.OrderCount, @@ -592,6 +594,7 @@ func DashboardAnalyticsModelToContract(resp *models.DashboardAnalyticsResponse) CategoryID: item.CategoryID, CategoryName: item.CategoryName, QuantitySold: item.QuantitySold, + WeightSold: item.WeightSold, Revenue: item.Revenue, AveragePrice: item.AveragePrice, OrderCount: item.OrderCount, diff --git a/internal/transformer/order_transformer.go b/internal/transformer/order_transformer.go index 88f88d6..92b8ab8 100644 --- a/internal/transformer/order_transformer.go +++ b/internal/transformer/order_transformer.go @@ -103,6 +103,10 @@ func OrderModelToContract(resp *models.OrderResponse) *contract.OrderResponse { CategoryID: item.CategoryID, CategoryName: item.CategoryName, Quantity: item.Quantity, + Weight: item.Weight, + UnitID: item.UnitID, + UnitName: item.UnitName, + UnitAbbreviation: item.UnitAbbreviation, UnitPrice: item.UnitPrice, TotalPrice: item.TotalPrice, Modifiers: item.Modifiers, @@ -174,6 +178,10 @@ func AddToOrderModelToContract(resp *models.AddToOrderResponse) *contract.AddToO CategoryID: item.CategoryID, CategoryName: item.CategoryName, Quantity: item.Quantity, + Weight: item.Weight, + UnitID: item.UnitID, + UnitName: item.UnitName, + UnitAbbreviation: item.UnitAbbreviation, UnitPrice: item.UnitPrice, TotalPrice: item.TotalPrice, Modifiers: item.Modifiers, diff --git a/internal/transformer/product_transformer.go b/internal/transformer/product_transformer.go index e6f0321..0a628f6 100644 --- a/internal/transformer/product_transformer.go +++ b/internal/transformer/product_transformer.go @@ -20,6 +20,11 @@ func CreateProductRequestToModel(apctx *appcontext.ContextInfo, req *contract.Cr businessType = constants.BusinessType(*req.BusinessType) } + sellBy := constants.SellByUnit + if req.SellBy != nil { + sellBy = *req.SellBy + } + var variants []models.CreateProductVariantRequest if req.Variants != nil { variants = make([]models.CreateProductVariantRequest, len(req.Variants)) @@ -58,6 +63,8 @@ func CreateProductRequestToModel(apctx *appcontext.ContextInfo, req *contract.Cr ImageURL: req.ImageURL, PrinterType: req.PrinterType, PrintToChecker: req.PrintToChecker, + UnitID: req.UnitID, + SellBy: sellBy, Metadata: metadata, Variants: variants, } @@ -86,6 +93,8 @@ func UpdateProductRequestToModel(apctx *appcontext.ContextInfo, req *contract.Up ImageURL: req.ImageURL, PrinterType: req.PrinterType, PrintToChecker: req.PrintToChecker, + UnitID: req.UnitID, + SellBy: req.SellBy, Metadata: metadata, IsActive: req.IsActive, } @@ -145,6 +154,8 @@ func ProductModelResponseToResponse(prod *models.ProductResponse) *contract.Prod ImageURL: prod.ImageURL, PrinterType: prod.PrinterType, PrintToChecker: prod.PrintToChecker, + UnitID: prod.UnitID, + SellBy: prod.SellBy, Metadata: prod.Metadata, IsActive: prod.IsActive, CreatedAt: prod.CreatedAt, diff --git a/migrations/000089_add_weight_to_order_items.down.sql b/migrations/000089_add_weight_to_order_items.down.sql new file mode 100644 index 0000000..50803d6 --- /dev/null +++ b/migrations/000089_add_weight_to_order_items.down.sql @@ -0,0 +1,15 @@ +DROP INDEX IF EXISTS idx_order_items_unit_id; + +ALTER TABLE order_items + DROP CONSTRAINT IF EXISTS chk_order_items_weight_single_line, + DROP CONSTRAINT IF EXISTS chk_order_items_weight_positive; + +ALTER TABLE order_items + DROP COLUMN IF EXISTS unit_id, + DROP COLUMN IF EXISTS weight; + +ALTER TABLE products + DROP CONSTRAINT IF EXISTS chk_products_sell_by; + +ALTER TABLE products + DROP COLUMN IF EXISTS sell_by; diff --git a/migrations/000089_add_weight_to_order_items.up.sql b/migrations/000089_add_weight_to_order_items.up.sql new file mode 100644 index 0000000..00157a2 --- /dev/null +++ b/migrations/000089_add_weight_to_order_items.up.sql @@ -0,0 +1,30 @@ +-- Weight-based products (e.g. fish sold per ons/kg). +-- One weighing = one order_items row: quantity stays 1, the weight goes in `weight`. + +ALTER TABLE products + ADD COLUMN sell_by VARCHAR(20) NOT NULL DEFAULT 'unit'; + +ALTER TABLE products + ADD CONSTRAINT chk_products_sell_by + CHECK (sell_by IN ('unit', 'weight')); + +ALTER TABLE order_items + ADD COLUMN weight DECIMAL(12,3), + ADD COLUMN unit_id UUID REFERENCES units(id) ON DELETE RESTRICT; + +-- A weighed line always carries a positive weight... +ALTER TABLE order_items + ADD CONSTRAINT chk_order_items_weight_positive + CHECK (weight IS NULL OR weight > 0); + +-- ...and always represents exactly one weighing, so its quantity is pinned to 1. +-- This is what makes billable quantity unambiguous and keeps void all-or-nothing. +ALTER TABLE order_items + ADD CONSTRAINT chk_order_items_weight_single_line + CHECK (weight IS NULL OR quantity = 1); + +CREATE INDEX idx_order_items_unit_id ON order_items(unit_id); + +COMMENT ON COLUMN products.sell_by IS 'How the product is sold: unit (discrete count) or weight (weighed per transaction)'; +COMMENT ON COLUMN order_items.weight IS 'Weighed amount in unit_id units; NULL for unit-priced products. Price is weight * unit_price.'; +COMMENT ON COLUMN order_items.unit_id IS 'Snapshot of the product unit at sale time, so historical lines keep their meaning'; diff --git a/templates/daily_transaction.html b/templates/daily_transaction.html index b9e788e..ed43d76 100644 --- a/templates/daily_transaction.html +++ b/templates/daily_transaction.html @@ -524,6 +524,7 @@ No. Nama Item Qty + Berat Penjualan Kotor Diskon Penjualan Bersih @@ -537,6 +538,7 @@ {{add $i 1}} {{$item.Name}} {{$item.Quantity}} + {{$item.Weight}} {{$item.GrossSales}} {{$item.Discount}} {{$item.NetSales}}