TEAMModelOS/TEAMModelOS.SDK/Models/Service/OpenApiService.cs

using Azure;
using Azure.Cosmos;
using HTEXLib.COMM.Helpers;
using Microsoft.AspNetCore.Http;
using Microsoft.Azure.Cosmos.Table;
using Microsoft.Azure.Functions.Worker.Http;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.Filter;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Models.Table;
using TEAMModelOS.SDK.Helper.Common.ReflectorExtensions;
using TEAMModelOS.SDK.Context.Constant;
using TEAMModelOS.SDK.Models.Dtos;
using TEAMModelOS.SDK.Services;
using Microsoft.Extensions.Configuration;
using Azure.Messaging.ServiceBus;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.Models.Service;
using TEAMModelOS.SDK.Models.Cosmos.BI.BINormal;
using TEAMModelOS.SDK.Models.Cosmos.Student;
using Microsoft.OData.Edm;
using System.IdentityModel.Tokens.Jwt;
using TEAMModelOS.SDK.Models.Cosmos.OpenEntity;
using Microsoft.OData.UriParser;
using Azure.Core;
using System.Security.Policy;
using System.Net.Http.Json;
using System.Drawing;
using Microsoft.AspNetCore.DataProtection;
using Newtonsoft.Json.Linq;
using Microsoft.Extensions.Hosting;
using Microsoft.AspNetCore.Hosting;
using TEAMModelOS.Models.ShanDa;
using System.Runtime.ConstrainedExecution;
using DocumentFormat.OpenXml.Wordprocessing;
using DocumentFormat.OpenXml.Office2010.Excel;
using DocumentFormat.OpenXml.Office2016.Excel;

namespace TEAMModelOS.SDK
{
    public class OpenApiService
    {


        private static List<string> weekDays = new List<string> { "MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN" };

        /// <summary>
        /// 第三方获取学校列表
        /// [ApiToken(Auth = "1000", Name = "合作商获取可访问的学校列表",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<List<BizSchool>>> GetSchools(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId)
        {
            try
            {
                List<BizSchool> schools = new();

                var response = await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "Normal").ReadItemStreamAsync(bizId, new PartitionKey("BizConfig"));
                if (response.Status == 200)
                {
                    using var resJson = await JsonDocument.ParseAsync(response.ContentStream);
                    Business bizConfig = resJson.ToObject<Business>();
                    schools = bizConfig.schools;
                }
                else return new ResponseData<List<BizSchool>>() { code = RespondCode.NotFound, msg = "未找到该企业" };

                return new ResponseData<List<BizSchool>>() { code = RespondCode.Ok, msg = "成功", data = schools };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetSchools()   参数：bizId:{bizId} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<List<BizSchool>>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// josn:
        /// {
        ///     "roles":"",
        ///     "scope":""
        ///     "pageCount":"",
        ///     "DESC":"",
        ///     "ASC":"",
        ///     "continuationToken":"",
        ///     "school":"",
        ///     "tmdid":""
        /// }
        /// </summary>
        /// <param name="azureCosmos"></param>
        /// <param name="dingDing"></param>
        /// <param name="id"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public static async Task<ResponseData<dynamic>> GetLessonRecordCount(AzureCosmosFactory _azureCosmos, IConfiguration _configuration, AzureServiceBusFactory _serviceBus,
           Option _option, DingDing _dingDing, string id, string school, JsonElement json)
        {
            json.TryGetProperty("identity", out JsonElement _identity);
            string identity = "";
            if (!string.IsNullOrWhiteSpace($"{_identity}"))
            {
                identity = $"{_identity}";
            }
            json.TryGetProperty("managePage", out JsonElement _managePage);
            bool managePage = false;
            if (_managePage.ValueKind.Equals(JsonValueKind.True))
            {
                managePage = true;
            }
            StringBuilder sql = new StringBuilder();
            sql.Append("select c.id,c.groupIds,c.courseId from c   ");
            Dictionary<string, object> dict = LessonService.GetLessonCond(json);
            AzureCosmosQuery cosmosDbQuery = SQLHelper.GetSQL(dict, sql);
            string tbname = "";
            string code = "";

            List<string> autoTch = new List<string>();
            string sqlPrivate = "";
            code = $"LessonRecord-{school}";
            tbname = "School";
            List<string> ids = new List<string>();
            //只查询某个老师的课例
            if (json.TryGetProperty("tmdid", out JsonElement tmdid) && !string.IsNullOrWhiteSpace($"{tmdid}"))
            {
                ids.Add($"{tmdid}");
            }
            else
            {
                string sqltch = "select distinct value(c.id) from c ";
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                    .GetItemQueryIterator<string>(queryText: sqltch, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school}") }))
                {
                    ids.Add(item);
                }
            }
            if (ids.Any())
            {
                string sqlTechbase = $"select distinct value(c.id) from c  where c.id in ({string.Join(",", ids.Select(x => $"'{x}'"))})  and (array_contains(c.lessonShow,'student') or array_contains(c.lessonShow,'all')) ";
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher)
                   .GetItemQueryIterator<string>(queryText: sqlTechbase, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Base") }))
                {
                    autoTch.Add(item);
                }
            }
            int count = 0;

            string sqlShow = "";
            if (identity.Equals("student"))
            {
                string autoSql = "";
                if (autoTch.Any())
                {
                    autoSql = $" or c.tmdid in ({string.Join(",", autoTch.Select(x => $"'{x}'"))})";
                }
                sqlShow = $" and (array_contains(c.show,'student') or array_contains(c.show,'all')  {autoSql} ) ";
            }
            string sql_status_managePage = " (c.status<>404 or IS_DEFINED(c.status) = false ) and ";
            if (managePage)
            {
                sql_status_managePage = "";
            }
            long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
            cosmosDbQuery.QueryText = cosmosDbQuery.QueryText.Replace("where", $" where {sql_status_managePage} array_length(c.groupIds)>0 {sqlPrivate} {sqlShow}  and  ");
            if (json.TryGetProperty("singleGreen", out JsonElement doubleGreen) && doubleGreen.GetBoolean())
            {
                cosmosDbQuery.QueryText = cosmosDbQuery.QueryText.Replace("where", $" where  ((c.tLevel=2 and c.pLevel<2 )or(c.tLevel<2 and c.pLevel=2 )) and   ");
            }
            if (json.TryGetProperty("expire", out JsonElement expire) && expire.ValueKind.Equals(JsonValueKind.True))
            {
                cosmosDbQuery.QueryText = cosmosDbQuery.QueryText.Replace("where", $" where c.expire>{now} and   ");
            }
            List<LessonRecord> records = new List<LessonRecord>();
            await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).GetItemQueryIterator<LessonRecord>(queryDefinition: cosmosDbQuery.CosmosQueryDefinition, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey(code) }))
            {
                records.Add(item);
            }
            if (records.Any())
            {
                var groupIds = records.SelectMany(x => x.groupIds).ToHashSet();
                if (groupIds.Any())
                {
                    var groups = await GroupListService.GetGroupListByListids(_azureCosmos.GetCosmosClient(), _dingDing, groupIds.ToList(), school, " c.id ");
                    //获取已经被删除的名单。
                    var idsExp = groupIds.Except(groups.Select(x => x.id));
                    if (idsExp.Any())
                    {


                        foreach (var item in records)
                        {
                            int countRmv = item.groupIds.RemoveAll(x => idsExp.Contains(x));
                            if (countRmv > 0)
                            {
                                try
                                {
                                    LessonRecord record = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).ReadItemAsync<LessonRecord>(item.id, new PartitionKey(code));
                                    record.groupIds = item.groupIds;
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).ReplaceItemAsync<LessonRecord>(record, item.id, new PartitionKey(code));
                                }
                                catch (CosmosException ex) when (ex.Status == 404)
                                {
                                    continue;
                                }
                            }
                        }
                    }
                }
            }
            count = records.Count;
            ResponseData<dynamic> resDate = new ResponseData<dynamic>
            {
                code = RespondCode.Ok,
                msg = "成功",
                data = new
                {
                    count = count,
                }
            };
            return resDate;
        }
        /// <summary>
        /// josn:
        /// {
        ///     "roles":"",
        ///     "scope":""
        ///     "pageCount":"",
        ///     "DESC":"",
        ///     "ASC":"",
        ///     "continuationToken":"",
        ///     "school":"",
        ///     "tmdid":""
        /// }
        /// </summary>
        /// <param name="azureCosmos"></param>
        /// <param name="dingDing"></param>
        /// <param name="id"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public static async Task<ResponseData<dynamic>> GetLessonRecord(AzureCosmosFactory _azureCosmos, IConfiguration _configuration, AzureServiceBusFactory _serviceBus,
           Option _option, DingDing _dingDing, string id, string school, JsonElement json)
        {

            json.TryGetProperty("identity", out JsonElement _identity);
            string identity = "";
            if (!string.IsNullOrWhiteSpace($"{_identity}"))
            {
                identity = $"{_identity}";
            }

            json.TryGetProperty("managePage", out JsonElement _managePage);
            bool managePage = false;
            if (_managePage.ValueKind.Equals(JsonValueKind.True))
            {
                managePage = true;
            }
            StringBuilder sql = new StringBuilder();
            sql.Append("select   value(c) from c ");
            int pageCount = 10;
            Dictionary<string, object> dict = LessonService.GetLessonCond(json);
            if (json.TryGetProperty("pageCount", out JsonElement _pageCount))
            {
                int.TryParse($"{_pageCount}", out int pcount);
                if (pcount > 0)
                {
                    pageCount = pcount;
                }
            }
            if (json.TryGetProperty("DESC", out JsonElement desc))
            {
                dict.Add("@DESC", desc.ToString());
            }
            if (json.TryGetProperty("ASC", out JsonElement asc))
            {
                dict.Add("@ASC", asc.ToString());
            }
            string continuationToken = null;
            if (json.TryGetProperty("continuationToken", out JsonElement _continuationToken))
            {
                if (!string.IsNullOrEmpty($"{_continuationToken}"))
                {
                    continuationToken = $"{_continuationToken}";
                }
            }
            AzureCosmosQuery cosmosDbQuery = SQLHelper.GetSQL(dict, sql);
            string tbname = "";
            string code = "";

            string sqlPrivate = "";
            List<string> autoTch = new List<string>();
            code = $"LessonRecord-{school}";
            tbname = "School";

            List<string> ids = new List<string>();
            //只查询某个老师的课例
            if (json.TryGetProperty("tmdid", out JsonElement tmdid) && !string.IsNullOrWhiteSpace($"{tmdid}"))
            {
                ids.Add($"{tmdid}");
            }
            else
            {
                string sqltch = "select distinct value(c.id) from c ";
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                    .GetItemQueryIterator<string>(queryText: sqltch, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school}") }))
                {
                    ids.Add(item);
                }
            }
            if (ids.Any())
            {
                string sqlTechbase = $"select distinct value(c.id) from c  where c.id in ({string.Join(",", ids.Select(x => $"'{x}'"))})  and (array_contains(c.lessonShow,'student') or array_contains(c.lessonShow,'all')) ";
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher)
                   .GetItemQueryIterator<string>(queryText: sqlTechbase, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Base") }))
                {
                    autoTch.Add(item);
                }
            }
            List<LessonRecord> lessonRecords = new List<LessonRecord>();
            try
            {
                string sqlShow = "";
                if (identity.Equals("student"))
                {
                    string autoSql = "";
                    if (autoTch.Any())
                    {
                        autoSql = $" or c.tmdid in ({string.Join(",", autoTch.Select(x => $"'{x}'"))})";
                    }
                    sqlShow = $" and (array_contains(c.show,'student') or array_contains(c.show,'all')  {autoSql} ) ";
                }

                string sql_status_managePage = "(c.status<>404 or IS_DEFINED(c.status) = false ) and  ";
                if (managePage)
                {
                    sql_status_managePage = "";
                }
                cosmosDbQuery.QueryText = cosmosDbQuery.QueryText.Replace("where", $" where  {sql_status_managePage}  array_length(c.groupIds)>0 {sqlPrivate}  {sqlShow} and  ");
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname)
                   .GetItemQueryStreamIterator(queryDefinition: cosmosDbQuery.CosmosQueryDefinition, continuationToken: continuationToken,
                   requestOptions: new QueryRequestOptions() { MaxItemCount = pageCount, PartitionKey = new PartitionKey(code) }))
                {
                    using var jsonData = await JsonDocument.ParseAsync(item.ContentStream);
                    if (jsonData.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                    {
                        foreach (var obj in jsonData.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            lessonRecords.Add(obj.ToObject<LessonRecord>());
                        }
                        continuationToken = item.GetContinuationToken();
                        break;
                    }
                }
                long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                //查询时处理已经过期的课例。防止ServiceBus未触发的。
                var expireRecords = lessonRecords.Where(x => x.expire > 0 && now > x.expire);
                try
                {
                    foreach (var item in expireRecords)
                    {
                        //item.status = 404;
                        //await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).ReplaceItemAsync(item, item.id, new PartitionKey(item.code));
                        var ActiveTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");
                        var messageChange = new ServiceBusMessage(new { delete_id = item.id, tmdid = item.tmdid, scope = item.scope, opt = "delete", school = item.school }.ToJsonString());
                        messageChange.ApplicationProperties.Add("name", "LessonRecordEvent");
                        await _serviceBus.GetServiceBusClient().SendMessageAsync(ActiveTask, messageChange);
                    }
                }
                catch (Exception ex)
                {
                    await _dingDing.SendBotMsg($"{_option.Location},ServiceBus ,LessonRecordEvent 发送消息失败，检查是否配置正常。", GroupNames.成都开发測試群組);
                }
                var tmdids = lessonRecords.Select(x => x.tmdid).ToHashSet();
                if (tmdids != null && tmdids.Count > 0)
                {
                    List<IdNameCode> codes = new List<IdNameCode>();
                    string sqltmd = $"select c.id,c.name,c.picture from c where c.id in ({string.Join(",", tmdids.Select(x => $"'{x}'"))})";
                    await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").GetItemQueryIterator<IdNameCode>(queryText: sqltmd, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey("Base") }))
                    {
                        codes.Add(item);
                    }
                    if (codes.IsNotEmpty())
                    {
                        lessonRecords.ForEach(x =>
                        {
                            var tmd = codes.Find(z => z.id.Equals(x.tmdid));
                            if (tmd != null)
                            {
                                x.tmdname = tmd.name;
                                x.tmdpicture = tmd.picture;
                            }
                        });
                    }
                }
                var groupIds = lessonRecords.SelectMany(x => x.groupIds);
                if (groupIds.Any())
                {
                    List<GroupListDto> groupLists = await GroupListService.GetGroupListByListids(_azureCosmos.GetCosmosClient(), _dingDing, groupIds.ToList(), school);
                    lessonRecords.ForEach(x =>
                    {
                        List<string> groupNmae = new List<string>();
                        x.groupIds.ForEach(y =>
                        {
                            var dto = groupLists.Find(z => z.id.Equals(y));
                            string name = dto != null ? dto.name : "-";
                            groupNmae.Add(name);
                        });
                        x.groupNames = groupNmae;
                    });
                }
                ResponseData<dynamic> resDate = new ResponseData<dynamic>
                {
                    code = RespondCode.Ok,
                    msg = "成功",
                    data = new
                    {
                        currCount = lessonRecords.Count,
                        continuationToken,
                        lessonRecords = lessonRecords.Select(x => new { x.tmdid, x.tmdname, x.tmdpicture, x.name, x.school, x.startTime, x.duration, x.courseId, x.groupIds, x.periodId, x.subjectId, x.grade, x.id, x.category })
                    }
                };
                return resDate;
            }
            catch (Exception)
            {
                continuationToken = null;
                ResponseData<dynamic> resDate = new ResponseData<dynamic> { code = RespondCode.Ok, msg = "成功", data = new { currCount = 0, continuationToken = continuationToken, lessonRecords } };
                return resDate;
            }
        }

        /// <summary>
        /// 学校基本信息
        /// //[ApiToken(Auth = "1001", Name = "学校基本信息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="schoolId"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetSchoolInfo(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string schoolId)
        {
            try
            {
                ResponseData<dynamic> resDate = new();
                School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(schoolId, new PartitionKey("Base"));
                List<dynamic> period = new();
                data.period.ForEach(x => { period.Add(new { x.subjects, x.grades, x.name, x.id, x.campusId, x.semesters }); });
                if (data != null)
                {
                    resDate.code = RespondCode.Ok;
                    resDate.msg = "成功";
                    resDate.data = new { data.id, data.name, data.areaId, data.type, data.region, data.province, data.city, data.dist, data.campuses, period };
                }
                else
                {
                    resDate.code = RespondCode.NotFound;
                    resDate.msg = "未找到学校信息";
                }
                return resDate;
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetSchoolInfo()   参数：bizId:{bizId},school:{schoolId} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 名单列表信息 获取学校的行政班，教学班，教研组，研修名单
        /// [ApiToken(Auth = "1201", Name = "名单列表信息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<List<OGroupList>>> GetGroupList(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                ResponseData<List<OGroupList>> resDate = new();
                List<OGroupList> groupLists = new();
                var client = _azureCosmos.GetCosmosClient();
                json.TryGetProperty("periodId", out JsonElement periodId);
                List<GroupListGrp> tempGroupLists = new();
                //包含，学校的行政班，教学班
                json.TryGetProperty("type", out JsonElement _type);
                List<string> types = null;
                if (_type.ValueKind.Equals(JsonValueKind.Array))
                {
                    types = _type.ToObject<List<string>>();
                }
                else if (_type.ValueKind.Equals(JsonValueKind.String))
                {
                    types = new List<string> { $"{types}" };
                }
                if (types.IsEmpty() || types.Contains("class"))
                {
                    StringBuilder classsql = new StringBuilder($"SELECT c.id,c.name,c.periodId ,c.year  FROM c ");
                    if (!string.IsNullOrEmpty($"{periodId}"))
                    {
                        classsql.Append($" where  c.periodId='{periodId}' ");
                    }
                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<ClassInfo>(queryText: classsql.ToString(),
                        requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Class-{school}") }))
                    {
                        HashSet<string> groupNames = new HashSet<string>();
                        string gpsql = $"SELECT distinct c.groupId,c.groupName FROM c where  c.classId='{item.id}'and c.groupName <>null";
                        await foreach (var gp in client.GetContainer(Constant.TEAMModelOS, "Student").GetItemQueryIterator<Student>(queryText: gpsql,
                            requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base-{school}") }))
                        {
                            groupNames.Add(gp.groupName);
                        }
                        ///行政班（学生搜寻classId动态返回）class
                        GroupListGrp group = new GroupListGrp
                        {
                            id = item.id,
                            code = $"GroupList-{school}",
                            name = item.name,
                            periodId = item.periodId,
                            scope = "school",
                            school = $"{school}",
                            type = "class",
                            year = item.year,
                            expire = 0,
                            groupName = groupNames
                        };
                        tempGroupLists.Add(group);
                    }
                }
                if (types.IsEmpty() || types.Contains("teach"))
                {
                    //教学班
                    StringBuilder teachsql = new StringBuilder($" SELECT distinct value(c) FROM c  where c.type='teach'");
                    if (!string.IsNullOrEmpty($"{periodId}"))
                    {
                        teachsql.Append($" and c.periodId='{periodId}'");
                    }
                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                        GetItemQueryIterator<GroupList>(queryText: teachsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                    {
                        HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                        tempGroupLists.Add(new GroupListGrp(item, groupName));
                    }
                }
                if (types.IsEmpty() || types.Contains("research"))
                {
                    //教研组
                    StringBuilder researchsql = new StringBuilder($"SELECT distinct value(c) FROM c   where c.type='research'");
                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                        GetItemQueryIterator<GroupList>(queryText: researchsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                    {
                        HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                        tempGroupLists.Add(new GroupListGrp(item, groupName));
                    }
                }

                if (types.IsEmpty() || types.Contains("yxtrain"))
                {
                    //研修名单
                    StringBuilder yxtrainsql = new StringBuilder($"SELECT distinct value(c) FROM c    where c.type='yxtrain'");
                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").
                        GetItemQueryIterator<GroupList>(queryText: yxtrainsql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"GroupList-{school}") }))
                    {
                        HashSet<string> groupName = item.members.Where(x => !string.IsNullOrEmpty(x.groupName)).Select(y => y.groupName).ToHashSet();
                        tempGroupLists.Add(new GroupListGrp(item, groupName));
                    }
                }
                groupLists = tempGroupLists.Select(x => new OGroupList { id = x.id, name = x.name, type = x.type, periodId = x.periodId, school = x.school, scope = x.scope, year = x.year, expire = x.expire }).ToList();
                if (groupLists.Count > 0)
                {
                    resDate.code = RespondCode.Ok;
                    resDate.msg = "成功";
                    resDate.data = groupLists;
                }
                else
                {
                    resDate.code = RespondCode.NotFound;
                    resDate.msg = "未找到学校信息";
                }
                return resDate;
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetGroupList()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<List<OGroupList>>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 名单成员信息,学生成员信息，包含（学生，成员）基本信息，分组等信息
        /// [ApiToken(Auth = "1202", Name = "名单成员信息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_coreAPIHttpService"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetGroupMembers(AzureCosmosFactory _azureCosmos, CoreAPIHttpService _coreAPIHttpService, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                List<OGgroup> groups = new();
                var client = _azureCosmos.GetCosmosClient();
                if (!json.TryGetProperty("ids", out JsonElement ids)) return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "参数错误" };
                List<string> listids = ids.ToObject<List<string>>();
                (List<RMember> members, List<RGroupList> tGroups) = await GroupListService.GetMemberByListids(_coreAPIHttpService, client, _dingDing, listids, $"{school}");
                groups = tGroups.Select(x => new OGgroup
                {
                    name = x.name,
                    no = x.no,
                    periodId = x.periodId,
                    school = x.school,
                    type = x.type,
                    year = x.year,
                    expire = x.expire,
                    tcount = x.tcount,
                    scount = x.scount,
                    leader = x.leader,
                    members = x.members,
                    id = x.id
                }).ToList();
                if (bizId.Equals("cc7e900c-4881-4fe9-9c64-abb1a1f95518") || bizId.Equals("633d4d36-2cae-469a-bdcb-c52ce2e416b3") || bizId.Equals("8254bc86-aae9-4fef-9655-4fbda1bd39da"))
                {
                    if (listids.Count == 1 && listids.First().Equals("TeacherAll") && !string.IsNullOrEmpty(school))
                    {
                        var keys = members.Select(x => x.id).ToHashSet();
                        var content = new StringContent(keys.ToJsonString(), Encoding.UTF8, "application/json");
                        string ujson = await _coreAPIHttpService.GetUserInfos(content);
                        if (!string.IsNullOrWhiteSpace(ujson))
                        {
                            var coreUsers = ujson.ToObject<List<CoreUser>>();
                            if (coreUsers.IsNotEmpty())
                            {
                                coreUsers.ForEach(z => {
                                    var mb = members.Find(x => x.id.Equals(z.id));
                                    if (mb != null)
                                    {
                                        mb.no = z.mobile;
                                    }
                                });

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

            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetGroupMembers()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };

            }
        }

        /// <summary>
        /// 获取课程列表信息
        /// [ApiToken(Auth = "1301", Name = "获取课程列表信息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetCourseList(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                var client = _azureCosmos.GetCosmosClient();
                json.TryGetProperty("periodId", out JsonElement periodId);
                json.TryGetProperty("subjectId", out JsonElement subjectId);
                StringBuilder sql = new StringBuilder($"SELECT c.id,c.name,c.subject,c.period,c.scope,c.no,c.school FROM c where 1=1 ");
                if (!string.IsNullOrWhiteSpace($"{periodId}"))
                {
                    sql.Append($" and c.period.id='{periodId}'");
                }
                if (!string.IsNullOrWhiteSpace($"{subjectId}"))
                {
                    sql.Append($" and c.subject.id='{subjectId}'");
                }
                List<dynamic> courses = new List<dynamic>();
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<dynamic>(queryText: sql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Course-{school}") }))
                {
                    courses.Add(item);
                }
                return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = courses };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetCourseList()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };

            }
        }

        /// <summary>
        /// 课程详细信息
        /// [ApiToken(Auth = "1302", Name = "课程详细信息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetCourseInfo(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                json.TryGetProperty("courseId", out JsonElement courseId);
                Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{courseId}", new PartitionKey($"Course-{school}"));
                if (response.Status == 200)
                {
                    JsonDocument document = JsonDocument.Parse(response.Content);
                    Course course = document.RootElement.Deserialize<Course>();
                    return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = new { course.name, course.id, course.subject, course.period, course.scope, course.school, course.no, course.desc, course.schedule } };
                }
                else
                    return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "未找到相关课程" };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetCourseInfo()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 获取指定学段作息
        /// [ApiToken(Auth = "1303", Name = "获取指定学段作息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetPaperExamCondition(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                json.TryGetProperty("periodId", out JsonElement _periodId);
                School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                var period = data.period.Find(x => x.id.Equals($"{_periodId}"));
                if (period != null)
                {
                    return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = new { period.subjects, period.timetable, period.grades, period.majors, weekDays } };
                }
                else
                    return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "未找到相关课程" };

            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetPaperExamCondition()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        public static async Task<ResponseData<dynamic>> getCourseTechnology(IHttpClientFactory _httpClient, DingDing _dingDing, string bizId, string school, JsonElement json, IWebHostEnvironment _environment)
        {
            try
            {
                _httpClient.CreateClient().DefaultRequestHeaders.Add("ContentLength", "0");
                HttpContent httpContent = new StringContent(new { method = "statistic/data/" }.ToJsonString());
                /*Dictionary<string, object> data = new Dictionary<string, object>();
                data.Add("method", "statistic/data/");*/
                //data.Add("params", new { method = "statistic/data/"});
                //HttpResponseMessage responseMessage = await _httpClient.CreateClient().PostAsJsonAsync("http://116.204.72.199:81/statistic/data/", data);
                var response = await _httpClient.CreateClient().PostAsync("http://116.204.72.199:81/statistic/data/", httpContent);
                //获取配置文件内容
                string path = $"{_environment.ContentRootPath}/JsonFile/Core/field.json";

                StreamReader streamReader = new(new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.UTF8);
                StringBuilder stringBuilder = new();
                string text;
                while ((text = streamReader.ReadLine()) != null)
                {
                    stringBuilder.Append(text.ToString());
                }
                streamReader.Close();
                string input = stringBuilder.ToString();
                Field fields = input.ToObject<Field>();
                List<OCourseBase> courses = new();
                List<(string name, double T, double P, int attendCount, int mCount, int groups, long time,
                    List<(string name, int count)> counts, List<(string name, double score)> ps,
                    List<(string name, long time)> appTimes, List<(string name, string url, int duration, long time)> vd)> scores = new();
                //List<(string name, List<(string name, int count)> counts)> eveCounts = new();
                if (response.IsSuccessStatusCode)
                {
                    string responseBody = response.Content.ReadAsStringAsync().Result;
                    JObject jo = JObject.Parse(responseBody.ToString());
                    JArray array = jo.Value<JArray>("base");
                    foreach (var ne in array)
                    {
                        OCourseBase @base = new();
                        var tname = ne["tmdname"].Value<string>();
                        var cname = ne["courseName"].Value<string>();
                        var attendCount = ne["attendCount"].Value<int>();
                        var mCount = ne["mCount"].Value<int>();
                        var time = ne["time"].Value<long>();
                        var obj = ne["events"].ToObject<List<Events>>();
                        var video = ne["videos"].ToObject<List<Videos>>();
                        @base.tmdname = tname;
                        @base.courseName = cname;
                        @base.attendCount = attendCount;
                        @base.mCount = mCount;
                        @base.groups = new List<string>();
                        @base.time = time;
                        @base.eves = obj;
                        @base.videos = video;
                        //events.Add(obj);
                        courses.Add(@base);
                    }
                    foreach (var eve in courses)
                    {
                        var countEve = eve.eves.GroupBy(x => x.@event).Select(y => new { name = y.Key, value = y.Sum(c => c.freq) });
                        double scoreA = 0;
                        if (countEve.Any())
                        {
                            scoreA += 20;
                        }
                        double scoreB = 0;
                        int P1Count = 0;
                        int P2Count = 0;
                        int P3Count = 0;
                        int P4Count = 0;
                        int P5Count = 0;
                        List<(string name, long time)> eveTimes = new();
                        List<(string name, string url, int duration, long time)> videos = new();
                        foreach (var v in eve.videos)
                        {
                            videos.Add((v.videoName, v.video, v.duration, v.startTime));
                        }
                        foreach (var apps in eve.eves)
                        {
                            var name = fields.fields.Where(x => x.field.Equals(apps.@event)).FirstOrDefault()?.desc;
                            eveTimes.Add((name, apps.createTime));
                        }
                        List<(string name, int count)> eves = new();
                        foreach (var per in countEve)
                        {
                            var name = fields.fields.Where(x => x.field.Equals(per.name)).FirstOrDefault()?.desc;
                            eves.Add((name, per.value));
                            foreach (var evePercent in fields.fields)
                            {
                                //计算T分
                                if (per.name.Equals(evePercent.field))
                                {
                                    if (evePercent.dimension.Equals("小组学习"))
                                    {
                                        P1Count++;
                                    }
                                    if (evePercent.dimension.Equals("全班互动"))
                                    {
                                        P2Count++;
                                    }
                                    if (evePercent.dimension.Equals("生本决策"))
                                    {
                                        P3Count++;
                                    }
                                    if (evePercent.dimension.Equals("全班测验"))
                                    {
                                        P4Count++;
                                    }
                                    if (evePercent.dimension.Equals("个人学习"))
                                    {
                                        P5Count++;
                                    }
                                    double bScore = 0;
                                    if (per.value == 1)
                                    {
                                        bScore += evePercent.percent * 0.9;
                                    }
                                    else if (per.value == 2)
                                    {
                                        bScore += evePercent.percent * 0.95;
                                    }
                                    else if (per.value >= 3)
                                    {
                                        bScore += evePercent.percent;
                                    }
                                    scoreB += bScore;
                                }
                            }
                        }
                        List<(string name, double score)> PScore = new();

                        double P1Score = 0;
                        if (P1Count == 1)
                        {
                            P1Score = 18 * 0.8;
                        }
                        else if (P1Count == 2)
                        {
                            P1Score = 18 * 0.9;
                        }
                        else if (P1Count >= 3)
                        {
                            P1Score = 18;
                        }
                        double P2Score = 0;
                        if (P2Count == 1)
                        {
                            P2Score = 18 * 0.8;
                        }
                        else if (P2Count == 2)
                        {
                            P2Score = 18 * 0.9;
                        }
                        else if (P2Count >= 3)
                        {
                            P2Score = 18;
                        }
                        double P3Score = 0;
                        if (P3Count == 1)
                        {
                            P3Score = 18 * 0.8;
                        }
                        else if (P3Count == 2)
                        {
                            P3Score = 18 * 0.9;
                        }
                        else if (P3Count >= 3)
                        {
                            P3Score = 18;
                        }
                        double P4Score = 0;
                        if (P4Count == 1)
                        {
                            P4Score = 18 * 0.8;
                        }
                        else if (P3Count == 2)
                        {
                            P4Score = 18 * 0.9;
                        }
                        else if (P4Count >= 3)
                        {
                            P4Score = 18;
                        }
                        double P5Score = 0;
                        if (P5Count == 1)
                        {
                            P5Score = 18 * 0.8;
                        }
                        else if (P5Count == 2)
                        {
                            P5Score = 18 * 0.9;
                        }
                        else if (P5Count >= 3)
                        {
                            P5Score = 18;
                        }
                        double P6Score = (P1Score + P2Score + P3Score + P4Score + P5Score) * 0.1;
                        PScore.Add(("小组学习", P1Score));
                        PScore.Add(("全班互动", P2Score));
                        PScore.Add(("生本决策", P3Score));
                        PScore.Add(("全班测验", P4Score));
                        PScore.Add(("个人学习", P5Score));
                        PScore.Add(("多元评价", P6Score));
                        double P = P1Score + P2Score + P3Score + P4Score + P5Score + P6Score;
                        double scoreC = (scoreA + scoreB) * 0.1;
                        double scoreT = scoreA + scoreB + scoreC;
                        scoreT = scoreT > 0 ? Math.Round(scoreT, 2) : 0;
                        P = P > 0 ? Math.Round(P, 2) : 0;
                        scores.Add((eve.courseName, scoreT, P, eve.attendCount, eve.mCount, eve.groups.Count, eve.time, eves, PScore, eveTimes, videos));
                        //eveCounts.Add((eve.courseName, eves));
                    }
                    //var eve = courses.Select(c => c.eves).ToList();
                    /*using JsonDocument document = JsonDocument.Parse(responseBody.ToString());
                    if (document.RootElement.TryGetProperty("base", out JsonElement AccessTokenObj))
                    {
                        //AccessToken = AccessTokenObj.ToString();
                    }*/
                }
                var courseScore = scores.Select(c => new
                {
                    c.name,
                    c.T,
                    c.P,
                    c.attendCount,
                    c.mCount,
                    c.groups,
                    c.time,
                    count = c.counts.Select(x => new { x.name, x.count }),
                    pScore = c.ps.Select(x => new { x.name, x.score }),
                    appTime = c.appTimes.Select(x => new { x.name, x.time }),
                    videos = c.vd.Select(x => new { x.name, x.url, x.duration, x.time })
                });
                /*var courseCount = eveCounts.Select(c => new
                {
                    c.name,
                    count = c.counts.Select(x => new { x.name, x.count })
                });*/
                return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = new { courseScore } };
                /*if (period != null)
                {
                    return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = new { period.subjects, period.timetable, period.grades, period.majors, weekDays } };
                }
                else
                    return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "未找到相关课程" };*/

            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/getCourseTechnology()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 物理教室列表
        /// [ApiToken(Auth = "1401", Name = "物理教室列表",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<List<ORoom>>> GetRoomList(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                var client = _azureCosmos.GetCosmosClient();
                List<ORoom> dtRooms = new();
                StringBuilder sql = new StringBuilder($"select value(c) from c where 1=1 ");
                json.TryGetProperty("openType", out JsonElement openType);
                json.TryGetProperty("no", out JsonElement no);

                if (!string.IsNullOrWhiteSpace($"{openType}"))
                {
                    sql.Append($" and c.openType='{openType}'");
                }
                if (!string.IsNullOrWhiteSpace($"{no}"))
                {
                    sql.Append($" and c.no='{no}'");
                }
                List<Room> rooms = new List<Room>();
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<Room>(queryText: sql.ToString(),
                requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Room-{school}") }))
                {
                    rooms.Add(item);
                }

                dtRooms = rooms.Select(s => new ORoom { id = s.id, name = s.name, x = s.x, y = s.y, openType = s.openType, style = s.style, area = s.area, address = s.address, school = school }).ToList();
                if (dtRooms.Count > 0)
                    return new ResponseData<List<ORoom>>() { code = RespondCode.Ok, data = dtRooms };
                else
                    return new ResponseData<List<ORoom>>() { code = RespondCode.NotFound, msg = "未找到该学校的物理教室" };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetRoomList()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<List<ORoom>>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 物理教室详细
        /// [ApiToken(Auth = "1402", Name = "物理教室详细",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetRoomInfo(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                var client = _azureCosmos.GetCosmosClient();
                if (!json.TryGetProperty("roomId", out JsonElement roomId)) return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "参数错误" };

                Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{roomId}", new PartitionKey($"Room-{school}"));
                if (response.Status == 200)
                {
                    JsonDocument document = JsonDocument.Parse(response.Content);
                    Room tRoom = document.RootElement.Deserialize<Room>();
                    return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = new { tRoom.id, tRoom.name, tRoom.x, tRoom.y, tRoom.openType, tRoom.style, tRoom.area, tRoom.address, school } };
                }
                else
                    return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "未找到物理教室详情" };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetRoomInfo()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 教师列表信息
        /// [ApiToken(Auth = "1501", Name = "教师列表信息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_coreAPIHttpService"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetTeacherList(AzureCosmosFactory _azureCosmos, CoreAPIHttpService _coreAPIHttpService, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                var client = _azureCosmos.GetCosmosClient();
                json.TryGetProperty("searchKey", out JsonElement _searchKey);
                List<CoreUser> coreUsers = new(); List<CoreUser> unjoined = new();
                IEnumerable<string> unexist = null;
                StringBuilder sql = new("select c.id,c.name ,c.picture,c.job ,c.subjectIds,c.roles from c");

                if (_searchKey.ValueKind.Equals(JsonValueKind.Array))
                {
                    List<string> searchKey = _searchKey.ToObject<List<string>>();
                    if (searchKey.Any())
                    {
                        var keys = searchKey.Where(x => !string.IsNullOrWhiteSpace(x));
                        var content = new StringContent(keys.ToJsonString(), Encoding.UTF8, "application/json");
                        string ujson = await _coreAPIHttpService.GetUserInfos(content);
                        if (!string.IsNullOrWhiteSpace(ujson))
                        {
                            coreUsers = ujson.ToObject<List<CoreUser>>();
                        }
                        if (coreUsers.Any())
                            unexist = searchKey.Except(coreUsers.Select(x => x.searchKey));
                        else
                            return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "没有找到对应的教师信息", data = _searchKey };
                    }
                }

                List<SchoolTeacher> teachers = new();
                //string insql = "";
                if (coreUsers.Any())
                    sql.Append($" where  c.id in  ({string.Join(",", coreUsers.Select(x => $"'{x.id}'"))}) ");

                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<SchoolTeacher>
                    (queryText: sql.ToString(), requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school}") }))
                {
                    teachers.Add(item);
                }

                if (coreUsers.Count > 0)
                {
                    var teacherIds = coreUsers.Select(x => x.id).Except(teachers.Select(x => x.id));
                    unjoined = coreUsers.FindAll(x => teacherIds.Contains(x.id));
                }

                List<dynamic> tchs = new List<dynamic>();
                teachers.Select(x => new { x.id, x.name, x.picture, x.job, x.subjectIds, x.roles }).ToList().ForEach(x =>
                {
                    if (coreUsers.Count > 0)
                    {
                        var coreUser = coreUsers.Find(c => c.id.Equals(x.id));
                        if (coreUser != null)
                        {
                            tchs.Add(new { x.id, coreUser.name, coreUser.picture, x.job, x.subjectIds, x.roles, coreUser.searchKey, school });
                        }
                    }
                    else
                        tchs.Add(new { x.id, x.name, x.picture, x.job, x.subjectIds, x.roles, school });
                });

                return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = new { tchs, unjoined = unjoined.Select(x => new { id = x.id, name = x.name, picture = x.picture, searchKey = x.searchKey }).ToList(), unexist } };
            }
            catch (Exception ex)
            {
                //await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetTeacherList()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }


        /// <summary>
        /// 教师执教的班级和课程
        /// [ApiToken(Auth = "1502", Name = "教师详细信息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetTeacherTeach(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {

            try
            {
                if (json.TryGetProperty("tmdid", out JsonElement _tmdid))
                {
                    json.TryGetProperty("period", out JsonElement _period);
                    List<OCourse> courses = new List<OCourse>();
                    var query = $"SELECT distinct  c.code,c.id,c.no,c.name,c.period,c.subject,c.scope ,c['desc'] ,c.creatorId ,  c.year ,s as schedule FROM c  join  s in  c.schedule  where s.teacherId='{_tmdid}' ";
                    HashSet<string> classIds = new HashSet<string>();
                    if (!string.IsNullOrWhiteSpace($"{_period}"))
                    {
                        query = $"{query} and   c.period.id ='{_period}'";
                    }
                    await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<OCourse>(queryText: query,
                            requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Course-{school}") }))
                    {
                        if (!string.IsNullOrWhiteSpace(item.schedule?.stulist))
                        {
                            classIds.Add(item.schedule?.stulist);
                        }
                        if (!string.IsNullOrWhiteSpace(item.schedule?.classId))
                        {
                            classIds.Add(item.schedule?.classId);
                        }
                        courses.Add(item);
                    }
                    List<OGroupList> groupLists = new List<OGroupList>();
                    if (classIds.Any())
                    {
                        var tempGroupLists = await GroupListService.GetGroupListByListids(_azureCosmos.GetCosmosClient(), _dingDing, classIds.ToList(), school);
                        groupLists = tempGroupLists.Select(x => new OGroupList { id = x.id, name = x.name, type = x.type, periodId = x.periodId, school = x.school, scope = x.scope, year = x.year, expire = x.expire }).ToList();
                    }

                    var group = courses.GroupBy(x => x.id).Select(g => new { key = g.Key, list = g.ToList() });
                    List<Course> coursesR = new List<Course>();
                    group.ToList().ForEach(x =>
                    {
                        var first = x.list.First();
                        coursesR.Add(new Course
                        {
                            id = x.key,
                            name = first.name,
                            code = first.code,
                            no = first.no,
                            period = first.period,
                            subject = first.subject,
                            desc = first.desc,
                            creatorId = first.creatorId,
                            year = first.year,
                            schedule = x.list.Select(x => x.schedule).ToList()
                        });
                    });
                    return new ResponseData<dynamic>()
                    {
                        code = RespondCode.Ok,
                        data = new
                        {

                            courses = coursesR.Select(x => new
                            {
                                x.id,
                                school = school,
                                x.name,
                                x.no,
                                x.period,
                                x.subject,
                                x.desc,
                                x.creatorId,
                                x.year,
                                x.schedule
                            }),
                            groupLists
                        }
                    };
                }
                else
                {
                    return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "参数错误" };
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetTeacherTeach()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 教师详细信息
        /// [ApiToken(Auth = "1502", Name = "教师详细信息",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetTeacherInfo(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                var client = _azureCosmos.GetCosmosClient();
                json.TryGetProperty("tmdid", out JsonElement _tmdid);
                Response responseSchoolTch = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School")
                    .ReadItemStreamAsync($"{_tmdid}", new PartitionKey($"Teacher-{school}"));
                Response responseTch = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher")
                     .ReadItemStreamAsync($"{_tmdid}", new PartitionKey($"Base"));
                Teacher teacher = null;
                if (responseTch.Status == 200)
                {
                    teacher = JsonDocument.Parse(responseTch.Content).RootElement.Deserialize<Teacher>();
                }
                else
                    return new ResponseData<dynamic> { code = RespondCode.NotFound, msg = "账号未创建" };
                if (responseSchoolTch.Status == 200 && teacher != null)
                {
                    SchoolTeacher schoolTeacher = JsonDocument.Parse(responseSchoolTch.Content).RootElement.Deserialize<SchoolTeacher>();

                    return new ResponseData<dynamic> { code = RespondCode.Ok, msg = "成功", data = new { teacher.id, teacher.name, teacher.picture, schoolTeacher.job, schoolTeacher.status, schoolTeacher.roles, schoolTeacher.subjectIds, school = teacher.schools?.Find(x => x.schoolId.Equals(school)) } };
                }
                else
                    return new ResponseData<dynamic> { code = RespondCode.NotFound, msg = "教师未就职该学校" };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetTeacherInfo()   参数：bizId:{bizId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 教师批量导入，并加入学校。可以导入学科，但需要填写学段id
        /// [ApiToken(Auth = "1503", Name = "教师批量导入",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_coreAPIHttpService"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<List<OTeachers>>> GetTeacherInfo(AzureCosmosFactory _azureCosmos, CoreAPIHttpService _coreAPIHttpService, DingDing _dingDing, string bizId, string school, ImportTechDto json)
        {
            try
            {
                //如果需要同时导入学科，则需要填写学段
                List<ImportTech> impTeachers = json.teachers;
                List<string> searchKey = impTeachers.Select(x => x.id).ToList();
                string ujson = null;
                var keys = searchKey.Where(x => !string.IsNullOrWhiteSpace(x));
                if (keys.Any())
                {
                    var content = new StringContent(keys.ToJsonString(), Encoding.UTF8, "application/json");
                    ujson = await _coreAPIHttpService.GetUserInfos(content);
                }
                List<CoreUser> coreUsers = new List<CoreUser>();
                if (!string.IsNullOrWhiteSpace(ujson))
                {
                    coreUsers = ujson.ToObject<List<CoreUser>>();
                }
                IEnumerable<string> unexist = new List<string>();
                if (coreUsers.Any())
                {
                    unexist = searchKey.Except(coreUsers.Select(x => x.id));
                }
                else
                {
                    return new ResponseData<List<OTeachers>>() { code = RespondCode.NotFound, msg = "没有找到对应的教师信息" };
                }
                var exist = coreUsers.Select(x => x.id);
                //注册了账号的教师
                impTeachers = impTeachers.Where(x => exist.Contains(x.id)).ToList();

                List<Teacher> teachersList = new List<Teacher>();
                List<SchoolTeacher> schoolTeachers = new List<SchoolTeacher>();
                string sql = $"select value(c) from c where c.id in ({string.Join(",", impTeachers.Select(x => $"'{x.id}'"))})";
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher)
                    .GetItemQueryIterator<Teacher>(queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey("Base") }))
                {
                    teachersList.Add(item);
                }
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School)
                  .GetItemQueryIterator<SchoolTeacher>(queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school}") }))
                {
                    schoolTeachers.Add(item);
                }
                long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                School data = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                //学校学科发生变化。
                List<SchoolTeacher> schoolTeachersAdd = new List<SchoolTeacher>();
                bool baseChange = false;
                foreach (var item in impTeachers)
                {
                    var teacher = teachersList.Find(x => x.id.Equals(item.id));
                    var coreUser = coreUsers.Find(x => x.id.Equals(item.id));
                    if (teacher != null)
                    {
                        var sch = teacher.schools?.Find(x => x.schoolId.Equals(school));
                        if (sch == null)
                        {
                            if (teacher.schools.IsNotEmpty())
                            {
                                teacher.schools.Add(new Teacher.TeacherSchool { schoolId = school, name = data.name, status = "invite", time = now, picture = data.picture, areaId = data.areaId });
                            }
                            else
                            {
                                teacher.defaultSchool = school;
                                teacher.size = teacher.size + 1;
                                teacher.schools = new List<Teacher.TeacherSchool> { new Teacher.TeacherSchool { schoolId = school, name = data.name, status = "invite", time = now, picture = data.picture, areaId = data.areaId } };
                            }
                        }
                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReplaceItemAsync(teacher, teacher.id, new PartitionKey("Base"));
                    }
                    else
                    {

                        teacher = new Teacher
                        {
                            createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                            id = coreUser.id,
                            name = coreUser.name,
                            picture = coreUser.picture,
                            defaultSchool = school,
                            size = 2,
                            code = "Base",
                            pk = "Base",
                            schools = new List<Teacher.TeacherSchool> { new Teacher.TeacherSchool { schoolId = school, name = data.name, status = "invite", time = now, picture = data.picture, areaId = data.areaId } }
                        };
                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).CreateItemAsync(teacher, new PartitionKey("Base"));
                    }
                    var schoolTeacher = schoolTeachers.Find(x => x.id.Equals(item.id));
                    //处理导入的学科
                    List<string> subjectIds = new List<string>();
                    if (item.subjects.IsNotEmpty() && !string.IsNullOrWhiteSpace(item.periodId))
                    {
                        item.subjects.ForEach(s =>
                        {
                            //同名学科
                            var subject = data.period.Find(x => x.id.Equals(item.periodId))?.subjects?.Find(x => x.id.Equals(s.id));
                            if (subject == null)
                            {
                                subject = data.period.Find(x => x.id.Equals(item.periodId))?.subjects?.Find(x => x.name.Equals(s.name));
                            }
                            else
                            {
                                subjectIds.Add(subject.id);
                            }
                            if (subject == null)
                            {
                                var period = data.period.Find(x => x.id.Equals(item.periodId));
                                if (period != null)
                                {
                                    period.subjects.Add(new Subject { id = s.id, name = s.name, type = 2 });
                                    subjectIds.Add(s.id);
                                    baseChange = true;
                                }
                            }
                        });
                    }
                    if (schoolTeacher == null)
                    {
                        schoolTeacher = new SchoolTeacher
                        {
                            id = item.id,
                            name = coreUser.name,
                            picture = coreUser.picture,
                            job = item.job,
                            subjectIds = subjectIds,
                            roles = new List<string> { "teacher" },
                            permissions = new List<string> { "content-read", "exercise-read", "knowledge-read", "syllabus-read" },
                            status = "invite",
                            code = $"Teacher-{school}",
                            pk = "Teacher",
                            createTime = now,
                        };
                        schoolTeachersAdd.Add(schoolTeacher);
                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).CreateItemAsync(schoolTeacher, new PartitionKey(schoolTeacher.code));
                    }
                    else
                    {
                        if (subjectIds.IsNotEmpty())
                        {
                            subjectIds.ForEach(x =>
                            {
                                if (!schoolTeacher.subjectIds.Contains(x))
                                {
                                    schoolTeacher.subjectIds.Add(x);
                                }
                            });
                        }
                        schoolTeacher.job = string.IsNullOrWhiteSpace(item.job) ? schoolTeacher.job : item.job;
                        schoolTeachersAdd.Add(schoolTeacher);
                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync(schoolTeacher, schoolTeacher.id, new PartitionKey(schoolTeacher.code));
                    }
                }
                if (baseChange)
                {
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync(data, data.id, new PartitionKey("Base"));
                }

                return new ResponseData<List<OTeachers>>() { code = RespondCode.Ok, msg = "成功", data = schoolTeachersAdd.Select(x => new OTeachers { id = x.id, name = x.name, picture = x.picture, job = x.job, subjectIds = x.subjectIds, roles = x.roles, school = school }).ToList() };
                //return schoolTeachersAdd.Select(x => new OTeachers { id = x.id, name = x.name, picture = x.picture, job = x.job, subjectIds = x.subjectIds, roles = x.roles, school = school }).ToList();
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetTeacherInfo()   参数：bizId:{bizId},school:{school},json:{json} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<List<OTeachers>>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 查找课纲
        /// [ApiToken(Auth = "1601", Name = "查询课纲",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<List<OSyllabusTreeNode>>> GetSyllabus(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                if (!json.TryGetProperty("volumeId", out JsonElement volumeId)) return new ResponseData<List<OSyllabusTreeNode>>() { code = RespondCode.ParamsError, msg = "参数错误" };
                //if (!json.TryGetProperty("volumeCode", out JsonElement volumeCode)) return new ResponseData<List<OSyllabusTreeNode>>() { code = RespondCode.ParamsError, msg = "参数错误" };
                if (!json.TryGetProperty("scope", out JsonElement scope)) return new ResponseData<List<OSyllabusTreeNode>>() { code = RespondCode.ParamsError, msg = "参数错误" };

                var client = _azureCosmos.GetCosmosClient();

                OVolume volume = null;
                List<OSyllabusTreeNode> treeNodes = new();
                List<OSyllabusTreeNode> redt = new();
                if ($"{scope}".Equals("school"))
                {
                    List<OSyllabus> delSyllabus = new();
                    volume = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<OVolume>($"{volumeId}", new PartitionKey($"Volume-{school}"));
                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<OSyllabus>(queryText: $"select value(c) from c where c.volumeId='{volumeId}'",
                        requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Syllabus-{volume.school}") }))
                    {
                        if (item.children.IsEmpty())
                        {
                            delSyllabus.Add(item);
                        }
                        else
                        {
                            List<OSyllabusTree> trees = SyllabusService.OListToTree(item.children);
                            OSyllabusTreeNode otree = new() { id = item.id, scope = item.scope, trees = trees, volumeId = item.volumeId, codeval = volume.school };
                            treeNodes.Add(otree);
                        }
                    }
                    if (delSyllabus.IsNotEmpty())
                    {
                        await client.GetContainer(Constant.TEAMModelOS, "School").DeleteItemsAsync<OSyllabus>(delSyllabus.Select(x => x.id).ToList(), $"Syllabus-{volume.school}");
                    }
                }
                else
                    return new ResponseData<List<OSyllabusTreeNode>>() { code = RespondCode.ParamsError, msg = "参数错误" };

                ResponseData<List<OSyllabusTreeNode>> responseData = new();
                //对课纲树形结构排序
                if (volume.syllabusIds.IsNotEmpty())
                {
                    volume.syllabusIds.ForEach(x =>
                    {
                        for (int index = 0; index < treeNodes.Count; index++)
                        {
                            if (treeNodes[index].id == x)
                            {
                                redt.Add(treeNodes[index]);
                                treeNodes.RemoveAt(index);
                            }
                        }
                    });
                    redt.AddRange(treeNodes);
                    responseData = new ResponseData<List<OSyllabusTreeNode>>() { code = RespondCode.Ok, msg = "成功", data = redt };
                }
                else
                {
                    responseData = new ResponseData<List<OSyllabusTreeNode>>() { code = RespondCode.Ok, msg = "成功", data = treeNodes };
                }
                return responseData;
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetSyllabus()  参数：bizId:{bizId},school:{school},参数json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<List<OSyllabusTreeNode>>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 查询册别清单
        /// [ApiToken(Auth = "1602", Name = "查询册别",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<List<OVolume>>> GetVolumes(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                ResponseData<List<OVolume>> responseData = new();

                List<OVolume> ovolumes = new List<OVolume>();
                json.TryGetProperty("periodId", out JsonElement periodCode);
                json.TryGetProperty("subjectId", out JsonElement subjectCode);
                json.TryGetProperty("status", out JsonElement status);
                json.TryGetProperty("scope", out JsonElement scope);
                if (scope.GetString().Equals("school"))
                {
                    await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<OVolume>(queryText: $"select value(c) from c where c.status = {status} and c.periodId = '{periodCode}' and c.subjectId = '{subjectCode}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Volume-{school}") }))
                    {
                        ovolumes.Add(item);
                    }
                }
                else { return new ResponseData<List<OVolume>>() { code = RespondCode.ParamsError, msg = "参数错误" }; };

                if (ovolumes.Count > 0)
                {
                    responseData = new ResponseData<List<OVolume>>() { code = RespondCode.Ok, msg = "成功", data = ovolumes };
                }
                else
                    responseData = new ResponseData<List<OVolume>>() { code = RespondCode.NotFound, msg = "未找到参数相关的数据" };
                return responseData;
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetVolumes()  参数：bizId:{bizId},school:{school},参数json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<List<OVolume>>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }

        /// <summary>
        /// 查询知识
        /// [ApiToken(Auth = "1701", Name = "查询知识点",TName ="",EName ="", RWN = "R", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetKnowledges(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {
            try
            {
                ResponseData<dynamic> responseData = new();
                var client = _azureCosmos.GetCosmosClient();

                json.TryGetProperty("periodId", out JsonElement periodId);
                if (!json.TryGetProperty("subjectId", out JsonElement subjectId)) return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "参数错误" };
                //if (!json.TryGetProperty("school_code", out JsonElement school_code)) return new ResponseData<List<Knowledge>>() { code = RespondCode.ParamsError, msg = "参数错误" };
                string code = $"Knowledge-{school}-{subjectId}";
                StringBuilder sql = new($"select value(c) from c");
                if (periodId.ValueKind.Equals(JsonValueKind.String))
                {
                    sql.Append($" where c.periodId = '{periodId}'");
                }
                List<dynamic> knowledges = new();

                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<Knowledge>(queryText: sql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"{code}") }))
                {
                    knowledges.Add(new { item.periodId, item.subjectId, item.points, item.blocks, item.id });
                }

                if (knowledges.Any())
                {
                    var data = knowledges.Select(x => new { });
                    responseData = new() { code = RespondCode.Ok, msg = "成功", data = knowledges };
                }
                else
                {
                    responseData = new() { code = RespondCode.NotFound, msg = "未找到相关" };
                }
                return responseData;
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetKnowledges()  参数：bizId:{bizId},school:{school},参数json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }
        /// <summary>
        /// 设置学生全面教育画像
        ///[ApiToken(Auth = "1901", Name = "设置学生全面教育画像", TName = "設置學生全面教育畫像", EName = "Set up students overall education portrait", RWN = "W", Limit = false)]
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> UpsertStudentPortrait(AzureCosmosFactory _azureCosmos, DingDing _dingDing,AzureRedisFactory _azureRedis ,  JsonElement json,string school=null)
        {
            try
            {
                ResponseData<dynamic> responseData = new();
                var client = _azureCosmos.GetCosmosClient();
                if (!json.TryGetProperty("schoolCode", out JsonElement schoolCode))
                {
                    return responseData = new() { code = RespondCode.ParamsError, msg = "schoolCode为空" };
                }
#if !DEBUG
                if (!string.IsNullOrWhiteSpace(school) && !school.Equals($"{schoolCode}", StringComparison.OrdinalIgnoreCase)) {
                    return responseData = new() { code = RespondCode.ParamsError, msg = "授权学校与参数schoolCode不匹配" };
                }
#endif
                if (!json.TryGetProperty("periodId", out JsonElement periodId))
                {
                    return responseData = new() { code = RespondCode.ParamsError, msg = "periodId为空" };
                }
                if (!json.TryGetProperty("subjectId", out JsonElement subjectId))
                {
                    return responseData = new() { code = RespondCode.ParamsError, msg = "subjectId为空" };
                }
                if (!json.TryGetProperty("students", out JsonElement _students) && !_students.ValueKind.Equals(JsonValueKind.Array))
                {
                    return responseData = new() { code = RespondCode.ParamsError, msg = "students为空或格式错误" };
                }
                if (!$"{subjectId}".Equals("subject_sport") && !$"{subjectId}".Equals("subject_virtue") && !$"{subjectId}".Equals("subject_labour")
                    && !$"{subjectId}".Equals("subject_intelligence")  
                    && !$"{subjectId}".Equals("subject_art"))
                {
                    return responseData = new() { code = RespondCode.ParamsError, msg = "当前subjectId未开放画像业务" };
                }
                School schoolBase = await client.GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>($"{schoolCode}", new PartitionKey("Base"));
                List<PortraitStudent> students = _students.ToObject<List<PortraitStudent>>();
                if (students.IsEmpty()) { 
                    return responseData = new() { code = RespondCode.ParamsError, msg = "没有学生数据" };
                }
                List<(Student studentBase, PortraitStudent portrait)> studentsBases = new List<(Student, PortraitStudent)>();
                //学生信息不匹配的
                List<PortraitStudent> unmatchStuInfo = new List<PortraitStudent>();
                //学期不匹配的
                List<PortraitStudent> unmatchSemester = new List<PortraitStudent>();
                List<PortraitStudent> upsertDatas = new List<PortraitStudent>();
                //细项类型不匹配的
                List<PortraitStudent> unmatchItemScoreType = new List<PortraitStudent>();
                string stusql = $"select c.id,c.classId,c.name,c.year  from c where c.id in ({string.Join(",", students.Select(f => $"'{f.studentId}'"))})";
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, Constant.Student)
                    .GetItemQueryIterator<Student>(queryText: stusql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Base-{schoolCode}") }))
                {
                    var student = students.Find(x => x.studentId.Equals(item.id));
                    student.classId = item.classId;
                    studentsBases.Add((item, student));
                    //if ($"{item.classId}".Equals($"{student.classId}"))
                    //{
                    //    studentsBases.Add((item,student));
                    //}
                    //else {
                    //    unmatchStuInfo.Add(student);
                    //}
                }
                var unexist = students.FindAll(z => !studentsBases.Select(z => z.studentBase.id).Contains(z.studentId));
                if (unexist.Any())
                {
                    unmatchStuInfo.AddRange(unexist);
                }
                Period period = schoolBase.period.Find(x => x.id.Equals($"{periodId}"));

                if (period == null)
                {
                    return responseData = new() { code = RespondCode.NotFound, msg = "periodId不存在" };
                }
                else
                {
                    bool periodChange = false;
                    if (!period.semesters.Any())
                    {
                        //未设置学期则默认
                        period.semesters.Add(new Semester
                        {
                            id = Guid.NewGuid().ToString(),
                            name = "第一学期",
                            start = 1,
                            month = 9,
                            day = 1
                        }); period.semesters.Add(new Semester
                        {
                            id = Guid.NewGuid().ToString(),
                            name = "第二学期",
                            start = 0,
                            month = 3,
                            day = 1
                        });
                        periodChange = true;
                    }
                    //是否需要创建科目 
                    if (!$"{subjectId}".Equals("subject_art", StringComparison.OrdinalIgnoreCase) || !$"{subjectId}".Equals("subject_intelligence", StringComparison.OrdinalIgnoreCase))
                    {
                        var bind = period.subjects.Find(x => !string.IsNullOrWhiteSpace(x.bindId) && x.bindId.Equals($"{subjectId}", StringComparison.OrdinalIgnoreCase));
                        if (bind == null)
                        {
                            string subjectName = "";
                            switch (true)
                            {
                                case bool when $"{subjectId}".Equals("subject_sport"):
                                    subjectName = "体育";
                                    break;
                                case bool when $"{subjectId}".Equals("subject_virtue"):
                                    subjectName = "德育";
                                    break;
                                case bool when $"{subjectId}".Equals("subject_labour"):
                                    subjectName = "劳动";
                                    break;
                                    //case bool when $"{subjectId}".Equals("subject_music"):
                                    //    subjectName = "音乐";
                                    //    break;
                                    //case bool when $"{subjectId}".Equals("subject_painting"):
                                    //    subjectName = "美术";
                                    //    break;
                            }
                            if (!string.IsNullOrWhiteSpace(subjectName))
                            {
                                var subName = period.subjects.Find(z => z.name.Contains(subjectName));
                                if (subName != null)
                                {
                                    subName.bindId = $"{subjectId}";
                                }
                                else
                                {
                                    period.subjects.Add(new Subject { id = Guid.NewGuid().ToString(), name = subjectName, bindId = $"{subjectId}", type = 1 });
                                }
                                periodChange = true;
                            }
                        }
                    }
                    //是否要创建艺术类的 音乐，美术科目
                    if ($"{subjectId}".Equals("subject_art", StringComparison.OrdinalIgnoreCase))
                    {
                        var bind_music = period.subjects.Find(x => !string.IsNullOrWhiteSpace(x.bindId) && x.bindId.Equals("subject_music", StringComparison.OrdinalIgnoreCase));
                        if (bind_music != null)
                        {
                            string subjectName = "音乐";
                            var subName = period.subjects.Find(z => z.name.Contains(subjectName));
                            if (subName != null)
                            {
                                subName.bindId = "subject_music";
                            }
                            else
                            {
                                period.subjects.Add(new Subject { id = Guid.NewGuid().ToString(), name = subjectName, bindId = "subject_music", type = 1 });
                            }
                            periodChange = true;
                        }
                        var bind_painting = period.subjects.Find(x => !string.IsNullOrWhiteSpace(x.bindId) && x.bindId.Equals("subject_painting", StringComparison.OrdinalIgnoreCase));
                        if (bind_painting != null)
                        {
                            string subjectName = "美术";
                            var subName = period.subjects.Find(z => z.name.Contains(subjectName));
                            if (subName != null)
                            {
                                subName.bindId = "subject_painting";
                            }
                            else
                            {
                                period.subjects.Add(new Subject { id = Guid.NewGuid().ToString(), name = subjectName, bindId = "subject_painting", type = 1 });
                            }
                            periodChange = true;

                        }
                    }
                    if (periodChange)
                    {
                        await client.GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync<School>(schoolBase, $"{schoolCode}", new PartitionKey("Base"));
                    }
                    List<Semester> sortedSemesters = SchoolService.SortSemester(period.semesters);
                    foreach (var studentInfo in studentsBases)
                    {
                        Student student = studentInfo.studentBase;
                        string studentId = studentInfo.studentBase.id;
                        string classId = studentInfo.studentBase.classId;
                        List<SemesterData> semesterDatas = studentInfo.portrait.semesterData;

                        if (semesterDatas.Any())
                        {
                            semesterDatas.ForEach(data =>
                            {
                                if (!string.IsNullOrWhiteSpace(data.semesterId))
                                {
                                    var semester = period.semesters.Find(s => s.id.Equals(data.semesterId));
                                    //如果找到对应的semesterId则直接使用当前semesterId
                                    if (semester == null)
                                    {
                                        //先处理，最后再检查。
                                        data.semesterId = $"{data.semesterId}--semesterId学期无效";
                                        if (data.semester > 0)
                                        {
                                            int count = period.semesters.Count();
                                            if (count >= data.semester)
                                            {
                                                data.semesterId = sortedSemesters[data.semester - 1].id;
                                            }
                                            else
                                            {
                                                data.semesterId = $"{data.semester}--semester学期无效";
                                            }
                                        }
                                        else
                                        {
                                            data.semesterId = $"{data.semester}--semester学期无效";
                                            //无效的学期数
                                        }
                                    }
                                }
                                else
                                {
                                    data.semesterId = $"{data.semesterId}--semesterId学期无效";
                                    if (data.semester > 0)
                                    {
                                        int count = period.semesters.Count();
                                        if (count >= data.semester)
                                        {
                                            data.semesterId = sortedSemesters[data.semester - 1].id;
                                        }
                                        else
                                        {
                                            data.semesterId = $"{data.semester}--semester学期无效";
                                        }
                                    }
                                    else
                                    {
                                        data.semesterId = $"{data.semester}--semester学期无效";
                                        //无效的学期数
                                    }
                                }
                            });
                            var noSemesterDatas = semesterDatas.Where(z => z.semesterId.Contains("学期无效")).ToList();
                            if (noSemesterDatas.Any())
                            {
                                unmatchSemester.Add(new PortraitStudent
                                {
                                    studentId = studentInfo.portrait.studentId,
                                    name = studentInfo.portrait.name,
                                    classId = studentInfo.portrait.classId,
                                    semesterData = noSemesterDatas,
                                });
                            }
                            var okSemesterDatas = semesterDatas.Where(z => !z.semesterId.Contains("学期无效"));
                            if (okSemesterDatas.Any())
                            {
                                upsertDatas.Add(new PortraitStudent
                                {
                                    studentId = studentInfo.portrait.studentId,
                                    name = studentInfo.portrait.name,
                                    classId = studentInfo.portrait.classId,
                                    semesterData = okSemesterDatas.ToList(),
                                });
                            }
                            var ids = okSemesterDatas.Select(k => $"{k.year}-{k.semesterId}-{studentId}");
                            if (ids.Any())
                            {
                                List<OverallEducation> overallEducations = new List<OverallEducation>();
                                string sql = $"select value c from c where c.id in ({string.Join(",", ids.Select(f => $"'{f}'"))})" +
                                    $" and c.studentId ='{studentId}' and c.schoolCode='{schoolCode}' and c.periodId='{periodId}' and c.classId='{classId}'";
                                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, Constant.Student)
                                    .GetItemQueryIterator<OverallEducation>(queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"OverallEducation-{schoolCode}") }))
                                {
                                    overallEducations.Add(item);
                                }
                                var nodbids = ids.Except(overallEducations.Select(x => x.id));
                                var newDatas = semesterDatas.FindAll(k => nodbids.Contains($"{k.year}-{k.semesterId}-{studentId}"));
                                var updateDatas = semesterDatas.FindAll(k => overallEducations.Select(z => z.id).Contains($"{k.year}-{k.semesterId}-{studentId}"));
                                List<OverallEducation> newOverallEducations = new List<OverallEducation>();
                                newDatas.ForEach(z =>
                                {
                                    //处理新增的学生学期画像
                                    var overallEducation = newOverallEducations.Find(o => o.id.Equals($"{z.year}-{z.semesterId}-{studentId}") && o.code.Equals($"OverallEducation-{schoolCode}"));
                                    if (overallEducation == null)
                                    {
                                        overallEducation = new OverallEducation
                                        {
                                            id = $"{z.year}-{z.semesterId}-{studentId}",
                                            code = $"OverallEducation-{schoolCode}",
                                            pk = "OverallEducation",
                                            ttl = -1,
                                            name = student.name,
                                            classId = student.classId,
                                            schoolCode = $"{schoolCode}",
                                            semesterId = z.semesterId,
                                            year = z.year,
                                            periodId = $"{periodId}",
                                            stuYear = student.year,
                                            studentId = student.id,
                                        };
                                        newOverallEducations.Add(overallEducation);
                                    }
                                });
                                if (newOverallEducations.Any())
                                {
                                    (newOverallEducations, unmatchItemScoreType) = FillSemesterData(studentId, $"{subjectId}", newOverallEducations, unmatchItemScoreType, newDatas,period);
                                    foreach (var edu in newOverallEducations)
                                    {
                                        await client.GetContainer(Constant.TEAMModelOS, Constant.Student).CreateItemAsync(edu, new PartitionKey(edu.code));
                                        string key = $"OverallEducation:{edu.schoolCode}:{edu.periodId}:{edu.year}:{edu.semesterId}:{edu.classId}";
                                        await _azureRedis.GetRedisClient(8).HashSetAsync(key, edu.studentId, edu.ToJsonString());
                                        await _azureRedis.GetRedisClient(8).KeyExpireAsync(key, new TimeSpan(180 * 24, 0, 0));
                                    }
                                }
                                if (overallEducations.Any())
                                {
                                    (overallEducations, unmatchItemScoreType) = FillSemesterData(studentId, $"{subjectId}", overallEducations, unmatchItemScoreType, updateDatas, period);
                                    foreach (var edu in overallEducations)
                                    {
                                        await client.GetContainer(Constant.TEAMModelOS, Constant.Student).ReplaceItemAsync(edu, edu.id, new PartitionKey(edu.code));
                                        string key = $"OverallEducation:{edu.schoolCode}:{edu.periodId}:{edu.year}:{edu.semesterId}:{edu.classId}";
                                        await _azureRedis.GetRedisClient(8).HashSetAsync(key, edu.studentId, edu.ToJsonString());
                                        await _azureRedis.GetRedisClient(8).KeyExpireAsync(key, new TimeSpan(180 * 24, 0, 0));
                                    }
                                }
                            }
                        }
                    }
                }
                return responseData = new() { data = new { unmatchStuInfo, unmatchSemester, unmatchItemScoreType, upsertDatas }, code = RespondCode.Ok, msg = "成功" };
            }
            catch (CosmosException cex) when (cex.Status == 404)
            {
                return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "学校编码不存在" };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/UpsertStudentPortrait() ,参数json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务端异常" };
            }
        }
        public static (List<OverallEducation> overallEducations, List<PortraitStudent> unmatchItemScoreType) FillSemesterData(string studentId, string subjectId, List<OverallEducation> overallEducations,List<PortraitStudent> unmatchItemScoreType, List<SemesterData> semestersDatas,Period period)
        {
            foreach (var z in semestersDatas)  
            {
                var oedu = overallEducations.Find(x => x.id.Equals($"{z.year}-{z.semesterId}-{studentId}"));
                if (oedu != null)
                {
                    List<EducationScore> educationScores = null;
                    switch (true)
                    {
                        case bool when $"{subjectId}".Equals("subject_sport"):
                            educationScores = oedu.sports;
                            break;
                        case bool when $"{subjectId}".Equals("subject_virtue"):
                            educationScores = oedu.virtue;
                            break;
                        case bool when $"{subjectId}".Equals("subject_labour"):
                            educationScores = oedu.labour;
                            break;
                        case bool when $"{subjectId}".Equals("subject_intelligence"):
                            {
                                educationScores = oedu.intelligence;
                                //对评测需要验证 细项的具体信息
                                bool isunmatch = false;
                                foreach (var v in z.itemScore)
                                {
                                    var subject = period.subjects.Find(b => b.id.Equals(v.type));
                                    if (subject == null)
                                    {
                                        isunmatch = true;
                                    }
                                }
                                if (isunmatch)
                                {
                                    unmatchItemScoreType.Add(new PortraitStudent { classId = oedu.classId, name = oedu.name, studentId = oedu.studentId, semesterData = new List<SemesterData> { z } });
                                    continue;
                                }
                                break;
                            }
                        case bool when $"{subjectId}".Equals("subject_art"):
                            {
                                educationScores = oedu.art;
                                //对艺术评测需要验证 细项的具体信息
                                bool isunmatch = false;
                                foreach (var v in z.itemScore)
                                {
                                    var subject = period.subjects.Find(b =>!string .IsNullOrWhiteSpace(b.bindId) && b.bindId.Equals(v.type));
                                    if (subject == null)
                                    {
                                        isunmatch = true;
                                    }
                                }
                                if (isunmatch)
                                {
                                    unmatchItemScoreType.Add(new PortraitStudent { classId = oedu.classId, name = oedu.name, studentId = oedu.studentId, semesterData = new List<SemesterData> { z } });
                                    continue;
                                }
                                break;
                            }
                        default:
                            educationScores = new List<EducationScore>();
                            break;
                    }
                    var edu = educationScores.Find(m => m.examId.Equals(z.examId));
                    z.totalScore = z.totalScore <= 0 ? 100 : z.totalScore;
                    if (edu == null)
                    {
                        edu = new EducationScore();
                        educationScores.Add(edu);
                    }
                    edu.examId = z.examId;
                    edu.examDate = z.examDate;
                    edu.examName = z.examName;
                    edu.examType = z.examType;
                    edu.excellenceRate = z.excellenceRate;
                    edu.totalScore = z.totalScore;
                    edu.rate = z.sumScore / z.totalScore;
                    edu.level = z.sumScore / z.totalScore;
                    edu.sumScore = z.sumScore;
                    edu.passRate = z.passRate;
                    edu.itemScore = z.itemScore;
                }
            }
            return (overallEducations, unmatchItemScoreType);
        }
        public static void GenApiTableRecord(AzureStorageFactory azureStorage)
        {

            //在开发模式时，自检 [ApiToken(Auth = "1")] 有重复的接口 https://teammodelos.table.core.chinacloudapi.cn/IESOpenApi
            (List<OpenApi> openApis, List<ApiTokenAttribute> attributes) = ReflectorExtensions.GetOpenApi(new string[] { "TEAMModelOS" });
            openApis.GroupBy(x => $"{x.PartitionKey}{x.RowKey}").ToList().ForEach(x =>
            {
                if (x.Count() > 1)
                {
                    throw new Exception($"接口Auth重复定义{x.ToList()}");
                }
            });

            var table = azureStorage.GetCloudTableClient().GetTableReference("IESOpenApi");
            openApis = openApis.OrderBy(x => x.RowKey).ToList();
            string tbqurey = $"PartitionKey {QueryComparisons.Equal} 'IES5-API' and RowKey {QueryComparisons.GreaterThanOrEqual} '{openApis.First().RowKey}' and  RowKey {QueryComparisons.LessThanOrEqual} '{openApis.Last().RowKey}'  ";
            var apiResult = table.ExecuteQuerySegmented(new TableQuery<OpenApi>().Where(tbqurey), null);
            List<OpenApi> apis = apiResult.Results;
            //数据库历史数据处理
            apis.ForEach(x =>
            {
                var api = openApis.Find(z => z.RowKey.Equals(x.RowKey));
                if (api != null)
                {
                    x.auth = api.auth;
                    x.name = api.name;
                    x.type = api.type;
                    x.url = api.url;
                    x.method = api.method;
                }
            });
            openApis.RemoveAll(x => apis.Select(z => z.RowKey).Contains(x.RowKey));
            openApis.AddRange(apis);
            _ = table.SaveOrUpdateAll<OpenApi>(openApis);
            string dataopenApis = openApis.ToJsonString();
            (List<WebHook> webHooks, List<ApiTokenAttribute> _attributes) = ReflectorExtensions.GetWebHook(new string[] { "TEAMModelOS.SDK" });

            webHooks.GroupBy(x => $"{x.PartitionKey}{x.RowKey}").ToList().ForEach(x =>
            {
                if (x.Count() > 1)
                {
                    throw new Exception($"接口Auth重复定义{x.ToList()}");
                }
            });
            webHooks = webHooks.OrderBy(x => x.RowKey).ToList();
            tbqurey = $"PartitionKey {QueryComparisons.Equal} 'IES5-WEBHOOK' and RowKey {QueryComparisons.GreaterThanOrEqual} '{webHooks.First().RowKey}' and  RowKey {QueryComparisons.LessThanOrEqual} '{webHooks.Last().RowKey}'  ";
            var hookResult = table.ExecuteQuerySegmented(new TableQuery<WebHook>().Where(tbqurey), null);
            List<WebHook> hooks = hookResult.Results;
            //数据库历史数据处理
            hooks.ForEach(x =>
            {
                var api = webHooks.Find(z => z.RowKey.Equals(x.RowKey));
                if (api != null)
                {
                    x.auth = api.auth;
                    x.name = api.name;
                    x.ename = api.ename;
                    x.tname = api.tname;
                    x.type = api.type;
                    x.url = api.url;
                    x.method = api.method;
                    x.notice = api.notice;
                }
            });
            webHooks.RemoveAll(x => hooks.Select(z => z.RowKey).Contains(x.RowKey));
            webHooks.AddRange(hooks);
            _ = table.SaveOrUpdateAll<WebHook>(webHooks);
            string datawebHooks = webHooks.ToJsonString();
        }

        /// <summary>
        /// 学生登录信息
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetLoginStuInfo(AzureCosmosFactory _azureCosmos, DingDing _dingDing, Option _option, string bizId, string school, JsonElement json)
        {
            if (!json.TryGetProperty("idToken", out JsonElement _idToken)) return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "idToken参数错误", data = null };
            JwtSecurityToken jwt = new($"{_idToken}");
            var iss = jwt.Payload.Iss;
            var stuId = jwt.Payload.Sub;
            var scId = jwt.Payload.Azp;
            try
            {
                var client = _azureCosmos.GetCosmosClient();

                //if (!string.IsNullOrWhiteSpace($"{_idToken}") && JwtAuthExtension.ValidateApiToken($"{_idToken}", _option.JwtSecretKey))
                //{
                //    JwtSecurityToken jwt = new($"{_idToken}");
                //}
                OStudent student = new();
                jwt.Payload.TryGetValue("name", out object stuName);
                jwt.Payload.TryGetValue("picture", out object stuPicture);
                if (!jwt.Payload.TryGetValue("scope", out object scope)) return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "参数错误：scope", data = null };
                if (!jwt.Payload.TryGetValue("roles", out object _roles)) return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "参数错误：roles", data = null };
                jwt.Payload.TryGetValue("permissions", out object permissions);
                jwt.Payload.TryGetValue("standard", out object standard);
                jwt.Payload.TryGetValue("area", out object area);
                jwt.Payload.TryGetValue("website", out object website);

                List<string> roles = $"{_roles}".ToObject<List<string>>();
                if (roles.Contains("student") && $"{scope}".Equals("student"))
                {
                    if (!string.IsNullOrEmpty(stuId) && !string.IsNullOrEmpty(scId))
                    {
                        if (school.Equals(scId))
                        {
                            var responseStu = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Student").ReadItemStreamAsync(stuId, new PartitionKey($"Base-{scId}"));
                            if (responseStu.Status == 200)
                            {
                                JsonDocument jsonD = JsonDocument.Parse(responseStu.Content);
                                student = jsonD.RootElement.ToObject<OStudent>();
                                switch (student.gender)
                                {
                                    case "M":
                                        student.gender = "男";
                                        break;
                                    case "F":
                                        student.gender = "女";
                                        break;
                                    case "N":
                                        student.gender = "保密";
                                        break;
                                }
                            }
                            else
                            { return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "未找到该学生", data = new { id = stuId, schoolId = scId } }; }
                        }
                        else
                        { return new ResponseData<dynamic>() { code = RespondCode.NotFound, msg = "headers和idToken中的学校ID不匹配", data = null }; }
                    }
                    else
                    { return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "参数错误：Sub/scId", data = null }; }
                }
                else
                { return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "参数错误：roles/Azp", data = null }; }


                return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = student };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetLoginStuInfo()   参数：stu:{stuId},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务器错误" };
            }
        }

        /// <summary>
        /// 获取学生详细信息
        /// </summary>
        /// <param name="_azureCosmos"></param>
        /// <param name="_dingDing"></param>
        /// <param name="bizId"></param>
        /// <param name="school"></param>
        /// <param name="json"></param>
        /// <returns></returns>
        public static async Task<ResponseData<dynamic>> GetStudentInfo(AzureCosmosFactory _azureCosmos, DingDing _dingDing, string bizId, string school, JsonElement json)
        {

            if (!json.TryGetProperty("ids", out JsonElement _ids)) return new ResponseData<dynamic>() { code = RespondCode.ParamsError, msg = "idToken参数错误", data = null };
            try
            {
                List<string> ids = _ids.ToObject<List<string>>();
                List<OStudent> student = new();
                //List<OStudent> tmdId = new();

                string sqlStu = $"select value(c) from c ";
                if (ids.Count > 0)
                    sqlStu = $"select value(c) from c  where c.id in ({string.Join(",", ids.Select(s => $"'{s}'"))})";
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Student").GetItemQueryIterator<OStudent>(queryText: sqlStu, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base-{school}") }))
                {
                    student.Add(item);
                }
                //string sqlTmd = $"select value(c) from c join s in c.schools where c.id in ({string.Join(",", ids.Select(s => $"'{s}'"))}) and s.schoolId='{school}'";
                //await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Student").GetItemQueryIterator<OStudent>(queryText: sqlTmd, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base") }))
                //{
                //    tmdId.Add(item);
                //}

                return new ResponseData<dynamic>() { code = RespondCode.Ok, msg = "成功", data = student };
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OpenApi，{Environment.GetEnvironmentVariable("Option:Location")} OpenApiService/GetLoginStuInfo()   参数：学生id集合:{_ids},school:{school},json:{json.ToJsonString()} \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return new ResponseData<dynamic>() { code = RespondCode.Error, msg = "服务器错误" };
            }
        }
    }
    public class OCourseBase
    {
        public string tmdname { get; set; }
        public string courseName { get; set; }
        public int attendCount { get; set; }
        public int mCount { get; set; }
        public List<string> groups { get; set; }
        public long time { get; set; }
        public List<Events> eves { get; set; }
        public List<Videos> videos { get; set; }
    }
    public class Events
    {
        public string @event { get; set; }
        public int freq { get; set; }
        public long createTime { get; set; }
    }
    public class Videos
    {
        public string videoName { get; set; }
        public string video { get; set; }
        public int duration { get; set; }
        public long startTime { get; set; }
    }
}