TEAMModelOS/TEAMModelOS.FunctionV4/CosmosDB/TriggerArt.cs

using Azure.Messaging.ServiceBus;
using HTEXLib.COMM.Helpers;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK;
using Azure.Cosmos;
using TEAMModelOS.SDK.Models.Cosmos.Common;
using Azure.Core;
using TEAMModelOS.SDK.Models.Service;
using Microsoft.AspNetCore.Http;
using OpenXmlPowerTools;
using DocumentFormat.OpenXml.Office2010.Excel;
using DocumentFormat.OpenXml.Office2016.Excel;
using static TEAMModelOS.SDK.Models.Cosmos.Student.StudentAnalysis;
using HTEXLib.Helpers.ShapeHelpers;
using DocumentFormat.OpenXml.Spreadsheet;
using NUnit.Framework;
using Microsoft.AspNetCore.Mvc;
using TEAMModelOS.SDK.Models.Cosmos.OpenEntity;
using static System.Formats.Asn1.AsnWriter;

namespace TEAMModelOS.FunctionV4.CosmosDB
{
    public class TriggerArt
    {
        public static async Task Trigger(CoreAPIHttpService _coreAPIHttpService, AzureServiceBusFactory _serviceBus, AzureStorageFactory _azureStorage, DingDing _dingDing,
            CosmosClient client, JsonElement input, TriggerData tdata, AzureRedisFactory _azureRedis, IConfiguration _configuration, HttpTrigger _httpTrigger)
        {
            try
            {
                if ((tdata.status != null && tdata.status.Value == 404))
                {
                    await client.GetContainer(Constant.TEAMModelOS, "Common").DeleteItemStreamAsync(tdata.id, new PartitionKey(tdata.code));
                    ActivityList data = input.ToObject<ActivityList>();
                    //删除blob 相关资料
                    await _azureStorage.GetBlobServiceClient().DeleteBlobs(_dingDing, tdata.school, new List<string> { $"art/{tdata.id}" });
                    await ActivityService.DeleteActivity(_coreAPIHttpService, client, _dingDing, data);
                    var table_cancel = _azureStorage.GetCloudTableClient().GetTableReference("ChangeRecord");
                    List<ChangeRecord> records = await table_cancel.FindListByDict<ChangeRecord>(new Dictionary<string, object>() { { "RowKey", tdata.id } });
                    foreach (var record in records)
                    {
                        try
                        {
                            await table_cancel.DeleteSingle<ChangeRecord>(record.PartitionKey, record.RowKey);
                            await _serviceBus.GetServiceBusClient().CancelMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), record.sequenceNumber);
                        }
                        catch (Exception)
                        {
                            continue;
                        }
                    }
                    return;
                }
                var table = _azureStorage.GetCloudTableClient().GetTableReference("ChangeRecord");
                var adid = tdata.id;
                var adcode = "";
                string blobcntr = null;
                if (tdata.scope.Equals("school"))
                {
                    adcode = $"Activity-{tdata.school}";
                    blobcntr = tdata.school;
                }
                else
                {
                    adcode = $"Activity-{tdata.creatorId}";
                    blobcntr = tdata.creatorId;
                }
                ArtEvaluation art = await client.GetContainer("TEAMModelOS", "Common").ReadItemAsync<ArtEvaluation>(tdata.id, new Azure.Cosmos.PartitionKey($"{tdata.code}"));

                if (art != null)
                {
                    string PartitionKey = string.Format("{0}{1}{2}", art.code, "-", art.progress);
                    List<ChangeRecord> voteRecords = await table.FindListByDict<ChangeRecord>(new Dictionary<string, object>() { { "RowKey", tdata.id }, { "PartitionKey", PartitionKey } });
                    switch (art.progress)
                    {
                        case "pending":
                            var messageVote = new ServiceBusMessage(new { tdata.id, progress = "going", code = tdata.code }.ToJsonString());
                            messageVote.ApplicationProperties.Add("name", "Art");
                            if (voteRecords.Count > 0)
                            {
                                long start = await _serviceBus.GetServiceBusClient().SendScheduleMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), messageVote, DateTimeOffset.FromUnixTimeMilliseconds(tdata.startTime));
                                try
                                {
                                    await _serviceBus.GetServiceBusClient().CancelMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), voteRecords[0].sequenceNumber);
                                }
                                catch (Exception)
                                {
                                }
                                voteRecords[0].sequenceNumber = start;
                                await table.SaveOrUpdate<ChangeRecord>(voteRecords[0]);
                            }
                            else
                            {

                                long start = await _serviceBus.GetServiceBusClient().SendScheduleMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), messageVote, DateTimeOffset.FromUnixTimeMilliseconds(tdata.startTime));
                                ChangeRecord changeRecord = new ChangeRecord
                                {
                                    RowKey = tdata.id,
                                    PartitionKey = PartitionKey,
                                    sequenceNumber = start,
                                    msgId = messageVote.MessageId
                                };
                                await table.Save<ChangeRecord>(changeRecord);
                            }
                            break;
                        case "going":

                            if (art.classes.Count > 0)
                            {
                                List<string> classes = ExamService.getClasses(art.classes, art.stuLists);
                                (List<RMember> tmdIds, List<RGroupList> classLists) = await GroupListService.GetMemberByListids(_coreAPIHttpService, client, _dingDing, classes, art.school, null);
                                var addStudentsCls = tmdIds.FindAll(x => x.type == 2);
                                var addTmdidsCls = tmdIds.FindAll(x => x.type == 1);
                                List<string> tmds = new List<string>();
                                if (addTmdidsCls.IsNotEmpty())
                                {
                                    tmds.AddRange(addTmdidsCls.Select(x => x.id).ToList());
                                }
                                List<StuActivity> stuActivities = new List<StuActivity>();
                                List<StuActivity> tmdActivities = new List<StuActivity>();
                                List<StuActivity> tchActivities = new List<StuActivity>();
                                List<string> sub = new();
                                if (art.subjects.Count > 0)
                                {
                                    foreach (var course in art.subjects)
                                    {
                                        sub.Add(course.id);
                                    }
                                }
                                if (tmds.IsNotEmpty())
                                {
                                    tmds.ForEach(x =>
                                    {
                                        HashSet<string> classIds = new HashSet<string>();
                                        classLists.ForEach(z =>
                                        {
                                            z.members.ForEach(y =>
                                            {
                                                if (y.id.Equals(x) && y.type == 1)
                                                {
                                                    classIds.Add(z.id);
                                                }
                                            });
                                        });
                                        tmdActivities.Add(new StuActivity
                                        {
                                            pk = "Activity",
                                            id = art.id,
                                            code = $"Activity-{x}",
                                            type = "Art",
                                            name = art.name,
                                            startTime = art.startTime,
                                            endTime = art.endTime,
                                            scode = art.code,
                                            scope = art.scope,
                                            school = art.school,
                                            creatorId = art.creatorId,
                                            subjects = sub,
                                            blob = null,
                                            owner = art.owner,
                                            createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                                            ext = new Dictionary<string, JsonElement>() { { "subjects", art.subjects.ToJsonString().ToObject<JsonElement>() } },
                                            taskStatus = -1,
                                            classIds = classIds.ToList()
                                        });
                                    });
                                }
                                if (addStudentsCls.IsNotEmpty())
                                {
                                    addStudentsCls.ForEach(x =>
                                    {
                                        HashSet<string> classIds = new HashSet<string>();
                                        classLists.ForEach(z =>
                                        {
                                            z.members.ForEach(y =>
                                            {
                                                if (y.id.Equals(x.id) && y.code.Equals(art.school) && y.type == 2)
                                                {
                                                    classIds.Add(z.id);
                                                }
                                            });
                                        });
                                        stuActivities.Add(new StuActivity
                                        {
                                            pk = "Activity",
                                            id = art.id,
                                            code = $"Activity-{x.code.Replace("Base-", "")}-{x.id}",
                                            type = "Art",
                                            name = art.name,
                                            startTime = art.startTime,
                                            endTime = art.endTime,
                                            scode = art.code,
                                            scope = art.scope,
                                            school = art.school,
                                            creatorId = art.creatorId,
                                            subjects = sub,
                                            blob = null,
                                            owner = art.owner,
                                            createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                                            ext = new Dictionary<string, JsonElement>() { { "subjects", art.subjects.ToJsonString().ToObject<JsonElement>() } },
                                            taskStatus = -1,
                                            classIds = classIds.ToList()
                                        });
                                    });
                                }
                                await ActivityService.SaveStuActivity(client, _dingDing, stuActivities, tmdActivities, tchActivities);
                                //await StatisticsService.SendServiceBus(list, _configuration, _serviceBus, client)

                            }
                            var messageVoteEnd = new ServiceBusMessage(new { tdata.id, progress = "finish", tdata.code }.ToJsonString());
                            messageVoteEnd.ApplicationProperties.Add("name", "Art");
                            if (voteRecords.Count > 0)
                            {
                                long end = await _serviceBus.GetServiceBusClient().SendScheduleMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), messageVoteEnd, DateTimeOffset.FromUnixTimeMilliseconds(tdata.endTime));
                                try
                                {
                                    await _serviceBus.GetServiceBusClient().CancelMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), voteRecords[0].sequenceNumber);
                                }
                                catch (Exception)
                                {
                                }
                                voteRecords[0].sequenceNumber = end;
                                await table.SaveOrUpdate<ChangeRecord>(voteRecords[0]);
                            }
                            else
                            {
                                long end = await _serviceBus.GetServiceBusClient().SendScheduleMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), messageVoteEnd, DateTimeOffset.FromUnixTimeMilliseconds(tdata.endTime));
                                ChangeRecord changeRecord = new()
                                {
                                    RowKey = tdata.id,
                                    PartitionKey = PartitionKey,
                                    sequenceNumber = end,
                                    msgId = messageVoteEnd.MessageId
                                };
                                await table.Save<ChangeRecord>(changeRecord);
                            }


                            break;
                        case "finish":
                            //判定是否是区级创建的活动内容
                            /* if (art.lost.Count == 0 && art.pass == 0)
                             {
                                 if (art.owner.Equals("area") && string.IsNullOrEmpty(art.pId))
                                 {
                                     *//* List<(string id, string code, List<Tasks> settings)> artSchools = new();
                                      string ql = $"select c.id,c.school,c.settings,c.classes from c where  c.pk = 'Art' and c.pId = '{art.id}'";
                                      await foreach (var item in client.GetContainer("TEAMModelOS", "Common").GetItemQueryStreamIterator(queryText: ql))
                                      {
                                          using var json = await JsonDocument.ParseAsync(item.ContentStream);
                                          if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                                          {
                                              var accounts = json.RootElement.GetProperty("Documents").EnumerateArray();
                                              while (accounts.MoveNext())
                                              {
                                                  JsonElement account = accounts.Current;
                                                  List<Tasks> settings = account.GetProperty("settings").ToObject<List<Tasks>>();
                                                  artSchools.Add((account.GetProperty("id").GetString(), account.GetProperty("school").GetString(), settings));

                                              }
                                          }
                                      }
                                      foreach (var (id, code, settings) in artSchools)
                                      {
                                          List<(string eId, string sId)> ids = new();
                                          var examIds = settings.SelectMany(s => s.task).Where(a => a.type == 1).Select(z => new { z.acId, z.subject }).ToList();
                                          examIds.ForEach(x =>
                                          {
                                              ids.Add((x.acId, x.subject));
                                          });
                                          List<(string code, string sub, List<string> stu)> stuInfo = await getLostAsync(ids, client, code);
                                          List<string> stus = new();
                                          foreach (var lost in stuInfo)
                                          {
                                              if (stus.Count == 0)
                                              {
                                                  stus = stus.Union(lost.stu).ToList();
                                              }
                                              else {
                                                  stus = stus.Intersect(lost.stu).ToList();
                                              }                                          
                                              LostStudent lostStudent = new()
                                              {
                                                  code = lost.code,
                                                  subject = lost.sub,
                                                  stu = lost.stu.Count
                                              };
                                              art.lost.Add(lostStudent);
                                          }
                                          art.miss.Add(stus.Count);

                                      }
                                      art.pass = 1;
                                      await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync<ArtEvaluation>(art, art.id, new PartitionKey(art.code));*//*
                                 }
                                 else
                                 {
                                     //获取当前艺术评价相关评测ID目前暂时排除区级发布的评测信息

                                     *//*List<(string eId, string sId)> ids = new();
                                     var examId = art.settings.SelectMany(x => x.task).Where(c => c.type == 1).Select(z => new { z.acId, z.subject }).ToList();
                                     examId.ForEach(x =>
                                     {
                                         ids.Add((x.acId, x.subject));
                                     });
                                     List<(string code, string sub, List<string> stu)> stuInfo = await getLostAsync(ids, client, art.school);
                                     List<string> stus = new();
                                     foreach (var (code, sub, stu) in stuInfo)
                                     {
                                         if (stus.Count == 0)
                                         {
                                             stus = stus.Union(stu).ToList();
                                         }
                                         else
                                         {
                                             stus = stus.Intersect(stu).ToList();
                                         }
                                         LostStudent lostStudent = new()
                                         {
                                             code = code,
                                             subject = sub,
                                             stu = stu.Count
                                         };
                                         art.lost.Add(lostStudent);
                                     }
                                     art.miss.Add(stus.Count);
                                     //art.miss = stus.Count;
                                     art.pass = 1;
                                     await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync<ArtEvaluation>(art, art.id, new PartitionKey(art.code));*//*
                                 }
                             }*/
                            //根据学校编码去获取区级ID
                            School scInfo = new();
                            //School scInfo = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>($"{art.school}", partitionKey: new Azure.Cosmos.PartitionKey("Base"));
                            var response = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{art.school}", partitionKey: new Azure.Cosmos.PartitionKey("Base"));
                            if (response.Status == 200)
                            {
                                using var cJson = await JsonDocument.ParseAsync(response.ContentStream);
                                scInfo = cJson.ToObject<School>();
                            }
                            ArtSetting setting = new();
                            try
                            {
                                var artResponse = await client.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync($"{scInfo.areaId}", partitionKey: new Azure.Cosmos.PartitionKey("ArtSetting"));
                                if (response.Status == 200)
                                {
                                    using var json = await JsonDocument.ParseAsync(artResponse.ContentStream);
                                    setting = json.ToObject<ArtSetting>();
                                }
                            }
                            catch (Exception e)
                            {

                            }
                            if (art.publish == 0)
                            {
                                //获取该艺术评测的评测Id
                                List<(string id, string subjectId)> ids = new();
                                List<ExamClassResult> examClassResults = new();
                                var examId = art.settings.SelectMany(x => x.task).Where(c => c.type == 1).Select(z => new { z.acId, z.subject }).ToList();
                                examId.ForEach(x =>
                                {
                                    ids.Add((x.acId, x.subject));
                                });
                                List<string> results = new();
                                results = ids.Select(x => x.id).ToList();
                                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Common").GetItemQueryStreamIterator(queryText: $"select value(c) from c where c.examId in ({string.Join(",", results.Select(x => $"'{x}'"))})", requestOptions: new QueryRequestOptions() { PartitionKey = new Azure.Cosmos.PartitionKey($"ExamClassResult-{art.school}") }))
                                {
                                    using var json = await JsonDocument.ParseAsync(item.ContentStream);
                                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                                    {
                                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                                        {
                                            examClassResults.Add(obj.ToObject<ExamClassResult>());
                                        }
                                    }
                                }
                                //获取该艺术评测下面的活动结算结果
                                List<ExamResult> examResults = new();
                                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, Constant.Common).GetItemQueryIterator<ExamResult>(queryText: $"select value(c) from c where c.pk = 'ExamResult' and c.examId in ({string.Join(",", results.Select(o => $"'{o}'"))})"))
                                {
                                    examResults.Add(item);
                                }
                                var sta = examClassResults.SelectMany(x => x.status).ToList();
                                var ansCount = sta.Where(x => x == 0).ToList();
                                var persent = ansCount.Count * 1.0 / sta.Count * 100;
                                var period = scInfo.period.Where(x => x.id.Equals(art.period.id)).FirstOrDefault();

                                List<StudentArtResult> studentArtResults = new();
                                string sql = $"SELECT value c FROM c   where  c.pk='ArtResult' ";
                                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, Constant.Student)
                                    .GetItemQueryIterator<StudentArtResult>(queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"ArtResult-{art.id}") }))
                                {
                                    studentArtResults.Add(item);
                                }
                                List<Task<ItemResponse<StudentArtResult>>> tasks = new List<Task<ItemResponse<StudentArtResult>>>();
                                //新增数据推送 obj => Portrait
                                Portrait portrait = new()
                                {
                                    schoolCode = art.school,
                                    periodId = art.period.id,
                                    subjectId = "subject_art"
                                };
                                //var period = scInfo.period.Where(x => x.id.Equals(art.period.id)).FirstOrDefault();
                                List<(string ptype, string subId, List<(string name, List<string> kno)> knos)> knoledge = new();
                                List<string> subs = new List<string> { "subject_painting", "subject_music" };
                                foreach (var ss in subs)
                                {
                                    knoledge.Add(await getKnowledge(art.periodType, examResults.Where(c => c.subjectId.Equals(ss)).FirstOrDefault().paper.code, client, ss, examResults.Where(c => c.subjectId.Equals(ss)).FirstOrDefault().paper.periodId));
                                }

                                List<(string name, double score, string subject)> blockScore = new();
                                List<(List<(string name, double score, double point, string subject)> studentScore, string stuId)> studentScores = new();
                                foreach (var exam in examResults)
                                {
                                    HashSet<string> knowledge = new HashSet<string>();
                                    List<double> point = new List<double>();
                                    List<List<double>> result = new List<List<double>>();
                                    List<ClassRange> classes = new List<ClassRange>();
                                    //求单个知识点所占分数
                                    List<string> per = new List<string>();

                                    if (exam.paper.knowledge != null && exam.paper.knowledge.Count > 0)
                                    {
                                        exam.paper.knowledge.ForEach(k =>
                                        {
                                            k.ForEach(e =>
                                            {
                                                knowledge.Add(e);
                                            });
                                        });
                                    }
                                    point = exam.paper.point;

                                    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<double> Score = new List<double>();
                                    //List<(string name, double score, string subject)> pointScore = new();                                   
                                    foreach (string id in exam.studentIds) {
                                        //double scores = 0;
                                        List<(string name, double score, double point,string subject)> studentScore = new();
                                        for (int k = 0; k < knowledgeName.Count; k++)
                                        {
                                            int n = 0;
                                            double OnePoint = 0;
                                            double scores = 0;
                                            exam.paper.knowledge.ForEach(kno =>
                                            {
                                                if (kno.Contains(knowledgeName[k]))
                                                {
                                                    var itemPersent = kno.Count > 0 ? 1 / Convert.ToDouble(kno.Count) : 0;
                                                    OnePoint += point[n] * itemPersent;
                                                    int index = exam.studentIds.IndexOf(id);
                                                    if (exam.studentScores[index][n] > 0)
                                                    {
                                                        scores += exam.studentScores[index][n] * itemPersent;
                                                   }
                                                }
                                                n++;
                                            });
                                            studentScore.Add((knowledgeName[k], Math.Round(scores,2), OnePoint, exam.subjectId));                                           
                                        }
                                        studentScores.Add((studentScore,id));
                                    }
                                    for (int k = 0; k < knowledgeName.Count; k++)
                                    {
                                        double OnePoint = 0;
                                        int n = 0;
                                        exam.paper.knowledge.ForEach(kno =>
                                        {
                                            if (kno.Contains(knowledgeName[k]))
                                            {
                                                var itemPersent = kno.Count > 0 ? 1 / Convert.ToDouble(kno.Count) : 0;
                                                OnePoint += point[n] * itemPersent;                                              
                                            }
                                            n++;
                                        });
                                        blockScore.Add((knowledgeName[k], OnePoint, exam.subjectId));
                                        //blockScore.AddRange(pointScore);
                                    }
                                }
                                var bls = blockScore.GroupBy(x => x.subject).Select(v => new
                                {
                                    subjectId = v.Key,
                                    knoScore = v.ToList().GroupBy(k => k.name).Select(z => new
                                    {
                                        knoName = z.Key,
                                        score = z.ToList().Sum(j => j.score)
                                    })
                                });
                                var subjectKnow = knoledge.Where(c => c.ptype.Equals(art.periodType)).Select(x => new { x.subId, x.knos }).ToList();
                                List<(string subjectId, List<(string name, double score, List<string> dim)> bks)> bs = new();
                                foreach (var bb in subjectKnow)
                                {
                                    var kno1 = bls.Where(c => c.subjectId.Equals(bb.subId)).SelectMany(x => x.knoScore).ToList();
                                    //var kno2 = dimensions.Where(c => c.subjectBind.Equals(bb.subId)).Select(x => new { x.dimension,x.blocks}).ToList();
                                    List<(string name, double score)> blockScores = new();
                                    foreach (var k2 in bb.knos)
                                    {
                                        double bsc = 0;
                                        foreach (var k3 in kno1)
                                        {
                                            if (null != k2.kno && k2.kno.Contains(k3.knoName))
                                            {
                                                bsc += k3.score;
                                            }
                                        }
                                        blockScores.Add((k2.name, bsc));
                                    }
                                    var blk = blockScores.Select(x => new
                                    {
                                        x.name,
                                        x.score,
                                        dimension = setting.dimensions.Where(s => s.blocks.Contains(x.name)).Select(x => x.dimension)
                                    });
                                    List<(string name, double score, List<string> dim)> bks = new();
                                    foreach (var bk in blk)
                                    {
                                        bks.Add((bk.name, bk.score, bk.dimension.ToList()));
                                    }
                                    bs.Add((bb.subId, bks));
                                }

                                var blocks = bs.Select(x => new
                                {
                                    x.subjectId,
                                    dim = x.bks.Select(z => new
                                    {
                                        z.name,
                                        z.score,
                                        z.dim
                                    })
                                });


                                //获取学期信息

                                var (currSemester, studyYear, currSemesterDate, date, nextSemester) = SchoolService.GetSemester(period, art.startTime);
                                //总分的占比情况

                                foreach (var rs in studentArtResults)
                                {
                                    foreach (var res in rs.results)
                                    {
                                        if (res.quotaId.Equals("quota_21") && res.score > -1 && res.score < 95)
                                        {
                                            /*res.score *= 1.5;
                                            if (res.score >= 95) {
                                                res.score = new Random().Next(90, 99);
                                            }*/
                                            res.score = Math.Round(res.score);
                                        }
                                    }

                                    //if (rs.totalScore == 0)
                                    //{
                                    foreach (var sc in rs.subjectScores)
                                    {
                                        //if (sc.score == 0)
                                        //{
                                        /* var subjectMore = rs.results.GroupBy(x => x.subjectId).Select(c => new { subject = c.Key, list = c.ToList().Select(m => new { m.quotaId,m.score}) });
                                         var totalScore = subjectMore.Select(x => new { 
                                             x.subject,
                                             quotaScroe =  x.list.Select(c => new {
                                                 c.quotaId,
                                                 c.score
                                             }),
                                         });*/
                                        var quotaPercent = setting.quotas.Select(x => new
                                        {
                                            x.id,
                                            x.percent,
                                            score = x.children.Select(c => new
                                            {
                                                real = rs.results.Where(r => r.quotaId.Equals(c.id) && r.subjectId.Equals(sc.subjectId) && r.score > -1).FirstOrDefault()?.score * c.percent * 0.01,
                                                score = c.children.Select(s => new
                                                {
                                                    real = rs.results.Where(r => r.quotaId.Equals(s.id) && r.subjectId.Equals(sc.subjectId) && r.score > -1).FirstOrDefault()?.score * s.percent * 0.01
                                                }).Sum(n => n.real) * c.percent * 0.01
                                            }).Sum(n => n.real + n.score) * x.percent * 0.01
                                        });
                                        double realScore = Math.Round((double)quotaPercent.Sum(c => c.score), 2);
                                        sc.score = realScore;
                                        //}
                                    }
                                    rs.totalScore = Math.Round(rs.subjectScores.Where(m => m.score >= 0).Sum(z => z.score), 2);
                                    tasks.Add(client.GetContainer(Constant.TEAMModelOS, Constant.Student).ReplaceItemAsync(rs, rs.id, new PartitionKey(rs.code)));

                                    PortraitStudent student = new()
                                    {
                                        studentId = rs.studentId,
                                        name = rs.studentName,
                                        classId = rs.classIds[0]
                                    };
                                    SemesterData semesterData = new()
                                    {
                                        examName = art.name,
                                        examId = art.id,
                                        examDate = art.startTime,
                                        examType = "",
                                        year = studyYear,
                                        semesterId = currSemester.id,
                                        totalScore = 200,
                                        sumScore = rs.totalScore,
                                        excellenceRate = 0,
                                        passRate = 0,
                                    };
                                    int index = 0;
                                    foreach (var sj in art.subjects)
                                    {
                                        ItemScore item = new()
                                        {
                                            name = sj.name,
                                            score = rs.subjectScores.Where(x => x.subjectId.Equals(sj.id)).FirstOrDefault().score,
                                            time = art.startTime,
                                            totalScore = 100,
                                            type = sj.id,
                                            block = blocks.Where(c => c.subjectId.Equals(sj.id))?.FirstOrDefault().dim,
                                            kno = studentScores.Where(c => c.stuId.Equals(rs.studentId)).SelectMany(c => c.studentScore).Where(
                                                p => p.subject.Equals(sj.id)).Select(z => new { 
                                                z.name,
                                                z.score,
                                                z.point,
                                                block = subjectKnow.Where(v => v.subId.Equals(sj.id)).SelectMany(k => k.knos).Where(c => null != c.kno && c.kno.Contains(z.name)).Select(x => x.name)
                                            })
                                        };
                                        index++;
                                        semesterData.itemScore.Add(item);
                                    }
                                    student.semesterData.Add(semesterData);

                                    portrait.students.Add(student);
                                    //}
                                }
                                if (tasks.Count > 0)
                                {
                                    await Task.WhenAll(tasks);
                                }
                                //获取学生信息
                                //(List<RMember> rmembers, List<RGroupList> groups) = await GroupListService.GetMemberByListids(_coreAPIHttpService, client, _dingDing, art.classes, art.school);
                                /* foreach (var member in studentArtResults)
                                 {                                

                                 }*/
                                if (null != period && persent >= 60)
                                {
                                    string location = $"{Environment.GetEnvironmentVariable("Option:Location")}";
                                    var responseData = await _httpTrigger.RequestHttpTrigger(portrait, location, "upsert-student-portrait");
                                }
                            }

                            break;
                    }
                }
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-CosmosDB异常{e.Message}\n{e.StackTrace}\n{e.Status}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}艺术评价异常{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
            }

        }

        private static async Task<(string key, string subId, List<(string name, List<string> kno)>)> getKnowledge(string key, string school, CosmosClient client, string subjectBid, string pId)
        {
            try
            {
                var response = await client.GetContainer("TEAMModelOS", "School").ReadItemStreamAsync(school, new PartitionKey($"Base"));
                string subjectId = string.Empty;
                List<Knowledge> knowledges = new();
                List<(string name, List<string> kno)> blocks = new();
                if (response.Status == 200)
                {
                    using var json = await JsonDocument.ParseAsync(response.ContentStream);
                    School sc = json.ToObject<School>();
                    var subjects = sc.period.Where(p => p.id.Equals(pId)).Select(x => x.subjects);
                    foreach (var sj in subjects)
                    {
                        foreach (var s in sj)
                        {
                            if (!string.IsNullOrWhiteSpace(s.bindId) && s.bindId.Equals(subjectBid))
                            {
                                subjectId = s.id;
                            }
                        }
                    }

                    string code = $"Knowledge-{school}-{subjectId}";
                    StringBuilder sql = new StringBuilder($"select value(c) from c");
                    if (string.IsNullOrWhiteSpace(pId))
                    {
                        sql.Append($" where c.periodId = '{pId}'");
                    }

                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<Knowledge>(queryText: sql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"{code}") }))
                    {
                        knowledges.Add(item);
                    }
                }
                foreach (var know in knowledges)
                {
                    foreach (var block in know.blocks)
                    {
                        blocks.Add((block.name, block.points));
                    }
                }
                return (key, subjectBid, blocks);
            }
            catch (Exception e)
            {
                return (null, null, null);
            }
        }

    }
}