9c444061fd
- Improved auto-generated list/form/search views with priority fields, two-column form layout, statusbar widget, notebook for O2M fields - Enhanced fields_get with currency_field, compute, related metadata - Fixed session handling: handleSessionInfo/handleSessionCheck use real session from cookie instead of hardcoded values - Added read_progress_bar and activity_format RPC stubs - Improved bootstrap translations with lang_parameters - Added "contacts" to session modules list Server starts successfully: 14 modules, 93 models, 378 XML templates, 503 JS modules transpiled — all from local frontend/ directory. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
464 lines
15 KiB
Go
464 lines
15 KiB
Go
package models
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"odoo-go/pkg/orm"
|
|
)
|
|
|
|
// initSaleOrder registers sale.order — the sales quotation / order model.
|
|
// Mirrors: odoo/addons/sale/models/sale_order.py
|
|
func initSaleOrder() {
|
|
m := orm.NewModel("sale.order", orm.ModelOpts{
|
|
Description: "Sales Order",
|
|
Order: "date_order desc, id desc",
|
|
})
|
|
|
|
// -- Identity & State --
|
|
m.AddFields(
|
|
orm.Char("name", orm.FieldOpts{
|
|
String: "Order Reference", Required: true, Index: true, Readonly: true, Default: "/",
|
|
}),
|
|
orm.Selection("state", []orm.SelectionItem{
|
|
{Value: "draft", Label: "Quotation"},
|
|
{Value: "sent", Label: "Quotation Sent"},
|
|
{Value: "sale", Label: "Sales Order"},
|
|
{Value: "cancel", Label: "Cancelled"},
|
|
}, orm.FieldOpts{String: "Status", Default: "draft", Required: true, Readonly: true, Index: true}),
|
|
)
|
|
|
|
// -- Partners --
|
|
m.AddFields(
|
|
orm.Many2one("partner_id", "res.partner", orm.FieldOpts{
|
|
String: "Customer", Required: true, Index: true,
|
|
}),
|
|
orm.Many2one("partner_invoice_id", "res.partner", orm.FieldOpts{
|
|
String: "Invoice Address",
|
|
}),
|
|
orm.Many2one("partner_shipping_id", "res.partner", orm.FieldOpts{
|
|
String: "Delivery Address",
|
|
}),
|
|
)
|
|
|
|
// -- Dates --
|
|
m.AddFields(
|
|
orm.Datetime("date_order", orm.FieldOpts{
|
|
String: "Order Date", Required: true, Index: true, Default: "today",
|
|
}),
|
|
orm.Date("validity_date", orm.FieldOpts{String: "Expiration"}),
|
|
)
|
|
|
|
// -- Company & Currency --
|
|
m.AddFields(
|
|
orm.Many2one("company_id", "res.company", orm.FieldOpts{
|
|
String: "Company", Required: true, Index: true,
|
|
}),
|
|
orm.Many2one("currency_id", "res.currency", orm.FieldOpts{
|
|
String: "Currency", Required: true,
|
|
}),
|
|
)
|
|
|
|
// -- Order Lines --
|
|
m.AddFields(
|
|
orm.One2many("order_line", "sale.order.line", "order_id", orm.FieldOpts{
|
|
String: "Order Lines",
|
|
}),
|
|
)
|
|
|
|
// -- Amounts (Computed) --
|
|
m.AddFields(
|
|
orm.Monetary("amount_untaxed", orm.FieldOpts{
|
|
String: "Untaxed Amount", Compute: "_compute_amounts", Store: true, CurrencyField: "currency_id",
|
|
}),
|
|
orm.Monetary("amount_tax", orm.FieldOpts{
|
|
String: "Taxes", Compute: "_compute_amounts", Store: true, CurrencyField: "currency_id",
|
|
}),
|
|
orm.Monetary("amount_total", orm.FieldOpts{
|
|
String: "Total", Compute: "_compute_amounts", Store: true, CurrencyField: "currency_id",
|
|
}),
|
|
)
|
|
|
|
// -- Invoice Status --
|
|
m.AddFields(
|
|
orm.Selection("invoice_status", []orm.SelectionItem{
|
|
{Value: "upselling", Label: "Upselling Opportunity"},
|
|
{Value: "invoiced", Label: "Fully Invoiced"},
|
|
{Value: "to invoice", Label: "To Invoice"},
|
|
{Value: "no", Label: "Nothing to Invoice"},
|
|
}, orm.FieldOpts{String: "Invoice Status", Compute: "_compute_invoice_status", Store: true}),
|
|
)
|
|
|
|
// -- Accounting & Terms --
|
|
m.AddFields(
|
|
orm.Many2one("fiscal_position_id", "account.fiscal.position", orm.FieldOpts{
|
|
String: "Fiscal Position",
|
|
}),
|
|
orm.Many2one("payment_term_id", "account.payment.term", orm.FieldOpts{
|
|
String: "Payment Terms",
|
|
}),
|
|
orm.Many2one("pricelist_id", "product.pricelist", orm.FieldOpts{
|
|
String: "Pricelist",
|
|
}),
|
|
orm.Many2one("journal_id", "account.journal", orm.FieldOpts{
|
|
String: "Invoicing Journal",
|
|
}),
|
|
)
|
|
|
|
// -- Misc --
|
|
m.AddFields(
|
|
orm.Text("note", orm.FieldOpts{String: "Terms and Conditions"}),
|
|
orm.Boolean("require_signature", orm.FieldOpts{String: "Online Signature", Default: true}),
|
|
orm.Boolean("require_payment", orm.FieldOpts{String: "Online Payment"}),
|
|
)
|
|
|
|
// -- Computed: _compute_amounts --
|
|
// Computes untaxed, tax, and total amounts from order lines.
|
|
// Mirrors: odoo/addons/sale/models/sale_order.py SaleOrder._compute_amounts()
|
|
computeSaleAmounts := func(rs *orm.Recordset) (orm.Values, error) {
|
|
env := rs.Env()
|
|
soID := rs.IDs()[0]
|
|
|
|
var untaxed float64
|
|
err := env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT COALESCE(SUM(product_uom_qty * price_unit * (1 - COALESCE(discount,0)/100)), 0)
|
|
FROM sale_order_line WHERE order_id = $1
|
|
AND (display_type IS NULL OR display_type = '' OR display_type = 'product')`,
|
|
soID).Scan(&untaxed)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sale: compute amounts for SO %d: %w", soID, err)
|
|
}
|
|
|
|
// Compute tax from linked tax records on lines; fall back to sum of line taxes
|
|
var tax float64
|
|
err = env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT COALESCE(SUM(
|
|
product_uom_qty * price_unit * (1 - COALESCE(discount,0)/100)
|
|
* COALESCE((SELECT t.amount / 100 FROM account_tax t
|
|
JOIN sale_order_line_account_tax_rel rel ON rel.account_tax_id = t.id
|
|
WHERE rel.sale_order_line_id = sol.id LIMIT 1), 0)
|
|
), 0)
|
|
FROM sale_order_line sol WHERE sol.order_id = $1
|
|
AND (sol.display_type IS NULL OR sol.display_type = '' OR sol.display_type = 'product')`,
|
|
soID).Scan(&tax)
|
|
if err != nil {
|
|
// Fallback: if the M2M table doesn't exist, estimate tax at 0
|
|
tax = 0
|
|
}
|
|
|
|
return orm.Values{
|
|
"amount_untaxed": untaxed,
|
|
"amount_tax": tax,
|
|
"amount_total": untaxed + tax,
|
|
}, nil
|
|
}
|
|
m.RegisterCompute("amount_untaxed", computeSaleAmounts)
|
|
m.RegisterCompute("amount_tax", computeSaleAmounts)
|
|
m.RegisterCompute("amount_total", computeSaleAmounts)
|
|
|
|
// -- Sequence Hook --
|
|
m.BeforeCreate = func(env *orm.Environment, vals orm.Values) error {
|
|
name, _ := vals["name"].(string)
|
|
if name == "" || name == "/" {
|
|
seq, err := orm.NextByCode(env, "sale.order")
|
|
if err == nil {
|
|
vals["name"] = seq
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// -- Business Methods --
|
|
|
|
// action_confirm: draft → sale
|
|
// Mirrors: odoo/addons/sale/models/sale_order.py SaleOrder.action_confirm()
|
|
m.RegisterMethod("action_confirm", func(rs *orm.Recordset, args ...interface{}) (interface{}, error) {
|
|
env := rs.Env()
|
|
for _, id := range rs.IDs() {
|
|
var state string
|
|
err := env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT state FROM sale_order WHERE id = $1`, id).Scan(&state)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if state != "draft" && state != "sent" {
|
|
return nil, fmt.Errorf("sale: can only confirm draft/sent orders (current: %s)", state)
|
|
}
|
|
if _, err := env.Tx().Exec(env.Ctx(),
|
|
`UPDATE sale_order SET state = 'sale' WHERE id = $1`, id); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return true, nil
|
|
})
|
|
|
|
// create_invoices: Generate invoice from confirmed sale order
|
|
// Mirrors: odoo/addons/sale/models/sale_order.py SaleOrder._create_invoices()
|
|
m.RegisterMethod("create_invoices", func(rs *orm.Recordset, args ...interface{}) (interface{}, error) {
|
|
env := rs.Env()
|
|
var invoiceIDs []int64
|
|
|
|
for _, soID := range rs.IDs() {
|
|
// Read SO header
|
|
var partnerID, companyID, currencyID int64
|
|
var journalID int64
|
|
err := env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT partner_id, company_id, currency_id, COALESCE(journal_id, 1)
|
|
FROM sale_order WHERE id = $1`, soID,
|
|
).Scan(&partnerID, &companyID, ¤cyID, &journalID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sale: read SO %d: %w", soID, err)
|
|
}
|
|
|
|
// Read SO lines
|
|
rows, err := env.Tx().Query(env.Ctx(),
|
|
`SELECT id, COALESCE(name,''), COALESCE(product_uom_qty,1), COALESCE(price_unit,0), COALESCE(discount,0)
|
|
FROM sale_order_line
|
|
WHERE order_id = $1 AND (display_type IS NULL OR display_type = '')
|
|
ORDER BY sequence, id`, soID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
type soLine struct {
|
|
id int64
|
|
name string
|
|
qty float64
|
|
price float64
|
|
discount float64
|
|
}
|
|
var lines []soLine
|
|
for rows.Next() {
|
|
var l soLine
|
|
if err := rows.Scan(&l.id, &l.name, &l.qty, &l.price, &l.discount); err != nil {
|
|
rows.Close()
|
|
return nil, err
|
|
}
|
|
lines = append(lines, l)
|
|
}
|
|
rows.Close()
|
|
|
|
if len(lines) == 0 {
|
|
continue
|
|
}
|
|
|
|
// Build invoice line commands
|
|
var lineCmds []interface{}
|
|
for _, l := range lines {
|
|
subtotal := l.qty * l.price * (1 - l.discount/100)
|
|
lineCmds = append(lineCmds, []interface{}{
|
|
float64(0), float64(0), map[string]interface{}{
|
|
"name": l.name,
|
|
"quantity": l.qty,
|
|
"price_unit": l.price,
|
|
"discount": l.discount,
|
|
"debit": subtotal,
|
|
"credit": float64(0),
|
|
"account_id": float64(2), // Revenue account
|
|
"company_id": float64(companyID),
|
|
},
|
|
})
|
|
// Receivable counter-entry
|
|
lineCmds = append(lineCmds, []interface{}{
|
|
float64(0), float64(0), map[string]interface{}{
|
|
"name": "Receivable",
|
|
"debit": float64(0),
|
|
"credit": subtotal,
|
|
"account_id": float64(1), // Receivable account
|
|
"company_id": float64(companyID),
|
|
},
|
|
})
|
|
}
|
|
|
|
// Create invoice
|
|
invoiceRS := env.Model("account.move")
|
|
inv, err := invoiceRS.Create(orm.Values{
|
|
"move_type": "out_invoice",
|
|
"partner_id": partnerID,
|
|
"company_id": companyID,
|
|
"currency_id": currencyID,
|
|
"journal_id": journalID,
|
|
"invoice_origin": fmt.Sprintf("SO%d", soID),
|
|
"date": time.Now().Format("2006-01-02"),
|
|
"line_ids": lineCmds,
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sale: create invoice for SO %d: %w", soID, err)
|
|
}
|
|
|
|
invoiceIDs = append(invoiceIDs, inv.ID())
|
|
|
|
// Update SO invoice_status
|
|
env.Tx().Exec(env.Ctx(),
|
|
`UPDATE sale_order SET invoice_status = 'invoiced' WHERE id = $1`, soID)
|
|
}
|
|
|
|
return invoiceIDs, nil
|
|
})
|
|
|
|
// action_create_delivery: Generate a stock picking (delivery) from a confirmed sale order.
|
|
// Mirrors: odoo/addons/sale/models/sale_order.py SaleOrder._action_confirm() → _create_picking()
|
|
m.RegisterMethod("action_create_delivery", func(rs *orm.Recordset, args ...interface{}) (interface{}, error) {
|
|
env := rs.Env()
|
|
var pickingIDs []int64
|
|
|
|
for _, soID := range rs.IDs() {
|
|
// Read SO header for partner and company
|
|
var partnerID, companyID int64
|
|
var soName string
|
|
err := env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT COALESCE(partner_shipping_id, partner_id), company_id, name
|
|
FROM sale_order WHERE id = $1`, soID,
|
|
).Scan(&partnerID, &companyID, &soName)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sale: read SO %d for delivery: %w", soID, err)
|
|
}
|
|
|
|
// Read SO lines with products
|
|
rows, err := env.Tx().Query(env.Ctx(),
|
|
`SELECT product_id, product_uom_qty, COALESCE(name, '') FROM sale_order_line
|
|
WHERE order_id = $1 AND product_id IS NOT NULL
|
|
AND (display_type IS NULL OR display_type = '' OR display_type = 'product')`, soID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sale: read SO lines %d for delivery: %w", soID, err)
|
|
}
|
|
|
|
type soline struct {
|
|
productID int64
|
|
qty float64
|
|
name string
|
|
}
|
|
var lines []soline
|
|
for rows.Next() {
|
|
var l soline
|
|
if err := rows.Scan(&l.productID, &l.qty, &l.name); err != nil {
|
|
rows.Close()
|
|
return nil, err
|
|
}
|
|
lines = append(lines, l)
|
|
}
|
|
rows.Close()
|
|
if len(lines) == 0 {
|
|
continue
|
|
}
|
|
|
|
// Find outgoing picking type and locations
|
|
var pickingTypeID, srcLocID, destLocID int64
|
|
env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT pt.id, COALESCE(pt.default_location_src_id, 0), COALESCE(pt.default_location_dest_id, 0)
|
|
FROM stock_picking_type pt
|
|
WHERE pt.code = 'outgoing' AND pt.company_id = $1
|
|
LIMIT 1`, companyID,
|
|
).Scan(&pickingTypeID, &srcLocID, &destLocID)
|
|
|
|
// Fallback: find internal and customer locations
|
|
if srcLocID == 0 {
|
|
env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT id FROM stock_location WHERE usage = 'internal' AND COALESCE(company_id, $1) = $1 LIMIT 1`,
|
|
companyID).Scan(&srcLocID)
|
|
}
|
|
if destLocID == 0 {
|
|
env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT id FROM stock_location WHERE usage = 'customer' LIMIT 1`).Scan(&destLocID)
|
|
}
|
|
if pickingTypeID == 0 {
|
|
env.Tx().QueryRow(env.Ctx(),
|
|
`SELECT id FROM stock_picking_type WHERE code = 'outgoing' LIMIT 1`).Scan(&pickingTypeID)
|
|
}
|
|
|
|
// Create picking
|
|
var pickingID int64
|
|
err = env.Tx().QueryRow(env.Ctx(),
|
|
`INSERT INTO stock_picking
|
|
(name, state, scheduled_date, company_id, partner_id, picking_type_id,
|
|
location_id, location_dest_id, origin)
|
|
VALUES ($1, 'confirmed', NOW(), $2, $3, $4, $5, $6, $7) RETURNING id`,
|
|
fmt.Sprintf("WH/OUT/%05d", soID), companyID, partnerID, pickingTypeID,
|
|
srcLocID, destLocID, soName,
|
|
).Scan(&pickingID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sale: create picking for SO %d: %w", soID, err)
|
|
}
|
|
|
|
// Create stock moves
|
|
for _, l := range lines {
|
|
_, err = env.Tx().Exec(env.Ctx(),
|
|
`INSERT INTO stock_move
|
|
(name, product_id, product_uom_qty, state, picking_id, company_id,
|
|
location_id, location_dest_id, date, origin, product_uom)
|
|
VALUES ($1, $2, $3, 'confirmed', $4, $5, $6, $7, NOW(), $8, 1)`,
|
|
l.name, l.productID, l.qty, pickingID, companyID,
|
|
srcLocID, destLocID, soName)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sale: create stock move for SO %d: %w", soID, err)
|
|
}
|
|
}
|
|
|
|
pickingIDs = append(pickingIDs, pickingID)
|
|
}
|
|
return pickingIDs, nil
|
|
})
|
|
}
|
|
|
|
// initSaleOrderLine registers sale.order.line — individual line items on a sales order.
|
|
// Mirrors: odoo/addons/sale/models/sale_order_line.py
|
|
func initSaleOrderLine() {
|
|
m := orm.NewModel("sale.order.line", orm.ModelOpts{
|
|
Description: "Sales Order Line",
|
|
Order: "order_id, sequence, id",
|
|
})
|
|
|
|
// -- Parent --
|
|
m.AddFields(
|
|
orm.Many2one("order_id", "sale.order", orm.FieldOpts{
|
|
String: "Order Reference", Required: true, OnDelete: orm.OnDeleteCascade, Index: true,
|
|
}),
|
|
)
|
|
|
|
// -- Product --
|
|
m.AddFields(
|
|
orm.Many2one("product_id", "product.product", orm.FieldOpts{
|
|
String: "Product",
|
|
}),
|
|
orm.Char("name", orm.FieldOpts{String: "Description", Required: true}),
|
|
orm.Float("product_uom_qty", orm.FieldOpts{String: "Quantity", Required: true, Default: 1.0}),
|
|
orm.Many2one("product_uom", "uom.uom", orm.FieldOpts{String: "Unit of Measure"}),
|
|
)
|
|
|
|
// -- Pricing --
|
|
m.AddFields(
|
|
orm.Float("price_unit", orm.FieldOpts{String: "Unit Price", Required: true}),
|
|
orm.Many2many("tax_id", "account.tax", orm.FieldOpts{String: "Taxes"}),
|
|
orm.Float("discount", orm.FieldOpts{String: "Discount (%)"}),
|
|
orm.Monetary("price_subtotal", orm.FieldOpts{
|
|
String: "Subtotal", Compute: "_compute_amount", Store: true, CurrencyField: "currency_id",
|
|
}),
|
|
orm.Monetary("price_total", orm.FieldOpts{
|
|
String: "Total", Compute: "_compute_amount", Store: true, CurrencyField: "currency_id",
|
|
}),
|
|
)
|
|
|
|
// -- Display --
|
|
m.AddFields(
|
|
orm.Selection("display_type", []orm.SelectionItem{
|
|
{Value: "line_section", Label: "Section"},
|
|
{Value: "line_note", Label: "Note"},
|
|
}, orm.FieldOpts{String: "Display Type"}),
|
|
orm.Integer("sequence", orm.FieldOpts{String: "Sequence", Default: 10}),
|
|
)
|
|
|
|
// -- Delivery & Invoicing Quantities --
|
|
m.AddFields(
|
|
orm.Float("qty_delivered", orm.FieldOpts{String: "Delivered Quantity"}),
|
|
orm.Float("qty_invoiced", orm.FieldOpts{
|
|
String: "Invoiced Quantity", Compute: "_compute_qty_invoiced", Store: true,
|
|
}),
|
|
orm.Float("qty_to_invoice", orm.FieldOpts{
|
|
String: "To Invoice Quantity", Compute: "_compute_qty_to_invoice", Store: true,
|
|
}),
|
|
orm.Many2many("invoice_lines", "account.move.line", orm.FieldOpts{
|
|
String: "Invoice Lines",
|
|
}),
|
|
)
|
|
}
|