Merge branch 'dev_callback_20241204' into develop

src/core/__init__.py

@@ -1,4 +1,11 @@
+from functools import wraps
 
+def with_app_context(func):
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        with self.app.app_context():
+            return func(self, *args, **kwargs)
+    return wrapper
 
 def singleton(cls):
     _instance = {}

src/core/callcenter/acd.py

@@ -21,8 +21,8 @@ class AcdService:
         self.app = app
         self.logger = app.logger
         self.cache = Cache(app)
-        self.call_service = CallService(client, app.logger)
-        self.agent_service = AgentOperService(client, app.logger)
+        self.call_service = CallService(client, app)
+        self.agent_service = AgentOperService(app)
         self.holdsQueue: Dict[str, Queue] = {}
         self.pool = ThreadPoolExecutor(max_workers=4)
         self.checkIdleScheduler = BackgroundScheduler()

src/core/callcenter/agent.py

@@ -1,46 +1,252 @@
 #!/usr/bin/env python3
 # encoding:utf-8
 
-import traceback
-from typing import List
+import threading
 from collections import defaultdict
-from src.core.callcenter.constant import START_AGENT_NUM
-from src.core.callcenter.enumeration import AgentState, AgentCheck, AgentHeartState, AgentServiceState, AgentLogState, \
-    AgentScene, BizErrorCode, WorkStatus, DownEvent, HumanState
+from concurrent.futures import ThreadPoolExecutor
+from typing import List
+
 from sqlalchemy import or_
+
+import src.core.callcenter.esl.utils.esl_event_util as EslEventUtil
+from src.core import with_app_context
+from src.core.callcenter.api import AgentActionRequest, AgentQueryRequest, AgentRequest, AgentEventData, \
+    AgentStateData, HumanServiceQueryRequest, AgentMonitorData, CallInfo, DeviceInfo, AgentDelayStateData
+from src.core.callcenter.cache import Cache
 from src.core.callcenter.dao import *
+from src.core.callcenter.data_handler import DataHandleServer
+from src.core.callcenter.enumeration import AgentState, AgentCheck, AgentHeartState, AgentServiceState, AgentLogState, \
+    AgentScene, BizErrorCode, WorkStatus, DownEvent, HumanState, DeviceType, ServiceDirect
+from src.core.callcenter.esl.constant.event_names import *
 from src.core.callcenter.exception import BizException
-from src.core.callcenter.api import AgentActionRequest, AgentInfo, AgentQueryRequest, AgentRequest, AgentEventData, \
-    AgentStateData, HumanServiceQueryRequest, AgentMonitorData
 from src.core.callcenter.push import PushHandler
 from src.core.datasource import RedisHandler
 
-from concurrent.futures import ThreadPoolExecutor
-import threading
+
+class AgentEventService:
+    def __init__(self, app):
+        self.app = app
+        self.logger = app.logger
+        self.cache = Cache(app)
+        self.push_handler = PushHandler(app.logger)
+        self.data_handle_server = DataHandleServer(app)
+        self.agent_monitor_service = AgentMonitorService(app)
+        self.agent_state_service = AgentStateService(app)
+        self.agent_actionlog_service = AgentActionLogService(app)
+
+    def delay_state(self, state_data: AgentDelayStateData):
+        agent = self.data_handle_server.get_agent(state_data.saas_id, state_data.agent_num)
+        if not agent:
+            return
+        agent_monitor = self.data_handle_server.get_agent_monitor(state_data.saas_id, state_data.agent_num)
+        if not agent_monitor:
+            return
+
+        #TODO 非最新通话的延迟事件,忽略.
+
+        agent_scene = AgentScene.get_by_code(state_data.scene)
+        self.logger.info("agent event delay state %s %s %s %s", state_data.saas_id, state_data.agent_num, state_data.service_state, agent_monitor.service_state)
+        if AgentServiceState.REPROCESSING.code == state_data.service_state and AgentServiceState.REPROCESSING.code == agent_monitor.service_state:
+            self.reprocessing_idle(state_data)
+
+        if AgentServiceState.DIALING.code == state_data.service_state and AgentServiceState.DIALING.code == agent_monitor.service_state:
+            if self.cache.get_call_is_answer(state_data.saas_id, state_data.agent_num):
+                return
+            self.agent_monitor_service.update_idle(agent_monitor)
+
+            self.push_handler.push_on_call_end(state_data.saas_id, state_data.flow_id, state_data.agent_num, agent_scene, ServiceDirect.MANUAL_CALL.service_direct, '0')
+            self.push_handler.push_on_agent_work_report(state_data.saas_id, state_data.flow_id, state_data.agent_num, '', agent_scene, WorkStatus.AGENT_HANG_REPROCESSING)
+            self.push_handler.push_on_agent_work_report(state_data.saas_id, state_data.flow_id, state_data.agent_num, '', agent_scene, WorkStatus.AGENT_HANG_IDLE)
+
+            self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.IDLE, AgentLogState.BIZ_DIALING_IDLE)
+
+        if AgentServiceState.HANGING.code == state_data.service_state \
+                and (AgentServiceState.DIALING.code == agent_monitor.service_state
+                     or AgentServiceState.CALLING.code == agent_monitor.service_state):
+            self.agent_monitor_service.update_idle(agent_monitor)
+
+            if AgentServiceState.DIALING.code == agent_monitor.service_state:
+                self.push_handler.push_on_call_end(state_data.saas_id, state_data.flow_id, state_data.agent_num, agent_scene, ServiceDirect.MANUAL_CALL.service_direct, '0')
+                self.push_handler.push_on_agent_work_report(state_data.saas_id, state_data.flow_id, state_data.agent_num, '', agent_scene, WorkStatus.AGENT_HANG_REPROCESSING)
+
+            self.push_handler.push_on_agent_work_report(state_data.saas_id, state_data.flow_id, state_data.agent_num, '', agent_scene, WorkStatus.AGENT_HANG_IDLE)
+            self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.IDLE, AgentLogState.MANUAL_HANG_UP)
+
+
+    def agent_event_channel(self, event, call_info: CallInfo, device_info: DeviceInfo):
+        event_name = EslEventUtil.getEventName(event)
+        saas_id = call_info.saas_id if call_info else None
+        flow_id = call_info.cti_flow_id if call_info else None
+        call_id = call_info.call_id if call_info else None
+        device_id = device_info.device_id if device_info else None
+        agent_num = device_info.agent_key if device_info else None
+        caller = device_info.caller if device_info else None
+        called = device_info.called if device_info else None
+        is_agent = (device_info and DeviceType.AGENT.code == device_info.device_type) if device_info else False
+
+        # self.logger.info('agent_event_channel, event_name=%s, call_id=%s, device_id=%s, is_agent=%s', event_name, call_id, device_id, is_agent)
+        agent = self.data_handle_server.get_agent(saas_id, agent_num)
+        if not agent:
+            # self.logger.warn("event service channel agent is null %s %s %s %s %s", saas_id, event_name, caller, called, json.loads(event.serialize('json')))
+            return
+        agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_num)
+        if not agent_monitor:
+            # self.logger.warn("event service channel agentMonitor is null %s %s %s %s %s", saas_id, event_name, caller, called, json.loads(event.serialize('json')))
+            return
+
+        # 信道发起事件，触发完成发起（或桥）&& 坐席侧
+        if CHANNEL_ORIGINATE == event_name and is_agent:
+            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_RINGING)
+
+        # 进度事件，外呼时对方提醒。或者入呼时提醒 && 坐席侧
+        if CHANNEL_PROGRESS == event_name and is_agent:
+            self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.DIALING)
+            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_CALLING)
+
+        # 媒体进度事件，外呼时对方提醒。或者入呼时提醒 && 用户侧
+        if CHANNEL_PROGRESS_MEDIA == event_name and not is_agent:
+            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_CALLING_RINGING)
+
+        #应答
+        if CHANNEL_ANSWER == event_name:
+            self.logger.info('agent_event_channel, event_name=%s, call_id=%s, device_id=%s, is_agent=%s', event_name, call_id, device_id, is_agent)
+            if call_id:
+                if self.cache.get_call_is_end(call_id):
+                    # self.logger.warn("event service channel call is end {} {} {} {} {} {}", saas_id, event_name, caller, called, call_id, json.dumps(event.serialize('json')))
+                    return
+
+            self.agent_state_service.busy(saas_id, agent.agent_num, agent.phone_num)
+            if is_agent:
+                # 坐席接起
+                self.cache.set_call_is_answer(saas_id, flow_id)
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.ANSWER_COMPENSATE)
+                self.push_handler.push_answer_call(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, ServiceDirect.MANUAL_CALL.service_direct, WorkStatus.AGENT_HANG_REPROCESSING)
+
+                self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.CALLING, AgentLogState.CHANNEL_TURN_ON)
+            else:
+                # 用户侧接起
+                self.agent_monitor_service.update_calling(agent_monitor)
+                # self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_ANSWER_OUTGOING)
+                # self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.CALLING)
+
+        #挂断
+        if CHANNEL_HANGUP == event_name:
+            # 坐席侧挂断
+            if is_agent:
+                if call_id:
+                    self.cache.set_call_is_end(call_id)
+
+            self.agent_monitor_service.update_processing(agent_monitor)
+            self.reprocessing_idle(AgentDelayStateData(saas_id, flow_id, agent_num, AgentServiceState.REPROCESSING, AgentScene.MANUAL))
+            self.push_handler.push_on_call_end(saas_id, flow_id, agent_num, AgentScene.MANUAL, ServiceDirect.MANUAL_CALL.service_direct, '0')
+            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_HANG_REPROCESSING)
+            self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.REPROCESSING)
+
+            self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.REPROCESSING, AgentLogState.CHANNEL_HANG_UP)
+
+            # 同步处理后处理置闲
+            # reprocessingIdle(statusDto);
+            # agentProducer.pushDelayedStatus(statusDto, reprocessingTimeout);
+
+        if (CHANNEL_BRIDGE == event_name or PLAYBACK_START == event_name) and is_agent:
+            self.push_handler.push_on_ring_start(saas_id, flow_id, agent_num, AgentScene.MANUAL, call_id)
+            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_ANSWER_OUTGOING)
+            self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.CALLING)
+
+        if DETECTED_TONE == event_name and not is_agent:
+            self.push_handler.push_on_detected_tone(saas_id, flow_id, call_id, AgentScene.MANUAL, call_id)
+
+        if (CHANNEL_UNBRIDGE == event_name or PLAYBACK_STOP == event_name) and is_agent:
+            self.push_handler.push_on_ring_end(saas_id, flow_id, call_id, AgentScene.MANUAL, call_id)
+
+
+    def bot_event_channel(self, event, call_info, device_info):
+        event_name = EslEventUtil.getEventName(event)
+        saas_id = call_info.saas_id if call_info else None
+        flow_id = call_info.cti_flow_id if call_info else None
+        call_id = call_info.call_id if call_info else None
+        agent_num = device_info.agent_key if device_info else None
+        is_agent = (device_info and DeviceType.AGENT.code == device_info.device_type) if device_info else False
+        caller = (device_info.called if is_agent else device_info.caller) if device_info else None
+        called = (device_info.caller if is_agent else device_info.called) if device_info else None
+        human_service_id = '00000000000000000'
+
+        agent = self.data_handle_server.get_agent(saas_id, agent_num)
+        if not agent:
+            # self.logger.warn("bot event service channel agent is null %s %s %s %s %s", saas_id, event_name, caller, called,
+            #                  json.dumps(event.serialize('json')))
+            return
+        agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_num)
+        if not agent_monitor:
+            # self.logger.warn("bot event service channel agentMonitor is null %s %s %s %s %s", saas_id, event_name, caller,
+            #                  called, json.dumps(event.serialize('json')))
+            return
+
+        # 信道发起事件，触发完成发起（或桥）&& 坐席侧
+        if CHANNEL_ORIGINATE == event_name and is_agent:
+            self.push_handler.push_on_call_ring(saas_id, flow_id, agent_num, AgentScene.ROBOT, call_id, ServiceDirect.ROBOT_CALL.service_direct, called, caller, human_service_id)
+            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_RINGING)
+
+
+        if CHANNEL_ANSWER == event_name:
+            self.agent_state_service.busy(saas_id, agent.agent_num, agent.phone_num)
+            if is_agent:
+                self.agent_monitor_service.update_calling(agent_monitor)
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_ANSWER_INCOMING, "座席接通呼入电话! internal")
+                self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.ROBOT, AgentServiceState.CALLING)
+                self.push_handler.push_answer_call(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, ServiceDirect.ROBOT_CALL.service_direct, WorkStatus.AGENT_HANG_REPROCESSING)
+
+                self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.CALLING, AgentLogState.CHANNEL_TURN_ON, service_id=human_service_id)
+            else:
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_ANSWER_INCOMING, "座席接通呼入电话! external")
+
+        if CHANNEL_HANGUP == event_name and is_agent:
+            self.agent_monitor_service.update_processing(agent_monitor)
+            self.push_handler.push_on_call_end(saas_id, flow_id, agent_num, AgentScene.ROBOT, ServiceDirect.ROBOT_CALL.service_direct, "0")
+            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_HANG_REPROCESSING)
+            self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.ROBOT, AgentServiceState.REPROCESSING)
+
+            self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.REPROCESSING,
+                                                  AgentLogState.CHANNEL_HANG_UP, service_id=human_service_id)
+
+
+    def reprocessing_idle(self, state_data: AgentDelayStateData):
+        agent = self.data_handle_server.get_agent(state_data.saas_id, state_data.agent_num)
+        if not agent:
+            return
+        agent_monitor = self.data_handle_server.get_agent_monitor(state_data.saas_id, state_data.agent_num)
+        if not agent_monitor:
+            return
+        self.agent_monitor_service.update_idle(agent_monitor)
+        self.push_handler.push_on_agent_work_report(state_data.saas_id, state_data.flow_id, state_data.agent_num, "", state_data.scene, WorkStatus.AGENT_HANG_IDLE)
+        self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.IDLE, AgentLogState.REPROCESSING_IDLE)
 
 
 class AgentOperService:
 
-    def __init__(self, client, logger):
-        self.inbound_client = client
-        self.logger = logger
-        self.push_handler = PushHandler(logger)
-        self.agent_monitor_service = AgentMonitorService(client, logger)
-        self.agent_actionlog_service = AgentActionLogService(client, logger)
-        self.agent_state_service = AgentStateService(client, logger)
+    def __init__(self, app):
+        self.app = app
+        self.logger = app.logger
+        self.push_handler = PushHandler(app.logger)
+        self.data_handle_server = DataHandleServer(app)
+        self.agent_monitor_service = AgentMonitorService(app)
+        self.agent_actionlog_service = AgentActionLogService(app)
+        self.agent_state_service = AgentStateService(app)
 
+    @with_app_context
     def enable(self, req: AgentActionRequest):
-        agent = _get_agent(req.saas_id, req.agent_number, req.out_id)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_number, req.out_id)
         if agent.agent_state == AgentState.ENABLE.code:
             return
         agent.agent_state = AgentState.ENABLE.code
         db.session.commit()
 
+    @with_app_context
     def disable(self, req: AgentActionRequest):
-        agent = _get_agent(req.saas_id, req.agent_id)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_id)
         if agent.agent_state == AgentState.DISABLE.code:
             return
-        agent_monitor = _get_agent_monitor(req.saas_id, agent.agent_number)
+        agent_monitor = self.data_handle_server.get_agent_monitor(req.saas_id, agent.agent_number)
         if agent_monitor.check_state == AgentCheck.IN.code and \
                 agent_monitor.service_state == AgentServiceState.CALLING.code:
             raise BizException(BizErrorCode.AGENT_CALLING_NOT_ALLOW_OPERATE)
@@ -49,16 +255,17 @@ class AgentOperService:
         agent.agent_state = AgentState.DISABLE.code
         db.session.commit()
 
-        phone = _get_phone(req.saas_id, agent.phone_num)
+        phone = self.data_handle_server.get_phone(req.saas_id, agent.phone_num)
         phone.is_delete = 1
         db.session.commit()
 
+    @with_app_context
     def checkin(self, req: AgentActionRequest):
-        agent = _get_agent(req.saas_id, req.agent_id)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_id)
         if not agent or agent.agent_state == AgentState.DISABLE.code:
             raise BizException(BizErrorCode.ERROR_NOT_FOLLOW_CHECK_IN)
-        phone = _get_phone(req.saas_id, agent.phone_num)
-        agent_monitor = _get_agent_monitor(req.saas_id, agent.agent_num)
+        phone = self.data_handle_server.get_phone(req.saas_id, agent.phone_num)
+        agent_monitor = self.data_handle_server.get_agent_monitor(req.saas_id, agent.agent_num)
         agent_monitor.check_scene = req.scene
         self.agent_monitor_service.update_checkin(agent_monitor)
         self.agent_actionlog_service.insert_check_state(agent_monitor, AgentCheck.IN, AgentLogState.CHECKIN)
@@ -68,12 +275,14 @@ class AgentOperService:
         #     # 如果是手动外呼增加置忙
         #     self._handle_idle(req.scene, agent)
         return self._push_event_for_checkin(agent, agent_monitor, phone, req.scene)
+
+    @with_app_context
     def checkout(self, req: AgentActionRequest):
-        agent = _get_agent(req.saas_id, req.agent_id)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_id)
         if not agent or agent.agent_state == AgentState.DISABLE.code:
             raise BizException(BizErrorCode.AGENT_DISABLE_NOT_ALLOW_OPERATE)
 
-        agent_monitor = _get_agent_monitor(req.saas_id, agent.agent_num)
+        agent_monitor = self.data_handle_server.get_agent_monitor(req.saas_id, agent.agent_num)
         if not agent_monitor or agent_monitor.service_state == AgentServiceState.CALLING.code:
             raise BizException(BizErrorCode.AGENT_CALLING_NOT_ALLOW_OPERATE)
 
@@ -86,12 +295,13 @@ class AgentOperService:
 
         return self._push_event_for_checkout(agent, req.scene)
 
+    @with_app_context
     def busy(self, req: AgentActionRequest):
-        agent = _get_agent(req.saas_id, req.agent_id)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_id)
         if not agent or agent.agent_state == AgentState.DISABLE.code:
             raise BizException(BizErrorCode.AGENT_DISABLE_NOT_ALLOW_OPERATE)
 
-        agent_monitor = _get_agent_monitor(req.saas_id, agent.agent_num)
+        agent_monitor = self.data_handle_server.get_agent_monitor(req.saas_id, agent.agent_num)
         if not agent_monitor or agent_monitor.check_state == AgentCheck.OUT.code:
             raise BizException(BizErrorCode.AGENT_CHECK_OUT_NOT_ALLOW_OPERATE)
 
@@ -107,25 +317,30 @@ class AgentOperService:
         self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.BUSY, AgentLogState.BUSY)
         self._push_event_for_busy(agent, req.scene)
 
+    @with_app_context
     def idle(self, req: AgentActionRequest):
-        agent = _get_agent(req.saas_id, req.agent_id)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_id)
         if not agent or agent.agent_state == AgentState.DISABLE.code:
             raise BizException(BizErrorCode.AGENT_DISABLE_NOT_ALLOW_OPERATE)
         self._handle_idle(req.scene, agent)
 
+    @with_app_context
     def assign(self, req: AgentActionRequest):
         return self.agent_state_service.assign_agent(req.saas_id, req.service_id)
 
     def idle_agent_exist(self, request: AgentActionRequest):
         pass
+
+    @with_app_context
     def agent_state(self,req: AgentActionRequest):
         # agent = _get_agent(req.saas_id, req.agent_id)
-        agent_monitor = _get_agent_monitor(req.saas_id, req.agent_id)
+        agent_monitor = self.data_handle_server.get_agent_monitor(req.saas_id, req.agent_id)
         return agent_monitor.service_state
 
+    @with_app_context
     def turn_on(self, req: AgentActionRequest):
-        agent = _get_agent(req.saas_id, req.agent_id)
-        agent_monitor = _get_agent_monitor(req.saas_id, agent.agent_num)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_id)
+        agent_monitor = self.data_handle_server.get_agent_monitor(req.saas_id, agent.agent_num)
         agent_scene = AgentScene.get_by_code(req.scene)
         if not agent_monitor:
             raise BizException(BizErrorCode.RECORD_NOT_EXIST_ERROR)
@@ -138,8 +353,9 @@ class AgentOperService:
         self.agent_state_service.busy(agent.saas_id, agent.out_id, agent.phone_num)
         self.push_handler.push_on_agent_report(agent.saas_id, agent.out_id, agent_scene, AgentServiceState.BUSY)
 
+    @with_app_context
     def _handle_idle(self, scene, agent):
-        agent_monitor = _get_agent_monitor(agent.saas_id, agent.agent_num)
+        agent_monitor = self.data_handle_server.get_agent_monitor(agent.saas_id, agent.agent_num)
         if agent_monitor.check_state == AgentCheck.OUT.code:
             raise BizException(BizErrorCode.AGENT_CHECK_OUT_NOT_ALLOW_OPERATE)
         if agent_monitor.service_state == AgentServiceState.CALLING.code or agent_monitor.service_state == AgentServiceState.DIALING.code:
@@ -201,18 +417,21 @@ class AgentOperService:
 
 class AgentService:
 
-    def __init__(self, client, logger):
-        self.inbound_client = client
-        self.logger = logger
-        self.agent_monitor_service = AgentMonitorService(client, logger)
+    def __init__(self, app):
+        self.app = app
+        self.logger = app.logger
+        self.data_handle_server = DataHandleServer(app)
+        self.agent_monitor_service = AgentMonitorService(app)
 
+    @with_app_context
     def get_and_check(self, req: AgentActionRequest):
-        agent = _get_agent(req.saas_id, req.agent_id)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_id)
         if not agent:
             return {}
-        phone = _get_phone(req.saas_id, agent.phone_num)
+        phone = self.data_handle_server.get_phone(req.saas_id, agent.phone_num)
         return phone.to_dict()
 
+    @with_app_context
     def watch_agent_state(self, req: HumanServiceQueryRequest):
         pos = HumanServiceMap.query.filter(HumanServiceMap.is_delete == 0, HumanServiceMap.saas_id == req.saas_id,
                                            HumanServiceMap.service_id == req.serviceId).all()
@@ -220,8 +439,9 @@ class AgentService:
         monitors = self.agent_monitor_service.detail_monitor_out_ids(req.saas_id, agent_ids)
         return monitors
 
+    @with_app_context
     def add(self, req: AgentRequest):
-        new_agent_num = _get_newest_agent_number(req.saas_id)
+        new_agent_num = self.data_handle_server.get_newest_agent_number(req.saas_id)
         agent = Agent(saas_id=req.saas_id, agent_num=new_agent_num, agent_name=req.agent_name, out_id=req.out_id,
                       agent_pwd=req.agent_password, agent_type=req.agent_type, phone_num=req.phone_number,
                       distribute=req.distribute, agent_state=req.agent_state)
@@ -233,8 +453,9 @@ class AgentService:
         db.session.commit()
         return new_agent_num
 
+    @with_app_context
     def update(self, req: AgentRequest):
-        agent = _get_agent(req.saas_id, req.agent_number, req.out_id)
+        agent = self.data_handle_server.get_agent(req.saas_id, req.agent_number, req.out_id)
         if not agent:
             return
         phone_num = agent.phone_num
@@ -254,10 +475,12 @@ class AgentService:
             if phone:
                 db.session.delete(phone)
 
+    @with_app_context
     def detail(self, saas_id, agent_number):
-        agent = _get_agent(saas_id, agent_number=agent_number, out_id='')
+        agent = self.data_handle_server.get_agent(saas_id, agent_number=agent_number, out_id='')
         return agent
 
+    @with_app_context
     def count(self, req: AgentQueryRequest):
         cnt = Agent.query.filter(Agent.saas_id == req.saas_id,
                                  or_(Agent.agent_num == req.agent_number,
@@ -268,6 +491,7 @@ class AgentService:
                                  ).count()
         return cnt
 
+    @with_app_context
     def query_page(self, req: AgentQueryRequest):
         pagination = Agent.query.filter(Agent.saas_id == req.saas_id,
                                         or_(Agent.agent_num == req.agent_number,
@@ -293,27 +517,30 @@ class AgentService:
         # }
         return pagination
 
+    @with_app_context
     def delete(self, saas_id, agent_number):
-        agent = _get_agent(saas_id, agent_number=agent_number, out_id='')
+        agent = self.data_handle_server.get_agent(saas_id, agent_number=agent_number, out_id='')
         if not agent:
             return
         agent.is_delete = 1
 
-        agent_monitor = _get_agent_monitor(saas_id, agent_number)
+        agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_number)
         agent_monitor.is_delete = 1
         db.session.commit()
 
-        phone = _get_phone(saas_id, agent.phone_num)
+        phone = self.data_handle_server.get_phone(saas_id, agent.phone_num)
         phone.is_delete = 1
         db.session.commit()
 
 
 class AgentMonitorService:
 
-    def __init__(self, client, logger):
-        self.inbound_client = client
-        self.logger = logger
+    def __init__(self, app):
+        self.app = app
+        self.logger = app.logger
+        self.data_handle_server = DataHandleServer(app)
 
+    @with_app_context
     def detail_monitor_out_ids(self, saas_id, out_ids, check_scene=None):
         if not out_ids:
             return []
@@ -355,6 +582,7 @@ class AgentMonitorService:
             res.append(data.__dict__)
         return res
 
+    @with_app_context
     def update_checkin(self, agent_monitor):
         agent_monitor.check_state = AgentCheck.IN.code
         agent_monitor.check_in_time = datetime.utcnow()
@@ -362,6 +590,7 @@ class AgentMonitorService:
         agent_monitor.heart_time = datetime.utcnow()
         db.session.commit()
 
+    @with_app_context
     def update_checkout(self, agent_monitor):
         agent_monitor.check_state = AgentCheck.OUT.code
         agent_monitor.check_out_time = datetime.utcnow()
@@ -371,34 +600,41 @@ class AgentMonitorService:
         self.logger.info("update_checkout %s", agent_monitor.check_out_time)
         db.session.commit()
 
+    @with_app_context
     def update_idle(self, agent_monitor):
         agent_monitor.service_state = AgentServiceState.IDLE.code
         agent_monitor.idle_time = datetime.utcnow()
         db.session.commit()
 
+    @with_app_context
     def update_busy(self, agent_monitor):
         agent_monitor.service_state = AgentServiceState.BUSY.code
         agent_monitor.busy_time = datetime.utcnow()
         db.session.commit()
 
+    @with_app_context
     def update_dialing(self, agent_monitor):
         agent_monitor.service_state = AgentServiceState.DIALING.code
         db.session.commit()
 
+    @with_app_context
     def update_calling(self, agent_monitor):
         agent_monitor.service_state = AgentServiceState.CALLING.code
         agent_monitor.call_time = datetime.utcnow()
         db.session.commit()
 
+    @with_app_context
     def update_processing(self, agent_monitor):
         agent_monitor.service_state = AgentServiceState.REPROCESSING.code
         agent_monitor.hang_time = datetime.utcnow()
         db.session.commit()
 
+    @with_app_context
     def update_session_id(self, agent_monitor, session_id):
         agent_monitor.session_id = session_id
         db.session.commit()
 
+    @with_app_context
     def update_heart_error(self, agent_monitor):
         agent_monitor.heart_state = AgentHeartState.ABNORMAL.code
         agent_monitor.heart_time = datetime.utcnow()
@@ -411,10 +647,12 @@ class AgentMonitorService:
 
 class AgentActionLogService:
 
-    def __init__(self, client, logger):
-        self.inbound_client = client
-        self.logger = logger
+    def __init__(self, app):
+        self.app = app
+        self.logger = app.logger
+        self.data_handle_server = DataHandleServer(app)
 
+    @with_app_context
     def insert_check_state(self, agent_monitor, agent_check_enum: AgentCheck, agent_log_enum: AgentLogState):
         action_log = AgentActionLog()
         action_log.saas_id = agent_monitor.saas_id
@@ -440,6 +678,7 @@ class AgentActionLogService:
         db.session.add(action_log)
         db.session.commit()
 
+    @with_app_context
     def insert_service_state(self, agent_monitor, agent_service_state: AgentServiceState, agent_log_enum: AgentLogState,
                              task_id=None, service_id=None):
         if agent_monitor.service_state == agent_service_state.code:
@@ -480,35 +719,36 @@ class AgentActionLogService:
 
 class AgentStateService:
 
-    def __init__(self, client, logger):
-        self.inbound_client = client
-        self.logger = logger
+    def __init__(self, app):
+        self.app = app
+        self.logger = app.logger
         self.redis_handler = RedisHandler()
         self.assigned_recycle_millisecond = 60000
         self.state_service_id_data_map = defaultdict(dict)
         self.executor = ThreadPoolExecutor(max_workers=10)
-        self.agent_monitor_service = AgentMonitorService(client, logger)
-        self.agent_actionlog_service = AgentActionLogService(client, logger)
+        self.data_handle_server = DataHandleServer(app)
+        self.agent_monitor_service = AgentMonitorService(app)
+        self.agent_actionlog_service = AgentActionLogService(app)
 
     def idle(self, saas_id, agent_id, phone_num):
-        human_service = _get_human_service_service(saas_id, agent_id)
+        human_service = self.data_handle_server.get_human_service_service(saas_id, agent_id)
         if human_service is None:
             self.logger.info(f"agent engine idle not have human service {saas_id} {agent_id}")  # 使用print替代log
             return
         self.idle_hash(saas_id, agent_id, phone_num, human_service.service_id)
 
     def busy(self, saas_id, agent_id, phone_num):
-        human_service = _get_human_service_service(saas_id, agent_id)
+        human_service = self.data_handle_server.get_human_service_service(saas_id, agent_id)
         if human_service is None:
             self.logger.info(f"agent engine busy not hava human service {saas_id} {agent_id}")  # 使用print替代log
             return
         self.busy_hash(saas_id, agent_id, phone_num, human_service.service_id)
 
     def idle_by_human(self, saas_id, agent_id, service_id):
-        agent = _get_agent(saas_id, out_id=agent_id)
+        agent = self.data_handle_server.get_agent(saas_id, out_id=agent_id)
         if not agent:
             return
-        agent_monitor = _get_agent_monitor(saas_id, agent_number=agent.agent_num)
+        agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_number=agent.agent_num)
         if not agent_monitor:
             return
         if agent_monitor.check_state == AgentCheck.IN.code:
@@ -517,10 +757,10 @@ class AgentStateService:
             self.idle_hash(saas_id, agent_id, agent.phone_num, service_id)
 
     def busy_by_human(self, saas_id, service_id, agent_id=None):
-        agent = _get_agent(saas_id, out_id=agent_id)
+        agent = self.data_handle_server.get_agent(saas_id, out_id=agent_id)
         if not agent:
             return
-        agent_monitor = _get_agent_monitor(saas_id, agent_number=agent.agent_num)
+        agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_number=agent.agent_num)
         if not agent_monitor:
             return
         if agent_monitor.check_state == AgentCheck.IN.code:
@@ -692,34 +932,3 @@ class AgentStateService:
         idle_agents = sorted(idle_agents, key=lambda agent: agent.assign_time, reverse=False)
         return idle_agents[0].phone_num
 
-
-def _get_agent(saas_id, agent_id=None, agent_number=None, out_id=None):
-    agent = Agent.query.filter(
-        Agent.saas_id == saas_id,
-        or_(Agent.out_id == agent_id, Agent.out_id == out_id, Agent.agent_num == agent_number)
-    ).first()
-    return agent
-
-
-def _get_newest_agent_number(saas_id):
-    agent = Agent.query.filter(Agent.saas_id == saas_id).order_by(Agent.agent_num.desc()).first()
-    agentNum = START_AGENT_NUM
-    if agent and agent.agent_num:
-        agentNum = str(int(agent.agent_num) + 1)
-    return agentNum
-
-
-def _get_agent_monitor(saas_id, agent_number):
-    monitor = AgentMonitor.query.filter(AgentMonitor.saas_id == saas_id,
-                                        AgentMonitor.agent_num == agent_number).first()
-    return monitor
-
-
-def _get_phone(saas_id, phone_num):
-    phone = Phone.query.filter(Phone.saas_id == saas_id, Phone.phone_num == phone_num).first()
-    return phone
-
-
-def _get_human_service_service(saas_id, agent_id):
-    human_service_map = HumanServiceMap.query.filter(HumanServiceMap.saas_id == saas_id, HumanServiceMap.agent_id ==agent_id).first()
-    return human_service_map

src/core/callcenter/api.py

@@ -176,15 +176,25 @@ class AgentStateData(BaseApi):
         self.assign_time = assign_time
         self.phone_num = phone_num
 
+class AgentDelayStateData(BaseApi):
+    def __init__(self, saas_id=None, flow_id=None, agent_num=None, service_state=None, scene=None):
+        self.saas_id = saas_id
+        self.flow_id = flow_id
+        self.agent_num = agent_num
+        self.service_state = service_state
+        self.scene = scene
 
 class HangupCallRequest(BaseApi):
-    def __init__(self, saas_id, call_id, agent_number):
+    def __init__(self, saas_id=None, flow_id=None, agent_id=None, called=None, call_id=None, scene=None):
         # saasId(必填)
         self.saas_id = saas_id
+        self.flow_id = flow_id
         # 呼叫唯一id(选填)
         self.call_id = call_id
+        self.called = called
         # 分机号(必填)
-        self.agent_number = agent_number
+        self.agent_id = agent_id
+        self.scene = scene
 
 
 class CheckInCallRequest(BaseApi):

src/core/callcenter/cache.py

@@ -68,10 +68,9 @@ class Cache:
         self.redis_handler.set(CALL_INFO + call.call_id, call.to_json_string(), self.cacheDay * 24 * 60 * 60)
 
 
-    def get_call_info_by_device_id(self, device_id):
+    def get_call_id_by_device_id(self, device_id):
         call_id = self.deviceCall.get(device_id)
-        if not call_id:
-            return self.get_call_info(call_id)
+        return call_id
 
 
     # 获取callInfo
@@ -162,4 +161,20 @@ class Cache:
 
     def get_after_play_hold_music(self, call_id):
         key = AFTER_PLAY_HOLD_MUSIC % call_id
-        return self.redis_handler.redis.get(key)
+        return self.redis_handler.redis.get(key)
+
+    def get_call_is_end(self, call_id):
+        key = CTI_MANAGE_CENTER_CALL_END_KEY % call_id
+        return self.redis_handler.get(key)
+
+    def set_call_is_end(self, call_id):
+        key = CTI_MANAGE_CENTER_CALL_END_KEY % call_id
+        return self.redis_handler.redis.set(key, "1", ex=60 * 10, nx=True)
+
+    def get_call_is_answer(self, saas_id, flow_id):
+        key = CTI_AGENT_MANUAL_ANSWER%(saas_id, flow_id)
+        return self.redis_handler.get(key)
+
+    def set_call_is_answer(self, saas_id, flow_id):
+        key = CTI_AGENT_MANUAL_ANSWER%(saas_id, flow_id)
+        return self.redis_handler.redis.set(key, "1", ex=60, nx=True)

src/core/callcenter/call.py

@@ -3,9 +3,12 @@
 import json
 import time
 from datetime import datetime
+
+from src.core.callcenter.agent import AgentMonitorService, AgentActionLogService
 from src.core.callcenter.cache import Cache
 from src.core.callcenter.constant import saasId, HOLD_MUSIC_PATH
-from src.core.callcenter.enumeration import CallCause, Direction, NextType, DeviceType, CdrType, AgentServiceState,AgentScene,WorkStatus
+from src.core.callcenter.enumeration import CallCause, Direction, NextType, DeviceType, CdrType, AgentServiceState, \
+    AgentScene, WorkStatus, AgentLogState, ServiceDirect
 from src.core.callcenter.api import AgentCallRequest, CallInfo, HangupCallRequest, CheckInCallRequest, \
     DeviceInfo, NextCommand, MakeCallContext
 from src.core.callcenter.esl.constant.sip_header_constant import sipHeaderServiceId, sipHeaderCtiFlowId
@@ -15,13 +18,16 @@ from src.core.callcenter.data_handler import *
 
 class CallService:
 
-    def __init__(self, client, logger):
+    def __init__(self, client, app):
         self.client = client
-        self.logger = logger
-        self.cache = Cache(client.app)
+        self.logger = app.logger
+        self.cache = Cache(app)
         self.snowflake = Snowflake()
-        self.dataHandleServer=DataHandleServer(client.app)
-        self.push_handler = PushHandler(logger)
+        self.push_handler = PushHandler(app.logger)
+        self.data_handle_server=DataHandleServer(app)
+        self.agent_monitor_service = AgentMonitorService(app)
+        self.agent_actionlog_service = AgentActionLogService(app)
+        # self.push_handler = PushHandler(logger)
 
     def call(self, request: AgentCallRequest):
         call_id = 'C' + str(self.snowflake.next_id())
@@ -55,20 +61,26 @@ class CallService:
                                   sip_header_map={sipHeaderCtiFlowId: request.cti_flow_id})
 
         self.client.make_call_new(context)
-
-        # 创建一条通话记录
-        self.dataHandleServer.create_record({
-            "session_id": call_id,
-            "time_begin": datetime.utcnow(),
-            "category": 1,
-            "agent_num":request.agent_id,
-            "phone": request.called
-        })
-        # 变更坐席状态为拨号中
-        self.dataHandleServer.update_agent_monitor_service_state(request.agent_id, AgentServiceState.DIALING.code)
-        self.push_handler.push_on_agent_work_report(request.saas_id, request.cti_flow_id, request.agent_id, call_id,AgentScene.ROBOT, WorkStatus.AGENT_DIALING)
+        self.do_after_manual_call(call_info, agent.agent_number)
+        # # 创建一条通话记录
+        # self.dataHandleServer.create_record({
+        #     "session_id": call_id,
+        #     "time_begin": datetime.utcnow(),
+        #     "category": 1,
+        #     "agent_num":request.agent_id,
+        #     "phone": request.called
+        # })
+        # # 变更坐席状态为拨号中
+        # self.dataHandleServer.update_agent_monitor_service_state(request.agent_id, AgentServiceState.DIALING.code)
+        # self.push_handler.push_on_agent_work_report(request.saas_id, request.cti_flow_id, request.agent_id, call_id,AgentScene.ROBOT, WorkStatus.AGENT_DIALING)
         return call_id
 
+    def do_after_manual_call(self, call_info: CallInfo, agent_id):
+        agent_monitor = self.data_handle_server.get_agent_monitor(call_info.saas_id, agent_number=agent_id)
+        self.agent_monitor_service.update_dialing(agent_monitor)
+        self.push_handler.push_on_call_ring(call_info.saas_id, flow_id=call_info.cti_flow_id, user_id=agent_id, scene=AgentScene.MANUAL, call_id=call_info.call_id, service_direct=ServiceDirect.MANUAL_CALL.service_direct)
+        self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.DIALING, AgentLogState.DIALING)
+
     def hold(self, call_info: CallInfo, device_id):
         devices = call_info.device_list
         try:
@@ -115,16 +127,21 @@ class CallService:
                                   call_type=call_info.call_type, service_id=service_id, sip_header_map=sip_header_map)
         self.client.make_call_new(context)
 
-    def hangup(self, request: HangupCallRequest):
-        call_info = self.cache.get_call_info(request.call_id)
-        if not call_info:
-            self.logger.info('hangup call not exist callId: %s', request.call_id)
-            return
-        devices = call_info.device_list
-        if not devices:
-            self.logger.info('hangup deviceList is null callId: %s', request.call_id)
-            return
-        self.hangup_all(call_info, CallCause.AGENT_HANGUP_CALL)
+    def hangup_by_scene(self, request: HangupCallRequest):
+        scene = AgentScene.get_by_code(request.scene)
+        if scene and AgentScene.MANUAL == scene:
+            self.do_manual_hang(request)
+        elif scene and not AgentScene.MANUAL == scene:
+            self.do_robot_hang(request)
+
+    def do_manual_hang(self, request: HangupCallRequest):
+        self.hangup_call(request.call_id)
+
+        agent_monitor = self.data_handle_server.get_agent_monitor(saas_id=request.saas_id, agent_number=request.agent_id)
+        self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.HANGING, AgentLogState.MANUAL_HANG_UP)
+
+    def do_robot_hang(self, request: HangupCallRequest):
+        self.hangup_call(request.call_id)
 
     def hangup_all(self, call_info: CallInfo, case_enum=CallCause.DEFAULT):
         devices = call_info.device_list

src/core/callcenter/callback.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# encoding:utf-8
+import threading
+
+import src.core.callcenter.esl.utils.esl_event_util as EslEventUtil
+from src.core.callcenter.agent import AgentEventService
+from src.core.callcenter.cache import Cache
+from src.core.callcenter.enumeration import CallType
+from src.core.callcenter.esl.constant.event_names import CUSTOM, DETECTED_TONE
+
+
+class Callback(object):
+
+    def __init__(self, app):
+        self.app = app
+        self.logger = app.logger
+        self.cache = Cache(app)
+        self.agent_event_service = AgentEventService(app)
+
+    def callback_event(self, event):
+        event_name = EslEventUtil.getEventName(event)
+        # CUSTOM == event_name or
+        if not (event_name.startswith('CHANNEL_') or event_name.startswith('PLAYBACK_') or event_name == DETECTED_TONE):
+            return
+        call_id = EslEventUtil.getCallId(event)
+        device_id = EslEventUtil.getDeviceId(event)
+        if not call_id and device_id:
+            call_id = self.cache.get_call_id_by_device_id(device_id)
+        call_info = self.cache.get_call_info(call_id)
+        if not call_info:
+            # self.logger.info("liuwei::debugger::callback:return::event_name=%s, call_id=%s, device_id=%s", event_name, call_id, device_id)
+            return
+
+        call_type = CallType.get_by_code(call_info.call_type) if call_info else None
+        device_info = call_info.device_info_map.get(device_id) if call_info and call_info.device_info_map else None
+        # self.logger.info("liuwei::debugger::callback::event_name=%s, call_type=%s, call_id=%s, device_id=%s, call_info=%s", event_name, call_type, call_id, device_id, call_info)
+        if CallType.BOT_CALL == call_type:
+            threading.Thread(target=self.agent_event_service.bot_event_channel, args=(event, call_info, device_info)).start()
+            # self.agent_event_service.bot_event_channel(event, call_info, device_info)
+        else:
+            threading.Thread(target=self.agent_event_service.agent_event_channel, args=(event, call_info, device_info)).start()
+            # self.agent_event_service.agent_event_channel(event, call_info, device_info)

src/core/callcenter/constant.py

@@ -84,6 +84,8 @@ CTI_ENGINE_DELAY_ACTION = "DELAY:ACTION:%s"
 CTI_ENGINE_DELAY_ACTION_LOCK = "DELAY:ACTION:LOCK:%s"
 NEED_PLAY_HOLD_MUSIC = "CTI:ENGINE:NEED:HOLD:%s"
 AFTER_PLAY_HOLD_MUSIC = "CTI:ENGINE:AFTER:HOLD:%s"
+CTI_MANAGE_CENTER_CALL_END_KEY = "CTI:MANAGE:CENTER:CALL:END:KEY:%s"
+CTI_AGENT_MANUAL_ANSWER = "AGENT:MANUAL:ANSWER:%s:%s"
 
 def get_json_dict(json_text=None):
     if isinstance(json_text, str):

src/core/callcenter/data_handler.py

@@ -1,11 +1,7 @@
+from src.core import with_app_context
+from src.core.callcenter.constant import START_AGENT_NUM
 from src.core.callcenter.dao import *
-from functools import wraps
-def with_app_context(func):
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        with self.app.app_context():
-            return func(self, *args, **kwargs)
-    return wrapper
+from sqlalchemy import or_
 
 class DataHandleServer:
     """通话记录服务"""
@@ -51,6 +47,39 @@ class DataHandleServer:
     def get_agent_phone(self, saas_id, agent_num):
         return Phone.query.filter(Phone.saas_id == saas_id, Phone.phone_num == agent_num).first()
 
+    @with_app_context
+    def get_agent(self,saas_id, agent_id=None, agent_number=None, out_id=None):
+        agent = Agent.query.filter(
+            Agent.saas_id == saas_id,
+            or_(Agent.out_id == agent_id, Agent.out_id == out_id, Agent.agent_num == agent_number)
+        ).first()
+        return agent
+
+    @with_app_context
+    def get_newest_agent_number(self,saas_id):
+        agent = Agent.query.filter(Agent.saas_id == saas_id).order_by(Agent.agent_num.desc()).first()
+        agentNum = START_AGENT_NUM
+        if agent and agent.agent_num:
+            agentNum = str(int(agent.agent_num) + 1)
+        return agentNum
+
+    @with_app_context
+    def get_agent_monitor(self,saas_id, agent_number):
+        monitor = AgentMonitor.query.filter(AgentMonitor.saas_id == saas_id,
+                                            AgentMonitor.agent_num == agent_number).first()
+        return monitor
+
+    @with_app_context
+    def get_phone(self,saas_id, phone_num):
+        phone = Phone.query.filter(Phone.saas_id == saas_id, Phone.phone_num == phone_num).first()
+        return phone
+
+    @with_app_context
+    def get_human_service_service(self,saas_id, agent_id):
+        human_service_map = HumanServiceMap.query.filter(HumanServiceMap.saas_id == saas_id,
+                                                         HumanServiceMap.agent_id == agent_id).first()
+        return human_service_map
+
     @with_app_context
     def update_agent_monitor_service_state(self, agent_num,service_state):
         agent_monitor = AgentMonitor.query.filter(AgentMonitor.agent_num == agent_num).first()

src/core/callcenter/esl/client.py

@@ -17,6 +17,7 @@ from apscheduler.schedulers.background import BackgroundScheduler
 
 from src.core.callcenter.cache import Cache
 from src.core.callcenter.api import MakeCallContext, DelayAction, CallInfo, DeviceInfo, NextCommand
+from src.core.callcenter.callback import Callback
 from src.core.callcenter.constant import SK, EMPTY, CTI_ENGINE_DELAY_ACTION_LOCK, HOLD_MUSIC_PATH, saasId
 from src.core.callcenter.esl.constant.esl_constant import BRIDGE_VARIABLES, BRIDGE, HANGUP, NORMAL_CLEARING, SIP_HEADER, \
     SPACE, SPLIT, SOFIA, \
@@ -43,6 +44,7 @@ class InboundClient:
         self.logger = app.logger
         self.bot_agent = agent
         self.cache = Cache(app)
+        self.callback = Callback(app)
         self.dataHandleServer = DataHandleServer(app)
         self.handler_table = self.scan_esl_event_handlers()
         self.default_event_handler = DefaultEslEventHandler(self, self.bot_agent)
@@ -119,6 +121,7 @@ class InboundClient:
         address = self.host + ':' + self.port
         # self.logger.info("process_esl_event.event_name=%s,coreUUID=%s", event_name, coreUUID)
         try:
+            self.callback.callback_event(e)
             if event_name in self.handler_table:
                 items = self.handler_table.get(event_name)
                 for x in items:

src/core/callcenter/esl/handler/channel_answer_handler.py

@@ -27,7 +27,7 @@ class ChannelAnswerHandler(EslEventHandler):
     def handle(self, address, event, coreUUID):
         call_id = EslEventUtil.getCallId(event)
         call_info = self.cache.get_call_info(call_id)
-        self.logger.info("liuwei::debugger::answer call_id:%s, call_info:%s, event:%s"% (call_id, call_info, json.loads(event.serialize('json'))))
+        self.logger.info("liuwei::debugger::answer call_id:%s, call_info:%s", call_id, call_info)
         if not call_info:
             return
 
@@ -35,7 +35,7 @@ class ChannelAnswerHandler(EslEventHandler):
         device_info = call_info.device_info_map.get(device_id)
         next_command = call_info.next_commands[0] if len(call_info.next_commands) > 0 else None
         device_type = DeviceType.get_by_code(device_info.device_type)
-        self.logger.info("ChannelAnswerHandler call_id:%s, device_id:%s, device_type:%s, next_command:%s"%(call_id, device_id, device_type, next_command))
+        self.logger.info("liuwei::debugger::ChannelAnswerHandler call_id:%s, device_id:%s, device_type:%s, next_command:%s"%(call_id, device_id, device_type, next_command))
         if not next_command:
             return
 
@@ -46,8 +46,7 @@ class ChannelAnswerHandler(EslEventHandler):
         device_info.ring_end_time = EslEventUtil.getEventDateTimestamp(event)
         call_info.answer_count = call_info.answer_count + 1
         call_info.next_commands.remove(next_command)
-        self.logger.info("ysChannelAnswerHandler call_info.answer_time::%s,time:%s", call_info.answer_time, EslEventUtil.getEventDateTimestamp(event))
-        self.logger.info('坐席接听:%s,call_info.direction:%s', device_info.device_type, call_info.direction)
+        self.logger.info("liuwei::debugger::ChannelAnswerHandler call_info.answer_time::%s,time:%s", call_info.answer_time, EslEventUtil.getEventDateTimestamp(event))
 
 
         if NextType.NEXT_CALL_OTHER.code == next_command.next_type:
@@ -61,12 +60,12 @@ class ChannelAnswerHandler(EslEventHandler):
         else:
             self.logger.warn("can not match command :%s, callId :%s", next_command.next_type, call_id)
 
-        if device_info.device_type == DeviceType.AGENT.code:  # 如果是坐席接听 变更坐席状态
-            call_info.answer_time = EslEventUtil.getEventDateTimestamp(event)
-            self.dataHandleServer.update_record(call_id, {"status": 1})
-            self.push_handler.push_on_agent_work_report(call_info.saas_id, call_info.cti_flow_id, call_info.agent_key, call_info.call_id, AgentScene.ROBOT,WorkStatus.AGENT_ANSWER_INCOMING)
-            self.dataHandleServer.update_agent_monitor_service_state(call_info.agent_key,AgentServiceState.CALLING.code)
-            self.logger.info("坐席接听 event:%s" % (json.loads(event.serialize('json'))))
+        # if device_info.device_type == DeviceType.AGENT.code:  # 如果是坐席接听 变更坐席状态
+        #     call_info.answer_time = EslEventUtil.getEventDateTimestamp(event)
+        #     self.dataHandleServer.update_record(call_id, {"status": 1})
+        #     self.push_handler.push_on_agent_work_report(call_info.saas_id, call_info.cti_flow_id, call_info.agent_key, call_info.call_id, AgentScene.ROBOT,WorkStatus.AGENT_ANSWER_INCOMING)
+        #     self.dataHandleServer.update_agent_monitor_service_state(call_info.agent_key,AgentServiceState.CALLING.code)
+        #     self.logger.info("坐席接听 event:%s" % (json.loads(event.serialize('json'))))
 
         self.cache.add_call_info(call_info)
 

src/core/callcenter/esl/handler/channel_hangup_handler.py

@@ -23,7 +23,7 @@ class ChannelHangupHandler(EslEventHandler):
     def __init__(self, inbound_client, bot_agent):
         super().__init__(inbound_client, bot_agent)
         self.acd_service = AcdService(inbound_client,inbound_client.app)
-        self.call_service = CallService(inbound_client,inbound_client.logger)
+        self.call_service = CallService(inbound_client,inbound_client.app)
         self.push_handler = PushHandler(inbound_client.logger)
         self.dataHandleServer=DataHandleServer(inbound_client.app)
 
@@ -107,21 +107,21 @@ class ChannelHangupHandler(EslEventHandler):
                 # self.inbound_client.hangup_call(call_id, device_id, CallCause.HANGUP_EVENT)
 
             # 全部挂机以后推送挂机状态
-            self.logger.info('yushanghui::call_info.device_list %s', call_info.device_list)
-            if len(call_info.device_list) == 0:
-                self.push_handler.push_on_call_end(call_info.cti_flow_id, call_info.agent_key, AgentScene.ROBOT, call_info.direction, device_info.device_type)
-                self.push_handler.push_on_agent_work_report(call_info.saas_id, call_info.cti_flow_id,  call_info.agent_key, call_info.call_id, AgentScene.ROBOT, WorkStatus.AGENT_HANG_IDLE)
-                # 计算当前通话时长
-                if call_info.answer_time:
-                    call_info.end_time = timestamp
-                    call_info.talk_time = int(call_info.end_time) - int(call_info.answer_time)
-                    self.dataHandleServer.update_record(call_id, {"time_end": datetime.utcnow(), "times": int(call_info.talk_time / 1_000_000) })
-
-                self.logger.info('全部挂断 %s', device_info.device_type)
-                # 更新坐席状态
-                if device_info.device_type == DeviceType.AGENT.code:
-                    self.logger.info('更新坐席状态')
-                    self.dataHandleServer.update_agent_monitor_service_state(call_info.agent_key, AgentServiceState.IDLE.code)
+            # self.logger.info('yushanghui::call_info.device_list %s', call_info.device_list)
+            # if len(call_info.device_list) == 0:
+            #     self.push_handler.push_on_call_end(call_info.cti_flow_id, call_info.agent_key, AgentScene.ROBOT, call_info.direction, device_info.device_type)
+            #     self.push_handler.push_on_agent_work_report(call_info.saas_id, call_info.cti_flow_id,  call_info.agent_key, call_info.call_id, AgentScene.ROBOT, WorkStatus.AGENT_HANG_IDLE)
+            #     # 计算当前通话时长
+            #     if call_info.answer_time:
+            #         call_info.end_time = timestamp
+            #         call_info.talk_time = int(call_info.end_time) - int(call_info.answer_time)
+            #         self.dataHandleServer.update_record(call_id, {"time_end": datetime.utcnow(), "times": int(call_info.talk_time / 1_000_000) })
+            #
+            #     self.logger.info('全部挂断 %s', device_info.device_type)
+            #     # 更新坐席状态
+            #     if device_info.device_type == DeviceType.AGENT.code:
+            #         self.logger.info('更新坐席状态')
+            #         self.dataHandleServer.update_agent_monitor_service_state(call_info.agent_key, AgentServiceState.IDLE.code)
 
             # 判断挂机方向 && 更新缓存
             self.hangup_dir(call_info, device_info, cause)

src/core/callcenter/esl/handler/channel_originate_handler.py

@@ -15,11 +15,12 @@ class ChannelOriginateHandler(EslEventHandler):
         self.push_handler = PushHandler(inbound_client.logger)
 
     def handle(self, address, event, coreUUID):
-        call_id = EslEventUtil.getCallId(event)
-        device_id = EslEventUtil.getDeviceId(event)
-        call = self.cache.get_call_info(call_id)
-        device = call.device_info_map.get(device_id)
-        self.logger.info('ChannelOriginateHandler::event %s, device.device_type: %s,call.direction:%s ', event,device.device_type, call.direction)
-        if device.device_type == DeviceType.AGENT.code: # 如果是呼入有响铃
-            self.push_handler.push_on_call_ring(call.cti_flow_id,call.agent_key,AgentScene.ROBOT,call.call_id,call.caller, call.called,"00000000000000000")
-            self.push_handler.push_on_agent_work_report(call.saas_id, call.cti_flow_id,call.agent_key,call.call_id,AgentScene.ROBOT, WorkStatus.AGENT_RINGING,phone=call.caller)
+        pass
+        # call_id = EslEventUtil.getCallId(event)
+        # device_id = EslEventUtil.getDeviceId(event)
+        # call = self.cache.get_call_info(call_id)
+        # device = call.device_info_map.get(device_id)
+        # self.logger.info('ChannelOriginateHandler::event %s, device.device_type: %s,call.direction:%s ', event,device.device_type, call.direction)
+        # if device.device_type == DeviceType.AGENT.code: # 如果是呼入有响铃
+        #     self.push_handler.push_on_call_ring(call.cti_flow_id,call.agent_key,AgentScene.ROBOT,call.call_id,call.caller, call.called,"00000000000000000")
+        #     self.push_handler.push_on_agent_work_report(call.saas_id, call.cti_flow_id,call.agent_key,call.call_id,AgentScene.ROBOT, WorkStatus.AGENT_RINGING,phone=call.caller)

src/core/callcenter/esl/handler/channel_progress_media_handler.py

@@ -16,10 +16,11 @@ class ChannelProgressMediaHandler(EslEventHandler):
         self.push_handler = PushHandler(inbound_client.logger)
 
     def handle(self, address, event, coreUUID):
-        call_id = EslEventUtil.getCallId(event)
-        device_id = EslEventUtil.getDeviceId(event)
-        call_info = self.cache.get_call_info(call_id)
-        device = call_info.device_info_map.get(device_id)
-        self.logger.info('ChannelProgressMediaHandler:: device.device_type: %s,  call_info.direction: %s ',device.device_type, call_info.direction)
-        if call_info.direction == Direction.OUTBOUND.code and device.device_type == DeviceType.AGENT.code:
-            self.push_handler.push_on_agent_work_report(call_info.saas_id, call_info.cti_flow_id, call_info.agent_key, call_info.call_id, AgentScene.MANUAL, WorkStatus.AGENT_CALLING_RINGING)
+        pass
+        # call_id = EslEventUtil.getCallId(event)
+        # device_id = EslEventUtil.getDeviceId(event)
+        # call_info = self.cache.get_call_info(call_id)
+        # device = call_info.device_info_map.get(device_id)
+        # self.logger.info('ChannelProgressMediaHandler:: device.device_type: %s,  call_info.direction: %s ',device.device_type, call_info.direction)
+        # if call_info.direction == Direction.OUTBOUND.code and device.device_type == DeviceType.AGENT.code:
+        #     self.push_handler.push_on_agent_work_report(call_info.saas_id, call_info.cti_flow_id, call_info.agent_key, call_info.call_id, AgentScene.MANUAL, WorkStatus.AGENT_CALLING_RINGING)

src/core/callcenter/esl/handler/detected_tone_handler.py

@@ -17,9 +17,10 @@ class DetectedToneHandler(EslEventHandler):
         self.push_handler = PushHandler(inbound_client.logger)
 
     def handle(self, address, event, coreUUID):
-        call_id = EslEventUtil.getCallId(event)
-        device_id = EslEventUtil.getDeviceId(event)
-        call = self.cache.get_call_info(call_id)
-        device = call.device_info_map.get(device_id)
-        if call.answer_time and device.device_type == DeviceType.AGENT.code:
-            self.push_handler.push_on_detected_tone(call.cti_flow_id, call.agent_key, AgentScene.MANUAL,call.call_id)
+        pass
+        # call_id = EslEventUtil.getCallId(event)
+        # device_id = EslEventUtil.getDeviceId(event)
+        # call = self.cache.get_call_info(call_id)
+        # device = call.device_info_map.get(device_id)
+        # if call.answer_time and device.device_type == DeviceType.AGENT.code:
+        #     self.push_handler.push_on_detected_tone(call.cti_flow_id, call.agent_key, AgentScene.MANUAL,call.call_id)

src/core/callcenter/esl/handler/playback_start_handler.py

@@ -17,9 +17,10 @@ class PlaybackStartHandler(EslEventHandler):
         self.push_handler = PushHandler(inbound_client.logger)
 
     def handle(self, address, event, coreUUID):
-        call_id = EslEventUtil.getCallId(event)
-        device_id = EslEventUtil.getDeviceId(event)
-        call = self.cache.get_call_info(call_id)
-        device = call.device_info_map.get(device_id)
-        if device.device_type == DeviceType.AGENT.code:
-            self.push_handler.push_on_ring_start(call.cti_flow_id, call.agent_key, AgentScene.MANUAL, call.call_id)
+        pass
+        # call_id = EslEventUtil.getCallId(event)
+        # device_id = EslEventUtil.getDeviceId(event)
+        # call = self.cache.get_call_info(call_id)
+        # device = call.device_info_map.get(device_id)
+        # if device.device_type == DeviceType.AGENT.code:
+        #     self.push_handler.push_on_ring_start(call.cti_flow_id, call.agent_key, AgentScene.MANUAL, call.call_id)

src/core/callcenter/esl/handler/playback_stop_handler.py

@@ -18,9 +18,10 @@ class PlaybackStopHandler(EslEventHandler):
         self.push_handler = PushHandler(inbound_client.logger)
 
     def handle(self, address, event, coreUUID):
-        call_id = EslEventUtil.getCallId(event)
-        device_id = EslEventUtil.getDeviceId(event)
-        call = self.cache.get_call_info(call_id)
-        device = call.device_info_map.get(device_id)
-        if device.device_type == DeviceType.AGENT.code:
-            self.push_handler.push_on_ring_end(call.cti_flow_id, call.agent_key, AgentScene.MANUAL,call.call_id)
+        pass
+        # call_id = EslEventUtil.getCallId(event)
+        # device_id = EslEventUtil.getDeviceId(event)
+        # call = self.cache.get_call_info(call_id)
+        # device = call.device_info_map.get(device_id)
+        # if device.device_type == DeviceType.AGENT.code:
+        #     self.push_handler.push_on_ring_end(call.cti_flow_id, call.agent_key, AgentScene.MANUAL,call.call_id)

src/core/callcenter/push.py

@@ -8,6 +8,7 @@ from src.core.datasource import RedisHandler
 class PushHandler:
     def __init__(self, logger):
         self.logger = logger
+
     def push_to_socket_service(self,user_id, data, event='common_down_data'):
         # 创建发布的消息
         message = json.dumps({
@@ -18,6 +19,7 @@ class PushHandler:
         # 获取 RedisHandler 实例并发布消息到 Redis 频道
         redis_handler = RedisHandler()
         redis_handler.publish('socket_channel', message)
+
     def push_on_agent_work_report(self, saas_id, flow_id, user_id, call_id, scene: AgentScene, work_status: WorkStatus, description=None, phone=None):
         data = {
             'eventName': DownEvent.ON_AGENT_WORK_REPORT.code,
@@ -29,7 +31,7 @@ class PushHandler:
                     'phone':phone
                     }
         }
-        self.logger.info("flowId:[%s] OnAgentWorkReport push:[%s].", flow_id, json.dumps(data))
+        self.logger.info("flowId:[%s] push_on_agent_work_report push:[%s].", flow_id, json.dumps(data))
         new_data = {'data': json.dumps(data)}
         self.push_to_socket_service(user_id, json.dumps(new_data))
     def push_on_agent_report(self, saas_id, out_id, scene: AgentScene, service_state: AgentServiceState):
@@ -49,7 +51,7 @@ class PushHandler:
         new_data = {'data': json.dumps(data)}
         self.push_to_socket_service(user_id, json.dumps(new_data))
 
-    def push_on_call_ring(self, flow_id, user_id,scene:AgentScene, call_id,  calling_no, called_no, human_service_id):
+    def push_on_call_ring(self, saas_id, flow_id, user_id,scene:AgentScene, call_id, service_direct, calling_no=None, called_no=None, human_service_id=None):
         data = {
             'eventName': DownEvent.ON_CALLRING.code,
             'ext': {
@@ -58,14 +60,15 @@ class PushHandler:
                 'scene': scene.code,
                 'callingNo': calling_no,
                 'calledNo': called_no,
+                'serviceDirect': service_direct,
                 'serviceTaskId': human_service_id
             }
         }
-        self.logger.info("flowId:[%s] OnAgentWorkReport push:[%s].", flow_id, json.dumps(data))
+        self.logger.info("flowId:[%s] push_on_call_ring push:[%s].", flow_id, json.dumps(data))
         new_data = {'data': json.dumps(data)}
         self.push_to_socket_service(user_id, json.dumps(new_data))
 
-    def push_on_call_end(self, flow_id, user_id,  scene: AgentScene, service_direct=None, disconnect_type=0):
+    def push_on_call_end(self, saas_id, flow_id, user_id,  scene: AgentScene, service_direct=None, disconnect_type=0):
         data = {
             'eventName': DownEvent.ON_CALL_END.code,
             'ext': {
@@ -75,11 +78,11 @@ class PushHandler:
                 'serviceDirect': service_direct
             }
         }
-        self.logger.info("flowId:[%s] OnAgentWorkReport push:[%s].", flow_id, json.dumps(data))
+        self.logger.info("flowId:[%s] push_on_call_end push:[%s].", flow_id, json.dumps(data))
         new_data = {'data': json.dumps(data)}
         self.push_to_socket_service(user_id, json.dumps(new_data))
 
-    def push_on_ring_start(self, flow_id, user_id, scene: AgentScene, call_id=None):
+    def push_on_ring_start(self, saas_id, flow_id, user_id, scene: AgentScene, call_id=None):
         data = {
             'eventName': DownEvent.ON_RING_Start.code,
             'ext': {
@@ -92,7 +95,7 @@ class PushHandler:
         new_data = {'data': json.dumps(data)}
         self.push_to_socket_service(user_id, json.dumps(new_data))
 
-    def push_on_ring_end(self, flow_id, user_id, scene: AgentScene, call_id):
+    def push_on_ring_end(self, saas_id, flow_id, user_id, scene: AgentScene, call_id):
         data = {
             'eventName': DownEvent.ON_RING_END.code,
             'ext': {
@@ -105,7 +108,7 @@ class PushHandler:
         new_data = {'data': json.dumps(data)}
         self.push_to_socket_service(user_id, json.dumps(new_data))
 
-    def push_answer_call(self, saas_id,flow_id, out_id, call_id, scene: AgentScene, service_direct,work_status,user_id ):
+    def push_answer_call(self, saas_id,flow_id, user_id, call_id, scene: AgentScene, service_direct,work_status):
         data = {
             'eventName': DownEvent.ANSWER_CALL.code,
             'ext': {
@@ -113,14 +116,14 @@ class PushHandler:
                 'scene': scene.code,
                 'callId': call_id,
                 'serviceDirect':service_direct,
-                'workStatus':work_status
+                'workStatus':work_status.code
             }
         }
-        self.logger.info("flowId:[%s] push_on_ring_end push:[%s].", flow_id, json.dumps(data))
+        self.logger.info("flowId:[%s] push_answer_call push:[%s].", flow_id, json.dumps(data))
         new_data = {'data': json.dumps(data)}
         self.push_to_socket_service(user_id, json.dumps(new_data))
 
-    def push_on_detected_tone(self, flow_id, user_id, scene: AgentScene, call_id, ):
+    def push_on_detected_tone(self, saas_id, flow_id, user_id, scene: AgentScene, call_id):
         data = {
             'eventName': DownEvent.ON_DETECTED_TONE.code,
             'ext': {
@@ -129,6 +132,6 @@ class PushHandler:
                 'callId': call_id,
             }
         }
-        self.logger.info("flowId:[%s] push_on_ring_end push:[%s].", flow_id, json.dumps(data))
+        self.logger.info("flowId:[%s] push_on_detected_tone push:[%s].", flow_id, json.dumps(data))
         new_data = {'data': json.dumps(data)}
         self.push_to_socket_service(user_id, json.dumps(new_data))

src/core/callcenter/views.py

@@ -16,9 +16,9 @@ from .acd import AcdService
 agent = BotAgent(app)
 inbound_client = InboundClient(agent,app)
 outbound_client = OutboundClient(agent,app)
-call_service = CallService(inbound_client, app.logger)
-agent_service = AgentService(inbound_client, app.logger)
-agent_oper_service = AgentOperService(inbound_client, app.logger)
+call_service = CallService(inbound_client, app)
+agent_service = AgentService(app)
+agent_oper_service = AgentOperService(app)
 acd_service = AcdService(inbound_client, app)
 agent.acd_service = acd_service
 
@@ -154,8 +154,8 @@ def manual_hang():
     """挂断"""
     data = request.get_json()
     # agent = Cache.get_agent_info(data.get('saas_id'), data.get('agent_id'))
-    req = HangupCallRequest(saas_id=data.get('saas_id'), call_id=data.get('call_id'), agent_number=data.get('agent_id'))
-    call_service.hangup(req)
+    req = HangupCallRequest(saas_id=data.get('saas_id'), flow_id=data.get('ctiFlowId'), agent_id=data.get('agent_id'), called=data.get('called'), call_id=data.get('call_id'), scene=data.get('scene'))
+    call_service.hangup_by_scene(req)
     return success_response()