TEAMModelOS/TEAMModelBI/Controllers/RepairApi/SchoolRepController.cs

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Options;
using System.Net.Http;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK;
using TEAMModelOS.Models;
using System.Threading.Tasks;
using System.Text.Json;
using System.IO;
using TEAMModelBI.Models;
using System.Collections.Generic;
using System.Text;
using TEAMModelOS.SDK.Extension;
using System;
using TEAMModelOS.SDK.Models;
using Azure.Cosmos;
using System.Linq;
using TEAMModelOS.SDK.Context.Constant;
using Pipelines.Sockets.Unofficial.Arenas;
using TEAMModelBI.Tool;
using TEAMModelOS.SDK.Models.Cosmos.BI.BISchool;
using TEAMModelOS.SDK.Models.Cosmos.BI;
using static TEAMModelBI.Controllers.Census.SchoolController;
using DocumentFormat.OpenXml.Math;
using TEAMModelOS.SDK.Models.Service.BI;
using TEAMModelBI.Tool.CosmosBank;
using TEAMModelOS.SDK.Models.Service.BIStatsWay;

namespace TEAMModelBI.Controllers.RepairApi
{
    [Route("sccholrep")]
    [ApiController]
    public class SchoolRepController : 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 CoreAPIHttpService _coreAPIHttpService;
        private readonly IWebHostEnvironment _environment; //读取文件
        private readonly IHttpClientFactory _httpClient;

        public SchoolRepController(AzureCosmosFactory azureCosmos, DingDing dingDing, AzureStorageFactory azureStorage, IOptionsSnapshot<Option> option, AzureRedisFactory azureRedis, IConfiguration configuration, CoreAPIHttpService coreAPIHttpService, IHttpClientFactory httpClient, IWebHostEnvironment hostingEnvironment)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _azureStorage = azureStorage;
            _option = option?.Value;
            _azureRedis = azureRedis;
            _configuration = configuration;
            _coreAPIHttpService = coreAPIHttpService;
            _httpClient = httpClient;
            _environment = hostingEnvironment;
        }

        /// <summary>
        /// 添加新学段的学校
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-allscperiod")]
        public async Task<IActionResult> SetAllScPeriod(JsonElement jsonElement)
        {
            jsonElement.TryGetProperty("Language", out JsonElement Language);
            jsonElement.TryGetProperty("scId", out JsonElement scId);
            jsonElement.TryGetProperty("periodName", out JsonElement periodName);
            var cosmosClient = _azureCosmos.GetCosmosClient();
            var builder = $"{_environment.ContentRootPath}/JsonFile/Preset/LangSchoolConfig.json";
            StreamReader streamReader = new(new FileStream(builder, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.UTF8);
            StringBuilder stringBuilder = new();
            string text;
            while ((text = streamReader.ReadLine()) != null)
            {
                stringBuilder.Append(text.ToString());
            }
            streamReader.Close();
            string input = stringBuilder.ToString();
            List<SchoolConfig> schoolConfigs = input.ToObject<List<SchoolConfig>>();
            SchoolConfig schoolConfig = null;
            string Lang = string.Empty; //語系判斷用字串
            if (!string.IsNullOrEmpty($"{Language}"))
                schoolConfig = schoolConfigs.Find(x => x.Lang.Contains($"{Language}"));
                Lang = $"{Language}";

            if (schoolConfig == null)
            {
                //CN站
                if(_option.Location.Contains("china", StringComparison.OrdinalIgnoreCase)) {
                    if ($"{Language}".Contains("en"))
                    {
                        schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("en-US"));
                        Lang = "en-US";
                    }
                    else
                    {
                        schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("zh-CN"));
                        Lang = "zh-CN";
                    }
                }
                //GL站
                else
                {
                    if ($"{Language}".Contains("tw", StringComparison.OrdinalIgnoreCase))
                    {
                        schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("zh-TW"));
                        Lang = "zh-TW";
                    }
                    else
                    {
                        schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("en-US"));
                        Lang = "en-US";
                    } 
                }
            }
            string campusId = Guid.NewGuid().ToString();

            //默認學段、通識科目、學前、语言 各語系名稱取得
            string scName = string.Empty;
            string subjectGeneral = string.Empty;
            string subjectLanage = string.Empty;
            string gradePreschool = string.Empty;
            switch (Lang)
            {
                case "zh-CN":
                    scName = "默认学段";
                    subjectGeneral = "通识";
                    subjectLanage = "语言";
                    gradePreschool = "学前";
                    break;
                case "zh-TW":
                    scName = "預設學段";
                    subjectGeneral = "通識";
                    subjectLanage = "語言";
                    gradePreschool = "學前";
                    break;
                case "en-US":
                    scName = "Default period";
                    subjectGeneral = "General Studies";
                    subjectLanage = "Language";
                    gradePreschool = "Preschool";
                    break;
            }

            StringBuilder noPeriodScSql = new("SELECT DISTINCT value(c) FROM c ");
            List<School> allSc = new();
            List<string> scidList = new(); //更新的學校ID(回傳值)

            if (!string.IsNullOrEmpty($"{scId}"))
                noPeriodScSql.Append($" where c.id='{scId}'");
            else
                noPeriodScSql.Append($" join sp in c.period where c.code = 'Base' AND ( NOT IS_DEFINED(sp.grades) OR ARRAY_LENGTH(sp.grades) = 0 OR NOT IS_DEFINED(sp.subjects) OR ARRAY_LENGTH(sp.subjects) = 0 )");

            if (!string.IsNullOrEmpty($"{periodName}"))
                scName = $"{periodName}";

            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<School>(queryText: "select value(c) from c where c.code='Base' and c.period=[]", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") }))
            {
                allSc.Add(item);
            }

            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<School>(queryText: noPeriodScSql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") }))
            {
                allSc.Add(item);
            }

            foreach (var school in allSc)
            {
                if (school.name.Contains("幼儿园") || school.name.Contains("幼稚園") || school.name.Contains("幼兒園") || school.name.Contains("kindergarten", StringComparison.OrdinalIgnoreCase) || school.name.Contains("preschool", StringComparison.OrdinalIgnoreCase))
                {
                    List<Subject> newSubjects = new List<Subject>() {
                        new Subject { id = Guid.NewGuid().ToString(), name = subjectLanage, type = 1 }
                    };
                    if (school.period.Count > 0)
                    {
                        List<Period> grades = school.period.FindAll(sg => sg.grades.Count == 0);
                        foreach (Period grade in grades)
                        {
                            grade.grades = new List<string>() { gradePreschool };
                            grade.gradeCount = grade.grades.Count;
                        }
                        List<Period> semesters = school.period.FindAll(sg => sg.semesters.Count == 0);
                        foreach (Period semester in semesters)
                        {
                            semester.semesters = new List<Semester>() { 
                                new Semester { name = schoolConfig.semester[0].term, start = schoolConfig.semester[0].start, month = schoolConfig.semester[0].month, day = schoolConfig.semester[0].day, id = Guid.NewGuid().ToString() },
                                new Semester { name = schoolConfig.semester[1].term, start = schoolConfig.semester[1].start, month = schoolConfig.semester[1].month, day = schoolConfig.semester[1].day, id = Guid.NewGuid().ToString() }
                            };
                            semester.semesterCount = semester.semesters.Count;
                        }
                        List<Period> subjects = school.period.FindAll(sg => sg.subjects.Count == 0);
                        foreach (Period subject in subjects)
                        {
                            subject.subjects = newSubjects;
                            subject.subjectCount = subject.subjects.Count;
                        }
                    }
                    else
                    {
                        if (school.campuses.Count > 0)
                            campusId = school.campuses.Select(x => x.id).FirstOrDefault().ToString();

                        school.period.Add(new Period
                        {
                            id = Guid.NewGuid().ToString(),
                            name = scName,
                            grades = new List<string>() { gradePreschool },
                            campusId = campusId,
                            subjects = newSubjects,
                            semesters = new List<Semester>() { 
                                new Semester { name = schoolConfig.semester[0].term, start = schoolConfig.semester[0].start, month = schoolConfig.semester[0].month, day = schoolConfig.semester[0].day, id = Guid.NewGuid().ToString() },
                                new Semester { name = schoolConfig.semester[1].term, start = schoolConfig.semester[1].start, month = schoolConfig.semester[1].month, day = schoolConfig.semester[1].day, id = Guid.NewGuid().ToString() }
                            },
                            gradeCount = 1,
                            semesterCount = 2,
                            subjectCount = newSubjects.Count,
                        });

                        if (!school.campuses.Select(x => x.id).Contains(campusId))
                            school.campuses.Add(new Campus { name = school.name, id = campusId });
                    }
                }
                else
                {
                    if (school.period.Count > 0)
                    {
                        List<Period> grades = school.period.FindAll(sg => sg.grades.Count == 0);
                        foreach (Period grade in grades)
                        {
                            grade.grades = schoolConfig.grades;
                            grade.gradeCount = schoolConfig.grades.Count;
                        }
                        List<Period> semesters = school.period.FindAll(sg => sg.semesters.Count == 0);
                        foreach (Period semester in semesters)
                        {
                            semester.semesters = new List<Semester>() 
                            { 
                                new Semester { name = schoolConfig.semester[0].term, start = schoolConfig.semester[0].start, month = schoolConfig.semester[0].month, day = schoolConfig.semester[0].day, id = Guid.NewGuid().ToString() },
                                new Semester { name = schoolConfig.semester[1].term, start = schoolConfig.semester[1].start, month = schoolConfig.semester[1].month, day = schoolConfig.semester[1].day, id = Guid.NewGuid().ToString() }
                            };
                            semester.semesterCount = semester.semesters.Count;
                        }
                        List<Period> subjects = school.period.FindAll(sg => sg.subjects.Count == 0);
                        foreach (Period subject in subjects)
                        {
                            subject.subjects = (school.type.Equals(2)) ? new List<Subject>() //高教
                            {
                                new Subject { id=Guid.NewGuid().ToString(),name=subjectGeneral,type=1 }
                            } : new List<Subject>() //普教
                            {
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[0].name,type=schoolConfig.PresetSubject[0].type },
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[1].name,type=schoolConfig.PresetSubject[1].type },
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[2].name,type=schoolConfig.PresetSubject[2].type }
                            };
                            subject.subjectCount = subject.subjects.Count;
                        }
                    }
                    else
                    {
                        if (school.campuses.Count > 0)
                            campusId = school.campuses.Select(x => x.id).FirstOrDefault().ToString();

                        school.period.Add(new Period
                        {
                            id = Guid.NewGuid().ToString(),
                            name = scName,
                            campusId = campusId,
                            semesters = new List<Semester>() {
                                new Semester { name = schoolConfig.semester[0].term, start = schoolConfig.semester[0].start, month = schoolConfig.semester[0].month, day = schoolConfig.semester[0].day, id = Guid.NewGuid().ToString() },
                                new Semester { name = schoolConfig.semester[1].term, start = schoolConfig.semester[1].start, month = schoolConfig.semester[1].month, day = schoolConfig.semester[1].day, id = Guid.NewGuid().ToString() }
                            },
                            subjects = (school.type.Equals(2)) ? new List<Subject>() { //高教
                                new Subject { id=Guid.NewGuid().ToString(),name=subjectGeneral,type=1 },
                            } : new List<Subject>() { //普教
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[0].name,type=schoolConfig.PresetSubject[0].type },
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[1].name,type=schoolConfig.PresetSubject[1].type },
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[2].name,type=schoolConfig.PresetSubject[2].type }
                            },
                            grades = schoolConfig.grades,
                            analysis = new Analysis()
                            {
                                type = new List<ExamSimple>() {
                                    new ExamSimple { id = Guid.NewGuid().ToString(), name = schoolConfig.PresetExam[0].type[0].name },
                                    new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[1].name },
                                    new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[2].name },
                                    new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[3].name }
                                },
                                income = schoolConfig.PresetExam[0].income,
                                eugenics = schoolConfig.PresetExam[0].eugenics,
                                touch = schoolConfig.PresetExam[0].touch
                            },
                            gradeCount = schoolConfig.grades.Count,
                            semesterCount = schoolConfig.semester.Count,
                            subjectCount = (school.type.Equals(2)) ? 1 : schoolConfig.PresetSubject.Count
                        });
                        if (!school.campuses.Select(x => x.id).Contains(campusId))
                            school.campuses.Add(new Campus { name = school.name, id = campusId });
                    }
                }
                School rSchool = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, school.id, new PartitionKey("Base"));
                scidList.Add(rSchool.id);
            }

            return Ok(new { state = RespondCode.Ok, ids = scidList });
        }

        /// <summary>
        /// 新增学校学段（多个）
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-scperiod")]
        public async Task<IActionResult> SetScPeriod(JsonElement jsonElement)
        {
            if (!jsonElement.TryGetProperty("scId", out JsonElement scId)) return BadRequest();
            if (!jsonElement.TryGetProperty("periodName", out JsonElement periodName)) return BadRequest();

            List<string> periodNames = $"{periodName}".ToObject<List<string>>();
            jsonElement.TryGetProperty("Language", out JsonElement Language);

            var cosmosClient = _azureCosmos.GetCosmosClient();
            var builder = $"{_environment.ContentRootPath}/JsonFile/Preset/LangSchoolConfig.json";
            StreamReader streamReader = new(new FileStream(builder, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.UTF8);
            StringBuilder stringBuilder = new();
            string text;
            while ((text = streamReader.ReadLine()) != null)
            {
                stringBuilder.Append(text.ToString());
            }
            streamReader.Close();
            string input = stringBuilder.ToString();
            List<SchoolConfig> schoolConfigs = input.ToObject<List<SchoolConfig>>();
            SchoolConfig schoolConfig = null;
            if (!string.IsNullOrEmpty($"{Language}"))
                schoolConfig = schoolConfigs.Find(x => x.Lang.Contains($"{Language}"));

            if (schoolConfig == null)
            {
                if ($"{Language}".Contains("en"))
                    schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("en-US"));
                else
                    schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("zh-CN"));
            }
            string campusId = Guid.NewGuid().ToString();
            School school = null;

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

            if (school != null)
            {
                foreach (var item in periodNames)
                {
                    if (school.campuses.Count > 0)
                        campusId = school.campuses.Select(x => x.id).FirstOrDefault().ToString();

                    school.period.Add(new Period
                    {
                        id = Guid.NewGuid().ToString(),
                        name = item,
                        campusId = campusId,
                        semesters = new List<Semester>() { new Semester { name = schoolConfig.semester[0].term, start = schoolConfig.semester[0].start, month = schoolConfig.semester[0].month, day = schoolConfig.semester[0].day, id = Guid.NewGuid().ToString() },
                        new Semester { name = schoolConfig.semester[1].term, start = schoolConfig.semester[1].start, month = schoolConfig.semester[1].month, day = schoolConfig.semester[1].day, id = Guid.NewGuid().ToString() } },
                        subjects = new List<Subject>() {
                        new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[0].name,type=schoolConfig.PresetSubject[0].type },
                        new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[1].name,type=schoolConfig.PresetSubject[1].type },
                        new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[2].name,type=schoolConfig.PresetSubject[2].type }
                        },
                        grades = schoolConfig.grades,
                        analysis = new Analysis()
                        {
                            type = new List<ExamSimple>() { new ExamSimple { id = Guid.NewGuid().ToString(), name = schoolConfig.PresetExam[0].type[0].name },
                        new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[1].name },
                        new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[2].name },
                        new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[3].name } },
                            income = schoolConfig.PresetExam[0].income,
                            eugenics = schoolConfig.PresetExam[0].eugenics,
                            touch = schoolConfig.PresetExam[0].touch
                        }
                    });
                }

                if (!school.campuses.Select(x => x.id).Contains(campusId))
                    school.campuses.Add(new Campus { name = school.name, id = campusId });
            }

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

            return Ok(new { state = RespondCode.Ok, school });
        }

        /// <summary>
        /// 学校信息中间件查询和修复接口
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-allscinfos")]
        public async Task<IActionResult> SetAllScInfos(JsonElement jsonElement)
        {
            try
            {
                jsonElement.TryGetProperty("scId", out JsonElement scId);
                var cosmosClient = _azureCosmos.GetCosmosClient();
                List<string> scIds = new();
                if (!string.IsNullOrEmpty($"{scId}"))
                    scIds.Add($"{scId}");
                else
                    scIds = await CommonFind.FindScIds(cosmosClient, "select value(c.id) from c ", "Base");

                List<BIRelation> scInfos = new();
                foreach (var itemId in scIds)
                {
                    BIRelation bIRelation = null;
                    var resRel = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync(itemId, new PartitionKey("BIRel"));
                    if (resRel.Status == 200)
                    {
                        continue;
                        //using var fileJson = await JsonDocument.ParseAsync(resRel.ContentStream);
                        //bIRelation = fileJson.ToObject<BIRelation>();
                    }
                    else
                    {
                        ScBaseInfo scBaseInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<ScBaseInfo>(itemId, new PartitionKey("Base"));
                        string areaName = null;
                        if (!string.IsNullOrEmpty(scBaseInfo.areaId))
                        {
                            await foreach (var itemName in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<string>(queryText: $"select value(c.name) from c where c.pk='Area' and c.id='{scBaseInfo.areaId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base-Area") }))
                            {
                                areaName = itemName;
                            }
                        }

                        bIRelation = new BIRelation()
                        {
                            id = scBaseInfo.id,
                            name = scBaseInfo.name,
                            picture = scBaseInfo.picture,
                            size = scBaseInfo.size,
                            createDate = scBaseInfo.createTime,
                            region = scBaseInfo.region,
                            province = scBaseInfo.province,
                            city = scBaseInfo.city,
                            dist = scBaseInfo.dist,
                            address = scBaseInfo.address,
                            areaId = scBaseInfo.areaId,
                            scale = scBaseInfo.scale,
                            areaName = areaName,
                            upDate = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
                        };

                        var response = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync(itemId, new PartitionKey("ProductSum"));
                        if (response.Status == 200)
                        {
                            using var json = await JsonDocument.ParseAsync(response.ContentStream);
                            if (json.RootElement.TryGetProperty("serial", out JsonElement serial) && !serial.ValueKind.Equals(JsonValueKind.Null))
                            {
                                List<string> serials = serial.ToObject<List<SchoolProductSumData>>().Select(x => x.prodCode).ToList();
                                bIRelation.serial = serials;
                            }
                            if (json.RootElement.TryGetProperty("service", out JsonElement service) && !service.ValueKind.Equals(JsonValueKind.Null))
                            {
                                List<string> services = service.ToObject<List<SchoolProductSumData>>().Select(x => x.prodCode).ToList();
                                bIRelation.service = services;
                            }
                            if (json.RootElement.TryGetProperty("hard", out JsonElement hard) && !hard.ValueKind.Equals(JsonValueKind.Null))
                            {
                                List<string> hards = hard.ToObject<List<SchoolProductSumDataHard>>().Select(x => x.prodCode).ToList();
                                bIRelation.hard = hards;
                            }
                        }
                        bIRelation = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<BIRelation>(bIRelation, new PartitionKey("BIRel"));
                    }

                    scInfos.Add(bIRelation);
                }

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

        /// <summary>
        /// 修复所有学校统计数据中间件接口
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-allscstats")]
        public async Task<IActionResult> SetAllScStats(JsonElement jsonElement) 
        {
            jsonElement.TryGetProperty("scId", out JsonElement scId);
            var cosmosClient = _azureCosmos.GetCosmosClient();
            
            List<string> scIds = new();
            if (!string.IsNullOrEmpty($"{scId}"))
                scIds.Add($"{scId}");
            else
                scIds = await CommonFind.FindScIds(cosmosClient, "select value(c.id) from c ", "Base");

            DateTimeOffset dateTime = DateTimeOffset.UtcNow;

            List<StatsInfo> statsInfos = new();
            List<Task<ItemResponse<StatsInfo>>> taskStss = new();
            foreach (var sc in scIds) 
            {
                StatsInfo statsInfo = new();
                var scDataStats = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{dateTime.Year}-{sc}", new PartitionKey("Statistics"));
                if (scDataStats.Status == 200)
                {
                    using var fileJson = await JsonDocument.ParseAsync(scDataStats.ContentStream);
                    statsInfo = fileJson.ToObject<StatsInfo>();
                }
                else
                {
                    statsInfo.id = $"{dateTime.Year}-{sc}";
                }

                statsInfo = await SchoolStatsWay.GetSingleSc(cosmosClient, sc);

                if (scDataStats.Status == 200)
                    taskStss.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<StatsInfo>(statsInfo, $"{dateTime.Year}-{sc}", new PartitionKey("Statistics")));
                else
                    taskStss.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<StatsInfo>(statsInfo, new PartitionKey("Statistics")));

                //statsInfo = await StatsWay.upSingleSc(cosmosClient, sc);
                statsInfos.Add(statsInfo);
            }

            if (taskStss.Count < 256)
                await Task.WhenAll(taskStss);
            else 
            {
                int pages = (taskStss.Count + 255) / 256;
                for (int i = 0; i < pages; i++)
                {
                    List<Task<ItemResponse<StatsInfo>>> temTaskStss = taskStss.Skip(i * 256).Take(256).ToList();
                    await Task.WhenAll(temTaskStss);
                }
            }

            return Ok(new { state = RespondCode.Ok, statsInfos });
        }

    }
}