TEAMModelOS/TEAMModelBI/Controllers/BISchool/SchoolController.cs

using Azure.Cosmos;
using HTEXLib.COMM.Helpers;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Options;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelBI.Filter;
using TEAMModelBI.Tool;
using TEAMModelBI.Tool.CosmosBank;
using TEAMModelBI.Tool.Extension;
using TEAMModelOS.Models;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Models.Cosmos.BI;
using TEAMModelOS.SDK.Models.Service;

namespace TEAMModelBI.Controllers.BISchool
{
    [Route("schoolcheck")]
    [ApiController]
    public class SchoolController : ControllerBase
    {
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly IConfiguration _configuration;
        private readonly NotificationService _notificationService;
        private readonly CoreAPIHttpService _coreAPIHttpService;

        public SchoolController(AzureCosmosFactory azureCosmos, DingDing dingDing, AzureStorageFactory azureStorage, IOptionsSnapshot<Option> option, AzureRedisFactory azureRedis, IConfiguration configuration, NotificationService notificationService, CoreAPIHttpService coreAPIHttpService)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _azureStorage = azureStorage;
            _option = option?.Value;
            _azureRedis = azureRedis;
            _configuration = configuration;
            _notificationService = notificationService;
            _coreAPIHttpService = coreAPIHttpService;
        }

        /// <summary>
        /// 查询未加入区域的学校
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-notarea")]
        public async Task<IActionResult> GetNotAreaSchool(JsonElement jsonElement)
        {
            try
            {
                jsonElement.TryGetProperty("areaId", out JsonElement areaId);
                var cosmosClient = _azureCosmos.GetCosmosClient();
                //默认不指定返回大小
                int? pageSize = null;
                string continuationToken = string.Empty;
                string pageToken = default;
                if (jsonElement.TryGetProperty("pageSize", out JsonElement jsonPageSize))
                {
                    if (!jsonPageSize.ValueKind.Equals(JsonValueKind.Undefined) && !jsonPageSize.ValueKind.Equals(JsonValueKind.Null) && jsonPageSize.TryGetInt32(out int tempPageSize))
                    {
                        pageSize = tempPageSize;
                    }
                }
                //是否需要进行分页查询，默认不分页
                bool iscontinuation = false;
                if (pageSize != null && pageSize.Value > 0)
                {
                    iscontinuation = true;
                }
                if (jsonElement.TryGetProperty("contToken", out JsonElement ContToken))
                {
                    pageToken = ContToken.GetString();
                }

                string sqltxt = "SELECT c.id,c.name,c.schoolCode,c.province,c.city,c.dist,c.picture,c.period,c.areaId,c.standard,c.manyAreas FROM c WHERE c.areaId !='{areaId}'";
                List<NotAreaSchool> tempNotAreaSchools = new();
                await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: sqltxt, continuationToken: pageToken, requestOptions: new QueryRequestOptions() { MaxItemCount = pageSize, PartitionKey = new PartitionKey("Base") }))
                {
                    using var json = await JsonDocument.ParseAsync(item.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            //List<string> temp0 = obj.GetProperty("period").ToObject<List<Period>>().Select(x=>x.name).ToList();
                            NotAreaSchool notAreaSchool = new NotAreaSchool()
                            {
                                id = obj.GetProperty("id").GetString(),
                                name = obj.GetProperty("name").GetString(),
                                schoolCode = obj.GetProperty("schoolCode").GetString(),
                                picture = obj.GetProperty("picture").GetString(),
                                period = obj.GetProperty("period").ToObject<List<Period>>().Select(x => x.name).ToList(),
                                province = obj.GetProperty("province").GetString(),
                                city = obj.GetProperty("city").GetString(),
                                dist = obj.GetProperty("dist").GetString(),
                                areaId = obj.GetProperty("areaId").GetString(),
                                standard = obj.GetProperty("standard").GetString()
                            };
                            try
                            {
                                notAreaSchool.manyAreas = obj.GetProperty("manyAreas").ToObject<List<ManyArea>>();
                            }
                            catch { }
                            tempNotAreaSchools.Add(notAreaSchool);
                        }

                        if (iscontinuation)
                        {
                            continuationToken = item.GetContinuationToken();
                            break;
                        }
                    }
                }
                List<NotAreaSchool> notAreaSchools = new List<NotAreaSchool>();
                tempNotAreaSchools.ForEach(nas =>
                {
                    if (nas.manyAreas == null)
                        notAreaSchools.Add(nas);
                    else
                    {
                        var not = nas.manyAreas.Find(f => f.areaId == $"{areaId}");
                        if (not == null)
                            notAreaSchools.Add(nas);
                    }
                });

                //if (!string.IsNullOrEmpty($"{areaId}"))                    
                //    notAreaSchools = notAreaSchools.Select(na => new NotAreaSchool { id = na.id, name = na.name, schoolCode = na.schoolCode, picture = na.picture, period = na.period, province = na.province, city = na.city = na.city, dist = na.dist,  manyAreas =  new List<ManyArea> { na.manyAreas.Find(m => m.areaId != $"{areaId}") } }).ToList();

                return Ok(new { state = 200, continuationToken,cont= notAreaSchools.Count, notAreaSchools });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI，{_option.Location}  /schoolcheck/get-notarea   \n    {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 学校加入区
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin,rdc,assist")]
        [HttpPost("set-schooljoinarea")]
        public async Task<IActionResult> SetSchoolJoinArea(JsonElement jsonElement)
        {
            try
            {
                if (!jsonElement.TryGetProperty("standard", out JsonElement standard)) return BadRequest();
                if (!jsonElement.TryGetProperty("schoolCode", out JsonElement _schoolCode)) return BadRequest();
                if (!jsonElement.TryGetProperty("areaId", out JsonElement _areaId)) return BadRequest();
                jsonElement.TryGetProperty("isDefault", out JsonElement isDefault);

                var (_tmdId, _tmdName, pic, did, dname, dpic) = HttpJwtAnalysis.JwtXAuthBI(HttpContext.GetXAuth("AuthToken"), _option);

                List<string> schoolCodes = _schoolCode.ToObject<List<string>>();

                var cosmosCliet = _azureCosmos.GetCosmosClient();

                if (schoolCodes.Count > 0)
                {
                    foreach (var tempCode in schoolCodes)
                    {
                        School school = await cosmosCliet.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(tempCode, new PartitionKey("Base"));
                        if (school != null)
                        {
                            if (bool.Parse($"{isDefault}") == true)
                            {
                                school.standard = $"{standard}";
                                school.areaId = $"{_areaId}";
                            }

                            if (school.manyAreas == null) 
                            {
                                //ManyArea manyArea = new ManyArea() { areaId = $"{_areaId}", standard = $"{standard}" };
                                school.manyAreas = new List<ManyArea>() { new ManyArea() { areaId = $"{_areaId}", standard = $"{standard}" } };
                            }
                            else
                            {
                                var marea = school.manyAreas.Find(ma => ma.areaId == $"{_areaId}" && ma.standard == $"{standard}");
                                if (marea == null)
                                    school.manyAreas.Add(new ManyArea() { areaId = $"{_areaId}", standard = $"{standard}" });
                            }
                            await cosmosCliet.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, school.id, new PartitionKey(school.code));
                        }
                    }
                }

                //保存操作记录
                await _azureStorage.SaveBILog("school-update", $"{_tmdName}【{_tmdId}】操作学校加入区域功能，加入的区域：{standard},学校ID：{string.Join("|", schoolCodes.ToArray())}", _dingDing, httpContext: HttpContext);

                return Ok(new { state = 200 });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI，{_option.Location}  /schoolcheck/set-schooljoinarea   \n    {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 依据醍摩豆账户查询顾问管理学校的基础信息
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-assistschool")]
        public async Task<IActionResult> GetAssistSchool(JsonElement jsonElement)
        {
            try
            {
                if (!jsonElement.TryGetProperty("tmdId", out JsonElement tmdId)) return BadRequest();

                List<object> schools = new List<object>();
                var cosmosClient = _azureCosmos.GetCosmosClient();
                //List<string> schoolIds = new List<string>();
                //string sqlTxt = $"SELECT DISTINCT REPLACE(c.code, 'Teacher-', '') AS schoolId FROM c WHERE c.pk = 'Teacher' AND c.status = 'join' AND ARRAY_CONTAINS(c.roles, 'assist', true) AND c.id='{tmdId}' ";
                //await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: sqlTxt, requestOptions: new QueryRequestOptions() { }))
                //{
                //    using var json = await JsonDocument.ParseAsync(item.ContentStream);
                //    foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                //    {
                //        schoolIds.Add(obj.GetProperty("schoolId").GetString());
                //    }
                //}

                List<string> schoolIds = await CommonFind.FindSchoolIds(cosmosClient, $"{tmdId}");

                foreach (var item in schoolIds)
                {
                    await foreach (var itemBase in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: $"select c.id,c.code,c.name,c.picture,c.region,c.province,c.city,c.dist from c where c.id='{item}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") }))
                    {
                        var json = await JsonDocument.ParseAsync(itemBase.ContentStream);
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            schools.Add(obj.ToObject<object>());
                        }
                    }
                }

                return Ok(new { state = 200, schools });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI，{_option.Location}   /schoolcheck/get-assustschool  \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 依据学校编号查询学校信息
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-schoolid")]
        public async Task<IActionResult> GetSchoolId(JsonElement jsonElement)
        {
            try
            {
                if (!jsonElement.TryGetProperty("schoolId", out JsonElement schoolId)) return BadRequest();

                var cosmosClient = _azureCosmos.GetCosmosClient();

                var rsponse = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemStreamAsync($"{schoolId}", new PartitionKey("Base"));
                if (rsponse.Status == 200)
                {
                    using var json = await JsonDocument.ParseAsync(rsponse.ContentStream);
                    School school = json.ToObject<School>();

                    return Ok(new { state = 200, school });
                }
                else
                    return Ok(new { state = 404, msg = $"未找到ID是({schoolId})的学校" });

            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI，{_option.Location}   /schoolcheck/get-schoolid  \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 修改学校信息
        /// </summary>
        /// <param name="school"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin,rdc,assist")]
        [HttpPost("upd-school")]
        public async Task<IActionResult> UpdSchool(School school)
        {
            try
            {
                School schoolInfo = new School();
                var cosmosClient = _azureCosmos.GetCosmosClient();
                string _auth = HttpContext.GetXAuth("AuthToken");
                //var (tmdId, tmdName) = HttpJwtAnalysis.JwtXAuth(_auth, _option);
                var (tmdId, tmdName, pic, did, dname, dpic) = HttpJwtAnalysis.JwtXAuthBI(_auth, _option);
                var response = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemStreamAsync(school.id, new PartitionKey($"Base"));
                if (response.Status == 200)
                {
                    string sql = $"SELECT distinct value(c) FROM c join A1 in c.schools where A1.schoolId='{school.id}'";
                    List<Teacher> teachers = new List<Teacher>();
                    await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "Teacher").GetItemQueryIterator<Teacher>(sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey("Base") }))
                    {
                        teachers.Add(item);
                    }
                    foreach (var item in teachers)
                    {
                        Teacher.TeacherSchool teacherSchool = item.schools.Find(x => x.schoolId.Equals(school.id));
                        if (teacherSchool != null)
                        {
                            teacherSchool.name = school.name;
                            teacherSchool.picture = school.picture;
                            teacherSchool.areaId = school.areaId;
                        }
                        await cosmosClient.GetContainer("TEAMModelOS", "Teacher").ReplaceItemAsync(item, item.id, new PartitionKey($"Base"));
                    }
                    schoolInfo = await cosmosClient.GetContainer("TEAMModelOS", "School").ReplaceItemAsync<School>(school, school.id, new PartitionKey($"Base"));

                    //保存操作记录
                    await _azureStorage.SaveBILog("school-update", $"{tmdName}【{tmdId}】修改学校信息，学校和ID:{school.name}【{school.id}】", _dingDing, httpContext: HttpContext);
                }
                else return Ok(new { state = 400, message = "请求错误！" });

                return Ok(new { state = 200, schoolInfo });

                //School tempShool = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(replaceSchool.school.id, new PartitionKey("Base"));
                //if (tempShool != null)
                //{
                //    List<Teacher> teachers = new List<Teacher>();
                //    string sqltxt = $"select distinct value(c) from c join a1 in c.schools where a1.schoolId='{replaceSchool.school.id}'";
                //    await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Teacher").GetItemQueryIterator<Teacher>(queryText: sqltxt, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") }))
                //    {
                //        teachers.Add(item);
                //    }

                //    foreach (var item in teachers)
                //    {
                //        Teacher.TeacherSchool teacherSchool = item.schools.Find(x => x.schoolId.Equals(replaceSchool.school.id));
                //        if (teacherSchool != null)
                //        {
                //            teacherSchool.name = replaceSchool.school.name;
                //            teacherSchool.picture = replaceSchool.school.picture;
                //            teacherSchool.areaId = replaceSchool.school.areaId;
                //        }
                //        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync(item, item.id, new PartitionKey("Base"));
                //    }

                //    schoolInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(replaceSchool.school, replaceSchool.school.id, new PartitionKey("Base"));

                //    //保存操作记录
                //    await _azureStorage.SaveBILog("school-update", $"{replaceSchool.tmdName}【{replaceSchool.tmdId}】修改学校信息，学校和ID:{replaceSchool.school.name}【{replaceSchool.school.id}】", _dingDing, httpContext: HttpContext);

                //    return Ok(new { state = 200, schoolInfo });
                //}
                //else return Ok(new { state = 400, message = "请求错误！" });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location}  /batchschool/upd-school \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 顾问学校空间使用情况
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-assistspace")]
        public async Task<IActionResult> GetAssistSchoolSpace(JsonElement jsonElement)
        {
            if (!jsonElement.TryGetProperty("tmdId", out JsonElement tmdId)) return BadRequest();
            var cosmosClient = _azureCosmos.GetCosmosClient();

            List<string> schools = await CommonFind.FindSchoolIds(cosmosClient, $"{tmdId}");
            List<SchoolSpace> schoolSpaces = new();
            foreach (var sid in schools)
            {
                School school = new();
                var response = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemStreamAsync(sid, new PartitionKey("Base"));
                if (response.Status == 200)
                {
                    using var json = await JsonDocument.ParseAsync(response.ContentStream);
                    school = json.ToObject<School>();
                }

                long teach = 0;
                await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: $"SELECT sum(c.size) as size FROM c ", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Teacher-{sid}") }))
                {
                    var json = await JsonDocument.ParseAsync(item.ContentStream);
                    foreach (var elmt in json.RootElement.GetProperty("Documents").EnumerateArray())
                    {
                        if (elmt.TryGetProperty("size", out JsonElement _size) && _size.ValueKind.Equals(JsonValueKind.Number))
                        {
                            teach = _size.GetInt32();
                            break;
                        }
                    }
                }

                SchoolSpace schoolSpace = new() { id = sid, name = school != null ? school.name : sid };

                Space space = new Space();
                long blobsize = 0; //使用大小                
                RedisValue value = default;
                value = _azureRedis.GetRedisClient(8).HashGet($"Blob:Record", sid);

                if (value != default && !value.IsNullOrEmpty)
                {
                    JsonElement record = value.ToString().ToObject<JsonElement>();
                    if (record.TryGetInt64(out blobsize))
                    {
                    }
                }
                else
                {
                    var client = _azureStorage.GetBlobContainerClient(sid);
                    var size = await client.GetBlobsCatalogSize();
                    await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", sid, size.Item1);
                    foreach (var key in size.Item2.Keys)
                    {
                        await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Blob:Catalog:{sid}", key);
                        await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Blob:Catalog:{sid}", key, size.Item2[key].HasValue ? size.Item2[key].Value : 0);
                    }
                    space.useSize = (long)size.Item1; space.tSize = teach; space.catalogSize = size.Item2;
                    schoolSpace.space = space;
                    schoolSpaces.Add(schoolSpace);
                    continue;
                }

                Dictionary<string, double?> catalog = new Dictionary<string, double?>();
                SortedSetEntry[] Scores = _azureRedis.GetRedisClient(8).SortedSetRangeByScoreWithScores($"Blob:Catalog:{sid}");
                if (Scores != null)
                {
                    foreach (var score in Scores)
                    {
                        double val = score.Score;
                        string key = score.Element.ToString();
                        catalog.Add(key, val);
                    }

                    space.useSize = blobsize; space.tSize = teach; space.catalogSize = catalog;

                    schoolSpace.space = space;
                    schoolSpaces.Add(schoolSpace);
                    continue;
                }
                else
                {
                    var client = _azureStorage.GetBlobContainerClient(sid);
                    var size = await client.GetBlobsCatalogSize();
                    await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", sid, size.Item1);
                    foreach (var key in size.Item2.Keys)
                    {
                        await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Blob:Catalog:{sid}", key);
                        await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Blob:Catalog:{sid}", key, size.Item2[key].HasValue ? size.Item2[key].Value : 0);
                    }

                    space.useSize = (long)size.Item1;
                    space.tSize = teach;
                    space.catalogSize = size.Item2;
                    schoolSpace.space = space;
                    schoolSpaces.Add(schoolSpace);
                    continue;
                }
            }

            return Ok(new { state = 200, schoolSpaces });
        }

        /// <summary>
        /// 移交学校顾问
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-shift")]
        public async Task<IActionResult> GetShift(JsonElement jsonElement)
        {
            var (_tmdId, _tmdName, pic, did, dname, dpic) = HttpJwtAnalysis.JwtXAuthBI(HttpContext.GetXAuth("AuthToken"), _option);
            if (!jsonElement.TryGetProperty("school", out JsonElement _school)) return BadRequest();
            //if (!jsonElement.TryGetProperty("teacher", out JsonElement _teacher)) return BadRequest();
            if (!jsonElement.TryGetProperty("shiftTeacher", out JsonElement _shiftTeacher)) return BadRequest();

            var cosmosClient = _azureCosmos.GetCosmosClient();
            SchoolTeacher schoolTeacher = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemAsync<SchoolTeacher>($"{_tmdId}", new PartitionKey($"Teacher-{_school}"));
            if (schoolTeacher.roles.IsNotEmpty() && schoolTeacher.roles.Contains("assist"))
            {
                schoolTeacher.roles.Remove("assist");
                SchoolTeacher newSchoolTeacher = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemAsync<SchoolTeacher>($"{_shiftTeacher}", new PartitionKey($"Teacher-{_school}"));
                if (!newSchoolTeacher.roles.Contains("assist"))
                {
                    newSchoolTeacher.roles.Add("assist");
                    newSchoolTeacher = await cosmosClient.GetContainer("TEAMModelOS", "School").ReplaceItemAsync<SchoolTeacher>(newSchoolTeacher, $"{_shiftTeacher}", new PartitionKey($"Teacher-{_school}"));
                }

                await cosmosClient.GetContainer("TEAMModelOS", "School").ReplaceItemAsync<SchoolTeacher>(schoolTeacher, $"{_tmdId}", new PartitionKey($"Teacher-{_school}"));

                School schoolBase = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemAsync<School>($"{_school}", new PartitionKey($"Base"));

                //发送消息实体
                string shiftCode = "shift-assist";
                Notification notification = new Notification
                {
                    hubName = "hita",
                    type = "msg",
                    from = $"BI:{_option.Location}:{_school}",
                    to = new List<string> { $"{_shiftTeacher}" },
                    label = $"{shiftCode}_school",
                    body = new { location = _option.Location, biz = shiftCode, tmdid = $"{_tmdId}", tmdname = $"{_tmdName}", status = 1, time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() }.ToJsonString(),
                    expires = DateTimeOffset.UtcNow.AddDays(7).ToUnixTimeSeconds()
                };

                if (notification != null)
                {
                    var url = _configuration.GetValue<string>("HaBookAuth:CoreService:sendnotification");
                    var clientID = _configuration.GetValue<string>("HaBookAuth:CoreService:clientID");
                    var clientSecret = _configuration.GetValue<string>("HaBookAuth:CoreService:clientSecret");
                    var location = _option.Location;
                    await _notificationService.SendNotification(clientID, clientSecret, location, url, notification);//站内发送消息
                }

                //保存操作记录
                await _azureStorage.SaveBILog("schoolTeacher-add", $"{_tmdName}【{_tmdId}】移交顾问给{newSchoolTeacher.name}【{newSchoolTeacher.id}】", _dingDing, httpContext: HttpContext);
                return Ok(new { state = 200 });
            }
            else { return Ok(new { status = 201, msg = $"{_tmdName}【{_tmdId}】账号不是顾问" }); }
        }

        /// <summary>
        /// 修改顾问学校
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin,assist")]
        [HttpPost("set-aistschool")]
        public async Task<IActionResult> SetAssistSchool(JsonElement jsonElement)
        {
            try
            {
                if (!jsonElement.TryGetProperty("partitionKey", out JsonElement parKey)) return BadRequest();
                jsonElement.TryGetProperty("userId", out JsonElement userId);
                jsonElement.TryGetProperty("tmdId", out JsonElement tmdId);
                if (!jsonElement.TryGetProperty("schoolIds", out JsonElement jsSchoolIds)) return BadRequest();
                if (!jsonElement.TryGetProperty("busy", out JsonElement busy)) return BadRequest();

                List<string> schoolIds = jsSchoolIds.ToObject<List<string>>();
                var table = _azureStorage.GetCloudTableClient().GetTableReference("BIDDUserInfo");
                var cosmosClient = _azureCosmos.GetCosmosClient();
                string divide = _option.Location;

                Dictionary<string, object> dic = new() { { "PartitionKey", $"{parKey}" } };
                if (!string.IsNullOrEmpty($"{userId}"))
                {
                    dic.Add("userId", $"{userId}");
                }
                if (string.IsNullOrEmpty($"{userId}") && string.IsNullOrEmpty($"{tmdId}"))
                {
                    return Ok(new { state = 400, msg = "钉钉账户或醍摩豆账户需要至少要传一个！" });
                }

                Dictionary<string, List<string>> noSchools = new();
                List<DingDingUserInfo> ddUserInfoList = await table.FindListByDict<DingDingUserInfo>(dic);
                List<DingDingUserInfo> updUsers = new();

                if (ddUserInfoList.Count > 0)
                {
                    foreach (var ddInfo in ddUserInfoList)
                    {
                        if (schoolIds.Count > 0)
                        {
                            if (string.IsNullOrEmpty(ddInfo.tmdId))
                            {
                                List<string> moblie = new() { $"{ddInfo.mobile}" };

                                var content = new StringContent(moblie.ToJsonString(), Encoding.UTF8, "application/json");
                                string json = await _coreAPIHttpService.GetUserInfos(content);
                                if (!string.IsNullOrEmpty(json))
                                {
                                    List<JsonElement> json_id = json.ToObject<List<JsonElement>>();
                                    foreach (var tmd in json_id)
                                    {
                                        ddInfo.tmdId = tmd.GetProperty("id").ToString();
                                        ddInfo.tmdName = tmd.GetProperty("name").ToString();
                                        ddInfo.tmdMobile = tmd.GetProperty("mobile").ToString();
                                        ddInfo.picture = tmd.GetProperty("picture").ToString();
                                        ddInfo.mail = tmd.GetProperty("mail").ToString();
                                    }
                                }
                                else return Ok(new { state = 404, msg = "依据钉钉手机号未找到醍摩豆账号！" });
                            }
                            List<string> noSchool = await SchoolWay.SchoolAdviser(cosmosClient, ddInfo, schoolIds, $"{busy}");
                            if (noSchool.Count > 0)
                            {
                                noSchools.Add(ddInfo.tmdId, noSchool);
                            }
                        }
                        List<string> userSchoolAdv = new(ddInfo.schoolIds.Split("|", StringSplitOptions.RemoveEmptyEntries));
                        if ($"{busy}".Equals("add"))
                        {
                            userSchoolAdv.AddRange(schoolIds);
                            ddInfo.schoolIds = userSchoolAdv.Count > 0 ? string.Join("|", userSchoolAdv) : "";
                        }

                        if ($"{busy}".Equals("del"))
                        {
                            var temp = userSchoolAdv.Where(p => !schoolIds.Any(x => x == p)).ToList();
                            ddInfo.schoolIds = temp.Count > 0 ? string.Join("|", temp) : "";
                        }
                        updUsers.Add(ddInfo);
                    }
                }

                updUsers = await table.SaveOrUpdateAll(updUsers);
                if (noSchools.Count > 0)
                    return Ok(new { state = 201, recUsers = updUsers, noSchools });
                else
                    return Ok(new { state = 200, recUsers = updUsers });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location}  /batchschool/set-aistschool \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 依据学校ID查学校管理员信息
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-schoolmanage")]
        public async Task<IActionResult> GetSchoolManage(JsonElement jsonElement)
        {
            if (!jsonElement.TryGetProperty("schoolCode", out JsonElement schoolCode)) return BadRequest();
            if (!jsonElement.TryGetProperty("isAdmin", out JsonElement isAdmin)) return BadRequest();
            var cosmosClient = _azureCosmos.GetCosmosClient();
            List<SchoolTeacher> schoolTeachers = new List<SchoolTeacher>();
            //string sqlTxt = "select value(c) from c where array_contains(c.roles,'admin')";
            string sqlTxt = "select value(c) from c";
            await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryText: sqlTxt, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Teacher-{schoolCode}") }))
            {
                using var json = await JsonDocument.ParseAsync(item.ContentStream);
                if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetInt16() > 0)
                {
                    foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                    {
                        SchoolTeacher schoolTeacher = obj.ToObject<SchoolTeacher>();
                        //schoolTeachers.Add(schoolTeacher);
                        if (bool.Parse($"{isAdmin}") == true)
                        {
                            if (schoolTeacher.roles.Contains("admin"))
                            {
                                schoolTeachers.Add(schoolTeacher);
                            }
                        }
                        else
                        {
                            if (!schoolTeacher.roles.Contains("admin"))
                            {
                                schoolTeachers.Add(schoolTeacher);
                            }
                        }
                    }
                }
            }

            return Ok(new { state = 200, schoolTeachers });
        }

        /// <summary>
        /// 设置学校管理员
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("set-schoolme")]
        public async Task<IActionResult> SetSchoolManage(JsonElement jsonElement)
        {
            try
            {
                var (_tmdId, _tmdName, _, _, _, _) = HttpJwtAnalysis.JwtXAuthBI(HttpContext.GetXAuth("AuthToken"), _option);

                if (!jsonElement.TryGetProperty("manageId", out JsonElement _adminTmdId)) return BadRequest();
                if (!jsonElement.TryGetProperty("manageName", out JsonElement _adminTmdName)) return BadRequest();
                if (!jsonElement.TryGetProperty("schoolId", out JsonElement _schoolId)) return BadRequest();
                var cosmosClient = _azureCosmos.GetCosmosClient();

                var response = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemStreamAsync($"{_adminTmdId}", new PartitionKey($"Teacher-{_schoolId}"));
                if (response.Status == 200)
                {
                    using var json = await JsonDocument.ParseAsync(response.ContentStream);
                    SchoolTeacher schoolTeacher = json.ToObject<SchoolTeacher>();
                    if (!schoolTeacher.roles.Contains("admin"))
                    {
                        schoolTeacher.roles.Add("admin");
                        SchoolTeacher st = await cosmosClient.GetContainer("TEAMModelOS", "School").ReplaceItemAsync<SchoolTeacher>(schoolTeacher, schoolTeacher.id, new PartitionKey(schoolTeacher.code));

                        //保存操作记录
                        await _azureStorage.SaveBILog("schoolTeacher-update", $"{_tmdName}【{_tmdId}】账户把{_adminTmdName}【{_adminTmdId}】设置学校id为{_schoolId}管理员。", _dingDing, httpContext: HttpContext);
                        return Ok(new { state = 200, schoolTeacher = st });
                    }
                    else
                        return Ok(new { state = 201, schoolTeacher = "已经是管理人员" });
                }
                else
                {
                    SchoolTeacher schoolTeacher = new SchoolTeacher
                    {
                        id = $"{_adminTmdId}",
                        code = $"Teacher-{_schoolId}",
                        roles = new List<string> { "admin" },
                        job = "管理员",
                        name = $"{_adminTmdName}",
                        picture = "",
                        status = "join",
                        createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                        pk = "Teacher",
                        ttl = -1
                    };

                    schoolTeacher = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<SchoolTeacher>(schoolTeacher, new PartitionKey(schoolTeacher.code));
                    //保存操作记录
                    await _azureStorage.SaveBILog("schoolTeacher-add", $"{_tmdName}【{_tmdId}】账户创建{_adminTmdName}【{_adminTmdId}】账户，并设学校管理员。学校ID:{_schoolId}。", _dingDing, httpContext: HttpContext);
                    return Ok(new { status = 200, schoolTeacher });
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location}  /batchschool/set-schoolme \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }

        }

        /// <summary>
        /// 删除学校、学校相关的教师、学生
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin,rdc")]
        [HttpPost("set-del")]
        public async Task<IActionResult> DelSchool(JsonElement jsonElement)
        {
            try
            {
                if (!jsonElement.TryGetProperty("schoolId", out JsonElement schoolId)) return BadRequest();
                string _auth = HttpContext.GetXAuth("AuthToken");
                var (tmdId, tmdName, pic, did, dname, dpic) = HttpJwtAnalysis.JwtXAuthBI(_auth, _option);
                var cosmosClient = _azureCosmos.GetCosmosClient();
                StringBuilder msg = new();
                List<DelSchoolRel> delSchoolRels = new();

                List<string> scTchIds = new();
                List<string> scStuIds = new();
                string scTecSql = $"select value(c.id) from c where ARRAY_LENGTH(c.roles) > 0 and c.status = 'join'";
                await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "School").GetItemQueryIterator<string>(queryText: scTecSql, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Teacher-{schoolId}") }))
                {
                    scTchIds.Add(item);
                }

                string scStuSql = $"select value(c.id) from c";
                await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "School").GetItemQueryIterator<string>(queryText: scStuSql, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base-{schoolId}") }))
                {
                    scStuIds.Add(item);
                }

                var response = await cosmosClient.GetContainer("TEAMModelOS", "School").DeleteItemStreamAsync($"{schoolId}", new PartitionKey($"Base"));
                if (response.Status == 204)
                    msg.AppendLine($"{tmdName}【{tmdId}】删除学校，删除状态：{response.Status}，删除ID:{schoolId}");
                else
                    delSchoolRels.Add(new DelSchoolRel() { id = $"{schoolId}", code = "Base", type = 1, status = response.Status });

                foreach (var item in scTchIds)
                {
                    var tchRespnse = await cosmosClient.GetContainer("TEAMModelOS", "School").DeleteItemStreamAsync($"{item}", new PartitionKey($"Teacher-{schoolId}"));
                    if (tchRespnse.Status == 204)
                        msg.AppendLine($"删除教师，删除状态：{tchRespnse.Status}，删除ID:{item}");
                    else
                        delSchoolRels.Add(new DelSchoolRel() { id = $"{item}", code = $"Teacher-{schoolId}", type = 2, status = response.Status });
                }
                
                foreach (var item in scStuIds)
                {
                    var stuRespnse = await cosmosClient.GetContainer("TEAMModelOS", "Student").DeleteItemStreamAsync($"{item}", new PartitionKey($"Base-{schoolId}"));
                    if (stuRespnse.Status == 204)
                        msg.AppendLine($"删除学生，删除状态：{stuRespnse.Status}，删除ID:{item}");
                    else
                        delSchoolRels.Add(new DelSchoolRel() { id = $"{item}", code = $"Base-{schoolId}", type = 3, status = response.Status });
                }

                //保存操作记录
                await _azureStorage.SaveBILog("set-del", msg.ToString(), _dingDing, httpContext: HttpContext);
                if (delSchoolRels.Count > 0)
                    return Ok(new { state = 201, delSchoolRels });
                else
                    return Ok(new { state = 200 });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location}  /batchschool/set-del \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 通过学校Id查询详情   数据管理工具——查询工具
        /// </summary>
        /// <returns></returns>
        [HttpPost("get-info")]
        public async Task<IActionResult> GetSchool(JsonElement jsonElement)
        {
            jsonElement.TryGetProperty("schoolId", out JsonElement schoolId);
            var clientCosmosDB = _azureCosmos.GetCosmosClient();
            StringBuilder sqlTxt = new StringBuilder("select * from c");
            if (!string.IsNullOrEmpty($"{schoolId}"))
            {
                sqlTxt.Append($" where c.id='{schoolId}'");
            }

            List<School> schools = new();

            await foreach (var item in clientCosmosDB.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryText: sqlTxt.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") }))
            {
                using var json = await JsonDocument.ParseAsync(item.ContentStream);
                if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                {
                    foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                    {
                        schools.Add(obj.ToObject<School>());
                    }
                }
            }

            return Ok(new { state = 200, schools });
        }

        /// <summary>
        /// 依据区域Id查询区域空间统计
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-spance")]
        public async Task<IActionResult> GetAreaSpace(JsonElement jsonElement)
        {
            jsonElement.TryGetProperty("areaId", out JsonElement areaId);
            jsonElement.TryGetProperty("schoolId", out JsonElement schoolId);
            var cosmosClient = _azureCosmos.GetCosmosClient();
            long allSize = 0;    //全部大小
            int teacherSpace = 0;  //学校分配给教师的空间
            long useSize = 0;   //已使用大小 
            Dictionary<string, double?> useSpaceInfo = new();  //学校使用详情

            //查询区域所有学校
            if (!string.IsNullOrEmpty($"{areaId}"))
            {
                List<string> schools = new();
                schools = await CommonFind.FindSchoolIds(cosmosClient, $"select c.id from c where c.areaId='{areaId}'", "Base");

                allSize = await CommonFind.FindTotals(cosmosClient, $"select sum(c.size) as totals from c where c.areaId='{areaId}'", new List<string> { "School" }); //区域所有学校空间

                foreach (var school in schools)
                {
                    await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryText: $"SELECT sum(c.size) as size FROM c ", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Teacher-{school}") }))
                    {
                        var json = await JsonDocument.ParseAsync(item.ContentStream);
                        foreach (var elmt in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            if (elmt.TryGetProperty("size", out JsonElement _size) && _size.ValueKind.Equals(JsonValueKind.Number))
                            {
                                teacherSpace += _size.GetInt32();
                                break;
                            }
                        }
                    }

                    long blobsize = 0;
                    RedisValue value = _azureRedis.GetRedisClient(8).HashGet($"Blob:Record", $"{school}");
                    if (!value.IsNullOrEmpty)
                    {
                        JsonElement record = value.ToString().ToObject<JsonElement>();
                        if (record.TryGetInt64(out blobsize))
                        {
                        }
                    }
                    else
                    {
                        var storageClient = _azureStorage.GetBlobContainerClient("school");
                        var size = await storageClient.GetBlobsCatalogSize();
                        await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", $"{school}", size.Item1);
                        foreach (var key in size.Item2.Keys)
                        {
                            await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Bolb:Catalog:{school}", key);
                            await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Bolb:Catalog:school", key, size.Item2[key].HasValue ? size.Item2[key].Value : 0);
                        }

                        useSize += size.Item1.Value;
                        useSpaceInfo = useSpaceInfo.Concat(size.Item2).GroupBy(g => g.Key).ToDictionary(k => k.Key, k => k.Sum(kvp => kvp.Value));   //lamebda表达式
                        //useSpaceInfo = (from e in useSpaceInfo.Concat(size.Item2) group e by e.Key into g select new { Name = g.Key, value = g.Sum(kvp => kvp.Value) }).ToDictionary(item => item.Name, item => item.value);  //linq 方式合并
                    }

                    SortedSetEntry[] Scores = _azureRedis.GetRedisClient(8).SortedSetRangeByScoreWithScores($"Blob:Catalog:{school}");
                    if (Scores != null)
                    {
                        Dictionary<string, double?> catalog = new();
                        foreach (var score in Scores)
                        {
                            double val = score.Score;
                            string key = score.Element.ToString();
                            catalog.Add(key, val);
                        }
                        useSpaceInfo = useSpaceInfo.Concat(catalog).GroupBy(g => g.Key).ToDictionary(k => k.Key, k => k.Sum(kvp => kvp.Value));  //lamebda表达式
                        //useSpaceInfo = (from e in useSpaceInfo.Concat(catalog) group e by e.Key into g select new { Name = g.Key, value = g.Sum(kvp => kvp.Value) }).ToDictionary(item => item.Name, item => item.value);  //linq 方式合并
                    }
                    else
                    {
                        var client = _azureStorage.GetBlobContainerClient("school");
                        var size = await client.GetBlobsCatalogSize();
                        await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", $"{school}", size.Item1);
                        foreach (var key in size.Item2.Keys)
                        {
                            await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Blob:Catalog:{school}", key);
                            await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Blob:Catalog:{school}", key, size.Item2[key].HasValue ? size.Item2[key].Value : 0);
                        }
                        useSize += size.Item1.Value;
                        useSpaceInfo = useSpaceInfo.Concat(size.Item2).GroupBy(g => g.Key).ToDictionary(k => k.Key, k => k.Sum(kvp => kvp.Value));   //lamebda表达式
                        //useSpaceInfo = (from e in useSpaceInfo.Concat(size.Item2) group e by e.Key into g select new { Name = g.Key, value = g.Sum(kvp => kvp.Value) }).ToDictionary(item => item.Name, item => item.value);   //linq 方式合并
                    }
                }
            }

            //查询学校
            if (!string.IsNullOrEmpty($"{schoolId}"))
            {
                allSize = await CommonFind.FindTotals(cosmosClient, $"SELECT c.size as totals FROM c where c.id='{schoolId}'", "School", "Base");

                teacherSpace = await CommonFind.FindTotals(cosmosClient, $"SELECT sum(c.size) as totals FROM c", "School", $"Teacher-{schoolId}");

                long blobsize = 0;
                RedisValue value = _azureRedis.GetRedisClient(8).HashGet($"Blob:Record", $"{schoolId}");
                if (!value.IsNullOrEmpty)
                {
                    JsonElement record = value.ToString().ToObject<JsonElement>();
                    if (record.TryGetInt64(out blobsize))
                    {
                        useSize = blobsize;
                    }
                }
                else
                {
                    var storageClient = _azureStorage.GetBlobContainerClient("school");
                    var size = await storageClient.GetBlobsCatalogSize();
                    await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", $"{schoolId}", size.Item1);
                    foreach (var key in size.Item2.Keys)
                    {
                        await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Bolb:Catalog:{schoolId}", key);
                        await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Bolb:Catalog:school", key, size.Item2[key].HasValue ? size.Item2[key].Value : 0);
                    }
                    useSpaceInfo = size.Item2;
                }

                Dictionary<string, double?> catalog = new();
                SortedSetEntry[] Scores = _azureRedis.GetRedisClient(8).SortedSetRangeByScoreWithScores($"Blob:Catalog:{schoolId}");
                if (Scores != null)
                {
                    foreach (var score in Scores)
                    {
                        double val = score.Score;
                        string key = score.Element.ToString();
                        catalog.Add(key, val);
                    }

                    useSpaceInfo = catalog;
                }
                else
                {
                    var client = _azureStorage.GetBlobContainerClient("school");
                    var size = await client.GetBlobsCatalogSize();
                    await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", $"{schoolId}", size.Item1);
                    foreach (var key in size.Item2.Keys)
                    {
                        await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Blob:Catalog:{schoolId}", key);
                        await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Blob:Catalog:{schoolId}", key, size.Item2[key].HasValue ? size.Item2[key].Value : 0);
                    }

                    useSize = size.Item1.Value;
                    useSpaceInfo = size.Item2;
                }
            }

            return Ok(new { state = 200, allSize, useSize, teacherSpace, useSpaceInfo });
        }

        /// <summary>
        /// 未加入区域的学校
        /// </summary>
        public record NotAreaSchool
        {
            public string id { get; set; }
            public string name { get; set; }
            public string schoolCode { get; set; }
            public string picture { get; set; }
            public List<string> period { get; set; }
            public string province { get; set; }
            public string city { get; set; }
            public string dist { get; set; }
            public string areaId { get; set; } 
            public string standard { get; set; }
            public List<ManyArea> manyAreas { get; set; } = new List<ManyArea>();
        }

        /// <summary>
        /// 学校空间使用情况
        /// </summary>
        public record SchoolSpace
        {
            public string id { get; set; }
            public string name { get; set; }
            public Space space { get; set; }

        }
        /// <summary>
        /// 空间
        /// </summary>
        public record Space
        {
            /// <summary>
            /// 已使用空间
            /// </summary>
            public long useSize { get; set; }
            /// <summary>
            /// 分配教师空间
            /// </summary>
            public long tSize { get; set; }
            /// <summary>
            /// 空间类型
            /// </summary>
            public Dictionary<string, double?> catalogSize { get; set; }
        }

        public record DelSchoolRel
        {
            public string id { get; set; }
            public string code { get; set; }
            /// <summary>
            /// 未删除的类型 1 学校 2教师  3学生
            /// </summary>
            public int type { get; set; }
            public int status { get; set; }
        }
    }
}