sophhub 0.4.46 → 0.4.48

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

@@ -0,0 +1,89 @@
+"""Issued invoice download skeleton."""
+
+from __future__ import annotations
+
+from invoice_client import InvoiceClientError
+from output import build_result, failure, need_confirmation
+
+
+def _candidate_summary(items):
+    values = []
+    for item in items[:5]:
+        values.append(
+            "{0}({1})".format(
+                item.get("applicationNo") or "",
+                item.get("title") or item.get("status") or "unknown",
+            )
+        )
+    return "Multiple issued invoices were found. Specify an application number before downloading: {0}".format(", ".join(values))
+
+
+def run_download(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)
+        target_application_no = request.application_no
+        if not target_application_no:
+            page = client.list_invoice_applications(
+                org.get("id"),
+                params={"pageNum": 1, "pageSize": 10, "status": "ISSUED"},
+            )
+            items = page.get("list") or [] if isinstance(page, dict) else []
+            if not items:
+                return failure(
+                    action=request.action,
+                    error_code="NO_ISSUED_APPLICATION_FOUND",
+                    error_message="No issued invoice is currently available for download under the personal org.",
+                    extra={"ORG_ID": str(org.get("id"))},
+                )
+            if len(items) > 1:
+                return need_confirmation(
+                    action=request.action,
+                    summary=_candidate_summary(items),
+                    message="Multiple downloadable invoices were found. Please specify an application number.",
+                    extra={
+                        "ORG_ID": str(org.get("id")),
+                        "CANDIDATE_APPLICATION_NOS": ",".join(
+                            [str(item.get("applicationNo") or "") for item in items[:10]]
+                        ),
+                    },
+                )
+            target_application_no = items[0].get("applicationNo")
+
+        if not target_application_no:
+            return failure(
+                action=request.action,
+                error_code="APPLICATION_NO_REQUIRED",
+                error_message="The invoice application number is required before downloading.",
+            )
+
+        file_info = client.download_invoice_file(org.get("id"), target_application_no)
+    except InvoiceClientError as exc:
+        return failure(
+            action=request.action,
+            error_code=exc.code,
+            error_message=exc.message,
+        )
+
+    return build_result(
+        status="succeeded",
+        action=request.action,
+        message="Invoice download details were retrieved successfully.",
+        extra={
+            "ORG_ID": str(org.get("id")),
+            "ORG_NAME": org.get("name") or "",
+            "APPLICATION_NO": file_info.get("applicationNo") or str(target_application_no),
+            "FILE_NAME": file_info.get("fileName") or "",
+            "CONTENT_TYPE": file_info.get("contentType") or "",
+            "FILE_SIZE": str(file_info.get("fileSize") or ""),
+            "PREVIEW_URL": file_info.get("previewUrl") or "",
+            "DOWNLOAD_URL": file_info.get("downloadUrl") or "",
+            "EXPIRES_IN": str(file_info.get("expiresIn") or ""),
+        },
+    )

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

@@ -0,0 +1,46 @@
+"""Data transfer objects for the invoice assistant skeleton."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+
+@dataclass
+class ActionRequest(object):
+    action: str
+    user_request: str
+    org_id: Optional[str] = None
+    application_no: Optional[str] = None
+    template_id: Optional[str] = None
+    confirm: bool = False
+    buyer_type: Optional[str] = None
+    title: Optional[str] = None
+    tax_no: Optional[str] = None
+    address_phone: Optional[str] = None
+    bank_account: Optional[str] = None
+    invoice_type: Optional[str] = None
+    recharge_trans_nos: Optional[str] = None
+    issuing_mode: Optional[str] = None
+    save_as_template: bool = False
+    template_name: Optional[str] = None
+    use_latest_template: bool = False
+
+
+@dataclass
+class AuthContext(object):
+    api_base_url: str
+    access_token: Optional[str]
+    cookie: Optional[str]
+
+    @property
+    def is_authenticated(self) -> bool:
+        return bool(self.access_token or self.cookie)
+
+
+@dataclass
+class ActionResult(object):
+    status: str
+    action: str
+    message: str
+    extra: Optional[Dict[str, str]] = None

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)),
+        },
+    )