LqTrainingCheckinService.cs 14.5 KB
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using NCC.ClayObject;
using NCC.Common.Configuration;
using NCC.Common.Core.Manager;
using NCC.Common.Enum;
using NCC.Common.Extension;
using NCC.Common.Filter;
using NCC.Common.Helper;
using NCC.Common.Model.NPOI;
using NCC.DataEncryption;
using NCC.Dependency;
using NCC.DynamicApiController;
using NCC.Extend.Entitys.Dto.LqTrainingCheckin;
using NCC.Extend.Entitys.Enum;
using NCC.Extend.Entitys.lq_training_checkin_record;
using NCC.Extend.Entitys.lq_training_checkin_token;
using NCC.Extend.Helpers;
using NCC.Extend.Interfaces.BusinessOperationLog;
using NCC.FriendlyException;
using NCC.JsonSerialization;
using SqlSugar;
using Yitter.IdGenerator;

namespace NCC.Extend
{
    /// <summary>
    /// 培训签到(动态二维码 + 匿名打卡 + 管理端列表导出)
    /// </summary>
    [ApiDescriptionSettings(Tag = "培训签到", Name = "LqTrainingCheckin", Order = 212)]
    [Route("api/Extend/LqTrainingCheckin")]
    public class LqTrainingCheckinService : IDynamicApiController, ITransient
    {
        private const string BizLogModule = "培训签到";
        private const string BizTypeRecord = "lq_training_checkin_record";

        private readonly ISqlSugarClient _db;
        private readonly IUserManager _userManager;
        private readonly IBusinessOperationLogService _businessOperationLogService;

        /// <summary>
        /// 初始化培训签到服务
        /// </summary>
        public LqTrainingCheckinService(
            ISqlSugarClient db,
            IUserManager userManager,
            IBusinessOperationLogService businessOperationLogService)
        {
            _db = db;
            _userManager = userManager;
            _businessOperationLogService = businessOperationLogService;
        }

        #region 公开接口

        /// <summary>
        /// 获取培训签到投屏信息(当前二维码令牌)
        /// </summary>
        /// <remarks>
        /// 教室门口投屏页轮询调用,返回当前有效动态令牌及过期时间;令牌过期后服务端会自动轮换。
        ///
        /// 示例请求:
        /// ```json
        /// {}
        /// ```
        ///
        /// 参数说明:无
        /// </remarks>
        /// <returns>当前令牌与轮换配置</returns>
        /// <response code="200">成功</response>
        [AllowAnonymous]
        [HttpGet("GetDisplayInfo")]
        public async Task<LqTrainingCheckinDisplayInfoOutput> GetDisplayInfoAsync()
        {
            var now = DateTime.Now;
            var rotateMinutes = await TrainingCheckinHelper.GetRotateMinutesAsync(_db);
            var (plainToken, tokenEntity) = await EnsureCurrentTokenAsync(rotateMinutes, now);
            return new LqTrainingCheckinDisplayInfoOutput
            {
                token = plainToken,
                expireAt = tokenEntity.ExpireTime,
                serverTime = now,
                rotateMinutes = rotateMinutes
            };
        }

        /// <summary>
        /// 校验培训签到动态令牌
        /// </summary>
        /// <remarks>
        /// 扫码打开打卡页时调用,令牌无效或过期则不可打卡。
        ///
        /// 示例请求:
        /// `GET .../ValidateToken?token=xxx`
        ///
        /// 参数说明:
        /// - token: 二维码中的动态令牌
        /// </remarks>
        /// <param name="token">动态令牌</param>
        /// <returns>是否有效</returns>
        /// <response code="200">校验完成</response>
        [AllowAnonymous]
        [HttpGet("ValidateToken")]
        public async Task<LqTrainingCheckinValidateTokenOutput> ValidateTokenAsync([FromQuery] string token)
        {
            var valid = await IsTokenValidAsync(token, DateTime.Now);
            return new LqTrainingCheckinValidateTokenOutput
            {
                valid = valid,
                message = valid ? "令牌有效" : "签到码已失效,请重新扫码"
            };
        }

        /// <summary>
        /// 匿名提交培训签到/签退
        /// </summary>
        /// <remarks>
        /// 校验动态令牌、姓名与手机号后写入打卡记录,不做场次与人员关联校验。
        ///
        /// 示例请求:
        /// ```json
        /// {
        ///   "token": "动态令牌",
        ///   "realName": "张三",
        ///   "mobilePhone": "13800138000",
        ///   "checkinType": 1
        /// }
        /// ```
        ///
        /// 参数说明:
        /// - checkinType: 1=签到,2=签退
        /// </remarks>
        /// <param name="input">打卡数据</param>
        /// <returns>打卡结果</returns>
        /// <response code="200">提交成功</response>
        /// <response code="400">校验失败</response>
        [AllowAnonymous]
        [HttpPost("Submit")]
        public async Task<LqTrainingCheckinSubmitOutput> SubmitAsync([FromBody] LqTrainingCheckinSubmitInput input)
        {
            TrainingCheckinHelper.ValidateSubmitInput(input);
            var now = DateTime.Now;
            var tokenEntity = await ResolveValidTokenEntityAsync(input.token, now);
            if (tokenEntity == null)
                throw NCCException.Oh("签到码已失效,请重新扫码");

            var (submitIp, _) = TrainingCheckinHelper.ResolveSubmitClient();
            var realName = TrainingCheckinHelper.NormalizeRealName(input.realName);
            var mobile = TrainingCheckinHelper.NormalizeMobile(input.mobilePhone);
            var typeName = TrainingCheckinHelper.GetCheckinTypeName(input.checkinType);

            var entity = new LqTrainingCheckinRecordEntity
            {
                Id = YitIdHelper.NextId().ToString(),
                RealName = realName,
                MobilePhone = mobile,
                CheckinType = input.checkinType,
                CheckinTime = now,
                SubmitIp = submitIp,
                TokenId = tokenEntity.Id,
                CreateTime = now
            };

            var ok = await _db.Insertable(entity).ExecuteCommandAsync();
            if (ok <= 0)
                throw NCCException.Oh("打卡失败,请稍后重试");

            return new LqTrainingCheckinSubmitOutput
            {
                id = entity.Id,
                checkinTypeName = typeName,
                checkinTime = entity.CheckinTime,
                message = $"{typeName}成功"
            };
        }

        #endregion

        #region 管理端

        /// <summary>
        /// 分页查询培训签到记录
        /// </summary>
        /// <param name="input">筛选与分页参数</param>
        /// <returns>分页列表</returns>
        [HttpGet("GetList")]
        public async Task<dynamic> GetListAsync([FromQuery] LqTrainingCheckinListQueryInput input)
        {
            var sidx = string.IsNullOrWhiteSpace(input.sidx) ? "checkinTime" : input.sidx;
            var query = BuildListQuery(input);
            var data = await query
                .Select(it => new LqTrainingCheckinListOutput
                {
                    id = it.Id,
                    realName = it.RealName,
                    mobilePhone = it.MobilePhone,
                    checkinType = it.CheckinType,
                    checkinTypeName = SqlFunc.IIF(it.CheckinType == (int)TrainingCheckinTypeEnum.签到, "签到", "签退"),
                    checkinTime = it.CheckinTime,
                    submitIp = it.SubmitIp
                })
                .MergeTable()
                .OrderBy(sidx + " " + input.sort)
                .ToPagedListAsync(input.currentPage, input.pageSize);

            return PageResult<LqTrainingCheckinListOutput>.SqlSugarPageResult(data);
        }

        /// <summary>
        /// 导出培训签到记录
        /// </summary>
        /// <param name="input">筛选与导出列参数</param>
        /// <returns>下载地址</returns>
        [HttpGet("Actions/Export")]
        public async Task<dynamic> ExportAsync([FromQuery] LqTrainingCheckinListQueryInput input)
        {
            _ = await _userManager.GetUserInfo();
            var exportData = new List<LqTrainingCheckinListOutput>();
            if (input.dataType == 0)
            {
                var data = Clay.Object(await GetListAsync(input));
                exportData = data.Solidify<PageResult<LqTrainingCheckinListOutput>>().list;
            }
            else
            {
                exportData = await GetNoPagingListAsync(input);
            }

            var paramList = "[{\"value\":\"姓名\",\"field\":\"realName\"},{\"value\":\"手机号\",\"field\":\"mobilePhone\"},{\"value\":\"类型\",\"field\":\"checkinTypeName\"},{\"value\":\"打卡时间\",\"field\":\"checkinTime\"},{\"value\":\"提交IP\",\"field\":\"submitIp\"}]"
                .ToList<ParamsModel>();
            var excelconfig = new ExcelConfig
            {
                FileName = $"培训签到记录_{DateTime.Now:yyyyMMddHHmmss}.xls",
                HeadFont = "微软雅黑",
                HeadPoint = 10,
                IsAllSizeColumn = true,
                ColumnModel = new List<ExcelColumnModel>()
            };

            var selectKeyList = (input.selectKey ?? string.Empty).Split(',').ToList();
            foreach (var item in selectKeyList)
            {
                var isExist = paramList.Find(p => p.field == item);
                if (isExist != null)
                {
                    excelconfig.ColumnModel.Add(new ExcelColumnModel { Column = isExist.field, ExcelColumn = isExist.value });
                }
            }

            var addPath = FileVariable.TemporaryFilePath + excelconfig.FileName;
            ExcelExportHelper<LqTrainingCheckinListOutput>.Export(exportData, excelconfig, addPath);
            var fileName = _userManager.UserId + "|" + addPath + "|xls";
            var output = new
            {
                name = excelconfig.FileName,
                url = "/api/File/Download?encryption=" + DESCEncryption.Encrypt(fileName, "NCC")
            };

            await TryWriteLogAsync(
                "导出培训签到",
                null,
                $"导出培训签到记录,共 {exportData.Count} 条",
                new
                {
                    filters = new { input.keyword, input.checkinType, input.startTime, input.endTime, input.dataType },
                    rowCount = exportData.Count,
                    fileName = excelconfig.FileName
                }.Serialize());

            return output;
        }

        #endregion

        #region 私有方法

        [NonAction]
        private async Task<List<LqTrainingCheckinListOutput>> GetNoPagingListAsync(LqTrainingCheckinListQueryInput input)
        {
            var sidx = string.IsNullOrWhiteSpace(input.sidx) ? "checkinTime" : input.sidx;
            return await BuildListQuery(input)
                .Select(it => new LqTrainingCheckinListOutput
                {
                    id = it.Id,
                    realName = it.RealName,
                    mobilePhone = it.MobilePhone,
                    checkinType = it.CheckinType,
                    checkinTypeName = SqlFunc.IIF(it.CheckinType == (int)TrainingCheckinTypeEnum.签到, "签到", "签退"),
                    checkinTime = it.CheckinTime,
                    submitIp = it.SubmitIp
                })
                .MergeTable()
                .OrderBy(sidx + " " + input.sort)
                .ToListAsync();
        }

        private ISugarQueryable<LqTrainingCheckinRecordEntity> BuildListQuery(LqTrainingCheckinListQueryInput input)
        {
            DateTime? start = ParseDateTime(input.startTime);
            DateTime? end = ParseDateTime(input.endTime);
            var keyword = (input.keyword ?? string.Empty).Trim();

            return _db.Queryable<LqTrainingCheckinRecordEntity>()
                .WhereIF(!string.IsNullOrEmpty(keyword), it => it.RealName.Contains(keyword) || it.MobilePhone.Contains(keyword))
                .WhereIF(input.checkinType.HasValue, it => it.CheckinType == input.checkinType.Value)
                .WhereIF(start.HasValue, it => it.CheckinTime >= start.Value)
                .WhereIF(end.HasValue, it => it.CheckinTime <= end.Value);
        }

        private static DateTime? ParseDateTime(string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return null;
            return DateTime.TryParse(value.Trim(), out var dt) ? dt : (DateTime?)null;
        }

        private async Task<(string plainToken, LqTrainingCheckinTokenEntity entity)> EnsureCurrentTokenAsync(int rotateMinutes, DateTime now)
        {
            var current = await _db.Queryable<LqTrainingCheckinTokenEntity>()
                .Where(x => x.ExpireTime > now)
                .OrderBy(x => x.CreateTime, OrderByType.Desc)
                .FirstAsync();

            if (current != null && !string.IsNullOrWhiteSpace(current.PlainToken))
                return (current.PlainToken, current);

            var (plainToken, tokenEntity) = TrainingCheckinHelper.CreateTokenEntity(rotateMinutes, now);
            var ok = await _db.Insertable(tokenEntity).ExecuteCommandAsync();
            if (ok <= 0)
                throw NCCException.Oh("生成签到码失败,请稍后重试");

            return (plainToken, tokenEntity);
        }

        private async Task<bool> IsTokenValidAsync(string plainToken, DateTime now)
        {
            var entity = await ResolveValidTokenEntityAsync(plainToken, now);
            return entity != null;
        }

        private async Task<LqTrainingCheckinTokenEntity> ResolveValidTokenEntityAsync(string plainToken, DateTime now)
        {
            if (string.IsNullOrWhiteSpace(plainToken))
                return null;

            var hash = TrainingCheckinHelper.ComputeTokenHash(plainToken);
            return await _db.Queryable<LqTrainingCheckinTokenEntity>()
                .Where(x => x.TokenHash == hash && x.ExpireTime > now)
                .FirstAsync();
        }

        private async Task TryWriteLogAsync(string actionCode, string bizId, string summary, string detailJson)
        {
            try
            {
                await _businessOperationLogService.WriteAsync(
                    BizLogModule,
                    actionCode,
                    BizTypeRecord,
                    bizId,
                    summary,
                    detailJson);
            }
            catch
            {
                // 写日志失败不拖垮主业务
            }
        }

        #endregion
    }
}