事件剥离逻辑,fix

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

@@ -43,6 +43,7 @@ class AgentEventService:
             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:

src/core/callcenter/api.py

@@ -185,13 +185,16 @@ class AgentDelayStateData(BaseApi):
         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/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,12 +18,15 @@ 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(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):
@@ -55,7 +61,7 @@ class CallService:
                                   sip_header_map={sipHeaderCtiFlowId: request.cti_flow_id})
 
         self.client.make_call_new(context)
-
+        self.do_after_manual_call(call_info, agent.agent_number)
         # # 创建一条通话记录
         # self.dataHandleServer.create_record({
         #     "session_id": call_id,
@@ -69,6 +75,12 @@ class CallService:
         # 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/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)
 

src/core/callcenter/push.py

@@ -51,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, saas_id, flow_id, user_id,scene:AgentScene, call_id, service_direct, 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': {

src/core/callcenter/views.py

@@ -16,7 +16,7 @@ from .acd import AcdService
 agent = BotAgent(app)
 inbound_client = InboundClient(agent,app)
 outbound_client = OutboundClient(agent,app)
-call_service = CallService(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)
@@ -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()