TEAMModelOS/TEAMModelOS/Controllers/Analysis/AchievementController.cs

using ClouDASLibx;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Helper.Common.StringHelper;
using TEAMModelOS.SDK.DI;
 

using System.Diagnostics;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using TEAMModelOS.SDK.Helper.Security.ShaHash;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.Service.Models;
using TEAMModelOS.SDK.Helper.Network.HttpHelper;
using TEAMModelOS.Service.Analysis.Implements;
using OpenXmlPowerTools;
using System.Text.Json;

namespace TEAMModelOS.Controllers.Analysis
{
    [Route("api/[controller]")]
    [ApiController]
    public class AchievementController : Controller
    {

        private readonly AzureCosmosFactory azureCosmosDBRepository;
         
        private const string CacheCosmosPrefix = "Analysis:";
        private const int timeoutSeconds = 3600;
        public AchievementController( AzureCosmosFactory _azureCosmosDBRepository)
        {
            azureCosmosDBRepository = _azureCosmosDBRepository;
           

        }
        [HttpPost("Achievement")]
        public async Task<BaseResponse> FindExam(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            Dictionary<string, dynamic> info = new Dictionary<string, dynamic>();
            if (RedisHelper.Instance != null)
            {

                info = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + "Achievement",
                   ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), timeoutSeconds, () => { return FindExamRedis(dict, "Achievement"); });

                //数据从redis读取过后进行转换格式
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));

            }
            else
            {
                info = await FindExamRedis(dict, "Achievement");
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));
            }
            return builder.build();

        }
        public async Task<List<ExamResult>> FindExamResultRedis(Dictionary<string, object> dict, string method)
        {
            try
            {
                List<ExamResult> info = await azureCosmosDBRepository.FindByDict<ExamResult>(dict);
                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                    }
                }
                return info;
            }
            catch (Exception e)
            {
                throw new BizException(e.Message);

            }
        }
        public async Task<Dictionary<string, dynamic>> FindExamRedis(Dictionary<string, object> dict, string method) {

            ResponseBuilder builder = ResponseBuilder.custom();
            //Console.WriteLine(DateTimeOffset.Now.Second);
            //
            dict.TryGetValue("subjectCode", out object subjectCode);
            dict.TryGetValue("code", out object code);
            List<ExamResult> exams = new List<ExamResult>();
            /*if (RedisHelper.Instance != null)
            {
                exams = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + "FindExamResultRedis",
                    ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), timeoutSeconds, () => { return FindExamResultRedis(dict, "FindExamResultRedis"); });
            }
            else
            {
                exams = await FindExamResultRedis(dict, "FindExamResultRedis");
            }*/
            List<string> subjectCouns = JsonApiHelper.FromApiJson<List<string>>(subjectCode.ToApiJson());
            for (int i =0;i < subjectCouns.Count;i++ ) {
                if (RedisHelper.Exists(CacheCosmosPrefix + "examResult" + subjectCouns[i]))
                {
                    ExamResult result = RedisHelper.HGet<ExamResult>(CacheCosmosPrefix + "examResult" + subjectCouns[i], ShaHashHelper.GetSHA1(code.ToString()));
                    //builder.Data(info);
                    exams.Add(result);
                }
            }
            

            Dictionary<string, object> stuMap = new Dictionary<string, object>
            {
                { "schoolCode", "Habook" }
            };
            //声明进行标准用来设置进线标准，权重等参数
            dict.TryGetValue("Standard", out object Standard);
            List<Student> students = await azureCosmosDBRepository.FindByDict<Student>(stuMap);
            //Console.WriteLine(DateTimeOffset.Now.Second);
            List<Dictionary<string, object>> examList = new List<Dictionary<string, object>>();
            HashSet<string> classList = new HashSet<string>();
            HashSet<string> classId = new HashSet<string>();
            List<string> subjectAverage = new List<string>();
            List<List<string>> subjectPoints = new List<List<string>>();
            Dictionary<string, object> Average = new Dictionary<string, object>();
            Dictionary<string, object> entryTable = new Dictionary<string, object>();
            Dictionary<string, dynamic> achievementAnalysis = new Dictionary<string, dynamic>();
            List<string> arrSubject = new List<string>();
            List<string> keys = new List<string>();
            List<string> person = new List<string>();
            List<List<double>> subSum = new List<List<double>>();
            List<string> gAverage = new List<string>();
            List<string> cAverage = new List<string>();
            Dictionary<string, object> AclassAverage = new Dictionary<string, object>();
            Dictionary<string, object> passRateMap = new Dictionary<string, object>();
            List<List<string>> passALL = new List<List<string>>();
            List<string> gradeList = new List<string>();
            List<string> areaList = new List<string>();
            List<string> sbujectsList = new List<string>();
            if (exams.IsNotEmpty())
            {
                //存放进线情况统计key值
                keys.Add("name");
                keys.Add("className");
                keys.Add("gradeRank");
                keys.Add("score");
                //初始化进行人数
                double iPersons = 0;
                if (exams.IsNotEmpty())
                {
                    int classLen = exams[0].classes.Count;
                    for (int cls = 0; cls < classLen; cls++)
                    {
                        if (exams[0].classes[cls].TryGetValue(exams[0].classes[cls].Keys.ToArray<string>()[0], out int[] index))
                        {
                            List<double> stuScore = new List<double>();
                            int stdLen = index[1] - index[0] + 1;

                            for (int i = 0; i < stdLen; i++)
                            {
                                stuScore.Add(0);
                            }
                            subSum.Add(stuScore);
                        }
                    }
                }
                int xx = 0;
                //初始化总分
                double sumPoint = 0;
                int sumperson = exams[0].ids.Count;
                for (int i = 0; i < exams[0].ids.Count; i++)
                {
                    if (exams[0].ids[i].Equals("0"))
                    {
                        sumperson--;
                    }
                }
                exams.ForEach(e =>
                {
                    //获取总分数
                    e.result.ForEach(r =>
                    {
                        sumPoint += r.Sum();
                    });
                });
                var gradeAverage = sumPoint / sumperson;
                //存放年级平均
                gAverage.Add(gradeAverage.ToString());
                //任意一次考试数据提取班级信息
                List<Dictionary<string, int[]>> classToName = exams[0].classes;
                //任意一次考试数据提取学生ID信息
                List<string> idToName = exams[0].ids;
                //var gradeAverage = Math.Floor(Math.Round(decimal.Parse((10 / 3).ToString("0.000")), 2));
                List<string> subjects = new List<string>();
                exams.ForEach(e =>
                {

                    int peopleCount = 0;
                    Dictionary<string, object> detail = new Dictionary<string, object>
                    {
                        { "name", e.subjectCode }
                    };
                    subjects.Add(e.subjectCode);
                    List<string> ClassAverage = new List<string>();
                    //计算试卷总分
                    double sum = e.point.Sum();
                    //及格分数
                    double passRate = sum * 0.6;
                    int gradeCount = 0;
                    //初始化科目总分
                    double subjectPoint = 0;

                    //科目平均分
                    double subAverage = 0;
                    //计算班级平均分
                    int classIndex = 0;
                    List<string> passList = new List<string>();
                    e.classes.ForEach(c =>
                    {
                        List<List<string>> classPRL = new List<List<string>>();
                        //初始化班级总分
                        double classPoint = 0;
                        //初始化班级缺考人数
                        int classCount = 0;
                        //初始化班级平均分
                        double points = 0;
                        double passPoint = 0;
                        //初始化及格人数
                        int passCount = 0;
                        //初始化各班参考人数
                        int counts = 0;
                        //c.Keys遍历key值
                        foreach (string key in c.Keys)
                        {
                            classList.Add(key);
                        }
                        //每个班级平均分
                        foreach (int[] value in c.Values)
                        {
                            for (int i = value[0]; i <= value[1]; i++)
                            {
                                //初始化学生单科个人得分
                                double stuPoints = e.result[i].Sum();
                                //Console.WriteLine("xx: "+xx+" classIndex：" + classIndex + "，i：" + i + " value[0]:" + value[0]+ " value[0]:" + value[1]);

                                subSum[classIndex][i - value[0]] = stuPoints + subSum[classIndex][i - value[0]];

                                if (stuPoints > passRate)
                                {
                                    passCount++;
                                    gradeCount++;
                                }

                                classPoint += e.result[i].Sum();
                                if (e.result[i].Sum() == 0)
                                {
                                    classCount++;
                                }
                            }

                            //每个班级实际参考人数
                            counts = value[1] - value[0] - classCount + 1;
                            points = Convert.ToDouble(classPoint) / counts;
                            ClassAverage.Add(points.ToString("0.00"));
                            person.Add(counts + "");

                        }
                        passPoint = Convert.ToDouble(passCount) / counts;
                        passList.Add(passPoint.ToString("0.00"));
                        //classPRM.Add(classPRL);
                        classIndex += 1;
                    });
                    //科目平均分
                    ClassAverage.ForEach(a =>
                    {
                        subjectPoint += Convert.ToDouble(a);
                    });
                    subAverage = subjectPoint / ClassAverage.Count();
                    subjectAverage.Add(subAverage.ToString("0.00"));

                    detail.Add("schoolAverage", subAverage.ToString("0.00"));
                    detail.Add("areaAverage", subAverage.ToString("0.00"));
                    detail.Add("score", ClassAverage);
                    examList.Add(detail);
                    //获取实际参考总人数
                    e.ids.ForEach(i =>
                    {
                        if (!i.Equals("0"))
                        {
                            peopleCount++;
                        }
                    });
                    //班级及格率
                    passALL.Add(passList);
                    //年级及格率

                    double gradePass = Convert.ToDouble(gradeCount) / peopleCount;
                    gradeList.Add(gradePass.ToString("0.00"));
                    //passALL.Add(gradeList);
                    //区级及格率

                    //passALL.Add(areaList);
                    //获取进线人数
                    iPersons = peopleCount * 0.4;

                    //计算每个学生单科成绩
                    for (int i = 0; i < e.ids.Count(); i++)
                    {
                        List<string> info = new List<string>();
                        //info = new List<string>();
                        info.Add(e.ids[i]);
                        info.Add(e.subjectCode);
                        info.Add(e.result[i].Sum() + "");
                        //classId.Add(e.Ids[i]);
                        subjectPoints.Add(info);
                    }
                    keys.Add(e.subjectCode);
                    xx += 1;
                    //subjectPoints = GetMark(e.Result,e.Ids);
                });
                //subjectPoints.ForEach(f => f.GroupBy(f[0]));
                //进线情况统计
                Dictionary<string, List<List<string>>> dicts = new Dictionary<string, List<List<string>>>();
                foreach (IGrouping<string, List<string>> group in subjectPoints.GroupBy(c => c[0]))
                {
                    dicts.Add(group.Key, group.ToList());
                };

                Average.Add("classList", classList);

                List<List<string>> sp = new List<List<string>>();
                //Dictionary<string, int> rankScore = new Dictionary<string, int>();
                List<int> rankScore = new List<int>();
                foreach (string key in dicts.Keys)
                {
                    int score = 0;
                    List<string> values = new List<string>();
                    keys.ForEach(x =>
                    {
                        values.Add("-");
                    });
                    foreach (List<string> val in dicts[key])
                    {
                        int index = keys.IndexOf(val[1]);
                        values[index] = val[2];
                        values[keys.IndexOf("name")] = val[0];
                        score += int.Parse(val[2]);
                        values[keys.IndexOf("score")] = score + "";
                    }
                    rankScore.Add(score);
                    sp.Add(values);
                }
                AchievementService.ReName(sp, idToName, classToName, students);
                //处理人数为整
                string ip = iPersons.ToString("0");
                //初始化进线分数
                int ipoint = 0;
                //计算成绩年级排名
                rankScore.Sort(delegate (int s1, int s2) { return s2.CompareTo(s1); });
                ipoint = rankScore[int.Parse(ip)];
                foreach (List<string> rank in sp)
                {
                    int index = rankScore.IndexOf(int.Parse(rank[3]));
                    rank[2] = (index + 1) + "";
                }
                //排除成绩为零的选手
                for (int i = sp.Count - 1; i >= 0; i--)
                {
                    if (sp[i][0].Equals("0"))
                    {
                        sp.Remove(sp[i]);
                    }
                }
                entryTable.Add("keys", keys);
                entryTable.Add("datas", sp);
                //封装进线人数统计
                List<string> keyLine = new List<string>
                {
                    "gradeRank",
                    "name",
                    "entryNum",
                    "totalNum",
                    "overAverageRate"
                };
                Dictionary<string, object> entryLineBar = new Dictionary<string, object>();
                //存放班级信息
                List<string> className = new List<string>();
                foreach (string cla in classList)
                {
                    className.Add(cla);
                }
                List<List<string>> datas = new List<List<string>>();
                //记录各个班级进线率占比
                List<string> persent = new List<string>();
                int m = 0;
                foreach (List<double> points in subSum)
                {
                    List<string> detail = new List<string>();
                    keyLine.ForEach(x =>
                    {
                        detail.Add("-");
                    });
                    double sum = points.Count;
                    int j = 0;
                    for (int i = 0; i < points.Count; i++)
                    {
                        if (points[i] > ipoint)
                        {
                            j++;
                        }
                    }
                    double Lines = j;
                    detail[1] = className[m].ToString();
                    detail[2] = j.ToString();
                    detail[3] = points.Count.ToString();
                    var t3 = Math.Floor(Math.Round(decimal.Parse((Lines / sum).ToString("0.000")), 2) * 100);
                    persent.Add(t3.ToString());
                    detail[4] = t3.ToString();
                    datas.Add(detail);
                    m++;
                }
                persent.Sort(delegate (string s1, string s2) { return int.Parse(s2).CompareTo(int.Parse(s1)); });
                //存放班级的年级排名
                List<string> ranks = new List<string>();
                foreach (List<string> des in datas)
                {
                    int index = persent.IndexOf(des[4]);
                    des[0] = (index + 1).ToString();
                    ranks.Add((index + 1).ToString());
                }
                //预警统计
                Dictionary<string, object> early = new Dictionary<string, object>();
                List<List<string>> earlyWarning = new List<List<string>>();
                List<string> keyWarning = new List<string>
                {
                    "classId",
                    "totalNum",
                    "average",
                    "standardDeviation",
                    "overAverageRate",
                    "gradeRank"
                };
                int n = 0;
                foreach (List<double> points in subSum)
                {
                    double sum = 0;
                    List<string> classInfo = new List<string>();
                    classInfo.Add(className[n]);
                    classInfo.Add(points.Count.ToString());
                    foreach (int point in points)
                    {
                        sum += point;

                    }
                    double Aver = sum / points.Count;

                    classInfo.Add(Aver.ToString());
                    //存放班级平均
                    cAverage.Add(Aver.ToString());
                    //标准差
                    double powSum = 0;
                    foreach (int point in points)
                    {
                        powSum += Math.Pow(point - Aver, 2);
                    }
                    var pow = Math.Pow(powSum / points.Count, 0.5);
                    classInfo.Add(pow.ToString("0.00"));
                    //超均率
                    var super = (sum - (sum - 100)) / (sum - 100);
                    classInfo.Add(super.ToString("0.00"));
                    //年级排名
                    classInfo.Add(ranks[n]);
                    earlyWarning.Add(classInfo);
                    n++;

                }
                //sbujectsList.Add(subjects);
                passRateMap.Add("subjects", subjects);
                passRateMap.Add("class", passALL);
                passRateMap.Add("grade", gradeList);
                passRateMap.Add("area", areaList);
                //passRate.Add("passRate", passALL);
                early.Add("keys", keyWarning);
                early.Add("datas", earlyWarning);
                AclassAverage = AchievementService.GetAverage(exams, gAverage, cAverage, subSum, students);
                List<Dictionary<string, object>> rankPR = AchievementService.GetPR(exams, subSum, students);

                entryLineBar.Add("keys", keyLine);
                entryLineBar.Add("datas", datas);
                //sp.Sort(delegate (string s1, string s2) { return int.Parse(s1).CompareTo(int.Parse(s2)); });
                Average.Add("subjectAverage", subjectAverage);
                Average.Add("datas", examList);
                achievementAnalysis.Add("passRate", passRateMap);
                achievementAnalysis.Add("average", Average);
                achievementAnalysis.Add("entryLineBar", entryLineBar);
                achievementAnalysis.Add("entryTable", entryTable);
                achievementAnalysis.Add("earlyWarning", early);
                achievementAnalysis.Add("rankPR", rankPR);
                achievementAnalysis.Add("stuAverage", AclassAverage);
                //Redis处理结果集
                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), achievementAnalysis);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), achievementAnalysis);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                    }
                }
                return achievementAnalysis;
            }
            else return achievementAnalysis;
        }
        /* public List<string> GetMark(List<List<int>> point,List<string> ids) {
             List<string> info = null;
             for (int i = 0;i <= ids.Count();i++) {
                 info = new List<string>();
                 info.Add(ids[i]);
                 info.Add(point[i].Sum()+"");

             }
             return info;
         }*/
        [HttpPost("PointAnalysis")]
        public async Task<BaseResponse> PointAnalysis(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            List<Dictionary<string, dynamic>> info = new List<Dictionary<string, dynamic>>();
            if (RedisHelper.Instance != null)
            {

                info = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + "PointAnalysis",
                   ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), timeoutSeconds, () => { return FindPointAnalysisRedis(dict, "PointAnalysis"); });

                //数据从redis读取过后进行转换格式
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));

            }
            else
            {
                info = await FindPointAnalysisRedis(dict, "PointAnalysis");
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));
            }
            return builder.build();
        }
        public async Task<List<Dictionary<string, dynamic>>> FindPointAnalysisRedis(Dictionary<string, object> dict, string method)
        {
             //ResponseBuilder builder = ResponseBuilder.custom();
            List<Dictionary<string, dynamic>> scatterAnalysis = new List<Dictionary<string, dynamic>>();
            //Dictionary<string, object> scatterAnalysis = new Dictionary<string, object>();
            List<ExamResult> exams = new List<ExamResult>();

            dict.TryGetValue("subjectCode", out object subjectCode);
            dict.TryGetValue("code", out object code);
            dict.TryGetValue("schoolCode", out object schoolCode);
            /* List<string> subjectCouns = JsonApiHelper.FromApiJson<List<string>>(subjectCode.ToApiJson());
             for (int i = 0; i < subjectCouns.Count; i++)
             {*/
            if (RedisHelper.Exists(CacheCosmosPrefix + "examResult" + subjectCode.ToString()))
                {
                    ExamResult result = RedisHelper.HGet<ExamResult>(CacheCosmosPrefix + "examResult" + subjectCode.ToString(), ShaHashHelper.GetSHA1(code.ToString()));
                    //builder.Data(info);
                    exams.Add(result);
                }
            //}
            //List<Student> students = await azureCosmosDBRepository.FindByDict<Student>(stuMap);
            List<Student> students = null;
            if (RedisHelper.Exists(CacheCosmosPrefix + "students"))
            {
                students = RedisHelper.HGet<List<Student>>(CacheCosmosPrefix + "students", ShaHashHelper.GetSHA1(schoolCode.ToString()));
                //builder.Data(info);
                //students.Add(student);
            }
            List<string> key = new List<string>
            {
                "name",
                "className",
                "x",
                "y",
                "memberId",
                "score",
                "trueNum",
                "falseNum",
                "hardList",
                "carefulList",
                "scatter"
            };
            //key.Add("areaName");
            if (exams.IsNotEmpty())
            {
                //提取班级信息
                List<Dictionary<string, int[]>> classToName = exams[0].classes;
                //提取学生ID信息
                List<string> idToName = exams[0].ids;
                exams.ForEach(e =>
                {
                    Dictionary<string, object> detail = new Dictionary<string, object>
                    {
                        { "keys", key }
                    };
                    List<List<string>> datas = new List<List<string>>();
                    Dictionary<string, object> subject = new Dictionary<string, object>
                    {
                        { "name", e.subjectCode }
                    };
                    double[] point = StringHelper.ListTodouble(e.point);
                    double[,] result = StringHelper.ListToDouble(e.result);
                    try
                    {
                        var cdm = new ClouDASMatrix(result, point);
                        //学生通过率
                        List<double> pass = cdm.PassingRate;
                        //学生稳定度
                        List<double> sta = cdm.StabilityRate;
                        //落点区域
                        List<string> stu = cdm.StuFallArea;
                        //需努力的题型
                        List<int[]> strive = cdm.StriveTopic;
                        //需小心的题型
                        List<int[]> careful = cdm.CarefulTopic;
                        int i = 0;
                        for (int k = e.ids.Count - 1; k >= 0; k--)
                        {
                            if (e.ids[k].Equals("0"))
                            {
                                e.ids.Remove(e.ids[k]);
                            }
                        }
                        e.ids.ForEach(s =>
                        {
                            if (e.result[i].Sum() != 0)
                            {
                                List<string> info = new List<string>
                                {
                                    s,
                                    "-",
                                    sta[i].ToString(),
                                    pass[i].ToString(),
                                    i + 1 + "",
                                    e.result[i].Sum().ToString()
                                };
                                int right = 0;
                                int wrong = 0;
                                foreach (int p in e.result[i])
                                {
                                    if (p > 0)
                                    {
                                        right++;
                                    }
                                    else
                                    {
                                        wrong++;
                                    }
                                }
                                info.Add(right + "");
                                info.Add(wrong + "");
                                int[] str = strive[i];
                                string striveAll = "";

                                foreach (int n in str)
                                {
                                    striveAll += n.ToString() + ",";
                                }
                                int[] care = careful[i];
                                string careAll = "";
                                foreach (int n in care)
                                {
                                    careAll += n.ToString() + ",";
                                }
                                if (string.IsNullOrEmpty(striveAll))
                                {
                                    info.Add("无");
                                }
                                else {
                                    info.Add(striveAll.Substring(0, striveAll.Length - 1));
                                }
                                if (string.IsNullOrEmpty(careAll))
                                {
                                    info.Add("无");
                                }
                                else
                                {
                                    info.Add(careAll.Substring(0, careAll.Length - 1)); ;
                                }                               
                                info.Add(stu[i].ToString());
                                datas.Add(info);

                            }
                            i++;
                        });
                        AchievementService.ReName(datas, idToName, classToName, students);
                        detail.Add("datas", datas);
                        subject.Add("scatter", detail);
                        scatterAnalysis.Add(subject);

                    }
                    catch (Exception ex)
                    {
                        //builder.Data(exams);
                        //ex.Message;
                        Console.WriteLine("---------------------" + ex.Message + "--------------------------");
                    }

                });
                //Redis处理结果集
                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), scatterAnalysis);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), scatterAnalysis);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                    }
                }
                return scatterAnalysis;
            }else return scatterAnalysis;

        }

        [HttpPost("ExerciseScatter")]
        public async Task<BaseResponse> ExerciseScatter(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            List<Dictionary<string, dynamic>> info = new List<Dictionary<string, dynamic>>();
            if (RedisHelper.Instance != null)
            {

                info = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + "ExerciseScatter",
                   ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), timeoutSeconds, () => { return FindExerciseScatterRedis(dict, "ExerciseScatter"); });

                //数据从redis读取过后进行转换格式
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));

            }
            else
            {
                info = await FindExerciseScatterRedis(dict, "ExerciseScatter");
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));
            }
            return builder.build();
        }
        public async Task<List<Dictionary<string, dynamic>>> FindExerciseScatterRedis(Dictionary<string, object> dict, string method)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            HashSet<string> classList = new HashSet<string>();
            List<Dictionary<string, object>> exerciseScatter = new List<Dictionary<string, object>>();
            Dictionary<string, object> scatterAnalysis = new Dictionary<string, object>();
            dict.TryGetValue("subjectCode", out object subjectCode);
            dict.TryGetValue("schoolCode", out object schoolCode);
            dict.TryGetValue("code", out object code);
            //dict.TryGetValue("scopeCode", out object scopeCode);
/*            Dictionary<string, object> sub = new Dictionary<string, object>
            {
                { "subjectCode",  subjectCode.ToString()},
                { "code",code.ToString()}
            };
            Dictionary<string, object> examMap = new Dictionary<string, object>
            {
                { "subjectCode", subjectCode.ToString()},
                { "code", code.ToString()},
                { "schoolCode", schoolCode.ToString()}
            };*/
            //List<ExamResult> exams = await azureCosmosDBRepository.FindByDict<ExamResult>(examMap);
            List<ExamResult> exams = new List<ExamResult>();
            if (RedisHelper.Exists(CacheCosmosPrefix + "examResult" + subjectCode.ToString()))
            {
                ExamResult result = RedisHelper.HGet<ExamResult>(CacheCosmosPrefix + "examResult" + subjectCode.ToString(), ShaHashHelper.GetSHA1(code.ToString()));
                exams.Add(result);
            }            
            List<Paper> paper = new List<Paper>();
            if (RedisHelper.Exists(CacheCosmosPrefix + "paperInfo" + subjectCode.ToString()))
            {
                Paper paper1 = RedisHelper.HGet<Paper>(CacheCosmosPrefix + "paperInfo" + subjectCode.ToString(), ShaHashHelper.GetSHA1(code.ToString()));
                paper.Add(paper1);              
            }
          

            List<string> key = new List<string>
            {
                "id",
                "type",
                "areaName",
                "score",
                "diff",
                "identify",
                "classScoreRate",
                "gradeScoreRate",
                "areaScoreRate",
                "highScoreRate",
                "lowScoreRate",
                "knowledgePoint",
                "R1",
                "R2",
                "R3",
                "R4",
                "R5",
                "R6",
                "PH",
                "PL",
                "X",
                "Y",
                "knowledge"
            };
            //key.Add("areaName");
            if (exams.IsNotEmpty())
            {
                exams.ForEach(e =>
                {
                    List<double> gradeAnswer = new List<double>();
                    List<string> grasdepersent = new List<string>();
                    for (int n = 0; n < e.point.Count; n++)
                    {
                        gradeAnswer.Add(0);
                    }
                    //参考人数
                    double Qnum = 0;
                    e.ids.ForEach(i =>
                    {
                        if (!i.Equals("0"))
                        {
                            Qnum++;
                        }
                    });
                    Dictionary<string, object> detail = new Dictionary<string, object>
                    {
                        { "keys", key }
                    };
                    List<List<string>> datas = new List<List<string>>();
                    List<string[]> itemAnalysis = new List<string[]>();
                    Dictionary<string, object> subject = new Dictionary<string, object>
                    {
                        { "name", e.subjectCode }
                    };
                    Dictionary<string, object> classPersent = new Dictionary<string, object>();
                    List<List<string>> classdatas = new List<List<string>>();
                    try
                    {
                        e.classes.ForEach(c =>
                        {
                            //初始化每题得分情况
                            List<int> answerCount = new List<int>();
                            List<string> persent = new List<string>();
                            double peopleCount = 0;
                            for (int n = 0; n < e.point.Count; n++)
                            {
                                answerCount.Add(0);
                            }
                            int qCount = 0;
                            //int right = 0;
                            //c.Keys遍历key值
                            foreach (string keys in c.Keys)
                            {
                                classList.Add(keys);
                            }
                            //每个班级得分占比
                            foreach (int[] value in c.Values)
                            {
                                for (int i = value[0]; i <= value[1]; i++)
                                {
                                    if (e.result[i].Sum() > 0)
                                    {
                                        for (int j = 0; j < e.result[i].Count; j++)
                                        {
                                            if (e.result[i][j] > 0)
                                            {
                                                //记录班级每题得分数
                                                answerCount[j] = answerCount[j] + 1;
                                                //记录年级每题得分数
                                                gradeAnswer[j] = gradeAnswer[j] + 1;

                                                //right++;
                                            }
                                        }
                                    }
                                    else
                                    {
                                        qCount++;
                                    }

                                    peopleCount = value[1] - value[0] + 1 - qCount;
                                }
                            }
                            foreach (int p in answerCount)
                            {
                                var t = Math.Floor(Math.Round(decimal.Parse((p / peopleCount).ToString("0.000")), 2) * 100);
                                persent.Add(t.ToString());

                            }
                            classdatas.Add(persent);
                        });
                        classPersent.Add("classList", classList);
                        classPersent.Add("datas", classdatas);
                        exerciseScatter.Add(classPersent);


                        double[] point = StringHelper.ListTodouble(e.point);
                        double[,] result = StringHelper.ListToDouble(e.result);
                        var cdm = new ClouDASMatrix(result, point);
                        //试题Y
                        List<double> answer = cdm.AnswerRate;
                        //试题X
                        List<double> quality = cdm.QualityRate;
                        //试题区域
                        List<string> topic = cdm.TopicFallArea;
                        //试题相关分析结果
                        List<(double Diff, double Identify, double R1, double R2, double R3, double R4, double R5, double R6, double RH, double RL)> rs = cdm.RS;
                        for (int i = 0; i < rs.Count; i++)
                        {
                            string[] ex = new string[] { };
                            string ss = rs[i].ToString()[1..^1];
                            ex = ss.Split(",");
                            itemAnalysis.Add(ex);
                        }
                        foreach (int p in gradeAnswer)
                        {
                            var t = Math.Floor(Math.Round(decimal.Parse((p / Qnum).ToString("0.000")), 2) * 100);
                            grasdepersent.Add(t.ToString());
                        }
                        for (int k = 0; k < e.point.Count; k++)
                        {
                            List<string> values = new List<string>();
                            key.ForEach(x =>
                            {
                                values.Add("-");
                            });
                            values[0] = (k + 1).ToString();
                            values[1] = paper[0].item[k].type;
                            values[2] = topic[k].ToString();
                            values[3] = e.point[k].ToString();
                            values[4] = itemAnalysis[k][0];
                            values[5] = itemAnalysis[k][1];
                            values[7] = grasdepersent[k];
                            values[8] = grasdepersent[k];
                            values[12] = itemAnalysis[k][2];
                            values[13] = itemAnalysis[k][3];
                            values[14] = itemAnalysis[k][4];
                            values[15] = itemAnalysis[k][5];
                            values[16] = itemAnalysis[k][6];
                            values[17] = itemAnalysis[k][7];
                            values[18] = itemAnalysis[k][8];
                            values[19] = itemAnalysis[k][9];
                            values[20] = quality[k].ToString();
                            values[21] = answer[k].ToString();
                            string pointName = "";
                            if (paper[0].item[k].points.Count == 1 ) {
                                foreach (string index in paper[0].item[k].points)
                                {
                                    pointName = index ;
                                }
                            } else if (paper[0].item[k].points.Count > 1) {
                                foreach (string index in paper[0].item[k].points)
                                {
                                    pointName += index + ",";
                                }
                            }                           
                            values[22] = pointName;
                            datas.Add(values);


                        }
                        subject.Add("keys", key);
                        subject.Add("datas", datas);
                        exerciseScatter.Add(subject);

                    }
                    catch (Exception ex)
                    {
                        throw new BizException(ex.Message);
                    }

                });
                //Redis处理结果集
                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), exerciseScatter);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), exerciseScatter);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                    }
                }
                return exerciseScatter;
            }
            else return exerciseScatter;
        }


        public async Task<Dictionary<string, dynamic>> FindKnowledgePointRedis(Dictionary<string, object> dict, string method)
        {
            //ResponseBuilder builder = ResponseBuilder.custom();
            dict.TryGetValue("subjectCode", out object subjectCode);
            dict.TryGetValue("schoolCode", out object schoolCode);
            dict.TryGetValue("code", out object code);
            //dict.TryGetValue("scopeCode", out object scopeCode);
           /* Dictionary<string, object> sub = new Dictionary<string, object>
            {
                { "subjectCode",  subjectCode.ToString()},
                { "code",code.ToString()}

            };
            Dictionary<string, object> examMap = new Dictionary<string, object>
            {
                { "schoolCode", schoolCode.ToString()},
                { "code", code.ToString()},
                { "subjectCode",  subjectCode.ToString()}


            };*/
            List<ExamResult> exams = new List<ExamResult>();

                if (RedisHelper.Exists(CacheCosmosPrefix + "examResult" + subjectCode.ToString()))
                {
                    ExamResult res = RedisHelper.HGet<ExamResult>(CacheCosmosPrefix + "examResult" + subjectCode.ToString(), ShaHashHelper.GetSHA1(code.ToString()));
                    exams.Add(res);
                }
            List<Paper> paper = new List<Paper>();
            if (RedisHelper.Exists(CacheCosmosPrefix + "paperInfo" + subjectCode.ToString()))
            {

                Paper papers = RedisHelper.HGet<Paper>(CacheCosmosPrefix + "paperInfo" + subjectCode.ToString(), ShaHashHelper.GetSHA1(code.ToString()));
                paper.Add(papers);
            }          
            Dictionary<string, object> stuMap = new Dictionary<string, object>
            {
                { "schoolCode", "Habook" }
            };
            //List<Student> students = await azureCosmosDBRepository.FindByDict<Student>(stuMap);
            List<Student> students = null;
            if (RedisHelper.Exists(CacheCosmosPrefix + "students"))
            {
                students = RedisHelper.HGet<List<Student>>(CacheCosmosPrefix + "students", ShaHashHelper.GetSHA1(schoolCode.ToString()));
                //builder.Data(info);
                //students.Add(student);
            }
            HashSet<string> knowledge = new HashSet<string>();
            HashSet<string> area = new HashSet<string>();
            List<double> point = new List<double>();
            List<List<double>> result = new List<List<double>>();
            List<Dictionary<string, int[]>> classes = new List<Dictionary<string, int[]>>();
            List<string> ids = new List<string>();
            //string Type = "";
            if (dict.TryGetValue("type", out object Type))
            {
                paper.ForEach(p =>
                {
                    p.item.ForEach(i =>
                    {

                        knowledge.Add(i.field);
                        area.Add(i.field);


                    });
                });
            }
            else {
                paper.ForEach(p =>
                {
                    p.item.ForEach(i =>
                    {
                        i.points.ForEach(o =>
                        {
                            knowledge.Add(o);
                        });
                        area.Add(i.field);


                    });
                });
            }

            double Qnum = 0;
            //确定高分组 低分组人数
            List<List<double>> re = exams[0].result;
            List<double> resultSum = new List<double>();
            foreach (List<double> data in re)
            {
                resultSum.Add(data.Sum());
            }
            //确定高分组 最低分数
            resultSum.Sort(delegate (double s1, double s2) { return s2.CompareTo(s1); });
            for (int i = resultSum.Count - 1; i >= 0; i--)
            {
                if (resultSum[i] == 0)
                {
                    resultSum.Remove(resultSum[i]);
                }
            }
            double rhwCount = resultSum.Count * 0.27;
            double rhw = resultSum[int.Parse(rhwCount.ToString("0"))];
            //确定低分组 最高分数
            resultSum.Sort(delegate (double s1, double s2) { return s1.CompareTo(s2); });
            double rhlCount = resultSum.Count * 0.27;
            double rhl = resultSum[int.Parse(rhwCount.ToString("0"))];
            foreach (ExamResult ex in exams) {
                point = ex.point;
                result = ex.result;
                classes = ex.classes;
                ids = ex.ids;
            }
            /* exams.ForEach(e =>
             {
                 point = e.Point;
                 result = e.Result;
                 classes = e.Classes;
                 ids = e.Ids;
             });*/
            List<string> knowledgeName = new List<string>();
            foreach (string cla in knowledge)
            {
                knowledgeName.Add(cla);
            }
            for (int k = 0;k < knowledgeName.Count;k++ ) {
                if (null == knowledgeName[k]) {
                    knowledgeName.Remove(knowledgeName[k]);
                }
            }
            List<string> areaName = new List<string>();
            foreach (string cla in area)
            {
                areaName.Add(cla);
            }
            for (int k = 0; k < areaName.Count; k++)
            {
                if (null == areaName[k])
                {
                    areaName.Remove(areaName[k]);
                }
            }

            //初始化年级总分
            double total = 0;
            //处理年级单个知识点得分率
            foreach (List<double> grade in result)
            {
                total += grade.Sum();
            }
            foreach (string id in ids)
            {
                if (!id.Equals("0"))
                {
                    Qnum++;
                }
            }
            //试卷总分
            double TotalPoint = point.Sum();
            //计算认知层次占比

            List<string> fper = new List<string>();
            for (int a = 0; a < areaName.Count; a++)
            {
                double fieldPoint = 0;
                paper.ForEach(p =>
                {
                    int n = 0;
                    p.item.ForEach(i =>
                    {
                        if (i.field != null && i.field.Contains(areaName[a]))
                        {
                            fieldPoint += point[n];
                        }
                        n++;
                    });
                });
                double fieldPersent = fieldPoint / TotalPoint;
                fper.Add(fieldPersent.ToString("0.00"));
            }
            //求单个知识点所占分数
            List<string> per = new List<string>();
            List<string> gper = new List<string>();
            List<string> knowPer = new List<string>();
            List<Dictionary<string, double>> eper = new List<Dictionary<string, double>>();
            Dictionary<string, object> knowledgeALL = new Dictionary<string, object>();
            Dictionary<string, object> knowledgeMap = new Dictionary<string, object>();
            Dictionary<string, object> classMap = new Dictionary<string, object>();
            Dictionary<string, object> wrongMap = new Dictionary<string, object>();
            HashSet<string> className = new HashSet<string>();
            List<List<string>> wrongPersent = new List<List<string>>();
            List<string> key = new List<string>
            {
                "id",
                "className",
                "seatNO",
                "point",
                "anwPoint",
                "persent"
            };
            List<string> keyWrong = new List<string>
            {
                "name",
                "point",
                "itemNO",
                "persent",
                "wrong",
                "rhw",
                "rlw"
            };
            for (int k = 0; k < knowledgeName.Count; k++)
            {
                List<string> knowledgeClass = new List<string>();
                List<List<string>> stuPersent = new List<List<string>>();
                double OnePoint = 0;
                //获取每个知识点占有多少分值
                double ePoint = 0;
                double anwGPoint = 0;
                double poG = 0;
                int m = 0;
                List<string> valuew = new List<string>();
                List<string> itemNo = new List<string>();
                keyWrong.ForEach(x =>
                {
                    valuew.Add("-");
                });
                int wrongCount = 0;
                valuew[0] = knowledgeName[k];
                paper.ForEach(p =>
                {
                    int n = 0;
                    if (dict.TryGetValue("type", out object Type)) {
                        p.item.ForEach(i =>
                        {
                            if (i.field != null && i.field.Contains(knowledgeName[k]))
                            {

                                OnePoint += point[n];
                                itemNo.Add((n + 1).ToString());

                            }
                            n++;
                        });
                    } else {
                        p.item.ForEach(i =>
                        {
                            if (i.points != null && i.points.Contains(knowledgeName[k]))
                            {

                                OnePoint += 1 / Convert.ToDouble(i.points.Count) * point[n];
                                itemNo.Add((n + 1).ToString());

                            }
                            n++;
                        });
                    }
                    valuew[1] = OnePoint.ToString();
                    string itemNos = "";
                    foreach (string index in itemNo)
                    {
                        itemNos += index + ",";
                    }
                    valuew[2] = itemNos[0..^1];
                });
                int rhwC = 0;
                int rhlC = 0;
                foreach (string id in ids)
                {
                    if (id.Equals("0") || result[m].Sum() == 0)
                    {
                        m++;
                        continue;
                    }
                    List<string> values = new List<string>();
                    key.ForEach(x =>
                    {
                        values.Add("-");
                    });
                    foreach (Student info in students)
                    {
                        if (info.studentId.Equals(id))
                        {
                            values[2] = info.seatNo.ToString();
                            break;
                        }
                    }
                    //List<string> stu = new List<string>();
                    values[0] = id;
                    values[1] = "-";
                    //List<List<string>> stuItem = new List<List<string>>();
                    int statuCount = 0;
                    paper.ForEach(p =>
                    {
                        int n = 0;
                        double anwPoint = 0;
                        double po = 0;
                        p.item.ForEach(i =>
                        {
                            if (dict.TryGetValue("type", out object Type))
                            {
                                if (i.field!= null && i.field.Contains(knowledgeName[k]))
                                {

                                    //Dictionary<string, double> mapkeyItem = new Dictionary<string, double>();
                                    //OnePoint += 1 / Convert.ToDouble(i.points.Count) * point[n];
                                    //当前认知层次在该题占比多少
                                    ePoint = 1;
                                    anwPoint += result[m][n] * ePoint;
                                    //所有学生单个认知层次得分情况
                                    anwGPoint += result[m][n] * ePoint;
                                    po += point[n] * ePoint;
                                    //认知层次所占分数
                                    poG += point[n] * ePoint;
                                    if (result[m][n] == 0 && statuCount == 0)
                                    {
                                        statuCount++;
                                        wrongCount++;
                                        if (result[m].Sum() >= rhw)
                                        {
                                            rhwC++;
                                        }
                                        if (result[m].Sum() <= rhl)
                                        {
                                            rhlC++;
                                        }
                                    }
                                }
                                n++;
                            }
                            else {
                                if (i.points != null && i.points.Contains(knowledgeName[k]))
                                {

                                    //Dictionary<string, double> mapkeyItem = new Dictionary<string, double>();
                                    //OnePoint += 1 / Convert.ToDouble(i.points.Count) * point[n];
                                    //当前知识点在该题占比多少
                                    ePoint = 1 / Convert.ToDouble(i.points.Count);
                                    anwPoint += result[m][n] * ePoint;
                                    //所有学生单个知识点得分情况
                                    anwGPoint += result[m][n] * ePoint;
                                    po += point[n] * ePoint;
                                    //知识点所占分数
                                    poG += point[n] * ePoint;
                                    if (result[m][n] == 0 && statuCount == 0)
                                    {
                                        statuCount++;
                                        wrongCount++;
                                        if (result[m].Sum() >= rhw)
                                        {
                                            rhwC++;
                                        }
                                        if (result[m].Sum() <= rhl)
                                        {
                                            rhlC++;
                                        }
                                    }
                                }
                                n++;
                            }
                        });
                        double stuPser = anwPoint / po;
                        values[3] = po.ToString();
                        values[4] = anwPoint.ToString();
                        values[5] = stuPser.ToString("0.00");
                        //stuItem.Add(values);
                    });
                    stuPersent.Add(values);
                    m++;
                }
                AchievementService.ReName(stuPersent, ids, classes, students);
                double knowPser = anwGPoint / poG;
                knowPer.Add(knowPser.ToString("0.00"));
                //错题关系表
                valuew[3] = knowPser.ToString("0.00");
                valuew[4] = wrongCount.ToString();
                valuew[5] = rhwC.ToString();
                valuew[6] = rhlC.ToString();
                wrongPersent.Add(valuew);
                knowledgeMap.Add(knowledgeName[k], stuPersent);

                //知识点占比
                double persent = OnePoint / TotalPoint;
                foreach (Dictionary<string, int[]> map in classes)
                {
                    List<string> classPoints = new List<string>();
                    //初始化班级得分                   
                    double anwCPoint = 0;
                    double cpo = 0;
                    foreach (KeyValuePair<string, int[]> kvp in map)
                    {
                        className.Add(kvp.Key);
                        for (int n = kvp.Value[0]; n < kvp.Value[1]; n++)
                        {
                            if (result[n].Sum() == 0) continue;
                            paper.ForEach(p =>
                            {
                                int x = 0;

                                p.item.ForEach(i =>
                                {
                                    if (dict.TryGetValue("type", out object Type))
                                    {
                                        if (i.field != null && i.field.Contains(knowledgeName[k]))
                                        {
                                            //当前认知层次在该题占比多少
                                            ePoint = 1;
                                            anwCPoint += result[n][x] * ePoint;
                                            cpo += point[x] * ePoint;
                                        }
                                        x++;
                                    }
                                    else {
                                        if (i.points != null && i.points.Contains(knowledgeName[k]))
                                        {
                                            //当前知识点在该题占比多少
                                            ePoint = 1 / Convert.ToDouble(i.points.Count);
                                            anwCPoint += result[n][x] * ePoint;
                                            cpo += point[x] * ePoint;
                                        }
                                        x++;
                                    }

                                });

                            });

                        }
                    }
                    double classPser = anwCPoint / cpo;
                    knowledgeClass.Add(classPser.ToString("0.00"));
                }
                classMap.Add(knowledgeName[k], knowledgeClass);
                per.Add(persent.ToString("0.00"));

            }
            knowledgeMap.Add("grade", knowPer);
            knowledgeMap.Add("keys", key);
            classMap.Add("className", className);
            wrongMap.Add("keys", keyWrong);
            wrongMap.Add("datas", wrongPersent);
            knowledgeALL.Add("pointList", knowledgeName);
            knowledgeALL.Add("per", per);
            knowledgeALL.Add("level", areaName);
            knowledgeALL.Add("fper", fper);
            knowledgeALL.Add("stupercent", knowledgeMap);
            knowledgeALL.Add("classpercent", classMap);
            knowledgeALL.Add("wrong", wrongMap);
            //builder.Data(knowledgeALL);

            //Redis处理结果集
            if (RedisHelper.Instance != null)
            {
                if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                {
                    await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), knowledgeALL);
                }
                else
                {
                    await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), knowledgeALL);
                    await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                }
            }
            return knowledgeALL;
        }

        [HttpPost("knowledgePoint")]
        public async Task<BaseResponse> KnowledgePoint(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            Dictionary<string, dynamic> info = new Dictionary<string, dynamic>();
            if (RedisHelper.Instance != null)
            {

                info = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + "knowledgePoint",
                   ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), timeoutSeconds, () => { return FindKnowledgePointRedis(dict, "knowledgePoint"); });

                //数据从redis读取过后进行转换格式
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));

            }
            else
            {
                info = await FindKnowledgePointRedis(dict, "knowledgePoint");
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));
            }
            return builder.build();
        }
        [HttpPost("FindExamInfo")]
        public async Task<BaseResponse> FindExamInfo(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            if (RedisHelper.Instance != null)
            {
                try {
                    ///RedisHelper.Instance.CurrentSerialize = obj => System.Text.Json.JsonSerializer.Serialize(obj);
                   /// RedisHelper.Instance.CurrentDeserialize = (json, type) => System.Text.Json.JsonSerializer.Deserialize(json, type);
                    List<ExamInfo> info = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + "FindExamInfo",
                    ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), timeoutSeconds, () => { return FindExamInfoRedis(dict, "FindExamInfo"); });
                 
                    builder.Data(info);
                } catch (Exception e) {
                    throw new BizException(e.Message);
                }             
            }
            else
            {
                List<ExamInfo> info =  await FindExamInfoRedis(dict, "FindExamInfo");
                builder.Data(info);
            }
            return builder.build();
        }

        public async Task<List<ExamInfo>> FindExamInfoRedis(Dictionary<string, object> dict,string method)
        {
            try {
                List<ExamInfo> info = await azureCosmosDBRepository.FindByDict<ExamInfo>(dict);

                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                    }
                }
                return info;
            } catch (Exception e) {
                throw new BizException(e.Message);

            }
        }

        [HttpPost("FindExamPaper")]
        public BaseResponse FindExamPaper(JsonElement request)
        {
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            dict.TryGetValue("subjectCode", out object subjectCode);
            dict.TryGetValue("code", out object code);
            ResponseBuilder builder = ResponseBuilder.custom();
            /*if (RedisHelper.Instance != null)
            {

                 List<Paper> info = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + request.method,
                     ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(request.@params)), timeoutSeconds, () => { return FindExamPaperRedis(request.@params, request.method); });
                 builder.Data(info);

             }
             else
             {
                 List<Paper> info = await FindExamPaperRedis(request.@params, request.method);
                 builder.Data(info);
             }*/
            List<Paper> paper = new List<Paper>();
            if (RedisHelper.Exists(CacheCosmosPrefix + "paperInfo" + subjectCode.ToString()))
            {
                Paper paper1 = RedisHelper.HGet<Paper>(CacheCosmosPrefix + "paperInfo" + subjectCode.ToString(), ShaHashHelper.GetSHA1(code.ToString()));
                paper.Add(paper1);
                builder.Data(paper);
            }

            return builder.build();
        }
        public async Task<List<Paper>> FindExamPaperRedis(Dictionary<string, object> dict, string method)
        {
            try
            {
                List<Paper> info = await azureCosmosDBRepository.FindByDict<Paper>(dict);
                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                    }
                }
                return info;
            }
            catch (Exception e)
            {
                throw new BizException(e.Message);

            }
        }
        [HttpPost("FindExamAnswer")]
        public BaseResponse FindExamAnswer(JsonElement request)
        {
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            dict.TryGetValue("subjectCode", out object subjectCode);
            dict.TryGetValue("code", out object code);
            ResponseBuilder builder = ResponseBuilder.custom();
            List<ExamAnswer> exams = new List<ExamAnswer>();
            if (RedisHelper.Exists(CacheCosmosPrefix + "examAnswer" + subjectCode.ToString()))
            {
                ExamAnswer exam = RedisHelper.HGet<ExamAnswer>(CacheCosmosPrefix + "examAnswer" + subjectCode.ToString(), ShaHashHelper.GetSHA1(code.ToString()));
                exams.Add(exam);
                builder.Data(exams);
            }

            return builder.build();
        }
        public async Task<List<ExamAnswer>> FindExamAnswerRedis(Dictionary<string, object> dict, string method)
        {
            try
            {
                List<ExamAnswer> info = await azureCosmosDBRepository.FindByDict<ExamAnswer>(dict);
                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                    }
                }
                return info;
            }
            catch (Exception e)
            {
                throw new BizException(e.Message);

            }
        }

        public async Task<List<ExamAnswer>> FindExamAnswerRedis(Dictionary<string, object> dict)
        {
            try
            {
                List<ExamAnswer> info = await azureCosmosDBRepository.FindByDict<ExamAnswer>(dict);
                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + "FindExamAnswer"))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + "FindExamAnswer", ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + "FindExamAnswer", ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), info);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + "FindExamAnswer", timeoutSeconds);
                    }
                }
                return info;
            }
            catch (Exception e)
            {
                throw new BizException(e.Message);

            }
        }
        [HttpPost("HomeStatistics")]
        public async Task<BaseResponse> HomeStatistics(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            List<Dictionary<string, dynamic>> info = new List<Dictionary<string, dynamic>>();
            if (RedisHelper.Instance != null)
            {

                info = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + "HomeStatistics",
                   ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), timeoutSeconds, () => { return FindHomeStatisticsRedis(dict, "HomeStatistics"); });

                //数据从redis读取过后进行转换格式
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));

            }
            else
            {
                info = await FindHomeStatisticsRedis(dict, "HomeStatistics");
                builder.Data(JsonApiHelper.FromApiJson<System.Text.Json.JsonElement>(info.ToJson()));
            }
            return builder.build();
        }
        public async Task<List<Dictionary<string, dynamic>>> FindHomeStatisticsRedis(Dictionary<string, object> dict, string method) {

            //request.@params.TryGetValue("subjectCode", out object subjectCode);
            dict.TryGetValue("schoolCode", out object schoolCode);
            dict.TryGetValue("code", out object code);
            Dictionary<string, object> eMap = new Dictionary<string, object>
            {
                { "code",  code.ToString()},
                { "type","normal"}
            };
            Dictionary<string, object> SCMap = new Dictionary<string, object>
            {
                { "schoolCode", schoolCode.ToString()},
            };
            //await SaveRedisInfoAsync(eMap);
            //说明 同学校、同类型考试数据
            //List<ExamInfo> exams = await azureCosmosDBRepository.FindByDict<ExamInfo>(eMap);
            List<ExamInfo> exams = new List<ExamInfo>();
            if (RedisHelper.Instance != null)
            {
                exams = await RedisHelper.CacheShellAsync(CacheCosmosPrefix + "FindExamInfo",
                    ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(eMap)), timeoutSeconds, () => { return FindExamInfoRedis(eMap, "FindExamInfo"); });
            }
            else
            {
                exams = await FindExamInfoRedis(eMap, "FindExamInfo");
            }
            List<ExamInfo> newInfo = new List<ExamInfo>();
            //获取各个学段最新的考试信息
            foreach (IGrouping<string, ExamInfo> group in exams.GroupBy(c => c.conditions.period))
            {                 
                ExamInfo examInfo = group.ToList().OrderByDescending(e => e.createTime).ToList().FirstOrDefault();
                newInfo.Add(examInfo);
            };
            //newInfo.Select(e => e.type.Equals("union")); 
            //List<ExamInfo> unionInfo = newInfo.Where(e => e.type.Equals("union")).ToList();
            //exams.GroupBy(e => e.conditions.period);
            //ExamInfo info = exams.OrderByDescending(e => e.createTime).ToList().FirstOrDefault();
            //查询学校对应的年级信息
            //List<School> schools = await azureCosmosDBRepository.FindByDict<School>(SCMap);
            List<School> schools = new List<School>();
            if (RedisHelper.Exists(CacheCosmosPrefix + "schoolInfo"))
            {
                School sc = RedisHelper.HGet<School>(CacheCosmosPrefix + "schoolInfo",
                    ShaHashHelper.GetSHA1(schoolCode.ToString()));
                schools.Add(sc);
            }
            HashSet<string> classList = new HashSet<string>();
            HashSet<string> subjectList = new HashSet<string>();
            List<List<List<string>>> AllPoint = new List<List<List<string>>>();
            List<List<List<string>>> AllPointAverage = new List<List<List<string>>>();
            List<List<List<string>>> AllKeyLine = new List<List<List<string>>>();
            string Period = "";
            string Grade = "";
            List<double> CoreAverage = new List<double>();
            double weightSum = 0;
            try
            {
                List<Period> periods = new List<Period>();
                List<Grade> grades = new List<Grade>();
                foreach (School s in schools)
                {
                    periods = s.period;
                }
                periods.ForEach(p =>
                {
                    if (p.periodName.Equals("初中"))
                    {
                        grades = p.grades;
                    }
                    else if (p.periodName.Equals("高中"))
                    {
                        grades = p.grades;
                    }
                    else
                    {
                        grades = p.grades;
                    }
                });
                List<Dictionary<string, object>> map = new List<Dictionary<string, object>>();
                //循环处理不同年级考试信息
                foreach (Grade g in grades)
                {
                    for (int i = 0; i < newInfo.Count; i++)
                    {
                        if (g.gradeCode.Equals(newInfo[i].conditions.grade))
                        {
                            List<ExamResult> simples = new List<ExamResult>();
                            for (int j = 0; j < newInfo[i].conditions.subject.Count; j++)
                            {
                                ExamResult result = new ExamResult();
                                if (RedisHelper.Exists(CacheCosmosPrefix + "examResult" + newInfo[i].conditions.subject[j]))
                                {
                                    result = RedisHelper.HGet<ExamResult>(CacheCosmosPrefix + "examResult" + newInfo[i].conditions.subject[j],
                                        ShaHashHelper.GetSHA1(newInfo[i].examCode));
                                    simples.Add(result);
                                }
                            }

                            //List<ExamResult> examResults = new List<ExamResult>();                    
                            /*Dictionary<string, object> sub = new Dictionary<string, object>
                            {
                                { "code",  newInfo[i].id}
                            };*/
                            Period = newInfo[i].conditions.period;
                            Grade = newInfo[i].conditions.grade;
                            List<string> subjects = new List<string>();
                            List<List<string>> SubjectClassAverage = new List<List<string>>();
                            List<List<string>> SubjectAverage = new List<List<string>>();
                            //List<List<string>> SubjectClassAverage = new List<List<string>>();
                            //List<ExamResult> simples = await azureCosmosDBRepository.FindByDict<ExamResult>(sub);

                            // 学生总分
                            double coreSum = 0;
                            int stuCount = newInfo[i].stuCount;
                            //初始化进行人数
                            double iPersons = 0;
                            //获取进线人数
                            iPersons = stuCount * 0.4;
                            //
                            List<List<double>> subSum = new List<List<double>>();
                            if (simples.IsEmpty()) continue;
                            double weight = 0.5;
                            weightSum += weight;
                            int classLen = simples[0].classes.Count;
                            for (int cls = 0; cls < classLen; cls++)
                            {
                                if (simples[0].classes[cls].TryGetValue(simples[0].classes[cls].Keys.ToArray<string>()[0], out int[] indexs))
                                {
                                    List<double> stuScore = new List<double>();
                                    int stdLen = indexs[1] - indexs[0] + 1;

                                    for (int n = 0; n < stdLen; n++)
                                    {
                                        stuScore.Add(0);
                                    }
                                    subSum.Add(stuScore);
                                }
                            }

                            simples.ForEach(s =>
                            {
                                subjectList.Add(s.subjectCode);
                                //计算试卷总分
                                double sum = s.point.Sum();
                                //int stuSum = 0;
                                int classIndex = 0;
                                List<string> ClassAverage = new List<string>();
                                List<string> Average = new List<string>();
                                List<string> passList = new List<string>();
                                s.classes.ForEach(c =>
                                {
                                    List<List<string>> classPRL = new List<List<string>>();

                                    //初始化班级总分
                                    double classPoint = 0;
                                    //初始化班级缺考人数
                                    int classCount = 0;
                                    //初始化班级平均得分率
                                    double points = 0;
                                    //初始化班级平均得分率
                                    double AveragePoints = 0;
                                    //初始化各班参考人数
                                    int counts = 0;
                                    //c.Keys遍历key值
                                    foreach (string key in c.Keys)
                                    {
                                        classList.Add(key);
                                    }
                                    //每个班级平均分
                                    foreach (int[] value in c.Values)
                                    {
                                        for (int i = value[0]; i <= value[1]; i++)
                                        {
                                            //初始化学生单科个人得分
                                            double stuPoints = s.result[i].Sum();

                                            subSum[classIndex][i - value[0]] = stuPoints + subSum[classIndex][i - value[0]];

                                            classPoint += s.result[i].Sum();
                                            coreSum += s.result[i].Sum();

                                            if (s.result[i].Sum() == 0)
                                            {
                                                classCount++;
                                            }
                                        }
                                        //每个班级实际参考人数
                                        counts = value[1] - value[0] - classCount + 1;
                                        //stuSum += counts;
                                        points = Convert.ToDouble(classPoint) / counts / sum;
                                        //计算每个班级平均得分
                                        AveragePoints = Convert.ToDouble(classPoint) / counts;
                                        ClassAverage.Add(points.ToString("0.000"));
                                        Average.Add(AveragePoints.ToString());
                                    }
                                    classIndex += 1;
                                });
                                SubjectClassAverage.Add(ClassAverage);
                                SubjectAverage.Add(Average);
                                //subAverage = subjectPoint / ClassAverage.Count();
                                //subjectAverage.Add(subAverage.ToString("0.00"));
                            });
                            double core = coreSum / stuCount * weight;
                            CoreAverage.Add(core);
                            AllPoint.Add(SubjectClassAverage);
                            AllPointAverage.Add(SubjectAverage);

                            //处理人数为整
                            string ip = iPersons.ToString("0");
                            //初始化进线分数
                            int ipoint = 0;
                            List<int> AllPoints = new List<int>();
                            foreach (List<double> points in subSum)
                            {
                                foreach (int po in points)
                                {
                                    AllPoints.Add(po);
                                }
                            }
                            for (int sn = 0; sn < subSum.Count; sn++)
                            {
                                for (int j = 0; j < subSum[sn].Count; j++)
                                {
                                    if (subSum[sn][j].Equals("0"))
                                    {
                                        subSum[sn].Remove(subSum[sn][j]);
                                    }
                                }
                            }
                            //计算成绩年级排名
                            AllPoints.Sort(delegate (int s1, int s2) { return s2.CompareTo(s1); });
                            ipoint = AllPoints[int.Parse(ip)];
                            int m = 0;
                            List<List<string>> KeyLine = new List<List<string>>();
                            foreach (List<double> points in subSum)
                            {
                                List<string> detail = new List<string>();
                                double sum = points.Count;
                                int l = 0;
                                for (int mq = 0; mq < points.Count; mq++)
                                {
                                    if (points[i] > ipoint)
                                    {
                                        l++;
                                    }
                                }
                                double Lines = l;
                                detail.Add(Lines.ToString());
                                detail.Add(points.Count.ToString());
                                var t3 = Math.Floor(Math.Round(decimal.Parse((Lines / sum).ToString("0.000")), 2) * 100);
                                detail.Add(t3.ToString());
                                KeyLine.Add(detail);
                                m++;
                            }
                            AllKeyLine.Add(KeyLine);

                        }
                        //年级成就指标
                        if (weightSum == 0)
                        {
                            weightSum = 1;
                        }
                        double index = CoreAverage.Sum() / weightSum;
                        List<List<double>> AveragePoint = new List<List<double>>();
                        List<List<double>> AverageClassPoint = new List<List<double>>();
                        //List<double> ClassCore = new List<double>();
                        int k = AllPoint.Count;
                        if (k > 0)
                        {
                            for (int m = 0; m < AllPoint[0].Count; m++)
                            {
                                List<double> SubjectAverage = new List<double>();
                                for (int n = 0; n < AllPoint[0][m].Count; n++)
                                {
                                    double startPoint = 0;
                                    for (int f = 0; f < k; f++)
                                    {
                                        startPoint = double.Parse(AllPoint[f][m][n]) + startPoint;
                                    }
                                    SubjectAverage.Add(startPoint / k);
                                }
                                AveragePoint.Add(SubjectAverage);
                            }
                        }
                        //每个班级成就指标
                        int p = AllPointAverage.Count;
                        if (p > 0)
                        {
                            for (int m = 0; m < AllPointAverage[0].Count; m++)
                            {
                                List<double> SubjectAverage = new List<double>();
                                for (int n = 0; n < AllPointAverage[0][m].Count; n++)
                                {
                                    double startPoint = 0;
                                    for (int f = 0; f < k; f++)
                                    {
                                        startPoint = double.Parse(AllPointAverage[f][m][n]) + startPoint;
                                    }
                                    SubjectAverage.Add(startPoint / k);
                                }
                                AverageClassPoint.Add(SubjectAverage);
                            }
                        }
                        int c = AverageClassPoint.Count;
                        List<double> ClassCore = new List<double>();
                        if (c > 0)
                        {
                            for (int j = 0; j < AverageClassPoint[0].Count; j++)
                            {
                                double startAverage = 0;
                                for (int f = 0; f < c; f++)
                                {
                                    startAverage = AverageClassPoint[f][j] + startAverage;
                                }
                                ClassCore.Add(startAverage / weightSum);
                            }
                        }
                        //班级平均进线率
                        int ExamCount = AllKeyLine.Count;
                        List<List<double>> KeyLines = new List<List<double>>();
                        if (ExamCount > 0)
                        {
                            for (int m = 0; m < AllKeyLine[0].Count; m++)
                            {
                                List<double> ClassLine = new List<double>();
                                for (int n = 0; n < AllKeyLine[0][m].Count; n++)
                                {
                                    double startPoint = 0;
                                    for (int f = 0; f < ExamCount; f++)
                                    {
                                        startPoint = double.Parse(AllKeyLine[f][m][n]) + startPoint;
                                    }
                                    ClassLine.Add(startPoint / ExamCount);
                                }
                                KeyLines.Add(ClassLine);
                            }
                        }
                        Dictionary<string, object> AveragePointMap = new Dictionary<string, object>
                        {
                            { "Period",Period},
                            { "Grade",Grade},
                            { "index", index},
                            { "className", classList },
                            { "subjectName", subjectList },
                            { "AveragePoint", AveragePoint },
                            //{ "AverageClassPoint", AverageClassPoint },
                            { "ClassCore", ClassCore },
                            { "KeyLines",KeyLines}
                        };
                        map.Add(AveragePointMap);
                    }   
                }

                //Redis处理结果集
                if (RedisHelper.Instance != null)
                {
                    if (!RedisHelper.Exists(CacheCosmosPrefix + method))
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), map);
                    }
                    else
                    {
                        await RedisHelper.HSetAsync(CacheCosmosPrefix + method, ShaHashHelper.GetSHA1(JsonNetHelper.ToJson(dict)), map);
                        await RedisHelper.ExpireAsync(CacheCosmosPrefix + method, timeoutSeconds);
                    }
                }
                return map;
            }
            catch (Exception e)
            {
                throw new BizException(e.Message);
            }
        }
    }
}