lambda-erp 0.8.18__tar.gz → 0.8.20__tar.gz

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 0.8.18
+Version: 0.8.20
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/api/chat.py

@@ -467,7 +467,7 @@ TOOLS = [
                 "type": "object",
                 "properties": {
                     "doctype": {"type": "string", "enum": DOCUMENT_SLUGS, "description": "Document type slug"},
-                    "filters": {"type": "object", "description": "Optional filters on any column. Equality: {\"status\": \"Draft\", \"customer\": \"CUST-001\"}. Comparison (value = a 2-item array [op, value]): {\"grand_total\": [\">\", 100]}, {\"fit\": [\"!=\", \"A\"]}. NULL checks (1-item array): {\"fit\": [\"is null\"]}, {\"main_email\": [\"is not null\"]}. Allowed ops: =, !=, >, <, >=, <=, like, not like, is null, is not null. Free-text search: {\"search\": \"acme\"} matches the doctype's default text columns; narrow it with {\"search\": \"acme\", \"search_fields\": [\"company_name\", \"tags\"]}.", "default": {}},
+                    "filters": {"type": "object", "description": "Optional filters on any column. Equality: {\"status\": \"Draft\", \"customer\": \"CUST-001\"}. Comparison (value = a 2-item array [op, value]): {\"grand_total\": [\">\", 100]}, {\"fit\": [\"!=\", \"A\"]}. Case-insensitive text substring: {\"customer_name\": [\"contains\", \"acme\"]}. NULL checks (1-item array): {\"fit\": [\"is null\"]}, {\"main_email\": [\"is not null\"]}. Allowed ops: =, !=, >, <, >=, <=, contains, like, not like, is null, is not null. Free-text search: {\"search\": \"acme\"} matches the doctype's default text columns; narrow it with {\"search\": \"acme\", \"search_fields\": [\"company_name\", \"tags\"]}.", "default": {}},
                     "order_by": {"type": "string", "description": "Optional column to sort by (e.g. \"occurred_at\" for a timeline). Defaults to creation."},
                     "order": {"type": "string", "enum": ["asc", "desc"], "description": "Sort direction (default desc)", "default": "desc"},
                     "limit": {"type": "integer", "description": "Max results (default 20, max 500)", "default": 20},

lambda_erp-0.8.20/api/list_values.py

@@ -0,0 +1,25 @@
+"""Shared value suggestions for the generic master/document list filters."""
+
+
+def distinct_list_values(db, table: str, field: str, query: str = "", limit: int = 200) -> list:
+    """Return distinct, non-empty values for one validated table column.
+
+    ``field`` is checked against the live schema before it is interpolated.
+    Prefix matching keeps autocomplete useful without loading a whole
+    high-cardinality column into the browser.
+    """
+    if field not in db._get_table_columns(table):
+        raise KeyError(field)
+
+    where = [f'"{field}" IS NOT NULL', f'CAST("{field}" AS TEXT) <> \'\'']
+    params: list = []
+    if query:
+        where.append(f'LOWER(CAST("{field}" AS TEXT)) LIKE LOWER(?)')
+        params.append(f"{query}%")
+
+    rows = db.sql(
+        f'SELECT DISTINCT "{field}" AS v FROM "{table}" '
+        f'WHERE {" AND ".join(where)} ORDER BY "{field}" LIMIT {int(limit)}',
+        params,
+    )
+    return [row["v"] for row in rows]

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/api/routers/documents.py

@@ -14,9 +14,13 @@ from api.services import (
     count_documents,
     document_columns,
     adjacent_documents,
+    parse_list_filter,
+    SLUG_TO_DOCTYPE,
 )
 from api.pdf import generate_pdf
 from api.auth import require_role
+from api.list_values import distinct_list_values
+from lambda_erp.database import get_db
 
 router = APIRouter(prefix="/documents", tags=["documents"])
 
@@ -24,7 +28,8 @@ _viewer = Depends(require_role("viewer"))
 _manager = Depends(require_role("manager"))
 
 # Query params the list endpoint interprets itself — everything else is treated
-# as an ad-hoc column=value filter (validated against the doctype's columns).
+# as an ad-hoc field filter (validated against the doctype's columns). Plain
+# keys are exact; ``field__contains`` is available for real text columns.
 _LIST_RESERVED = {
     "status", "party", "from_date", "to_date", "docstatus",
     "include_discarded", "limit", "offset", "order_by", "order",
@@ -64,16 +69,23 @@ def list_docs(
     if to_date:
         filters["to_date"] = to_date
 
-    # Ad-hoc equality filters: any remaining query param that names a real column
-    # of this doctype (e.g. /documents/activity?lead_id=LEAD-3316). Validate
-    # against the live columns so an unknown field is a 400, never interpolated.
+    # Ad-hoc filters: any remaining query param must name a real column, with an
+    # optional __contains suffix for schema-confirmed text columns.
     columns = document_columns(doctype_slug)
+    doctype = SLUG_TO_DOCTYPE.get(doctype_slug)
     for key, value in request.query_params.items():
         if key in _LIST_RESERVED:
             continue
-        if key not in columns:
+        try:
+            field, parsed_value = parse_list_filter(get_db(), doctype, key, value)
+        except KeyError:
             raise HTTPException(status_code=400, detail=f"Unknown filter field: {key}")
-        filters[key] = value
+        except TypeError:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Contains filter is only supported for text fields: {key}",
+            )
+        filters[field] = parsed_value
 
     # Which column from_date/to_date filter on. The frontend passes its declared
     # dateField so plugin doctypes get working date filters without a server-side
@@ -115,7 +127,13 @@ def list_docs(
                           include_discarded=include_discarded, order_by=order_by, order=order,
                           fields=projection)
     total = count_documents(doctype_slug, filters=filters, include_discarded=include_discarded)
-    return {"rows": rows, "total": total, "limit": limit, "offset": offset}
+    return {
+        "rows": rows,
+        "total": total,
+        "limit": limit,
+        "offset": offset,
+        "text_fields": sorted(get_db()._get_text_columns(doctype)),
+    }
 
 
 @router.get("/{doctype_slug}/{name}/adjacent")
@@ -151,12 +169,20 @@ def adjacent_doc(
     if to_date:
         filters["to_date"] = to_date
     columns = document_columns(doctype_slug)
+    doctype = SLUG_TO_DOCTYPE.get(doctype_slug)
     for key, value in request.query_params.items():
         if key in _LIST_RESERVED:
             continue
-        if key not in columns:
+        try:
+            field, parsed_value = parse_list_filter(get_db(), doctype, key, value)
+        except KeyError:
             raise HTTPException(status_code=400, detail=f"Unknown filter field: {key}")
-        filters[key] = value
+        except TypeError:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Contains filter is only supported for text fields: {key}",
+            )
+        filters[field] = parsed_value
     if date_field:
         filters["date_field"] = date_field
     if search:
@@ -183,6 +209,27 @@ def search_docs(doctype_slug: str, q: str = "", limit: int = Query(default=10, l
     return [{"name": d["name"]} for d in docs]
 
 
+@router.get("/{doctype_slug}/filter-values")
+def document_filter_values(
+    doctype_slug: str,
+    field: str,
+    q: str = "",
+    limit: int = Query(default=200, ge=1, le=200),
+    _user: dict = _viewer,
+):
+    """Distinct values for the generic list's field autocomplete."""
+    from api.services import SLUG_TO_DOCTYPE
+
+    doctype = SLUG_TO_DOCTYPE.get(doctype_slug)
+    if not doctype:
+        raise HTTPException(status_code=404, detail=f"Unknown document type: {doctype_slug}")
+    try:
+        values = distinct_list_values(get_db(), doctype, field, q, limit)
+    except KeyError:
+        raise HTTPException(status_code=400, detail=f"Unknown field: {field}")
+    return {"values": values}
+
+
 @router.get("/{doctype_slug}/{name}/pdf")
 def get_pdf(doctype_slug: str, name: str, _user: dict = _viewer):
     pdf_bytes = generate_pdf(doctype_slug, name)

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/api/routers/masters.py

@@ -13,9 +13,11 @@ from api.services import (
     MASTER_TABLES, MASTER_NAME_PREFIXES, MASTER_NAME_DIGITS, MASTER_RANDOM_NAME_TYPES,
     MASTER_IDENTITY_ALIAS,
     MASTER_REFERENCE_CHECKS,
-    _search_clause, _where_from_filters, master_search_columns, count_query_cached,
+    _filter_atom, _search_clause, _where_from_filters, count_query_cached,
+    master_search_columns, parse_list_filter,
 )
 from api.auth import require_role, require_non_public_manager
+from api.list_values import distinct_list_values
 
 router = APIRouter(prefix="/masters", tags=["masters"])
 
@@ -300,7 +302,9 @@ def update_master_record(master_type: str, name: str, data: dict) -> dict:
 
 
 # Query params list_masters consumes itself — anything else is treated as an
-# ad-hoc equality field filter (validated against the master's real columns).
+# ad-hoc field filter (validated against the master's real columns). Plain keys
+# are exact; text columns additionally support the explicit ``__contains``
+# suffix used by Smart Search.
 _MASTER_LIST_RESERVED = {
     "limit", "offset", "include_disabled", "search", "search_fields", "fields",
     "order_by", "order",
@@ -328,10 +332,18 @@ def _master_list_where(db, doctype: str, master_type: str, request: Request,
     for key, value in request.query_params.items():
         if key in _MASTER_LIST_RESERVED:
             continue
-        if key not in columns:
+        try:
+            field, parsed_value = parse_list_filter(db, doctype, key, value)
+        except KeyError:
             raise HTTPException(status_code=400, detail=f"Unknown filter field: {key}")
-        where_parts.append(f'"{key}" = ?')
-        params.append(value)
+        except TypeError:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Contains filter is only supported for text fields: {key}",
+            )
+        clause, clause_params = _filter_atom(field, parsed_value)
+        where_parts.append(clause)
+        params.extend(clause_params)
 
     if search:
         requested = [f.strip() for f in (search_fields or "").split(",") if f.strip()]
@@ -374,6 +386,8 @@ def _master_order_sql(column: str, direction: str, *, reverse: bool = False) ->
 def master_filter_values(
     master_type: str,
     field: str,
+    q: str = "",
+    limit: int = Query(default=200, ge=1, le=200),
     _user: dict = _viewer,
 ):
     """Distinct non-empty values of one column — populates a master-list filter
@@ -382,14 +396,11 @@ def master_filter_values(
     if not doctype:
         raise HTTPException(status_code=404, detail=f"Unknown master type: {master_type}")
     db = get_db()
-    if field not in db._get_table_columns(doctype):
+    try:
+        values = distinct_list_values(db, doctype, field, q, limit)
+    except KeyError:
         raise HTTPException(status_code=400, detail=f"Unknown field: {field}")
-    rows = db.sql(
-        f'SELECT DISTINCT "{field}" AS v FROM "{doctype}" '
-        f'WHERE "{field}" IS NOT NULL AND "{field}" <> \'\' '
-        f'ORDER BY "{field}" LIMIT 200'
-    )
-    return {"values": [r["v"] for r in rows]}
+    return {"values": values}
 
 
 @router.get("/{master_type}")
@@ -436,7 +447,13 @@ def list_masters(
         query += f" OFFSET {int(offset)}"
     rows = db.sql(query, params)
 
-    return {"rows": rows, "total": total, "limit": limit, "offset": offset}
+    return {
+        "rows": rows,
+        "total": total,
+        "limit": limit,
+        "offset": offset,
+        "text_fields": sorted(db._get_text_columns(doctype)),
+    }
 
 
 @router.get("/{master_type}/search")

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/api/routers/reports.py

@@ -508,14 +508,14 @@ def _profit_and_loss(db, company=None, from_date=None, to_date=None):
             "account": acc["name"],
             "account_name": acc["account_name"],
             "root_type": acc["root_type"],
-            "amount": abs(balance),
+            "amount": balance,
         }
         if acc["root_type"] == "Income":
             income_rows.append(row)
-            total_income += abs(balance)
+            total_income += balance
         else:
             expense_rows.append(row)
-            total_expense += abs(balance)
+            total_expense += balance
 
     return {
         "income": income_rows,

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/api/services.py

@@ -709,6 +709,7 @@ _FILTER_OPS = {
     "=": "=", "==": "=", "!=": "!=", "<>": "!=",
     ">": ">", "<": "<", ">=": ">=", "<=": "<=",
     "like": "LIKE", "not like": "NOT LIKE",
+    "contains": "CONTAINS",
     "is null": "IS NULL", "is not null": "IS NOT NULL",
 }
 _NULLARY_OPS = {"IS NULL", "IS NOT NULL"}  # take no bound value
@@ -744,6 +745,13 @@ def _filter_atom(col: str, value):
             op = _resolve_op(value[0])
             if op in _NULLARY_OPS:
                 return f'"{col}" {op}', []  # value ignored for IS [NOT] NULL
+            if op == "CONTAINS":
+                # Literal, case-insensitive substring search. Escape LIKE's two
+                # wildcard characters so a user-entered '%' or '_' keeps its
+                # ordinary meaning. The REST layer only permits this operator
+                # for schema-confirmed text columns.
+                escaped = str(value[1]).replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+                return f'LOWER("{col}") LIKE LOWER(?) ESCAPE \'\\\'', [f"%{escaped}%"]
             return f'"{col}" {op} ?', [value[1]]
         raise ValueError(
             f"Malformed filter for {col!r}: expected a scalar, [op], or [op, value]"
@@ -751,6 +759,39 @@ def _filter_atom(col: str, value):
     return f'"{col}" = ?', [value]
 
 
+def parse_list_filter(db, doctype: str, raw_key: str, value):
+    """Parse one REST list-filter query parameter.
+
+    Plain ``field=value`` parameters retain their historical equality
+    semantics. ``field__contains=value`` becomes the internal whitelisted
+    ``contains`` operator, but only when the live schema says ``field`` is a
+    text column. Unknown fields raise ``KeyError``; applying ``contains`` to a
+    non-text field raises ``TypeError``. Callers translate both into HTTP 400.
+    """
+    suffix = "__contains"
+    field = raw_key[:-len(suffix)] if raw_key.endswith(suffix) else raw_key
+    if not field or field not in db._get_table_columns(doctype):
+        raise KeyError(field or raw_key)
+    if raw_key.endswith(suffix):
+        if field not in db._get_text_columns(doctype):
+            raise TypeError(field)
+        return field, ("contains", value)
+    return field, value
+
+
+def _validate_typed_filters(db, doctype: str, filters: dict) -> None:
+    """Keep type-sensitive operators honest for REST, chat, and direct calls."""
+    text_columns = db._get_text_columns(doctype)
+    for field, value in filters.items():
+        if (
+            isinstance(value, (list, tuple))
+            and len(value) == 2
+            and str(value[0]).strip().lower() == "contains"
+            and field not in text_columns
+        ):
+            raise ValueError(f"Contains filter is only supported for text fields: {field}")
+
+
 def _where_from_filters(db_filters: dict):
     """(where_parts, params) for a dict of already-parsed equality/operator
     filters, via the whitelisted _filter_atom builder."""
@@ -806,6 +847,7 @@ def list_documents(doctype_slug: str, filters: dict = None, limit: int = 50, off
                 db_filters[key] = value
 
     _exclude_discarded(db, doctype, db_filters, include_discarded)
+    _validate_typed_filters(db, doctype, db_filters)
 
     # Date range filtering via the doctype's primary date field
     date_field = _resolve_date_field(db, doctype, date_field_override)
@@ -961,6 +1003,7 @@ def _count_documents_uncached(doctype_slug: str, filters: dict = None, include_d
                 db_filters[key] = value
 
     _exclude_discarded(db, doctype, db_filters, include_discarded)
+    _validate_typed_filters(db, doctype, db_filters)
 
     date_field = _resolve_date_field(db, doctype, date_field_override)
     where_parts = []
@@ -1010,6 +1053,7 @@ def _filter_where(db, doctype: str, doctype_slug: str, filters: dict, include_di
         else:
             db_filters[key] = value
     _exclude_discarded(db, doctype, db_filters, include_discarded)
+    _validate_typed_filters(db, doctype, db_filters)
 
     date_field = _resolve_date_field(db, doctype, date_field_override)
     where_parts, params = [], []

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/frontend/src/api/client.ts

@@ -167,7 +167,7 @@ export const api = {
 
   // Documents
   listDocuments: (doctype: string, params?: Record<string, string | number | undefined>) =>
-    request<{ rows: any[]; total: number; limit: number; offset: number }>(
+    request<{ rows: any[]; total: number; limit: number; offset: number; text_fields: string[] }>(
       `/documents/${doctype}${qs(params)}`,
     ),
 
@@ -243,16 +243,24 @@ export const api = {
 
   // Masters
   listMasters: (type: string, params?: Record<string, string | number | undefined>) =>
-    request<{ rows: any[]; total: number; limit: number; offset: number }>(
+    request<{ rows: any[]; total: number; limit: number; offset: number; text_fields: string[] }>(
       `/masters/${type}${qs(params)}`,
     ),
 
   searchMasters: (type: string, q: string) =>
     request<any[]>(`/masters/${type}/search?q=${encodeURIComponent(q)}`),
 
-  // Distinct values of one master column — populates a list filter dropdown.
-  masterFilterValues: (type: string, field: string) =>
-    request<{ values: any[] }>(`/masters/${type}/filter-values?field=${encodeURIComponent(field)}`),
+  // Distinct values of one list column — used by dropdown filters and the
+  // shared field-aware search autocomplete.
+  masterFilterValues: (type: string, field: string, q = "", limit = 200) =>
+    request<{ values: any[] }>(
+      `/masters/${type}/filter-values${qs({ field, q: q || undefined, limit })}`,
+    ),
+
+  documentFilterValues: (doctype: string, field: string, q = "", limit = 200) =>
+    request<{ values: any[] }>(
+      `/documents/${doctype}/filter-values${qs({ field, q: q || undefined, limit })}`,
+    ),
 
   searchDocuments: (doctype: string, q: string) =>
     request<any[]>(`/documents/${doctype}/search?q=${encodeURIComponent(q)}`),

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/lambda_erp/accounting/journal_entry.py

@@ -76,26 +76,27 @@ class JournalEntry(Document):
         self._set_totals()
 
     def _normalize_amounts(self):
-        """Keep each row's base debit/credit and its *_in_account_currency twin in
-        sync. lambda-erp has no per-line exchange rate (base == account currency),
-        so back-fill whichever side is missing. Without this, a row created with
-        the amount ONLY in debit_in_account_currency (as the chat's create path
-        did) leaves base debit/credit at 0 — it passes the 0==0 balance check,
-        submits "successfully", and posts NOTHING (GL is built from the base
-        fields, and _get_gl_entries skips 0/0 rows). Idempotent."""
+        """Back-fill only missing base/account-currency amounts.
+
+        ``None`` or an absent field means the caller supplied only the matching
+        amount in the other currency. An explicit zero is meaningful: period-end
+        valuation entries move the base carrying value without changing the
+        foreign-currency quantity, so their *_in_account_currency amount must
+        remain zero.
+        """
         for row in self.get("accounts") or []:
-            debit = flt(row.get("debit"))
-            credit = flt(row.get("credit"))
-            dr_ac = flt(row.get("debit_in_account_currency"))
-            cr_ac = flt(row.get("credit_in_account_currency"))
-            if not debit and dr_ac:
-                row["debit"] = dr_ac
-            if not credit and cr_ac:
-                row["credit"] = cr_ac
-            if not dr_ac and debit:
-                row["debit_in_account_currency"] = debit
-            if not cr_ac and credit:
-                row["credit_in_account_currency"] = credit
+            debit = row.get("debit")
+            credit = row.get("credit")
+            dr_ac = row.get("debit_in_account_currency")
+            cr_ac = row.get("credit_in_account_currency")
+            if debit is None and dr_ac is not None:
+                row["debit"] = flt(dr_ac)
+            if credit is None and cr_ac is not None:
+                row["credit"] = flt(cr_ac)
+            if dr_ac is None and debit is not None:
+                row["debit_in_account_currency"] = flt(debit)
+            if cr_ac is None and credit is not None:
+                row["credit_in_account_currency"] = flt(credit)
 
     def _validate_debit_credit(self):
         """Ensure total debits == total credits.
@@ -235,21 +236,33 @@ class JournalEntry(Document):
         journal entries map 1:1 from account rows to GL entries.
         """
         gl_entries = []
+        db = get_db()
+        base_currency = db.get_value("Company", self.company, "default_currency") or "USD"
 
         for row in self.get("accounts"):
             if not (flt(row.get("debit")) or flt(row.get("credit"))):
                 continue
 
+            debit = flt(row.get("debit"), 2)
+            credit = flt(row.get("credit"), 2)
+            dr_ac = row.get("debit_in_account_currency")
+            cr_ac = row.get("credit_in_account_currency")
+            account_currency = (
+                db.get_value("Account", row.get("account"), "account_currency")
+                or base_currency
+            )
+
             gl_entries.append(
                 _dict(
                     account=row.get("account"),
                     party_type=row.get("party_type"),
                     party=row.get("party"),
                     cost_center=row.get("cost_center"),
-                    debit=flt(row.get("debit"), 2),
-                    credit=flt(row.get("credit"), 2),
-                    debit_in_account_currency=flt(row.get("debit_in_account_currency") or row.get("debit"), 2),
-                    credit_in_account_currency=flt(row.get("credit_in_account_currency") or row.get("credit"), 2),
+                    debit=debit,
+                    credit=credit,
+                    debit_in_account_currency=flt(debit if dr_ac is None else dr_ac, 2),
+                    credit_in_account_currency=flt(credit if cr_ac is None else cr_ac, 2),
+                    account_currency=account_currency,
                     against_voucher_type=row.get("reference_doctype") or row.get("reference_type"),
                     against_voucher=row.get("reference_name"),
                     voucher_type=self.DOCTYPE,

{lambda_erp-0.8.18 → lambda_erp-0.8.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.8.18"
+version = "0.8.20"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "Apache-2.0"