hotline/src/Hotline.Api/Controllers/Bi/BiCallController.cs

using Hotline.Application.ExportExcel;
using Hotline.Application.StatisticalReport;
using Hotline.Application.Systems;
using Hotline.Caching.Interfaces;
using Hotline.CallCenter.Calls;
using Hotline.CallCenter.Tels;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.CallCenter;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Dtos.TrCallCenter;
using Hotline.Share.Requests;
using Hotline.Tools;
using Hotline.Users;
using MapsterMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using System.Data;
using XF.Domain.Repository;

namespace Hotline.Api.Controllers.Bi;

/// <summary>
/// 话务报表
/// </summary>
public class BiCallController : BaseController
{
    private readonly IRepository<TrCallRecord> _trCallRecordRepository;
    private readonly BaseDataApplication _baseDataApplication;
    private readonly IRepository<User> _userRepository;
    private readonly IRepository<TelRest> _telRestRepository;
    private readonly IMapper _mapper;
    private readonly ISystemSettingCacheManager _systemSettingCacheManager;
    private readonly IRepository<Work> _workRepository;
    private readonly ISystemDicDataCacheManager _sysDicDataCacheManager;
    private readonly ICallReportApplication _callReportApplication;
    private readonly IExportApplication _exportApplication;



    public BiCallController(
        IRepository<TrCallRecord> trCallRecordRepository,
        IRepository<User> userRepository,
        IRepository<TelRest> telRestRepository,
        IMapper mapper,
        ISystemSettingCacheManager systemSettingCacheManager,
        ISystemDicDataCacheManager sysDicDataCacheManager,
        IRepository<Work> workRepository,
        ICallReportApplication callReportApplication,
        IExportApplication exportApplication,
        BaseDataApplication baseDataApplication)
    {
        _trCallRecordRepository = trCallRecordRepository;
        _userRepository = userRepository;
        _telRestRepository = telRestRepository;
        _mapper = mapper;
        _systemSettingCacheManager = systemSettingCacheManager;
        _workRepository = workRepository;
        _sysDicDataCacheManager = sysDicDataCacheManager;
        _callReportApplication = callReportApplication;
        _exportApplication = exportApplication;
        _baseDataApplication = baseDataApplication;
    }

    /// <summary>
    /// 话务统计分析
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("calls")]
    [AllowAnonymous]
    public async Task<List<BiCallDto>> QueryCallsAsync([FromQuery] BiQueryCallsDto dto)
        => await _callReportApplication.QueryCallsAsync(dto, HttpContext.RequestAborted);

    /// <summary>
    /// 话务统计分析---导出
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("calls_export")]
    [AllowAnonymous]
    public async Task<FileStreamResult> ExportQueryCallsAsync([FromBody] ExportExcelDto<BiQueryCallsDto> dto)
        => ExcelStreamResult(
            await _exportApplication.FittingAsync(
                dto,
                await _callReportApplication.QueryCallsAsync(dto.QueryDto, HttpContext.RequestAborted),
                list =>
                {
                    list.Add(new BiCallDto()
                    {
                        HourRange = "合计",
                        Hour = 13,
                        Total = list.Sum(p => p.Total),
                        Answered = list.Sum(p => p.Answered),
                        Hanguped = list.Sum(p => p.Hanguped)
                    });
                }),
            "话务统计分析");

    /// <summary>
    /// 话务日期明细
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("query_calls_detail")]
    public async Task<object> QueryCallsDetailAsync([FromQuery] BiQueryCallsDto dto)
    {
        var items = await _callReportApplication.QueryCallsDetailAsync(dto);

        var total = new QueryCallsDetailDto
        {
            Date = "合计",
            Hour = "",
            InTotal = items.Sum(p => p.InTotal),
            InConnectionQuantity = items.Sum(p => p.InConnectionQuantity),
            NotAcceptedHang = items.Sum(p => p.NotAcceptedHang),
            TotalDurationIncomingCalls = items.Sum(p => p.TotalDurationIncomingCalls),
            InAvailableAnswer = items.Sum(p => p.InAvailableAnswer),
            InHangupImmediateWhenAnswered = items.Sum(p => p.InHangupImmediateWhenAnswered),
            TimeoutConnection = items.Sum(p => p.TimeoutConnection),
            TimeoutSuspension = items.Sum(p => p.TimeoutSuspension),
            QueueByeCount = items.Sum(p => p.QueueByeCount),
            IvrByeCount = items.Sum(p => p.IvrByeCount),
            OutTotal = items.Sum(p => p.OutTotal),
            OutConnectionQuantity = items.Sum(p => p.OutConnectionQuantity)
        };

        return new { List = items, Total = total };

    }

    /// <summary>
    /// 话务日期明细--导出
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("query_calls_detail_export")]
    public async Task<FileStreamResult> QueryCallsDetailExportAsync([FromBody] ExportExcelDto<BiQueryCallsDto> dto)
    {
        return ExcelStreamResult(
            await _exportApplication.FittingAsync(
                dto,
                await _callReportApplication.QueryCallsDetailAsync(dto.QueryDto),
                items =>
                {
                    var total = new QueryCallsDetailDto
                    {
                        Date = "合计",
                        Hour = "",
                        InTotal = items.Sum(p => p.InTotal),
                        InConnectionQuantity = items.Sum(p => p.InConnectionQuantity),
                        NotAcceptedHang = items.Sum(p => p.NotAcceptedHang),
                        TotalDurationIncomingCalls = items.Sum(p => p.TotalDurationIncomingCalls),
                        InAvailableAnswer = items.Sum(p => p.InAvailableAnswer),
                        InHangupImmediateWhenAnswered = items.Sum(p => p.InHangupImmediateWhenAnswered),
                        TimeoutConnection = items.Sum(p => p.TimeoutConnection),
                        TimeoutSuspension = items.Sum(p => p.TimeoutSuspension),
                        QueueByeCount = items.Sum(p => p.QueueByeCount),
                        IvrByeCount = items.Sum(p => p.IvrByeCount),
                        OutTotal = items.Sum(p => p.OutTotal),
                        OutConnectionQuantity = items.Sum(p => p.OutConnectionQuantity)
                    };
                    items.Add(total);
                }
                )
            , "话务日期明细数据");

    }

    /// <summary>
    /// 话务日期明细--呼入明细
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("query_incall_calls_list")]
    public async Task<PagedDto<CallRecordOutDto>> GetInCallCallListAsync([FromQuery] BiQueryCallsDto dto)
    {
        var (total, items) = await _callReportApplication.QueryCallsDetailInTotalAsync(dto, false);
        return new PagedDto<CallRecordOutDto>(total, items);
    }

    /// <summary>
    /// 话务日期明细----导出
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("query_incall_calls_list_export")]
    public async Task<FileStreamResult> GetInCallCallListExportAsync([FromBody] ExportExcelDto<BiQueryCallsDto> dto)
    {
        var (total, data) = await _callReportApplication.QueryCallsDetailInTotalAsync(dto.QueryDto, dto.IsExportAll);

        dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass(dto.ColumnInfos);

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

        var stream = ExcelHelper.CreateStream(dtos);


        return ExcelStreamResult(
            await _exportApplication.FittingAsync(
            dto,
            (await _callReportApplication.QueryCallsDetailInTotalAsync(dto.QueryDto, dto.IsExportAll)).Item2
            ),
            dto.QueryDto.TypeCode == "2" ? "话务日期-接通明细数据" : "话务日期-总量明细数据");

    }

    /// <summary>
    /// 话务日期明细--时间段
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("query_calls_hour_detail_list")]
    public async Task<TotalList<QueryCallsDetailDto>> QueryCallsHourDetailListAsync([FromQuery] BiQueryCallsDto dto)
    {
        var items = await _callReportApplication.QueryCallsHourDetailAsync(dto, HttpContext.RequestAborted);
        var total = new QueryCallsDetailDto
        {
            Date = "",
            Hour = "合计",
            InTotal = items.Sum(p => p.InTotal),
            InConnectionQuantity = items.Sum(p => p.InConnectionQuantity),
            NotAcceptedHang = items.Sum(p => p.NotAcceptedHang),
            TotalDurationIncomingCalls = items.Sum(p => p.TotalDurationIncomingCalls),
            InAvailableAnswer = items.Sum(p => p.InAvailableAnswer),
            InHangupImmediateWhenAnswered = items.Sum(p => p.InHangupImmediateWhenAnswered),
            TimeoutConnection = items.Sum(p => p.TimeoutConnection),
            TimeoutSuspension = items.Sum(p => p.TimeoutSuspension),
            QueueByeCount = items.Sum(p => p.QueueByeCount),
            IvrByeCount = items.Sum(p => p.IvrByeCount),
            OutTotal = items.Sum(p => p.OutTotal),
            OutConnectionQuantity = items.Sum(p => p.OutConnectionQuantity)
        };

        return new TotalList<QueryCallsDetailDto>(items, total);

    }

    /// <summary>
    /// 话务日期明细--时间段--导出
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("query_calls_hour_detail_list_export")]
    public async Task<FileStreamResult> QueryCallsHourDetailListExportAsync([FromBody] ExportExcelDto<BiQueryCallsDto> dto)
        => ExcelStreamResult(
            await _exportApplication.FittingAsync(
                dto,
                await _callReportApplication.QueryCallsHourDetailAsync(dto.QueryDto, HttpContext.RequestAborted),
                items =>
                {
                    var total = new QueryCallsDetailDto
                    {
                        Date = "",
                        Hour = "合计",
                        InTotal = items.Sum(p => p.InTotal),
                        InConnectionQuantity = items.Sum(p => p.InConnectionQuantity),
                        NotAcceptedHang = items.Sum(p => p.NotAcceptedHang),
                        TotalDurationIncomingCalls = items.Sum(p => p.TotalDurationIncomingCalls),
                        InAvailableAnswer = items.Sum(p => p.InAvailableAnswer),
                        InHangupImmediateWhenAnswered = items.Sum(p => p.InHangupImmediateWhenAnswered),
                        TimeoutConnection = items.Sum(p => p.TimeoutConnection),
                        TimeoutSuspension = items.Sum(p => p.TimeoutSuspension),
                        QueueByeCount = items.Sum(p => p.QueueByeCount),
                        IvrByeCount = items.Sum(p => p.IvrByeCount),
                        OutTotal = items.Sum(p => p.OutTotal),
                        OutConnectionQuantity = items.Sum(p => p.OutConnectionQuantity)
                    };
                    items.Add(total);
                })
            , "话务日期明细-时间段");


    /// <summary>
    /// 坐席话务统计分析
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("seats/export")]
    public async Task<FileStreamResult> ExportSeatss([FromBody] ExportExcelDto<ReportRequiredPagedRequest> dto)
    {
        return ExcelStreamResult(
            await _exportApplication.FittingAsync(
                dto,
                await _callReportApplication.QuerySeatCallAsync(dto.QueryDto, HttpContext.RequestAborted),
                list =>
                {
                    list.Add(new BiSeatCallsDto()
                    {
                        Name = "合计",
                        InTotal = list.Sum(p => p.InTotal),
                        InAnswered = list.Sum(p => p.InAnswered),
                        InHangupImmediate = list.Sum(p => p.InHangupImmediate),
                        InHanguped = list.Sum(m => m.InHanguped),
                        OutDurationAvg = list.Sum(m => m.OutDurationAvg),
                        InAvailableAnswer = list.Sum(m => m.InAvailableAnswer),
                        InHangupImmediateWhenAnswered = list.Sum(m => m.InHangupImmediateWhenAnswered),
                        OutTotal = list.Sum(m => m.OutTotal),
                        OutAnswered = list.Sum(m => m.OutAnswered),
                        LoginDuration = list.Sum(m => m.LoginDuration),
                        RestDuration = list.Sum(m => m.RestDuration),
                        InDurationAvg = list.Sum(m => m.InDurationAvg)
                    });
                })
            , "坐席话务统计分析");
    }

    /// <summary>
    /// 坐席话务统计分析
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("seats")]
    [AllowAnonymous]
    public async Task<IReadOnlyList<BiSeatCallsDto>> QuerySeatCallsAsync([FromQuery] ReportRequiredPagedRequest dto)
        => await _callReportApplication.QuerySeatCallAsync(dto, HttpContext.RequestAborted);

    /// <summary>
    /// 小休统计
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("rests")]
    [AllowAnonymous]
    public async Task<IReadOnlyList<BiSeatRestDto>> QuerySeatRest([FromQuery] QuerySeatRestRequest dto)
    {
        return await _telRestRepository.Queryable()
            .WhereIF(!string.IsNullOrEmpty(dto.UserName), x => x.UserName.Contains(dto.UserName))
            .WhereIF(!string.IsNullOrEmpty(dto.StaffNo), x => x.StaffNo.Contains(dto.StaffNo))
            .Where(x => x.CreationTime >= dto.StartTime)
            .Where(x => x.CreationTime <= dto.EndTime)
            .GroupBy(x => new { x.UserId, x.StaffNo, x.UserName })
            .Select(x => new BiSeatRestDto
            {
                UserId = x.UserId,
                StaffNo = x.StaffNo,
                UserName = x.UserName,
                RestCount = SqlFunc.AggregateCount(x.Id),
                RestDuration = SqlFunc.AggregateSum(x.RestDuration / 60) / SqlFunc.AggregateCount(x.Id),
                CumulativeDuration = SqlFunc.AggregateSum(x.RestDuration / 60)
            })
            .OrderByIF(dto.SortRule is 0, a => a.RestDuration, OrderByType.Asc)
            .OrderByIF(dto.SortRule is 1, a => a.RestDuration, OrderByType.Desc)
            .MergeTable()
            .ToListAsync(HttpContext.RequestAborted);
    }

    /// <summary>
    /// 坐席转接统计
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("seatswitch")]
    [AllowAnonymous]
    public async Task<PagedDto<BiSeatSwitchDto>> QuerySeatSwitch([FromQuery] QuerySeatSwitchRequest dto)
    {
        var (total, items) = await _callReportApplication.QuerySeatSwitchAsync(dto, HttpContext.RequestAborted);
        return new PagedDto<BiSeatSwitchDto>(total, items);
    }

    /// <summary>
    /// 小时统计
    /// </summary>
    /// <returns></returns>
    [HttpGet("hourcall")]
    [AllowAnonymous]
    public async Task<List<TrCallHourDto>> QueryHourCall([FromQuery] BiQueryHourCallDto dto)
        => await _callReportApplication.GetCallHourListAsync(dto, HttpContext.RequestAborted);

    /// <summary>
    /// 小时统计--导出
    /// </summary>
    /// <returns></returns>
    [HttpPost("hourcall/export")]
    [AllowAnonymous]
    public async Task<FileStreamResult> ExportQueryHourCall([FromBody] ExportExcelDto<BiQueryHourCallDto> dto)
        => ExcelStreamResult(
            await _exportApplication.FittingAsync(
                dto,
                await _callReportApplication.GetCallHourListAsync(dto.QueryDto, HttpContext.RequestAborted),
                list =>
                {
                    list.Add(new TrCallHourDto()
                    {
                        HourTo = "合计",
                        EffectiveCount = list.Sum(p => p.EffectiveCount),
                        ConnectByeCount = list.Sum(p => p.ConnectByeCount),
                        NoConnectByeCount = list.Sum(p => p.NoConnectByeCount),
                        QueueByeCount = list.Sum(m => m.QueueByeCount),
                        IvrByeCount = list.Sum(m => m.IvrByeCount)
                    });
                })
            , "通话时段分析");


    /// <summary>
    /// 通话时段统计明细
    /// </summary>
    /// <returns></returns>
    [HttpGet("hourcall_list")]
    public async Task<object> QueryCallList([FromQuery] QueryCallListDto dto)
        => await _callReportApplication.GetCallListAsync(dto, HttpContext.RequestAborted);

    /// <summary>
    /// 通话时段统计明细获取基本信息
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("hourcall_list_base")]
    public async Task<object> ReTransactBaseData()
        => _baseDataApplication
        .CallForwardingType()
        .CallForwardingSource()
        .Build();

    /// <summary>
    /// 热线号码统计
    /// </summary>
    /// <param name="StartTime"></param>
    /// <param name="EndTime"></param>
    /// <returns></returns>
    [AllowAnonymous]
    [HttpGet("gateway-query")]
    public async Task<List<CallHotLineDto>> QueryGateWay([FromQuery] BiQueryGateWayDto dto)
        => await _callReportApplication.GetCallHotLineListAsync(dto, HttpContext.RequestAborted);

    /// <summary>
    /// 热线号码统计导出
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("gateway-query/export")]
    public async Task<FileStreamResult> ExportQueryGatetWay(ExportExcelDto<BiQueryGateWayDto> dto)
        => ExcelStreamResult(
            await _exportApplication.FittingAsync(
                dto,
                await _callReportApplication.GetCallHotLineListAsync(dto.QueryDto, HttpContext.RequestAborted)
                )
            , "热线号码统计");
}