TEAMModelOS/TEAMModelOS/Controllers/School/SchoolController.cs

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using System.Text.Json;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Extension;
using Azure.Cosmos;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;
using System.IO;
using System.Dynamic;
using System.Net.Http;
using System.Net;
using Newtonsoft.Json;
using System.Linq;
using StackExchange.Redis;
using Microsoft.Extensions.Configuration;
using TEAMModelOS.Filter;
using Microsoft.AspNetCore.Authorization;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using HTEXLib.COMM.Helpers;
using System.IdentityModel.Tokens.Jwt;
using TEAMModelOS.SDK.DI.CoreAPI;

namespace TEAMModelOS.Controllers
{
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]

    [Route("school/init")]
    [ApiController]
    public class SchoolController : ControllerBase
    {

        public AzureCosmosFactory _azureCosmos;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        int baseSpaceSize = 10; //學校保底空間大小(1G)
        private readonly double bytes = 1073741824;
        private readonly int redisAclassoneDbNum = 8; //AclassOne Redis DB號
        private readonly IConfiguration _configuration;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        private readonly NotificationService _notificationService;
        private readonly HttpClient _httpClient;
        private readonly HttpTrigger _httpTrigger;
        public SchoolController(HttpTrigger httpTrigger,CoreAPIHttpService coreAPIHttpService, NotificationService notificationService, AzureCosmosFactory azureCosmos, AzureStorageFactory azureStorage, AzureRedisFactory azureRedis, DingDing dingDing, IOptionsSnapshot<Option> option, IConfiguration configuration, HttpClient httpClient)
        {
            _azureCosmos = azureCosmos;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
            _dingDing = dingDing;
            _option = option?.Value;
            _configuration = configuration;
            _coreAPIHttpService = coreAPIHttpService;
            _notificationService = notificationService;
            _httpClient = httpClient;
            _httpTrigger = httpTrigger;
        }
        /// <summary>
        /// 修改学校信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-school-info")]
        [Authorize(Roles = "IES")]

        [AuthToken(Roles = "admin", Permissions = "train-appraise")]

        public async Task<IActionResult> SetTeacherInfo(JsonElement request)
        {
            var client = _azureCosmos.GetCosmosClient();

            if (!request.TryGetProperty("opt", out JsonElement _opt))
            {
                return BadRequest();
            }
            var (userid, name, _, school) = HttpContext.GetAuthTokenInfo();
            try
            {
                SchoolTeacher teacher = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<SchoolTeacher>(userid, new PartitionKey($"Teacher-{school}"));
                switch (true)
                {
                    //修改互评开关
                    case bool when $"{_opt}".Equals("modify-hpappraise", StringComparison.OrdinalIgnoreCase):
                        int hpappraise = -1;
                        if (request.TryGetProperty("hpappraise", out JsonElement _hpappraise))
                        {
                            int.TryParse($"{_hpappraise}", out hpappraise);
                        }
                        if (hpappraise != -1)
                        {
                            School schoolData = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school, new PartitionKey("Base"));
                            schoolData.hpappraise = hpappraise;
                            await client.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(schoolData, school, new PartitionKey("Base"));
                            return Ok(new { status = 200 });
                        }
                        else
                        {
                            return Ok(new { error = 1, msg = "参数异常！" });
                        }

                    default:
                        return Ok(new { error = 1, msg = "参数异常！" });

                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"IES5，{_option.Location}，Teacher/init/set-teacher-info()\n{ex.Message}\n{ex.StackTrace}{request.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
                return Ok(new { error = 1, msg = "参数异常！" });

            }
        }
        /// <summary>
        /// 保存或更新学校
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "admin")]
        [HttpPost("upsert")]
        [Authorize(Roles = "IES")]

        public async Task<IActionResult> Upsert(School school)
        {
            var (_, _, _, _school) = HttpContext.GetAuthTokenInfo();
            try
            {
                School schoolInfo = new ();
                var client = _azureCosmos.GetCosmosClient();
                var schoolContainer = client.GetContainer(Constant.TEAMModelOS, "School");
                var response = await schoolContainer.ReadItemStreamAsync(school.id, new PartitionKey($"Base"));
                if (response.Status == 200)
                {
                    School db_school = JsonDocument.Parse(response.Content).RootElement.Deserialize<School>();
                    //计算 比较更改前后 学段的年级变化的学段，并重新处理行政班的毕业状态。
                    //变更后
                    List<KeyValuePair<string, int>> period_gradeCount = new List<KeyValuePair<string, int>>();
                    school.period.ForEach(z => { period_gradeCount.Add(new KeyValuePair<string, int>(z.id, z.grades.Count)); });
                    //变更前
                    List<KeyValuePair<string, int>> dbperiod_gradeCount = new List<KeyValuePair<string, int>>();
                    db_school.period.ForEach(z => { dbperiod_gradeCount.Add(new KeyValuePair<string, int>(z.id, z.grades.Count)); });
                    List<string> periodIds = new List<string>();
                    period_gradeCount.ForEach(x => {
                        var gradeCount =   dbperiod_gradeCount.Find(y => x.Key.Equals(y.Key));
                        if (!string.IsNullOrWhiteSpace(gradeCount.Key)) {
                            if (gradeCount.Value != x.Value) {
                                periodIds.Add(x.Key);
                            }
                        }
                    });
                    await SchoolService.DoGraduateClasses(_httpTrigger, _azureCosmos, periodIds, school, _option);
                    //变更教师关联的学校基本信息
                    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 client.GetContainer(Constant.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 client.GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync(item, item.id, new PartitionKey($"Base"));
                    }
                    schoolInfo = await schoolContainer.UpsertItemAsync(school, new PartitionKey($"Base"));
                }
                else
                {
                    school.code = "Base";
                    schoolInfo = await schoolContainer.CreateItemAsync(school, new PartitionKey($"Base"));
                }
                return Ok(new { schoolInfo });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"CoreAPI2，{_option.Location}，school/upsert()\n{ex.Message}\n{ex.StackTrace}\n", GroupNames.醍摩豆服務運維群組);
                return BadRequest();
            }
        }
        /// <summary>
        /// 查找学校
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("find")]
        [Authorize(Roles = "IES")]
        public async Task<IActionResult> Find(JsonElement request)
        {
            if (!request.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
            var client = _azureCosmos.GetCosmosClient();
            List<School> schools = new ();
            var query = $"select c.id,c.pk,c.code, c.name,c.region,c.province,c.city,c.timeZone,c.picture,c.size,c.period,c.campuses from c where c.id ='{school_code}'";
            await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: query, 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 { schools });
            /* ResponseBuilder builder = ResponseBuilder.custom();

             if (request.TryGetProperty("code", out JsonElement code) &&! string.IsNullOrEmpty(code.ToString()))
             {
                 List<School> sc = await _azureCosmos.FindByDict<School>(request);
                 return builder.Data(sc).build();
             }
             else {
                 return builder.Data(null).build();
             }*/
        }
        /// <summary>
        /// 取得所有學校(只取基本資料)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-all-school-base")]
        public async Task<IActionResult> GetAllSchoolBaesInfo(JsonElement request)
        {
            var client = _azureCosmos.GetCosmosClient();
            List<object> schools = new ();
            await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: $"SELECT c.id, c.code, c.name, c.region, c.province, c.city, c.address, c.picture FROM c ", 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<object>());
                    }
                }
            }
            return Ok(new { schools });
        }

        /// <summary>
        /// 取得某學校基本資料 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-school-base")]
        public async Task<IActionResult> GetSchoolBaesInfo(JsonElement request)
        {
            if (!request.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();

            var client = _azureCosmos.GetCosmosClient();
            var schoolContainer = client.GetContainer(Constant.TEAMModelOS, "School");
            //取得學校學制、年級、教室
            List<object> classes = new List<object>();
            await foreach (var item in schoolContainer.GetItemQueryStreamIterator(queryText: $"SELECT c.id, c.name, c.gradeId FROM c", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Class-{school_code}") }))
            {
                var jsonc = await JsonDocument.ParseAsync(item.ContentStream);
                foreach (var classeinfo in jsonc.RootElement.GetProperty("Documents").EnumerateArray())
                {
                    dynamic classExtobj = new ExpandoObject();
                    classExtobj.id = classeinfo.GetProperty("id");
                    classExtobj.name = classeinfo.GetProperty("name");
                    classExtobj.gradeId = classeinfo.GetProperty("gradeId");
                    classes.Add(classExtobj);
                }
            }
            List<object> periods = new List<object>();
            List<object> grades = new List<object>();
            var responsesch = await schoolContainer.ReadItemStreamAsync(school_code.ToString(), new PartitionKey($"Base"));
            if (responsesch.Status == 200)
            {
                var jsons = await JsonDocument.ParseAsync(responsesch.ContentStream);
                if (jsons.RootElement.TryGetProperty("period", out JsonElement periodJobj))
                {
                    foreach (var periodinfo in periodJobj.EnumerateArray())
                    {
                        dynamic periodExtobj = new ExpandoObject();
                        periodExtobj.id = periodinfo.GetProperty("id");
                        periodExtobj.name = periodinfo.GetProperty("name");
                        periods.Add(periodExtobj);
                        if (periodinfo.TryGetProperty("grades", out JsonElement gradesJobj))
                        {
                            foreach (var gradeinfo in gradesJobj.EnumerateArray())
                            {
                                dynamic gradeExtobj = new ExpandoObject();
                                gradeExtobj.id = gradeinfo.GetProperty("id");
                                gradeExtobj.name = gradeinfo.GetProperty("name");
                                gradeExtobj.periodId = periodinfo.GetProperty("id");
                                grades.Add(gradeExtobj);
                            }
                        }
                    }
                }
            }
            return Ok(new { periods, grades, classes });
        }
        /// <summary>
        /// 取得某學校產品購買紀錄
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-school-product")]
        //[AuthToken(Roles = "admin,teacher")]
        //[Authorize(Roles = "IES")]
        public async Task<IActionResult> GetSchoolProductInfo(JsonElement request)
        {
            try
            {
                if (!request.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
                var db = _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School");
                var r8 = _azureRedis.GetRedisClient(8);

                List<SchoolProductSerial> serial = new (); //承接DB資料用：序號
                List<SerialInfoBaseWithdeviceBoundExt> serialResult = new (); //最後要輸出的序號結果
                List<SchoolProductService> serviceProduct = new (); //承接DB資料用：服務
                List<SchoolProductOrder> serviceOrder = new(); //服務各產品購買紀錄
                List<SchoolProductSumDataService> serviceSum = new (); //服務各產品購買紀錄
                List<SchoolProductHard> hard = new (); //承接DB資料用：硬體
                SchoolProductSum productSum = new (); //承接DB資料用：產品目前狀態 
                List<SchoolProductSumProdInfo> prodinfo = new (); //產品資訊列表(名稱、八碼)
                List<deviceForCoreService> uuidList = new (); //要向CoreService詢問deviceID及硬體資訊的UUID列表
                long UTCNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();

                ////取得各產品目前可得數量
                var response = await db.ReadItemStreamAsync(school_code.ToString(), new PartitionKey($"ProductSum"));
                if (response.Status == 200)
                {
                    using var json = await JsonDocument.ParseAsync(response.ContentStream);
                    productSum = json.ToObject<SchoolProductSum>();
                    prodinfo = productSum.prodinfo;
                    serviceSum = productSum.service;
                }

                //軟體
                await foreach (var itemsr in db.GetItemQueryStreamIterator(queryText: $"SELECT * FROM c WHERE c.dataType = 'serial'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Product-{school_code}") }))
                {
                    using var json = await JsonDocument.ParseAsync(itemsr.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            serial.Add(obj.ToObject<SchoolProductSerial>());
                            if (obj.TryGetProperty("deviceBound", out JsonElement deviceBoundJobj) && !string.IsNullOrWhiteSpace(deviceBoundJobj.ToString()))
                            {
                                foreach (var deviceBoundRow in deviceBoundJobj.EnumerateArray())
                                {
                                    deviceForCoreService uuidForCore = new deviceForCoreService();
                                    uuidForCore.sn = (!string.IsNullOrWhiteSpace(Convert.ToString(obj.GetProperty("serial")))) ? Convert.ToString(obj.GetProperty("serial")) : null;
                                    uuidForCore.uuid1 = (!string.IsNullOrWhiteSpace(Convert.ToString(deviceBoundRow.GetProperty("uuid")))) ? Convert.ToString(deviceBoundRow.GetProperty("uuid")) : null;
                                    uuidForCore.uuid2 = (!string.IsNullOrWhiteSpace(Convert.ToString(deviceBoundRow.GetProperty("uuid2")))) ? Convert.ToString(deviceBoundRow.GetProperty("uuid2")) : null;
                                    uuidForCore.device_id = (!string.IsNullOrWhiteSpace(Convert.ToString(deviceBoundRow.GetProperty("deviceId")))) ? Convert.ToString(deviceBoundRow.GetProperty("deviceId")) : null;
                                    uuidForCore.class_id = (!string.IsNullOrWhiteSpace(Convert.ToString(deviceBoundRow.GetProperty("classId")))) ? Convert.ToString(deviceBoundRow.GetProperty("classId")) : null;
                                    uuidList.Add(uuidForCore);
                                }
                            }
                        }
                    }
                }
                ////取得DeviceInfo From Core 並更新序號資料
                List<deviceFromCoreService> coreUuidList = (List<deviceFromCoreService>)GetDeviceFromCoreAsync(uuidList).GetAwaiter().GetResult();
                foreach (SchoolProductSerial serialRow in serial)
                {
                    var deviceBoundArray = new List<deviceBoundExt>();
                    List<deviceFromCoreService> coreUuid = coreUuidList
                           .Where((deviceFromCoreService x) => x.sn == serialRow.serial)
                           .ToList();
                    foreach (deviceFromCoreService deviceRow in coreUuid)
                    {
                        if (!string.IsNullOrWhiteSpace(deviceRow.uuid1) || !string.IsNullOrWhiteSpace(deviceRow.uuid2) || !string.IsNullOrWhiteSpace(deviceRow.device_id)) //uuid1、uuid2、device_id 任一欄有值
                        {
                            //前端顯示用
                            deviceForCoreService deviceBoundRow = uuidList.Where(u => u.sn == deviceRow.sn && u.uuid1 == deviceRow.uuid1 && u.uuid2 == deviceRow.uuid2).FirstOrDefault();
                            deviceBoundExt deviceBoundExt = new deviceBoundExt();
                            deviceBoundExt.uuid = deviceBoundRow.uuid1;
                            deviceBoundExt.uuid2 = deviceBoundRow.uuid2;
                            deviceBoundExt.classId = deviceBoundRow.class_id;
                            deviceBoundExt.deviceId = deviceRow.device_id;
                            deviceBoundExt.os = deviceRow.os;
                            deviceBoundExt.ip = deviceRow.local_ip;
                            deviceBoundExt.cpu = deviceRow.cpu;
                            deviceBoundExt.pcname = deviceRow.pc_name;
                            deviceBoundExt.osver = deviceRow.os_ver;
                            deviceBoundArray.Add(deviceBoundExt);
                            //DB更新用
                            deviceBound serialDeviceBoundRow = serialRow.deviceBound.Where(d => (d.uuid == deviceBoundRow.uuid1 && d.uuid2 == deviceBoundRow.uuid2) || (d.uuid == deviceBoundRow.uuid2 && d.uuid2 == deviceBoundRow.uuid1)).FirstOrDefault();
                            if (serialDeviceBoundRow != null)
                            {
                                serialDeviceBoundRow.deviceId = deviceRow.device_id;
                            }
                        }
                    }
                    if (deviceBoundArray.Count.Equals(0)) //無法取得CS的硬體資訊，則用序號的硬體資訊帶入
                    {
                        if (serialRow.deviceBound != null)
                        {
                            foreach (deviceBound serialRowDeviceBound in serialRow.deviceBound)
                            {
                                if (!string.IsNullOrEmpty(serialRowDeviceBound.uuid) || !string.IsNullOrEmpty(serialRowDeviceBound.uuid2))
                                {
                                    deviceBoundExt deviceBoundExt = new deviceBoundExt();
                                    deviceBoundExt.uuid = serialRowDeviceBound.uuid;
                                    deviceBoundExt.uuid2 = serialRowDeviceBound.uuid2;
                                    deviceBoundExt.classId = serialRowDeviceBound.classId;
                                    deviceBoundExt.deviceId = serialRowDeviceBound.deviceId;
                                    deviceBoundArray.Add(deviceBoundExt);
                                }
                            }
                        }
                    }
                    //序號更新
                    await db.ReplaceItemAsync<SchoolProductSerial>(serialRow, serialRow.id, new PartitionKey($"Product-{school_code}"));
                    //回傳值
                    SerialInfoBaseWithdeviceBoundExt serialResultRow = new SerialInfoBaseWithdeviceBoundExt();
                    serialResultRow.code = serialRow.code;
                    serialResultRow.id = serialRow.id;
                    serialResultRow.dataType = serialRow.dataType;
                    serialResultRow.serial = serialRow.serial;
                    serialResultRow.prodCode = serialRow.prodCode;
                    serialResultRow.clientQty = serialRow.clientQty;
                    serialResultRow.orderDate = serialRow.orderDate;
                    serialResultRow.regDate = serialRow.regDate;
                    serialResultRow.startDate = serialRow.startDate;
                    serialResultRow.endDate = serialRow.endDate;
                    serialResultRow.deviceMax = serialRow.deviceMax;
                    serialResultRow.expireStatus = serialRow.expireStatus;
                    serialResultRow.status = serialRow.status;
                    serialResultRow.deviceBound = deviceBoundArray;
                    if (serialRow.aprule != null)
                    {
                        string apruleJsonString = serialRow.aprule.ToJsonString();
                        var apruleDc = JsonDocument.Parse(apruleJsonString);
                        serialResultRow.aprule = (apruleDc.RootElement.TryGetProperty("json", out JsonElement apruleJson)) ? apruleJson : null;
                    }
                    else serialResultRow.aprule = null;
                    serialResult.Add(serialResultRow);
                }

                //服務
                List<SchoolProductSumDataService> service = new List<SchoolProductSumDataService>();
                await foreach (var items in db.GetItemQueryStreamIterator(queryText: $"SELECT * FROM c WHERE c.id = '{school_code}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"ProductSum") }))
                {
                    using var json = await JsonDocument.ParseAsync(items.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            SchoolProductSum schoolProductSum = obj.ToObject<SchoolProductSum>();
                            service = schoolProductSum.service;
                        }
                    }
                }
                if (service.Count > 0)
                {
                    foreach (SchoolProductSumDataService serviceRow in service)
                    {
                        SchoolProductOrder spOrderRow = new SchoolProductOrder();
                        spOrderRow.prodCode = serviceRow.prodCode;
                        spOrderRow.avaliable = serviceRow.avaliable;
                        spOrderRow.avaliableStartDate = serviceRow.startDate;
                        spOrderRow.avaliableEndDate = serviceRow.endDate;
                        serviceOrder.Add(spOrderRow);
                    }
                }

                #region 產品購買履歷廢除部分
                ////(服務)取得各產品購買履歷
                //await foreach (var itemsv in clientContainer.GetItemQueryStreamIterator(queryText: $"SELECT * FROM c WHERE c.dataType = 'service'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Product-{school_code}") }))
                //{
                //    using var json = await JsonDocument.ParseAsync(itemsv.ContentStream);
                //    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                //    {
                //        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                //        {
                //            SchoolProductService serviceProductRow = obj.ToObject<SchoolProductService>();
                //            serviceProduct.Add(serviceProductRow);
                //        }
                //    }
                //}
                ////(服務)產品購買履歷整形
                //IEnumerable<SchoolProductService> serviceProductOrder = serviceProduct.OrderBy(sp => sp.startDate);
                //foreach (SchoolProductService serviceProductRow in serviceProduct)
                //{
                //    //取得此產品現在可用數
                //    SchoolProductSumDataService serviceSumNow = serviceSum.Where(ss => ss.prodCode.Equals(serviceProductRow.prodCode)).FirstOrDefault();
                //    int serviceAvaliableNow = (serviceSumNow != null) ? serviceSumNow.avaliable : 0;
                //    long serviceAvaliableStartDate = (serviceSumNow != null) ? serviceSumNow.startDate : 0;
                //    long serviceAvaliableEndDate = (serviceSumNow != null) ? serviceSumNow.endDate : 0;
                //    //取得此產品購買履歷
                //    SchoolProductOrder serviceOrderNow = serviceOrder.Where(so => so.prodCode == serviceProductRow.prodCode).FirstOrDefault();
                //    if (serviceOrderNow == null) //無此產品項
                //    {
                //        SchoolProductOrder serviceOrderRow = new SchoolProductOrder();
                //        serviceOrderRow.prodCode = serviceProductRow.prodCode;
                //        serviceOrderRow.order = new List<SchoolProductOrderList>();
                //        SchoolProductOrderList serviceOrderRowOrderList = new SchoolProductOrderList();
                //        serviceOrderRowOrderList.id = serviceProductRow.id;
                //        serviceOrderRowOrderList.orderDate = serviceProductRow.orderDate;
                //        serviceOrderRowOrderList.startDate = serviceProductRow.startDate;
                //        serviceOrderRowOrderList.endDate = serviceProductRow.endDate;
                //        serviceOrderRowOrderList.number = serviceProductRow.number;
                //        serviceOrderRowOrderList.unit = serviceProductRow.unit;
                //        serviceOrderRow.order.Add(serviceOrderRowOrderList);
                //        serviceOrderRow.avaliable = serviceAvaliableNow;
                //        serviceOrderRow.avaliableStartDate = serviceAvaliableStartDate;
                //        serviceOrderRow.avaliableEndDate = serviceAvaliableEndDate;
                //        serviceOrder.Add(serviceOrderRow);
                //    }
                //    else //有此產品項 => 看是否有此購買紀錄
                //    {
                //        //記入可用起始終止日
                //        serviceOrderNow.avaliableStartDate = serviceAvaliableStartDate;
                //        serviceOrderNow.avaliableEndDate = serviceAvaliableEndDate;
                //        //記入購買紀錄
                //        SchoolProductOrderList SchoolProductOrderListNow = serviceOrderNow.order.Where(Sol => Sol.id.Equals(serviceProductRow.id)).FirstOrDefault();
                //        if (SchoolProductOrderListNow == null) //無此購買紀錄
                //        {
                //            SchoolProductOrderList serviceOrderRowOrderList = new SchoolProductOrderList();
                //            serviceOrderRowOrderList.id = serviceProductRow.id;
                //            serviceOrderRowOrderList.orderDate = serviceProductRow.orderDate;
                //            serviceOrderRowOrderList.startDate = serviceProductRow.startDate;
                //            serviceOrderRowOrderList.endDate = serviceProductRow.endDate;
                //            serviceOrderRowOrderList.number = serviceProductRow.number;
                //            serviceOrderRowOrderList.unit = serviceProductRow.unit;
                //            serviceOrderNow.order.Add(serviceOrderRowOrderList);
                //        }
                //    }
                //}
                #endregion

                //硬體
                await foreach (var itemhd in db.GetItemQueryStreamIterator(queryText: $"SELECT * FROM c WHERE c.dataType = 'hard'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Product-{school_code}") }))
                {
                    using var json = await JsonDocument.ParseAsync(itemhd.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            hard.Add(obj.ToObject<SchoolProductHard>());
                        }
                    }
                }

                //空間計算
                ////取得教師分配空間
                long teach = 0;
                var querysp = $"SELECT SUM(c.size) as size FROM c";
                await foreach (var item in db.GetItemQueryStreamIterator(queryText: querysp, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Teacher-{school_code}") }))
                {
                    var jsonts = await JsonDocument.ParseAsync(item.ContentStream);
                    foreach (var obj in jsonts.RootElement.GetProperty("Documents").EnumerateArray())
                    {
                        teach = obj.GetProperty("size").GetInt64() * 1073741824; //G換算
                    }
                }
                ////學校已使用空間
                long blobsize = 0;
                RedisValue value = default;
                value = r8.HashGet($"Blob:Record", $"{school_code}");
                if (value != default && !value.IsNullOrEmpty)
                {
                    JsonElement record = value.ToString().ToObject<JsonElement>();
                    if (record.TryGetInt64(out blobsize))
                    {
                    }
                }
                ////各項空間數值取得
                Dictionary<string, double> catalog = new();
                SortedSetEntry[] Scores = _azureRedis.GetRedisClient(8).SortedSetRangeByScoreWithScores($"Blob:Catalog:{school_code}");
                if (Scores != null)
                {
                    foreach (var score in Scores)
                    {
                        double val = score.Score;
                        string key = score.Element.ToString();
                        catalog.Add(key, val);
                    }
                }
                dynamic space = new ExpandoObject();
                space.size = blobsize;
                space.teach = teach;
                space.catalog = catalog;

                //取得購買紀錄
                List<object> order = await GetOrderHisFromCoreBBAsync(school_code.GetString());

                //取得CC授權使用狀態
                var hashs = await r8.HashGetAllAsync($"CC:License:{school_code.GetString()}");
                var ccuser = hashs.Select(x => JsonDocument.Parse(x.Value.ToString())).ToList();
                return Ok(new { serial = serialResult, service = serviceOrder, hard, space, order , ccuser });
            }
            catch (Exception ex)
            {
                return BadRequest();
            }
        }

        /// <summary>
        /// 取得CoreDevice資訊
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task<List<deviceFromCoreService>> GetDeviceFromCoreAsync(List<deviceForCoreService> uuidList)
        {
            List<deviceFromCoreService> result = new List<deviceFromCoreService>();
            try
            {
                string url = _configuration.GetValue<string>("HaBookAuth:CoreService:deviceinfo");
                string AccessToken = await getCoreAccessToken();
                _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
                string uuidListJson = JsonConvert.SerializeObject(uuidList);
                var content = new StringContent(uuidListJson, Encoding.UTF8, "application/json");
                HttpResponseMessage responseMessage = await _httpClient.PostAsync(url, content);
                if (responseMessage.StatusCode == HttpStatusCode.OK)
                {
                    string responseBody = responseMessage.Content.ReadAsStringAsync().Result;
                    result = System.Text.Json.JsonSerializer.Deserialize<List<deviceFromCoreService>>(responseBody.ToString());
                }
                return result;
            }
            catch (Exception ex)
            {
                return result;
            }
        }

        /// <summary>
        /// 取得CoreBB學校訂單履歷資訊
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task<List<object>> GetOrderHisFromCoreBBAsync(string schoolCode)
        {
            List<object> result = new List<object>();
            try
            {
                string url = _configuration.GetValue<string>("HaBookAuth:CoreBBAPI") + "/ies5/get-school-order";
                string AccessToken = await getCoreAccessToken();
                _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
                string paramJson = JsonConvert.SerializeObject(new { school_code = schoolCode });
                var content = new StringContent(paramJson, Encoding.UTF8, "application/json");
                HttpResponseMessage responseMessage = await _httpClient.PostAsync(url, content);
                if (responseMessage.StatusCode == HttpStatusCode.OK)
                {
                    string responseBody = responseMessage.Content.ReadAsStringAsync().Result;
                    result = System.Text.Json.JsonSerializer.Deserialize<List<object>>(responseBody.ToString());
                }
                return result;
            }
            catch (Exception ex)
            {
                return result;
            }
        }

        private async Task<string> getCoreAccessToken()
        {
            string AccessToken = "";
            try
            {
                string Url = _configuration.GetValue<string>("HaBookAuth:CoreAPI") + "/oauth2/token";
                string GrantType = "device";
                string ClientID = _configuration.GetValue<string>("HaBookAuth:CoreService:clientID");
                string Secret = _configuration.GetValue<string>("HaBookAuth:CoreService:clientSecret");
                var content = new { grant_type = GrantType, client_id = ClientID, client_secret = Secret };
                var response = await _httpClient.PostAsJsonAsync($"{Url}", content);
                if (response.IsSuccessStatusCode)
                {
                    string responseBody = response.Content.ReadAsStringAsync().Result;
                    using (JsonDocument document = JsonDocument.Parse(responseBody.ToString()))
                    {
                        if (document.RootElement.TryGetProperty("access_token", out JsonElement AccessTokenObj))
                        {
                            AccessToken = AccessTokenObj.ToString();
                        }
                    }
                }
                return AccessToken;
            }
            catch (Exception ex)
            {
                return AccessToken;
            }
        }

        /// <summary>
        /// 計算各產品的初始結束時間及可用數
        /// </summary>
        /// <param name="mainPeriodList">active的主周期</param>
        /// <param name="periodList">附屬周期</param>
        /// <param name="serviceProduct">產品資訊</param>
        /// <returns></returns>
        private ServiceProductResult CalServiceProductAuth(List<ServiceMainPeriod> mainPeriodList, List<ServicePeriod> periodList, ServiceProduct serviceProduct)
        {
            periodZone periodZoneResult = new periodZone();
            List<periodZone> periodZone = new List<periodZone>();
            //篩選出產品有的副週期
            List<string> existPeriodIdList = new List<string>();
            if (serviceProduct.auth.Count > 0)
            {
                foreach (ServiceProductAuth serviceProductAuthRow in serviceProduct.auth)
                {
                    if (!string.IsNullOrWhiteSpace(serviceProductAuthRow.periodId) && !existPeriodIdList.Contains(serviceProductAuthRow.periodId))
                    {
                        existPeriodIdList.Add(serviceProductAuthRow.periodId);
                    }
                }
            }
            List<ServicePeriod> periodOrder = periodList.Where(p => existPeriodIdList.Contains(p.periodId)).OrderBy(p => Int32.Parse(p.periodId)).ToList();

            //combine period
            if (periodOrder.Count() > 0)
            {

                //篩選出主週期(複數active主週期對策) ※最終篩出唯一一組 篩選原則：(1)由此產品有的副週期ID篩出 (2)若還有複數筆，則期間長者勝出
                List<string> existMainPeriodIdList = new List<string>();
                foreach (ServicePeriod periodRow in periodOrder)
                {
                    if (!existMainPeriodIdList.Contains(periodRow.mainPeriodId))
                    {
                        existMainPeriodIdList.Add(periodRow.mainPeriodId);
                    }
                }
                ServiceMainPeriod mainPeriod = mainPeriodList.Where(w => existMainPeriodIdList.Contains(w.mainPeriodId)).OrderByDescending(w => w.endDate - w.startDate).First();
                List<ServicePeriod> periods = periodOrder.Where(p => p.mainPeriodId == mainPeriod.mainPeriodId).ToList();

                //combine period，compare to mainPeriod start, end
                periodZone = combinePeriodZone(periods);
                periodZoneResult.startDate = (periodZone[0].startDate > mainPeriod.startDate) ? periodZone[0].startDate : mainPeriod.startDate;
                periodZoneResult.endDate = (periodZone[0].endDate < mainPeriod.endDate) ? periodZone[0].endDate : mainPeriod.endDate;
            }

            //return
            ServiceProductResult serviceProductResult = new ServiceProductResult();
            if ((serviceProduct.noperiod && periodZoneResult.startDate == 0 && periodZoneResult.endDate == 0) || (!serviceProduct.noperiod && periodZoneResult.startDate > 0 && periodZoneResult.endDate > 0))
            {
                serviceProductResult.prodCode = serviceProduct.prodCode;
                serviceProductResult.noperiod = serviceProduct.noperiod;
                serviceProductResult.serviceType = serviceProduct.serviceType;
                serviceProductResult.startDate = periodZoneResult.startDate;
                serviceProductResult.endDate = periodZoneResult.endDate;
                serviceProductResult.avaliable = serviceProduct.avaliable;
            }

            return serviceProductResult;
        }

        /// <summary>
        /// 軟體序號解綁API
        /// </summary>
        /// <param name="id_token">ID Token</param>
        /// <param name="uuid">硬體識別碼1</param>
        /// <param name="uuid2">硬體識別碼2</param>
        /// <param name="serial">產品資訊</param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("unbind-serial")]
        [Authorize(Roles = "IES")]
        [AuthToken(Roles = "admin,teacher")]
        public async Task<IActionResult> UnbindSerial(JsonElement request)
        {
            try
            {
                //輸入參數
                if (!request.TryGetProperty("serial", out JsonElement serialJson)) return BadRequest();
                var (id, name, _, _) = HttpContext.GetAuthTokenInfo(); //取得IDToken資訊

                request.TryGetProperty("uuid", out JsonElement uuidJson);
                request.TryGetProperty("uuid2", out JsonElement uuid2Json);
                string serial = serialJson.ToString();
                string uuid = uuidJson.ToString();
                string uuid2 = uuid2Json.ToString();
                if (string.IsNullOrEmpty(serial) && (string.IsNullOrEmpty(uuid) || string.IsNullOrEmpty(uuid2)))
                {
                    return BadRequest();
                }
                string lang = "en-US";
                var content = new
                {
                    lang = lang,
                    serial = serial,
                    uuid = uuid,
                    uuid2 = uuid2,
                    olduuid = "",
                    pcname = "",
                    dp = "IES5",
                    user = new
                    {
                        id = $"{id}",
                        name = $"{name}"
                    }
                };

                //呼叫BB解綁API
                object result = new { };
                bool unbindFlg = false; //解綁是否成功 true:成功 false:失敗
                string url = _configuration.GetValue<string>("HaBookAuth:CoreBBAPI") + "/bbauthapi/srunbind";
                string AccessToken = await getCoreAccessToken();
                _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
                HttpResponseMessage response = await _httpClient.PostAsJsonAsync(url, content);
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    string responseBody = await response.Content.ReadAsStringAsync();
                    //result = System.Text.Json.JsonSerializer.Deserialize<object>(responseBody.ToString());
                    var unbindResult = JsonDocument.Parse(responseBody);
                    unbindResult.RootElement.TryGetProperty("status", out JsonElement statusJson);
                    int status = statusJson.GetInt32();
                    unbindResult.RootElement.TryGetProperty("error", out JsonElement errorJson);
                    string error = errorJson.GetString();
                    if (unbindResult.RootElement.TryGetProperty("prod", out JsonElement prodJson))
                    {
                        if (!prodJson.ValueKind.Equals(JsonValueKind.Null))
                        {
                            if (prodJson.TryGetProperty("auth_unbind_req", out JsonElement unbindReqJson))
                            {
                                if (!unbindReqJson.ValueKind.Equals(JsonValueKind.Undefined) && !unbindReqJson.ValueKind.Equals(JsonValueKind.Null))
                                {
                                    unbindFlg = true;
                                }
                            }
                        }
                    }
                    result = (unbindFlg) ? new { status = 0, error = "" } : new { status = status, error = error };
                }
                else
                {
                    result = new
                    {
                        status = 1,
                        error = $"Unbind serial: {serial} fail."
                    };
                }
                return Ok(result);
            }
            catch (Exception ex)
            {
                return BadRequest();
            }
        }

        /// <summary>
        /// 計算各產品的購買歷史紀錄 [舊制，不使用]
        /// </summary>
        /// <param name="mainPeriodList">所有的主周期</param>
        /// <param name="periodList">所有附屬周期</param>
        /// <param name="serviceProduct">產品資訊</param>
        /// <returns></returns>
        private List<ServiceProductAuthHistoryStartEnd> CalServiceProductOrderHistory(List<ServiceMainPeriod> mainPeriodList, List<ServicePeriod> periodList, ServiceProduct serviceProduct)
        {
            List<ServiceProductAuthHistoryStartEnd> serviceProductOrderStartEndList = new List<ServiceProductAuthHistoryStartEnd>();

            //GROUP BY orderId
            if (serviceProduct.auth.Count > 0)
            {
                List<ServiceProductAuthHistory> serviceProductOrderList = new List<ServiceProductAuthHistory>();
                foreach (ServiceProductAuth serviceProductAuthRow in serviceProduct.auth)
                {
                    ServiceProductAuthHistory existServiceProductAuthHistory = serviceProductOrderList.Where(a => a.orderId == serviceProductAuthRow.orderId).FirstOrDefault();
                    if (existServiceProductAuthHistory != null)
                    {
                        if (!existServiceProductAuthHistory.periodIdList.Contains(serviceProductAuthRow.periodId))
                        {
                            existServiceProductAuthHistory.periodIdList.Add(serviceProductAuthRow.periodId);
                        }
                    }
                    else
                    {
                        ServiceProductAuthHistory serviceProductAuthHistoryRow = new ServiceProductAuthHistory();
                        serviceProductAuthHistoryRow.orderId = serviceProductAuthRow.orderId;
                        int y = Int32.Parse(serviceProductAuthRow.orderId.Substring(0, 4));
                        int m = Int32.Parse(serviceProductAuthRow.orderId.Substring(4, 2));
                        int d = Int32.Parse(serviceProductAuthRow.orderId.Substring(6, 2));
                        serviceProductAuthHistoryRow.orderDate = new DateTimeOffset(y, m, d, 0, 0, 0, TimeSpan.Zero).ToUnixTimeSeconds();
                        serviceProductAuthHistoryRow.number = serviceProductAuthRow.number;
                        serviceProductAuthHistoryRow.unit = serviceProductAuthRow.unit;
                        serviceProductAuthHistoryRow.periodIdList = new List<string>();
                        serviceProductAuthHistoryRow.periodIdList.Add(serviceProductAuthRow.periodId);
                        serviceProductOrderList.Add(serviceProductAuthHistoryRow);
                    }
                }

                foreach (ServiceProductAuthHistory serviceProductOrderRow in serviceProductOrderList)
                {
                    ServiceProductAuthHistoryStartEnd ServiceProductAuthHistoryStartEndRow = new ServiceProductAuthHistoryStartEnd();
                    //combine period
                    List<ServicePeriod> periodOrder = periodList.Where((ServicePeriod x) => serviceProductOrderRow.periodIdList.Contains(x.periodId)).OrderBy(p => Int32.Parse(p.periodId)).ToList();
                    List<periodZone> periodZone = combinePeriodZone(periodOrder);
                    ServiceProductAuthHistoryStartEndRow.startDate = periodZone[0].startDate;
                    ServiceProductAuthHistoryStartEndRow.endDate = periodZone[0].endDate;
                    ServiceProductAuthHistoryStartEndRow.orderId = serviceProductOrderRow.orderId;
                    ServiceProductAuthHistoryStartEndRow.orderDate = serviceProductOrderRow.orderDate;
                    ServiceProductAuthHistoryStartEndRow.number = serviceProductOrderRow.number;
                    ServiceProductAuthHistoryStartEndRow.unit = serviceProductOrderRow.unit;
                    serviceProductOrderStartEndList.Add(ServiceProductAuthHistoryStartEndRow);
                }
            }
            //return
            return serviceProductOrderStartEndList;
        }

        //子週期合併開始結束時間
        private List<periodZone> combinePeriodZone(List<ServicePeriod> periods)
        {
            List<periodZone> periodZone = new List<periodZone>();
            foreach (ServicePeriod periodRow in periods)
            {
                if (periodZone.Count == 0)
                {
                    periodZone periodZoneNew = new periodZone();
                    periodZoneNew.startDate = periodRow.startDate;
                    periodZoneNew.endDate = periodRow.endDate;
                    periodZone.Add(periodZoneNew);
                }
                else
                {
                    bool zoneExistFlg = false;
                    for (int i = 0; i < periodZone.Count; i++) //考慮到副週期可能斷成數個block，整合後取第一個
                    {
                        if (periodRow.startDate <= periodZone[i].endDate + 10 && periodZone[i].endDate + 10 < periodRow.endDate)
                        {
                            periodZone[i].endDate = periodRow.endDate;
                            zoneExistFlg = true;
                        }
                        else if (periodZone[i].startDate <= periodRow.endDate + 10 && periodRow.endDate + 10 < periodZone[i].endDate)
                        {
                            periodZone[i].startDate = periodRow.startDate;
                            zoneExistFlg = true;
                        }
                    }
                    if (!zoneExistFlg)
                    {
                        periodZone periodZoneNew = new periodZone();
                        periodZoneNew.startDate = periodRow.startDate;
                        periodZoneNew.endDate = periodRow.endDate;
                        periodZone.Add(periodZoneNew);
                    }
                }
            }
            return periodZone;
        }
        /*
        /// <summary>
        /// 取得某學校AClassOne授權及使用資料 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        /// 目前產品DB樣式未定，暫時依照舊樣式建構
        [ProducesDefaultResponseType]
        [HttpPost("get-school-aclassone")]
        public async Task<IActionResult> GetSchoolAclassoneInfo(JsonElement request)
        {
            if (!request.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();

            var clientContainer = _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School");
            var response = await clientContainer.ReadItemStreamAsync(school_code.ToString(), new PartitionKey("Product"));
            int total = 0; //可分配總數
            int staNum = 0; //固定分配數
            int dyncNum = 0; //動態分配數
            List<string> staIds = new List<string>(); //固定分配學生ID列
            List<string> dyncIds = new List<string>(); //動態分配學生ID列
            if (response.Status == 200)
            {
                var json = await JsonDocument.ParseAsync(response.ContentStream);
                if (json.RootElement.TryGetProperty("service", out JsonElement serviceJobj))
                {
                    //取得active主週期
                    List<ServiceMainPeriod> activeMainPeriod = new List<ServiceMainPeriod>();
                    if (serviceJobj.TryGetProperty("mainperiod", out JsonElement mainperiodJobj) && mainperiodJobj.ValueKind != JsonValueKind.Null)
                    {
                        foreach (var mainperiodRow in mainperiodJobj.EnumerateArray())
                        {
                            if (mainperiodRow.GetProperty("active").GetBoolean())
                            {
                                activeMainPeriod.Add(mainperiodRow.ToObject<ServiceMainPeriod>());
                            }
                        }
                    }
                    //取得active主週期的副週期
                    List<ServicePeriod> activePeriodOfMain = new List<ServicePeriod>();
                    if (serviceJobj.TryGetProperty("period", out JsonElement periodJobj) && mainperiodJobj.ValueKind != JsonValueKind.Null)
                    {
                        foreach (var periodRow in periodJobj.EnumerateArray())
                        {
                            foreach (ServiceMainPeriod mainPeriodRow in activeMainPeriod)
                            {
                                if (periodRow.GetProperty("mainPeriodId").ToString() == mainPeriodRow.mainPeriodId)
                                {
                                    activePeriodOfMain.Add(periodRow.ToObject<ServicePeriod>());
                                }
                            }
                        }
                    }
                    //取得AClassOne可用數量
                    if (serviceJobj.TryGetProperty("product", out JsonElement serviceProductJobj) && serviceProductJobj.ValueKind != JsonValueKind.Null)
                    {
                        foreach (var serviceProductRow in serviceProductJobj.EnumerateArray())
                        {
                            //AClassOne買斷、週期
                            string prodCode = serviceProductRow.GetProperty("prodCode").GetString();
                            if (prodCode .Equals("RYGVCPLY") || prodCode .Equals("AEGMCPLY"))
                            {
                                ServiceProductResult serviceProductResultRow = CalServiceProductAuth(activeMainPeriod, activePeriodOfMain, serviceProductRow.ToObject<ServiceProduct>());
                                total += serviceProductResultRow.avaliable;
                            }
                        }
                    }
                    //取得AClassOne固定分配數、動態分配數、固定分配學生ID
                    if (json.RootElement.TryGetProperty("aclassone", out JsonElement aclassoneJobj))
                    {
                        if (aclassoneJobj.ValueKind != JsonValueKind.Null)
                        {
                            if (aclassoneJobj.TryGetProperty("ids", out JsonElement ids) && ids.ValueKind != JsonValueKind.Null)
                            {
                                staIds = System.Text.Json.JsonSerializer.Deserialize<List<string>>(ids.ToJsonString());
                                staNum = staIds.Count;
                            }
                        }
                        dyncIds = GetSchoolDynamicAclassOneIDList(school_code.GetString());
                        dyncNum = dyncIds.Count;
                    }
                }
            }

            return Ok(new { total, staNum, dyncNum, staIds, dyncIds });
        }
        */

        /// <summary>
        /// 取得某學校AClassOne動態可使用數 
        /// </summary>
        public int GetSchoolDynamicAclassOne(string schoolCode)
        {
            try
            {
                int result = 0;
                string key = schoolCode + ":" + "AclassOne" + ":" + "dynamic";
                var redisClient = _azureRedis.GetRedisClient(redisAclassoneDbNum);
                var dyncount = redisClient.StringGet(key);
                if (redisClient.KeyExists(key))
                {
                    result = Int32.Parse(redisClient.StringGet(key));
                }
                return result;
            }
            catch (Exception ex)
            {
                return 0;
            }
        }
        /// <summary>
        /// 取得某學校AClassOne動態已取用的ID List 
        /// </summary>
        public List<string> GetSchoolDynamicAclassOneIDList(string schoolCode)
        {
            string key = schoolCode + ":" + "AclassOne" + ":" + "dynamicIds";
            var redisClient = _azureRedis.GetRedisClient(redisAclassoneDbNum);
            RedisValue[] redisResult = redisClient.SetMembers(key);
            List<string> result = Array.ConvertAll(redisResult, x => (string)x).ToList();
            return result;
        }

        public long GetSchoolDynamicAclassOneIDCount(string schoolCode)
        {
            string key = schoolCode + ":" + "AclassOne" + ":" + "dynamicIds";
            var redisClient = _azureRedis.GetRedisClient(redisAclassoneDbNum);
            long result = redisClient.SetLength(key);
            return result;
        }

        /// <summary>
        /// [測試用]放入某學校的AClassOne動態學生ID 
        /// </summary>
        [ProducesDefaultResponseType]
        [HttpPost("set-school-aclassone-dync")]
        public IActionResult SetSchoolAclassoneDync(JsonElement request)
        {
            if (!request.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
            request.TryGetProperty("student_id", out JsonElement student_id);
            var redisClient = _azureRedis.GetRedisClient(redisAclassoneDbNum);
            string key1 = school_code + ":" + "AclassOne" + ":" + "dynamicIds";
            RedisValue[] redisIdsOriginal = redisClient.SetMembers(key1);
            var resultIdsOriginal = Array.ConvertAll(redisIdsOriginal, x => (string)x).ToList();
            redisClient.SetAdd(key1, student_id.GetString());
            RedisValue[] redisIds = redisClient.SetMembers(key1);
            var resultIds = Array.ConvertAll(redisIds, x => (string)x).ToList();
            string key2 = school_code + ":" + "AclassOne" + ":" + "dynamic";
            if (resultIds.Count > resultIdsOriginal.Count)
            {
                redisClient.StringDecrement(key2, 1);
            }
            string resultCount = redisClient.StringGet(key2);
            return Ok(new { resultIds, resultCount });
        }

        /// <summary>
        /// 設定某學校AClassOne固定分配授權學生
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-school-aclasson-sta")]
        public async Task<IActionResult> SetSchoolAclassoneStatic(JsonElement request)
        {
            if (!request.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
            if (!request.TryGetProperty("student_ids", out JsonElement student_ids)) return BadRequest();
            try
            {
                List<string> studentIds = System.Text.Json.JsonSerializer.Deserialize<List<string>>(student_ids.ToJsonString()); //新的學生ID列

                /* ERROR CODE定義：
                 * 0: 無錯誤
                 * 1: AClassOne授權數不足或無AClassOne授權
                 */
                int status = 0;
                string err = "";
                var clientContainer = _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School");
                var response = await clientContainer.ReadItemStreamAsync(school_code.ToString(), new PartitionKey("Product"));
                if (response.Status == 200)
                {
                    int total = 0; //(回傳值)可分配總數
                    int staNum = 0; //(回傳值)固定分配數
                    int dyncNum = 0; //(回傳值)動態分配數
                    List<string> staIds = new List<string>(); //(回傳值)固定學生ID列
                    List<string> dyncIds = new List<string>(); //(回傳值)動態學生ID列
                    using (Stream stream = response.ContentStream)
                    {
                        using (StreamReader streamReader = new StreamReader(stream))
                        {
                            string content = streamReader.ReadToEnd();
                            SchoolProduct schoolProduct = System.Text.Json.JsonSerializer.Deserialize<SchoolProduct>(content);
                            if (schoolProduct.aclassone != null) //有AClassOne產品授權，schoolProduct.aclassone不會為null
                            {
                                total = schoolProduct.aclassone.total;
                                List<string> studentIdsInDB = schoolProduct.aclassone.ids; //舊的學生ID列
                                int totalInDB = schoolProduct.aclassone.total;
                                //STEP1 驗證所給的ID數是否超過AClassOne總數
                                if (studentIds.Count > totalInDB)
                                {
                                    status = 1;
                                    err = "AclassOne numbers is not enouth.";
                                    return Ok(new { status, err });
                                }
                                //STEP2 將學生ID放入 School.Product.aclassone.ids，更新aclassone.used
                                staIds = schoolProduct.aclassone.ids = studentIds;
                                staNum = schoolProduct.aclassone.used = studentIds.Count;
                                ////Update
                                await clientContainer.ReplaceItemAsync<SchoolProduct>(schoolProduct, schoolProduct.id, new PartitionKey("Product"));
                                //STEP3更新Redis.hbcn:AclassOne:dynamic ※註：只更新動態ID可用數，不更動動態ID列表，所以若可用數為0，當天被動態分配到的學生仍可使用至今日0時才會被清掉
                                int dynamicAclassCount = totalInDB - studentIds.Count; //動態可使用數
                                dyncNum = (int)GetSchoolDynamicAclassOneIDCount(school_code.GetString()); //動態ID已使用數
                                var redisClient = _azureRedis.GetRedisClient(redisAclassoneDbNum);
                                string keys = school_code.GetString() + ":" + "AclassOne" + ":" + "dynamic";
                                int updDynAclassCount = (dynamicAclassCount - dyncNum > 0) ? dynamicAclassCount - dyncNum : 0;
                                redisClient.StringSet(keys, updDynAclassCount);
                                string keyd = school_code.GetString() + ":" + "AclassOne" + ":" + "dynamicIds";
                                RedisValue[] redisIds = redisClient.SetMembers(keyd);
                                dyncIds = Array.ConvertAll(redisIds, x => (string)x).ToList();

                                return Ok(new { status, err, total, staNum, dyncNum, staIds, dyncIds });
                            }
                            else
                            {
                                status = 1;
                                err = "AClassOne has no authorization.";
                                return Ok(new { status, err });
                            }
                        }
                    }
                }
                else
                {
                    return BadRequest();
                }
            }
            catch (Exception ex)
            {
                return BadRequest();
            }
        }

        /// <summary>
        /// 回收某學校AClassOne固定分配、動態分配授權學生
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("recall-school-aclasson")]
        public async Task<IActionResult> RecallSchoolAclassone(JsonElement request)
        {
            if (!request.TryGetProperty("school_code", out JsonElement school_code)) return BadRequest();
            string action = "all"; //預設回收：固定及動態均回收  sta:回收固定 dync:回收動態
            if (request.TryGetProperty("mode", out JsonElement mode))
            {
                if (mode.GetString().Equals("sta") || mode.GetString().Equals("dync"))
                {
                    action = mode.GetString();
                }
            }
            int status = 0;
            string err = "";
            var redisClient = _azureRedis.GetRedisClient(redisAclassoneDbNum);
            string keys = school_code.GetString() + ":" + "AclassOne" + ":" + "dynamic";
            string keyd = school_code.GetString() + ":" + "AclassOne" + ":" + "dynamicIds";
            var clientContainer = _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School");
            var response = await clientContainer.ReadItemStreamAsync(school_code.ToString(), new PartitionKey("Product"));
            if (response.Status == 200)
            {
                int total = 0; //(回傳值)可分配總數
                int staNum = 0; //(回傳值)固定分配數
                int dyncNum = 0; //(回傳值)動態分配數
                List<string> staIds = new List<string>(); //(回傳值)固定學生ID列
                List<string> dyncIds = new List<string>(); //(回傳值)動態學生ID列
                using (Stream stream = response.ContentStream)
                {
                    using (StreamReader streamReader = new StreamReader(stream))
                    {
                        string content = streamReader.ReadToEnd();
                        SchoolProduct schoolProduct = System.Text.Json.JsonSerializer.Deserialize<SchoolProduct>(content);
                        if (schoolProduct.aclassone != null) //有AClassOne產品授權，schoolProduct.aclassone不會為null
                        {
                            total = schoolProduct.aclassone.total;
                            staNum = schoolProduct.aclassone.used;
                            staIds = schoolProduct.aclassone.ids;
                            dyncNum = (int)GetSchoolDynamicAclassOneIDCount(school_code.GetString());
                            dyncIds = GetSchoolDynamicAclassOneIDList(school_code.GetString());
                            switch (action)
                            {
                                case "sta":
                                    staIds = schoolProduct.aclassone.ids = new List<string>();
                                    staNum = schoolProduct.aclassone.used = 0;
                                    await clientContainer.ReplaceItemAsync<SchoolProduct>(schoolProduct, schoolProduct.id, new PartitionKey("Product"));
                                    int updDynAclassCount = (total - dyncNum > 0) ? total - dyncNum : 0;
                                    redisClient.StringSet(keys, updDynAclassCount);
                                    break;
                                case "dync": //動態回收
                                    dyncNum = 0;
                                    dyncIds = new List<string>();
                                    redisClient.StringSet(keys, total - staNum);
                                    redisClient.KeyDelete(keyd);
                                    break;
                                case "all": //全回收
                                    staIds = schoolProduct.aclassone.ids = new List<string>();
                                    staNum = schoolProduct.aclassone.used = 0;
                                    await clientContainer.ReplaceItemAsync<SchoolProduct>(schoolProduct, schoolProduct.id, new PartitionKey("Product"));
                                    dyncNum = 0;
                                    dyncIds = new List<string>();
                                    redisClient.StringSet(keys, total);
                                    redisClient.KeyDelete(keyd);
                                    break;
                            }
                            return Ok(new { status, err, total, staNum, dyncNum, staIds, dyncIds });
                        }
                        else
                        {
                            status = 1;
                            err = "AClassOne has no authorization.";
                            return Ok(new { status, err });
                        }
                    }
                }
            }
            else
            {
                return BadRequest();
            }
        }

        /// <summary>
        /// 教師空間
        /// </summary>
        [ProducesDefaultResponseType]
        [HttpPost("teacher-space")]
        [Authorize(Roles = "IES")]
        public async Task<IActionResult> TeacherSpace(JsonElement request)
        {
            // 必要檢查
            if (!request.TryGetProperty("school_code", out JsonElement code)) return BadRequest();
            if (!request.TryGetProperty("action", out JsonElement type)) return BadRequest();
            long usedSpace = 0;//已被使用的空間量(G)
            School school = null;
            string school_code = code.ToString(); // 學校簡碼
            try
            {
                // [變數宣告]

                string action = type.ToString();  // 功能分類
                string queryText = ""; // 統一sql文記憶體

                // response
                string status = "0";
                string err = "";
                List<string> errTeachers = new List<string>();
                RedisValue value = _azureRedis.GetRedisClient(8).HashGet($"Blob:Record", school_code);
                if (value != default && !value.IsNullOrEmpty)
                {
                    JsonElement record = value.ToString().ToObject<JsonElement>();
                    if (record.TryGetInt64(out usedSpace))
                    {
                    }
                    usedSpace = Convert.ToInt64(Math.Ceiling(usedSpace / bytes));
                }
                else
                {
                    //[學校空間]
                    var blobClient = _azureStorage.GetBlobContainerClient(school_code.ToString());
                    long? docSize = await blobClient.GetBlobsSize("doc");
                    long? videoSize = await blobClient.GetBlobsSize("video");
                    long? imageSize = await blobClient.GetBlobsSize("image");
                    long? paperSize = await blobClient.GetBlobsSize("paper");
                    long? itemSize = await blobClient.GetBlobsSize("item");
                    long? otherSize = await blobClient.GetBlobsSize("other");
                    long? voteSize = await blobClient.GetBlobsSize("vote");
                    long? surveySize = await blobClient.GetBlobsSize("survey");
                    long? audioSize = await blobClient.GetBlobsSize("audio");
                    long? resSize = await blobClient.GetBlobsSize("res");
                    long? tempSize = await blobClient.GetBlobsSize("temp");
                    long? thumSize = await blobClient.GetBlobsSize("thum");
                    long? syllabusSize = await blobClient.GetBlobsSize("syllabus");
                    long? examSize = await blobClient.GetBlobsSize("exam");
                    long? recordsSize = await blobClient.GetBlobsSize("records");
                    long? yxptSize = await blobClient.GetBlobsSize("yxpt");
                    long? trainSize = await blobClient.GetBlobsSize("train");
                    long? homeworkSize = await blobClient.GetBlobsSize("homework");
                    long? avatarSize = await blobClient.GetBlobsSize("avatar");
                    docSize = docSize != null ? docSize : 0;
                    videoSize = videoSize != null ? videoSize : 0;
                    imageSize = imageSize != null ? imageSize : 0;
                    paperSize = paperSize != null ? paperSize : 0;
                    itemSize = itemSize != null ? itemSize : 0;
                    otherSize = otherSize != null ? otherSize : 0;
                    voteSize = voteSize != null ? voteSize : 0;
                    surveySize = surveySize != null ? surveySize : 0;
                    audioSize = audioSize != null ? audioSize : 0;
                    resSize = resSize != null ? resSize : 0;
                    tempSize = tempSize != null ? tempSize : 0;
                    thumSize = thumSize != null ? thumSize : 0;
                    syllabusSize = syllabusSize != null ? syllabusSize : 0;
                    examSize = examSize != null ? examSize : 0;
                    usedSpace = Convert.ToInt64(Math.Ceiling((double)((avatarSize + homeworkSize + trainSize + yxptSize + recordsSize + docSize + videoSize + imageSize + paperSize + itemSize + otherSize + voteSize + audioSize + resSize + tempSize + thumSize + syllabusSize + examSize) / bytes)));
                }
                long avaliable = this.baseSpaceSize; // (G) 目前學校申請空間總數
                long teacherSpace = 0; // 教師可設定的空間量(G)
                school = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(school_code, new PartitionKey("Base"));
                if (school.size <= 0)
                {
                    school.size = baseSpaceSize;
                }
                avaliable = school.size;
                // 取得學校目前的總空間數(G)
                teacherSpace = avaliable - usedSpace;
                List<SchoolTeacher> teachersInschool = new List<SchoolTeacher>();
                switch (action)
                {
                    case "baseSpace": // 現在的教師空間
                        return Ok(new
                        {
                            status,
                            avaliable = avaliable.ToString(),
                            usedSpace = usedSpace.ToString()
                        });
                    case "upd": // 修改教師空間
                                // [二次檢核]

                        if (!request.TryGetProperty("teachers", out JsonElement _teachers)) return BadRequest();
                        List<Teacher> teachers = _teachers.Deserialize<List<Teacher>>();

                        // 教師設定總數
                        int setSpaceTotal = 0;

                        // 教師List

                        var ids = teachers.Select(x => x.id);
                        int notInSpaceTotal = 0;
                        string notinsql = $"select value(sum(c.size)) from c ";
                        if (ids.Any())
                        {
                            notinsql = $"select value(sum(c.size)) from c where c.id  not in ({string.Join(",", ids.Select(o => $"'{o}'"))})";
                        }

                        await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<int>(queryText: notinsql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Teacher-{school_code}") }))
                        {
                            notInSpaceTotal = item;
                            break;
                        }
                        setSpaceTotal = notInSpaceTotal + teachers.Select(x => x.size).Sum();
                        // 檢核總數是否超過
                        if (setSpaceTotal > teacherSpace)
                        {
                            status = "1"; // 要設定的空間總數大於目前學校有的
                            err = $"設定總量({setSpaceTotal}G)超過目前空間({teacherSpace}G)";
                            return Ok(new { status, err });
                        }
                        queryText = $"select * from c where c.id in ({string.Join(",", ids.Select(o => $"'{o}'"))})";

                        await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: queryText, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Teacher-{school_code}") }))
                        {
                            using var jsoncm = await JsonDocument.ParseAsync(item.ContentStream);
                            foreach (var obj in jsoncm.RootElement.GetProperty("Documents").EnumerateArray())
                            {
                                teachersInschool.Add(obj.ToObject<SchoolTeacher>());
                            }
                        }
                        foreach (var obj in teachers)
                        {
                            SchoolTeacher teacher = teachersInschool.Where(t => t.id == obj.id).FirstOrDefault<SchoolTeacher>();
                            int orgTeacherSize = teacher.size;
                            teacher.size = obj.size;
                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<SchoolTeacher>(teacher, obj.id, new PartitionKey($"Teacher-{school_code}"));
                        }
                        return Ok(new { status, err, errTeachers });
                    case "retract": // 收回教師空間
                        // [取得DB資料]
                        queryText = "select * from c ";
                        string record = "0";

                        await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: queryText, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Teacher-{school_code}") }))
                        {
                            using var jsoncm = await JsonDocument.ParseAsync(item.ContentStream);
                            if (jsoncm.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                            {
                                // 修改的筆數
                                record = count.ToString();
                                //List<SchoolTeacher> teachersInschool = new List<SchoolTeacher>();
                                foreach (var obj in jsoncm.RootElement.GetProperty("Documents").EnumerateArray())
                                {
                                    teachersInschool.Add(obj.ToObject<SchoolTeacher>());
                                }

                                foreach (SchoolTeacher teacher in teachersInschool)
                                {
                                    // 修改DB裡School的老師size
                                    int teacherSizeInSchool = teacher.size;
                                    teacher.size = 0;


                                    // 修改DB裡Teacher的size
                                    var response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").ReadItemStreamAsync(teacher.id, new PartitionKey("Base"));
                                    if (response.Status == 200)
                                    {
                                        // var json = await JsonDocument.ParseAsync(response.ContentStream);

                                        //軟體
                                        // Teacher teacherHimself = json.ToObject<Teacher>();
                                        // teacherHimself.size -= teacherSizeInSchool;

                                        // 最後一起修改


                                        //huanghb 2021，7.21修改 ，不用再统计到Teacher-Base中 ，Teacher-Base只记录教师自己的空间大小，并包含其他学校赠与的空间，其他学校的赠与空间放在School 表的Teacher-hbcn（SchoolTeacher）中SchoolTeacher
                                        //，并在教师登陆的时候 一并计算个人空间和总空间大小。其中总空间大小包含（个人空间+多个学校累加的空间大小，并且如果退出或者被移除Teacher-Base 的"schools": [],为空，则已经实现自动回收）
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<SchoolTeacher>(teacher, teacher.id, new PartitionKey($"Teacher-{school_code}"));
                                        //await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync<Teacher>(teacherHimself, teacherHimself.id, new PartitionKey("Base"));
                                    }
                                    else
                                    {
                                        status = "3";
                                        err = "有老師不存在於 Teacher 的DB";
                                    }
                                }
                            }
                        }

                        return Ok(new { status, record });
                    default:
                        return BadRequest(); // 不存在的功能BadRequest
                }
            }
            catch (CosmosException ex)
            {
                await _dingDing.SendBotMsg($"OS，{_option.Location}，schoool/teacher-space\n{ex.Message}\n{ex.StackTrace}\n{request.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
                return BadRequest();
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OS，{_option.Location}，schoool/teacher-space\n{ex.Message}\n{ex.StackTrace}\n{request.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
                return BadRequest();
            }
            finally
            {
                if (school != null)
                {
                    string sql = "select value sum(c.size ) from c  ";
                    int teachSize = 0;
                    await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<int>(queryText: sql,
                        requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Teacher-{school_code}") }))
                    {
                        teachSize += item;
                    }
                    school.tsize = teachSize;
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, school.id, new PartitionKey("Base"));
                }
            }
        }
        [ProducesDefaultResponseType]
        [HttpPost("teacher-import-manage")]
        [Authorize(Roles = "IES")]
        [AuthToken(Roles = "admin,teacher")]
        public async Task<IActionResult> TeacherImportManage(JsonElement request)
        {
            (string adminId, string adminName, string pic, string schoolId) = HttpContext.GetAuthTokenInfo();
            if (!request.TryGetProperty("opt", out JsonElement _opt)) { return BadRequest(); }
            if (!request.TryGetProperty("schoolId", out JsonElement _schoolId)) { return BadRequest(); }
            long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            TeacherImport teacherImport = null;
            List<SchoolTeacher> idsInSchool = new List<SchoolTeacher>();
            List<CoreUser> coreUsers = new List<CoreUser>();
            switch ($"{_opt}")
            {
                case "upsert":
                    if (!request.TryGetProperty("teachers", out JsonElement _teachers) || !_teachers.ValueKind.Equals(JsonValueKind.Array)) { return BadRequest(); }
                    List<ImportTeacher> teachers = _teachers.ToObject<List<ImportTeacher>>();
                    var tmdids = teachers.Where(x => !string.IsNullOrWhiteSpace(x.tmdid)).Select(z => z.tmdid);
                    var phones = teachers.Where(x => !string.IsNullOrWhiteSpace(x.phone)).Select(z => z.phone);
                    var emails = teachers.Where(x => !string.IsNullOrWhiteSpace(x.email)).Select(z => z.email);
                    List<string> keys = new List<string>();
                    if (tmdids.Any())
                    {
                        keys.AddRange(tmdids);
                    }
                    if (phones.Any())
                    {
                        keys.AddRange(phones);
                    }
                    if (emails.Any())
                    {
                        keys.AddRange(emails);
                    }
                    teachers.ForEach(x => { x.status = "import"; x.time = now; x.iname = x.name; x.name = null; });
                    if (keys.Any())
                    {
                        try
                        {
                            var content = new StringContent(keys.ToJsonString(), Encoding.UTF8, "application/json");
                            string json = await _coreAPIHttpService.GetUserInfos(content);
                            if (!string.IsNullOrWhiteSpace(json))
                            {
                                coreUsers = json.ToObject<List<CoreUser>>();
                            }
                        }
                        catch (Exception ex)
                        {
                            await _dingDing.SendBotMsg($"{_option.Location},导入名单时，查验key信息错误{ex.Message}\n{ex.StackTrace}\n\n{keys.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
                        }
                    }
                    if (coreUsers.Any())
                    {
                        string sql = $"select c.id,c.status from c where c.id in ({string.Join(",", coreUsers.Select(x => $"'{x.id}'"))}) ";

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

                    }
                    List<string> inviteids = new List<string>();
                    School schoolBase = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemAsync<School>($"{_schoolId}", new PartitionKey("Base"));
                    if (coreUsers.Any())
                    {
                        foreach (var t in teachers)
                        {
                            if (!string.IsNullOrWhiteSpace(t.tmdid))
                            {
                                CoreUser coreUser = coreUsers.Find(x => x.id.Equals(t.tmdid));
                                if (coreUser != null)
                                {
                                    t.id = coreUser.id;
                                    t.name = coreUser.name;
                                    t.picture = coreUser.picture;
                                    t.tmdid = coreUser.id;
                                    if (!string.IsNullOrWhiteSpace(coreUser.mobile))
                                    {
                                        t.phone = coreUser.mobile;
                                    }
                                    if (!string.IsNullOrWhiteSpace(coreUser.mail))
                                    {
                                        t.email = coreUser.mail;
                                    }
                                }
                            }
                            if (string.IsNullOrWhiteSpace(t.id))
                            {
                                if (!string.IsNullOrWhiteSpace(t.phone))
                                {
                                    CoreUser coreUser = coreUsers.Find(x => !string.IsNullOrWhiteSpace(x.mobile) && x.mobile.Equals(t.phone));
                                    if (coreUser != null)
                                    {
                                        t.id = coreUser.id;
                                        t.name = coreUser.name;
                                        t.picture = coreUser.picture;
                                        t.tmdid = coreUser.id;
                                        if (!string.IsNullOrWhiteSpace(coreUser.mobile))
                                        {
                                            t.phone = coreUser.mobile;
                                        }
                                        if (!string.IsNullOrWhiteSpace(coreUser.mail))
                                        {
                                            t.email = coreUser.mail;
                                        }
                                    }
                                }
                            }
                            if (string.IsNullOrWhiteSpace(t.id))
                            {
                                if (!string.IsNullOrWhiteSpace(t.email))
                                {
                                    CoreUser coreUser = coreUsers.Find(x => !string.IsNullOrWhiteSpace(x.mail) && x.mail.Equals(t.email));
                                    if (coreUser != null)
                                    {
                                        t.id = coreUser.id;
                                        t.name = coreUser.name;
                                        t.picture = coreUser.picture;
                                        t.tmdid = coreUser.id;
                                        if (!string.IsNullOrWhiteSpace(coreUser.mobile))
                                        {
                                            t.phone = coreUser.mobile;
                                        }
                                        if (!string.IsNullOrWhiteSpace(coreUser.mail))
                                        {
                                            t.email = coreUser.mail;
                                        }
                                    }
                                }
                            }
                            if (!string.IsNullOrWhiteSpace(t.id))
                            {
                                SchoolTeacher teacher = idsInSchool.Find(x => x.id.Equals(t.id));
                                if (teacher != null)
                                {
                                    t.status = teacher.status;
                                }
                                else
                                {
                                    t.status = "invite";
                                    teacher = new SchoolTeacher
                                    {
                                        id = t.id,
                                        name = t.name,
                                        permissions = new List<string>(),
                                        picture = t.picture,
                                        job = null,
                                        roles = new List<string> { "teacher" },
                                        status = "invite",
                                        createTime = now,
                                        size = 0,
                                        subjectIds = new List<string>(),
                                        pk = "Teacher",
                                        code = $"Teacher-{_schoolId}"
                                    };
                                    inviteids.Add(t.id);
                                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).CreateItemAsync(teacher, new PartitionKey(teacher.code));
                                    Azure.Response responseTeacher = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(t.id, new PartitionKey("Base"));
                                    if (responseTeacher.Status == 200)
                                    {
                                        Teacher teacherBase = JsonDocument.Parse(responseTeacher.Content).RootElement.Deserialize<Teacher>();
                                        var school = teacherBase.schools?.Find(x => x.schoolId.Equals($"{_schoolId}"));
                                        if (teacherBase.schools.IsNotEmpty())
                                        {
                                            if (school == null)
                                            {
                                                teacherBase.schools.Add(new Teacher.TeacherSchool { schoolId = schoolBase.id, name = schoolBase.name, picture = schoolBase.picture, areaId = schoolBase.areaId, time = now, status = "invite" });
                                            }
                                        }
                                        else
                                        {
                                            teacherBase.schools = new List<Teacher.TeacherSchool> { new Teacher.TeacherSchool { schoolId = schoolBase.id, name = schoolBase.name, picture = schoolBase.picture, areaId = schoolBase.areaId, time = now, status = "invite" } };
                                        }
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReplaceItemAsync(teacherBase, teacherBase.id, new PartitionKey("Base"));
                                    }
                                    else
                                    {
                                        Teacher teacherBase = new Teacher
                                        {
                                            createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                                            id = t.id,
                                            name = t.name,
                                            picture = t.picture,
                                            size = 2,
                                            code = "Base",
                                            pk = "Base",
                                            schools = new List<Teacher.TeacherSchool> {
                                            new Teacher.TeacherSchool {schoolId= schoolBase.id,name= schoolBase.name,picture= schoolBase.picture, areaId= schoolBase.areaId,time=now,status= "invite" },
                                        }
                                        };
                                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher).CreateItemAsync(teacherBase, new PartitionKey("Base"));
                                    }

                                }
                            }
                        }
                    }

                    Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReadItemStreamAsync($"{_schoolId}", new PartitionKey("TeacherImport"));
                    if (response.Status == 200)
                    {
                        teacherImport = JsonDocument.Parse(response.Content).RootElement.Deserialize<TeacherImport>();
                        if (teacherImport != null && teacherImport.teachers.Any())
                        {
                            teachers.ForEach(x =>
                            {
                                ImportTeacher tch = null;
                                if (string.IsNullOrWhiteSpace(x.id))
                                {
                                    tch = teacherImport.teachers.Find(t => t.iname.Equals(x.iname));
                                }
                                else
                                {
                                    tch = teacherImport.teachers.Find(t => !string.IsNullOrWhiteSpace(x.id) && !string.IsNullOrWhiteSpace(t.id) && t.id.Equals(x.id));
                                }
                                if (tch != null)
                                {
                                    tch.time = now;
                                    tch.status = x.status;
                                    tch.name = x.name;
                                    tch.iname = x.iname;
                                    tch.picture = x.picture;
                                    tch.phone = x.phone;
                                    tch.tmdid = x.tmdid;
                                    tch.email = x.email;
                                    tch.note = x.note;
                                    tch.id = x.id;
                                }
                                else
                                {
                                    teacherImport.teachers.Add(new ImportTeacher
                                    {
                                        time = now,
                                        status = x.status,
                                        name = x.name,
                                        iname = x.iname,
                                        picture = x.picture,
                                        phone = x.phone,
                                        tmdid = x.tmdid,
                                        email = x.email,
                                        note = x.note,
                                        id = x.id
                                    });
                                }
                            });
                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync(teacherImport, $"{_schoolId}", new PartitionKey("TeacherImport"));
                        }
                        else
                        {
                            teacherImport = new TeacherImport { id = $"{_schoolId}", code = "TeacherImport", pk = "TeacherImport", teachers = teachers };
                            await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).ReplaceItemAsync(teacherImport, $"{_schoolId}", new PartitionKey("TeacherImport"));
                        }
                    }
                    else
                    {
                        teacherImport = new TeacherImport { id = $"{_schoolId}", code = "TeacherImport", pk = "TeacherImport", teachers = teachers };
                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).CreateItemAsync(teacherImport, new PartitionKey("TeacherImport"));
                    }


                    if (inviteids.Any())
                    {
                        string bizcode = "invite";
                        Notification notification = new Notification
                        {
                            hubName = "hita",
                            type = "msg",
                            from = $"ies5:{_option.Location}:private",
                            to = inviteids.Select(x => x).ToList(),
                            label = $"{bizcode}_school",
                            body = new { location = _option.Location, biz = bizcode, tmdid = adminId, tmdname = adminName, schoolcode = $"{_schoolId}", schoolname = $"{schoolBase.name}", status = 1, time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() }.ToJsonString(),
                            expires = DateTimeOffset.UtcNow.AddDays(7).ToUnixTimeSeconds()
                        };
                        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;
                        var code = await _notificationService.SendNotification(clientID, clientSecret, location, url, notification);
                    }
                    break;
            }
            return Ok(new { teacherImport });

        }
    }
}