sophhub 0.4.46 → 0.4.47

package/skills/sophnet-invoice-assistant/src/scripts/invoice_client.py

@@ -0,0 +1,164 @@
+"""Sophnet invoice API client."""
+
+from __future__ import annotations
+
+import requests
+
+
+class InvoiceClientError(RuntimeError):
+    def __init__(self, code, message):
+        super(InvoiceClientError, self).__init__(message)
+        self.code = code
+        self.message = message
+
+
+class InvoiceClient(object):
+    def __init__(self, auth_context):
+        self.auth_context = auth_context
+        self.base_url = auth_context.api_base_url.rstrip("/")
+        self.timeout = 30
+
+    def _headers(self):
+        headers = {
+            "Accept": "application/json",
+        }
+        if self.auth_context.access_token:
+            headers["Authorization"] = "Bearer {0}".format(self.auth_context.access_token.strip())
+        if self.auth_context.cookie:
+            headers["Cookie"] = self.auth_context.cookie.strip()
+        return headers
+
+    def _unwrap_result(self, payload):
+        if not isinstance(payload, dict):
+            return payload
+        status = payload.get("status")
+        if status not in (None, 0):
+            message = payload.get("message") or "Sophnet API returned an error"
+            raise InvoiceClientError("SOPHNET_API_ERROR", message)
+        return payload.get("result")
+
+    def _request(self, method, path, params=None, json_body=None):
+        url = "{0}{1}".format(self.base_url, path)
+        try:
+            response = requests.request(
+                method=method,
+                url=url,
+                headers=self._headers(),
+                params=params,
+                json=json_body,
+                timeout=self.timeout,
+            )
+        except requests.RequestException as exc:
+            raise InvoiceClientError("NETWORK_ERROR", "Failed to request Sophnet: {0}".format(exc))
+
+        if response.status_code in (401, 403):
+            raise InvoiceClientError("AUTH_EXPIRED", "Current Sophnet auth has expired. Please log in again.")
+
+        try:
+            payload = response.json()
+        except ValueError:
+            payload = None
+
+        if not response.ok:
+            if isinstance(payload, dict):
+                message = payload.get("message") or payload.get("error") or response.text
+            else:
+                message = response.text
+            raise InvoiceClientError(
+                "HTTP_{0}".format(response.status_code),
+                "Sophnet API request failed: {0}".format((message or "").strip()[:300]),
+            )
+
+        return self._unwrap_result(payload)
+
+    def list_joined_orgs(self):
+        result = self._request(
+            "GET",
+            "/orgs/joined-org",
+            params={"pageNum": 1, "pageSize": 9999},
+        )
+        if not isinstance(result, dict):
+            raise InvoiceClientError("UNEXPECTED_RESPONSE", "joined-org returned an unexpected response shape.")
+        return result
+
+    def get_current_personal_org(self, explicit_org_id=None):
+        page = self.list_joined_orgs()
+        org_list = page.get("list") or []
+        if explicit_org_id is not None:
+            for org in org_list:
+                if str(org.get("id")) == str(explicit_org_id):
+                    if org.get("isSpecificOrg") is True:
+                        return org
+                    raise InvoiceClientError(
+                        "PERSONAL_ORG_REQUIRED",
+                        "The specified org is not a personal org. This skill only supports personal invoice flows.",
+                    )
+            raise InvoiceClientError("ORG_NOT_FOUND", "The specified personal org was not found.")
+
+        for org in org_list:
+            if org.get("isSpecificOrg") is True:
+                return org
+
+        raise InvoiceClientError("PERSONAL_ORG_NOT_FOUND", "No available personal org was found for the current account.")
+
+    def list_invoice_templates(self, org_id):
+        return self._request("GET", "/orgs/{0}/invoices/templates".format(org_id))
+
+    def save_invoice_template(self, org_id, payload):
+        return self._request(
+            "POST",
+            "/orgs/{0}/invoices/templates".format(org_id),
+            json_body=payload,
+        )
+
+    def delete_invoice_template(self, org_id, template_id):
+        return self._request(
+            "DELETE",
+            "/orgs/{0}/invoices/templates/{1}".format(org_id, template_id),
+        )
+
+    def list_invoiceable_recharge_records(self, org_id, params=None):
+        return self._request(
+            "GET",
+            "/orgs/{0}/invoices/recharge-records".format(org_id),
+            params=params or {"pageNum": 1, "pageSize": 20},
+        )
+
+    def create_invoice_application(self, org_id, payload):
+        return self._request(
+            "POST",
+            "/orgs/{0}/invoices/applications".format(org_id),
+            json_body=payload,
+        )
+
+    def update_invoice_application(self, org_id, application_no, payload):
+        return self._request(
+            "PUT",
+            "/orgs/{0}/invoices/applications/{1}".format(org_id, application_no),
+            json_body=payload,
+        )
+
+    def list_invoice_applications(self, org_id, params=None):
+        return self._request(
+            "GET",
+            "/orgs/{0}/invoices/applications".format(org_id),
+            params=params or {},
+        )
+
+    def get_invoice_application(self, org_id, application_no):
+        page = self.list_invoice_applications(
+            org_id,
+            params={"pageNum": 1, "pageSize": 1, "applicationNo": application_no},
+        )
+        if not isinstance(page, dict):
+            raise InvoiceClientError("UNEXPECTED_RESPONSE", "Invoice list API returned an unexpected response shape.")
+        items = page.get("list") or []
+        if not items:
+            raise InvoiceClientError("APPLICATION_NOT_FOUND", "The target invoice application was not found.")
+        return items[0]
+
+    def download_invoice_file(self, org_id, application_no):
+        return self._request(
+            "GET",
+            "/orgs/{0}/invoices/applications/{1}/download".format(org_id, application_no),
+        )

package/skills/sophnet-invoice-assistant/src/scripts/output.py

@@ -0,0 +1,63 @@
+"""Structured output helpers for the invoice assistant skeleton."""
+
+from __future__ import annotations
+
+import json
+
+from dto import ActionResult
+
+
+def build_result(status, action, message, extra=None):
+    return ActionResult(status=status, action=action, message=message, extra=extra or {})
+
+
+def emit_result(result):
+    payload = {
+        "STATUS": result.status,
+        "ACTION": result.action,
+        "MESSAGE": result.message,
+    }
+    payload.update(result.extra or {})
+
+    for key, value in payload.items():
+        if value is None:
+            continue
+        if isinstance(value, (dict, list, tuple)):
+            value = json.dumps(value, ensure_ascii=False)
+        print("{0}={1}".format(key, value))
+
+
+def failure(action, error_code, error_message, extra=None):
+    data = {"ERROR_CODE": error_code, "ERROR_MESSAGE": error_message}
+    if extra:
+        data.update(extra)
+    return build_result(
+        status="failed",
+        action=action,
+        message=error_message,
+        extra=data,
+    )
+
+
+def not_implemented(action, message):
+    return build_result(
+        status="not_implemented",
+        action=action,
+        message=message,
+        extra={"ERROR_CODE": "API_NOT_IMPLEMENTED"},
+    )
+
+
+def need_confirmation(action, summary, message, extra=None):
+    data = {
+        "CONFIRM_REQUIRED": "true",
+        "CONFIRM_SUMMARY": summary,
+    }
+    if extra:
+        data.update(extra)
+    return build_result(
+        status="need_confirmation",
+        action=action,
+        message=message,
+        extra=data,
+    )

package/skills/sophnet-invoice-assistant/src/scripts/prepare_flow.py

@@ -0,0 +1,58 @@
+"""Prepare context for invoice actions."""
+
+from __future__ import annotations
+
+from invoice_client import InvoiceClientError
+from output import build_result, failure
+from submit_flow import INVOICE_ELIGIBLE_START_DATE, _filter_eligible_records
+
+
+def run_prepare(request, auth_context, client):
+    if not auth_context.is_authenticated:
+        return failure(
+            action=request.action,
+            error_code="AUTH_CONTEXT_MISSING",
+            error_message="Current Sophnet auth context is missing. Please log in again.",
+        )
+
+    try:
+        org = client.get_current_personal_org(request.org_id)
+        templates = client.list_invoice_templates(org.get("id")) or []
+        records_page = client.list_invoiceable_recharge_records(
+            org.get("id"),
+            params={"pageNum": 1, "pageSize": 20, "invoiceableOnly": "true"},
+        )
+        applications_page = client.list_invoice_applications(
+            org.get("id"),
+            params={"pageNum": 1, "pageSize": 10},
+        )
+    except InvoiceClientError as exc:
+        return failure(
+            action=request.action,
+            error_code=exc.code,
+            error_message=exc.message,
+        )
+
+    records = records_page.get("list") or [] if isinstance(records_page, dict) else []
+    eligible_records, ineligible_records = _filter_eligible_records(records)
+    applications = applications_page.get("list") or [] if isinstance(applications_page, dict) else []
+
+    return build_result(
+        status="succeeded",
+        action=request.action,
+        message="Resolved the current personal org and loaded invoice context.",
+        extra={
+            "ORG_ID": str(org.get("id")),
+            "ORG_NAME": org.get("name") or "",
+            "IS_SPECIFIC_ORG": str(bool(org.get("isSpecificOrg"))).lower(),
+            "TEMPLATE_COUNT": str(len(templates)),
+            "AVAILABLE_RECHARGE_RECORD_COUNT": str(len(eligible_records)),
+            "INELIGIBLE_RECHARGE_RECORD_COUNT": str(len(ineligible_records)),
+            "INVOICE_ELIGIBLE_START_DATE": INVOICE_ELIGIBLE_START_DATE,
+            "APPLICATION_COUNT": str(len(applications)),
+            "TEMPLATES": templates[:10],
+            "AVAILABLE_RECHARGE_RECORDS": eligible_records[:10],
+            "INELIGIBLE_RECHARGE_RECORDS": ineligible_records[:10],
+            "RECENT_APPLICATIONS": applications[:10],
+        },
+    )

package/skills/sophnet-invoice-assistant/src/scripts/risk_rules.py

@@ -0,0 +1,95 @@
+"""Risk classification rules for the invoice assistant skeleton."""
+
+from __future__ import annotations
+
+KEYWORD_LAST = "\u4e0a\u6b21"
+KEYWORD_RECENT = "\u6700\u8fd1"
+KEYWORD_LATEST = "\u6700\u65b0"
+
+TEMPLATE_FIELD_NAMES = (
+    "buyerType",
+    "title",
+    "taxNo",
+    "addressPhone",
+    "bankAccount",
+    "invoiceType",
+)
+
+
+def _normalize_text(value):
+    if value is None:
+        return ""
+    return str(value).strip()
+
+
+def _selected_trans_nos(request):
+    return [item.strip() for item in str(request.recharge_trans_nos or "").split(",") if item.strip()]
+
+
+def _requests_latest_template(request):
+    text = request.user_request or ""
+    return bool(
+        request.use_latest_template
+        or KEYWORD_LAST in text
+        or KEYWORD_RECENT in text
+        or KEYWORD_LATEST in text
+    )
+
+
+def _same_template(left, right):
+    if not left or not right:
+        return False
+    left_id = left.get("id")
+    right_id = right.get("id")
+    if left_id is not None and right_id is not None:
+        return str(left_id) == str(right_id)
+    return _normalize_text(left.get("templateName")) == _normalize_text(right.get("templateName"))
+
+
+def _payload_matches_template(payload, template):
+    if not payload or not template:
+        return False
+    for field_name in TEMPLATE_FIELD_NAMES:
+        if _normalize_text(payload.get(field_name)) != _normalize_text(template.get(field_name)):
+            return False
+    return True
+
+
+def classify_submit_risk(request, payload=None, template=None, latest_template=None, selected_records=None):
+    selected_records = selected_records or []
+    values = _selected_trans_nos(request)
+
+    if request.save_as_template:
+        return {
+            "level": "high",
+            "reason": "save_as_template_requires_confirmation",
+        }
+    if len(values) != 1 or len(selected_records) != 1:
+        return {
+            "level": "high",
+            "reason": "single_recharge_record_required",
+        }
+    if not _requests_latest_template(request):
+        return {
+            "level": "high",
+            "reason": "latest_template_reuse_not_requested",
+        }
+    if not template or not latest_template:
+        return {
+            "level": "high",
+            "reason": "latest_template_not_available",
+        }
+    if not _same_template(template, latest_template):
+        return {
+            "level": "high",
+            "reason": "selected_template_is_not_latest",
+        }
+    if not _payload_matches_template(payload, template):
+        return {
+            "level": "high",
+            "reason": "invoice_fields_changed_from_template",
+        }
+    return {
+        "level": "low",
+        "reason": "latest_template_with_single_record_and_matching_fields",
+    }

package/skills/sophnet-invoice-assistant/src/scripts/status_flow.py

@@ -0,0 +1,69 @@
+"""Invoice application status query skeleton."""
+
+from __future__ import annotations
+
+from invoice_client import InvoiceClientError
+from output import build_result, failure
+
+
+def _build_status_message(application):
+    status = application.get("status")
+    application_no = application.get("applicationNo")
+    if status == "ISSUED":
+        return "Invoice application {0} has been issued and is ready for download.".format(application_no)
+    if status == "REJECTED":
+        return "Invoice application {0} was rejected. Check the reject reason before retrying.".format(application_no)
+    return "Invoice application {0} is still being processed.".format(application_no)
+
+
+def run_status(request, auth_context, client):
+    if not auth_context.is_authenticated:
+        return failure(
+            action=request.action,
+            error_code="AUTH_CONTEXT_MISSING",
+            error_message="Current Sophnet auth context is missing. Please log in again.",
+        )
+
+    try:
+        org = client.get_current_personal_org(request.org_id)
+        params = {"pageNum": 1, "pageSize": 10}
+        if request.application_no:
+            params["applicationNo"] = request.application_no
+        page = client.list_invoice_applications(org.get("id"), params=params)
+    except InvoiceClientError as exc:
+        return failure(
+            action=request.action,
+            error_code=exc.code,
+            error_message=exc.message,
+        )
+
+    items = []
+    if isinstance(page, dict):
+        items = page.get("list") or []
+    if not items:
+        return failure(
+            action=request.action,
+            error_code="NO_APPLICATION_FOUND",
+            error_message="No invoice application was found under the current personal org.",
+            extra={"ORG_ID": str(org.get("id"))},
+        )
+
+    application = items[0]
+    return build_result(
+        status="succeeded",
+        action=request.action,
+        message=_build_status_message(application),
+        extra={
+            "ORG_ID": str(org.get("id")),
+            "ORG_NAME": org.get("name") or "",
+            "APPLICATION_NO": application.get("applicationNo") or "",
+            "APPLICATION_STATUS": application.get("status") or "",
+            "TITLE": application.get("title") or "",
+            "AMOUNT": str(application.get("amount") or ""),
+            "HAS_INVOICE_FILE": str(bool(application.get("hasInvoiceFile"))).lower(),
+            "APPLIED_AT": application.get("appliedAt") or "",
+            "ISSUED_AT": application.get("issuedAt") or "",
+            "REJECT_REASON": application.get("rejectReason") or "",
+            "RESULT_COUNT": str(len(items)),
+        },
+    )