事件剥离逻辑

src/core/callcenter/agent.py

@@ -4,43 +4,189 @@
 import traceback
 from typing import List
 from collections import defaultdict
+
+from src.core.callcenter.cache import Cache
 from src.core.callcenter.constant import START_AGENT_NUM
+from src.core.callcenter.data_handler import DataHandleServer
 from src.core.callcenter.enumeration import AgentState, AgentCheck, AgentHeartState, AgentServiceState, AgentLogState, \
-    AgentScene, BizErrorCode, WorkStatus, DownEvent, HumanState
+    AgentScene, BizErrorCode, WorkStatus, DownEvent, HumanState, DeviceType, ServiceDirect
 from sqlalchemy import or_
 from src.core.callcenter.dao import *
 from src.core.callcenter.exception import BizException
 from src.core.callcenter.api import AgentActionRequest, AgentInfo, AgentQueryRequest, AgentRequest, AgentEventData, \
-    AgentStateData, HumanServiceQueryRequest, AgentMonitorData
+    AgentStateData, HumanServiceQueryRequest, AgentMonitorData, CallInfo, DeviceInfo
 from src.core.callcenter.push import PushHandler
 from src.core.datasource import RedisHandler
-
+import src.core.callcenter.esl.utils.esl_event_util as EslEventUtil
+from src.core.callcenter.esl.constant.event_names import *
 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 agent_event_channel(self, event, call_info: CallInfo, device_info: DeviceInfo):
+        event_name = EslEventUtil.getEventName(event)
+        saas_id = call_info.saas_id
+        flow_id = call_info.cti_flow_id
+        call_id = call_info.call_id
+        caller = device_info.caller
+        called = device_info.called
+        agent_num = device_info.agent_key
+
+        is_agent = device_info and DeviceType.AGENT.code == device_info.device_type
+        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, 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, 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:
+            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, 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.push_handler.push_on_call_end(saas_id, flow_id, 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 PLAYBACK_START == event_name and is_agent:
+            self.push_handler.push_on_ring_start(saas_id, flow_id, agent_num, AgentScene.MANUAL, call_id)
+
+        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 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
+        flow_id = call_info.cti_flow_id
+        call_id = call_info.call_id
+        agent_num = device_info.agent_key
+        is_agent = device_info and DeviceType.AGENT.code == device_info.device_type
+        caller = device_info.called if is_agent else device_info.caller
+        called = device_info.caller if is_agent else device_info.called
+        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,
+                             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, 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)
+
 
 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.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)
 
     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()
 
     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 +195,16 @@ 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()
 
     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)
@@ -69,11 +215,11 @@ class AgentOperService:
         #     self._handle_idle(req.scene, agent)
         return self._push_event_for_checkin(agent, agent_monitor, phone, req.scene)
     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)
 
@@ -87,11 +233,11 @@ class AgentOperService:
         return self._push_event_for_checkout(agent, req.scene)
 
     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)
 
@@ -108,7 +254,7 @@ class AgentOperService:
         self._push_event_for_busy(agent, req.scene)
 
     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)
@@ -120,12 +266,12 @@ class AgentOperService:
         pass
     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
 
     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)
@@ -139,7 +285,7 @@ class AgentOperService:
         self.push_handler.push_on_agent_report(agent.saas_id, agent.out_id, agent_scene, AgentServiceState.BUSY)
 
     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,16 +347,15 @@ 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.data_handle_server = DataHandleServer(app)
+        self.agent_monitor_service = AgentMonitorService(app)
 
     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()
 
     def watch_agent_state(self, req: HumanServiceQueryRequest):
@@ -221,7 +366,7 @@ class AgentService:
         return monitors
 
     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)
@@ -234,7 +379,7 @@ class AgentService:
         return new_agent_num
 
     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
@@ -255,7 +400,7 @@ class AgentService:
                 db.session.delete(phone)
 
     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
 
     def count(self, req: AgentQueryRequest):
@@ -294,25 +439,24 @@ class AgentService:
         return pagination
 
     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.data_handle_server = DataHandleServer(app)
 
     def detail_monitor_out_ids(self, saas_id, out_ids, check_scene=None):
         if not out_ids:
@@ -411,9 +555,8 @@ class AgentMonitorService:
 
 class AgentActionLogService:
 
-    def __init__(self, client, logger):
-        self.inbound_client = client
-        self.logger = logger
+    def __init__(self, app):
+        self.data_handle_server = DataHandleServer(app)
 
     def insert_check_state(self, agent_monitor, agent_check_enum: AgentCheck, agent_log_enum: AgentLogState):
         action_log = AgentActionLog()
@@ -480,35 +623,35 @@ class AgentActionLogService:
 
 class AgentStateService:
 
-    def __init__(self, client, logger):
-        self.inbound_client = client
-        self.logger = logger
+    def __init__(self, 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 +660,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 +835,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/cache.py

@@ -162,4 +162,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

@@ -21,7 +21,7 @@ class CallService:
         self.cache = Cache(client.app)
         self.snowflake = Snowflake()
         self.dataHandleServer=DataHandleServer(client.app)
-        self.push_handler = PushHandler(logger)
+        # self.push_handler = PushHandler(logger)
 
     def call(self, request: AgentCallRequest):
         call_id = 'C' + str(self.snowflake.next_id())
@@ -56,17 +56,17 @@ class CallService:
 
         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.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 hold(self, call_info: CallInfo, device_id):

src/core/callcenter/callback.py

@@ -0,0 +1,35 @@
+#!/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
+
+
+class Callback(object):
+
+    def __init__(self, app):
+        self.app = app
+        self.cache = Cache(app)
+        self.agent_event_service = AgentEventService(app)
+
+    def callback_event(self, event):
+        event_name = EslEventUtil.getEventName(event)
+
+        if not (CUSTOM == event_name and event_name.startswith('CHANNEL_') and event_name.startswith('PLAYBACK_') and event_name.startswith('PLAYBACK_')):
+            return
+
+        call_id = EslEventUtil.getCallId(event)
+        device_id = EslEventUtil.getDeviceId(event)
+
+        call_info = self.cache.get_call_info(call_id)
+        device_info = call_info.device_info_map.get(device_id) if call_info and call_info.device_info_map else None
+        if call_info and CallType.BOT_CALL.code == call_info.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,5 +1,8 @@
+from src.core.callcenter.constant import START_AGENT_NUM
 from src.core.callcenter.dao import *
 from functools import wraps
+from sqlalchemy import or_
+
 def with_app_context(func):
     @wraps(func)
     def wrapper(self, *args, **kwargs):
@@ -51,6 +54,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

@@ -61,12 +61,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

@@ -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,
@@ -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, called_no, human_service_id):
         data = {
             'eventName': DownEvent.ON_CALLRING.code,
             'ext': {
@@ -58,6 +60,7 @@ class PushHandler:
                 'scene': scene.code,
                 'callingNo': calling_no,
                 'calledNo': called_no,
+                'serviceDirect': service_direct,
                 'serviceTaskId': human_service_id
             }
         }
@@ -65,7 +68,7 @@ class PushHandler:
         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': {
@@ -79,7 +82,7 @@ class PushHandler:
         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': {
@@ -120,7 +123,7 @@ class PushHandler:
         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': {

src/core/callcenter/views.py

@@ -17,8 +17,8 @@ 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)
+agent_service = AgentService(app)
+agent_oper_service = AgentOperService(app)
 acd_service = AcdService(inbound_client, app)
 agent.acd_service = acd_service