feat(boc): v1.0 - Complete Business Operations Center

- Go backend API with full CRUD for all modules
- Rust analytics service with parallel processing
- C runtime with POSIX shared memory IPC
- PostgreSQL schema with 30+ tables
- Redis cache, Kafka event streaming
- WebSocket hub, automation engine
- PDF generation, Resend email integration
- JWT auth, multi-tenant
- Docker Compose deployment
- Nginx reverse proxy

Refs: BOC-001
This commit is contained in:
Bernt (LandveX AI)
2026-07-12 13:21:10 +00:00
commit 67a69ab073
1130 changed files with 18263 additions and 0 deletions
+296
View File
@@ -0,0 +1,296 @@
package handlers
import (
"database/sql"
"encoding/json"
"net/http"
"time"
)
type InventoryHandler struct {
DB *sql.DB
}
func NewInventoryHandler(db *sql.DB) *InventoryHandler {
return &InventoryHandler{DB: db}
}
type Warehouse struct {
ID string `json:"id"`
Name string `json:"name"`
Location string `json:"location"`
Address map[string]interface{} `json:"address"`
IsDefault bool `json:"is_default"`
CreatedAt time.Time `json:"created_at"`
}
type InventoryItem struct {
ID string `json:"id"`
ProductID string `json:"product_id"`
ProductName string `json:"product_name"`
WarehouseID string `json:"warehouse_id"`
WarehouseName string `json:"warehouse_name"`
Quantity float64 `json:"quantity"`
ReservedQty float64 `json:"reserved_qty"`
AvailableQty float64 `json:"available_qty"`
ReorderPoint float64 `json:"reorder_point"`
ReorderQty float64 `json:"reorder_qty"`
UnitCost float64 `json:"unit_cost"`
}
type InventoryMovement struct {
ID string `json:"id"`
ProductID string `json:"product_id"`
ProductName string `json:"product_name"`
WarehouseID string `json:"warehouse_id"`
Type string `json:"type"`
Quantity float64 `json:"quantity"`
ReferenceType string `json:"reference_type"`
ReferenceID string `json:"reference_id"`
Notes string `json:"notes"`
CreatedAt time.Time `json:"created_at"`
}
func (h *InventoryHandler) ListWarehouses(w http.ResponseWriter, r *http.Request) {
rows, err := h.DB.Query(`
SELECT id, name, location, address, is_default, created_at
FROM boc_warehouses ORDER BY name
`)
if err != nil {
writeError(w, http.StatusInternalServerError, "database error")
return
}
defer rows.Close()
warehouses := []Warehouse{}
for rows.Next() {
var w Warehouse
var addr []byte
if err := rows.Scan(&w.ID, &w.Name, &w.Location, &addr, &w.IsDefault, &w.CreatedAt); err != nil {
continue
}
json.Unmarshal(addr, &w.Address)
warehouses = append(warehouses, w)
}
writeJSON(w, http.StatusOK, map[string]interface{}{
"warehouses": warehouses,
"total": len(warehouses),
})
}
func (h *InventoryHandler) CreateWarehouse(w http.ResponseWriter, r *http.Request) {
var req Warehouse
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeError(w, http.StatusBadRequest, "invalid request")
return
}
addr, _ := json.Marshal(req.Address)
var id string
err := h.DB.QueryRow(`
INSERT INTO boc_warehouses (name, location, address, is_default)
VALUES ($1, $2, $3, $4)
RETURNING id
`, req.Name, req.Location, addr, req.IsDefault).Scan(&id)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to create warehouse")
return
}
writeJSON(w, http.StatusCreated, map[string]interface{}{
"id": id,
"message": "Warehouse created",
})
}
func (h *InventoryHandler) ListInventory(w http.ResponseWriter, r *http.Request) {
warehouseID := r.URL.Query().Get("warehouse_id")
var query string
var args []interface{}
if warehouseID != "" {
query = `
SELECT i.id, i.product_id, p.name, i.warehouse_id, w.name, i.quantity, i.reserved_qty, i.reorder_point, i.reorder_qty, i.unit_cost
FROM boc_inventory i
JOIN boc_products p ON i.product_id = p.id
JOIN boc_warehouses w ON i.warehouse_id = w.id
WHERE i.warehouse_id = $1
ORDER BY p.name
`
args = append(args, warehouseID)
} else {
query = `
SELECT i.id, i.product_id, p.name, i.warehouse_id, w.name, i.quantity, i.reserved_qty, i.reorder_point, i.reorder_qty, i.unit_cost
FROM boc_inventory i
JOIN boc_products p ON i.product_id = p.id
JOIN boc_warehouses w ON i.warehouse_id = w.id
ORDER BY p.name
`
}
rows, err := h.DB.Query(query, args...)
if err != nil {
writeError(w, http.StatusInternalServerError, "database error")
return
}
defer rows.Close()
items := []InventoryItem{}
for rows.Next() {
var i InventoryItem
if err := rows.Scan(&i.ID, &i.ProductID, &i.ProductName, &i.WarehouseID, &i.WarehouseName, &i.Quantity, &i.ReservedQty, &i.ReorderPoint, &i.ReorderQty, &i.UnitCost); err != nil {
continue
}
i.AvailableQty = i.Quantity - i.ReservedQty
items = append(items, i)
}
writeJSON(w, http.StatusOK, map[string]interface{}{
"inventory": items,
"total": len(items),
})
}
func (h *InventoryHandler) AdjustStock(w http.ResponseWriter, r *http.Request) {
var req struct {
ProductID string `json:"product_id"`
WarehouseID string `json:"warehouse_id"`
Quantity float64 `json:"quantity"`
Reason string `json:"reason"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeError(w, http.StatusBadRequest, "invalid request")
return
}
tx, err := h.DB.Begin()
if err != nil {
writeError(w, http.StatusInternalServerError, "transaction error")
return
}
defer tx.Rollback()
// Update or insert inventory
var existingID string
err = tx.QueryRow(`
SELECT id FROM boc_inventory WHERE product_id = $1 AND warehouse_id = $2
`, req.ProductID, req.WarehouseID).Scan(&existingID)
if err == sql.ErrNoRows {
// Insert new
_, err = tx.Exec(`
INSERT INTO boc_inventory (product_id, warehouse_id, quantity)
VALUES ($1, $2, $3)
`, req.ProductID, req.WarehouseID, req.Quantity)
} else if err == nil {
// Update existing
_, err = tx.Exec(`
UPDATE boc_inventory SET quantity = $1, updated_at = NOW() WHERE id = $2
`, req.Quantity, existingID)
}
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to update inventory")
return
}
// Record movement
_, err = tx.Exec(`
INSERT INTO boc_inventory_movements (product_id, warehouse_id, type, quantity, notes)
VALUES ($1, $2, 'adjustment', $3, $4)
`, req.ProductID, req.WarehouseID, req.Quantity, req.Reason)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to record movement")
return
}
if err := tx.Commit(); err != nil {
writeError(w, http.StatusInternalServerError, "commit failed")
return
}
writeJSON(w, http.StatusOK, map[string]interface{}{
"message": "Stock adjusted",
})
}
func (h *InventoryHandler) ListMovements(w http.ResponseWriter, r *http.Request) {
productID := r.URL.Query().Get("product_id")
var query string
var args []interface{}
if productID != "" {
query = `
SELECT m.id, m.product_id, p.name, m.warehouse_id, m.type, m.quantity, m.reference_type, m.reference_id, m.notes, m.created_at
FROM boc_inventory_movements m
JOIN boc_products p ON m.product_id = p.id
WHERE m.product_id = $1
ORDER BY m.created_at DESC
LIMIT 100
`
args = append(args, productID)
} else {
query = `
SELECT m.id, m.product_id, p.name, m.warehouse_id, m.type, m.quantity, m.reference_type, m.reference_id, m.notes, m.created_at
FROM boc_inventory_movements m
JOIN boc_products p ON m.product_id = p.id
ORDER BY m.created_at DESC
LIMIT 100
`
}
rows, err := h.DB.Query(query, args...)
if err != nil {
writeError(w, http.StatusInternalServerError, "database error")
return
}
defer rows.Close()
movements := []InventoryMovement{}
for rows.Next() {
var m InventoryMovement
if err := rows.Scan(&m.ID, &m.ProductID, &m.ProductName, &m.WarehouseID, &m.Type, &m.Quantity, &m.ReferenceType, &m.ReferenceID, &m.Notes, &m.CreatedAt); err != nil {
continue
}
movements = append(movements, m)
}
writeJSON(w, http.StatusOK, map[string]interface{}{
"movements": movements,
"total": len(movements),
})
}
func (h *InventoryHandler) GetLowStock(w http.ResponseWriter, r *http.Request) {
rows, err := h.DB.Query(`
SELECT i.id, i.product_id, p.name, i.warehouse_id, w.name, i.quantity, i.reserved_qty, i.reorder_point, i.reorder_qty
FROM boc_inventory i
JOIN boc_products p ON i.product_id = p.id
JOIN boc_warehouses w ON i.warehouse_id = w.id
WHERE i.quantity <= i.reorder_point
ORDER BY (i.quantity / NULLIF(i.reorder_point, 0))
`)
if err != nil {
writeError(w, http.StatusInternalServerError, "database error")
return
}
defer rows.Close()
items := []InventoryItem{}
for rows.Next() {
var i InventoryItem
if err := rows.Scan(&i.ID, &i.ProductID, &i.ProductName, &i.WarehouseID, &i.WarehouseName, &i.Quantity, &i.ReservedQty, &i.ReorderPoint, &i.ReorderQty); err != nil {
continue
}
i.AvailableQty = i.Quantity - i.ReservedQty
items = append(items, i)
}
writeJSON(w, http.StatusOK, map[string]interface{}{
"low_stock": items,
"total": len(items),
})
}