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>
        /// 导出数据
        ///通过线上回传数据需要鉴权验证等操作。
        ///通过离线包回传数据需要加密操作
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("export-evaluation-result")]
        [AuthToken("admin", "teacher", "visitor")]
        public async Task<IActionResult> ExportEvaluationResult(JsonNode json) 
        {
            string id = $"{json["evaluationId"]}";
            string shortCode = $"{json["shortCode"]}";
            string openCode = $"{json["openCode"]}";
            string deviceId = $"{json["deviceId"]}";
            EvaluationClient? evaluationClient = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>()
                .FindOne(x => x.id!.Equals(id) && x.openCode!.Equals(openCode)&& x.shortCode!.Equals(shortCode));
            return Ok();
        }
        /// <summary>
        /// 手动推送
        ///通过线上回传数据需要鉴权验证等操作。
        ///通过离线包回传数据需要加密操作
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("manual-push")]
        [AuthToken("admin", "teacher", "visitor")]
        public async Task<IActionResult> ManualPush(JsonNode json)
        {
            string id = $"{json["evaluationId"]}";
            string shortCode = $"{json["shortCode"]}";
            string openCode = $"{json["openCode"]}";
            string deviceId = $"{json["deviceId"]}";
            EvaluationClient? evaluationClient = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>()
                .FindOne(x => x.id!.Equals(id) && x.openCode!.Equals(openCode)&& x.shortCode!.Equals(shortCode));
            return Ok();
        }



        /// <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-music")]
        [AuthToken("admin", "teacher", "visitor")]
        public async Task<IActionResult> DownloadPackageMusic(JsonNode json) 
        {
            return Ok();
        }
        [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)
                    {
                        var dataInfo=  await GetEvaluationFromCenter(GetXAuthToken(), _configuration, _httpClientFactory, shortCode, evaluationClient.id!);
                        if (dataInfo.centerCode.Equals("200")&& dataInfo.evaluationCloud!=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}");
                                            }
                                        });
                                    }
                                }
                            }

                            _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().Upsert(dataInfo.evaluationCloud!);

                            (successMsgs, errorMsgs) = await ManageService.CheckFile(dataInfo.evaluationCloud!, 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 {
                            errorMsgs.Add($"云端数据检测结果：{dataInfo. centerMsg},状态：{dataInfo. centerCode}");
                        }

                    }
                    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"]}";
            string shortCode = $"{json["shortCode"]}";
            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) && x.shortCode!.Equals(shortCode));
                if (evaluationLocal!=null)
                {

                    //ManageService.CheckData(evaluationLocal, null, successMsgs, errorMsgs, _liteDBFactory);
                    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")))
                    {
                        string key = $"{Constant._KeyEvaluationZipExtract}:{evaluationId}:{openCode}";
                        successMsgs.Add("加载评测试卷文件包！");
                        //string keyData =  _memoryCache.Get<string>(key);
                        //if (!string.IsNullOrWhiteSpace(keyData))
                        //{
                        //}
                        //else {

                            
                        //}
                        //删除文件夹
                        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)
                        {
                            _memoryCache.Set(key,key,TimeSpan.FromSeconds(30));
                            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 });
            }

        }
        /// <summary>
        /// 检查数据包是否有更新，zip是否存在，数据文件是否完整，名单文件是否完整。
        /// 如果有智音模块，则需要检查智音音乐缓存是否完整。
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>

        [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)
                        {
                          (evaluationCloud, centerCode, centerMsg)=  await ManageService.GetEvaluationFromCenter(GetXAuthToken(), _configuration,_httpClientFactory,shortCode,evaluationId);
                        }
                        else
                        {
                            centerCode = $"401";
                            centerMsg = "当前登录账号未找到";
                        }
                    }
                }
                else
                {
                    centerCode = $"404";
                    centerMsg = "云端数据中心未连接";
                }
                if (centerCode.Equals("200"))
                {
                    successMsgs.Add($"云端数据检测结果：{centerMsg},状态：{centerCode}");
                }
                else
                {
                    errorMsgs.Add($"云端数据检测结果：{centerMsg},状态：{centerCode}");
                }

            }
            EvaluationCheckDataResult checkDataResult;
             (checkDataResult, evaluationLocal) = 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("list-evaluation-round")]
        [AuthToken("admin", "teacher", "visitor")]
        public IActionResult ListEvaluationRound(JsonNode json)
        {
            string evaluationId = $"{json["evaluationId"]}";
            string openCode = $"{json["openCode"]}";
            string shortCode = $"{json["shortCode"]}";
            EvaluationClient? evaluationClient = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>()
               .FindOne(x => x.id!.Equals(evaluationId) && x.shortCode!.Equals(shortCode) && x.openCode!.Equals(openCode));
            if (evaluationClient!=null)
            {
                IEnumerable<EvaluationRoundSetting>? settings = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationRoundSetting>().Find(x => x.evaluationId!.Equals(evaluationClient.id)).OrderByDescending(x => x.activate).ThenByDescending(x => x.startline).ThenByDescending(x => x.createTime);
                if (settings.IsNotEmpty())
                {
                    return Ok(new { code = 200, msg = "OK", settings = settings });
                }
                else
                {
                    return Ok(new { code = 2, msg = "未设置开考信息！" });
                }
            }
            else 
            {
                return Ok(new { code = 1, msg = "未找到评测信息！" });
            }
                
        }
        /// <summary>
        /// 获取当前评测的开考设置信息
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost("load-evaluation-round")]
        [AuthToken("admin", "teacher", "visitor")]
        public IActionResult LoadEvaluationRound(JsonNode json)
        {
            string evaluationId = $"{json["evaluationId"]}";
            string openCode = $"{json["openCode"]}";
            string shortCode = $"{json["shortCode"]}";
            string settingId = $"{json["settingId"]}";
            EvaluationClient? evaluationClient = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>()
                .FindOne(x => x.id!.Equals(evaluationId) && x.shortCode!.Equals(shortCode) && x.openCode!.Equals(openCode));
            EvaluationRoundSetting? setting = null;
            if (evaluationClient!=null)
            {
                setting =  _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationRoundSetting>().FindOne(x =>x.id!.Equals(settingId) &&   x.evaluationId!.Equals(evaluationClient.id));
                if (setting!=null)
                {
                    IEnumerable<EvaluationStudentResult>? results = null;
                    var members = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationMember>().Find(x => x.evaluationId!.Equals(evaluationClient.id)  && x.roundId!.Equals(setting.id));
                    //并获取学生的作答信息
                    //顺便返回本轮的学生名单
                    if (members!=null && members.Count()>0)
                    {
                        results = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationStudentResult>()
                                   .Find(x => members.Select(x => x.id).Contains(x.studentId)&&!string.IsNullOrWhiteSpace(x.evaluationId)  && x.evaluationId.Equals(evaluationClient.id));
                        if (results.Count()==members.Count())
                        {
                            return Ok(new { code = 200, setting, results });
                        }
                        else {
                            return Ok(new { code = 200,msg="学生作答信息数量不匹配", setting, results });
                        }
                    }
                    else 
                    {
                        return Ok(new { code = 200,msg="未分配学生名单，或名单没有学生！", setting , results });
                    }
                }
                else
                {
                    return Ok(new { code = 2, msg = "未设置开考信息！" });
                }
            }
            else {
                return Ok(new { code = 1, msg = "未找到评测信息！" });
            }
        }
       
        /// <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)
            {
                var db = _liteDBFactory.GetLiteDatabase();
                var collection = db.GetCollection<EvaluationClient>() ;
                //&& x.openCode!.Equals($"{json["openCode"]}")&& x.shortCode!.Equals($"{json["shortCode"]}")
                string shortCode = $"{json["shortCode"]}";
                string openCode = $"{json["openCode"]}";
                EvaluationClient ? evaluationClient = collection.FindOne(x => x.id!.Equals(setting.evaluationId) 
                && !string.IsNullOrWhiteSpace(x.shortCode) && x.shortCode.Equals(x.shortCode) 
                && !string.IsNullOrWhiteSpace(x.openCode) && x.openCode.Equals(openCode) );
                if (evaluationClient!=null)
                {
                    IEnumerable<EvaluationRoundSetting> settings = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationRoundSetting>().Find(x => x.evaluationId!.Equals(evaluationClient.id));
                    if (settings != null && settings.Count() > 0)
                    {
                        var datas = settings.ToList();
                        foreach (EvaluationRoundSetting item in datas)
                        {
                            item.activate = 0;
                        }
                        _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationRoundSetting>().Upsert(datas);
                    }
                    /// 判断是否包含所有分组
                    bool isAllContained = setting.groupList.All(x => evaluationClient.grouplist.Any(y => y.id == x.id));
                    if (isAllContained && evaluationClient.grouplist.IsNotEmpty())
                    {
                        
                        //增加排序,保证id的唯一性
                        setting.id=ShaHashHelper.GetSHA1($"{evaluationClient.id}_{string.Join("", setting.groupList.Select(x => x.id)).OrderBy(x => x)}");
                        setting.createTime= DateTimeOffset.Now.ToUnixTimeMilliseconds();
                      
                        _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationRoundSetting>().Upsert(setting);
                        _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().Upsert(evaluationClient);
                        /// 分配试卷
                       
                        var (roundStudentPapers, members, results,code,msg) = AssignStudentPaper(evaluationClient, setting);
                        return Ok(new { code = code, msg =msg , setting, results });
                    }
                    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) 
        {
            if (!string.IsNullOrWhiteSpace($"{_connectionService.serverDevice?.school?.id}"))
            {
                string code = $"{_connectionService!.serverDevice!.school!.id}";
                IEnumerable<EvaluationClient>? evaluationClients = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationClient>().Find(x => x.ownerId!.Equals(code)).OrderByDescending(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>() });
                }
            }
            else 
            {
                return Ok(new { code = 200, evaluation = new List<EvaluationClient>() });
            }
           
            
        }
        /// <summary>
        /// 设置评测开考信息（本轮名单，计时规则等）
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        //[HttpPost("assign-student-paper")]
        //[AuthToken("admin", "teacher", "visitor")]
        private (List<EvaluationStudentPaper> roundStudentPapers, List<EvaluationMember> members, List<EvaluationStudentResult> results, int code, string msg) 
            AssignStudentPaper(EvaluationClient evaluationClient, EvaluationRoundSetting setting)
        {
            int code = 200;
            string msg = string.Empty;
            List<EvaluationStudentPaper> roundStudentPapers = new List<EvaluationStudentPaper>();
            List<EvaluationMember> members = new List<EvaluationMember>();
            List<EvaluationStudentResult> results = new List<EvaluationStudentResult>();
            string packagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "package");
            string evaluationPath = Path.Combine(packagePath, evaluationClient.id!);
            string evaluationDataPath = Path.Combine(evaluationPath, "data");
            string path_groupList = Path.Combine(evaluationDataPath, "groupList.json");
            if (System.IO.File.Exists(path_groupList))
            {
                JsonNode? jsonNode = System.IO.File.ReadAllText(path_groupList).ToObject<JsonNode>();
                if (jsonNode!=null && jsonNode["groupList"]!=null)
                {
                    List<EvaluationGroupList>? groupList = jsonNode["groupList"]?.ToObject<List<EvaluationGroupList>>();
                    if (groupList!=null)
                    {
                        bool isAllContained = setting.groupList.All(x => groupList.Any(y => y.id == x.id));
                        if (isAllContained)
                        {

                            foreach (var item in setting.groupList)
                            {
                                EvaluationGroupList? groupListItem = groupList.Find(x => x.id == item.id);
                                if (groupListItem!=null)
                                {
                                    groupListItem.members.ForEach(x =>
                                    {
                                        x.schoolId=_connectionService?.serverDevice?.school?.id;
                                        x.evaluationId=evaluationClient.id;
                                        x.classId= groupListItem.id;
                                        x.periodId= groupListItem.periodId;
                                        x.roundId=setting.id;
                                        x.className= groupListItem.name;
                                    });
                                    members.AddRange(groupListItem.members);
                                }
                            }
                            //清空数据库，重新插入
                            _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationMember>().DeleteAll();
                            //插入
                            _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationMember>().Upsert(members);


                            foreach (var subject in evaluationClient.subjects)
                            {
                                var studentPaperIds = members.Select(x => ShaHashHelper.GetSHA1(x.id+evaluationClient.id+subject.examId+subject.subjectId));
                                IEnumerable<EvaluationStudentPaper> evaluationStudentPapers = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationStudentPaper>()
                                    .Find(x => studentPaperIds.Contains(x.id) && x.evaluationId!.Equals(evaluationClient.id));
                                List<EvaluationStudentPaper> studentPapers = new List<EvaluationStudentPaper>();
                                int paperIndex = 0;
                                int paperCount = subject.papers.Count();
                                //先把试卷顺序打乱
                                subject.papers =subject.papers.OrderBy(x => Guid.NewGuid().ToString()).ToList();
                                //将学生顺序打乱
                                members = members.OrderBy(x => Guid.NewGuid().ToString()).ToList();

                                foreach (var member in members)
                                {
                                    SubjectExamPaper studentPaper = subject.papers[paperIndex];
                                    string id = ShaHashHelper.GetSHA1(member.id+evaluationClient.id+subject.examId+subject.subjectId);
                                    var paper = evaluationStudentPapers.Where(x => x.id!.Equals(id));
                                    if (paper== null || paper.Count()==0)
                                    {
                                        studentPapers.Add(new EvaluationStudentPaper
                                        {
                                            studentId=member.id,
                                            studentName=member.name,
                                            classId=member.classId,
                                            className=member.className,
                                            evaluationId=evaluationClient.id,
                                            examId=subject.examId,
                                            examName=subject.examName,
                                            subjectId=subject.subjectId,
                                            subjectName=subject.subjectName,
                                            paperId=studentPaper.paperId,
                                            paperName=studentPaper.paperName,
                                            questionCount=studentPaper.questionCount,
                                            id=id,
                                        });
                                        // 移动到下一个试卷
                                        paperIndex = (paperIndex + 1) % paperCount;
                                    }
                                    else
                                    {
                                        // Console.WriteLine("已经分配过试卷，跳过");
                                        //已经分配过试卷，跳过
                                    }
                                }
                                if (studentPapers.Count>0)
                                {
                                    _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationStudentPaper>().Upsert(studentPapers);
                                    roundStudentPapers.AddRange(studentPapers);
                                }
                                if (evaluationStudentPapers!=null && evaluationStudentPapers.Count()>0)
                                {
                                    roundStudentPapers.AddRange(evaluationStudentPapers);
                                }
                            }
                            long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                            IEnumerable<EvaluationStudentResult> studentResults = _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationStudentResult>()
                                .Find(x => members.Select(x => x.id).Contains(x.studentId)&&!string.IsNullOrWhiteSpace(x.evaluationId)  && x.evaluationId.Equals(evaluationClient.id));
                            foreach (var member in members)
                            {
                                EvaluationStudentResult? studentResult = null;
                                //sha1(evaluationId-schoolId-studentId)
                                string resultId = ShaHashHelper.GetSHA1(evaluationClient.id+_connectionService?.serverDevice?.school?.id+member.id);
                                var result = studentResults.Where(x => x.id!.Equals(resultId)    && !string.IsNullOrWhiteSpace(x.studentId)  && x.studentId.Equals(member.id));
                                if (result==null || result.Count()==0)
                                {
                                    studentResult = new EvaluationStudentResult()
                                    {
                                        id = resultId,
                                        evaluationId = evaluationClient.id,
                                        schoolId = _connectionService?.serverDevice?.school?.id,
                                        studentId = member.id,
                                        studentName = member.name,
                                        classId = member.classId,
                                        className = member.className,
                                        ownerId= evaluationClient.ownerId,
                                        scope= evaluationClient.scope,
                                        type= evaluationClient.type,
                                        pid= evaluationClient.pid,
                                    };
                                    var studentPapers = roundStudentPapers.FindAll(x => !string.IsNullOrWhiteSpace(x.studentId) 
                                    &&  x.studentId.Equals(member.id) &&!string.IsNullOrWhiteSpace(x.evaluationId)  && x.evaluationId.Equals(evaluationClient.id));
                                    if (studentPapers.IsNotEmpty())
                                    {
                                        foreach (var studentPaper in studentPapers)
                                        {
                                            studentResult.subjectResults.Add(new EvaluationSubjectResult()
                                            {
                                                id = ShaHashHelper.GetSHA1(evaluationClient.id+studentPaper.examId+studentPaper.subjectId+member.id),
                                                evaluationId = studentPaper.evaluationId,
                                                examId = studentPaper.examId,
                                                examName = studentPaper.examName,
                                                subjectId = studentPaper.subjectId,
                                                subjectName = studentPaper.subjectName,
                                                paperId = studentPaper.paperId,
                                                paperName = studentPaper.paperName,
                                                questionCount=studentPaper.questionCount,
                                                createTime=now
                                            });
                                        }
                                    }
                                    // _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationStudentResult>().Upsert(studentResult);
                                }
                                else
                                {
                                    studentResult = result.First();
                                    studentResult.studentName = member.name;
                                    studentResult.classId = member.classId;
                                    studentResult.className = member.className;
                                    var studentPapers = roundStudentPapers.FindAll(x => !string.IsNullOrWhiteSpace(x.studentId)
                                    &&  x.studentId.Equals(member.id) &&!string.IsNullOrWhiteSpace(x.evaluationId)  && x.evaluationId.Equals(evaluationClient.id));
                                    if (studentPapers.IsNotEmpty())
                                    {
                                        foreach (var studentPaper in studentPapers)
                                        {
                                            string subjectResultId = ShaHashHelper.GetSHA1(evaluationClient.id+studentPaper.examId+studentPaper.subjectId+member.id);
                                            var subjectResult = studentResult.subjectResults.Where(x => x.id!.Equals(subjectResultId)).FirstOrDefault();
                                            if (subjectResult==null)
                                            {
                                                subjectResult=  new EvaluationSubjectResult()
                                                {
                                                    id = ShaHashHelper.GetSHA1(evaluationClient.id+studentPaper.examId+studentPaper.subjectId+member.id),
                                                    evaluationId = studentPaper.evaluationId,
                                                    examId = studentPaper.examId,
                                                    examName = studentPaper.examName,
                                                    subjectId = studentPaper.subjectId,
                                                    subjectName = studentPaper.subjectName,
                                                    paperId = studentPaper.paperId,
                                                    paperName = studentPaper.paperName,
                                                    questionCount= studentPaper.questionCount,
                                                    createTime=now
                                                };
                                            }
                                            studentResult.subjectResults.Add(subjectResult);
                                        }
                                    }
                                }
                                if (studentResult!=null)
                                {
                                    results.Add(studentResult);
                                }
                            }
                            if (results.Count>0)
                            {
                                _liteDBFactory.GetLiteDatabase().GetCollection<EvaluationStudentResult>().Upsert(results);
                            }
                        }
                        else
                        {
                            msg = "开考名单不在当前评测中！";
                            code = 4;
                        }
                    }
                    else
                    {
                        msg = "名单文件字段提取为空！";
                        code = 3;
                    }
                }
                else
                {
                    msg = "名单文件解析错误！";
                    code = 2;
                }
            }
            else
            {
                msg = "名单文件不存在！";
                code = 1;
            }
            if (members.Count()!=results.Count())
            {
                code = 5;
                msg = "名单成员与作答记录数量不匹配！";
            }
           
            if (roundStudentPapers.Count()!= results.SelectMany(x => x.subjectResults).Count())
            {
                code = 6;
                msg = "学生分配的试卷与作答记录数量不匹配！";
            }
            return (roundStudentPapers, members, results, code, msg);
        }

    }
}