lambda-erp 0.6.2__tar.gz → 0.6.4__tar.gz

{lambda_erp-0.6.2 → lambda_erp-0.6.4}/PKG-INFO

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

{lambda_erp-0.6.2 → lambda_erp-0.6.4}/api/chat.py

@@ -1198,6 +1198,16 @@ def _chat_doctype_section() -> str:
         if links:
             link_str = ", ".join(f"`{f}` → the {t}'s name" for f, t in links.items())
             line += f" Links: {link_str}."
+        # How to open a record of this type (so links resolve).
+        page = services.chat_doctype_page_info(slug)
+        if page and page["kind"] == "self":
+            line += f" Open a record at `/app/{slug}/<name>`."
+        elif page and page["kind"] == "via":
+            line += (f" It has NO page of its own — open it via its parent: "
+                     f"`/app/{page['parent_slug']}/<{page['link_field']}>`; "
+                     f"never link `/app/{slug}/…`.")
+        elif page and page["kind"] == "none":
+            line += " It has no page — do not emit a link for it."
         lines.append(line)
     return (
         "\n\n## Custom record types (deployment-specific)\n"

{lambda_erp-0.6.2 → lambda_erp-0.6.4}/api/main.py

@@ -121,6 +121,27 @@ def health():
     return {"status": "ok", "version": get_app_version()}
 
 
+@app.get("/api/chat-doctypes")
+def chat_doctypes():
+    """Public metadata for doctypes registered via register_chat_doctype: their
+    description and, for the frontend, how each is opened (`page`). The frontend
+    uses the `page` of kind "via" to auto-register a redirect from the doctype's
+    (chat-generated) `/app/{slug}/{name}` link to its parent's page. Not
+    sensitive — it's the same info the chat system prompt carries."""
+    from api import services
+    out = []
+    for slug, meta in services.CHAT_DOCTYPES.items():
+        if slug not in services.SLUG_TO_DOCTYPE:
+            continue
+        out.append({
+            "slug": slug,
+            "description": meta.get("description"),
+            "fields": meta.get("fields", []),
+            "page": services.chat_doctype_page_info(slug),
+        })
+    return {"doctypes": out}
+
+
 @app.websocket("/ws/chat")
 async def ws_chat(websocket: WebSocket):
     # Authenticate via cookie, fall back to public_manager for demo mode

{lambda_erp-0.6.2 → lambda_erp-0.6.4}/api/routers/documents.py

@@ -13,6 +13,7 @@ from api.services import (
     list_documents,
     count_documents,
     document_columns,
+    adjacent_documents,
 )
 from api.pdf import generate_pdf
 from api.auth import require_role
@@ -80,6 +81,50 @@ def list_docs(
     return {"rows": rows, "total": total, "limit": limit, "offset": offset}
 
 
+@router.get("/{doctype_slug}/{name}/adjacent")
+def adjacent_doc(
+    doctype_slug: str,
+    name: str,
+    request: Request,
+    status: str | None = None,
+    party: str | None = None,
+    from_date: str | None = None,
+    to_date: str | None = None,
+    docstatus: int | None = None,
+    include_discarded: bool = False,
+    order_by: str | None = None,
+    order: str = "desc",
+    _user: dict = _viewer,
+):
+    """Prev/next record around `name` in the same order+filters the list uses.
+    Returns {"prev": name|None, "next": name|None}. Filters mirror the list
+    endpoint so navigation stays within the list the user came from."""
+    filters = {}
+    if status:
+        filters["status"] = status
+    if docstatus is not None:
+        filters["docstatus"] = docstatus
+    if party:
+        filters["customer"] = party
+    if from_date:
+        filters["from_date"] = from_date
+    if to_date:
+        filters["to_date"] = to_date
+    columns = document_columns(doctype_slug)
+    for key, value in request.query_params.items():
+        if key in _LIST_RESERVED:
+            continue
+        if key not in columns:
+            raise HTTPException(status_code=400, detail=f"Unknown filter field: {key}")
+        filters[key] = value
+    if order_by is not None and order_by not in columns:
+        raise HTTPException(status_code=400, detail=f"Unknown order_by field: {order_by}")
+    if order.lower() not in ("asc", "desc"):
+        raise HTTPException(status_code=400, detail="order must be 'asc' or 'desc'")
+    return adjacent_documents(doctype_slug, name, filters=filters,
+                              include_discarded=include_discarded, order_by=order_by, order=order)
+
+
 @router.get("/{doctype_slug}/search")
 def search_docs(doctype_slug: str, q: str = "", limit: int = Query(default=10, le=50), _user: dict = _viewer):
     docs = list_documents(doctype_slug, limit=limit)

{lambda_erp-0.6.2 → lambda_erp-0.6.4}/api/services.py

@@ -225,12 +225,48 @@ def register_master(slug: str, table: str, name_field: str, *,
 CHAT_DOCTYPES: dict = {}
 
 
-def register_chat_doctype(slug: str, *, description: str, fields: list | None = None) -> None:
+def register_chat_doctype(slug: str, *, description: str, fields: list | None = None,
+                          page: str | None = "self") -> None:
     """Give the AI chat a description (and optional key-field hints) for a doctype
     already registered via `register_doctype`, so build_system_prompt can tell the
     model what it is and how it links (LINK_FIELDS are surfaced automatically).
-    No new tools — the document tools already cover every registered doctype."""
-    CHAT_DOCTYPES[slug] = {"description": description, "fields": fields or []}
+    No new tools — the document tools already cover every registered doctype.
+
+    `page` tells the chat how a record of this doctype is *opened*, so it emits
+    correct view links (and the frontend can auto-register redirects):
+      "self" (default) — its own page at `/app/{slug}/{name}`;
+      "<link_field>"   — no page of its own; it's shown inside the parent that
+                         `link_field` (a LINK_FIELD) references, so it opens at
+                         `/app/{parent-slug}/{value of link_field}` (e.g. a
+                         contact opens via its lead: page="lead_id");
+      None             — no page and no view link at all.
+    """
+    CHAT_DOCTYPES[slug] = {"description": description, "fields": fields or [], "page": page}
+
+
+def chat_doctype_page_info(slug: str) -> dict | None:
+    """Resolve a chat-doctype's `page` config into a link rule, for the system
+    prompt and the /api/chat-doctypes read. Returns one of:
+      {"kind": "self", "slug": slug}
+      {"kind": "via", "link_field": f, "parent_slug": p}   # opens via a parent
+      {"kind": "none"}
+    or None if the slug isn't a registered chat-doctype."""
+    meta = CHAT_DOCTYPES.get(slug)
+    if not meta:
+        return None
+    page = meta.get("page", "self")
+    if page == "self":
+        return {"kind": "self", "slug": slug}
+    if page is None:
+        return {"kind": "none"}
+    # page names a LINK_FIELD -> resolve the parent doctype -> its slug.
+    doctype = SLUG_TO_DOCTYPE.get(slug)
+    cls = DOCUMENT_CLASSES.get(doctype) if doctype else None
+    links = getattr(cls, "LINK_FIELDS", None) or {}
+    parent_slug = DOCTYPE_TO_SLUG.get(links.get(page)) if links.get(page) else None
+    if not parent_slug:
+        return {"kind": "self", "slug": slug}  # misconfigured -> safe fallback
+    return {"kind": "via", "link_field": page, "parent_slug": parent_slug}
 
 
 def get_document_class(doctype_slug: str):
@@ -483,6 +519,76 @@ def count_documents(doctype_slug: str, filters: dict = None, include_discarded:
     return int(rows[0]["c"]) if rows else 0
 
 
+def _filter_where(db, doctype: str, filters: dict, include_discarded: bool):
+    """Build (where_parts, params) for a doctype from a list-style `filters` dict
+    (equality filters + from_date/to_date on the doctype's date field + discard
+    exclusion). Same semantics as list_documents/count_documents so prev/next
+    matches exactly what the list shows."""
+    db_filters, from_date, to_date = {}, None, None
+    for key, value in (filters or {}).items():
+        if value is None or value == "":
+            continue
+        if key == "from_date":
+            from_date = value
+        elif key == "to_date":
+            to_date = value
+        else:
+            db_filters[key] = value
+    _exclude_discarded(db, doctype, db_filters, include_discarded)
+
+    date_field = DATE_FIELDS.get(doctype)
+    where_parts, params = [], []
+    if date_field and from_date:
+        where_parts.append(f'"{date_field}" >= ?'); params.append(from_date)
+    if date_field and to_date:
+        where_parts.append(f'"{date_field}" <= ?'); params.append(to_date)
+    for k, v in db_filters.items():
+        if isinstance(v, (list, tuple)) and len(v) == 2:
+            op, val = v
+            where_parts.append(f'"{k}" {op} ?'); params.append(val)
+        else:
+            where_parts.append(f'"{k}" = ?'); params.append(v)
+    return where_parts, params
+
+
+def adjacent_documents(doctype_slug: str, name: str, filters: dict = None,
+                       include_discarded: bool = False, order_by: str = None,
+                       order: str = "desc") -> dict:
+    """The records immediately before/after `name` in the same order+filters the
+    list uses — {"prev": name|None, "next": name|None}. `prev` is one step *up*
+    the list (toward the top), `next` one step *down*. Keyset queries (indexed,
+    not a full scan). Order defaults to creation DESC (the list default), with
+    `name` as a stable tie-break so rows sharing an order value still step 1:1."""
+    doctype = SLUG_TO_DOCTYPE.get(doctype_slug)
+    if not doctype:
+        raise ValueError(f"Unknown document type: {doctype_slug}")
+    db = get_db()
+    cols = db._get_table_columns(doctype)
+    oc = order_by if (order_by and order_by in cols) else "creation"
+    desc = str(order).lower() != "asc"
+
+    cur = db.sql(f'SELECT "{oc}" AS oc FROM "{doctype}" WHERE name = ?', [name])
+    if not cur:
+        return {"prev": None, "next": None}
+    cur_oc = cur[0]["oc"]
+
+    base_where, base_params = _filter_where(db, doctype, filters or {}, include_discarded)
+
+    def neighbor(direction):
+        # DESC list: next = tuple < current, prev = tuple > current (ASC flips).
+        going_less = (direction == "next") == desc
+        cmp = "<" if going_less else ">"
+        dir_sql = "DESC" if going_less else "ASC"
+        keyset = f'(("{oc}" {cmp} ?) OR ("{oc}" = ? AND name {cmp} ?))'
+        query = (f'SELECT name FROM "{doctype}" WHERE '
+                 + " AND ".join(base_where + [keyset])
+                 + f' ORDER BY "{oc}" {dir_sql}, name {dir_sql} LIMIT 1')
+        rows = db.sql(query, base_params + [cur_oc, cur_oc, name])
+        return rows[0]["name"] if rows else None
+
+    return {"prev": neighbor("prev"), "next": neighbor("next")}
+
+
 def _list_with_offset(db, doctype, doctype_slug, db_filters, limit, offset, order_clause="creation DESC"):
     where_parts = []
     params = []

{lambda_erp-0.6.2 → lambda_erp-0.6.4}/frontend/src/api/client.ts

@@ -123,6 +123,12 @@ export const api = {
   getDocument: (doctype: string, name: string) =>
     request<any>(`/documents/${doctype}/${encodeURIComponent(name)}`),
 
+  // Prev/next record around `name` in the same order+filters the list uses.
+  adjacentDocument: (doctype: string, name: string, params?: Record<string, string | number | undefined>) =>
+    request<{ prev: string | null; next: string | null }>(
+      `/documents/${doctype}/${encodeURIComponent(name)}/adjacent${qs(params)}`,
+    ),
+
   createDocument: (doctype: string, data: any) =>
     request<any>(`/documents/${doctype}`, { method: "POST", body: JSON.stringify(data) }),
 

{lambda_erp-0.6.2 → lambda_erp-0.6.4}/pyproject.toml

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