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.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelBI.Filter;
using TEAMModelBI.Tool;
using TEAMModelBI.Tool.Extension;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models;
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;

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

        /// <summary>
        /// 查询未加入区域的学校
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-notarea")]
        public async Task<IActionResult> GetNotAreaSchool()
        {
            try
            {
                var cosmosClient = _azureCosmos.GetCosmosClient();
                string sqltxt = $"SELECT c.id,c.name,c.schoolCode,c.province,c.city,c.dist,c.picture,c.period FROM c WHERE c.standard=null";
                List<NotAreaSchool> notAreaSchools = new List<NotAreaSchool>();
                await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: sqltxt, 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())
                        {
                            //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(),
                            };
                            notAreaSchools.Add(notAreaSchool);
                        }
                    }
                }

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

        /// <summary>
        /// 学校加入区
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "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();

                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)
                        {
                            school.standard = $"{standard}";
                            school.areaId = $"{_areaId}";
                            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}{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}{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}{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 修改学校信息
        /// </summary>
        /// <param name="school"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "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}{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>
        /// 依据学校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.ToUnixTimeSeconds(),
                        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}{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; }
        }

        /// <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; }
        }
    }
}