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 import registry
from src.core.callcenter.agent import AgentMonitorService, AgentActionLogService
from src.core.callcenter.cache import Cache
from src.core.callcenter.constant import SAAS_ID, 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)

    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.now().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=SAAS_ID,
                             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)
        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(context)
        self.do_after_manual_call(call_info, agent.agent_number)
        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)
        agent = self.data_handle_server.get_agent(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)
        self.data_handle_server.create_record(call_info.call_id, call_info.called, 2, service_category=0, category=1 , user_id=agent.user_id, user_name=agent.agent_name)

    def hold(self, call_id, device_id):
        self.logger.info('hold, custom_device_id=%s'%device_id)
        self.client.bridge_break(call_id, device_id)
        self.cache.set_need_play_hold_music(call_id)
        self.logger.info('hold success custom_device_id=%s'%device_id)

    # 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]
    #     custom_device_id = device_id
    #     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):
        registry.CALL_TRANSFER_REQUESTS.labels(f"{call_info.bucket_type}").inc()
        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.now().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=agent_number, 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)

        # 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(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)