初始化项目

apps/api/dcm/__init__.py

@@ -0,0 +1,8 @@
+"""
+数字城管接口。
+"""
+
+ApiPrefix = "/system/digital/city/management"
+"""
+API 前缀。
+"""

apps/api/dcm/apply_postpone.py

@@ -0,0 +1,102 @@
+"""
+接受OA请求，操作数字城管工单延期
+"""
+import logging
+from typing import Optional
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_push_apply_postpone
+from models.dcm_apply_delay import DcmApplyPostpone
+from models.dcm_task import DcmTask
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/applyDelay')
+class ApplyPostponeHandler(AppHandler):
+    """
+    申请延期接口。
+
+    对接数字城管系统的申请延期接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.dcm_task: Optional[DcmTask] = None
+        self.dcm_apply_postpone: Optional[DcmApplyPostpone] = None
+
+    def _params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            DcmApplyPostpone.flow_token.key: kwargs.get('flowToken', ''),
+            DcmApplyPostpone.dcm_task_id.key: kwargs.get('gdId', ''),
+            DcmApplyPostpone.task_number.key: kwargs.get('taskNumber', ''),
+            DcmApplyPostpone.apply_act_id.key: self.dcm_task.act_id,
+            DcmApplyPostpone.reply_part_id.key: kwargs.get('replyPartID', 39),
+            DcmApplyPostpone.ard_level.key: kwargs.get('ardLevel', 0),
+            DcmApplyPostpone.ard_type_id.key: kwargs.get('ardTypeId', 12),
+            DcmApplyPostpone.apply_memo.key: kwargs.get('opinion', ''),
+            DcmApplyPostpone.apply_type.key: kwargs.get('applyType', '延期'),
+            DcmApplyPostpone.attachments.key: kwargs.get('attachments', ''),
+            DcmApplyPostpone.delay_multiple.key: kwargs.get('delayMultiple', 2),
+            DcmApplyPostpone.time_num.key: kwargs.get('timeNum', 48),
+            DcmApplyPostpone.time_unit.key: kwargs.get('timeUnit', 4),
+            DcmApplyPostpone.postpone_date.key: kwargs.get('postponeDate', ''),
+        }
+
+    async def apply_postpone(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = [
+            'gdId', 'taskNumber', 'applyType', 'opinion', 'delayMultiple', 'flowToken'
+        ]
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+        if kwargs.get('delayMultiple') not in (1, 2, '1', '2'):
+            raise ValueError('延期倍数只能为1或2')
+
+        # 读取待办任务对象
+        dcm_task_id = kwargs.get('gdId', '')
+        self.dcm_task = await DcmTask.async_find_by_id(dcm_task_id)
+
+        # 保存请求数据
+        params = self._params_for_db(**kwargs)
+        self.dcm_apply_postpone = DcmApplyPostpone().copy_from_dict(params)
+        self.dcm_apply_postpone.status = 0
+        await self.dcm_apply_postpone.async_save()
+
+        # 后台执行提交申请延期请求到数字城管
+        await aio_pool.run_background_task(
+            dcm_push_apply_postpone.push_apply_postpone(self.dcm_apply_postpone, self.dcm_task)
+        )
+
+        return {
+            'msg': '申请延期成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 申请延期接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.apply_postpone(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/dcm/apply_rollback.py

@@ -0,0 +1,97 @@
+"""
+接受OA请求，操作数字城管的申请回退接口
+"""
+import logging
+from typing import Optional
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_push_apply_rollback
+from models.dcm_apply_rollback import DcmApplyRollback
+from models.dcm_task import DcmTask
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/applyRollback')
+class ApplyRollbackHandler(AppHandler):
+    """
+    申请回退接口。
+
+    对接数字城管系统的申请回退接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.dcm_task: Optional[DcmTask] = None
+        self.dcm_apply_rollback: Optional[DcmApplyRollback] = None
+
+    def _extract_params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            DcmApplyRollback.flow_token.key: kwargs.get('flowToken', ''),
+            DcmApplyRollback.dcm_task_id.key: kwargs.get('gdId', ''),
+            DcmApplyRollback.act_id.key: self.dcm_task.act_id,
+            DcmApplyRollback.task_number.key: kwargs.get('taskNumber', ''),
+            DcmApplyRollback.reply_part_id.key: kwargs.get('replyPartID', 39),
+            DcmApplyRollback.ard_level.key: kwargs.get('ardLevel', 0),
+            DcmApplyRollback.ard_type_id.key: 18 if kwargs.get('applyType', '拒签') == '拒签' else 62,
+            DcmApplyRollback.opinion.key: kwargs.get('opinion', ''),
+            DcmApplyRollback.apply_type.key: kwargs.get('applyType', '拒签'),
+            DcmApplyRollback.trans_info.key: kwargs.get('transInfo', '52,254,0'),
+            DcmApplyRollback.attachments.key: kwargs.get('attachments', '')
+        }
+
+    async def apply_rollback(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = ['gdId', 'taskNumber', 'opinion', 'applyType', 'flowToken']
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+        if kwargs['applyType'] not in ('拒签', '处置阶段照片未公开'):
+            raise ValueError('申请类型只能为拒签或处置阶段照片未公开')
+
+        # 读取待办任务对象
+        dcm_task_id = kwargs.get('gdId', '')
+        self.dcm_task = await DcmTask.async_find_by_id(dcm_task_id)
+
+        # 保存请求数据
+        params = self._extract_params_for_db(**kwargs)
+        self.dcm_apply_rollback = DcmApplyRollback().copy_from_dict(params)
+        self.dcm_apply_rollback.status = 0
+        await self.dcm_apply_rollback.async_save()
+
+        # 后台执行提交申请回退请求到数字城管
+        await aio_pool.run_background_task(
+            dcm_push_apply_rollback.push_apply_rollback(self.dcm_apply_rollback, self.dcm_task)
+        )
+
+        return {
+            'msg': '申请回退成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 申请回退接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.apply_rollback(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/dcm/dispose.py

@@ -0,0 +1,96 @@
+"""
+接受OA请求，操作数字城管的工单批转接口
+"""
+import logging
+from typing import Optional
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_push_dispose
+from models.dcm_dispose import DcmDispose
+from models.dcm_task import DcmTask
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/transfer')
+class DisposeHandler(AppHandler):
+    """
+    批转接口。
+
+    对接数字城管系统的批转接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.dcm_task: Optional[DcmTask] = None
+        self.dcm_dispose: Optional[DcmDispose] = None
+
+    def _params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            DcmDispose.flow_token.key: kwargs.get('flowToken', ''),
+            DcmDispose.dcm_task_id.key: kwargs.get('gdId', ''),
+            DcmDispose.act_id.key: self.dcm_task.act_id,
+            DcmDispose.task_number.key: kwargs.get('taskNumber', ''),
+            DcmDispose.opinion.key: kwargs.get('opinion', ''),
+            DcmDispose.attachments.key: kwargs.get('attachments', ''),
+            DcmDispose.send_message.key: kwargs.get('sendMessage', '1'),
+            DcmDispose.trans_info.key: '52,254,0,0',
+            DcmDispose.add_num.key: kwargs.get('addNum', '0'),
+            DcmDispose.task_list_id.key: kwargs.get('taskListId', '600058'),
+            DcmDispose.undertake_user_name.key: kwargs.get('undertakeUserName', ''),
+            DcmDispose.undertake_phone.key: kwargs.get('undertakePhone', '')
+        }
+
+    async def dispose(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = ['gdId', 'taskNumber', 'opinion', 'attachments', 'flowToken']
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        # 读取待办任务对象
+        dcm_task_id = kwargs.get('gdId', '')
+        self.dcm_task = await DcmTask.async_find_by_id(dcm_task_id)
+
+        # 保存请求数据
+        params = self._params_for_db(**kwargs)
+        self.dcm_dispose = DcmDispose().copy_from_dict(params)
+        self.dcm_dispose.status = 0
+        await self.dcm_dispose.async_save()
+
+        # 后台执行提交批转请求到数字城管
+        await aio_pool.run_background_task(
+            dcm_push_dispose.push_dispose(self.dcm_dispose, self.dcm_task)
+        )
+
+        return {
+            'msg': '批转成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 批转接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.dispose(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/dcm/fetch_allow_postpone.py

@@ -0,0 +1,58 @@
+"""
+接受OA请求，读取数字城管的是否允许申请延期。
+"""
+import logging
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_scrape_allow_postpone
+from models.dcm_task import DcmTask
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/fetchAllowPostpone')
+class AllowPostponeHandler(AppHandler):
+    """
+    获取是否允许申请延期接口。
+
+    对接数字城管系统的获取是否允许申请延期接口，用于判断工单有哪些是否允许申请延期。
+    """
+
+    async def fetch_allow_postpone(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = ['gdId']
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        dcm_task_id = kwargs.get('gdId', '')
+        dcm_task = await DcmTask(id=dcm_task_id).async_find_first()
+        assert dcm_task, f"未找到待办工单，工单ID：{dcm_task_id}"
+        success, message = await dcm_scrape_allow_postpone.fetch_allow_postpone(dcm_task)
+        return {
+            'success': success,
+            'msg': message,
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 获取是否允许申请延期接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.fetch_allow_postpone(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/dcm/fetch_dispose_form.py

@@ -0,0 +1,59 @@
+"""
+接受OA请求，读取数字城管的便民表单。
+"""
+import logging
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_scrape_conv_dispose
+from models.dcm_task import DcmTask
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/fetchDisposeForm')
+class FetchConvenientFormHandler(AppHandler):
+    """
+    获取便民表单接口。
+
+    对接数字城管系统的获取便民表单接口，用于判断工单有哪些便民表单。
+    """
+
+    async def fetch_form(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = ['gdId', 'formId']
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        dcm_task_id = kwargs.get('gdId', '')
+        dcm_task = await DcmTask(id=dcm_task_id).async_find_first()
+        assert dcm_task, f"未找到待办工单，工单ID：{dcm_task_id}"
+
+        form = await dcm_scrape_conv_dispose.fetch_form(dcm_task)
+        return {
+            'msg': '获取便民批转表单成功.',
+            'form': form,
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 获取便民表单接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.fetch_form(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/dcm/fetch_operation.py

@@ -0,0 +1,58 @@
+"""
+接受OA请求，读取数字城管的可用操作。
+"""
+import logging
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_scrape_operation
+from models.dcm_task import DcmTask
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/fetchOperation')
+class FetchOperationHandler(AppHandler):
+    """
+    获取可用操作接口。
+
+    对接数字城管系统的获取可用操作接口，用于判断工单有哪些可用操作。
+    """
+
+    async def fetch_operations(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = ['gdId']
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        dcm_task_id = kwargs.get('gdId', '')
+        dcm_task = await DcmTask(id=dcm_task_id).async_find_first()
+        assert dcm_task, f"未找到待办工单，工单ID：{dcm_task_id}"
+        operations = await dcm_scrape_operation.fetch_operation(dcm_task)
+        return {
+            'msg': '获取可用操作成功.',
+            'operations': operations,
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 获取可用操作接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.fetch_operations(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/dcm/fetch_rollback_form.py

@@ -0,0 +1,59 @@
+"""
+接受OA请求，读取数字城管的便民表单。
+"""
+import logging
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_scrape_conv_rollback
+from models.dcm_task import DcmTask
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/fetchRollbackForm')
+class FetchRollbackFormHandler(AppHandler):
+    """
+    获取便民表单接口。
+
+    对接数字城管系统的获取便民表单接口，用于判断工单有哪些便民表单。
+    """
+
+    async def fetch_form(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = ['gdId', 'formId']
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        dcm_task_id = kwargs.get('gdId', '')
+        dcm_task = await DcmTask(id=dcm_task_id).async_find_first()
+        assert dcm_task, f"未找到待办工单，工单ID：{dcm_task_id}"
+
+        form = await dcm_scrape_conv_rollback.fetch_form(dcm_task)
+        return {
+            'msg': '获取便民回退表单成功.',
+            'form': form,
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 获取便民表单接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.fetch_form(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/dcm/rollback.py

@@ -0,0 +1,98 @@
+"""
+接受OA请求，操作数字城管的回退接口
+"""
+import logging
+from typing import Optional
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_push_rollback
+from models.dcm_rollback import DcmRollback
+from models.dcm_task import DcmTask
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/rollback')
+class RollbackHandler(AppHandler):
+    """
+    回退接口。
+
+    对接数字城管系统的回退接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.dcm_task: Optional[DcmTask] = None
+        self.dcm_rollback: Optional[DcmRollback] = None
+
+    def _extract_params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            DcmRollback.flow_token.key: kwargs.get('flowToken', ''),
+            DcmRollback.dcm_task_id.key: kwargs.get('gdId', ''),
+            DcmRollback.act_id.key: self.dcm_task.act_id,
+            DcmRollback.task_number.key: kwargs.get('taskNumber', ''),
+            DcmRollback.opinion.key: kwargs.get('opinion', ''),
+            DcmRollback.attachments.key: kwargs.get('attachments', ''),
+            DcmRollback.send_message.key: kwargs.get('sendMessage', '1'),
+            DcmRollback.trans_info.key: kwargs.get('transInfo', '50,254,0'),
+            DcmRollback.save_old_act_flag.key: kwargs.get('saveOldActFlag', False),
+            DcmRollback.rollback_reason_id.key: kwargs.get('rollbackReasonId', -1),
+            DcmRollback.not_assigned.key: kwargs.get('notAssigned', '0'),
+            DcmRollback.not_assigned_reason.key: kwargs.get('notAssignedReason', ''),
+            DcmRollback.undertake_user_name.key: kwargs.get('undertakeUserName', ''),
+            DcmRollback.undertake_phone.key: kwargs.get('undertakePhone', '')
+        }
+
+    async def rollback(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = ['gdId', 'taskNumber', 'opinion', 'flowToken']
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        # 读取待办任务对象
+        dcm_task_id = kwargs.get('gdId', '')
+        self.dcm_task = await DcmTask.async_find_by_id(dcm_task_id)
+
+        # 保存请求数据
+        params = self._extract_params_for_db(**kwargs)
+        self.dcm_rollback = DcmRollback().copy_from_dict(params)
+        self.dcm_rollback.status = 0
+        await self.dcm_rollback.async_save()
+
+        # 后台执行提交回退请求到数字城管
+        await aio_pool.run_background_task(
+            dcm_push_rollback.push_rollback(self.dcm_rollback, self.dcm_task)
+        )
+
+        return {
+            'msg': '回退成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 回退接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.rollback(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/dcm/stage_reply.py

@@ -0,0 +1,91 @@
+"""
+接受OA请求，操作数字城管的阶段回复接口
+"""
+import logging
+from typing import Optional
+
+from apps.api import dcm
+from apps.app_handler import AppHandler
+from dock.dcm import dcm_push_stage_reply
+from models.dcm_stage_reply import DcmStageReply
+from models.dcm_task import DcmTask
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from paste.web.decorators import route
+
+
+@route(f'{dcm.ApiPrefix}/stageReply')
+class StageReplyHandler(AppHandler):
+    """
+    阶段回复接口。
+
+    对接数字城管系统的阶段回复接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.dcm_task: Optional[DcmTask] = None
+        self.dcm_stage_reply: Optional[DcmStageReply] = None
+
+    def _params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            DcmStageReply.flow_token.key: kwargs.get('flowToken', ''),
+            DcmStageReply.dcm_task_id.key: kwargs.get('gdId', ''),
+            DcmStageReply.rec_id.key: self.dcm_task.rec_id,
+            DcmStageReply.act_id.key: self.dcm_task.act_id,
+            DcmStageReply.content.key: kwargs.get('content', ''),
+            DcmStageReply.task_number.key: kwargs.get('taskNumber', ''),
+            DcmStageReply.item_type.key: kwargs.get('itemType', 'stage_reply'),
+        }
+
+    async def stage_reply(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = ['gdId', 'taskNumber', 'content', 'flowToken']
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        # 读取待办任务对象
+        dcm_task_id = kwargs.get('gdId', '')
+        self.dcm_task = await DcmTask.async_find_by_id(dcm_task_id)
+
+        # 保存请求数据
+        params = self._params_for_db(**kwargs)
+        self.dcm_stage_reply = DcmStageReply().copy_from_dict(params)
+        self.dcm_stage_reply.status = 1
+        await self.dcm_stage_reply.async_save()
+
+        # 后台执行提交阶段回复请求到数字城管
+        await aio_pool.run_background_task(
+            dcm_push_stage_reply.push_stage_reply(self.dcm_stage_reply, self.dcm_task)
+        )
+
+        return {
+            'msg': '阶段回复成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 阶段回复接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.stage_reply(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/govs/__init__.py

@@ -0,0 +1,8 @@
+"""
+省12345接口。
+"""
+
+ApiPrefix = "/system"
+"""
+API 前缀。
+"""

apps/api/govs/create_order_delay.py

@@ -0,0 +1,101 @@
+from typing import Optional
+import logging
+
+from apps.api import govs
+from apps.app_handler import AppHandler
+from paste.web.decorators import route
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from dock.govs import govs_create_order_delay
+from models.govs_order_master import GovsOrderMaster
+from models.govs_create_delay import GovsApplicationForDelay
+
+
+@route(f'{govs.ApiPrefix}/application-for-delay-formal/create')
+class CreateDelayHandler(AppHandler):
+    """
+    申请延期接口。
+
+    对接省12345的申请延期接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.govs_order: Optional[GovsOrderMaster] = None
+        self.govs_delay: Optional[GovsApplicationForDelay] = None
+
+    def _params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            GovsApplicationForDelay.master_id.key: kwargs.get('gdId', ''),
+            GovsApplicationForDelay.gd_id.key: kwargs.get('gdId', ''),
+            GovsApplicationForDelay.finally_time_after_approve.key: kwargs.get('finallyTimeAfterApprove', ''),
+            GovsApplicationForDelay.finally_time_before_approve.key: kwargs.get('finallyTimeBeforeApprove', ''),
+            GovsApplicationForDelay.request_delay.key: kwargs.get('requestDelay', ''),
+            GovsApplicationForDelay.is_nature_day.key: kwargs.get('isNatureDay', ''),
+            GovsApplicationForDelay.already_notify_order_user.key: kwargs.get('alreadyNotifyOrderUser', ''),
+            GovsApplicationForDelay.request_reason.key: kwargs.get('requestReason', ''),
+            GovsApplicationForDelay.remarks.key: kwargs.get('remarks', ''),
+            GovsApplicationForDelay.contact_name.key: kwargs.get('contactName', ''),
+            GovsApplicationForDelay.contact_time.key: kwargs.get('contactTime', ''),
+            GovsApplicationForDelay.contact_type.key: kwargs.get('contactType', ''),
+            GovsApplicationForDelay.contact_type_name.key: kwargs.get('contactTypeName', ''),
+            GovsApplicationForDelay.reply_script.key: kwargs.get('replyScript', ''),
+            GovsApplicationForDelay.file_id_str.key: kwargs.get('fileIdStr', ''),
+            GovsApplicationForDelay.request_delay_time.key: kwargs.get('requestDelayTime', ''),
+            GovsApplicationForDelay.flow_token.key: kwargs.get('flowToken', '')
+        }
+
+    async def create_delay(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = [
+            'gdId', 'flowToken', 'finallyTimeAfterApprove', 'requestDelay', 'isNatureDay',
+            'alreadyNotifyOrderUser', 'requestReason'
+        ]
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        # 读取待办任务对象
+        govs_task_id = kwargs.get('gdId', '')
+        self.govs_order = await GovsOrderMaster.async_find_by_id(govs_task_id)
+
+        # 保存请求数据
+        params = self._params_for_db(**kwargs)
+        self.govs_delay = GovsApplicationForDelay().copy_from_dict(params)
+        self.govs_delay.status = 0
+        await self.govs_delay.async_save()
+
+        # 后台执行提交申请延期请求到省12345
+        await aio_pool.run_background_task(
+            govs_create_order_delay.create_delay(self.govs_delay, self.govs_order)
+        )
+
+        return {
+            'msg': '申请延期成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 申请延期接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.create_delay(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/govs/create_order_return.py

@@ -0,0 +1,102 @@
+from typing import Optional
+import logging
+
+from apps.api import govs
+from apps.app_handler import AppHandler
+from paste.web.decorators import route
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from dock.govs import govs_create_order_return
+from models.govs_order_master import GovsOrderMaster
+from models.govs_create_return import GovsWorkOrderReturnFormal
+
+
+@route(f'{govs.ApiPrefix}/work-order-return-formal/create')
+class CreateDelayHandler(AppHandler):
+    """
+    申请工单退回接口。
+
+    对接省12345的申请退回接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.govs_order: Optional[GovsOrderMaster] = None
+        self.govs_return: Optional[GovsWorkOrderReturnFormal] = None
+
+    def _params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            GovsWorkOrderReturnFormal.master_id.key: kwargs.get('gdId', ''),
+            GovsWorkOrderReturnFormal.flow_token.key: kwargs.get('flowToken', ''),
+            GovsWorkOrderReturnFormal.gd_id.key: kwargs.get('gdId', ''),
+            GovsWorkOrderReturnFormal.return_reason.key: kwargs.get('returnReason', ''),
+            GovsWorkOrderReturnFormal.return_reason_name.key: kwargs.get('returnReasonName', ''),
+            GovsWorkOrderReturnFormal.return_auditor_name.key: kwargs.get('returnAuditorName', ''),
+            GovsWorkOrderReturnFormal.return_auditor_id.key: kwargs.get('returnAuditorId', ''),
+            GovsWorkOrderReturnFormal.deal_opinion.key: kwargs.get('dealOpinion', ''),
+            GovsWorkOrderReturnFormal.reason.key: kwargs.get('reason', ''),
+            GovsWorkOrderReturnFormal.remark.key: kwargs.get('remark', ''),
+            GovsWorkOrderReturnFormal.file_id_str.key: kwargs.get('fileIdStr', ''),
+            GovsWorkOrderReturnFormal.process_instance_id.key: kwargs.get('processInstanceId', ''),
+            GovsWorkOrderReturnFormal.action_name.key: kwargs.get('actionName', ''),
+            GovsWorkOrderReturnFormal.order_id.key: kwargs.get('orderId', ''),
+            GovsWorkOrderReturnFormal.task_id.key: kwargs.get('taskId', ''),
+            GovsWorkOrderReturnFormal.order_no.key: kwargs.get('orderNo', ''),
+            GovsWorkOrderReturnFormal.case_accord_type_one_name.key: kwargs.get('caseAccordTypeOneName', ''),
+            GovsWorkOrderReturnFormal.case_accord_type_two_name.key: kwargs.get('caseAccordTypeTwoName', ''),
+            GovsWorkOrderReturnFormal.case_accord_type_three_name.key: kwargs.get('caseAccordTypeThreeName', '')
+        }
+
+    async def create_return(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = [
+            'gdId', 'flowToken', 'returnReason', 'returnReasonName', 'dealOpinion', 'reason'
+        ]
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        # 读取待办任务对象
+        govs_task_id = kwargs.get('gdId', '')
+        self.govs_order = await GovsOrderMaster.async_find_by_id(govs_task_id)
+
+        # 保存请求数据
+        params = self._params_for_db(**kwargs)
+        self.govs_return = GovsWorkOrderReturnFormal().copy_from_dict(params)
+        self.govs_return.status = 0
+        await self.govs_return.async_save()
+
+        # 后台执行提交申请延期请求到省12345
+        await aio_pool.run_background_task(
+            govs_create_order_return.create_return(self.govs_return, self.govs_order)
+        )
+
+        return {
+            'msg': '申请退回成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 申请退回接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.create_return(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/govs/create_reply.py

@@ -0,0 +1,102 @@
+from typing import Optional
+import logging
+
+from apps.api import govs
+from apps.app_handler import AppHandler
+from paste.web.decorators import route
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from dock.govs import govs_create_reply
+from models.govs_order_master import GovsOrderMaster
+from models.govs_create_reply import GovsReplyFormal
+
+
+@route(f'{govs.ApiPrefix}/reply-formal/create')
+class CreateDelayHandler(AppHandler):
+    """
+    答复办结接口。
+
+    对接省12345的答复办结接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.govs_order: Optional[GovsOrderMaster] = None
+        self.govs_reply: Optional[GovsReplyFormal] = None
+
+    def _params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            GovsReplyFormal.master_id.key: kwargs.get('gdId', ''),
+            GovsReplyFormal.flow_token.key: kwargs.get('flowToken', ''),
+            GovsReplyFormal.gd_id.key: kwargs.get('gdId', ''),
+            GovsReplyFormal.is_contact.key: kwargs.get('isContact', ''),
+            GovsReplyFormal.contact_name.key: kwargs.get('contactName', ''),
+            GovsReplyFormal.contact_time.key: kwargs.get('contactTime', ''),
+            GovsReplyFormal.contact_type.key: kwargs.get('contactType', ''),
+            GovsReplyFormal.advice.key: kwargs.get('advice', ''),
+            GovsReplyFormal.reason.key: kwargs.get('reason', ''),
+            GovsReplyFormal.remarks.key: kwargs.get('remarks', ''),
+            GovsReplyFormal.file_id_str.key: kwargs.get('fileIdStr', ''),
+            GovsReplyFormal.save_id.key: kwargs.get('saveId', ''),
+            GovsReplyFormal.process_instance_id.key: kwargs.get('processInstanceId', ''),
+            GovsReplyFormal.business_key.key: kwargs.get('businessKey', ''),
+            GovsReplyFormal.order_no.key: kwargs.get('orderNo', ''),
+            GovsReplyFormal.action_name.key: kwargs.get('actionName', ''),
+            GovsReplyFormal.case_accord_type_one_name.key: kwargs.get('caseAccordTypeOneName', ''),
+            GovsReplyFormal.case_accord_type_two_name.key: kwargs.get('caseAccordTypeTwoName', ''),
+            GovsReplyFormal.case_accord_type_three_name.key: kwargs.get('caseAccordTypeThreeName', ''),
+        }
+
+    async def create_delay(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = [
+            'gdId', 'flowToken', 'isContact', 'contactType', 'advice', 'reason'
+        ]
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        # 读取待办任务对象
+        govs_task_id = kwargs.get('gdId', '')
+        self.govs_order = await GovsOrderMaster.async_find_by_id(govs_task_id)
+
+        # 保存请求数据
+        params = self._params_for_db(**kwargs)
+        self.govs_reply = GovsReplyFormal().copy_from_dict(params)
+        self.govs_reply.status = 0
+        await self.govs_reply.async_save()
+
+        # 后台执行提交答复办结请求到省12345
+        await aio_pool.run_background_task(
+            govs_create_reply.create_reply(self.govs_reply, self.govs_order)
+        )
+
+        return {
+            'msg': '答复办结成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 答复办结接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.create_delay(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/govs/phase_wise_completion.py

@@ -0,0 +1,101 @@
+from typing import Optional
+import logging
+
+from apps.api import govs
+from apps.app_handler import AppHandler
+from paste.web.decorators import route
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from dock.govs import govs_phase_wise_completion
+from models.govs_order_master import GovsOrderMaster
+from models.govs_phase_wise_completion import GovsPhaseWiseCompletion
+
+
+@route(f'{govs.ApiPrefix}/phase-wise-completion/create')
+class CreateDelayHandler(AppHandler):
+    """
+    阶段性办结接口。
+
+    对接省12345的阶段性办结接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.govs_order: Optional[GovsOrderMaster] = None
+        self.phase_wise_completion: Optional[GovsPhaseWiseCompletion] = None
+
+    def _params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            GovsPhaseWiseCompletion.master_id.key: kwargs.get('gdId', ''),
+            GovsPhaseWiseCompletion.flow_token.key: kwargs.get('flowToken', ''),
+            GovsPhaseWiseCompletion.gd_id.key: kwargs.get('gdId', ''),
+            GovsPhaseWiseCompletion.is_contact.key: kwargs.get('isContact', ''),
+            GovsPhaseWiseCompletion.contact_name.key: kwargs.get('contactName', ''),
+            GovsPhaseWiseCompletion.contact_time.key: kwargs.get('contactTime', ''),
+            GovsPhaseWiseCompletion.contact_type.key: kwargs.get('contactType', ''),
+            GovsPhaseWiseCompletion.next_feedback_time.key: kwargs.get('nextFeedbackTime', ''),
+            GovsPhaseWiseCompletion.advice.key: kwargs.get('advice', ''),
+            GovsPhaseWiseCompletion.reason.key: kwargs.get('reason', ''),
+            GovsPhaseWiseCompletion.remark.key: kwargs.get('remark', ''),
+            GovsPhaseWiseCompletion.action_name.key: kwargs.get('actionName', ''),
+            GovsPhaseWiseCompletion.case_accord_type_one_name.key: kwargs.get('caseAccordTypeOneName', ''),
+            GovsPhaseWiseCompletion.case_accord_type_two_name.key: kwargs.get('caseAccordTypeTwoName', ''),
+            GovsPhaseWiseCompletion.case_accord_type_three_name.key: kwargs.get('caseAccordTypeThreeName', ''),
+            GovsPhaseWiseCompletion.order_id.key: kwargs.get('orderId', ''),
+            GovsPhaseWiseCompletion.task_id.key: kwargs.get('taskId', '')
+        }
+
+    async def create_delay(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = [
+            'gdId', 'flowToken', 'isContact', 'contactName', 'contactTime', 'contactType', 'nextFeedbackTime', 'advice',
+            'reason'
+        ]
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        # 读取待办任务对象
+        govs_task_id = kwargs.get('gdId', '')
+        self.govs_order = await GovsOrderMaster.async_find_by_id(govs_task_id)
+
+        # 保存请求数据
+        params = self._params_for_db(**kwargs)
+        self.phase_wise_completion = GovsPhaseWiseCompletion().copy_from_dict(params)
+        self.phase_wise_completion.status = 0
+        await self.phase_wise_completion.async_save()
+
+        # 后台执行提交阶段性办结请求到省12345
+        await aio_pool.run_background_task(
+            govs_phase_wise_completion.create_phase_wise_completion(self.phase_wise_completion, self.govs_order)
+        )
+
+        return {
+            'msg': '阶段性办结成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 阶段性办结接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.create_delay(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)

apps/api/govs/save_sign.py

@@ -0,0 +1,91 @@
+from typing import Optional
+import logging
+
+from apps.api import govs
+from apps.app_handler import AppHandler
+from paste.web.decorators import route
+from paste.core import aio_pool
+from paste.core.logging import echo_log
+from dock.govs import govs_save_sign
+from models.govs_order_master import GovsOrderMaster
+from models.govs_save_sign import GovsSaveSign
+
+
+@route(f'{govs.ApiPrefix}/save-sign-for/create')
+class CreateDelayHandler(AppHandler):
+    """
+    申请延期接口。
+
+    对接省12345的申请延期接口，请求后本接口先将数据保存本地，然后响应客户端，然后开始后台启动推送。
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.govs_order: Optional[GovsOrderMaster] = None
+        self.govs_sign: Optional[GovsSaveSign] = None
+
+    def _params_for_db(self, **kwargs: dict) -> dict:
+        """
+        提取数据库所需参数。
+        """
+        return {
+            GovsSaveSign.gd_id.key: kwargs.get('gdId', ''),
+            GovsSaveSign.flow_token.key: kwargs.get('flowToken', ''),
+            GovsSaveSign.order_id.key: kwargs.get('orderId', ''),
+            GovsSaveSign.order_no.key: kwargs.get('orderNo', ''),
+            GovsSaveSign.master_id.key: kwargs.get('gdId', ''),
+            GovsSaveSign.order_process_id.key: kwargs.get('orderProcessId', ''),
+            GovsSaveSign.task_id.key: kwargs.get('taskId', ''),
+            GovsSaveSign.flag.key: kwargs.get('flag', '')
+        }
+
+    async def create_delay(self, **kwargs) -> dict:
+        # 必填参数校验
+        required_keys = [
+            'gdId', 'flowToken'
+        ]
+        missing = [
+            k for k in required_keys
+            if k not in kwargs or kwargs[k] is None
+        ]
+        if missing:
+            raise ValueError(f"缺少必要参数: {missing}")
+
+        # 读取待办任务对象
+        govs_task_id = kwargs.get('gdId', '')
+        self.govs_order = await GovsOrderMaster.async_find_by_id(govs_task_id)
+
+        # 保存请求数据
+        params = self._params_for_db(**kwargs)
+        self.govs_sign = GovsSaveSign().copy_from_dict(params)
+        self.govs_sign.status = 0
+        await self.govs_sign.async_save()
+
+        # 后台执行提交申请延期请求到省12345
+        await aio_pool.run_background_task(
+            govs_save_sign.sign_order(self.govs_sign, self.govs_order)
+        )
+
+        return {
+            'msg': '确认签收成功.'
+        }
+
+    # @auth_token
+    async def post(self):
+        """
+        处理 POST 请求。
+
+        ---
+        tags:
+        - D3I API
+        summary: 申请延期接口
+        """
+        try:
+            echo_log(self.request.body.decode())
+            _, params = self.get_request_params()
+            _result = await self.create_delay(**params)
+            self.response_ok(code=0, data=_result)
+        except Exception as e:
+            self.response_error(e, status_code=200, api_status_code=500)
+            self.log(msg=e, level=logging.ERROR, is_log_exc=True)