TEAMModelOS/TEAMModelOS/Controllers/OpenApi/Business/BizOverallEducationController.cs

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK;
using TEAMModelOS.Models;
using Microsoft.Extensions.Options;
using System.Threading.Tasks;
using TEAMModelOS.SDK.Models.Dtos;
using TEAMModelOS.SDK.Context.Constant;
using System.Collections.Generic;
using System.Text.Json;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.Filter;
using TEAMModelOS.SDK.Models;
using Microsoft.Azure.Cosmos;
using TEAMModelOS.SDK.Models.Cosmos.OpenEntity;
using System;
using System.Text;

namespace TEAMModelOS.Controllers
{
    /// <summary>
    /// 五育并举接口
    /// </summary>
    [Route("business")]
    [ApiController]
    public class BizOverallEducationController : ControllerBase
    {
        public AzureCosmosFactory _azureCosmos;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly IConfiguration _configuration;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        private readonly AzureServiceBusFactory _serviceBus;
        private readonly SnowflakeId _snowflakeId;

        public BizOverallEducationController(AzureCosmosFactory azureCosmos, AzureStorageFactory azureStorage, AzureRedisFactory azureRedis, AzureServiceBusFactory serviceBus, DingDing dingDing, CoreAPIHttpService coreAPIHttpService, IOptionsSnapshot<Option> option, IConfiguration configuration, SnowflakeId snowflakeId)
        {
            _azureCosmos = azureCosmos;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
            _dingDing = dingDing;
            _option = option?.Value;
            _configuration = configuration;
            _coreAPIHttpService = coreAPIHttpService;
            _serviceBus = serviceBus;
            _snowflakeId = snowflakeId;
        }

        /// <summary>
        /// 设置学生画像
        /// </summary>
        /// <param name="portrait"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("upsert-student-portrait")]
        [ApiToken(Auth = "1901", Name = "设置学生全面教育画像", TName = "設置學生全面教育畫像", EName = "Set up students overall education portrait", RWN = "W", Limit = false)]
        public async Task<IActionResult> UpsertStudentPortrait(JsonElement jsonElement)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            var responseData = await OpenApiService.UpsertStudentPortrait(_azureCosmos, _dingDing, _azureRedis,   jsonElement,school);
            return Ok(new { responseData });
        }


        #region  杉达公司
        /// <summary>
        /// 开课或者上传课例信息  是因支持VR/AR的公司(杉达)
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        //[ProducesDefaultResponseType]
        //[HttpPost("set-lesson-relord")]
        //[ApiToken(Auth = "1903", Name = "开课/上传课例信息", TName = "開課/上傳課例信息", EName = "Start class/upload class information", RWN = "W", Limit = false)]
        public async Task<IActionResult> UpLessonRec(JsonElement jsonElement)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            try
            {
                jsonElement.TryGetProperty("baseJson", out JsonElement baseJson);    //课例基础文件信息json
                jsonElement.TryGetProperty("timLineJson", out JsonElement timLineJson); //时间json
                jsonElement.TryGetProperty("lessonId", out JsonElement lessonId);  //课例id
                if (!jsonElement.TryGetProperty("tmdId", out JsonElement tmdId)) return Ok(new { responseDate = new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "tmdId参数错误", data = null } });  //上课人ID
                jsonElement.TryGetProperty("tmdName", out JsonElement tmdName);  //上课人昵称
                jsonElement.TryGetProperty("tmdPicture", out JsonElement tmdpicture); //上课人头像
                if (!jsonElement.TryGetProperty("startTime", out JsonElement startTime)) return Ok(new { responseDate = new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "startTime参数错误", data = null } });  //开始时间
                if (!jsonElement.TryGetProperty("duration", out JsonElement duration)) return Ok(new { responseDate = new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "startTime参数错误", data = null } });  //上课时长
                jsonElement.TryGetProperty("periodId", out JsonElement periodId);  //学段id
                jsonElement.TryGetProperty("periodName", out JsonElement periodName); //学段名称
                jsonElement.TryGetProperty("groupIds", out JsonElement _groupIds); //名单id
                jsonElement.TryGetProperty("groupNames", out JsonElement _groupNames); //名单名称
                jsonElement.TryGetProperty("gradeIds", out JsonElement _gradeIds); //年级id
                jsonElement.TryGetProperty("gradeNames", out JsonElement _gradeNames); //年级名称
                jsonElement.TryGetProperty("subjectId", out JsonElement subjectId);  //科目id
                jsonElement.TryGetProperty("subjecName", out JsonElement subjecName); //科目名称
                jsonElement.TryGetProperty("courseId", out JsonElement courseId);  //课程id
                jsonElement.TryGetProperty("courseName", out JsonElement courseName); //课程名称

                LessonRecord lessonRecord = new();
                LessonBase lessonBase = null;
                TimeLine timeLine = null;
                if (!string.IsNullOrEmpty($"{baseJson}"))
                {
                    lessonBase = baseJson.ToObject<LessonBase>();
                    lessonRecord.upload = 1;
                }
                else
                    lessonRecord.upload = 0;
                if (!string.IsNullOrEmpty($"{timLineJson}"))
                {
                    timeLine = timLineJson.ToObject<TimeLine>();
                    lessonRecord.upload = 1;
                }
                else
                    lessonRecord.upload = 0;

                List<string> groupIds = new();
                List<string> groupNames = new();
                List<string> gradeIds = new();
                List<string> gradeNames = new();

                if (!string.IsNullOrEmpty($"{_groupIds}"))
                    groupIds = _groupIds.ToObject<List<string>>();
                if (!string.IsNullOrEmpty($"{_groupNames}"))
                    groupNames = _groupNames.ToObject<List<string>>();
                if (!string.IsNullOrEmpty($"{_gradeIds}"))
                    gradeIds = _gradeIds.ToObject<List<string>>();
                if (!string.IsNullOrEmpty($"{_gradeNames}"))
                    gradeNames = _gradeNames.ToObject<List<string>>();

                var cosmosClient = _azureCosmos.GetCosmosClient();
                string code = $"LessonRecord-{school}";

                var resLess = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lessonId}", new PartitionKey($"{code}"));
                if (resLess.StatusCode==System.Net.HttpStatusCode.OK)
                {
                    JsonDocument jsonD = JsonDocument.Parse(resLess.Content);
                    lessonRecord = jsonD.RootElement.ToObject<LessonRecord>();
                }
                else
                {
                    lessonRecord.id = _snowflakeId.NextId().ToString();
                    lessonRecord.code = code;
                }

                lessonRecord.tmdid = $"{tmdId}";
                lessonRecord.tmdname = $"{tmdName}";
                lessonRecord.tmdpicture = $"{tmdpicture}";
                lessonRecord.school = school;
                lessonRecord.scope = "school";
                lessonRecord.startTime = long.Parse($"{startTime}");
                lessonRecord.duration = double.Parse($"{duration}");
                lessonRecord.periodId = $"{periodId}";
                lessonRecord.periodName = $"{periodName}";
                lessonRecord.subjectId = $"{subjectId}";
                lessonRecord.subjecName = $"{subjecName}";
                lessonRecord.courseId = $"{courseId}";
                lessonRecord.courseName = $"{courseName}";
                lessonRecord.groupIds = groupIds;
                lessonRecord.groupNames = groupNames;
                lessonRecord.grade = gradeIds;
                lessonRecord.gradeName = gradeNames;

                if (!string.IsNullOrEmpty($"{baseJson}"))
                {
                    lessonRecord.name = lessonBase.summary.activityName;
                    lessonRecord.attendCount = lessonBase.summary.attendCount;
                    lessonRecord.clientCount = lessonBase.summary.clientCount;
                    lessonRecord.attendRate = lessonBase.summary.attendRate;
                    lessonRecord.groupCount = lessonBase.summary.groupCount;
                    lessonRecord.collateTaskCount = lessonBase.summary.collateTaskCount;
                    lessonRecord.collateCount = lessonBase.summary.collateCount;
                    lessonRecord.pushCount = lessonBase.summary.pushCount;
                    lessonRecord.totalPoint = lessonBase.summary.totalPoint;
                    lessonRecord.examQuizCount = lessonBase.summary.examQuizCount;
                    lessonRecord.interactionCount = lessonBase.summary.interactionCount;
                    lessonRecord.examPointRate = lessonBase.summary.examPointRate;
                    lessonRecord.clientInteractionCount = lessonBase.summary.clientInteractionCount;
                    lessonRecord.clientInteractionAverge = lessonBase.summary.clientInteractionAverge;
                    lessonRecord.examCount = lessonBase.summary.examCount;
                    lessonRecord.totalInteractPoint = lessonBase.summary.totalInteractPoint;
                    lessonRecord.learningCategory = lessonBase.summary.learningCategory;
                    lessonRecord.source = 1;

                    //计算TP灯
                    {
                        int T = -1;
                        int P = -1;
                        if (lessonRecord.clientInteractionAverge <= 0)
                        {
                            T = 0;
                        }
                        else if (lessonRecord.clientInteractionAverge >= 1 && lessonRecord.clientInteractionAverge <= 2)
                        {
                            T = 1;
                        }
                        else
                        {
                            T = 2;
                        }
                        //if (lessonRecord.examCount > 0)
                        //{
                        //    //有评测次数大于0则P是直接绿灯
                        //    P = 2;
                        //}
                        //else {

                        //}

                        int a = lessonRecord.hitaClientCmpCount;
                        int b = lessonRecord.pushCount;
                        int c = lessonRecord.examCount;
                        switch (true)
                        {
                            case bool when T == 0:
                                P = 0;
                                break;
                            case bool when T == 1 || T == 2:
                                if (a == 0 && b == 0 && c == 0)
                                {
                                    P = 0;
                                }
                                else if ((a > 0 && b > 0) || (a > 0 && c > 0) || (b > 0 && c > 0))
                                {
                                    P = 2;
                                }
                                else
                                {
                                    P = 1;
                                }
                                break;
                        }
                        lessonRecord.tLevel = T;
                        lessonRecord.pLevel = P;
                    }
                }
                if (resLess.StatusCode==System.Net.HttpStatusCode.OK)
                    lessonRecord = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<LessonRecord>(lessonRecord, lessonRecord.id, new PartitionKey($"{code}"));
                else
                    lessonRecord = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<LessonRecord>(lessonRecord, new PartitionKey($"{code}"));

                var blobClient = _azureStorage.GetBlobContainerClient(containerName: $"{school}");
                if (!string.IsNullOrEmpty($"{baseJson}"))

                    //保存Basejson文件
                    await AzureStorageBlobExtensions.UploadFileByContainer(blobClient, lessonBase.ToJsonString(), $"records/{lessonRecord.id}/IES", $"Base.json");

                if (!string.IsNullOrEmpty($"{timLineJson}"))
                    //保存TimeLinejson文件
                    await AzureStorageBlobExtensions.UploadFileByContainer(blobClient, timeLine.ToJsonString(), $"records/{lessonRecord.id}/IES", $"TimeLine.json");

                return Ok(new
                {     
                    responseData = new ResponseData<dynamic>()
                    {
                        code = RespondCode.Ok,
                        msg = "成功",
                        data = new
                        {
                            lessonRecord,
                            analysis = new
                            {
                                lessonRecord.id,
                                lessonRecord.name,
                                lessonRecord.subjectId,
                                lessonRecord.courseId,
                                intIndex = lessonRecord.tLevel,
                                learning = lessonRecord.pLevel,
                                atendCnt = lessonRecord.attendCount,
                                grCnt = lessonRecord.groupCount,
                                taskCnt = lessonRecord.collateTaskCount,
                                worksCnt = lessonRecord.collateCount,
                                pushCnt = lessonRecord.pushCount,
                                scoreCnt = lessonRecord.totalPoint,
                                emCnt = lessonRecord.examCount,
                                intTopicCnt = lessonRecord.interactionCount,
                                emPct = $"{lessonRecord.examPointRate} %",
                                stuIntCnt = lessonRecord.clientInteractionCount,
                                study = new
                                {
                                    coopCnt = lessonRecord.learningCategory.cooperation,
                                    testCnt = lessonRecord.learningCategory.exam,
                                    intCnt = lessonRecord.learningCategory.interaction,
                                    dCnt = lessonRecord.learningCategory.diffential,
                                    taskCnt = lessonRecord.learningCategory.task,
                                }
                            }
                        }
                    }
                });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} BizOverallEducation/UpLessonRec()   参数：bizId:{id},school:{school},json:{jsonElement.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return Ok(new { responseData = new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" } });
            }
        }

        /// <summary>
        /// 获取学校课例  是因支持VR/AR的公司(杉达)
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        //[ProducesDefaultResponseType]
        //[HttpPost("get-lesson-relords")]
        //[ApiToken(Auth = "1904", Name = "获取学校课例", TName = "獲取學校課例", EName = "Get school lessons", RWN = "R", Limit = false)]
        public async Task<IActionResult> GetLessonRec(JsonElement jsonElement)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            jsonElement.TryGetProperty("lessonId", out JsonElement lessId);
            var cosmosClient = _azureCosmos.GetCosmosClient();

            StringBuilder sql = new("select value(c) from c where c.source=1");
            if (!string.IsNullOrEmpty($"{lessId}"))
                sql.Append($" and c.id='{lessId}'");

            List<OLessonRecord> lessonRecords = new();
            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIteratorSql<OLessonRecord>(queryText: sql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"LessonRecord-{school}") }))
            {
                lessonRecords.Add(item);
            }

            return Ok(new { responseData = new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = lessonRecords } });
        }


        /// <summary>
        /// 获取学校课例分析结果  是因支持VR/AR的公司(杉达)
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-lesson-analysis")]
        [ApiToken(Auth = "1906", Name = "获取学校课例", TName = "獲取學校課例", EName = "Get school lessons", RWN = "R", Limit = false)]
        public async Task<IActionResult> GetLessonStats(JsonElement jsonElement)
        {
            var (id, school) = HttpContext.GetApiTokenInfo();
            if(!jsonElement.TryGetProperty("lessonId", out JsonElement lessonId)) return Ok(new { responseDate = new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "lessId参数错误", data = null } });  //上课人ID  ;
            var cosmosClient = _azureCosmos.GetCosmosClient();

            dynamic analysis = null;

            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIteratorSql(queryText: $"select c.id,c.name,c.subjectId,c.courseId,c.tLevel,c.pLevel,c.attendCount,c.groupCount,c.collateTaskCount,c.collateCount,c.pushCount,c.totalPoint,c.examCount,c.interactionCount,c.examPointRate,c.clientInteractionCount,c.learningCategory from c where c.id='{lessonId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"LessonRecord-{school}") }))
            {
                using var json = await JsonDocument.ParseAsync(item.Content);
                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;
                        LearningCategory learningCategory = account.GetProperty("learningCategory").ToObject<LearningCategory>();

                        analysis = new
                        {
                            id = account.GetProperty("id").GetString(),
                            name = account.GetProperty("name").GetString(),
                            subjectId = account.GetProperty("subjectId").GetString(),
                            courseId = account.GetProperty("courseId").GetString(),                            
                            intIndex = account.GetProperty("tLevel").GetInt64(),
                            learning = account.GetProperty("pLevel").GetInt64(),
                            atendCnt = account.GetProperty("attendCount").GetInt64(),
                            grCnt = account.GetProperty("groupCount").GetInt64(),
                            taskCnt = account.GetProperty("collateTaskCount").GetInt64(),
                            worksCnt = account.GetProperty("collateCount").GetInt64(),
                            pushCnt = account.GetProperty("pushCount").GetInt64(),
                            scoreCnt = account.GetProperty("totalPoint").GetInt64(),
                            emCnt = account.GetProperty("examCount").GetInt64(),
                            intTopicCnt = account.GetProperty("interactionCount").GetInt64(),
                            emPct = $"{account.GetProperty("examPointRate").GetDouble()} %",
                            stuIntCnt = account.GetProperty("clientInteractionCount").GetInt64(),
                            study = new
                            {
                                coopCnt = learningCategory.cooperation,
                                testCnt = learningCategory.exam,
                                intCnt = learningCategory.interaction,
                                dCnt = learningCategory.diffential,
                                taskCnt = learningCategory.task,
                            }
                        };

                        //var ids = account.GetProperty("id").GetString();
                        //var name = account.GetProperty("name").GetString();
                        //var intIndex = account.GetProperty("tLevel").GetInt64();
                        //var learning = account.GetProperty("pLevel").GetInt64();
                        //var atendCnt = account.GetProperty("attendCount").GetInt64();
                        //var grCnt = account.GetProperty("groupCount").GetInt64();
                        //var taskCnt = account.GetProperty("collateTaskCount").GetInt64();
                        //var worksCnt = account.GetProperty("collateCount").GetInt64();
                        //var pushCnt = account.GetProperty("pushCount").GetInt64();
                        //var scoreCnt = account.GetProperty("totalPoint").GetInt64();
                        //var emCnt = account.GetProperty("examCount").GetInt64();
                        //var intTopicCnt = account.GetProperty("interactionCount").GetInt64();
                        //var emPct = $"{account.GetProperty("examPointRate").GetDouble()} %";
                        //var stuIntCnt = account.GetProperty("clientInteractionCount").GetInt64();

                        //var study = new
                        //{
                        //    coopCnt = learningCategory.cooperation,
                        //    testCnt = learningCategory.exam,
                        //    intCnt = learningCategory.interaction,
                        //    dCnt = learningCategory.diffential
                        //};
                    }
                }
            }

            return Ok(new { responseData = new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = analysis } });

        }

        #endregion

        


        ///数据结构说明
        /**
         *
url[post]https: //www.teammodel.cn/business/upsert-student-portrait
header:
X-Auth-School:hbcn  授权访问的学校
X-Auth-ApiToken:授权token eyJhbGciOiJodHRwOi8vd3d3LnczLm9yZy8yMDAxLzA0L3htbGRzaWctbW9yZSNobWFjLXNoYTI1NiIsInR5cCI6IkpXVCJ9
Content-Type: application/json
params [body json]: 
{
"schoolCode": "hbcn",
"periodId": "463db08d-cbe7-48a0-a81a-fc39b3c1fep1",
"subjectId": "subject_sport",
"students": [
        {
            "studentId": "202001001",
            "name": "卢三诗",
            "classId": "2ffbd7f9-2445-4139-90a7-59e27c0d097e",
            "semesterData": [
                {
                    "examName": "评测名称",
                    "examId": "评测id2",
                    "examDate": 1629947402486,
                    "examType": "期末",
                    "year": 2020,
                    "semester": 1,
                    "semesterId": "17f85c96-253d-4f84-84ad-c819f0b605s21",
                    "totalScore": 100,
                    "sumScore": 80,
                    "excellenceRate": 61.73,
                    "passRate": 91.88,
                    "itemScore": [
                        {
                            "name": "立定跳远",
                            "score": 99.95
                        }
                    ]
                }
            ]
        }
]
}
//正确返回
{
"responseData": {
        "code": 200,
        "msg": "成功",
        "data": {
            "unmatchStuInfo": [],//如果数组长度大于0则，学生信息或班级信息不匹配
            "unmatchSemester":[],//如果数组长度大于0则，包含的学期信息不匹配
            "upsertDatas":[],//如果数组长度大于0则，表示更新或保存成功的数据
        }
}
}
//错误返回
{
"responseData": {
        "code": 500,
        "msg": "返回信息"
        
}
}
code:
500 服务端异常
404 学校编码不存在
404 periodId不存在
400 当前subjectId未开放画像业务
400 students为空或格式错误
400 subjectId为空
400 periodId为空
400 schoolCode为空
//接口规范
{
"schoolCode": "hbcn", //学校简码
"periodId": "52076c94-7581-fbae-4487-4b162a61fea3", //学段id
"subjectId": "subject_sport", //体育科目id
"students": [
        {
            "studentId": "20220901", //学生编号
            "name": "海献仪", //学生姓名
            "classId": "c406eee2-1ce9-caf4-5fc0-57351604b615", //行政班id
            "semesterData": [ //学期数据
                {
                    "examName": "评测名称", //评测名称
                    "examId": "评测id", //用于数据新增或更新
                    "examDate": 1629947402486, //评测时间，13位时间戳
                    "examType": "期末", //期末，期中，季考，月考，周考，测验，练习，作业，日常，课中
                    "year": 2021, //所属学年，学年跨年，按上一年。
                    "semester": 2, //学期,与semesterId选填其一
                    "semesterId": "17f85c96-253d-4f84-84ad-c819f0b605s2", //学期id 
                    "totalScore": 100, //配分，总分
                    "sumScore": 74.29, //总成绩
                    "excellenceRate": 61.73, //优秀率
                    "passRate": 91.88, //及格率
                    "itemScore": [ //考核项目数据
                        {
                            "name": "立定跳远", //项目名称
                            "score": 99.95 //项目分数
                        }
                    ]
                }
            ]
        }
]
}
//五育数据看板结构
{
"id": "年份2021-学期id",
"semesterName": "上学期",
"year": 2021,
"semesterId": "17f85c96-253d-4f84-84ad-c819f0b605s2",
"code": "hbcn-20220901",
"schoolCode": "hbcn",
"studentId": "20220901",
"name": "海献仪",
"classId": [
        "c406eee2-1ce9-caf4-5fc0-57351604b615"
],
"periodId": "52076c94-7581-fbae-4487-4b162a61fea3",
"grade": 1,
"virtue": //德
[
        {
            "id": "17f85c96-253d-4f84-84ad-c819f0b605s2",
            "name": "评测名称",
            "type": "日常", //期末，期中，季考，月考，周考，测验，练习，作业,日常，课中
            "subjectId": "52076c94-7581-fbae-4487-4b162a61fea3",
            "examDate": 1629947402486,
            "sumScore": 74.29,
            "excellenceRate": 61.73,
            "passRate": 91.88,
            "itemScore": [ //考核项目数据
                {
                    "name": "迟到", //
                    "score": -1, //计分
                    "time": 1629947402486,
                }
            ]
        }
],
"intelligence": //智
[
        {
            "id": "17f85c96-253d-4f84-84ad-c819f0b605s2",
            "name": "评测名称",
            "type": "期末", //期末，期中，季考，月考，周考，测验，练习，作业,日常，课中
            "subjectId": "52076c94-7581-fbae-4487-4b162a61fea3",
            "examDate": 1629947402486,
            "level": 1
        }
],
"sports": //体
[
        {
            "id": "17f85c96-253d-4f84-84ad-c819f0b605s2",
            "name": "评测名称",
            "type": "期末", //期末，期中，季考，月考，周考，测验，练习，作业,日常，课中
            "subjectId": "52076c94-7581-fbae-4487-4b162a61fea3",
            "examDate": 1629947402486,
            "sumScore": 74.29,
            "excellenceRate": 61.73,
            "passRate": 91.88,
            "itemScore": [ //考核项目数据
                {
                    "name": "立定跳远", //项目名称
                    "score": 99.95 //项目分数
                }
            ]
        }
],
"art": //美
[
        {
            "id": "17f85c96-253d-4f84-84ad-c819f0b605s2",
            "name": "评测名称",
            "type": "期末", //期末，期中，季考，月考，周考，测验，练习，作业,日常，课中
            "subjectId": "52076c94-7581-fbae-4487-4b162a61fea3",
            "examDate": 1629947402486,
            "level": 1,
        }
],
"labour": //劳
[
        {
            "id": "17f85c96-253d-4f84-84ad-c819f0b605s2",
            "name": "任务名称",
            "type": "日常", //期末，期中，季考，月考，周考，测验，练习，作业,日常，课中
            "subjectId": "52076c94-7581-fbae-4487-4b162a61fea3",
            "examDate": 1629947402486,
            "itemScore": [ //考核项目数据
                {
                    "name": "洗碗", //洗碗，倒垃圾，打扫卫生等...
                    "score": 1, //项目计分
                    "time": 1629947402486,
                }
            ]
        }
]
}
    * **/

    }
}