Complete ORM gaps + server features + module depth push

ORM:
- SQL Constraints support (Model.AddSQLConstraint, applied in InitDatabase)
- Translatable field Read (ir_translation lookup for non-en_US)
- active_test filter in SearchCount + ReadGroup (consistency with Search)
- Environment.Ref() improved (format validation, parameterized query)

Server:
- /web/action/run endpoint (server action execution stub)
- /web/model/get_definitions (field metadata for multiple models)
- Binary field serving rewritten: reads from DB, falls back to SVG
  with record initial (fixes avatar/logo rendering)

Business modules deepened:
- Account: action_post validation (partner, lines), sequence numbering
  (JOURNAL/YYYY/NNNN), action_register_payment, remove_move_reconcile
- Sale: action_cancel, action_draft, action_view_invoice
- Purchase: button_draft
- Stock: action_cancel on picking
- CRM: action_set_won_rainbowman, convert_opportunity
- HR: hr.contract model (employee, wage, dates, state)
- Project: action_blocked, task stage seed data

Views:
- Cancel/Reset buttons in sale.form header
- Register Payment button in invoice.form (visible when posted+unpaid)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

pkg/orm/environment.go

@@ -3,6 +3,8 @@ package orm
 import (
 	"context"
 	"fmt"
+	"strconv"
+	"strings"
 
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
@@ -76,13 +78,23 @@ func (env *Environment) Model(name string) *Recordset {
 // Ref returns a record by its XML ID (external identifier).
 // Mirrors: self.env.ref('module.xml_id')
 func (env *Environment) Ref(xmlID string) (*Recordset, error) {
+	// Try direct integer ID (for programmatic use) — reject since model is unknown
+	if id, err := strconv.ParseInt(xmlID, 10, 64); err == nil {
+		return nil, fmt.Errorf("orm: ref requires module.name format, not bare ID %d", id)
+	}
+
 	// Query ir_model_data for the external ID
 	var resModel string
 	var resID int64
 
+	parts := strings.SplitN(xmlID, ".", 2)
+	if len(parts) != 2 {
+		return nil, fmt.Errorf("orm: ref %q must be module.name format", xmlID)
+	}
+
 	err := env.tx.QueryRow(env.ctx,
-		`SELECT model, res_id FROM ir_model_data WHERE module || '.' || name = $1 LIMIT 1`,
+		`SELECT model, res_id FROM ir_model_data WHERE module = $1 AND name = $2 LIMIT 1`,
-		xmlID,
+		parts[0], parts[1],
 	).Scan(&resModel, &resID)
 	if err != nil {
 		return nil, fmt.Errorf("orm: ref %q not found: %w", xmlID, err)

pkg/orm/model.go

@@ -50,6 +50,9 @@ type Model struct {
 	Constraints  []ConstraintFunc                                 // Validation constraints
 	Methods      map[string]MethodFunc                            // Named business methods
 
+	// SQL-level constraints
+	SQLConstraints []SQLConstraint
+
 	// Computed fields
 	computes      map[string]ComputeFunc // field_name → compute function
 	dependencyMap map[string][]string    // trigger_field → []computed_field_names
@@ -216,6 +219,19 @@ func (m *Model) IsAbstract() bool { return m.modelType == ModelAbstract }
 // IsTransient returns true if this is a wizard/temporary model.
 func (m *Model) IsTransient() bool { return m.modelType == ModelTransient }
 
+// SQLConstraint represents a SQL-level constraint on a model's table.
+// Mirrors: _sql_constraints in Odoo.
+type SQLConstraint struct {
+	Name       string // Constraint name
+	Definition string // SQL definition (e.g., "UNIQUE(name, company_id)")
+	Message    string // Error message
+}
+
+// AddSQLConstraint registers a SQL-level constraint on this model.
+func (m *Model) AddSQLConstraint(name, definition, message string) {
+	m.SQLConstraints = append(m.SQLConstraints, SQLConstraint{Name: name, Definition: definition, Message: message})
+}
+
 // ConstraintFunc validates a recordset. Returns error if constraint violated.
 // Mirrors: @api.constrains in Odoo.
 type ConstraintFunc func(rs *Recordset) error

pkg/orm/read_group.go

@@ -46,6 +46,25 @@ func (rs *Recordset) ReadGroup(domain Domain, groupby []string, aggregates []str
 		opt = opts[0]
 	}
 
+	// Auto-filter archived records unless active_test=false in context
+	// Mirrors: odoo/orm/models.py BaseModel._where_calc()
+	if activeField := m.GetField("active"); activeField != nil {
+		activeTest := true
+		if v, ok := rs.env.context["active_test"]; ok {
+			if b, ok := v.(bool); ok {
+				activeTest = b
+			}
+		}
+		if activeTest {
+			activeLeaf := Leaf("active", "=", true)
+			if len(domain) == 0 {
+				domain = Domain{activeLeaf}
+			} else {
+				domain = append(Domain{OpAnd}, append(domain, activeLeaf)...)
+			}
+		}
+	}
+
 	// Apply record rules
 	domain = ApplyRecordRules(rs.env, m, domain)
 

pkg/orm/recordset.go

@@ -591,6 +591,33 @@ func (rs *Recordset) Read(fields []string) ([]Values, error) {
 		}
 	}
 
+	// Post-fetch: translations for non-English languages
+	// Mirrors: odoo/orm/models.py BaseModel._read() translation lookup
+	if rs.env.Lang() != "en_US" && rs.env.Lang() != "" {
+		for _, fname := range storedFields {
+			f := m.GetField(fname)
+			if f == nil || !f.Translate {
+				continue
+			}
+			for _, rec := range results {
+				srcVal, _ := rec[fname].(string)
+				if srcVal == "" {
+					continue
+				}
+				var translated string
+				err := rs.env.tx.QueryRow(rs.env.ctx,
+					`SELECT value FROM ir_translation
+					 WHERE lang = $1 AND src = $2 AND value != ''
+					 LIMIT 1`,
+					rs.env.Lang(), srcVal,
+				).Scan(&translated)
+				if err == nil && translated != "" {
+					rec[fname] = translated
+				}
+			}
+		}
+	}
+
 	// Post-fetch: M2M fields (from junction tables)
 	if len(m2mFields) > 0 && len(rs.ids) > 0 {
 		for _, fname := range m2mFields {
@@ -779,6 +806,25 @@ func (rs *Recordset) Search(domain Domain, opts ...SearchOpts) (*Recordset, erro
 func (rs *Recordset) SearchCount(domain Domain) (int64, error) {
 	m := rs.model
 
+	// Auto-filter archived records unless active_test=false in context
+	// Mirrors: odoo/orm/models.py BaseModel._where_calc()
+	if activeField := m.GetField("active"); activeField != nil {
+		activeTest := true
+		if v, ok := rs.env.context["active_test"]; ok {
+			if b, ok := v.(bool); ok {
+				activeTest = b
+			}
+		}
+		if activeTest {
+			activeLeaf := Leaf("active", "=", true)
+			if len(domain) == 0 {
+				domain = Domain{activeLeaf}
+			} else {
+				domain = append(Domain{OpAnd}, append(domain, activeLeaf)...)
+			}
+		}
+	}
+
 	compiler := &DomainCompiler{model: m, env: rs.env}
 	where, params, err := compiler.Compile(domain)
 	if err != nil {

pkg/server/action.go

@@ -7,6 +7,31 @@ import (
 	"strings"
 )
 
+// handleActionRun executes a server action by ID.
+// Mirrors: odoo/addons/web/controllers/action.py Action.run()
+//
+// In Python Odoo this executes ir.actions.server records (Python code, email, etc.).
+// In Go we just dispatch to registered methods; for now, return false (no follow-up action).
+func (s *Server) handleActionRun(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	var req JSONRPCRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		s.writeJSONRPC(w, nil, nil, &RPCError{Code: -32700, Message: "Parse error"})
+		return
+	}
+	var params struct {
+		ActionID interface{} `json:"action_id"`
+		Context  interface{} `json:"context"`
+	}
+	json.Unmarshal(req.Params, &params)
+
+	// For now, just return false (no follow-up action)
+	s.writeJSONRPC(w, req.ID, false, nil)
+}
+
 // handleLoadBreadcrumbs returns breadcrumb data for the current navigation path.
 // Mirrors: odoo/addons/web/controllers/action.py Action.load_breadcrumbs()
 func (s *Server) handleLoadBreadcrumbs(w http.ResponseWriter, r *http.Request) {

pkg/server/image.go

@@ -1,62 +1,94 @@
 package server
 
 import (
+	"fmt"
 	"net/http"
+	"strconv"
 	"strings"
+
+	"odoo-go/pkg/orm"
 )
 
 // handleImage serves images for model records.
 // Mirrors: odoo/addons/web/controllers/binary.py content_image()
-// For now, return SVG placeholders that look like real Odoo avatars.
+//
+// The client requests images like:
+//   /web/image/res.partner/5/avatar_128
+//   /web/image/product.product/1/image_1920
+//
+// We first try to read the binary field from the database.
+// If no data is found, we fall back to an SVG placeholder.
 func (s *Server) handleImage(w http.ResponseWriter, r *http.Request) {
-	field := r.URL.Query().Get("field")
+	// Parse: /web/image/<model>/<id>/<field>
-	model := r.URL.Query().Get("model")
+	parts := strings.Split(strings.TrimPrefix(r.URL.Path, "/web/image/"), "/")
 
-	// Also parse path-style URLs: /web/image/res.partner/2/avatar_128
+	model := ""
-	path := strings.TrimPrefix(r.URL.Path, "/web/image/")
+	id := int64(0)
-	if model == "" && path != "" && path != r.URL.Path {
+	field := "image_1920"
-		pathParts := strings.Split(path, "/")
+
-		if len(pathParts) >= 3 {
+	// Also accept query parameters (legacy format)
-			model = pathParts[0]
+	if qm := r.URL.Query().Get("model"); qm != "" {
-			field = pathParts[2]
+		model = qm
-		} else if len(pathParts) >= 1 {
+	}
-			model = pathParts[0]
+	if qf := r.URL.Query().Get("field"); qf != "" {
+		field = qf
+	}
+
+	if len(parts) >= 1 && parts[0] != "" {
+		model = parts[0]
+	}
+	if len(parts) >= 2 {
+		if n, err := strconv.ParseInt(parts[1], 10, 64); err == nil {
+			id = n
+		}
+	}
+	if len(parts) >= 3 && parts[2] != "" {
+		field = parts[2]
+	}
+
+	// Try to read binary data from DB
+	if model != "" && id > 0 {
+		m := orm.Registry.Get(model)
+		if m != nil {
+			f := m.GetField(field)
+			if f != nil && f.Type == orm.TypeBinary {
+				table := m.Table()
+				var data []byte
+				ctx := r.Context()
+				_ = s.pool.QueryRow(ctx,
+					fmt.Sprintf(`SELECT "%s" FROM "%s" WHERE id = $1`, f.Column(), table), id,
+				).Scan(&data)
+				if len(data) > 0 {
+					// Detect content type
+					contentType := http.DetectContentType(data)
+					w.Header().Set("Content-Type", contentType)
+					w.Header().Set("Cache-Control", "public, max-age=604800")
+					w.Write(data)
+					return
+				}
+			}
 		}
 	}
 
-	// Company logo: return a styled SVG with company initial
+	// Fallback: SVG placeholder with the record's initial letter
-	if model == "res.company" && (field == "logo" || field == "logo_web") {
+	initial := "?"
-		w.Header().Set("Content-Type", "image/svg+xml")
+	if model != "" && id > 0 {
-		w.Header().Set("Cache-Control", "public, max-age=3600")
+		m := orm.Registry.Get(model)
-		w.Write([]byte(`<svg xmlns="http://www.w3.org/2000/svg" width="100" height="30" viewBox="0 0 100 30">
+		if m != nil {
-  <rect width="100" height="30" rx="4" fill="#71639e"/>
+			var name string
-  <text x="50" y="20" font-family="sans-serif" font-size="14" fill="white" text-anchor="middle">Odoo</text>
+			_ = s.pool.QueryRow(r.Context(),
-</svg>`))
+				fmt.Sprintf(`SELECT COALESCE(name, '') FROM "%s" WHERE id = $1`, m.Table()), id,
-		return
+			).Scan(&name)
+			if len(name) > 0 {
+				initial = strings.ToUpper(name[:1])
+			}
+		}
 	}
 
-	// User avatar: return a colored circle with initial
+	w.Header().Set("Content-Type", "image/svg+xml")
-	if (model == "res.partner" || model == "res.users") &&
+	w.Header().Set("Cache-Control", "public, max-age=604800")
-		(field == "avatar_128" || field == "avatar_256" || field == "image_128" || field == "image_256" || strings.HasPrefix(field, "avatar") || strings.HasPrefix(field, "image")) {
+	fmt.Fprintf(w, `<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">
-		w.Header().Set("Content-Type", "image/svg+xml")
-		w.Header().Set("Cache-Control", "public, max-age=3600")
-		w.Write([]byte(`<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">
   <rect width="64" height="64" rx="32" fill="#71639e"/>
-  <text x="32" y="40" font-family="sans-serif" font-size="28" fill="white" text-anchor="middle">U</text>
+  <text x="32" y="40" font-family="sans-serif" font-size="28" fill="white" text-anchor="middle">%s</text>
-</svg>`))
+</svg>`, initial)
-		return
-	}
-
-	// Default: 1x1 transparent PNG
-	w.Header().Set("Content-Type", "image/png")
-	w.Header().Set("Cache-Control", "public, max-age=3600")
-	png := []byte{
-		0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
-		0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
-		0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x15, 0xc4, 0x89, 0x00, 0x00, 0x00,
-		0x0a, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x62, 0x00, 0x00, 0x00, 0x02,
-		0x00, 0x01, 0xe5, 0x27, 0xde, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45,
-		0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
-	}
-	w.Write(png)
 }

pkg/server/server.go

@@ -100,6 +100,10 @@ func (s *Server) registerRoutes() {
 	// Action loading
 	s.mux.HandleFunc("/web/action/load", s.handleActionLoad)
 	s.mux.HandleFunc("/web/action/load_breadcrumbs", s.handleLoadBreadcrumbs)
+	s.mux.HandleFunc("/web/action/run", s.handleActionRun)
+
+	// Model definitions
+	s.mux.HandleFunc("/web/model/get_definitions", s.handleGetDefinitions)
 
 	// Database endpoints
 	s.mux.HandleFunc("/web/database/list", s.handleDBList)

pkg/server/views.go

@@ -1,12 +1,38 @@
 package server
 
 import (
+	"encoding/json"
 	"fmt"
+	"net/http"
 	"strings"
 
 	"odoo-go/pkg/orm"
 )
 
+// handleGetDefinitions returns field definitions for one or more models.
+// Mirrors: odoo/addons/web/controllers/model.py Model.get_definitions()
+func (s *Server) handleGetDefinitions(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	var req JSONRPCRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		s.writeJSONRPC(w, nil, nil, &RPCError{Code: -32700, Message: "Parse error"})
+		return
+	}
+	var params struct {
+		Models []string `json:"model_names"`
+	}
+	json.Unmarshal(req.Params, &params)
+
+	result := make(map[string]interface{})
+	for _, modelName := range params.Models {
+		result[modelName] = fieldsGetForModel(modelName)
+	}
+	s.writeJSONRPC(w, req.ID, result, nil)
+}
+
 // handleGetViews implements the get_views method.
 // Mirrors: odoo/addons/base/models/ir_ui_view.py get_views()
 func handleGetViews(env *orm.Environment, model string, params CallKWParams) (interface{}, *RPCError) {

pkg/service/db.go

@@ -7,6 +7,7 @@ import (
 	"crypto/rand"
 	"fmt"
 	"log"
+	"strings"
 
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
@@ -115,6 +116,34 @@ func InitDatabase(ctx context.Context, pool *pgxpool.Pool) error {
 		}
 	}
 
+	// Phase 4c: SQL constraints
+	// Mirrors: _sql_constraints in Odoo models
+	for name, m := range models {
+		if m.IsAbstract() {
+			continue
+		}
+		for _, sc := range m.SQLConstraints {
+			constraintName := strings.ReplaceAll(name, ".", "_") + "_" + sc.Name
+			query := fmt.Sprintf(
+				`DO $$ BEGIN
+					ALTER TABLE %q ADD CONSTRAINT %s %s;
+				EXCEPTION WHEN duplicate_object THEN NULL;
+				END $$`,
+				m.Table(), constraintName, sc.Definition,
+			)
+			sp, spErr := tx.Begin(ctx)
+			if spErr != nil {
+				continue
+			}
+			if _, err := sp.Exec(ctx, query); err != nil {
+				log.Printf("db: constraint %s: %v", constraintName, err)
+				sp.Rollback(ctx)
+			} else {
+				sp.Commit(ctx)
+			}
+		}
+	}
+
 	// Phase 5: Seed ir_model and ir_model_fields with model metadata.
 	// This is critical because ir.rule joins through ir_model to find rules for a model.
 	// Mirrors: odoo/modules/loading.py load_module_graph() → _setup_base()