hotline/src/Hotline.Api/Controllers/CallController.cs

using Hotline.Application.CallCenter;
using Hotline.Share.Tools;
using Hotline.Caching.Interfaces;
using Hotline.CallCenter.BlackLists;
using Hotline.CallCenter.Calls;
using Hotline.CallCenter.Configs;
using Hotline.CallCenter.Tels;
using Hotline.EventBus;
using Hotline.Quality.Notifications;
using Hotline.Settings;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.CallCenter;
using Hotline.Share.Dtos.Quality;
using Hotline.Share.Dtos.TrCallCenter;
using Hotline.Share.Enums.CallCenter;
using Hotline.Repository.SqlSugar.Extensions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using System.Threading;
using XF.Domain.Exceptions;
using XF.Utility.EnumExtensions;
using XF.Domain.Repository;
using MapsterMapper;
using SqlSugar;
using Hotline.Api.Filter;
using Microsoft.AspNetCore.Authorization;
using Hotline.Share.Dtos.Order;
using Hotline.Tools;
using XF.Domain.Authentications;
using Hotline.Caching.Services;

namespace Hotline.Api.Controllers
{
    public class CallController : BaseController
    {
        private readonly ICallApplication _callApplication;
        private readonly Publisher _publisher;
        private readonly IMapper _mapper;
        private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
        private readonly ISystemSettingCacheManager _systemSettingCacheManager;
        private readonly IRepository<TelOperationXthx> _telOperationXthxRepository;
        private readonly IUserCacheManager _userCacheManager;
        private readonly ISessionContext _sessionContext;
        private readonly IRepository<TelActionRecord> _telActionRecordRepository;

        public CallController(
            ICallApplication callApplication,
            Publisher publisher,
            IMapper mapper,
            IOptionsSnapshot<CallCenterConfiguration> callcenterOptions,
            ISystemSettingCacheManager systemSettingCacheManager,
            IRepository<TelOperationXthx> telOperationXthxRepository,
            IUserCacheManager userCacheManager,
            ISessionContext sessionContext,
            IRepository<TelActionRecord> telActionRecordRepository)
        {
            _callApplication = callApplication;
            _publisher = publisher;
            _mapper = mapper;
            _callcenterOptions = callcenterOptions;
            _systemSettingCacheManager = systemSettingCacheManager;
            _telOperationXthxRepository = telOperationXthxRepository;
            _userCacheManager = userCacheManager;
            _sessionContext = sessionContext;
            _telActionRecordRepository = telActionRecordRepository;
        }

        /// <summary>
        /// 查询分机组和分机
        /// </summary>
        [HttpGet("querygrouptel")]
        public Task<IReadOnlyList<TelGroupDto>> QueryGroupTel()
            => _callApplication.QueryGroupTel(HttpContext.RequestAborted);

        /// <summary>
        /// 查询分机
        /// </summary>
        [HttpGet("tels")]
        public async Task<IList<TelDto>> QueryTels()
            => (await _callApplication.QueryTelsAsync(new QueryTelsInDto(null) { PageSize = 99999 }, HttpContext.RequestAborted)).Item2;

        /// <summary>
        /// 查询分机
        /// </summary>
        [HttpGet("tels-paged")]
        public async Task<PagedDto<TelDto>> QueryTelsAsync([FromQuery] QueryTelsInDto dto)
            => (await _callApplication.QueryTelsAsync(dto, HttpContext.RequestAborted)).ToPaged();

        /// <summary>
        /// 查询分机组
        /// </summary>
        [HttpGet("groups")]
        public Task<IReadOnlyList<TelGroupDto>> QueryTelGroups()
            => _callApplication.QueryTelGroupsAsync(HttpContext.RequestAborted);

        #region 黑名单

        //Task<string> AddBlackListAsync(AddBlacklistDto dto, CancellationToken cancellationToken);
        //Task RemoveBlackListAsync(string id, CancellationToken cancellationToken);
        //Task<List<Blacklist>> QueryBlackListsAsync(CancellationToken cancellationToken);

        #endregion

        /// <summary>
        /// 签入
        /// </summary>
        [HttpPost("signin")]
        [LogFilterAlpha("分机签入")]
        public Task<TrOnDutyResponseDto> SignIn([FromBody] SignInDto dto)
            => _callApplication.SignInAsync(dto, HttpContext.RequestAborted);

        /// <summary>
        /// 签出
        /// </summary>
        [HttpPost("signout")]
        [LogFilterAlpha("分机签出")]
        public Task SignOut()
            => _callApplication.SingOutAsync(HttpContext.RequestAborted);

        /// <summary>
        /// 签出
        /// </summary>
        [HttpPost("signout/{telNo}")]
        [LogFilterAlpha("分机签出")]
        public Task SignOut(string telNo)
            => _callApplication.SingOutAsync(telNo, HttpContext.RequestAborted);

        /// <summary>
        /// 分机动作开始
        /// </summary>
        /// <returns></returns>
        [HttpGet("call-action-record-begin")]
        public async Task CallActionRecordBegin(int actionType)
        {
            var work = _userCacheManager.GetWorkByUser(_sessionContext.RequiredUserId);

            if (work is null)
                throw UserFriendlyException.SameMessage("分机未签入，不能操作");

            if (actionType == 0)//小休
            {
                var isResting = await _telActionRecordRepository.AnyAsync(x => x.TelNo == work.TelNo && x.ActionType == EActionType.TelRest && !x.EndTime.HasValue, HttpContext.RequestAborted);
                if (!isResting)
                {
                    var telAction = new TelActionRecord(work.UserId, work.UserName, work.TelNo, work.QueueId, EActionType.TelRest);
                    await _telActionRecordRepository.AddAsync(telAction, HttpContext.RequestAborted);
                    work.OldExtensionStatus = work.ExtensionStatus;
                    work.ExtensionStatus = EExtensionStatus.TelRest;
                    _userCacheManager.SetWorkByUser(work);
                }
                return;
            }

            //判断如果已经存在未结束的该动作就不新增
            var ishas = await _telActionRecordRepository.AnyAsync(x => x.TelNo == work.TelNo && x.ActionType == (EActionType)actionType && !x.EndTime.HasValue, HttpContext.RequestAborted);
            if (!ishas)
            {
                var telAction = new TelActionRecord(work.UserId, work.UserName, work.TelNo, work.QueueId, (EActionType)actionType);
                await _telActionRecordRepository.AddAsync(telAction, HttpContext.RequestAborted);
            }
            //动作写入成功，修改话机动作状态
            work.OldExtensionStatus = work.ExtensionStatus;
            switch (actionType)
            {
                case 1://整理
                    work.ExtensionStatus = EExtensionStatus.Arrange;
                    break;
                case 2://保持
                    work.ExtensionStatus = EExtensionStatus.Hold;
                    break;
                default:
                    break;
            }
            _userCacheManager.SetWorkByUser(work);
        }

        /// <summary>
        /// 分机动作结束
        /// </summary>
        /// <returns></returns>
        [HttpGet("call-action-record-end")]
        public async Task CallActionRecordEnd(int actionType)
        {
            var work = _userCacheManager.GetWorkByUser(_sessionContext.RequiredUserId);
            if (work is null)
                throw UserFriendlyException.SameMessage("分机未签入，不能操作");

            if (actionType == 0)//小休
            {
                var telRest = await _telActionRecordRepository.GetAsync(x => x.TelNo == work.TelNo && x.ActionType == EActionType.TelRest && !x.EndTime.HasValue, HttpContext.RequestAborted);
                if (telRest is null)
                    throw UserFriendlyException.SameMessage("未查询到分机休息信息");
                else
                {
                    telRest.EndAction();
                    await _telActionRecordRepository.UpdateAsync(telRest);
                    work.OldExtensionStatus = work.ExtensionStatus;
                    work.ExtensionStatus = EExtensionStatus.Ready;
                    _userCacheManager.SetWorkByUser(work);
                }
                return;
            }

            var telAction = await _telActionRecordRepository.GetAsync(x => x.TelNo == work.TelNo && x.ActionType == (EActionType)actionType && !x.EndTime.HasValue, HttpContext.RequestAborted);
            if (telAction != null)
            {
                telAction.EndAction();
                await _telActionRecordRepository.UpdateAsync(telAction);
            }
            //动作结束成功，修改话机动作状态
            work.OldExtensionStatus = work.ExtensionStatus;
            switch (actionType)
            {
                case 1://整理
                    work.ExtensionStatus = EExtensionStatus.Arrange;
                    break;
                case 2://保持
                    work.ExtensionStatus = EExtensionStatus.Hold;
                    break;
                default:
                    break;
            }
            _userCacheManager.SetWorkByUser(work);
        }

        /// <summary>
        /// 查询当前用户的分机状态
        /// </summary>
        /// <returns></returns>
        [HttpGet("tel-state")]
        public Task<TrOnDutyResponseDto> GetTelState()
            => _callApplication.GetTelStateAsync(HttpContext.RequestAborted);

        /// <summary>
        /// 查询通话记录（固定数据量）
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("calls-fixed")]
        public async Task<List<CallNativeDto>> QueryCallsFixed([FromQuery] QueryCallsFixedDto dto)
            => await _callApplication.QueryCallsFixedAsync(dto, HttpContext.RequestAborted).ToPageListWithoutTotalAsync(dto, HttpContext.RequestAborted);

        /// <summary>
        /// 查询通话记录（固定数据量）
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("calls-fixed/count")]
        public async Task<int> QueryCallsFixedCount([FromQuery] QueryCallsFixedDto dto)
            => await _callApplication.QueryCallsFixedAsync(dto, HttpContext.RequestAborted).CountAsync(HttpContext.RequestAborted);

        /// <summary>
        /// 导出通话记录
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost("calls-fixed/export")]
        [LogFilterAlpha("导出日志")]
        public async Task<FileStreamResult> ExportOrders([FromBody] ExportExcelDto<QueryCallsFixedDto> dto)
        {
            var query = _callApplication.QueryCallsFixedAsync(dto.QueryDto, HttpContext.RequestAborted);
            List<CallNativeDto> callls;
            if (dto.IsExportAll)
            {
                callls = await query.ToListAsync(HttpContext.RequestAborted);
            }
            else
            {
                var (_, items) = await query.ToPagedListAsync(dto.QueryDto, HttpContext.RequestAborted);
                callls = items;
            }
            dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass<CallNativeDto>(dto.ColumnInfos);

            var dtos = callls
                .Select(stu => _mapper.Map(stu, typeof(CallNativeDto), dynamicClass))
                .Cast<object>()
                .ToList();

            var stream = ExcelHelper.CreateStream(dtos);

            return ExcelStreamResult(stream, "通话记录");
        }

        /// <summary>
        /// 查询通话记录
        /// </summary>
        /// <param name="callId"></param>
        /// <returns></returns>
        [HttpGet("{callId}")]
        public Task<List<CallNative>> GetCall(string callId)
        {
            //为兼容天润通话记录返回集合
            if (string.IsNullOrEmpty(callId)) return default;
            return _callApplication.GetCallListAsync(callId, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 通话记录基础数据
        /// </summary>
        /// <returns></returns>
        [HttpGet("base-data")]
        public object BaseData()
        {
            return new
            {
                Direction = EnumExts.GetDescriptions<ECallDirection>(),
                EndBy = EnumExts.GetDescriptions<EEndBy>(),
            };
        }

        /// <summary>
        /// 查询坐席操作记录(固定数据量)
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("tel-operations-fixed")]
        public async Task<IReadOnlyList<TelOperation>> QueryTelOperationsAsync([FromQuery] QueryTelOperationsFixedDto dto) =>
            await _callApplication.QueryTelOperationsAsync(dto).ToPageListWithoutTotalAsync(dto, HttpContext.RequestAborted);

        /// <summary>
        /// 查询坐席操作记录(固定数据量)
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("tel-operations-fixed/count")]
        public async Task<int> QueryTelOperationsCountAsync([FromQuery] QueryTelOperationsFixedDto dto) =>
            await _callApplication.QueryTelOperationsAsync(dto).CountAsync(HttpContext.RequestAborted);

        /// <summary>
        /// 查询坐席操作记录基础数据
        /// </summary>
        [HttpGet("base-data-tel-operation")]
        public object BaseDataTelOperation()
        {
            return new
            {
                Operations = _callApplication.GetTelOperationOptions()
            };
        }

        /// <summary>
        /// 通话转写
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost("calls/transliteration")]
        public async Task CallTransliteration([FromBody] CallTransliteration dto)
        {
            foreach (var id in dto.Ids)
            {
                var call = await _callApplication.GetTianrunCallAsync(id, HttpContext.RequestAborted);
                if (call is null)
                    throw UserFriendlyException.SameMessage("通话信息错误");
                if (call.TransliterationState == ECallTransliterationState.Underway)
                    throw UserFriendlyException.SameMessage("正在转写中,请勿重复点击，请稍作等待");
                if (call.TransliterationState == ECallTransliterationState.Succeed)
                    throw UserFriendlyException.SameMessage("转写成功，不能重新转写");
                call.InitTransliterationId();
                await _callApplication.EditTransliterationStateAsync(call.Id, ECallTransliterationState.Underway, call.TransliterationId, HttpContext.RequestAborted);
                var audioFile = call.RecordingAbsolutePath;
                var fromNo = call.CPN;
                var callStartTime = call.CreatedTime;
                var Id = call.TransliterationId;
                var setting = _systemSettingCacheManager.GetSetting(SettingConstants.ViteRecordPrefix);



                var handler = new AiQualityHandler()
                {
                    Id = Id,
                    Source = "AiAnswered",
                    AudioFile = audioFile,
                    FromNo = fromNo,
                    CallStartTime = callStartTime,
                    ViteRecordPrefix = setting?.SettingValue[0],
                };
                await _publisher.PublishAsync(new AiOrderQualityNotify(handler), PublishStrategy.ParallelNoWait, HttpContext.RequestAborted);
            }
        }

        #region 坐席动作类型统计

        /// <summary>
        /// 坐席动作类型统计
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("telaction/list")]
        public async Task<PagedDto<TelActionListXthx>> TelActionList([FromQuery] TelActionXthxDto dto)
        {
            var (total, items) = await _telOperationXthxRepository.Queryable()
                .WhereIF(string.IsNullOrEmpty(dto.TelNo) == false, x => x.TelNo.Contains(dto.TelNo))
                .WhereIF(dto.OperationStatus != null, x => x.OperationStatus == dto.OperationStatus)
                .WhereIF(string.IsNullOrEmpty(dto.UserName) == false, x => x.UserName.Contains(dto.UserName))
                .WhereIF(dto.StartTime.HasValue, x => x.StartTime >= dto.StartTime)
                .WhereIF(dto.EndTime.HasValue, x => x.StartTime <= dto.EndTime)
                .OrderByDescending(x => x.StartTime)
                .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
            return new PagedDto<TelActionListXthx>(total, _mapper.Map<IReadOnlyList<TelActionListXthx>>(items));
        }

        #endregion
    }
}