TEAMModelOS/TEAMModelOS.Extension/IES.Exam/IES.ExamServer/Controllers/ManageController.cs

using ICSharpCode.SharpZipLib.GZip;
using IES.ExamLibrary.Models;
using IES.ExamServer.DI;
using IES.ExamServer.DI.SignalRHost;
using IES.ExamServer.Filters;
using IES.ExamServer.Helper;
using IES.ExamServer.Helpers;
using IES.ExamServer.Models;
using IES.ExamServer.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Configuration;
using System;
using System.Diagnostics.Eventing.Reader;
using System.Linq.Expressions;
using System.Net.Http;
using System.Net.Http.Json;

using System.Security.Cryptography.X509Certificates;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.RegularExpressions;
using static IES.ExamServer.Services.ManageService;
using static System.Reflection.Metadata.BlobBuilder;

namespace IES.ExamServer.Controllers
{
    [ApiController]
    [Route("manage")]
    public class ManageController : BaseController
    {
        private readonly IConfiguration _configuration;
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly IMemoryCache _memoryCache;
        private readonly ILogger<ManageController> _logger;
        private readonly LiteDBFactory _liteDBFactory;
        private readonly CenterServiceConnectionService _connectionService;
        private readonly int DelayMicro = 10;//微观数据延迟
        private readonly int DelayMacro = 100;//宏观数据延迟
        private readonly IHubContext<SignalRExamServerHub> _signalRExamServerHub;
        public ManageController(LiteDBFactory liteDBFactory, ILogger<ManageController> logger, IConfiguration configuration,
            IHttpClientFactory httpClientFactory, IMemoryCache memoryCache, CenterServiceConnectionService connectionService, IHubContext<SignalRExamServerHub> signalRExamServerHub)
        {
            _logger = logger;
            _configuration=configuration;
            _httpClientFactory=httpClientFactory;
            _memoryCache=memoryCache;
            _liteDBFactory=liteDBFactory;
            _connectionService=connectionService;
            _signalRExamServerHub=signalRExamServerHub;
        }
        ///通过线上回传数据需要鉴权验证等操作。
        ///通过离线包回传数据需要加密操作

        /// <summary>
        /// 清理缓存，列出缓存占用空间，type =list列出，type=clear清理，不能清理近期及正在激活的数据，并且提示清理中暂未上传或者导出的数据。
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("clean-cache")]
        [AuthToken("admin", "teacher", "visitor")]
        public async Task<IActionResult> CleanCache(JsonNode json)
        {
            return Ok();
        }

        //C#.NET 6 后端与前端流式通信
        //https://www.doubao.com/chat/collection/687687510791426?type=Thread
        //下载日志记录：1.步骤，检查，2.获取描述信息，3.分类型，4下载文件，5.前端处理，6.返回结果 ， 正在下载...==> [INFO]https://www.doubao.com/chat/collection/687687510791426?type=Thread [Size=180kb] Ok...
        //进度条 展示下载文件总大小和已下载，末尾展示 文件总个数和已下载个数
        //https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/8.0.7/signalr.min.js
        /* int data = 0,blob=0, groupList=0
         {
            "evaluationId":"idssss",
            "shortCode":"1234567890",
            "ownerId":"hbcn/tmdid",
            "data":1,
            "blob":1,
            "groupList":1
        }
         */
        //如果要访问中心，则需要教师登录联网。  

        [HttpPost("download-package")]
        [AuthToken("admin", "teacher", "visitor")]
        public async Task<IActionResult> DownloadPackage(JsonNode json)
        {
            var token = GetAuthTokenInfo();

            //检查试卷文件完整性
            List<string> successMsgs = new List<string>();
            List<string> errorMsgs = new List<string>();
            EvaluationCheckFileResult result = new EvaluationCheckFileResult() { successMsgs=successMsgs, errorMsgs=errorMsgs };
            if (token.scope.Equals(ExamConstant.ScopeTeacher) || token.scope.Equals(ExamConstant.ScopeVisitor))
            {
                if (_connectionService.centerIsConnected)
                {
                    Teacher? teacher = _liteDBFactory.GetLiteDatabase().GetCollection<Teacher>().FindOne(x => x.id!.Equals(token.id));
                    string id = $"{json["evaluationId"]}";
                    string shortCode = $"{json["shortCode"]}";
                    string deviceId = $"{json["deviceId"]}";
                    EvaluationClient? evaluationClient = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().FindOne(x => x.id!.Equals(id) && x.shortCode!.Equals(shortCode));
                    if (teacher != null && evaluationClient!= null)
                    {
                        string? CenterUrl = _configuration.GetValue<string>("ExamServer:CenterUrl");
                        var client = _httpClientFactory.CreateClient();
                        if (client.DefaultRequestHeaders.Contains(Constant._X_Auth_AuthToken))
                        {
                            client.DefaultRequestHeaders.Remove(Constant._X_Auth_AuthToken);
                        }
                        client.DefaultRequestHeaders.Add(Constant._X_Auth_AuthToken, teacher.x_auth_token);
                        HttpResponseMessage message = await client.PostAsJsonAsync($"{CenterUrl}/blob/sas-read", new { containerName = $"{evaluationClient.ownerId}" });
                        string sas = string.Empty;
                        string url = string.Empty;
                        string cnt = string.Empty;
                        if (message.IsSuccessStatusCode)
                        {
                            //url  sas timeout name
                            string content = await message.Content.ReadAsStringAsync();
                            JsonNode? jsonNode = content.ToObject<JsonNode>();
                            if (jsonNode != null)
                            {
                                sas = $"{jsonNode["sas"]}";
                                cnt = $"{jsonNode["name"]}";
                                url = $"{jsonNode["url"]}";
                            }
                        }
                        var httpClient = _httpClientFactory.CreateClient();
                        string packagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "package");
                        string evaluationPath = Path.Combine(packagePath, evaluationClient.id!);
                        //删除文件夹
                        FileHelper.DeleteFolder(evaluationPath);
                        string evaluationDataPath = Path.Combine(evaluationPath, "data");
                        if (!Directory.Exists(evaluationDataPath))
                        {
                            Directory.CreateDirectory(evaluationDataPath);
                        }

                        string evaluationData = string.Empty;
                        {
                            //evaluation
                            string evaluationUrl = $"{url}/{cnt}/package/{json["evaluationId"]}/data/evaluation.json?{sas}";
                            HttpResponseMessage dataMessage = await httpClient.GetAsync(evaluationUrl);
                            if (dataMessage.IsSuccessStatusCode)
                            {
                                var content = await dataMessage.Content.ReadAsStringAsync();
                                evaluationData=content;
                                string path_evaluation = Path.Combine(evaluationDataPath, "evaluation.json");
                                await System.IO.File.WriteAllTextAsync(path_evaluation, content);
                                successMsgs.Add("评测信息文件evaluation.json文件下载成功！");
                            }
                            else
                            {
                                errorMsgs.Add("评测信息文件evaluation.json文件下载失败！");
                            }


                        }
                        {
                            //source.json
                            string sourceUrl = $"{url}/{cnt}/package/{json["evaluationId"]}/data/source.json?{sas}";
                            HttpResponseMessage dataMessage = await httpClient.GetAsync(sourceUrl);
                            if (dataMessage.IsSuccessStatusCode)
                            {
                                var content = await dataMessage.Content.ReadAsStringAsync();
                                string path_source = Path.Combine(evaluationDataPath, "source.json");
                                await System.IO.File.WriteAllTextAsync(path_source, content);
                                successMsgs.Add("评测数据原始文件source.json文件下载成功！");
                            }
                            else
                            {
                                errorMsgs.Add("评测数据原始文件source.json文件下载失败！");
                            }
                        }
                        {
                            //grouplist.json
                            string grouplistUrl = $"{url}/{cnt}/package/{json["evaluationId"]}/data/grouplist.json?{sas}";
                            HttpResponseMessage groupListMessage = await httpClient.GetAsync(grouplistUrl);
                            if (groupListMessage.IsSuccessStatusCode)
                            {
                                var content = await groupListMessage.Content.ReadAsStringAsync();
                                string path_groupList = Path.Combine(evaluationDataPath, "grouplist.json");
                                await System.IO.File.WriteAllTextAsync(path_groupList, content);
                                successMsgs.Add("评测名单grouplist.json文件下载成功！");
                            }
                            else
                            {
                                errorMsgs.Add("评测名单grouplist.json文件下载失败！");
                            }
                        }

                        {
                            //下载试卷文件
                            List<EvaluationExam>? evaluationExams = evaluationData.ToObject<JsonNode>()?["evaluationExams"]?.ToObject<List<EvaluationExam>>();
                            foreach (var evaluationExam in evaluationExams!)
                            {
                                foreach (var evaluationPaper in evaluationExam.papers)
                                {
                                    string path_paper = Path.Combine(evaluationPath, $"papers/{evaluationPaper.paperId}");
                                    if (!Directory.Exists(path_paper))
                                    {
                                        Directory.CreateDirectory(path_paper);
                                    }
                                    //最多开启10个线程并行下载
                                    var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = 20 };
                                    // 使用 Parallel.ForEachAsync 并行处理每个 blob
                                    await Parallel.ForEachAsync(evaluationPaper.blobs, parallelOptions, async (blob, cancellationToken) =>
                                    {
                                        try
                                        {
                                            // 下载 Blob 文件到本地
                                            HttpResponseMessage blobMessage = await httpClient.GetAsync($"{url}/{cnt}/{blob.path}?{sas}", cancellationToken);
                                            if (blobMessage.IsSuccessStatusCode)
                                            {
                                                byte[] bytes = await blobMessage.Content.ReadAsByteArrayAsync(cancellationToken);
                                                string? extension = Path.GetExtension(blob.path);
                                                if (extension!=null)
                                                {
                                                    if (extension.Equals(extension.ToUpper()))
                                                    {
                                                        string? fileNameWithoutExtension = Path.GetFileNameWithoutExtension(blob.path);
                                                        await System.IO.File.WriteAllBytesAsync(Path.Combine(path_paper, $"{fileNameWithoutExtension!}_1{extension}"), bytes, cancellationToken);
                                                    }
                                                    else
                                                    {
                                                        string? fileName = Path.GetFileName(blob.path);
                                                        await System.IO.File.WriteAllBytesAsync(Path.Combine(path_paper, fileName!), bytes, cancellationToken);
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                string? error = await blobMessage.Content.ReadAsStringAsync(cancellationToken);
                                                errorMsgs.Add($"{evaluationExam.subjectName},{evaluationPaper.paperName},{blob.path}文件下载失败，{blobMessage.StatusCode},{error}");
                                                // Console.WriteLine($"Error downloading {blob.path},{blobMessage.StatusCode},{error}");
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            errorMsgs.Add($"{evaluationExam.subjectName},{evaluationPaper.paperName},{blob.path}文件下载错误，{ex.Message}");
                                            // 处理异常
                                            //Console.WriteLine($"Error downloading {blob.path}: {ex.Message}");
                                        }
                                    });
                                }
                            }
                        }

                        (successMsgs, errorMsgs) = await ManageService.CheckFile(evaluationClient, successMsgs, errorMsgs, _signalRExamServerHub, _memoryCache, _logger, deviceId, evaluationPath);
                        //下载完成后，对数据进行检查，然后在加密压缩。
                        string zipPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "zip");
                        if (!Directory.Exists(zipPath))
                        {
                            Directory.CreateDirectory(zipPath);
                        }
                        string zipFilePath = Path.Combine(zipPath, $"{evaluationClient.id}-{evaluationClient.blobHash}.zip");
                        var zipInfo = ZipHelper.CreatePasswordProtectedZip(evaluationPath, zipFilePath, evaluationClient.openCode!);
                        if (zipInfo.res)
                        {
                            successMsgs.Add("评测数据压缩包创建成功！");
                        }
                        else {
                            errorMsgs.Add("评测数据压缩包创建失败！");
                        }

                    }
                    else
                    {
                        string teacherMsg = teacher==null ? "未找到教师信息" : "";
                        string evaluationMsg = evaluationClient==null ? "未找到评测信息" : "";
                        errorMsgs.Add($"用户信息或未找到评测信息！{teacherMsg}{evaluationMsg}");
                    }
                }
                else {
                    errorMsgs.Add($"云端数据中心未连接");
                }
            }
            else
            {
                errorMsgs.Add($"请使用教师或访客账号登录!");
            }
            result.checkError=result.errorMsgs.Count();
            result.checkSuccess=result.successMsgs.Count();
            result.checkTotal=result.checkSuccess+result.checkError;
            if (result.errorMsgs.Count()==0)
            {
                return Ok(new { code = 200, msg = "下载成功！", result });
            }
            else {
                return Ok(new { code = 1, msg = "下载失败！", result });
            }

        }

        /// <summary>
        /// 输入开卷码，查询评测信息，并返回数据。
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("open-evaluation")]
        [AuthToken("admin", "teacher", "visitor")]
        public async Task<IActionResult> OpenEvaluation(JsonNode json)
        {
            string deviceId = $"{json["deviceId"]}";
            string evaluationId = $"{json["evaluationId"]}";
            string openCode = $"{json["openCode"]}";
            var token = GetAuthTokenInfo();
            List<string> successMsgs = new List<string>();
            List<string> errorMsgs = new List<string>();
            EvaluationCheckFileResult result = new EvaluationCheckFileResult() { successMsgs=successMsgs, errorMsgs  =errorMsgs };
            if (!string.IsNullOrEmpty(openCode) &&  !string.IsNullOrEmpty(evaluationId))
            {
                EvaluationClient? evaluationLocal = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().FindOne(x => x.id!.Equals(evaluationId) && x.openCode!.Equals(openCode));
                if (evaluationLocal!=null)
                {

                    await _signalRExamServerHub.SendMessage(_memoryCache, _logger, deviceId, Constant._Message_grant_type_check_file,
                        new MessageContent { dataId=evaluationLocal.id, dataName=evaluationLocal.name, messageType=Constant._Message_type_message, status=0, content="开始检查评测信息文件.." });
                    //判断文件包的压缩包是否存在。
                    string zipPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "zip");
                    //校验本地文件数据
                    string packagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "package");
                    string evaluationPath = Path.Combine(packagePath, evaluationLocal.id!);
                    if (System.IO.File.Exists(Path.Combine(zipPath, $"{evaluationLocal.id}-{evaluationLocal.blobHash}.zip")))
                    {
                        successMsgs.Add("加载评测试卷文件包！");
                        //删除文件夹
                        FileHelper.DeleteFolder(evaluationPath);
                        if (!Directory.Exists(evaluationPath))
                        {
                            Directory.CreateDirectory(evaluationPath);
                        }
                        //解压文件包
                        var extractRes = ZipHelper.ExtractPasswordProtectedZip(Path.Combine(zipPath, $"{evaluationLocal.id}-{evaluationLocal.blobHash}.zip"), evaluationPath, evaluationLocal.openCode!);
                        if (extractRes.res)
                        {
                            successMsgs.Add("评测试卷文件包解压成功！");
                            (successMsgs, errorMsgs) =  await ManageService.CheckFile(evaluationLocal, successMsgs, errorMsgs, _signalRExamServerHub, _memoryCache, _logger, deviceId, evaluationPath);
                        }
                        else {
                            errorMsgs.Add("评测试卷文件包解压失败！");
                            //return Ok(new { code = 3, msg = "评测试卷文件包解压失败！" });
                        }
                    }
                    else {
                        errorMsgs.Add("评测试卷文件包不存在！");
                        //return Ok(new { code = 3, msg = "评测试卷文件包不存在！" });
                    }
                }
                else {
                    errorMsgs.Add("未找到评测信息！");
                    // return Ok(new { code = 2, msg = "未找到评测信息！" });
                }
            }
            else
            {
                errorMsgs.Add("评测ID或提取码均未填写！");
                // return Ok(new { code = 1, msg = "评测ID或提取码均未填写！" });
            }

            result.checkTotal = result.errorMsgs.Count() + result.successMsgs.Count();
            result.checkError= result.errorMsgs.Count();
            result.checkSuccess = result.successMsgs.Count();
            if (result.errorMsgs.Count()==0)
            {
                return Ok(new { code = 200, msg = "校验成功！", result });
            }
            else
            {
                return Ok(new { code = 1, msg = "校验失败！", result });
            }

        }

        [HttpPost("check-evaluation")]
        [AuthToken("admin", "teacher", "visitor")]
        public async Task<IActionResult> CheckEvaluation(JsonNode json)
        {
            string shortCode = $"{json["shortCode"]}";
            string evaluationId = $"{json["evaluationId"]}";
            string checkCenter = $"{json["checkCenter"]}";
            string deviceId = $"{json["deviceId"]}";
            string centerCode = string.Empty, centerMsg = string.Empty;
            Expression<Func<EvaluationClient, bool>> predicate = x => true;
            var token = GetAuthTokenInfo();

            if (!string.IsNullOrEmpty(shortCode) || !string.IsNullOrEmpty(evaluationId))
            {
                if (!string.IsNullOrEmpty(shortCode))
                {
                    predicate= predicate.And(x => !string.IsNullOrWhiteSpace(x.shortCode) && x.shortCode.Equals(shortCode));
                }
                if (!string.IsNullOrWhiteSpace(evaluationId))
                {
                    predicate= predicate.And(x => x.id!.Equals(evaluationId));
                }
            }
            else
            {
                return Ok(new { code = 400, msg = "评测ID或提取码均未填写！" });
            }
            IEnumerable<EvaluationClient>? evaluationClients = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().Find(predicate);
            EvaluationClient? evaluationLocal = null;
            EvaluationClient? evaluationCloud = null;
            if (evaluationClients!=null && evaluationClients.Count()>0)
            {
                evaluationLocal= evaluationClients.First();
            }
            List<string> successMsgs = new List<string>();
            List<string> errorMsgs = new List<string>();
            //从数据中心搜索
            if ("1".Equals($"{checkCenter}"))
            {
                if (_connectionService.centerIsConnected)
                {
                    if (token.scope.Equals(ExamConstant.ScopeTeacher) || token.scope.Equals(ExamConstant.ScopeVisitor))//由于已经绑定学校，访客教师也可以访问中心。
                    {
                        Teacher? teacher = _liteDBFactory.GetLiteDatabase().GetCollection<Teacher>().FindOne(x => x.id!.Equals(token.id));
                        if (teacher != null)
                        {
                            string? CenterUrl = _configuration.GetValue<string>("ExamServer:CenterUrl");
                            var client = _httpClientFactory.CreateClient();
                            if (client.DefaultRequestHeaders.Contains(Constant._X_Auth_AuthToken))
                            {
                                client.DefaultRequestHeaders.Remove(Constant._X_Auth_AuthToken);
                            }
                            client.DefaultRequestHeaders.Add(Constant._X_Auth_AuthToken, teacher.x_auth_token);
                            try
                            {
                                HttpResponseMessage message = await client.PostAsJsonAsync($"{CenterUrl}/evaluation-sync/find-sync-info", new { shortCode, evaluationId });
                                if (message.IsSuccessStatusCode)
                                {
                                    string content = await message.Content.ReadAsStringAsync();
                                    JsonNode? jsonNode = content.ToObject<JsonNode>();
                                    if (jsonNode != null)
                                    {
                                        centerCode = $"{jsonNode["code"]}";
                                        centerMsg = $"{jsonNode["msg"]}";
                                        if ($"{jsonNode["code"]}".Equals("200"))
                                        {
                                            evaluationCloud = jsonNode["evaluation"]?.ToObject<EvaluationClient>();
                                        }
                                    }
                                    else
                                    {
                                        centerCode = "500";
                                        centerMsg = "数据转换异常";
                                    }
                                }
                                else
                                {
                                    centerCode = $"{message.StatusCode}";
                                    centerMsg = "数据中心访问异常";
                                }
                            }
                            catch (Exception ex)
                            {
                                centerCode = $"500";
                                centerMsg = $"数据中心访问异常：{ex.Message}";
                            }
                        }
                        else
                        {
                            centerCode = $"401";
                            centerMsg = "当前登录账号未找到";
                        }
                    }
                }
                else
                {
                    centerCode = $"404";
                    centerMsg = "云端数据中心未连接";
                }
                if (centerCode.Equals("200"))
                {
                    successMsgs.Add($"云端数据检测结果：{centerMsg},状态：{centerCode}");
                }
                else
                {
                    errorMsgs.Add($"云端数据检测结果：{centerMsg},状态：{centerCode}");
                }

            }
            var checkDataResult = ManageService.CheckData(evaluationLocal, evaluationCloud, successMsgs, errorMsgs, _liteDBFactory);
            Dictionary<string, object?>? evaluation = null;
            if (evaluationLocal!=null)
            {
                string zipPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "zip");
                //判断文件包的压缩包是否存在。
                if (!System.IO.File.Exists(Path.Combine(zipPath, $"{evaluationLocal.id}-{evaluationLocal.blobHash}.zip")))
                {
                    checkDataResult.zip =1;
                    checkDataResult.blob=1;
                    checkDataResult.data=1;
                    checkDataResult.groupList=1;
                    checkDataResult.blobSize=evaluationLocal.blobSize;
                    checkDataResult.dataSize=evaluationLocal.dataSize;
                    checkDataResult.studentCount=evaluationLocal.studentCount;
                    errorMsgs.Add($"评测文件包压缩包不存在，需要重新下载评测！");

                }
                var properties = evaluationLocal.GetType().GetProperties();
                evaluation = new Dictionary<string, object?>();
                foreach (var property in properties)
                {
                    if (!property.Name.Equals("openCode"))
                    {
                        evaluation[property.Name] = property.GetValue(evaluationLocal);
                    }
                }
            }

            return Ok(new
            {
                code = 200,
                evaluation = evaluation,
                result = checkDataResult
            });
        }

        /// <summary>
        /// 获取当前评测的开考设置信息
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("load-evaluation-round-setting")]
        [AuthToken("admin", "teacher", "visitor")]
        public IActionResult LoadEvaluationRoundSetting(JsonNode json)
        {
            EvaluationClient? evaluationClient = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().FindOne(x => x.id!.Equals(json["evaluationId"]));
            EvaluationRoundSetting? setting = null;
            if (evaluationClient!=null)
            {
                if (string.IsNullOrWhiteSpace(evaluationClient.roundId))
                {
                    setting =  _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationRoundSetting>().FindOne(x => x.id!.Equals(evaluationClient.roundId));
                }

                if (setting!=null)
                {
                    return Ok(new
                    {
                        code = 200,
                        setting = setting
                    });
                }
                else
                {
                    return Ok(new { code = 2, msg = "未设置开考信息！" });
                }
            }
            else {
                return Ok(new { code = 1, msg = "未找到评测信息！" });
            }
        }
        /// <summary>
        /// 设置评测开考信息（本轮名单，计时规则等）
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("assign-student-paper")]
        [AuthToken("admin", "teacher", "visitor")]
        public IActionResult AssignStudentPaper(JsonNode json) 
        {
            return Ok();
        }

        /// <summary>
        /// 设置评测开考信息（本轮名单，计时规则等）
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("setting-evaluation-round")]
        [AuthToken("admin", "teacher", "visitor")]
        public IActionResult SettingEvaluationRound(JsonNode json)
        {
            EvaluationRoundSetting? setting = json.ToObject<EvaluationRoundSetting>();
            if (setting!=null)
            {
                EvaluationClient? evaluationClient = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().FindOne(x => x.id!.Equals(setting.evaluationId) && x.openCode!.Equals(json["openCode"])&& x.shortCode!.Equals(json["shortCode"]));
                if (evaluationClient!=null)
                {
                    IEnumerable<EvaluationClient> evaluationClients = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().Find(x => x.activate==1);
                    if (evaluationClients != null && evaluationClients.Count() > 0)
                    {
                        foreach (EvaluationClient item in evaluationClients)
                        {
                            item.activate = 0;
                            _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().Upsert(item);
                        }
                    }
                    /// 判断是否包含所有分组
                    bool isAllContained = setting.groupList.All(x => evaluationClient.grouplist.Any(y => y.id == x.id));
                    if (isAllContained)
                    {
                        evaluationClient.countdownType = setting.countdownType;
                        evaluationClient.countdown = setting.countdown;
                        evaluationClient.deadline = setting.deadline;
                        evaluationClient.startline = setting.startline;
                        evaluationClient.activate = setting.activate;
                        //增加排序,保证id的唯一性
                        setting.id=ShaHashHelper.GetSHA1($"{evaluationClient.id}_{string.Join("", setting.groupList.Select(x => x.id)).OrderBy(x => x)}");
                        setting.createTime= DateTimeOffset.Now.ToUnixTimeMilliseconds();
                        evaluationClient.roundId = setting.id;
                        _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationRoundSetting>().Upsert(setting);
                        _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().Upsert(evaluationClient);
                        return Ok(new { code = 200, msg = "操作成功！" });
                    }
                    else
                    {
                        return Ok(new { code = 3, msg = "开考名单不在当前评测中！" });
                    }
                }
                else { return Ok(new { code = 2, msg = "未找到评测，请确认评测ID、提取码、开卷码是否正确！" }); }
            }
            else
            {
                return Ok(new { code = 1, msg = "未完善设置信息！" });
            }
            
        }
       
        /// <summary>
        /// 加载本地的活动列表
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("list-local-evaluation")]
        [AuthToken("admin", "teacher", "visitor")]
        public IActionResult ListLocalEvaluation(JsonNode json) 
        {

            IEnumerable<EvaluationClient>? evaluationClients = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().FindAll().OrderByDescending(x=>x.activate).ThenByDescending(x=>x.stime);

            if (evaluationClients != null)
            {
                var result = evaluationClients.Select(client =>
                {
                    var properties = client.GetType().GetProperties();
                    var anonymousObject = new Dictionary<string, object?>();
                    foreach (var property in properties)
                    {
                        if (!property.Name.Equals("openCode"))
                        {
                            anonymousObject[property.Name] = property.GetValue(client);
                        }
                    }
                    return anonymousObject;
                });
                return Ok(new { code = 200, evaluation = result });
            }
            else {
                return Ok(new { code = 200, evaluation = new List<EvaluationClient>  ()});
            }
            
        }
    }
}