voice-gateway-service/src/core/callcenter/call.py

#!/usr/bin/env python3
# encoding:utf-8
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, 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
from src.core.callcenter.snowflake import Snowflake
from src.core.callcenter.push import PushHandler
from src.core.callcenter.data_handler import *

class CallService:

    def __init__(self, client, app):
        self.client = client
        self.logger = app.logger
        self.cache = Cache(app)
        self.snowflake = Snowflake()
        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())
        device_id = 'D' + str(self.snowflake.next_id())
        # now = lambda: int(round(time.time() * 1000))
        now = datetime.utcnow().timestamp()
        self.logger.info("CallService 人工外呼 agent:%s makecall, ctiFlowId:%s, callId:%s, callerDisplay:%s, called:%s"%
              (request.caller, request.cti_flow_id, call_id, request.caller_display, request.called))

        agent = self.cache.get_agent_info(request.saas_id, request.agent_id)
        route_gateway = self.cache.get_route_gateway(request.saas_id)
        call_info = CallInfo(cti_flow_id=request.cti_flow_id, call_id=call_id, agent_key=agent.agent_number, sip_server=agent.sip_server,
                             caller=agent.agent_number, called=request.called, direction=Direction.OUTBOUND.code,
                             caller_display=request.caller_display, called_display=request.called_display,
                             call_type=request.call_type, call_time=now, follow_data=request.follow_data,
                             uuid1=request.uuid1, uuid2=request.uuid2, saas_id=saasId,
                             core_uuid=None, conference=None, group_id=None, hidden_customer=0, number_location=None, agent_name=None, login_type=None, ivr_id=None, task_id=None, media_host=None, client_host=None, record=None, record2=None, record_time=None, answer_flag=None, wait_time=None, answer_count=0, hangup_dir=None, sdk_hangup=0, hangup_code=None, answer_time=None, end_time=None, talk_time=None, first_queue_time=None, queue_start_time=None, queue_end_time=None, overflow_count=0, cdr_notify_url=None, queue_level=None, transfer_agent=None, device_list=[], device_info_map = {}, process_data = {}, next_commands=[], call_details=[])
        device_info = DeviceInfo(cti_flow_id=request.cti_flow_id, device_id=device_id, call_time=now, call_id=call_id, device_type=DeviceType.AGENT.code,
                                 agent_key=agent.agent_number, caller_display=route_gateway.name, cdr_type=CdrType.INBOUND.code,
                                 conference=None, agent_name=None, from_agent=None, caller=None, called=None, display=None, called_location=None, caller_location=None, ring_start_time=None, ring_end_time=None, answer_time=None, bridge_time=None, end_time=None, talk_time=None, sip_protocol=None, channel_name=None, hangup_cause=None, ring_cause=None, sip_status=None, record=None, record_time=None, record_start_time=None, state=None, apparent_number=None,
                                 )
        call_info.device_list.append(device_id)
        self.logger.info("liuwei::debugger:1111::call_id=%s, device_id=%s"%(call_id, device_id))
        call_info.next_commands.append(NextCommand(device_id, NextType.NEXT_CALL_OTHER.code))
        call_info.device_info_map = {device_id: device_info}
        self.cache.add_call_info(call_info)

        context = MakeCallContext(display=request.called, caller=request.called, called=request.caller,
                                  call_id=call_id, device_id=device_id, device_type=device_info.device_type,
                                  call_type=call_info.call_type, sip_server=call_info.sip_server,
                                  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,
        #     "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:
            devices.remove(device_id)
        except:
            pass
        custom_device_id = devices[0]
        self.logger.info('hold, custom_device_id=%s'%custom_device_id)
        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('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])

    def transfer(self, call_info: CallInfo, agent_number, service_id):
        caller = call_info.called
        call_id = call_info.call_id
        agent = self.cache.get_agent_info(call_info.saas_id, agent_number)
        device_id = 'T' + str(self.snowflake.next_id())
        # now = lambda: int(round(time.time() * 1000))
        now = datetime.utcnow().timestamp()

        device_info = DeviceInfo(device_id=device_id, caller=caller, display=caller, called=agent_number, call_id=call_id,
                            call_time=now, cdr_type=CdrType.TRANSFER.code, device_type=DeviceType.AGENT.code,
                            cti_flow_id=None, agent_key=None, agent_name=None, from_agent=None, called_location=None, caller_location=None, ring_start_time=None, ring_end_time=None, answer_time=None, bridge_time=None, end_time=None, talk_time=None, sip_protocol=None, channel_name=None, hangup_cause=None, ring_cause=None, sip_status=None, record=None, record_time=None, record_start_time=None, state=None, apparent_number=None, caller_display=None)
        call_info.device_list.append(device_id)
        self.logger.info("liuwei::debugger:2222::call_id=%s, device_id=%s" % (call_id, device_id))

        # call_info.caller = agent_number
        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('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)

        sip_header_map = {sipHeaderServiceId: service_id}
        context = MakeCallContext(display=call_info.caller, caller=call_info.caller, called=agent_number,
                                  call_id=call_id, device_id=device_id, device_type=device_info.device_type,sip_server=agent.sip_server,
                                  call_type=call_info.call_type, service_id=service_id, sip_header_map=sip_header_map)
        self.client.make_call_new(context)

    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
        if not devices:
            self.logger.info('hangupCallAll skip 已全部挂断 callId: %s', call_info.call_id)
            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.kill_call(call_info.call_id, device, case_enum)

    def hangup_call(self, call_id):
        call_info = self.cache.get_call_info(call_id)
        if not call_info:
            self.logger.info('hangup call not exist callId: %s', call_id)
            return
        devices = call_info.device_list
        if not devices:
            self.logger.info('hangup deviceList is null callId: %s', call_id)
            return
        self.logger.info("hangup_all, call_id:%s, devices=%s" % (call_info.call_id, json.dumps(devices)))
        for device in devices:
            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)
        return self.client.show_channel(agent.device_id)