Watch
1
0
Fork
You've already forked arc
0
forked from hesabix/arc
arc/hesabixAPI/tests/test_office_automation_plugin.py
Babak Alizadeh 6a5e60c87d feat(office-automation): add commercial correspondence suite
Bring secretariats, ECE 1.01, multi-sign, archive, public tracking, and due-followup alerts into the OA plugin, with fa/en UI and existing workflow/SMS reuse.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-02 15:15:33 +03:30

769 lines
29 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""گیت لایسنس، گردش نامه سمت‌محور و ابزارهای MCP اتوماسیون اداری."""
from __future__ import annotations
import re
from datetime import date, datetime, timedelta
from pathlib import Path
from unittest.mock import MagicMock, patch
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from adapters.db.models.file_storage import FileStorage
from adapters.db.models.office_automation import (
OaArchiveFolder,
OaAuditLog,
OaCartableRule,
OaDelegation,
OaDispatch,
OaEceMessage,
OaExternalOrg,
OaLetter,
OaLetterAttachment,
OaLetterFormat,
OaLetterLink,
OaLetterNumberCounter,
OaLetterSignStep,
OaLetterTemplate,
OaLetterVersion,
OaMailboxMessage,
OaOrgUnit,
OaParaph,
OaPosition,
OaPositionHolder,
OaReferral,
OaSecretariat,
OaSettings,
OaSignPathTemplate,
OaSignPathTemplateStep,
OaUserSignature,
)
from adapters.db.models.user import User
from adapters.db.session import Base
from adapters.db.seed_data.notification_event_types_seed import OFFICE_AUTOMATION_EVENT_CODES
from app.core.office_automation_plugin_dependency import PLUGIN_CODE, check_office_automation_plugin_active
from app.core.responses import ApiError
from app.services import office_automation_extended_service as ext
from app.services import office_automation_service as svc
from app.services.ai.ai_tool_manifest import get_manifest_entry
from app.services.office_automation_ece import build_ece_xml, parse_ece_xml
def _mock_db_with_license(*, plugin_active: bool = True, business_active: bool = True, expired: bool = False):
db = MagicMock()
plugin = MagicMock()
plugin.id = 77
plugin.is_active = plugin_active
license_row = None
if business_active:
license_row = MagicMock()
license_row.status = "active"
if expired:
license_row.ends_at = datetime.utcnow() - timedelta(days=1)
else:
license_row.ends_at = datetime.utcnow() + timedelta(days=30)
def query_side_effect(model):
q = MagicMock()
if model.__name__ == "MarketplacePlugin":
q.filter.return_value.first.return_value = plugin if plugin_active else None
elif model.__name__ == "BusinessPlugin":
q.filter.return_value.first.return_value = license_row
return q
db.query.side_effect = query_side_effect
return db
def test_plugin_active_when_licensed():
assert check_office_automation_plugin_active(_mock_db_with_license(), 1) is True
def test_plugin_inactive_when_no_marketplace_plugin():
assert check_office_automation_plugin_active(_mock_db_with_license(plugin_active=False), 1) is False
def test_plugin_inactive_when_no_business_license():
assert check_office_automation_plugin_active(_mock_db_with_license(business_active=False), 1) is False
def test_plugin_inactive_when_expired():
assert check_office_automation_plugin_active(_mock_db_with_license(expired=True), 1) is False
def test_plugin_code_constant():
assert PLUGIN_CODE == "office_automation"
assert "office_automation.letter_referred" in OFFICE_AUTOMATION_EVENT_CODES
assert "office_automation.letter_returned" in OFFICE_AUTOMATION_EVENT_CODES
assert "office_automation.letter_dispatched" in OFFICE_AUTOMATION_EVENT_CODES
assert "office_automation.letter_followup_due" in OFFICE_AUTOMATION_EVENT_CODES
OA_TOOLS = (
"get_oa_dashboard",
"get_oa_settings",
"update_oa_settings",
"list_oa_org_units",
"create_oa_org_unit",
"update_oa_org_unit",
"list_oa_positions",
"create_oa_position",
"update_oa_position",
"list_my_oa_positions",
"list_oa_position_holders",
"assign_oa_position_holder",
"end_oa_position_holder",
"list_oa_delegations",
"create_oa_delegation",
"end_oa_delegation",
"list_oa_cartable",
"get_oa_letter",
"get_oa_letter_print",
"create_oa_letter_draft",
"update_oa_letter_draft",
"delete_oa_letter_draft",
"register_oa_letter",
"refer_oa_letter",
"complete_oa_referral",
"return_oa_referral",
"add_oa_paraph",
"add_oa_letter_attachment",
"remove_oa_letter_attachment",
"archive_oa_letter",
"set_oa_follow_up",
"link_oa_letters",
"search_oa_letters",
"list_oa_letter_formats",
"create_oa_letter_format",
"update_oa_letter_format",
"delete_oa_letter_format",
"list_oa_letter_templates",
"create_oa_letter_template",
"update_oa_letter_template",
"delete_oa_letter_template",
"list_oa_secretariats",
"create_oa_secretariat",
"list_oa_external_orgs",
"create_oa_external_org",
"start_oa_sign_path",
"sign_oa_letter",
"dispatch_oa_letter",
"export_oa_ece",
"import_oa_ece",
"summarize_oa_letter",
"list_oa_archive_folders",
"get_oa_delay_report",
"import_oa_email_letter",
"ocr_oa_letter",
"send_oa_ece",
"send_oa_email_letter",
)
def test_mcp_tools_cover_letter_lifecycle():
src = Path(__file__).resolve().parents[1] / "app" / "services" / "ai" / "ai_function_extensions_mcp_office_automation.py"
text = src.read_text(encoding="utf-8")
names = set(re.findall(r'_register\(\s*registry,\s*"([^"]+)"', text))
assert set(OA_TOOLS) <= names
assert 'category="office_automation"' in text
assert '"office_automation.refer"' in text
assert '"registry"' in text
registry_src = (Path(__file__).resolve().parents[1] / "app" / "services" / "ai" / "function_registry.py").read_text(encoding="utf-8")
assert "register_mcp_office_automation_functions" in registry_src
for name in OA_TOOLS:
entry = get_manifest_entry(name)
assert entry is not None, name
assert "office_automation" in entry.domains
assert get_manifest_entry("delete_oa_letter_draft").side_effect == "delete"
assert get_manifest_entry("register_oa_letter").always_confirm is True
def _session():
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(
engine,
tables=[
User.__table__,
FileStorage.__table__,
OaSettings.__table__,
OaOrgUnit.__table__,
OaPosition.__table__,
OaPositionHolder.__table__,
OaDelegation.__table__,
OaLetterFormat.__table__,
OaLetterTemplate.__table__,
OaLetter.__table__,
OaLetterNumberCounter.__table__,
OaReferral.__table__,
OaParaph.__table__,
OaLetterAttachment.__table__,
OaLetterLink.__table__,
OaAuditLog.__table__,
OaSecretariat.__table__,
OaExternalOrg.__table__,
OaArchiveFolder.__table__,
OaUserSignature.__table__,
OaSignPathTemplate.__table__,
OaSignPathTemplateStep.__table__,
OaLetterSignStep.__table__,
OaLetterVersion.__table__,
OaDispatch.__table__,
OaEceMessage.__table__,
OaCartableRule.__table__,
OaMailboxMessage.__table__,
],
)
return sessionmaker(bind=engine)()
def _user(db, email, code):
row = User(email=email, password_hash="x", referral_code=code, is_active=True)
db.add(row)
db.commit()
db.refresh(row)
return row
@patch("app.services.office_automation_service.check_office_automation_plugin_active", return_value=True)
def test_position_occupancy_numbering_paraph_and_referral(_plugin):
db = _session()
owner = _user(db, "owner@example.com", "oa1")
clerk = _user(db, "clerk@example.com", "oa2")
bid = 1
unit = svc.create_org_unit(db, bid, {"code": "hq", "name_i18n": {"fa": "ستاد", "en": "HQ"}}, owner.id)
auto_unit = svc.create_org_unit(db, bid, {"name_i18n": {"fa": "واحد خودکار"}}, owner.id)
assert auto_unit["code"].startswith("u")
with pytest.raises(ApiError) as dup_code:
svc.create_org_unit(
db, bid,
{"code": "hq", "name_i18n": {"fa": "تکراری"}, "auto_generate_code": False},
owner.id,
)
assert dup_code.value.code == "OA_CODE_EXISTS"
with pytest.raises(ApiError) as missing_code:
svc.create_org_unit(
db, bid,
{"name_i18n": {"fa": "بدون کد"}, "auto_generate_code": False},
owner.id,
)
assert missing_code.value.code == "VALIDATION_ERROR"
mgr = svc.create_position(
db, bid,
{"code": "mgr", "org_unit_id": unit["id"], "name_i18n": {"fa": "مدیر", "en": "Manager"}, "is_secretariat": True},
owner.id,
)
exp = svc.create_position(
db, bid,
{"code": "exp", "org_unit_id": unit["id"], "name_i18n": {"fa": "کارشناس", "en": "Expert"}},
owner.id,
)
auto_pos = svc.create_position(
db, bid,
{"org_unit_id": unit["id"], "name_i18n": {"fa": "سمت خودکار"}},
owner.id,
)
assert auto_pos["code"].startswith("p")
with pytest.raises(ApiError) as dup_pos:
svc.create_position(
db, bid,
{"code": "mgr", "org_unit_id": unit["id"], "name_i18n": {"fa": "تکراری"}, "auto_generate_code": False},
owner.id,
)
assert dup_pos.value.code == "OA_CODE_EXISTS"
svc.assign_position_holder(db, bid, {"position_id": mgr["id"], "user_id": owner.id, "is_primary": True}, owner.id)
svc.assign_position_holder(db, bid, {"position_id": exp["id"], "user_id": clerk.id, "is_primary": True}, owner.id)
mine = svc.list_my_positions(db, bid, owner.id)
assert {p["code"] for p in mine} == {"mgr"}
with pytest.raises(ApiError) as missing:
svc.create_letter_draft(db, bid, {"subject": "بدون سمت"}, clerk.id, mgr["id"])
assert missing.value.code == "OA_POSITION_NOT_HELD"
draft = svc.create_letter_draft(
db, bid,
{"subject": "درخواست مرخصی", "body": "متن نامه", "letter_kind": "internal", "letter_date": "1404/08/10"},
owner.id, mgr["id"], calendar_type="jalali",
)
assert draft["status"] == "draft"
assert draft["secretariat_number"] is None
incoming_draft = svc.create_letter_draft(
db, bid, {"subject": "وارده", "letter_kind": "incoming"}, clerk.id, exp["id"],
)
with pytest.raises(ApiError) as secretariat:
svc.register_letter(db, bid, incoming_draft["id"], {"letter_kind": "incoming"}, clerk.id, exp["id"])
assert secretariat.value.code == "OA_SECRETARIAT_REQUIRED"
registered = svc.register_letter(
db, bid, draft["id"],
{"recipients": [{"to_position_id": exp["id"], "kind": "action", "instruction": "اقدام شود"}]},
owner.id, mgr["id"],
)
assert registered["status"] == "in_circulation"
assert registered["secretariat_number"]
assert registered["secretariat_seq"] == 1
assert len(registered["referrals"]) == 1
second = svc.create_letter_draft(
db, bid, {"subject": "نامه دوم", "letter_kind": "internal", "letter_date": "1404/08/10"}, owner.id, mgr["id"], calendar_type="jalali",
)
second_reg = svc.register_letter(db, bid, second["id"], {}, owner.id, mgr["id"])
assert second_reg["secretariat_seq"] == 2
inbox = svc.list_cartable(db, bid, clerk.id, exp["id"], folder="inbox")
assert inbox["total"] == 1
referral_id = inbox["items"][0]["referral_id"]
paraph = svc.add_paraph(db, bid, registered["id"], {"text": "موافقت می‌شود", "referral_id": referral_id}, clerk.id, exp["id"])
assert "موافقت" in paraph["text"]
done = svc.complete_referral(db, bid, referral_id, {"note": "انجام شد"}, clerk.id, exp["id"])
assert any(r["id"] == referral_id and r["status"] == "done" for r in done["referrals"])
file_row = FileStorage(
id="oa-file-00000000-0000-0000-0000-000000000001",
original_name="scan.pdf",
stored_name="scan.pdf",
file_path="/tmp/scan.pdf",
file_size=12,
mime_type="application/pdf",
storage_type="local",
uploaded_by=owner.id,
business_id=None,
module_context="office_automation",
is_active=True,
created_at=datetime.utcnow(),
updated_at=datetime.utcnow(),
)
db.add(file_row)
db.commit()
attached = svc.add_attachment(
db, bid, registered["id"],
{"file_storage_id": file_row.id, "title": "پیوست اسکن"},
owner.id, mgr["id"],
)
assert attached["title"] == "پیوست اسکن"
letter_with_file = svc.get_letter(db, bid, registered["id"], owner.id, mgr["id"], is_admin=True)
assert letter_with_file["attachments"]
svc.remove_attachment(db, bid, attached["id"], owner.id, mgr["id"])
archived = svc.archive_letter(db, bid, registered["id"], owner.id, mgr["id"])
assert archived["status"] == "archived"
with pytest.raises(ApiError) as attach_archived:
svc.add_attachment(
db, bid, registered["id"],
{"file_storage_id": file_row.id, "title": "بعد از بایگانی"},
owner.id, mgr["id"],
)
assert attach_archived.value.code == "OA_LETTER_ARCHIVED"
registry = svc.list_cartable(db, bid, owner.id, mgr["id"], folder="registry")
assert registry["total"] == 2
printed = svc.get_letter_print(db, bid, registered["id"], owner.id, mgr["id"])
assert printed["paraphs"]
assert printed["print"]["internal_prefix"] == "INT"
updated_draft = svc.update_letter_draft(
db, bid, incoming_draft["id"], {"subject": "وارده دبیرخانه", "sender_org": "سازمان الف"}, clerk.id, exp["id"]
)
assert updated_draft["subject"] == "وارده دبیرخانه"
incoming_reg = svc.register_letter(
db, bid, incoming_draft["id"], {"letter_kind": "incoming"}, owner.id, mgr["id"]
)
assert incoming_reg["secretariat_number"].startswith("IN-")
assert incoming_reg["letter_kind"] == "incoming"
cced = svc.refer_letter(
db, bid, second_reg["id"],
{"recipients": [{"to_position_id": exp["id"], "kind": "info", "instruction": "رونوشت"}]},
owner.id, mgr["id"],
)
assert any(r["kind"] == "info" for r in cced["referrals"])
cc_box = svc.list_cartable(db, bid, clerk.id, exp["id"], folder="cc")
assert cc_box["total"] >= 1
ret_draft = svc.create_letter_draft(db, bid, {"subject": "نامه عودت", "letter_kind": "internal"}, owner.id, mgr["id"])
ret_reg = svc.register_letter(
db, bid, ret_draft["id"],
{"recipients": [{"to_position_id": exp["id"], "kind": "action"}]},
owner.id, mgr["id"],
)
ret_inbox = svc.list_cartable(db, bid, clerk.id, exp["id"], folder="inbox")
ret_id = next(item["referral_id"] for item in ret_inbox["items"] if item["id"] == ret_reg["id"])
returned = svc.return_referral(db, bid, ret_id, {"note": "نیاز به اصلاح"}, clerk.id, exp["id"])
assert any(r["id"] == ret_id and r["status"] == "returned" for r in returned["referrals"])
assert any(r["kind"] == "return" for r in returned["referrals"])
followed = svc.set_follow_up(db, bid, second_reg["id"], {"follow_up_at": "1404/08/20"}, owner.id, mgr["id"])
assert followed["follow_up_at"]
follow_box = svc.list_cartable(db, bid, owner.id, mgr["id"], folder="followup")
assert follow_box["total"] >= 1
linked = svc.link_letters(
db, bid, second_reg["id"],
{"related_letter_id": registered["id"], "link_kind": "related"},
owner.id, mgr["id"],
)
assert linked["related_letter_id"] == registered["id"]
assert linked["link_kind"] == "related"
settings = svc.update_settings(db, bid, {"internal_prefix": "INTX", "numbering_calendar": "jalali"}, owner.id)
assert settings["internal_prefix"] == "INTX"
with pytest.raises(ApiError) as dup_holder:
svc.assign_position_holder(db, bid, {"position_id": mgr["id"], "user_id": owner.id, "is_primary": True}, owner.id)
assert dup_holder.value.code == "OA_HOLDER_EXISTS"
with pytest.raises(ApiError) as bad_date:
svc.create_letter_draft(db, bid, {"subject": "x", "letter_date": "not-a-date"}, owner.id, mgr["id"])
assert bad_date.value.code == "VALIDATION_ERROR"
draft_only = svc.create_letter_draft(db, bid, {"subject": "فقط پیش‌نویس"}, owner.id, mgr["id"])
with pytest.raises(ApiError) as arch:
svc.archive_letter(db, bid, draft_only["id"], owner.id, mgr["id"])
assert arch.value.code == "OA_LETTER_STILL_DRAFT"
dash = svc.get_dashboard(db, bid, owner.id, 999999)
assert dash["active_position_id"] == mgr["id"]
assert "inbox" in dash["counts"]
with pytest.raises(ApiError) as link_draft:
svc.link_letters(
db, bid, draft_only["id"],
{"related_letter_id": registered["id"], "link_kind": "related"},
owner.id, mgr["id"],
)
assert link_draft.value.code == "OA_LETTER_STILL_DRAFT"
archived = svc.archive_letter(db, bid, second_reg["id"], owner.id, mgr["id"])
assert archived["status"] == "archived"
with pytest.raises(ApiError) as rearch:
svc.archive_letter(db, bid, second_reg["id"], owner.id, mgr["id"])
assert rearch.value.code == "OA_LETTER_ARCHIVED"
delegation = svc.create_delegation(
db, bid, {"position_id": mgr["id"], "delegate_user_id": clerk.id, "scope": "full"}, owner.id
)
assert delegation["delegate_user_id"] == clerk.id
with pytest.raises(ApiError) as dup_del:
svc.create_delegation(
db, bid, {"position_id": mgr["id"], "delegate_user_id": clerk.id, "scope": "full"}, owner.id
)
assert dup_del.value.code == "OA_DELEGATION_EXISTS"
delegated = svc.list_my_positions(db, bid, clerk.id)
assert {p["code"] for p in delegated} >= {"exp", "mgr"}
svc.end_delegation(db, bid, delegation["id"], owner.id)
throwaway = svc.create_letter_draft(db, bid, {"subject": "حذف شود"}, owner.id, mgr["id"])
deleted = svc.delete_letter_draft(db, bid, throwaway["id"], owner.id, mgr["id"])
assert deleted["deleted"] is True
db.close()
@patch("app.services.office_automation_service.check_office_automation_plugin_active", return_value=True)
def test_letter_templates_formats_search_and_rich_body(_plugin):
db = _session()
owner = _user(db, "fmt@example.com", "oa3")
bid = 1
unit = svc.create_org_unit(db, bid, {"code": "hq", "name_i18n": {"fa": "ستاد"}}, owner.id)
mgr = svc.create_position(
db, bid,
{"code": "mgr", "org_unit_id": unit["id"], "name_i18n": {"fa": "مدیر بازرگانی"}},
owner.id,
)
exp = svc.create_position(
db, bid,
{"code": "exp", "org_unit_id": unit["id"], "name_i18n": {"fa": "کارشناس مالی"}},
owner.id,
)
svc.assign_position_holder(db, bid, {"position_id": mgr["id"], "user_id": owner.id, "is_primary": True}, owner.id)
fmt = svc.create_letter_format(
db, bid,
{"name": "رسمی A4", "paper_size": "a4", "footer_text": "شرکت نمونه", "is_default": True, "margin_top": 25},
owner.id,
)
assert fmt["is_default"] is True
assert fmt["margin_top"] == 25
settings = svc.get_settings(db, bid)
assert settings["default_format_id"] == fmt["id"]
assert settings["paper_size"] == "a4"
tpl = svc.create_letter_template(
db, bid,
{
"name": "درخواست مرخصی",
"letter_kind": "internal",
"subject": "درخواست مرخصی استحقاقی",
"body": "## درخواست\nبا سلام",
"body_format": "markdown",
"format_id": fmt["id"],
"is_default": True,
},
owner.id,
)
assert tpl["body_format"] == "markdown"
found = svc.list_positions(db, bid, q="بازرگانی")
assert any(p["id"] == mgr["id"] for p in found)
miss = svc.list_positions(db, bid, q="ناموجودxyz")
assert miss == []
draft = svc.create_letter_draft(
db, bid,
{
"subject": tpl["subject"],
"body": tpl["body"],
"body_format": "markdown",
"letter_kind": "internal",
"sender_position_id": mgr["id"],
"receiver_position_id": exp["id"],
"format_id": fmt["id"],
"template_id": tpl["id"],
},
owner.id, mgr["id"],
)
assert draft["body_format"] == "markdown"
assert draft["format_id"] == fmt["id"]
registered = svc.register_letter(db, bid, draft["id"], {}, owner.id, mgr["id"])
printed = svc.get_letter_print(db, bid, registered["id"], owner.id, mgr["id"], is_admin=True)
assert printed["print"]["footer_text"] == "شرکت نمونه"
assert printed["print"]["paper_size"] == "a4"
assert printed["sender_position_title"] == "مدیر بازرگانی"
hits = svc.search_letters(db, bid, owner.id, q="مرخصی", is_admin=True)
assert any(item["id"] == registered["id"] for item in hits)
svc.update_settings(db, bid, {"background_file_id": None, "default_body_format": "html", "footer_text": "پاورقی"}, owner.id)
updated = svc.get_settings(db, bid)
assert updated["default_body_format"] == "html"
svc.delete_letter_template(db, bid, tpl["id"], owner.id)
svc.delete_letter_format(db, bid, fmt["id"], owner.id)
db.close()
def test_ece_xml_roundtrip_jalali_and_classification():
from datetime import date
xml = build_ece_xml(
sender={"name": "دبیرخانه", "organization": "شرکت نمونه", "position": "مدیر", "department": "ستاد"},
receiver={"name": "سازمان الف", "organization": "سازمان الف"},
letter_no="OUT-1404-000001",
letter_date=date(2025, 10, 31),
subject="درخواست استعلام",
urgency="urgent",
confidentiality="highly_confidential",
keywords="استعلام",
body="متن نامه برای ECE",
calendar_label="jalali",
)
assert "<letter" in xml
assert "Protocol" in xml
parsed = parse_ece_xml(xml)
assert parsed["subject"] == "درخواست استعلام"
assert parsed["urgency"] == "urgent"
assert parsed["confidentiality"] == "highly_confidential"
assert parsed["letter_no"] == "OUT-1404-000001"
assert parsed["show_as"] == "jalali"
assert "متن نامه" in (parsed.get("body") or "")
@patch("app.services.office_automation_service.check_office_automation_plugin_active", return_value=True)
def test_commercial_upgrade_secretariats_sign_ece_track_archive(_plugin):
db = _session()
owner = _user(db, "oa-pro@example.com", "oa4")
clerk = _user(db, "oa-clerk@example.com", "oa5")
bid = 1
unit = svc.create_org_unit(db, bid, {"code": "hq", "name_i18n": {"fa": "ستاد", "en": "HQ"}}, owner.id)
mgr = svc.create_position(
db, bid,
{"code": "mgr", "org_unit_id": unit["id"], "name_i18n": {"fa": "مدیر", "en": "Manager"}, "is_secretariat": True},
owner.id,
)
exp = svc.create_position(
db, bid,
{"code": "exp", "org_unit_id": unit["id"], "name_i18n": {"fa": "کارشناس", "en": "Expert"}},
owner.id,
)
svc.assign_position_holder(db, bid, {"position_id": mgr["id"], "user_id": owner.id, "is_primary": True}, owner.id)
svc.assign_position_holder(db, bid, {"position_id": exp["id"], "user_id": clerk.id, "is_primary": True}, owner.id)
main_row = ext.ensure_default_secretariat(db, bid)
db.commit()
main = {"id": main_row.id}
branch = ext.create_secretariat(
db, bid,
{"code": "branch", "name_i18n": {"fa": "دبیرخانه شعبه", "en": "Branch secretariat"}, "outgoing_prefix": "BR"},
owner.id,
)
assert main["id"] != branch["id"]
secs = ext.list_secretariats(db, bid, lang="en")
assert any(s["title"] == "Central secretariat" for s in secs)
org = ext.create_external_org(
db, bid,
{"code": "org-a", "name_i18n": {"fa": "سازمان الف", "en": "Org A"}, "ece_email": "ece@org-a.test"},
owner.id, lang="fa",
)
assert org["ece_email"] == "ece@org-a.test"
folder = ext.save_archive_folder(db, bid, {"code": "legal", "name_i18n": {"fa": "حقوقی", "en": "Legal"}}, owner.id)
assert folder["code"] == "legal"
ext.save_cartable_rule(
db, bid,
{"name": "رونوشت خودکار", "conditions": {"subject_contains": "رونوشت"}, "actions": {"mark_seen": True}},
owner.id,
)
incoming = svc.create_letter_draft(
db, bid,
{
"subject": "وارده محرمانه با کلیدواژه",
"body": "متن کامل برای جستجوی تمام‌متن",
"letter_kind": "incoming",
"confidentiality": "secret",
"keywords": "قرارداد",
"external_org_id": org["id"],
"receipt_number": "EXT-99",
"letter_date": "1404/08/12",
},
owner.id, mgr["id"], calendar_type="jalali",
)
assert incoming["confidentiality"] == "secret"
incoming_reg = svc.register_letter(db, bid, incoming["id"], {"letter_kind": "incoming"}, owner.id, mgr["id"])
assert incoming_reg["tracking_token"]
assert incoming_reg["secretariat_id"] == main["id"]
assert incoming_reg["receipt_number"] == "EXT-99"
track = ext.public_track(db, incoming_reg["tracking_token"])
assert track["number"] == incoming_reg["secretariat_number"]
assert track["subject"] is None
hits = svc.search_letters(db, bid, owner.id, q="تمام‌متن", is_admin=True)
assert any(item["id"] == incoming_reg["id"] for item in hits)
key_hits = svc.search_letters(db, bid, owner.id, q="قرارداد", is_admin=True)
assert any(item["id"] == incoming_reg["id"] for item in key_hits)
outgoing = svc.create_letter_draft(
db, bid,
{"subject": "صادره نیازمند امضا", "letter_kind": "outgoing", "letter_date": "2025-11-02"},
owner.id, mgr["id"], calendar_type="gregorian",
)
ext.start_sign_path(
db, bid, outgoing["id"],
{"steps": [{"position_id": mgr["id"], "is_required": True}, {"position_id": exp["id"], "is_required": True}]},
owner.id, mgr["id"],
)
with pytest.raises(ApiError) as early:
ext.sign_letter_step(db, bid, outgoing["id"], {}, clerk.id, exp["id"])
assert early.value.code == "OA_SIGN_STEP_NOT_FOUND"
with pytest.raises(ApiError) as blocked:
svc.register_letter(db, bid, outgoing["id"], {"letter_kind": "outgoing"}, owner.id, mgr["id"])
assert blocked.value.code == "OA_SIGNATURE_REQUIRED"
ext.sign_letter_step(db, bid, outgoing["id"], {"note": "امضا شد"}, owner.id, mgr["id"])
ext.sign_letter_step(db, bid, outgoing["id"], {}, clerk.id, exp["id"])
signed = svc.get_letter(db, bid, outgoing["id"], owner.id, mgr["id"], is_admin=True)
assert signed["sign_status"] == "signed"
out_reg = svc.register_letter(
db, bid, outgoing["id"],
{"letter_kind": "outgoing", "secretariat_id": branch["id"]},
owner.id, mgr["id"], calendar_type="gregorian",
)
assert out_reg["secretariat_id"] == branch["id"]
assert out_reg["secretariat_number"].startswith("BR-")
assert out_reg["tracking_token"]
versions = ext.list_letter_versions(db, bid, outgoing["id"], owner.id, mgr["id"], is_admin=True)
assert versions
xml_data = ext.export_ece(db, bid, out_reg["id"], owner.id, mgr["id"])
assert "<letter" in xml_data["xml"]
imported = ext.import_ece(db, bid, {"xml": xml_data["xml"], "from_email": "ece@org-a.test"}, owner.id, mgr["id"])
assert imported["letter_kind"] == "incoming"
assert imported["subject"] == "صادره نیازمند امضا"
dispatched = ext.dispatch_letter(
db, bid, incoming_reg["id"],
{"to_position_id": exp["id"], "instruction": "ابلاغ جهت اجرا"},
owner.id, mgr["id"],
)
assert dispatched["dispatches"]
ack = ext.acknowledge_dispatch(db, bid, dispatched["dispatches"][0]["id"], clerk.id, exp["id"])
assert any(d["status"] == "acknowledged" for d in ack["dispatches"])
filed = ext.archive_to_folder(db, bid, incoming_reg["id"], {"folder_id": folder["id"]}, owner.id, mgr["id"])
assert filed["status"] == "archived"
assert filed["archive_folder_id"] == folder["id"]
mail = ext.import_email_as_letter(
db, bid,
{"subject": "ایمیل وارده", "body": "متن ایمیل", "from_email": "a@b.test", "letter_date": "1404/08/01"},
owner.id, mgr["id"], calendar_type="jalali",
)
assert mail["letter_kind"] == "incoming"
assert mail["subject"] == "ایمیل وارده"
rule_letter = svc.create_letter_draft(db, bid, {"subject": "نامه رونوشت خودکار", "letter_kind": "internal"}, owner.id, mgr["id"])
ruled = svc.register_letter(
db, bid, rule_letter["id"],
{"recipients": [{"to_position_id": exp["id"], "kind": "action"}]},
owner.id, mgr["id"],
)
assert any(r["status"] == "seen" for r in ruled["referrals"])
delay = ext.delay_report(db, bid)
volume = ext.volume_report(db, bid)
perf = ext.performance_report(db, bid)
assert "items" in delay and "by_kind" in volume and "items" in perf
summary = ext.summarize_letter(db, bid, out_reg["id"], owner.id, mgr["id"])
assert summary["ai_summary"]
conf_sec = ext.create_secretariat(
db, bid,
{"code": "secret", "name_i18n": {"fa": "دبیرخانه محرمانه", "en": "Confidential secretariat"}, "is_confidential": True, "incoming_prefix": "SEC"},
owner.id,
)
secret_draft = svc.create_letter_draft(
db, bid,
{"subject": "نامه سری برای دبیرخانه محرمانه", "letter_kind": "incoming", "confidentiality": "secret"},
owner.id, mgr["id"],
)
secret_reg = svc.register_letter(db, bid, secret_draft["id"], {"letter_kind": "incoming"}, owner.id, mgr["id"])
assert secret_reg["secretariat_id"] == conf_sec["id"]
assert secret_reg["secretariat_number"].startswith("SEC-")
with pytest.raises(ApiError) as classified:
blocked_draft = svc.create_letter_draft(
db, bid,
{"subject": "انتخاب دبیرخانه عادی برای سری", "letter_kind": "incoming", "confidentiality": "highly_confidential"},
owner.id, mgr["id"],
)
svc.register_letter(
db, bid, blocked_draft["id"],
{"letter_kind": "incoming", "secretariat_id": main["id"]},
owner.id, mgr["id"],
)
assert classified.value.code == "OA_CONFIDENTIAL_SECRETARIAT_REQUIRED"
printed = svc.get_letter_print(db, bid, out_reg["id"], owner.id, mgr["id"], is_admin=True)
assert "signatures" in printed["print"]
assert printed["print"]["copies_label"] in {"Copies", "رونوشت"}
reg_src = (Path(__file__).resolve().parents[1] / "app" / "services" / "workflow" / "trigger_registry.py").read_text(encoding="utf-8")
assert 'self.register("office_automation.letter_registered"' in reg_src
assert 'self.register("office_automation.letter_referred"' in reg_src
assert 'self.register("office_automation.letter_archived"' in reg_src
main_src = (Path(__file__).resolve().parents[1] / "app" / "main.py").read_text(encoding="utf-8")
assert "oa_automation_background_loop" in main_src
due_letter = svc.create_letter_draft(db, bid, {"subject": "پیگیری سررسید", "letter_kind": "internal"}, owner.id, mgr["id"])
due_reg = svc.register_letter(db, bid, due_letter["id"], {}, owner.id, mgr["id"])
row = db.query(OaLetter).filter(OaLetter.id == due_reg["id"]).one()
row.follow_up_at = date.today()
db.commit()
stats = ext.notify_due_followups(db, bid)
assert stats["due_letters"] >= 1
db.commit()
again = ext.notify_due_followups(db, bid)
assert again["due_letters"] == 0
db.close()