Build a Point of Sale App

package models

import (
	"time"

	"gorm.io/gorm"
)

type Product struct {
	ID        uint           `gorm:"primaryKey" json:"id"`
	Name      string         `json:"name"`
	Sku       string         `json:"sku"`
	Price     float64        `json:"price"`
	Cost      float64        `json:"cost"`
	Stock     int            `json:"stock"`
	Category  string         `json:"category"`
	Barcode   string         `json:"barcode"`
	CreatedAt time.Time      `json:"created_at"`
	UpdatedAt time.Time      `json:"updated_at"`
	DeletedAt gorm.DeletedAt `gorm:"index" json:"deleted_at"`
}

package models

import (
	"time"

	"gorm.io/gorm"
)

type Sale struct {
	ID            uint           `gorm:"primaryKey" json:"id"`
	CustomerID    uint           `json:"customer_id"`
	Total         float64        `json:"total"`
	Tax           float64        `json:"tax"`
	PaymentMethod string         `json:"payment_method"`
	Status        string         `json:"status"`
	Notes         string         `json:"notes"`
	CreatedAt     time.Time      `json:"created_at"`
	UpdatedAt     time.Time      `json:"updated_at"`
	DeletedAt     gorm.DeletedAt `gorm:"index" json:"deleted_at"`

	// Optional: add relationships for eager loading
	// Customer  Customer    `gorm:"foreignKey:CustomerID" json:"customer,omitempty"`
	// Items     []SaleItem  `gorm:"foreignKey:SaleID" json:"items,omitempty"`
}

// GetLowStock returns products with stock below the given threshold.
func (s *ProductService) GetLowStock(threshold int) ([]models.Product, error) {
	var products []models.Product
	result := s.db.Where("stock < ?", threshold).Order("stock ASC").Find(&products)
	return products, result.Error
}

// GetByBarcode looks up a single product by its barcode string.
func (s *ProductService) GetByBarcode(barcode string) (*models.Product, error) {
	var product models.Product
	result := s.db.Where("barcode = ?", barcode).First(&product)
	if result.Error != nil {
		return nil, result.Error
	}
	return &product, nil
}

// GetByCategory returns all products in a given category.
func (s *ProductService) GetByCategory(category string) ([]models.Product, error) {
	var products []models.Product
	result := s.db.Where("category = ?", category).Order("name ASC").Find(&products)
	return products, result.Error
}

// DecrementStock reduces the stock of a product by the given quantity.
// Returns an error if insufficient stock is available.
func (s *ProductService) DecrementStock(productID uint, qty int) error {
	return s.db.Model(&models.Product{}).
		Where("id = ? AND stock >= ?", productID, qty).
		Update("stock", gorm.Expr("stock - ?", qty)).Error
}

// GetLowStockProducts returns products with stock below 10 units.
func (a *App) GetLowStockProducts() ([]models.Product, error) {
	return a.product.GetLowStock(10)
}

// LookupBarcode finds a product by its barcode for the POS scanner.
func (a *App) LookupBarcode(barcode string) (*models.Product, error) {
	return a.product.GetByBarcode(barcode)
}

// GetProductsByCategory returns all products in a given category.
func (a *App) GetProductsByCategory(category string) ([]models.Product, error) {
	return a.product.GetByCategory(category)
}

// ProcessSaleInput is the payload from the frontend checkout form.
type ProcessSaleInput struct {
	CustomerID    uint            `json:"customer_id"`
	PaymentMethod string          `json:"payment_method"`
	Notes         string          `json:"notes"`
	TaxRate       float64         `json:"tax_rate"`
	Items         []SaleItemInput `json:"items"`
}

// SaleItemInput represents a single line item in the cart.
type SaleItemInput struct {
	ProductID uint    `json:"product_id"`
	Quantity  int     `json:"quantity"`
	UnitPrice float64 `json:"unit_price"`
}

// ProcessSale handles the complete checkout flow within a database
// transaction. It creates the sale, line items, updates stock, and
// awards loyalty points.
func (a *App) ProcessSale(input types.ProcessSaleInput) (*models.Sale, error) {
	var sale models.Sale

	err := a.db.Transaction(func(tx *gorm.DB) error {
		// Calculate totals from line items
		var subtotal float64
		for _, item := range input.Items {
			subtotal += item.UnitPrice * float64(item.Quantity)
		}
		tax := subtotal * input.TaxRate
		total := subtotal + tax

		// 1. Create the Sale record
		sale = models.Sale{
			CustomerID:    input.CustomerID,
			Total:         total,
			Tax:           tax,
			PaymentMethod: input.PaymentMethod,
			Status:        "completed",
			Notes:         input.Notes,
		}
		if err := tx.Create(&sale).Error; err != nil {
			return fmt.Errorf("create sale: %w", err)
		}

		// 2. Create SaleItem records for each line item
		for _, item := range input.Items {
			saleItem := models.SaleItem{
				SaleID:    sale.ID,
				ProductID: item.ProductID,
				Quantity:  item.Quantity,
				UnitPrice: item.UnitPrice,
				Subtotal:  item.UnitPrice * float64(item.Quantity),
			}
			if err := tx.Create(&saleItem).Error; err != nil {
				return fmt.Errorf("create sale item: %w", err)
			}

			// 3. Decrement product stock
			result := tx.Model(&models.Product{}).
				Where("id = ? AND stock >= ?", item.ProductID, item.Quantity).
				Update("stock", gorm.Expr("stock - ?", item.Quantity))
			if result.Error != nil {
				return fmt.Errorf("decrement stock: %w", result.Error)
			}
			if result.RowsAffected == 0 {
				return fmt.Errorf("insufficient stock for product %d", item.ProductID)
			}
		}

		// 4. Award loyalty points to the customer (1 point per dollar)
		if input.CustomerID > 0 {
			points := int(total)
			err := tx.Model(&models.Customer{}).
				Where("id = ?", input.CustomerID).
				Update("loyalty_points", gorm.Expr("loyalty_points + ?", points)).Error
			if err != nil {
				return fmt.Errorf("update loyalty points: %w", err)
			}
		}

		return nil
	})

	if err != nil {
		return nil, err
	}

	return &sale, nil
}

import { useState } from "react";
import { LookupBarcode } from "../../wailsjs/go/main/App";

interface Product {
  id: number;
  name: string;
  price: number;
  stock: number;
  barcode: string;
}

interface BarcodeScannerProps {
  onProductFound: (product: Product) => void;
}

export function BarcodeScanner({ onProductFound }: BarcodeScannerProps) {
  const [barcode, setBarcode] = useState("");
  const [error, setError] = useState("");

  const handleScan = async () => {
    if (!barcode.trim()) return;
    setError("");
    try {
      const product = await LookupBarcode(barcode.trim());
      if (product) {
        onProductFound(product);
        setBarcode("");
      }
    } catch (err) {
      setError("Product not found");
    }
  };

  return (
    <div className="flex gap-2">
      <input
        type="text"
        value={barcode}
        onChange={(e) => setBarcode(e.target.value)}
        onKeyDown={(e) => e.key === "Enter" && handleScan()}
        placeholder="Scan or type barcode..."
        className="flex-1 px-3 py-2 rounded-md border bg-background"
        autoFocus
      />
      <button
        onClick={handleScan}
        className="px-4 py-2 rounded-md bg-primary text-primary-foreground"
      >
        Add
      </button>
      {error && <span className="text-destructive text-sm">{error}</span>}
    </div>
  );
}

import { useState } from "react";
import { BarcodeScanner } from "../../components/barcode-scanner";
import { ProcessSale } from "../../../wailsjs/go/main/App";

interface CartItem {
  product_id: number;
  name: string;
  quantity: number;
  unit_price: number;
}

export default function POSPage() {
  const [cart, setCart] = useState<CartItem[]>([]);
  const [paymentMethod, setPaymentMethod] = useState("cash");
  const TAX_RATE = 0.08; // 8% sales tax

  const subtotal = cart.reduce(
    (sum, item) => sum + item.unit_price * item.quantity, 0
  );
  const tax = subtotal * TAX_RATE;
  const total = subtotal + tax;

  const addToCart = (product: any) => {
    setCart((prev) => {
      const existing = prev.find((i) => i.product_id === product.id);
      if (existing) {
        return prev.map((i) =>
          i.product_id === product.id
            ? { ...i, quantity: i.quantity + 1 }
            : i
        );
      }
      return [...prev, {
        product_id: product.id,
        name: product.name,
        quantity: 1,
        unit_price: product.price,
      }];
    });
  };

  const handleCheckout = async () => {
    try {
      await ProcessSale({
        customer_id: 0,
        payment_method: paymentMethod,
        notes: "",
        tax_rate: TAX_RATE,
        items: cart.map((item) => ({
          product_id: item.product_id,
          quantity: item.quantity,
          unit_price: item.unit_price,
        })),
      });
      setCart([]);
      alert("Sale completed!");
    } catch (err) {
      alert("Error: " + err);
    }
  };

  return (
    <div className="p-6">
      <h1 className="text-2xl font-bold mb-4">Quick Sale</h1>
      <BarcodeScanner onProductFound={addToCart} />

      {/* Cart items table, totals, checkout button */}
      {/* ... build out the full UI here */}
    </div>
  );
}

// frontend/src/routes/_layout/pos.index.tsx
import { createFileRoute } from "@tanstack/react-router";

export const Route = createFileRoute("/_layout/pos/")({
  component: POSPage,
});

// ... POSPage component from above

// GenerateReceipt builds a plain-text receipt for a completed sale.
// Returns the receipt string for display or printing.
func (a *App) GenerateReceipt(saleID uint) (string, error) {
	// Fetch the sale
	var sale models.Sale
	if err := a.db.First(&sale, saleID).Error; err != nil {
		return "", fmt.Errorf("sale not found: %w", err)
	}

	// Fetch the line items
	var items []models.SaleItem
	if err := a.db.Where("sale_id = ?", saleID).Find(&items).Error; err != nil {
		return "", fmt.Errorf("fetch items: %w", err)
	}

	// Fetch product names for each item
	type lineItem struct {
		Name     string
		Qty      int
		Price    float64
		Subtotal float64
	}
	var lines []lineItem
	for _, item := range items {
		var product models.Product
		a.db.First(&product, item.ProductID)
		lines = append(lines, lineItem{
			Name:     product.Name,
			Qty:      item.Quantity,
			Price:    item.UnitPrice,
			Subtotal: item.Subtotal,
		})
	}

	// Fetch customer name if available
	customerName := "Walk-in Customer"
	if sale.CustomerID > 0 {
		var customer models.Customer
		if err := a.db.First(&customer, sale.CustomerID).Error; err == nil {
			customerName = customer.Name
		}
	}

	// Build the receipt
	var b strings.Builder
	b.WriteString("========================================\n")
	b.WriteString("            POS SYSTEM RECEIPT          \n")
	b.WriteString("========================================\n")
	b.WriteString(fmt.Sprintf("Date:     %s\n", sale.CreatedAt.Format("2006-01-02 15:04")))
	b.WriteString(fmt.Sprintf("Sale #:   %d\n", sale.ID))
	b.WriteString(fmt.Sprintf("Customer: %s\n", customerName))
	b.WriteString(fmt.Sprintf("Payment:  %s\n", sale.PaymentMethod))
	b.WriteString("----------------------------------------\n")
	b.WriteString(fmt.Sprintf("%-20s %5s %10s\n", "Item", "Qty", "Amount"))
	b.WriteString("----------------------------------------\n")
	for _, line := range lines {
		b.WriteString(fmt.Sprintf("%-20s %5d %10.2f\n", line.Name, line.Qty, line.Subtotal))
	}
	b.WriteString("----------------------------------------\n")
	b.WriteString(fmt.Sprintf("%-26s %10.2f\n", "Subtotal:", sale.Total-sale.Tax))
	b.WriteString(fmt.Sprintf("%-26s %10.2f\n", "Tax:", sale.Tax))
	b.WriteString(fmt.Sprintf("%-26s %10.2f\n", "TOTAL:", sale.Total))
	b.WriteString("========================================\n")
	b.WriteString("        Thank you for your purchase!    \n")
	b.WriteString("========================================\n")

	return b.String(), nil
}

import { GenerateReceipt } from "../../../wailsjs/go/main/App";

// After successful ProcessSale call:
const receipt = await GenerateReceipt(sale.id);
// Display in a <pre> block or open the system print dialog

// DailyReport aggregates the financial data for a single day.
type DailyReport struct {
	Date           string         `json:"date"`
	TotalSales     float64        `json:"total_sales"`
	TotalTax       float64        `json:"total_tax"`
	TotalExpenses  float64        `json:"total_expenses"`
	NetProfit      float64        `json:"net_profit"`
	TransactionCount int          `json:"transaction_count"`
	TopProducts    []TopProduct   `json:"top_products"`
}

// TopProduct represents a best-selling product for the report.
type TopProduct struct {
	ProductID   uint    `json:"product_id"`
	ProductName string  `json:"product_name"`
	QuantitySold int    `json:"quantity_sold"`
	Revenue      float64 `json:"revenue"`
}

// GetDailyReport returns aggregated sales, expenses, and profit
// for a specific date (format: "2006-01-02").
func (a *App) GetDailyReport(date string) (*types.DailyReport, error) {
	report := &types.DailyReport{Date: date}

	// Parse the date to get start and end boundaries
	start, err := time.Parse("2006-01-02", date)
	if err != nil {
		return nil, fmt.Errorf("invalid date format: %w", err)
	}
	end := start.Add(24 * time.Hour)

	// Aggregate sales
	var salesResult struct {
		Total float64
		Tax   float64
		Count int64
	}
	a.db.Model(&models.Sale{}).
		Where("created_at >= ? AND created_at < ? AND status = ?", start, end, "completed").
		Select("COALESCE(SUM(total), 0) as total, COALESCE(SUM(tax), 0) as tax, COUNT(*) as count").
		Scan(&salesResult)

	report.TotalSales = salesResult.Total
	report.TotalTax = salesResult.Tax
	report.TransactionCount = int(salesResult.Count)

	// Aggregate expenses
	var expenseTotal float64
	a.db.Model(&models.Expense{}).
		Where("date >= ? AND date < ?", start, end).
		Select("COALESCE(SUM(amount), 0)").
		Scan(&expenseTotal)

	report.TotalExpenses = expenseTotal
	report.NetProfit = report.TotalSales - report.TotalTax - report.TotalExpenses

	// Top 5 selling products
	var topProducts []types.TopProduct
	a.db.Model(&models.SaleItem{}).
		Select("sale_items.product_id, products.name as product_name, SUM(sale_items.quantity) as quantity_sold, SUM(sale_items.subtotal) as revenue").
		Joins("JOIN products ON products.id = sale_items.product_id").
		Joins("JOIN sales ON sales.id = sale_items.sale_id").
		Where("sales.created_at >= ? AND sales.created_at < ? AND sales.status = ?", start, end, "completed").
		Group("sale_items.product_id, products.name").
		Order("quantity_sold DESC").
		Limit(5).
		Scan(&topProducts)

	report.TopProducts = topProducts

	return report, nil
}

pos-system/
├── main.go                        # Wails entry point
├── app.go                         # App struct + ProcessSale, reports, receipts
├── wails.json                     # Wails project configuration
├── go.mod / go.sum
├── internal/
│   ├── config/
│   │   └── config.go              # App configuration
│   ├── db/
│   │   └── db.go                  # GORM setup + AutoMigrate (7 models)
│   ├── models/
│   │   ├── user.go                # Auth user
│   │   ├── product.go             # Product catalog
│   │   ├── customer.go            # Customer records
│   │   ├── sale.go                # Sales transactions
│   │   ├── sale_item.go           # Sale line items
│   │   └── expense.go             # Business expenses
│   ├── services/
│   │   ├── auth.go                # Authentication
│   │   ├── product.go             # Product CRUD + barcode lookup
│   │   ├── customer.go            # Customer CRUD
│   │   ├── sale.go                # Sale CRUD
│   │   ├── sale_item.go           # SaleItem CRUD
│   │   └── expense.go             # Expense CRUD
│   └── types/
│       └── types.go               # Input structs + DailyReport
├── frontend/
│   └── src/
│       ├── components/
│       │   ├── sidebar.tsx         # Navigation with all resources
│       │   └── barcode-scanner.tsx # Barcode input component
│       ├── routes/
│       │   ├── __root.tsx         # Root route
│       │   ├── _layout.tsx        # Auth guard + sidebar
│       │   └── _layout/           # Protected routes
│       │       ├── products.index.tsx
│       │       ├── customers.index.tsx
│       │       ├── sales.index.tsx
│       │       ├── sale-items.index.tsx
│       │       ├── expenses.index.tsx
│       │       └── pos.index.tsx  # Quick Sale checkout
└── cmd/
    └── studio/
        └── main.go                # GORM Studio (7 models registered)