Merge branch 'dev_transfer_20241123' of ssh://gitlab.fuxicarbon.com:1111/client_service/voice-gateway-service into dev_transfer_20241123

docker-compose.yml

@@ -3,23 +3,23 @@ services:
     image: pjsua2:v2.14.1201
     container_name: pjsua
     restart: always
-    network_mode: host
+#    network_mode: host
     volumes:
 #      - /Users/yushanghui/hongshantianping/git/voice-gateway-service:/code
       - /home/hongshan/voice-gateway-service:/code
       - /root/aibot/dm/voice:/root/aibot/dm/voice
     environment:
       - SERVE_HOST=192.168.100.159
-#    ports:
-#        - 8084:8084/udp
-#        - 8084:8084/tcp
-#        - 5008:5000/udp
-#        - 5008:5000/tcp
-#        - 8090:8090/udp
-#        - 8090:8090/tcp
-#        - 8091:8091/udp
-#        - 8091:8091/tcp
-          #        - 5060:5060/udp
+    ports:
+      - 8084:8084/udp
+      - 8084:8084/tcp
+      - 5008:5000/udp
+      - 5008:5000/tcp
+      - 8090:8090/udp
+      - 8090:8090/tcp
+      - 8091:8091/udp
+      - 8091:8091/tcp
+         #        - 5060:5060/udp
           #        - 5060:5060/tcp
           #        - 5080:5080/tcp
           #        - 5080:5080/udp

src/core/callcenter/acd.py

@@ -31,17 +31,17 @@ class AcdService:
 
     def transfer_to_agent(self, call_id, device_id, service_id):
         call_info = self.cache.get_call_info(call_id)
-        self.logger.info('debugger::transfer_to_agent, come in, call_id:%s, call_info:%s'%(call_id, call_info))
+        self.logger.info('transfer_to_agent, come in, call_id:%s, call_info:%s'%(call_id, call_info))
         if not call_info:
             return
         call_info.answer_flag = AnswerFlag.TRANSFER_TO_AGENT.code
         self.cache.add_call_info(call_info)
         # 1. hold住并且播放等待音
         self.call_service.hold(call_info, device_id)
-        self.logger.info('debugger::transfer_to_agent, 1111111 ')
+        self.logger.info('transfer_to_agent, 1111111 ')
         # 获得空闲坐席
         agent_number = self.agent_service.assign(AgentActionRequest(saas_id=saasId, service_id=service_id))
-        self.logger.info('debugger::transfer_to_agent, 222222 %s'%agent_number)
+        self.logger.info('transfer_to_agent, 222222 %s'%agent_number)
         if not agent_number:
             # 如果没有空闲坐席，播放等待音
             self.logger.info("AcdService transferToAgent agentNumber is empty serviceId:%s,called:%s,callId:%s"%(

src/core/callcenter/cache.py

@@ -64,7 +64,7 @@ class Cache:
     def add_call_info(self, call: CallInfo):
         for k, v in call.device_info_map.items():
             self.add_device(k, call.call_id)
-        # print('daviddebugger::add_call_info call_id:%s, call=%s'% (call.call_id, call))
+        # print('liuwei::debugger::add_call_info call_id:%s, call=%s'% (call.call_id, call))
         self.redis_handler.set(CALL_INFO + call.call_id, call.to_json_string(), self.cacheDay * 24 * 60 * 60)
 
 
@@ -79,7 +79,7 @@ class Cache:
         text = None
         if call_id:
             text = self.redis_handler.get(CALL_INFO + call_id)
-            # print('daviddebugger::get_call_info call_id:%s, text:%s'% (call_id, text))
+            # print('liuwei::debugger::get_call_info call_id:%s, text:%s'% (call_id, text))
         if text:
             return CallInfo.from_json(text)
 

src/core/callcenter/call.py

@@ -73,12 +73,12 @@ class CallService:
         except:
             pass
         custom_device_id = devices[0]
-        self.logger.info('debugger::hold, custom_device_id=%s'%custom_device_id)
+        self.logger.info('hold, custom_device_id=%s'%custom_device_id)
         # self.client.sync_invoke_method("bridge_break", method_args=(custom_device_id,))
         # self.client.sync_invoke_method("hold_play", method_args=(custom_device_id,HOLD_MUSIC_PATH))
         self.client.bridge_break(call_info.call_id, custom_device_id)
         self.cache.set_need_play_hold_music(call_info.call_id)
-        self.logger.info('debugger::hold success custom_device_id=%s'%custom_device_id)
+        self.logger.info('hold success custom_device_id=%s'%custom_device_id)
 
     def cancel_hold(self, call_info: CallInfo, device_id):
         self.client.bridge_call(call_info.call_id, call_info.device_list[0], call_info.device_list[1])
@@ -101,7 +101,7 @@ class CallService:
         call_info.device_info_map[device_id] = device_info
         call_info.next_commands.append(NextCommand(device_info.device_id, NextType.NEXT_TRANSFER_CALL.code, call_info.device_list[0]))
         call_info.agent_key = agent_number
-        self.logger.info('lwdebugger::transfer, agent_number=%s, device_id=%s, call_info=%s'% (agent_number, device_id, call_info))
+        self.logger.info('transfer, agent_number=%s, device_id=%s, call_info=%s'% (agent_number, device_id, call_info))
         # agent.sip_server
         self.cache.add_call_info(call_info)
         self.cache.add_agent_info(agent=agent, call_id=call_id, device_id=device_id)
@@ -130,7 +130,7 @@ class CallService:
             return
         self.logger.info("hangup_all, call_id:%s, devices=%s, case=%s"%(call_info.call_id, json.dumps(devices), case_enum))
         for device in devices:
-            self.client.hangup_call(call_info.call_id, device, case_enum)
+            self.client.kill_call(call_info.call_id, device, case_enum)
 
     def hangup_call(self, call_id):
         call_info = self.cache.get_call_info(call_id)
@@ -143,7 +143,7 @@ class CallService:
             return
         self.logger.info("hangup_all, call_id:%s, devices=%s" % (call_info.call_id, json.dumps(devices)))
         for device in devices:
-            self.client.hangup_call(call_info.call_id, device, CallCause.RESTART)
+            self.client.kill_call(call_info.call_id, device, CallCause.RESTART)
 
     def checkin_call(self, request: CheckInCallRequest):
         agent = self.cache.get_agent_info(request.saas_id, request.agent_number)

src/core/callcenter/esl/client.py

@@ -271,11 +271,11 @@ class InboundClient:
             if _con:
                 _con.disconnect()
 
-    def kill_call(self, call_id, device_id):
+    def kill_call(self, call_id, device_id, case_enum=CallCause.DEFAULT):
         if not device_id:
             return
-        self.logger.info("kill_call:%s, device:%s", call_id, device_id)
-        self.bgapi(UUID_KILL, device_id, desc="kill_call")
+        self.logger.info("kill_call:%s, device:%s, case_enum:%s", call_id, device_id, case_enum)
+        self.api(UUID_KILL, device_id, desc="kill_call")
 
     def broadcast(self, uuid, path, smf):
         builder = [
@@ -424,7 +424,7 @@ class InboundClient:
             _con = ESL.ESLconnection(self.host, self.port, self.password)
             if _con.connected():
                 e = _con.api(command, arg)
-                self.logger.info('debugger::%s success, arg=%s, event=%s' % (desc, command + ' ' + arg, e.serialize('json')))
+                self.logger.info('%s success, arg=%s, event=%s' % (desc, command + ' ' + arg, e.serialize('json')))
         except:
             traceback.print_exc()
         finally:
@@ -437,7 +437,7 @@ class InboundClient:
             _con = ESL.ESLconnection(self.host, self.port, self.password)
             if _con.connected():
                 e = _con.bgapi(command, arg)
-                self.logger.info('debugger::%s success, arg=%s, event=%s' % (desc, command + ' '+arg, e.serialize('json')))
+                self.logger.info('%s success, arg=%s, event=%s' % (desc, command + ' '+arg, e.serialize('json')))
         except:
             traceback.print_exc()
         finally:
@@ -552,7 +552,7 @@ class OutboundClient:
                     else:
                         #转到ai机器人
                         destination = self.server.agent.register(**kwargs)
-                        self.server.logger.info("debugger::device_id=%s, destination=%s, new_device_id=%s"% (device_id, destination, new_device_id))
+                        self.server.logger.info("device_id=%s, destination=%s, new_device_id=%s"% (device_id, destination, new_device_id))
                         call_info['type'] = 1
                         call_info['service_category'] = 1
                         call_info['user_id'] = destination
@@ -609,7 +609,7 @@ class OutboundClient:
             self.server.logger.info("liuwei::debugger:4444::call_id=%s, device_id=%s" % (call_id, new_device_id))
             # call_info.next_commands.append(NextCommand(device_id, NextType.NEXT_CALL_BRIDGE.code, new_device_id))
             call_info.device_info_map = {device_id: device_custom, new_device_id: device_bot}
-            self.server.logger.info("lwdebugger::outBound, call_info=%s"%(call_info))
+            self.server.logger.info("lwoutBound, call_info=%s"%(call_info))
             self.server.cache.add_call_info(call_info)
 
 

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

@@ -28,7 +28,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("lwdebugger::answer call_id:%s, call_info:%s, event:%s"% (call_id, call_info, json.loads(event.serialize('json'))))
+        # self.logger.info("lwanswer call_id:%s, call_info:%s, event:%s"% (call_id, call_info, json.loads(event.serialize('json'))))
         if not call_info:
             return
 
@@ -36,7 +36,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("lwdebugger::ChannelAnswerHandler call_id:%s, device_id:%s, device_type:%s, next_command:%s"%(call_id, device_id, device_type, next_command))
+        self.logger.info("lwChannelAnswerHandler 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
 
@@ -90,7 +90,7 @@ class ChannelAnswerHandler(EslEventHandler):
                                 call_time=now, device_type=DeviceType.CUSTOMER.code, caller_display=route_gateway.name, cdr_type=CdrType.OUTBOUND.code)
         call.next_commands.append(NextCommand(device_id=device_id, next_type=NextType.NEXT_CALL_BRIDGE.code, next_value=new_device_id))
         call.device_info_map[new_device_id] = new_device
-        # self.logger.info("lwdebugger::call_other, call_info=%s"%call)
+        # self.logger.info("lwcall_other, call_info=%s"%call)
         self.cache.add_call_info(call)
         self.cache.add_agent_info(agent=agent, call_id=call_id, device_id=device_id)
 

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

@@ -19,7 +19,7 @@ class ChannelBridgeHandler(EslEventHandler):
         device_id = EslEventUtil.getDeviceId(event)
         call = self.cache.get_call_info(call_id)
         device = call.device_info_map.get(device_id)
-        self.logger.info('debugger::device_id: %s, device:%s ', device_id, device)
+        self.logger.info('device_id: %s, device:%s ', device_id, device)
         if device.device_type == DeviceType.AGENT.code: # 如果是坐席接听 变更坐席状态
             self.dataHandleServer.update_agent_monitor_service_state(device_id, AgentServiceState.IDLE.code)
         pass

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

@@ -31,28 +31,28 @@ class ChannelHangupHandler(EslEventHandler):
         self.logger.info(json.loads(event.serialize('json')))
         try:
             call_id = EslEventUtil.getCallId(event)
-            self.logger.info('debugger::call_id is %s', call_id)
+            self.logger.info('call_id is %s', call_id)
             if not call_id:
                 self.release(event)
                 self.logger.info("call_id is null")
                 return
-            call = self.cache.get_call_info(call_id)
-            self.logger.info('debugger::call_info is %s', call)
-            if not call:
-                self.logger.info("call:%s is null", call_id)
+            call_info = self.cache.get_call_info(call_id)
+            self.logger.info('call_info is %s', call_info)
+            if not call_info:
+                self.logger.info("call_info:%s is null", call_id)
                 return
             device_id = EslEventUtil.getDeviceId(event)
             device_id = device_id if device_id else EslEventUtil.getUniqueId(event)
-            device = call.device_info_map.get(device_id)
-            # self.logger.info('debugger::device_id is ', device_id)
-            if not device:
-                self.logger.info("device:%s is null", device_id)
+            device_info = call_info.device_info_map.get(device_id)
+            # self.logger.info('device_id is ', device_id)
+            if not device_info:
+                self.logger.info("device_info:%s is null", device_id)
                 return
 
-            count = len(call.device_list)
-            self.logger.info('lwdebugger::ChannelHangupHandler, call_id=%s, device_id=%s, count=%s'% (call_id, device_id, count))
+            count = len(call_info.device_list)
+            self.logger.info('ChannelHangupHandler, call_id=%s, device_id=%s, count=%s'% (call_id, device_id, count))
             try:
-                call.device_list.remove(device_id)
+                call_info.device_list.remove(device_id)
             except:
                 pass
             cause = EslEventUtil.getCallHangupCause(event)
@@ -66,56 +66,56 @@ class ChannelHangupHandler(EslEventHandler):
             hangup_cause = EslEventUtil.getVariableSipHPLIBRAHangupCause(event)
             hangup_reason = EslEventUtil.getLIBRAHangupReason(event)
 
-            device.hangup_cause = cause
-            device.sip_protocol = sip_protocol
-            device.sip_status = sip_status
-            device.channel_name = channel_name
-            device.end_time = timestamp
+            device_info.hangup_cause = cause
+            device_info.sip_protocol = sip_protocol
+            device_info.sip_status = sip_status
+            device_info.channel_name = channel_name
+            device_info.end_time = timestamp
 
             # 计算通话时长
-            if device.answer_time:
-                device.talk_time = int(device.end_time) - int(device.answer_time)
+            if device_info.answer_time:
+                device_info.talk_time = int(device_info.end_time) - int(device_info.answer_time)
             else:
-                device.ring_start_time = device.end_time
+                device_info.ring_start_time = device_info.end_time
             # 计算录音时长
-            if device.record_start_time:
-                device.record_time = int(device.end_time) - int(device.record_start_time)
-            call.device_info_map[device.device_id] = device
-
-            skip_hangup_all = device.device_type == DeviceType.ROBOT.code
+            if device_info.record_start_time:
+                device_info.record_time = int(device_info.end_time) - int(device_info.record_start_time)
+            call_info.device_info_map[device_info.device_id] = device_info
+            skip_hangup_all = device_info.device_type == DeviceType.ROBOT.code
 
             # 更新通话记录
-            # self.dataHandleServer.update_record(call_id, {"time_end": datetime.fromtimestamp(int(device.end_time)),"times":device.talk_time})
+            # self.dataHandleServer.update_record(call_id, {"time_end": datetime.fromtimestamp(int(device_info.end_time)),"times":device_info.talk_time})
 
-            self.logger.info('debugger::ChannelHangupHandler, hangup_reason=%s, device_type=%s, cdr_type=%s, end_time=%s, skip_hangup_all=%s' % (hangup_reason, device.device_type, device.cdr_type, call.end_time, skip_hangup_all))
+            self.logger.info('ChannelHangupHandler, hangup_reason=%s, device_type=%s, cdr_type=%s, end_time=%s, skip_hangup_all=%s' % (hangup_reason, device_info.device_type, device_info.cdr_type, call_info.end_time, skip_hangup_all))
             # 如果是转人工
-            # if 'transferToAgent' == hangup_reason and DeviceType.ROBOT.code == device.device_type:
-            #     call.answer_flag = AnswerFlag.TRANSFER_TO_AGENT.code
+            # if 'transferToAgent' == hangup_reason and DeviceType.ROBOT.code == device_info.device_type:
+            #     call_info.answer_flag = AnswerFlag.TRANSFER_TO_AGENT.code
             #     service_id = EslEventUtil.getLIBRAServiceId(event)
-            #     call.transfer_agent = True
-            #     self.cache.add_call_info(call)
-            #     self.logger.info('debugger::ChannelHangupHandler, transferToAgent, service_id=%s' % (service_id))
-            #     self.acd_service.transfer_to_agent(call, device_id, service_id)
+            #     call_info.transfer_agent = True
+            #     self.cache.add_call_info(call_info)
+            #     self.logger.info('ChannelHangupHandler, transferToAgent, service_id=%s' % (service_id))
+            #     self.acd_service.transfer_to_agent(call_info, device_id, service_id)
             #     return
 
             # 如果有下一步
-            # next_command = call.next_commands[0] if len(call.next_commands) > 0 else None
+            # next_command = call_info.next_commands[0] if len(call_info.next_commands) > 0 else None
             # if next_command:
-            #     self.next_cmd(call, device, next_command, cause)
+            #     self.next_cmd(call_info, device_info, next_command, cause)
             #     return
             # 一般情况下，挂断其他所有设备
-            if device.cdr_type <= 4 and not call.end_time and not skip_hangup_all:
-                call.end_time = device.end_time
-                self.call_service.hangup_all(call, CallCause.HANGUP_EVENT)
+            if device_info.cdr_type <= 4 and not call_info.end_time and not skip_hangup_all:
+                call_info.end_time = device_info.end_time
+                self.logger.info("liuwei::debugger::hang_all, call_info:%s, device_info:%s"%(call_info,device_info))
+                self.call_service.hangup_all(call_info, CallCause.HANGUP_EVENT)
                 # self.inbound_client.hangup_call(call_id, device_id, CallCause.HANGUP_EVENT)
 
             # 判断挂机方向 && 更新缓存
-            self.hangup_dir(call, device, cause)
-            self.cache.add_call_info(call)
+            self.hangup_dir(call_info, device_info, cause)
+            self.cache.add_call_info(call_info)
 
-            if device.device_type == DeviceType.AGENT.code:
+            if device_info.device_type == DeviceType.AGENT.code:
                 self.dataHandleServer.update_agent_monitor_service_state(device_id, AgentServiceState.IDLE.code)
-                self.push_handler.push_on_call_end(call.cti_flow_id,call.agent_key,AgentScene.ROBOT,call.direction, device.device_type)
+                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)
         except:
             traceback.print_exc()
 
@@ -125,7 +125,7 @@ class ChannelHangupHandler(EslEventHandler):
         self.logger.info(f"release device_id={device_id}, user_part={user_part}")
         self.bot_agent.release(user_part)
 
-    def next_cmd(self, call: CallInfo, device: DeviceInfo, next_command: NextCommand, cause):
+    def next_cmd(self, call_info: CallInfo, device_info: DeviceInfo, next_command: NextCommand, cause):
         # 呼入转到坐席，坐席拒接和坐席sip呼不通的时候，都需要再次转回来到技能组排队。
         if NextType.NEXT_CALL_BRIDGE.code == next_command.next_type or NextType.NEXT_LISTEN_CALL.code == next_command.next_type:
             pass
@@ -135,21 +135,21 @@ class ChannelHangupHandler(EslEventHandler):
             pass
 
         if not next_command or NextType.NEXT_HANGUP.code != next_command.next_type:
-            call.next_commands.remove(next_command)
+            call_info.next_commands.remove(next_command)
 
         # 判断挂机方向 && 更新缓存
-        self.hangup_dir(call, device, cause)
-        self.cache.add_call_info(call)
+        self.hangup_dir(call_info, device_info, cause)
+        self.cache.add_call_info(call_info)
 
-    def hangup_dir(self, call:CallInfo, device:DeviceInfo, cause):
-        if call.hangup_dir or device.cdr_type > CdrType.CONSULT.code:
-            self.logger.info("hangup_dir::hangup_dir :%s, cdr_type :%s", call.hangup_dir, device.cdr_type)
+    def hangup_dir(self, call_info:CallInfo, device_info:DeviceInfo, cause):
+        if call_info.hangup_dir or device_info.cdr_type > CdrType.CONSULT.code:
+            self.logger.info("hangup_dir::hangup_dir :%s, cdr_type :%s", call_info.hangup_dir, device_info.cdr_type)
             return
-        if DeviceType.AGENT.code == device.device_type:
-            call.hangup_dir = HangupDir.HOST_HANGUP.code
-        elif DeviceType.CUSTOMER.code == device.device_type:
-            call.hangup_dir = HangupDir.CUSTOMER_HANGUP.code
-
-        if not call.end_time:
-            call.end_time = device.end_time
-        self.logger.info("hangup_dir::callId: %s, direction:%s, hangupDir:%s, cause:%s, deviceId: %s", call.call_id, call.direction, call.hangup_dir, cause, device.device_id)
+        if DeviceType.AGENT.code == device_info.device_type:
+            call_info.hangup_dir = HangupDir.HOST_HANGUP.code
+        elif DeviceType.CUSTOMER.code == device_info.device_type:
+            call_info.hangup_dir = HangupDir.CUSTOMER_HANGUP.code
+
+        # if not call_info.end_time:
+        #     call_info.end_time = device_info.end_time
+        self.logger.info("hangup_dir::callId: %s, direction:%s, hangupDir:%s, cause:%s, deviceId: %s", call_info.call_id, call_info.direction, call_info.hangup_dir, cause, device_info.device_id)