TEAMModelOS/TEAMModelOS.Extension/HTEX.Test/Controllers/LessonRecordController.cs

using Azure.Storage.Blobs.Models;
using Microsoft.AspNetCore.Mvc;
using System.Text.Json;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Extension;
using StackExchange.Redis;
using System.Text.RegularExpressions;

namespace HTEX.Test.Controllers
{
    [ApiController]
    [Route("lesson-record")]
    public class LessonRecordController : ControllerBase
    {
        private readonly ILogger<LessonRecordController> _logger;
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly AzureStorageFactory _azureStorage;

        // 创建一个字典来存储状态编号和对应的分数
        private readonly Dictionary<int, double> states = new Dictionary<int, double>();
        public LessonRecordController(ILogger<LessonRecordController> logger, AzureCosmosFactory azureCosmos, AzureStorageFactory azureStorage)
        {
            _logger = logger;
            _azureCosmos = azureCosmos;
            _azureStorage = azureStorage;
            #region
            // 无二次作答的互动，且未设置正确答案
            states.Add(1, 0); // 未作答0
            states.Add(2, 1); // 已作答1

            // 无二次作答的互动，且设置了正确答案
            states.Add(3, 0); // 未作答0
            states.Add(4, 1); // 已作答1
            states.Add(5, 1.5); // 作答正确1.5

            // 有二次作答的互动，且未设置正确答案
            states.Add(6, 0); // 第一次未作答0，第二次未作答0
            states.Add(7, 1); // 第一次已作答1，第二次未作答0
            states.Add(8, 1); // 第一次未作答0，第二次已作答1
            states.Add(9, 2); // 第一次已作答1，第二次已作答1

            // 有二次作答的互动，且设置了正确答案
            states.Add(10, 0); // 第一次未作答0，第二次未作答0
            states.Add(11, 1.5); // 第一次已作答，作答正确1.5，第二次未作答0
            states.Add(12, 1); // 第一次已作答，作答错误1.5，第二次未作答0
            states.Add(13, 1.5); // 第一次未作答0，第二次已作答，作答正确1.5
            states.Add(14, 1); // 第一次未作答0，第二次已作答，作答错误1
            states.Add(15, 2); // 第一次已作答，作答错误1，第二次已作答，作答错误1
            states.Add(16, 2.5); // 第一次已作答，作答正确1.5，第二次已作答，作答错误1
            states.Add(17, 2.5); // 第一次已作答，作答错误1，第二次已作答，作答正确1.5
            states.Add(18, 3); // 第一次已作答，作答正确1.5，第二次已作答，作答正确1.5

            // 抢权模式
            states.Add(19, 0); // 未参与抢权0
            states.Add(20, 1); // 参与抢权1
            states.Add(21, 1.5); // 抢权成功1.5
            // 挑人时被挑到
            states.Add(22, 1.5); // 被挑到1.5

            #endregion
        }
        [HttpPost("read")]
        public async Task<IActionResult> Read(JsonElement json) 
        {
            string m = await System.IO.File.ReadAllTextAsync("C:\\Users\\CrazyIter\\Downloads\\m.json");
            string p = await System.IO.File.ReadAllTextAsync("C:\\Users\\CrazyIter\\Downloads\\p.json");
            List<ItemInfo> mlist=m.ToObject<List<ItemInfo>>();
            List<ItemInfo> plist=p.ToObject<List<ItemInfo>>();
            var km = mlist.Where(x=> x.knowledge.IsNotEmpty()).SelectMany(x => x.knowledge).Distinct();
            var kp = plist.Where(x=> x.knowledge.IsNotEmpty()).SelectMany(x => x.knowledge).Distinct();
            List<CodeLong> cp = new List<CodeLong>();
            foreach (var item in kp)
            {
                var count = plist.Where(x => x.knowledge.Contains(item)).Count();
                cp.Add(new CodeLong() { code = item, value = count });
            }
            List<CodeLong> cm = new List<CodeLong>();
            foreach (var item in km)
            {
               var count =  mlist.Where(x => x.knowledge.Contains(item)).Count();
               cm.Add(new CodeLong() { code = item, value = count });
            }
          

            return Ok(new { cm,cp });
        }
        [HttpPost("process-history")]
        public async Task<IActionResult> ProcessHistory(JsonElement json)
        {
            //1709222400000 2024.3.1
            var result = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                .GetList<LessonRecord>($"SELECT value c FROM School AS c  where c.startTime>1709222400000 and c.expire<=0  and c.status<>404",
                $"LessonRecord-{json.GetProperty("schoolId")}", pageSize: 20);
            if (result.list.IsNotEmpty())
            {
                foreach (var item in result.list)
                {
                    //读取TimeLine.json
                    TimeLineData? timeLineData = null;
                    try
                    {
                        BlobDownloadResult timeLineBlobDownload = await _azureStorage.GetBlobContainerClient(item.school).GetBlobClient($"/records/{item.id}/IES/TimeLine.json").DownloadContentAsync();
                        timeLineData = timeLineBlobDownload.Content.ToObjectFromJson<TimeLineData>();
                    }
                    catch (Exception ex)
                    {
                        if (!ex.Message.Contains("The specified blob does not exist"))
                        {
                            _logger.LogError(ex, $"文件不存在：/records/{item.id}/IES/TimeLine.json");
                        }
                    }

                    //读取基础Base信息
                    //base.json
                    LessonBase? lessonBase = null;
                    List<StudentLessonData> studentLessonDatas = new List<StudentLessonData>();
                    try
                    {
                        BlobDownloadResult baseblobDownload = await _azureStorage.GetBlobContainerClient(item.school).GetBlobClient($"/records/{item.id}/IES/base.json").DownloadContentAsync();
                        string basejson = baseblobDownload.Content.ToString().Replace("\"Uncall\"", "0").Replace("Uncall", "0");
                        lessonBase = basejson.ToObject<LessonBase>();
                        var data = GetBaseData(item, lessonBase);
                        studentLessonDatas=data.studentLessonDatas;
                    }
                    catch (Exception ex)
                    {
                        if (!ex.Message.Contains("The specified blob does not exist"))
                        {
                            _logger.LogError(ex, $"文件不存在：/records/{item.id}/IES/base.json");
                        }
                    }

                    //读取Task.json
                    ///Event 过滤类型 ： 'WrkSpaceLoad'作品收集, 'WrkCmp' 作品贴上 文件：Task.json  根据clientWorks 中的seatID 匹配base.json 中的 student
                    List<TaskData> taskDatas = new List<TaskData>();
                    try
                    {
                        BlobDownloadResult taskBlobDownload = await _azureStorage.GetBlobContainerClient(item.school).GetBlobClient($"/records/{item.id}/IES/Task.json").DownloadContentAsync();
                        taskDatas = taskBlobDownload.Content.ToObjectFromJson<List<TaskData>>();
                    }
                    catch (Exception ex)
                    {
                        if (!ex.Message.Contains("The specified blob does not exist"))
                        {
                            _logger.LogError(ex, $"文件不存在：/records/{item.id}/IES/Task.json");
                        }
                    }

                    //读取互评信息
                    //Event 过滤类型  'RatingStart'
                    //smartRateSummary.mutualSummary.mutualType 互评【All(每人多件评分)  Two(随机分配互评)  Self(自评)】 smartRateSummary.meteor_VoteSummary 投票 
                    //读取SmartRating.json
                    List<SmartRatingData> smartRatingDatas = new List<SmartRatingData>();
                    try
                    {
                        BlobDownloadResult smartRatingBlobDownload = await _azureStorage.GetBlobContainerClient(item.school).GetBlobClient($"/records/{item.id}/IES/SmartRating.json").DownloadContentAsync();
                        smartRatingDatas = smartRatingBlobDownload.Content.ToObjectFromJson<List<SmartRatingData>>();

                    }
                    catch (Exception ex)
                    {
                        if (!ex.Message.Contains("The specified blob does not exist"))
                        {
                            _logger.LogError(ex, $"文件不存在：/records/{item.id}/IES/SmartRating.json");
                        }
                    }
                    //读取互动信息
                    //Event 过滤类型  'PopQuesLoad', 'ReAtmpAnsStrt', 'BuzrAns','BuzrLoad'
                    //TimeLine.json 中找到对应类型，根据Pgid 去 IRS.json 中找到对应数据，从clientAnswers 的下标对应 base.json 中的 student 找到对应学生信息 clientAnswers.length > 1 则表示有二次作答
                    //读取IRS.json
                    List<IRSData> irsDatas = new List<IRSData>();
                    try
                    {
                        BlobDownloadResult irsBlobDownload = await _azureStorage.GetBlobContainerClient(item.school).GetBlobClient($"/records/{item.id}/IES/IRS.json").DownloadContentAsync();
                        irsDatas = irsBlobDownload.Content.ToObjectFromJson<List<IRSData>>();

                    }
                    catch (Exception ex)
                    {
                        if (!ex.Message.Contains("The specified blob does not exist"))
                        {
                            _logger.LogError(ex, $"文件不存在：/records/{item.id}/IES/IRS.json");
                        }
                    }
                    //读取协作信息
                    ///Event 过滤类型  'CoworkLoad'
                    //Cowork.json 中找到对应类型，根据Pgid 去 Cowork.json 中找到对应数据
                    List<CoworkData> coworkDatas = new List<CoworkData>();
                    try
                    {
                        BlobDownloadResult irsBlobDownload = await _azureStorage.GetBlobContainerClient(item.school).GetBlobClient($"/records/{item.id}/IES/Cowork.json").DownloadContentAsync();
                        coworkDatas = irsBlobDownload.Content.ToObjectFromJson<List<CoworkData>>();

                    }
                    catch (Exception ex)
                    {
                        if (!ex.Message.Contains("The specified blob does not exist"))
                        {
                            _logger.LogError(ex, $"文件不存在：/records/{item.id}/IES/Cowork.json");
                        }
                    }
                }
            }
            return Ok("Lesson records");
        }

        /// <summary>
        /// 处理base.json的数据
        /// </summary>
        /// <param name="lessonRecord"></param>
        /// <param name="lessonBase"></param>
        /// <returns></returns>
        private (LessonBase lessonBase, List<StudentLessonData> studentLessonDatas) GetBaseData(LessonRecord lessonRecord, LessonBase lessonBase)
        {
            //处理学生定位数据
            List<StudentLessonData> studentLessonDatas = new List<StudentLessonData>();
            int index = 0;
            lessonBase.student.ForEach(x =>
            {
                studentLessonDatas.Add(new StudentLessonData()
                {
                    id = x.id,
                    index = index,
                    seatID =$"{x.seatID}",
                    groupId = x.groupId,
                });
                index++;
            });
            return (lessonBase, studentLessonDatas);
        }

        /// <summary>
        ///读取互动信息
        ///Event 过滤类型  'PopQuesLoad', 'ReAtmpAnsStrt', 'BuzrAns','BuzrLoad'
        /// 在IRS.json处理 'PopQuesLoad'互动问答 , 'ReAtmpAnsStrt' 二次作答 , 'BuzrAns'  抢权（新）, 'BuzrLoad'抢权（旧）, PickupResult   挑人算不算互动？？  读取PickupMemberId "[\r\n  35\r\n]"
        ///TimeLine.json 中找到对应类型，根据Pgid 去 IRS.json 中找到对应数据，从clientAnswers 的下标对应 base.json 中的 student 找到对应学生信息 clientAnswers.length > 1 则表示有二次作答
        ///读取IRS.json
        /// </summary>
        /// <param name="lessonRecord"></param>
        /// <param name="lessonBase"></param>
        /// <param name="irsDatas"></param>
        /// <returns></returns>
        private async Task<List<StudentLessonData>> GetIRSData(LessonRecord lessonRecord, LessonBase lessonBase, TimeLineData timeLineData, List<IRSData> irsDatas, List<StudentLessonData> studentLessonDatas)
        {
            List<string> interactTypes = new List<string>() { "PopQuesLoad", "ReAtmpAnsStrt", "BuzrAns", "BuzrLoad", "PickupResult" };
            //去重页面
            var enventsInteract = timeLineData.events.Where(x => interactTypes.Contains(x.Event)).GroupBy(x => x.Pgid) .Select(x => new { key = x.Key, list = x.ToList() });

            if (enventsInteract!= null)
            {
                var keys = enventsInteract.Select(x => x.key).ToList();

                foreach (var item in enventsInteract)
                {
                    ProcessIRSPageData(irsDatas, studentLessonDatas, item);
                }
                //处理其他，评测类型的互动，因为有可能不会记录在TimeLine.json中
                var envents_other = timeLineData.events.Where(x => !keys.Contains(x.Pgid)).GroupBy(x => x.Pgid)  .Select(x => new { key = x.Key, list = x.ToList() });
                if (envents_other!=null)
                {
                    foreach (var item in envents_other)
                    {
                        ProcessIRSPageData(irsDatas, studentLessonDatas, item);
                    }
                }
            }
            else 
            {
                //处理其他，评测类型的互动，因为有可能不会记录在TimeLine.json中
                var envents_other = timeLineData.events.GroupBy(x => x.Pgid) .Select(x => new { key = x.Key, list = x.ToList() });
                if (envents_other!=null)
                {
                    foreach (var item in envents_other)
                    {
                        ProcessIRSPageData(irsDatas, studentLessonDatas, item);
                    }
                }
            }
            //单独处理挑人的逻辑
            //是否从小组里面挑人。
            //不需要去重页面，直接获取挑人大类 PickupResult
            //小类处理：PickupRight  , PickupOption  , PickupNthGrp  ,PickupEachGrp  ,PickupDiff
            var enventsPickup = timeLineData.events.Where(x => x.Event.Equals("PickupResult"));
            if (enventsPickup.IsNotEmpty())
            {
                foreach (var item in enventsPickup)
                {
                    List<int> mbrs = item.PickupMemberId.ToObject<List<int>>();

                    foreach (var mbr in mbrs)
                    {
                        var studentLessonData = studentLessonDatas.Find(x => x.seatID!.Equals($"{mbr}"));
                        if (studentLessonData!=null)
                        {
                            studentLessonData.interactRecords.Add(new InteractRecord() 
                            {
                                resultWeight = InteractWeight.TT,
                                resultType="TT",
                                interactType = string.IsNullOrWhiteSpace(item.PickupType) ? "PickupResult" : item.PickupType
                            });
                        }
                    }
                }
            }
            return studentLessonDatas;
        }

        private static void ProcessIRSPageData(List<IRSData> irsDatas, List<StudentLessonData> studentLessonDatas, dynamic item)
        {
            var irsDataPages = irsDatas.Where(y => item.key.Equals(y.pageID));
            foreach (var irsDataPage in irsDataPages)
            {
                //检查是否设置正确答案。
                var answers_q = irsDataPage.question?["exercise"]?["answer"]?.ToJsonString().ToObject<List<string>>();
                List<string> answers = new List<string>();
                answers_q?.ForEach(x => {
                    if (!string.IsNullOrWhiteSpace(x))
                    {
                        answers.Add(x);
                    }
                });
                var _objective = irsDataPage.question?["exercise"]?["objective"];
                var scoreNode = irsDataPage.question?["exercise"]?["score"];
                var _type = irsDataPage.question?["exercise"]?["type"];
                var _answerType = irsDataPage.question?["exercise"]?["answerType"];//file,audio,text,image
                double score = 0;
                bool objective = false;
              
                if (_objective!=null) { 
                    objective = _objective.GetValue<bool>();
                }
                //题型
                string type= string.Empty;
                if (_type!=null)
                {
                    //题型
                     type  = _type.GetValue<string>();
                    List<string> types = new List<string>() { "single", "multiple" , "judge" , "sortmultiple" };
                    if (types.Contains(type))
                    {
                        objective = true;
                    }
                    else {
                        objective = false;
                    }
                   
                }

                if (_answerType!=null)
                {
                    _answerType.GetValue<string>();

                    //暂不处理，可能存在依然传文字的情况
                    //不是文本作答的处理，题目不是客观题，答案不记录
                    //if (!_answerType.Equals("text"))
                    //{
                    //    objective=false;
                    //    answers=new List<string>();
                    //}
                }
                if (scoreNode!=null)
                {
                    double.TryParse(scoreNode.ToString(), out score);
                }
                string interactType = string.Empty;

                if (irsDataPage.clientAnswers.IsNotEmpty())
                {

                    //第一个list是几轮，一次作答，二次作答， 第二个list是学生的下标， 第三个list是 答案
                    List<List<List<string>>> clientAnswers = new List<List<List<string>>>();
                    foreach (var key in irsDataPage.clientAnswers.Keys)
                    {
                        clientAnswers.Add(irsDataPage.clientAnswers[key]);
                    }
                    // 获取第一个列表的长度作为比较基准
                    int firstListLength = clientAnswers.First().Count;
                    bool isSameLength = true;
                    // 遍历剩余的列表并检查它们的长度是否与第一个列表相同
                    foreach (var innerList in clientAnswers.Skip(1))
                    {
                        if (innerList.Count != firstListLength)
                        {
                            isSameLength = false;
                            break;
                        }
                    }
                    //并检查学生集合的长度是否与第一个列表相同
                    if (!isSameLength  && studentLessonDatas.Count()==firstListLength)
                    {
                        for (int index = 0; index< clientAnswers[0].Count; index++)
                        {
                            //index  代表学生下标
                            List<InteractRecord> interactRecords = new List<InteractRecord>();
                            if (clientAnswers.Count==1)
                            {
                                //即问即答
                                interactType = "PopQuesLoad";
                                var ans0 = clientAnswers[0][index];
                                var IS0 = GetInteractResultHasAnswer(answers, ans0, objective,type);
                                interactRecords.Add(new InteractRecord()
                                {
                                    resultWeight = IS0.weight,
                                    resultType=IS0.reultType,
                                    interactType= interactType
                                });
                            }
                            if (clientAnswers.Count==2)
                            {
                                //二次作答
                                interactType="ReAtmpAnsStrt";
                                var ans1 = clientAnswers[1][index];
                                var IS1 = GetInteractResultHasAnswer(answers, ans1, objective,type);
                                interactRecords.Add(new InteractRecord()
                                {
                                    resultWeight = IS1.weight,
                                    resultType=IS1.reultType,
                                    interactType= interactType
                                });
                            }
                            if (clientAnswers.Count>2)
                            {
                                //三次作答
                                interactType="TeAtmpAnsStrt";
                                var ans2 = clientAnswers[2][index];
                                var IS2 = GetInteractResultHasAnswer(answers, ans2, objective,type);
                                interactRecords.Add(new InteractRecord()
                                {
                                    resultWeight = IS2.weight,
                                    resultType=IS2.reultType,
                                    interactType= interactType
                                });
                            }
                            studentLessonDatas[index].interactRecords.AddRange(interactRecords);
                        }

                    }
                }
                //是否抢权作答的模式
                if (irsDataPage.isBuzz)
                {
                    interactType = "BuzrAns";
                    //处理参与抢权的
                    Dictionary<string, InteractRecord> buzzParticipants = new Dictionary<string, InteractRecord>();
                    foreach (var buzzParticipant in irsDataPage.buzzParticipants)
                    {
                        var studentData = studentLessonDatas.Find(x => x.seatID!.Equals(buzzParticipant));
                        if (studentData != null)
                        {
                            buzzParticipants[buzzParticipant]=new InteractRecord() { resultWeight = InteractWeight.T1, interactType= interactType };
                        }
                    }
                    //处理抢权成功的
                    foreach (var buzzClient in irsDataPage.buzzClients)
                    {
                        buzzParticipants[buzzClient]=new InteractRecord() { resultWeight = InteractWeight.TT, interactType= interactType };
                    }
                    foreach (var studentLessonData in studentLessonDatas)
                    {
                        if (buzzParticipants.ContainsKey(studentLessonData.seatID!))
                        {
                            //处理已经有抢权结果的数据
                            studentLessonData.interactRecords.Add(buzzParticipants[studentLessonData.seatID!]);
                        }
                        else
                        {
                            //处理未参与抢权的
                            studentLessonData.interactRecords.Add(new InteractRecord() { resultWeight = InteractWeight.T0, interactType = interactType });
                        }
                    }
                }
            }
        }

        private static (double weight,string reultType) GetInteractResultHasAnswer(List<string>? answers, List<string> ans0 , bool objective,string type)
        {
            //List<string> ans0 = new List<string>();
            //ans?.ForEach(x => {
            //    if (!string.IsNullOrWhiteSpace(x))
            //    {
            //        ans0.Add(x);
            //    }
            //    else { ans.Add("");}
            //});
            double weight = InteractWeight.T0;
            string reultType = InteractReultType.T0;
            if (answers.IsNotEmpty())
            {
                if (ans0.IsNotEmpty())
                {
                    if (objective) //客观题
                    {
                        //标准答案等于作答的结果
                        if (answers!.Count == ans0.Count)
                        {
                            if (answers.All(item => ans0.Contains(item)))
                            {
                                //完全正确
                                weight= InteractWeight.TT;
                                reultType= InteractReultType.TT;
                            }
                            else
                            {
                                //作答错误
                                weight= InteractWeight.T1;
                                reultType = InteractReultType.T1;
                            }
                        }
                        //标准答案比作答的结果多
                        else if (answers!.Count > ans0.Count)
                        {
                            if (ans0.All(item => answers.Contains(item)))
                            {
                                //部分正确
                                weight= InteractWeight.TP;
                                reultType = InteractReultType.TP;
                            }
                            else
                            {
                                //作答错误
                                weight= InteractWeight.T1;
                                reultType = InteractReultType.T1;
                            }
                        }
                        //标准答案比作答结果少
                        else
                        {
                            //作答错误
                            weight= InteractWeight.T1;
                            reultType = InteractReultType.T1;
                        }
                    }
                    else
                    {
                        //填空题
                        if ("complete".Equals(type) && answers!.Count==ans0.Count)
                        {
                            bool hasT = false;
                            bool hasF = false;
                            for (int i = 0; i < answers!.Count; i++) 
                            {
                                if (answers[i].Equals(ans0[i]))
                                {
                                    hasT=true;
                                }
                                else {
                                    hasF=true;
                                }
                            }
                            if (hasT && !hasF)
                            {
                                //完全正确
                                weight= InteractWeight.TT;
                                reultType = InteractReultType.TT;
                            }
                            else if (hasT && hasF)
                            {
                                //部分正确
                                weight= InteractWeight.TP;
                                reultType = InteractReultType.TP;
                            }
                            else if (!hasT && hasF)
                            {
                                //没有正确的，但有错误的，代表参与了
                                weight= InteractWeight.T1;
                                reultType = InteractReultType.T1;
                            }
                            else if (!hasT && !hasF)
                            {
                                //没有正确的，也没有错误的，代表没有作答
                                weight= InteractWeight.T0;
                                reultType = InteractReultType.T0;
                            }
                        }
                        else
                        {  
                            //主观题,完全匹配的
                            if (answers!.All(item => ans0.Contains(item)))
                            {
                                //完全正确
                                weight= InteractWeight.TT;
                                reultType = InteractReultType.TT;
                            }
                            else
                            {   // 使用LINQ查询来判断是否有匹配的答案
                                bool hasMatchingAnswer = answers!.Intersect(ans0).Any();
                                if (hasMatchingAnswer)
                                {
                                    //主观题回答正确即为完全正确
                                    weight= InteractWeight.TT;
                                    reultType = InteractReultType.TT;
                                }
                                else
                                {
                                    //没有匹配上答案,则采用Levenshtein距离来评估两个字符串的相似度
                                    var sc = CalculateSimilarity(answers![0], ans0[0]) * 1.0/100 *(InteractWeight.TT-InteractWeight.T1);
                                    weight = sc;
                                    reultType = InteractReultType.TP;
                                }
                            }
                        }
                    }
                }
                else
                {
                    //没有作答
                    weight= InteractWeight.T0;
                    reultType = InteractReultType.T0;
                }
            }
            else 
            {
                //没有答案的情况
                if (ans0.IsNotEmpty()) 
                {
                    bool hasAns = false;
                    ans0.ForEach(x => {
                        if (!string.IsNullOrWhiteSpace(x)) { 
                         hasAns = true;    
                        }
                    });
                    if (hasAns)
                    {
                        //作答了
                        weight= InteractWeight.T1;
                        reultType = InteractReultType.T1;
                    }
                    else {
                        //没有作答
                        weight= InteractWeight.T0;
                        reultType = InteractReultType.T0;
                    }
                   
                }
                else
                {
                    //没有作答
                    weight= InteractWeight.T0;
                    reultType = InteractReultType.T0;
                }
            }
            return (weight,reultType);
        }
        #region C# 代码 如何判断两句话是否一个意思,非机器学习的算法。使用Levenshtein距离来评估两个字符串的相似度，但是不能判断它们是否表达了同一个意思，后续借助AI实现
        public static double CalculateSimilarity(string s1, string s2)
        {
            int n = s1.Length;
            int m = s2.Length;
            int[,] d = new int[n + 1, m + 1];
            for (int i = 0; i <= n; i++)
            {
                d[i, 0] = i;
            }

            for (int j = 0; j <= m; j++)
            {
                d[0, j] = j;
            }

            for (int i = 1; i <= n; i++)
            {
                for (int j = 1; j <= m; j++)
                {
                    int cost = (s1[i - 1] == s2[j - 1]) ? 0 : 1;
                    d[i, j] = Math.Min(Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1), d[i - 1, j - 1] + cost);
                }
            }

            return (1.0 - ((double)d[n, m] / Math.Max(s1.Length, s2.Length))) * 100;
        }

         
        #endregion
        /// <summary>
        /// 获取课中评测数据
        /// </summary>
        /// <param name="lessonRecord"></param>
        /// <param name="lessonBase"></param>
        /// <param name="timeLineData"></param>
        /// <param name="coworkDatas"></param>
        /// <param name="studentLessonDatas"></param>
        /// <returns></returns>
        private async Task<dynamic> GetExamData(LessonRecord lessonRecord, LessonBase lessonBase, TimeLineData timeLineData, List<ExamData> examDatas, List<StudentLessonData> studentLessonDatas) 
        {
            foreach (var examData in examDatas) 
            {
                var allocation=  examData?.exam?.papers?.SelectMany(x => x.point).Sum();
                var answersStd = examData?.exam?.papers?.FirstOrDefault()?.answers;
                List<List<string>> answers= new List<List<string>>();
                if (answersStd!=null) 
                {
                 answersStd.ForEach(x =>
                 {
                     List<string> ans = new List<string>();
                    x.ForEach(y =>
                    {
                        if (string.IsNullOrWhiteSpace(y)) 
                        {
                        
                        }
                    });
                     answers.Add(ans);
                 });
                }
                examData?.examClassResult?.ForEach(item =>{
                    int index = 0;
                    item.studentAnswersArray.ForEach(x => {
                        //是否要判断主观题或者客观题， 多套试卷，有主观题的
                        //主观题有回答的：608942756458532864\Clients\18782481024\Ans\27-4341670635487887360-examExchangeAnswerlist   27 从1开始的学生序号-4341670635487887360评测编号，内容qNo 是从1开始的题号。
                        if (x.IsNotEmpty()) 
                        {
                        }
                    });
                });
            }
            return null;
        }
        /// <summary>
        /// 协作参与率 态度计算
        /// </summary>
        /// <param name="lessonRecord"></param>
        /// <param name="lessonBase"></param>
        /// <param name="timeLineData"></param>
        /// <param name="coworkDatas"></param>
        /// <param name="studentLessonDatas"></param>
        /// <returns></returns>
        private async Task<dynamic> GetCoworkData(LessonRecord lessonRecord, LessonBase lessonBase, TimeLineData timeLineData, List<CoworkData> coworkDatas, List<StudentLessonData> studentLessonDatas)
        {
            return Ok(lessonRecord);
        }

        /// <summary>
        /// 处理学生回推数据，并将回推纳入学习态度计算。
        /// </summary>
        /// <param name="lessonRecord"></param>
        /// <param name="lessonBase"></param>
        /// <param name="timeLineData"></param>
        /// <param name="taskDatas"></param>
        /// <param name="studentLessonDatas"></param>
        /// <returns></returns>
        private async Task<dynamic> GetTaskData(LessonRecord lessonRecord, LessonBase lessonBase, TimeLineData timeLineData, List<TaskData> taskDatas, List<StudentLessonData> studentLessonDatas)
        {
            return Ok(lessonRecord);
        }

        /// <summary>
        /// 评分参与率 态度计算
        /// </summary>
        /// <param name="lessonRecord"></param>
        /// <param name="lessonBase"></param>
        /// <param name="timeLineData"></param>
        /// <param name="smartRatingDatas"></param>
        /// <param name="studentLessonDatas"></param>
        /// <returns></returns>
        private async Task<dynamic> GetSmartRatingData(LessonRecord lessonRecord, LessonBase lessonBase, TimeLineData timeLineData, List<SmartRatingData> smartRatingDatas, List<StudentLessonData> studentLessonDatas)
        {
            return Ok(lessonRecord);
        }
    }

    public class LessonRecordData
    {
        /// <summary>
        /// 互动次数
        /// </summary>
        public int interactCount;
        public List<StudentLessonData> data { get; set; } = new List<StudentLessonData>();
    }


    /// <summary>
    /// 学生课中数据
    /// </summary>
    public class StudentLessonData
    {
        /// <summary>
        /// 学生的学号
        /// </summary>
        public string? id { get; set; }
        /// <summary>
        /// 学生所在下标
        /// </summary>
        public int index { get; set; } = -1;
        /// <summary>
        /// 学生座位号
        /// </summary>
        public string? seatID { get; set; }
        /// <summary>
        /// 小组编号
        /// </summary>
        public string? groupId { get; set; }
        /// <summary>
        /// 小组下标 ,暂不使用
        /// </summary>
        //public int groupIndex { get; set; } = -1;
        /// <summary>
        /// 学生专属的互动次数，单独设置此字段，因为存在挑人的情况，需要单独设置
        /// </summary>
        public int interactCount { get; set; }
        /// <summary>
        /// 互动积分
        /// </summary>
        public double interactScore { get; set; }

        /// <summary>
        /// -1表示本次互动未统计分数，0表示本次互动答错为0，大于0 的分数表示本次互动打对为相应的分数。  该分数用于统计成果。
        /// 互动积分记录[-1,0,10]
        /// </summary>
        public List<InteractRecord> interactRecords { get; set; } = new List<InteractRecord>();
        /// <summary>
        /// 学生评测记录相关
        /// </summary>
        public List<StudentExamRecord> examRecords { get; set; } = new List<StudentExamRecord>();
    }
    /// <summary>
    /// 学生课中评测记录
    /// </summary>
    public class StudentExamRecord
    {
        /// <summary>
        /// 作答率0 未作答，1，所有题目作答，小数点则表示部分作答。 可纳入学习态度计算,  主观题需要确认 是否会在此写入答案。
        /// </summary>
        public int  answerRate{ get; set; }
        /// <summary>
        /// 评测得分
        /// </summary>
        public double score { get; set;}
        /// <summary>
        /// 评测id
        /// </summary>
        public string? examId { get; set; }
        /// <summary>
        /// 得分率
        /// </summary>
        public double scoreRate { get; set; }
        /// <summary>
        /// 配分
        /// </summary>
      //  public double allocation { get; set; }
        /// <summary> 
        /// 暂不计算
        /// 每个题的得分情况
        /// </summary>
        // public List<double> itemScores { get; set; } = new List<double>();
    }

    public class InteractRecord
    {
       
        /// <summary>
        ///    { "PopQuesLoad", "ReAtmpAnsStrt", "BuzrAns", "BuzrLoad", "PickupResult" };
        /// </summary>
        public string? interactType { get; set; }
        /// <summary>
        /// 互动结果权重，纳入学习状态计算
        /// </summary>
        public double resultWeight { get; set; }
        /// <summary>
        /// 互动结果类型，如：T0没有作答, 没有参与,T1作答错误,有参加，有抢权,TP部分正确,TT作答正确，抢权成功，被抽到
        /// </summary>
        public string? resultType { get; set; }
         /// <summary>
         /// 互动结果分值
         /// </summary>
        //public double resultScore { get; set; }
        /// <summary>
        ///  互动积分，试题评分
        /// </summary>
        public double interactScore { get; set; }
        /// <summary>
        /// 基准分值
        /// </summary>
        public double criterion { get; set; }
    }
    public static class InteractReultType 
    {
        /// <summary>
        /// 没有作答, 没有参与0
        /// </summary>
        public static readonly string T0 = "T0";
        /// <summary>
        /// 作答错误,有参加，有抢权1
        /// </summary>
        public static readonly string T1 = "T1";
        /// <summary>
        /// 部分正确1.3
        /// </summary>
        public static readonly string TP = "TP";
        /// <summary>
        /// 作答正确，抢权成功，被抽到1.5
        /// </summary>
        public static readonly string TT ="TT";

    }
    public static class InteractWeight 
    {
        /// <summary>
        /// 没有作答, 没有参与0
        /// </summary>
        public static readonly double T0 = 0;
        /// <summary>
        /// 作答错误,有参加，有抢权1
        /// </summary>
        public static readonly double T1 = 1;
        /// <summary>
        /// 部分正确1.3
        /// </summary>
        public static readonly double TP =1.3;
        /// <summary>
        /// 作答正确，抢权成功，被抽到1.5
        /// </summary>
        public static readonly double TT = 1.5;

        /// 互动参与指数（按倍数的权重设计）
        /// 无二次作答的互动，且未设置正确答案：1.未作答0
        ///                                     2.已作答1
        ///                                     
        /// 无二次作答的互动，且设置了正确答案：3.未作答0
        ///                                     4.已作答1
        ///                                     5.不完全正确1.3 
        ///                                     6.作答正确1.5
        ///                     
        ///                                     
        /// 有二次作答的互动，且未设置正确答案：7.第一次未作答0，第二次未作答0=》0
        ///                                     8.第一次已作答1，第二次未作答0=》1
        ///                                     9.第一次未作答0，第二次已作答1=》1
        ///                                     10.第一次已作答1，第二次已作答1=》2
        ///                                     
        /// 有二次作答的互动，且设置了正确答案：（16种可能）
        ///                                     11.第一次未作答0，第二次未作答0=》0
        ///                                     12.第一次已作答，不完全正确1.3，第二次未作答0=》1.3
        ///                                     13.第一次已作答，作答正确1.5，第二次未作答0=》1.5
        ///                                     14.第一次已作答，作答错误1，第二次未作答0=》1
        ///                                     15.第一次未作答0，第二次已作答，不完全正确1.3=》1.3
        ///                                     16.第一次未作答0，第二次已作答，作答正确1.5=》1.5
        ///                                     17.第一次未作答0，第二次已作答，作答错误1=》1
        ///                                     18.第一次已作答，作答错误1，第二次已作答，作答错误1=》2
        ///                                     19.第一次已作答，不完全正确1.3，第二次已作答，作答错误1=》2.3
        ///                                     20.第一次已作答，作答正确1.5，第二次已作答，作答错误1=》2.5
        ///                                     21.第一次已作答，作答错误1，第二次已作答，不完全正确1.3=》2.3
        ///                                     22.第一次已作答，作答错误1，第二次已作答，作答正确1.5=》2.5
        ///                                     23.第一次已作答，不完全正确1.3，第二次已作答，不完全正确1.3=》2.6
        ///                                     24.第一次已作答，不完全正确1.3，第二次已作答，作答正确1.5=》2.8
        ///                                     25.第一次已作答，作答正确1.5，第二次已作答，不完全正确1.3=》2.8
        ///                                     26.第一次已作答，作答正确1.5，第二次已作答，作答正确1.5=》3
        ///                                     
        /// 抢权模式：                          27.未参与抢权 0
        ///                                     28.参与抢权 1
        ///                                     29.抢权成功 1.5                                   
        /// 挑人时被挑到                        30.被挑到 1.5                                    
        /// 有三次作答的互动，且设置了正确答案：（64种可能）
        /*
       1	未作答0	未作答0	未作答0	0
       2	未作答0	未作答0	不完全正确1.3	1.3
       3	未作答0	未作答0	作答正确1.5	1.5
       4	未作答0	未作答0	作答错误1	1
       5	未作答0	不完全正确1.3	未作答0	1.3
       6	未作答0	不完全正确1.3	不完全正确1.3	2.6
       7	未作答0	不完全正确1.3	作答正确1.5	2.8
       8	未作答0	不完全正确1.3	作答错误1	2.3
       9	未作答0	作答正确1.5	未作答0	1.5
       10	未作答0	作答正确1.5	不完全正确1.3	2.8
       11	未作答0	作答正确1.5	作答正确1.5	3
       12	未作答0	作答正确1.5	作答错误1	2.5
       13	未作答0	作答错误1	未作答0	1
       14	未作答0	作答错误1	不完全正确1.3	2.3
       15	未作答0	作答错误1	作答正确1.5	2.5
       16	未作答0	作答错误1	作答错误1	2
       17	已作答错误1	未作答0	未作答0	1
       18	已作答错误1	未作答0	不完全正确1.3	2.3
       19	已作答错误1	未作答0	作答正确1.5	2.5
       20	已作答错误1	未作答0	作答错误1	2
       21	已作答错误1	不完全正确1.3	未作答0	2.3
       22	已作答错误1	不完全正确1.3	不完全正确1.3	3.6
       23	已作答错误1	不完全正确1.3	作答正确1.5	3.8
       24	已作答错误1	不完全正确1.3	作答错误1	3.3
       25	已作答错误1	作答正确1.5	未作答0	2.5
       26	已作答错误1	作答正确1.5	不完全正确1.3	3.8
       27	已作答错误1	作答正确1.5	作答正确1.5	4
       28	已作答错误1	作答正确1.5	作答错误1	3.5
       29	已作答错误1	作答错误1	未作答0	2
       30	已作答错误1	作答错误1	不完全正确1.3	3.3
       31	已作答错误1	作答错误1	作答正确1.5	3.5
       32	已作答错误1	作答错误1	作答错误1	3
       33	已作答不完全正确1.3	未作答0	未作答0	1.3
       34	已作答不完全正确1.3	未作答0	不完全正确1.3	2.6
       35	已作答不完全正确1.3	未作答0	作答正确1.5	2.8
       36	已作答不完全正确1.3	未作答0	作答错误1	2.3
       37	已作答不完全正确1.3	不完全正确1.3	未作答0	2.6
       38	已作答不完全正确1.3	不完全正确1.3	不完全正确1.3	3.9
       39	已作答不完全正确1.3	不完全正确1.3	作答正确1.5	4.1
       40	已作答不完全正确1.3	不完全正确1.3	作答错误1	3.6
       41	已作答不完全正确1.3	作答正确1.5	未作答0	2.8
       42	已作答不完全正确1.3	作答正确1.5	不完全正确1.3	4.1
       43	已作答不完全正确1.3	作答正确1.5	作答正确1.5	4.3
       44	已作答不完全正确1.3	作答正确1.5	作答错误1	3.8
       45	已作答不完全正确1.3	作答错误1	未作答0	2.3
       46	已作答不完全正确1.3	作答错误1	不完全正确1.3	3.6
       47	已作答不完全正确1.3	作答错误1	作答正确1.5	3.8
       48	已作答不完全正确1.3	作答错误1	作答错误1	3.3
       49	已作答正确1.5	未作答0	未作答0	1.5
       50	已作答正确1.5	未作答0	不完全正确1.3	2.8
       51	已作答正确1.5	未作答0	作答正确1.5	3
       52	已作答正确1.5	未作答0	作答错误1	2.5
       53	已作答正确1.5	不完全正确1.3	未作答0	2.8
       54	已作答正确1.5	不完全正确1.3	不完全正确1.3	4.1
       55	已作答正确1.5	不完全正确1.3	作答正确1.5	4.3
       56	已作答正确1.5	不完全正确1.3	作答错误1	3.8
       57	已作答正确1.5	作答正确1.5	未作答0	3
       58   已作答正确1.5   作答正确1.5 不完全正确1.3 4.3
       59   已作答正确1.5   作答正确1.5作答正确1.5  4.5
       60   已作答正确1.5   作答正确1.5作答错误1 4  
       61   已作答正确1.5   作答错误1 未作答0   2.5
       62   已作答正确1.5   作答错误1 不完全正确1.3 3.8
       63   已作答正确1.5   作答错误1 作答正确1.54  
       64   已作答正确1.5   作答错误1 作答错误1 3.5
             */
    }


    /*
     * 
     /// 事件
        /// 推送相关 在Push.json处理 DifObjPush 推送给学生 差异化推送   "PushMemberId":[1,4,8,12,17,18,19,23,24,27,32,36]  ，FastPgPush 同一推送
        /// 互动相关 在IRS.json处理 'PopQuesLoad'互动问答 , 'ReAtmpAnsStrt' 二次作答 , 'BuzrAns'  抢权（新）, 'BuzrLoad'抢权（旧）, PickupResult   挑人算不算互动？？  读取PickupMemberId "[\r\n  35\r\n]"
        /// 测验相关 在IRS.json处理 SPQStrt 测验模式
        /// 任务相关 在Task.json处理 'WrkSpaceLoad' 作品收集, 'WrkCmp' 作品贴上  是什么操作
        /// 评分相关 在SmartRating.json 处理 'SmartRating' 评分模式，分 投票Voting 和 GrandRating  星光大评分（All每人多件评分，Two随机分配互评， Self自评）    
        /// 协作相关 在Cowork.json 处理   CoworkLoad 协作类型   coworkType   All: '全体协作',    Group: '分组协作',   其他的为  : '差异化协作',
     问题汇总：
    TimeLine.json 
    挑人大类 Event= PickupResult 里面 分小类
                PickupType=PickupRight  , PickupOption  , PickupNthGrp  ,PickupEachGrp  ,PickupDiff   五种类型分别是什么意思，是否还有其他类型的。  
                ,"PickupCount":1,"PickupOption":2  ,"PickupGroup":2  这三个字段是什么意思。
                "PickupMemberId":"[\r\n  1\r\n]"  里面是学生的座号还是数组下标。
    "Event":"PressGood","TargetClass":0,"MemberId":"[\r\n  1\r\n]","Count":1},
        是代表什么意思。 MemberId  是座号还说下标。
    8月27日 17:581.   Task.json的  clientWorks.isGroupItem    bool 类型  false代表什么意思   true代表什么意思
2.   Cowork.json 的  coworkType   All: '全体协作',    Group: '分组协作',      : '差异化协作',    差异化协作的简码是什么？  
3.   TimeLine.json 的  类型 PickupResult   挑人算不算互动？？  读取PickupMemberId "[\r\n  35\r\n]"
4.   小组任务具体详细信息如何获取？ 需要精确到 所有小组任务信息和 某一小组的参与情况  用于计算小组任务参与率
     */
}