New tools: get records, get record url

misc_files/run_list_attributes.py

@@ -0,0 +1,13 @@
+import json
+from tools.templates_tools.tool_list_attributes import list_attributes
+
+
+if __name__ == "__main__":
+    params = {
+        "application_system_name": "Управлениеавтопарком",
+        "template_system_name": "Заявкинаавтомобили",
+    }
+    res = list_attributes.invoke(params)
+    print(json.dumps(res, ensure_ascii=False, indent=2))
+
+

misc_files/run_list_template_records.py

@@ -0,0 +1,28 @@
+import json
+from tools.templates_tools.tool_list_records import list_template_records
+
+
+def run_case(application_system_name: str, template_system_name: str, attributes, filters):
+    params = {
+        "application_system_name": application_system_name,
+        "template_system_name": template_system_name,
+        "attributes": attributes,
+        "filters": filters,
+        "limit": 10,
+        "offset": 0,
+        "sort_by": None,
+        "sort_desc": False,
+    }
+    res = list_template_records.invoke(params)
+    print(json.dumps(res, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    # Target case from chat
+    print("\n=== Case 1: attributes=[], filters={} ===")
+    run_case("Управлениеавтопарком", "Заявкинаавтомобили", attributes=[], filters={})
+
+    print("\n=== Case 2: attributes=None, filters=None ===")
+    run_case("Управлениеавтопарком", "Заявкинаавтомобили", attributes=None, filters=None)
+
+

tools/__init__.py

@@ -38,7 +38,7 @@ from . import tools
 
 # Import key functions from subpackages for convenience
 from .applications_tools import list_applications, list_templates
-from .applications_tools import get_platform_entity_url
+from .applications_tools import get_platform_entity_url, get_record_url
 from .attributes_tools import (
     # General operations
     delete_attribute, archive_or_unarchive_attribute, get_attribute,
@@ -102,6 +102,7 @@ __all__ = [
     'list_templates',
     'list_attributes',
     'get_platform_entity_url',
+    'get_record_url',
     
     # General operations
     'delete_attribute',

tools/applications_tools/__init__.py

@@ -13,9 +13,11 @@ Available Tools:
 from .tool_list_applications import list_applications
 from .tool_list_templates import list_templates
 from .tool_platform_entity_url import get_platform_entity_url
+from .tool_record_url import get_record_url
 
 __all__ = [
     'list_applications',
     'list_templates',
-    'get_platform_entity_url'
+    'get_platform_entity_url',
+    'get_record_url'
 ]

tools/applications_tools/tool_record_url.py

@@ -0,0 +1,73 @@
+from typing import Any, Dict
+
+from pydantic import BaseModel, Field, field_validator
+
+from ..tool_utils import tool, requests_  # type: ignore
+
+
+class GetRecordUrlSchema(BaseModel):
+    """
+    Schema for generating a direct URL to a specific record by its ID.
+    """
+
+    record_id: str = Field(description="Record ID to generate URL for")
+
+    @field_validator("record_id", mode="before")
+    @classmethod
+    def non_empty_str(cls, v: Any) -> Any:
+        if isinstance(v, str) and v.strip() == "":
+            raise ValueError("Value must be a non-empty string")
+        return v
+
+
+@tool("get_record_url", return_direct=False, args_schema=GetRecordUrlSchema)
+def get_record_url(record_id: str) -> Dict[str, Any]:
+    """
+    Get the URL for a record by its ID.
+
+    Returns:
+        dict: {
+            "success": bool,
+            "status_code": int,
+            "record_url": str|None,
+            "error": str|None,
+        }
+    """
+
+    try:
+        cfg = requests_._load_server_config()
+        base_url = cfg.base_url.rstrip("/")
+
+        if not base_url:
+            return {
+                "success": False,
+                "status_code": 500,
+                "record_url": None,
+                "error": "Base URL not found in server configuration",
+            }
+
+        record_url = f"{base_url}/#Resolver/{record_id}"
+
+        return {
+            "success": True,
+            "status_code": 200,
+            "record_url": record_url,
+            "error": None,
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "status_code": 500,
+            "record_url": None,
+            "error": f"Error generating record URL: {str(e)}",
+        }
+
+
+if __name__ == "__main__":
+    # Local manual test example
+    results = get_record_url.invoke({
+        "record_id": "1"
+    })
+    print(results)
+

tools/templates_tools/__init__.py

@@ -1,18 +1,17 @@
-"""
-Templates Tools Package
-======================
-
-This package contains tools for managing Comindware Platform templates and their attributes.
+# ruff: noqa: N999
+"""Templates Tools Package.
 
-Available Tools:
-- list_attributes: List all attributes in a specific template
+This package contains tools for managing Comindware Platform templates and records and listing
+template attributes.
 """
 
 # Import all tool functions
-from .tool_list_attributes import list_attributes
-from .tools_record_template import edit_or_create_record_template
+from tools.templates_tools.tool_list_attributes import list_attributes
+from tools.templates_tools.tool_list_records import list_template_records
+from tools.templates_tools.tools_record_template import edit_or_create_record_template
 
 __all__ = [
-    'list_attributes',
-    'edit_or_create_record_template'
+    "edit_or_create_record_template",
+    "list_attributes",
+    "list_template_records",
 ]

tools/templates_tools/tool_list_records.py

@@ -0,0 +1,214 @@
+from contextlib import suppress
+from typing import Any
+
+from langchain_core.tools import tool
+from pydantic import BaseModel, Field, field_validator
+
+from tools import requests_
+from tools.models import AttributeResult
+from tools.tool_utils import execute_list_operation, remove_values
+
+RECORDS_ENDPOINT_PREFIX = "webapi/Records"
+
+
+class ListTemplateRecordsSchema(BaseModel):
+    application_system_name: str = Field(
+        description=(
+            "System name of the application with the template. "
+            "RU: Системное имя приложения"
+        )
+    )
+    template_system_name: str = Field(
+        description=(
+            "System name of the template to fetch records from. "
+            "RU: Системное имя шаблона"
+        )
+    )
+    attributes: list[str] | None = Field(
+        default=None,
+        description=(
+            "List of attribute system names to return. If omitted, returns all "
+            "template attributes."
+        ),
+    )
+    filters: dict[str, Any] | None = Field(
+        default=None,
+        description=(
+            "Optional mapping attribute->value to filter dataset. "
+            "Keep filters narrow; prefer pagination over large scans. "
+        ),
+    )
+    limit: int = Field(
+        default=100,
+        ge=1,
+        le=100,
+        description=(
+            "Number of records to fetch (page size). Default 100. Max 100 per request. "
+        ),
+    )
+    offset: int = Field(
+        default=0,
+        ge=0,
+        description=(
+            "Position to start fetching from (use for paging). Example: first "
+            "page offset=0, second page offset=10."
+        ),
+    )
+    sort_by: str | None = Field(
+        default="creationDate",
+        description="Attribute system name to sort by.",
+    )
+    sort_desc: bool = Field(
+        default=False,
+        description=(
+            "Sort in descending order if True, ascending if False. "
+        ),
+    )
+
+    @field_validator("application_system_name", "template_system_name", mode="before")
+    @classmethod
+    def non_empty_str(cls, v: Any) -> Any:
+        if isinstance(v, str) and v.strip() == "":
+            msg = "must be a non-empty string"
+            raise ValueError(msg)
+        return v
+
+
+@tool(
+    "list_template_records",
+    return_direct=False,
+    args_schema=ListTemplateRecordsSchema,
+)
+def list_template_records(
+    application_system_name: str,
+    template_system_name: str,
+    *,
+    attributes: list[str] | None = None,
+    filters: dict[str, Any] | None = None,
+    limit: int = 100,
+    offset: int = 0,
+    sort_by: str | None = "creationDate",
+    sort_desc: bool = False,
+) -> dict[str, Any]:
+    r"""
+    List records for a given template with filtering, attribute projection,
+    sorting, and pagination.
+
+    - Before calling this tool fetch the template attribute model using the
+      `list_attributes` tool and use it to determine available attribute properties.
+    - Filtering: exact match by keys in `filters`; list values are supported
+    (contains/all-of).
+    - Attributes: when a non-empty `attributes` list is provided, only those
+      attributes are returned.
+    - Pagination/sorting: hard limit 100 per call (page via `offset`).
+    - After each iteration talk to the user about the results instead of
+      fetching too many records at once.
+
+    Returns:
+        dict: {
+            "success": bool - True if record list was fetched successfully
+            "status_code": int - HTTP response status code
+            "data": list|None - List of attribute and their values if successful
+            "error": str|None - Error message if operation failed
+        }
+    """
+
+    # Build Template@solution.template path parameter
+    template_global_alias_str = (
+        f"Template@{application_system_name}.{template_system_name}"
+    )
+    endpoint = f"{RECORDS_ENDPOINT_PREFIX}/{template_global_alias_str}"
+
+    result = requests_._get_request(endpoint)  # noqa: SLF001
+
+    # If the API call failed or structure is unexpected, normalize via common adapter
+    if not result.get("success", False):
+        return execute_list_operation(
+            response_data=result,
+            result_model=AttributeResult,
+        )
+
+    raw = result.get("raw_response")
+    if not isinstance(raw, dict) or "response" not in raw:
+        return execute_list_operation(
+            response_data=result,
+            result_model=AttributeResult,
+        )
+
+    # Normalize response to a list of records
+    response_payload = raw.get("response")
+    if isinstance(response_payload, dict):
+        data = list(response_payload.values())
+    elif isinstance(response_payload, list):
+        data = response_payload
+    else:
+        data = []
+
+    # Client-side filtering (exact match semantics with light list support)
+    if isinstance(filters, dict) and filters:
+        def _matches(rec: dict[str, Any]) -> bool:
+            for key, expected in filters.items():
+                actual = (rec or {}).get(key, None)
+                # List-aware comparison
+                if isinstance(actual, list):
+                    if isinstance(expected, list):
+                        # Require all expected items to be present
+                        if not set(expected).issubset(set(actual)):
+                            return False
+                    elif expected not in actual:
+                        return False
+                elif actual != expected:
+                    return False
+            return True
+
+        data = [r for r in data if isinstance(r, dict) and _matches(r)]
+
+    # Client-side attribute projection (None or empty list => return all fields)
+    if attributes not in (None, []) and isinstance(attributes, list):
+        attr_set = set(attributes)
+        projected: list[dict[str, Any]] = []
+        for rec in data:
+            if not isinstance(rec, dict):
+                continue
+            projected.append({k: v for k, v in rec.items() if k in attr_set})
+        data = projected
+
+    # Optional client-side sorting
+    if sort_by:
+        with suppress(Exception):
+            data = sorted(
+                data,
+                key=lambda r: (r or {}).get(sort_by),
+                reverse=bool(sort_desc),
+            )
+
+    # Client-side pagination — enforce hard ceiling of 100 per request
+    start = max(0, int(offset))
+    page_size = max(1, min(int(limit), 100))
+    end = max(start, start + page_size)
+    paged = data[start:end]
+
+    adapted = dict(result)
+    adapted["raw_response"] = {"response": paged}
+
+    return execute_list_operation(
+        response_data=adapted,
+        result_model=AttributeResult,
+    )
+
+
+if __name__ == "__main__":
+    results = list_template_records.invoke({
+        "application_system_name": "AItestAndApi",
+        "template_system_name": "Test",
+        "attributes": [],
+        "filters": {},
+        "limit": 10,
+        "offset": 0,
+        "sort_by": None,
+        "sort_desc": False,
+    })
+    print(results)
+
+
+

tools/tools.py

@@ -47,6 +47,7 @@ from langchain_core.tools import tool
 # Expose Comindware Platform tools from all directories
 # Templates tools
 from .templates_tools.tool_list_attributes import list_attributes
+from .templates_tools.tool_list_records import list_template_records
 
 # Applications tools  
 from .applications_tools.tool_list_templates import list_templates