TEAMModelOS/TEAMModelOS.FunctionV4/ServiceBus/ActiveTaskTopic.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using Azure.Cosmos;
using Azure.Messaging.ServiceBus;
using Microsoft.Extensions.Logging;
using StackExchange.Redis;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Models.Cosmos;
using TEAMModelOS.SDK.Models.Cosmos.Common;
using System.Linq;
using TEAMModelOS.SDK.Models.Service;
using TEAMModelOS.SDK.Models.Cosmos.BI;
using TEAMModelOS.Models;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Configuration;
using HTEXLib.COMM.Helpers;
using Microsoft.Azure.Functions.Worker;
using TEAMModelOS.SDK.Services;
using Azure.Storage.Blobs.Models;
using System.IO;
using Azure;
using static TEAMModelOS.SDK.Models.Service.LessonService;
using DinkToPdf.Contracts;
using TEAMModelOS.SDK.Helper.Common.DateTimeHelper;
using static TEAMModelOS.SDK.StatisticsService;
using TEAMModelOS.SDK.DI.CoreAPI;
using DocumentFormat.OpenXml.Office2010.Excel;

namespace TEAMModelOS.FunctionV4.ServiceBus
{
    public class ActiveTaskTopic
    {
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly AzureServiceBusFactory _serviceBus;
        private readonly Option _option;
        private readonly NotificationService _notificationService;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        private readonly IConfiguration _configuration;
        private readonly IConverter _converter;
        private readonly SnowflakeId _snowflakeId;
        public ActiveTaskTopic(SnowflakeId snowflakeId, IConverter converter, CoreAPIHttpService coreAPIHttpService, AzureCosmosFactory azureCosmos, DingDing dingDing, AzureStorageFactory azureStorage, AzureRedisFactory azureRedis, AzureServiceBusFactory serviceBus, IOptionsSnapshot<Option> option, NotificationService notificationService, IConfiguration configuration)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
            _serviceBus = serviceBus;
            _option = option?.Value;
            _notificationService = notificationService;
            _configuration = configuration;
            _coreAPIHttpService = coreAPIHttpService;
            _converter = converter;
            _snowflakeId = snowflakeId;
        }
        [Function("Exam")]
        public async Task ExamFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "exam", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                var json = JsonDocument.Parse(msg);
                json.RootElement.TryGetProperty("id", out JsonElement id);
                json.RootElement.TryGetProperty("progress", out JsonElement progress);
                json.RootElement.TryGetProperty("code", out JsonElement code);
                //Dictionary<string, object> keyValuePairs = mySbMsg.ToObject<Dictionary<string, object>>();
                var client = _azureCosmos.GetCosmosClient();
                ExamInfo exam = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<ExamInfo>(id.ToString(), new PartitionKey($"{code}"));
                exam.progress = progress.ToString();
                await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(exam, id.ToString(), new PartitionKey($"{code}"));
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,ExamBus()-CosmosDB异常{e.Message}\n{e.StackTrace}\n{e.Status}\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,ExamBus()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }

        }
        [Function("Vote")]
        public async Task VoteFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "vote", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                var jsonMsg = JsonDocument.Parse(msg);
                jsonMsg.RootElement.TryGetProperty("id", out JsonElement id);
                jsonMsg.RootElement.TryGetProperty("progress", out JsonElement progress);
                jsonMsg.RootElement.TryGetProperty("code", out JsonElement code);
                var client = _azureCosmos.GetCosmosClient();
                Vote vote = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<Vote>(id.ToString(), new PartitionKey($"{code}"));
                vote.progress = progress.ToString();
                await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(vote, id.ToString(), new PartitionKey($"{code}"));
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,VoteBus()-CosmosDB异常{e.Message}\n{e.StackTrace}\n{e.Status}\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,VoteBus()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }

        }
        [Function("Correct")]
        public async Task CorrectFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "correct", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                var jsonMsg = JsonDocument.Parse(msg);
                jsonMsg.RootElement.TryGetProperty("id", out JsonElement id);
                jsonMsg.RootElement.TryGetProperty("progress", out JsonElement progress);
                jsonMsg.RootElement.TryGetProperty("code", out JsonElement code);
                var client = _azureCosmos.GetCosmosClient();
                Correct correct = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<Correct>(id.ToString(), new PartitionKey($"{code}"));
                correct.progress = progress.ToString();
                await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(correct, id.ToString(), new PartitionKey($"{code}"));
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Correct()-CosmosDB异常{e.Message}\n{e.StackTrace}\n{e.Status}\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Correct()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }

        }
        [Function("Survey")]
        public async Task SurveyFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "survey", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                var jsonMsg = JsonDocument.Parse(msg);
                jsonMsg.RootElement.TryGetProperty("id", out JsonElement id);
                jsonMsg.RootElement.TryGetProperty("progress", out JsonElement progress);
                jsonMsg.RootElement.TryGetProperty("code", out JsonElement code);
                //Dictionary<string, object> keyValuePairs = mySbMsg.ToObject<Dictionary<string, object>>();
                var client = _azureCosmos.GetCosmosClient();
                Survey survey = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<Survey>(id.ToString(), new PartitionKey($"{code}"));
                survey.progress = progress.ToString();
                await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(survey, id.ToString(), new PartitionKey($"{code}"));
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,SurveyBus()-CosmosDB异常{e.Message}\n{e.StackTrace}\n{e.Status}\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,SurveyBus()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
        }
        [Function("Homework")]
        public async Task HomeworkFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "homework", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                var jsonMsg = JsonDocument.Parse(msg);
                jsonMsg.RootElement.TryGetProperty("id", out JsonElement id);
                jsonMsg.RootElement.TryGetProperty("progress", out JsonElement progress);
                jsonMsg.RootElement.TryGetProperty("code", out JsonElement code);
                var client = _azureCosmos.GetCosmosClient();
                Homework homework = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<Homework>(id.ToString(), new PartitionKey($"{code}"));
                homework.progress = progress.ToString();
                await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(homework, id.ToString(), new PartitionKey($"{code}"));
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Homework()-CosmosDB异常{e.Message}\n{e.StackTrace}\n{e.Status}\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Homework()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }

        }
        [Function("Study")]
        public async Task StudyFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "study", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            string activityId = string.Empty;
            try
            {
                var jsonMsg = JsonDocument.Parse(msg);
                jsonMsg.RootElement.TryGetProperty("id", out JsonElement id);
                jsonMsg.RootElement.TryGetProperty("progress", out JsonElement progress);
                jsonMsg.RootElement.TryGetProperty("code", out JsonElement code);
                var client = _azureCosmos.GetCosmosClient();
                Study study = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<Study>(id.ToString(), new PartitionKey($"{code}"));
                study.progress = progress.ToString();
                activityId = id.ToString();
                await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(study, id.ToString(), new PartitionKey($"{code}"));
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Study()-CosmosDB异常{e.Message}\n{e.StackTrace}\n{e.Status}\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Study()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }

        }
        [Function("ExamLite")]
        public async Task ExamLiteFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "examlite", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                var jsonMsg = JsonDocument.Parse(msg);
                jsonMsg.RootElement.TryGetProperty("id", out JsonElement id);
                jsonMsg.RootElement.TryGetProperty("progress", out JsonElement progress);
                jsonMsg.RootElement.TryGetProperty("code", out JsonElement code);
                var client = _azureCosmos.GetCosmosClient();
                ExamLite lite = await client.GetContainer(Constant.TEAMModelOS, "Common").ReadItemAsync<ExamLite>(id.ToString(), new PartitionKey($"{code}"));
                lite.progress = progress.ToString();
                await client.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync(lite, id.ToString(), new PartitionKey($"{code}"));
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,ExamLite()-CosmosDB异常{e.Message}\n{e.StackTrace}\n{e.Status}\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,ExamLite()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }

        }

        /// <summary>
        /// 根据容器的根目录刷新redis并获取redis的最新使用情况
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        [Function("BlobRoot")]
        public async Task BlobRootFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "blobroot", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {

                var jsonMsg = JsonDocument.Parse(msg);
                if (jsonMsg.RootElement.TryGetProperty("name", out JsonElement _name) && _name.ValueKind == JsonValueKind.String)
                {
                    if (jsonMsg.RootElement.TryGetProperty("root", out JsonElement root) && root.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace($"{root}"))
                    {
                        List<Dictionary<string, double?>> list = new List<Dictionary<string, double?>>();
                        string[] uls = System.Web.HttpUtility.UrlDecode($"{root}", Encoding.UTF8).Split("/");
                        string u = !string.IsNullOrEmpty(uls[0]) ? uls[0] : uls[1];
                        string name = $"{_name}";
                        string lockKey = $"Blob:Lock:{name}:{u}";
                        bool exist = await _azureRedis.GetRedisClient(8).KeyExistsAsync(lockKey);

                        if (!exist)
                        {   ///key不存在则正常进行计算
                            bool condition = false;
                            TimeSpan timeSpan = new TimeSpan(DateTimeOffset.UtcNow.AddMinutes(5).Ticks);
                            timeSpan = timeSpan - new TimeSpan(DateTimeOffset.UtcNow.Ticks);
                            //准备处理Blob刷新时间
                            long action = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                            await _azureRedis.GetRedisClient(8).StringSetAsync(lockKey, action, expiry: timeSpan);
                            await RefreshBlob(name, u);
                            //将action 与Redis最新的时间进行比较，如果
                            var rds = await CheckLockKey(lockKey, action);
                            condition = rds.condition;
                            exist = rds.exist;
                            if (condition || !exist)
                            {
                                await RefreshBlob(name, u);
                            }

                            //使用  CancellationToken 
                            //while (condition || !exist)
                            //{

                            //}
                        }
                        else
                        {
                            ///key存在则,则刷新key对应的值
                            TimeSpan timeSpan = new TimeSpan(DateTimeOffset.UtcNow.AddMinutes(5).Ticks);
                            timeSpan = timeSpan - new TimeSpan(DateTimeOffset.UtcNow.Ticks);
                            long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                            await _azureRedis.GetRedisClient(8).StringSetAsync(lockKey, now, expiry: timeSpan);
                        }
                    }
                    else
                    {
                        var client = _azureStorage.GetBlobContainerClient($"{_name}");
                        var size = await client.GetBlobsCatalogSize();
                        await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", $"{_name}", size.Item1);
                        foreach (var key in size.Item2.Keys)
                        {
                            await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Blob:Catalog:{_name}", key);
                            await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Blob:Catalog:{_name}", key, size.Item2[key].HasValue ? size.Item2[key].Value : 0);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Blob()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
        }

        private async Task<(bool condition, bool exist)> CheckLockKey(string lockKey, long nowTime)
        {
            //Redis的最新时间
            long newestTime = 0;
            RedisValue value = await _azureRedis.GetRedisClient(8).StringGetAsync(lockKey);
            if (value != default && !value.IsNullOrEmpty)
            {
                JsonElement record = value.ToString().ToObject<JsonElement>();
                if (record.TryGetInt64(out newestTime))
                {
                }
            }
            //说明key已经不存在
            if (newestTime == 0)
            {
                return (false, true);
            }
            //说明key存在
            else
            {
                //说明Redis记录了最新的时间戳
                if (nowTime != newestTime)
                {
                    return (true, false);
                }
                //时间相同，没有被再次记录最新的时间戳
                else
                {
                    await _azureRedis.GetRedisClient(8).KeyDeleteAsync(lockKey);
                    return (false, true);
                }
            }
        }
        private async Task RefreshBlob(string name, string u)
        {
            long statr = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            var client = _azureStorage.GetBlobContainerClient(name);
            var size = await client.GetBlobsSize(u);
            await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Blob:Catalog:{name}", u);
            await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Blob:Catalog:{name}", u, size.HasValue ? size.Value : 0);
            var scores = await _azureRedis.GetRedisClient(8).SortedSetRangeByRankWithScoresAsync($"Blob:Catalog:{name}");
            double blobsize = 0;
            if (scores != default && scores != null)
            {
                foreach (var score in scores)
                {
                    blobsize = blobsize + score.Score;
                }
            }
            await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", new RedisValue(name), new RedisValue($"{blobsize}"));
            long end = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            long dis = (end - statr) / 1000;
            long timeout = 60 * 5;
            if (dis > timeout)
            {
                await _dingDing.SendBotMsg($"ServiceBus,RefreshBlob:空间计算已经超过{timeout}秒\n容器名：{name}\n文件夹：{u}\n计算时长：{dis}", GroupNames.醍摩豆服務運維群組);
            }
        }
        /// <param name="msg"></param>
        /// <returns></returns>
        [Function("TeacherTrainChange")]
        public async Task TeacherTrainChangeFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "teacher-train-change", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            var client = _azureCosmos.GetCosmosClient();
            var data = msg.ToObject<TeacherTrainChangeMsg>();
            List<TeacherTrain> trains = new List<TeacherTrain>();
            //redis锁
            bool lockKey = await _azureRedis.GetRedisClient(8).KeyExistsAsync($"Train:Statistics:Lock:{data.areaId}");
            if (!lockKey)
            {
                await _azureRedis.GetRedisClient(8).SetAddAsync($"Train:Statistics:Lock:{data.areaId}", new RedisValue(data.areaId));
                DateTime minutes = DateTime.UtcNow.AddMinutes(15);   //15分钟 
                await _azureRedis.GetRedisClient(8).KeyExpireAsync($"Train:Statistics:Lock:{data.areaId}", minutes);
                Area area = await client.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemAsync<Area>($"{data.areaId}", new PartitionKey("Base-Area"));
                AreaSetting setting = null;
                if (area != null)
                {
                    try
                    {
                        setting = await client.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemAsync<AreaSetting>(area.id, new PartitionKey("AreaSetting"));
                    }
                    catch (CosmosException)
                    {
                        setting = null;
                    }
                }
                if (setting == null)
                {
                    setting = new AreaSetting
                    {
                        allTime = 50,
                        classTime = 5,
                        submitTime = 15,
                        onlineTime = 20,
                        offlineTime = 10,
                        lessonMinutes = 45,
                    };
                }
                foreach (var school in data.schools)
                {
                    List<Study> studies = new List<Study>();
                    await foreach (var item in client.GetContainer("TEAMModelOS", "Common")
                       .GetItemQueryIterator<Study>(queryText: $"select value(c) from c    where c.owner<>'area'  ", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Study-{school.school}") }))
                    {
                        studies.Add(item);
                    }
                    if (school.teachers.Any())
                    {
                        string trainSql = $"select value(c) from c where c.id in ({string.Join(",", school.teachers.Select(x => $"'{x}'"))}) ";
                        await foreach (var item in client.GetContainer("TEAMModelOS", Constant.Teacher)
                      .GetItemQueryIterator<TeacherTrain>(queryText: trainSql, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"TeacherTrain-{school.school}") }))
                        {
                            trains.Add(item);
                        }
                    }
                    await StatisticsService.GetStatisticsTeacher(trains, setting, area, client, studies);
                }
                area.updateTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                await client.GetContainer(Constant.TEAMModelOS, "Normal").ReplaceItemAsync<Area>(area, $"{data.areaId}", new PartitionKey("Base-Area"));
            }

        }

        /// <param name="msg"></param>
        /// <returns></returns>
        //[Function("TeacherTrainChange")]
        public async Task TeacherTrainChangeFuncBak([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "teacher-train-change", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                TeacherTrainChange change = msg.ToObject<TeacherTrainChange>();
                if (change.update == null || change.update.Count <= 0 || change.tmdids.IsEmpty())
                {
                    return;
                }
                var client = _azureCosmos.GetCosmosClient();
                string insql = $"where c.id in ({string.Join(",", change.tmdids.Select(x => $"'{x}'"))})";
                string selsql = $"select value(c) from c {insql} ";
                List<TeacherTrain> teacherTrains = new List<TeacherTrain>();
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Teacher").GetItemQueryIterator<TeacherTrain>(queryText: selsql,
                      requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"TeacherTrain-{change.school}") }))
                {
                    teacherTrains.Add(item);
                }

                if (change.statistics != 1)
                {
                    List<Task<ItemResponse<TeacherTrain>>> task = new List<Task<ItemResponse<TeacherTrain>>>();
                    teacherTrains.ForEach(x =>
                    {
                        x.update.UnionWith(change.update);
                        task.Add(client.GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync<TeacherTrain>(x, x.id, new PartitionKey($"TeacherTrain-{change.school}")));
                    });
                    await task.TaskPage(5);
                    var unchange = change.tmdids.Except(teacherTrains.Select(x => x.id));
                    if (unchange != null)
                    {
                        task.Clear();
                        unchange.ToList().ForEach(x =>
                        {
                            TeacherTrain teacherTrain = new TeacherTrain
                            {
                                pk = "TeacherTrain",
                                id = x,
                                code = $"TeacherTrain-{change.school}",
                                tmdid = x,
                                school = change.school,
                                update = new HashSet<string> {  StatisticsService.TeacherAbility,
                        StatisticsService.TeacherClass, StatisticsService.OfflineRecord }
                            };
                            teacherTrain.update.UnionWith(change.update);
                            task.Add(client.GetContainer(Constant.TEAMModelOS, "Teacher").UpsertItemAsync<TeacherTrain>(teacherTrain, new PartitionKey($"TeacherTrain-{change.school}")));
                        });
                        await task.TaskPage(1);
                    }
                }
                else
                {
                    Area area = null;
                    string sql = $"select value(c) from c where c.standard='{change.standard}'";
                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Area>(queryText: sql,
                          requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base-Area") }))
                    {
                        area = item;
                    }
                    AreaSetting setting = null;
                    if (area != null)
                    {
                        try
                        {
                            setting = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<AreaSetting>(change.school, new PartitionKey("AreaSetting"));
                        }
                        catch (CosmosException)
                        {
                            try
                            {
                                setting = await client.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemAsync<AreaSetting>(area.id, new PartitionKey("AreaSetting"));
                            }
                            catch (CosmosException)
                            {
                                setting = null;
                            }
                        }
                    }
                    if (setting == null)
                    {
                        setting = new AreaSetting
                        {
                            allTime = 50,
                            classTime = 5,
                            submitTime = 15,
                            onlineTime = 20,
                            offlineTime = 10,
                            lessonMinutes = 45,
                        };
                    }
                    List<Task<TeacherTrain>> task = new List<Task<TeacherTrain>>();
                    teacherTrains.ForEach(x =>
                    {
                        x.update.UnionWith(change.update);
                        task.Add(StatisticsService.StatisticsTeacher(x, setting, area, client, null));
                    });
                    await task.TaskPage(1);
                    var unchange = change.tmdids.Except(teacherTrains.Select(x => x.id));
                    if (unchange != null)
                    {
                        task.Clear();
                        unchange.ToList().ForEach(x =>
                        {
                            task.Add(StatisticsService.StatisticsTeacher(new TeacherTrain
                            {
                                pk = "TeacherTrain",
                                id = x,
                                code = $"TeacherTrain-{change.school}",
                                tmdid = x,
                                school = change.school,
                                update = new HashSet<string> {  StatisticsService.TeacherAbility,
                                StatisticsService.TeacherClass, StatisticsService.OfflineRecord }
                            }, setting, area, client, null));
                        });
                        await task.TaskPage(1);
                    }
                }
            }
            catch (CosmosException ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-研修数据变更，重新统计-TeacherTrainChange\n{msg}\n{ex.Message}\n{ex.StackTrace}\nCosmosException{ex.Status}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-研修数据变更，重新统计-TeacherTrainChange\n{msg}\n{ex.Message}\n{ex.StackTrace}\n", GroupNames.醍摩豆服務運維群組);
            }
        }

        /// <summary>
        /// 完善课程变更,StuListChange,  originCode是学校编码 则表示名单是学校自定义名单，如果是tmdid则表示醍摩豆的私有名单，scope=school,private。
        /// </summary>
        /// <data msg>
        /// CourseChange
        ///// </data>
        /// <param name="msg"></param>
        /// <returns></returns>
        [Function("GroupChange")]
        public async Task GroupChangeFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "group-change", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            var client = _azureCosmos.GetCosmosClient();
            try
            {
                //await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-名单成员变更-GroupChange\n{msg}", GroupNames.醍摩豆服務運維群組);
                var jsonMsg = JsonDocument.Parse(msg);
                GroupChange groupChange = msg.ToObject<GroupChange>();
                //名单变动修改学生课程关联信息
                //await StuListService.FixStuCourse(client, stuListChange);
                //Vote投票 Survey问卷 Exam评测 Learn学习活动 Homework作业活动
                //名单变动修改学生问卷关联信息
                await ActivityService.FixActivity(client, _dingDing, groupChange, "Survey");
                //名单变动修改学生投票关联信息
                await ActivityService.FixActivity(client, _dingDing, groupChange, "Vote");
                //名单变动修改学生评测关联信息
                await ActivityService.FixActivity(client, _dingDing, groupChange, "Exam");
                //名单变动修改学生研修关联信息
                await ActivityService.FixActivity(client, _dingDing, groupChange, "Study");
                //名单变动修改学生简易评测关联信息
                await ActivityService.FixActivity(client, _dingDing, groupChange, "ExamLite");
                //名单变动修改学生作业活动信息
                await ActivityService.FixActivity(client, _dingDing, groupChange, "Homework");
                //TODO学习活动
                //await FixActivity(client, stuListChange, "Learn");

                if (groupChange.type == null || !groupChange.type.Equals("research") || !groupChange.type.Equals("yxtrain") || !groupChange.type.Equals("activity"))
                {
                    //课程名单变动修改学生课程关联信息
                    await ActivityService.FixStuCourse(client, _dingDing, groupChange);
                    //名单变动修改课例关联信息
                    //await ActivityService.FixLessonRecord(client, _dingDing, groupChange);

                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-GroupChange-GroupChange\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
        }
        //接收死信消息
        [Function("ItemCondDel")]
        public async Task ItemCondDelFunc([ServiceBusTrigger("%Azure:ServiceBus:ItemCondQueue%/$DeadLetterQueue", Connection = "Azure:ServiceBus:ConnectionString")] string message)
        {
            await _dingDing.SendBotMsg($"{message}", GroupNames.成都开发測試群組);

        }
        [Function("ItemCond")]
        public async Task ItemCondFunc([ServiceBusTrigger("%Azure:ServiceBus:ItemCondQueue%", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {

            try
            {
                var client = _azureCosmos.GetCosmosClient();
                var jsonMsg = JsonDocument.Parse(msg);
                List<ItemCondDto> itemCondDtos = msg.ToObject<List<ItemCondDto>>();
                foreach (var itemCondDto in itemCondDtos)
                {
                    if (itemCondDto.scope.Equals("school"))
                    {
                        ItemCond itemCond = null;
                        List<ItemInfo> items = new List<ItemInfo>();
                        var queryslt = $"SELECT c.gradeIds,c.subjectId,c.periodId,c.type,c.level,c.field ,c.scope FROM c where   c.periodId='{itemCondDto.filed}' and c.pid= null  ";
                        await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<ItemInfo>(queryText: queryslt, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Item-{itemCondDto.key}") }))
                        {
                            items.Add(item);
                        }
                        itemCond = new ItemCond()
                        {
                            id = $"{itemCondDto.filed}",
                            code = $"ItemCond-{itemCondDto.key}",
                            pk = "ItemCond",
                            ttl = -1,
                            count = items.Count,
                            grades = new List<GradeCount>(),
                            subjects = new List<SubjectItemCount>()
                        };
                        items.ForEach(z =>
                        {
                            if (!string.IsNullOrEmpty(z.type))
                            {
                                ItemService.CountItemCond(z, null, itemCond);
                            }
                        });
                        await _azureRedis.GetRedisClient(8).HashSetAsync($"ItemCond:{itemCondDto.key}", $"{itemCondDto.filed}", itemCond.ToJsonString());
                    }
                    else
                    {
                        ItemCond itemCond = null;
                        List<ItemInfo> items = new List<ItemInfo>();
                        var queryslt = $"SELECT c.gradeIds,c.subjectId,c.periodId,c.type,c.level,c.field ,c.scope FROM c where c.pid= null  ";
                        await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Teacher").GetItemQueryIterator<ItemInfo>(queryText: queryslt, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Item-{itemCondDto.filed}") }))
                        {
                            items.Add(item);
                        }
                        itemCond = new ItemCond() { id = $"{itemCondDto.filed}", code = $"ItemCond", pk = "ItemCond", ttl = -1, count = items.Count };
                        items.ForEach(z =>
                        {
                            if (!string.IsNullOrEmpty(z.type))
                            {
                                ItemService.CountItemCond(z, null, itemCond);
                            }
                        });
                        await _azureRedis.GetRedisClient(8).HashSetAsync($"ItemCond:ItemCond", $"{itemCondDto.filed}", itemCond.ToJsonString());
                    }
                }

            }
            catch (CosmosException ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,ItemCond()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,ItemCond()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
        }
        [Function("GenPdf")]
        public async Task GenPdfFunc([ServiceBusTrigger("%Azure:ServiceBus:GenPdfQueue%", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                var client = _azureCosmos.GetCosmosClient();
                /*                var jsonMsg = JsonDocument.Parse(msg);
                                jsonMsg.RootElement.TryGetProperty("id", out JsonElement id);
                                //jsonMsg.RootElement.TryGetProperty("code", out JsonElement code);*/
                JsonElement element = msg.ToObject<JsonElement>();
                element.TryGetProperty("id", out JsonElement ids);
                List<string> tIds = ids.ToObject<List<string>>();
                element.TryGetProperty("school", out JsonElement _code);
                string code = "";
                element.TryGetProperty("Key", out JsonElement key);
                if (string.IsNullOrWhiteSpace($"{_code}"))
                {
                    code = $"{key}";
                }
                else
                {
                    code = $"{_code}";
                }
                if (string.IsNullOrWhiteSpace(code))
                {
                    await _dingDing.SendBotMsg($"校本研修生成PDF时，学校id为空\n{msg}", GroupNames.成都开发測試群組);
                    return;

                }
                string sname = string.Empty;
                string areaId = string.Empty;
                School school = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>($"{code}", new PartitionKey("Base"));
                sname = school.name;
                areaId = school.areaId;
                //var scquery = $"SELECT c.name,c.areaId from c where c.id = '{code}'";
                //await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: scquery, 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)
                //    {
                //        var accounts = json.RootElement.GetProperty("Documents").EnumerateArray();
                //        while (accounts.MoveNext())
                //        {
                //            JsonElement account = accounts.Current;
                //            sname = account.GetProperty("name").ToString();
                //            areaId = account.GetProperty("areaId").ToString();
                //        }
                //    }
                //}
                if (string.IsNullOrWhiteSpace(areaId))
                {
                    await _dingDing.SendBotMsg($"校本研修生成PDF时，区级id为空\n{msg}", GroupNames.成都开发測試群組);
                    return;
                }
                var blobclient = _azureStorage.GetBlobContainerClient($"teammodelos");
                //查询当前学校所有的校本研修活动
                List<Study> studies = new();
                var query = $"select value(c) FROM c join b in c.teacIds where b in ({string.Join(",", tIds.Select(o => $"'{o}'"))}) and (c.status<>404 or IS_DEFINED(c.status) = false)";
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Common").GetItemQueryIterator<Study>(queryText: query, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Study-{code}") }))
                {
                    studies.Add(item);
                }
                //List<string> tcs = new();
                //foreach (var item in studies)
                //{
                //    foreach (var td in item.tchLists)
                //    {
                //        if (!tcs.Contains(td))
                //        {
                //            tcs.Add(td);
                //        }
                //    }
                //}
                HashSet<string> tcs= studies.SelectMany(x => x.tchLists).Where(y => !string.IsNullOrWhiteSpace(y)).ToHashSet();
                (List<RMember> tchList, List<RGroupList> classInfos) = await GroupListService.GetMemberByListids(_coreAPIHttpService, client, _dingDing, tcs.ToList(), code, null);
                foreach (string id in tIds)
                {
                    StringBuilder stringBuilder = new StringBuilder();
                    string cname = string.Empty;
                    string gname = string.Empty;
                    if (tchList.Exists(c => c.id == id))
                    {
                        gname = tchList.Where(c => c.id == id).FirstOrDefault().groupName;
                        cname = tchList.Where(c => c.id == id).FirstOrDefault().name;
                    }
                    List<string> details = new();
                    foreach (Study study in studies)
                    {
                        if (!study.teacIds.Contains(id))
                        {
                            continue;
                        }
                        var sresponse = await client.GetContainer("TEAMModelOS", "Teacher").ReadItemStreamAsync(study.id, new PartitionKey($"StudyRecord-{id}"));
                        if (sresponse.Status == 200)
                        {
                            var json = await JsonDocument.ParseAsync(sresponse.ContentStream);
                            StudyRecord record = json.ToObject<StudyRecord>();
                            if (record.status == 1)
                            {
                                var start = DateTimeHelper.FromUnixTimestamp(study.startTime).ToString("yyyy/MM/dd");
                                var end = DateTimeHelper.FromUnixTimestamp(study.endTime).ToString("yyyy/MM/dd");
                                string tname = string.Empty;
                                List<string> setName = new();
                                foreach (string setting in study.settings)
                                {
                                    if (setting.Equals("sign"))
                                    {
                                        setName.Add("扫码签到");
                                    }
                                    else if (setting.Equals("hw"))
                                    {
                                        setName.Add("作业提交");
                                    }
                                    else if (setting.Equals("survey"))
                                    {
                                        setName.Add("问卷反馈");
                                    }
                                    else if (setting.Equals("exam"))
                                    {
                                        setName.Add("评测活动");
                                    }
                                }
                                switch (study.type)
                                {
                                    case 1:
                                        tname = "信息化教学案例展示与分享";
                                        break;
                                    case 2:
                                        tname = "专家专题培训";
                                        break;
                                    case 3:
                                        tname = "同课同构";
                                        break;
                                    case 4:
                                        tname = "同课异构";
                                        break;
                                    case 5:
                                        tname = "校本2.0培训";
                                        break;
                                    case 6:
                                        tname = "自定义活动";
                                        break;
                                };
                                stringBuilder.Append($@"<tr>
                                                        <td> {study.topic} </td>
                                                        <td> {tname} </td >
                                                        <td> {study.hour} </td >
                                                        <td> {study.hour} </td >
                                                        <td> {start} 到 {end} </td>
                                                        <td>{study.desc}</td>
                                                        <td> {string.Join("、", setName.Select(x => $"{x}\n"))} </td>
                                                        <td> 已完成 </td >
                                                    </tr> ");
                            }
                            else
                            {
                                continue;
                            }
                        }
                        else
                        {
                            continue;
                        }
                    }
                    string url = await StudyService.GenPdf(id, areaId, cname, sname, gname, stringBuilder.ToString(), _converter, _azureStorage, _dingDing);
                    Azure.Response teacherTrainRes = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemStreamAsync(id, new PartitionKey($"TeacherTrain-{code}"));
                    if (teacherTrainRes.Status == 200)
                    {
                        TeacherTrain teacherTrain = JsonDocument.Parse(teacherTrainRes.Content).RootElement.Deserialize<TeacherTrain>();
                        try
                        {
                            BlobDownloadInfo blobDownload = await blobclient.GetBlobClient(url).DownloadAsync(range: new HttpRange(0, 4 * 1048576), rangeGetContentHash: true);
                            if (blobDownload.Details.ContentHash != null)
                            {

                                string hash = Md5Hash.GetbyteToString(blobDownload.Details.ContentHash);
                                teacherTrain.offlineReport = new Attachment
                                {
                                    hash = hash,
                                    url = url,
                                    blob = $"{blobclient.Uri}/{url}",
                                    extension = "pdf",
                                    name = $"{teacherTrain.nickname}-校本研修汇总报告.pdf",
                                    type = "doc",
                                    size = blobDownload.ContentLength
                                };
                                await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReplaceItemAsync<TeacherTrain>(teacherTrain, id, new PartitionKey($"TeacherTrain-{code}"));
                            }
                        }
                        catch
                        {
                        }
                    }
                }


                /*var query = $"select c.id,c.name,c.type,c.hour,c.startTime,c.endTime,c.presenter,c.topic from c where (c.status<>404 or IS_DEFINED(c.status) = false and array_contains(c.teacIds, '{id}') )";
                await foreach (var item in client.GetContainer("TEAMModelOS", "Common").GetItemQueryIterator<Study>(queryText: query, requestOptions: new QueryRequestOptions() {PartitionKey = new PartitionKey($"Study-{code}") }))
                {
                    studies.Add(item);

                }*/
                //(List<StuActivity> datas, string continuationToken) = await ActivityStudentService.FindActivity(element, null, null, _azureCosmos, _azureRedis);

                // string blob =  await StudyService.GenPdf(cname,sname,gname,"", _converter);

            }
            catch (CosmosException ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,GenPdfFunc()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,GenPdfFunc()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
        }
        //更新學校產品一覽表
        //處理內容：取得所有序號購買紀錄，服務週期、硬體購買紀錄後，更新ProductSum
        [Function("Product")]
        public async Task ProductFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "product", Connection = "Azure:ServiceBus:ConnectionString")] string msg, ILogger log)
        {
            try
            {
                var jsonMsg = JsonDocument.Parse(msg);
                jsonMsg.RootElement.TryGetProperty("method", out JsonElement method);
                jsonMsg.RootElement.TryGetProperty("schoolId", out JsonElement schoolId);
                jsonMsg.RootElement.TryGetProperty("prodCode", out JsonElement prodCode);
                jsonMsg.RootElement.TryGetProperty("prodId", out JsonElement prodId);
                var client = _azureCosmos.GetCosmosClient();
                string strQuery = string.Empty;
                //取得所有學校產品
                ////序號
                List<SchoolProductSumData> serialsProductSumOrg = new List<SchoolProductSumData>();
                strQuery = $"SELECT * FROM c WHERE c.dataType = 'serial'";
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: strQuery, requestOptions: new QueryRequestOptions() { PartitionKey = new Azure.Cosmos.PartitionKey($"Product-{schoolId}") }))
                {
                    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())
                        {
                            SchoolProductSerial serialInfo = obj.ToObject<SchoolProductSerial>();
                            SchoolProductSumData serialProd = serialsProductSumOrg.Where(sp => sp.prodCode == serialInfo.prodCode).FirstOrDefault();
                            if (serialProd == null)
                            {
                                SchoolProductSumData serialProdAdd = new SchoolProductSumData();
                                serialProdAdd.prodCode = serialInfo.prodCode;
                                serialProdAdd.ids.Add(serialInfo.id);
                                serialProdAdd.avaliable = serialProdAdd.ids.Count;
                                serialsProductSumOrg.Add(serialProdAdd);
                            }
                            else
                            {
                                if (!serialProd.ids.Contains(serialInfo.id))
                                {
                                    serialProd.ids.Add(serialInfo.id);
                                }
                                serialProd.avaliable = serialProd.ids.Count;
                            }
                        }
                    }
                }
                ////服務
                List<SchoolProductSumDataService> servicesProductSumOrg = new List<SchoolProductSumDataService>();
                //////取得學校產品 授權週期:授權中 條件: startDate <= now <= endDate
                long timestampToday = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
                string strQueryM = $"SELECT * FROM c WHERE c.dataType = 'servicePeriod' AND c.startDate <= {timestampToday} AND {timestampToday} <= c.endDate AND c.ttl < 0";
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: strQueryM, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Product-{schoolId}") }))
                {
                    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())
                        {
                            SchoolProductServicePeriod servicePeriodInfo = obj.ToObject<SchoolProductServicePeriod>();
                            SchoolProductSumDataService serviceProd = servicesProductSumOrg.Where(sp => sp.prodCode == servicePeriodInfo.prodCode).FirstOrDefault();
                            if (serviceProd == null)
                            {
                                SchoolProductSumDataService serviceProdAdd = new SchoolProductSumDataService();
                                serviceProdAdd.prodCode = servicePeriodInfo.prodCode;
                                serviceProdAdd.avaliable = 0;
                                serviceProdAdd.ids.Add(servicePeriodInfo.id);
                                serviceProdAdd.avaliable += servicePeriodInfo.number;
                                serviceProdAdd.startDate = servicePeriodInfo.startDate;
                                serviceProdAdd.endDate = servicePeriodInfo.endDate;
                                servicesProductSumOrg.Add(serviceProdAdd);
                            }
                            else
                            {
                                serviceProd.ids = new List<string>();
                                serviceProd.ids.Add(servicePeriodInfo.id);
                                serviceProd.startDate = servicePeriodInfo.startDate;
                                serviceProd.endDate = servicePeriodInfo.endDate;
                            }
                        }
                    }

                }
                ////服務產品特別對應項
                School school = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>($"{schoolId}", new PartitionKey("Base")); //學校基本資料取得
                bool updSchool = false; //是否變更學校基本資料
                int chgSchSizeCnt = 0; //變更學校空間的次數 若為0表示現時間點沒有任何空間可使用 => 回復學校空間為初始值
                int schoolDefaultSize = 1; //學校空間初始值:1
                if (!string.IsNullOrWhiteSpace(school.id))
                {
                    if (servicesProductSumOrg.Count > 0)
                    {
                        foreach (SchoolProductSumDataService servicesProductSumOrgRow in servicesProductSumOrg)
                        {
                            //更新學校空間
                            if (servicesProductSumOrgRow.prodCode.Equals("IPALJ6NY"))
                            {
                                school.size = (servicesProductSumOrgRow.avaliable < 1) ? 1 : servicesProductSumOrgRow.avaliable;
                                await client.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, $"{schoolId}", new PartitionKey("Base"));
                                updSchool = true;
                                chgSchSizeCnt++;
                            }
                        }
                    }
                    if (chgSchSizeCnt.Equals(0) && !school.size.Equals(schoolDefaultSize))
                    {
                        school.size = schoolDefaultSize;
                        //updSchool = true; //關於學校空間初始式樣未定，目前暫定：若需要Reset空間，則先維持原空間數不更動
                        updSchool = false;
                    }
                }
                //變更學校基本資料
                if (updSchool)
                {
                    await client.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, $"{schoolId}", new PartitionKey("Base"));
                }

                ////硬體
                List<SchoolProductSumDataHard> hardsProductSumOrg = new List<SchoolProductSumDataHard>();
                strQuery = $"SELECT * FROM c WHERE c.dataType = 'hard'";
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryStreamIterator(queryText: strQuery, requestOptions: new QueryRequestOptions() { PartitionKey = new Azure.Cosmos.PartitionKey($"Product-{schoolId}") }))
                {
                    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())
                        {
                            SchoolProductHard hardInfo = obj.ToObject<SchoolProductHard>();
                            SchoolProductSumData hardProd = hardsProductSumOrg.Where(sp => sp.prodCode == hardInfo.prodCode).FirstOrDefault();
                            if (hardProd == null)
                            {
                                SchoolProductSumDataHard hardProdAdd = new SchoolProductSumDataHard();
                                hardProdAdd.prodCode = hardInfo.prodCode;
                                hardProdAdd.model = hardInfo.model;
                                hardProdAdd.ids.Add(hardInfo.id);
                                hardProdAdd.avaliable = hardProdAdd.ids.Count;
                                hardsProductSumOrg.Add(hardProdAdd);
                            }
                            else
                            {
                                if (!hardProd.ids.Contains(hardInfo.id))
                                {
                                    hardProd.ids.Add(hardInfo.id);
                                }
                                hardProd.avaliable = hardProd.ids.Count;
                            }
                        }
                    }
                }
                //更新學校產品一覽表
                SchoolProductSum prodSum = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<SchoolProductSum>(schoolId.ToString(), new PartitionKey($"ProductSum"));
                prodSum.serial = serialsProductSumOrg;
                prodSum.service = servicesProductSumOrg;
                prodSum.hard = hardsProductSumOrg;
                await client.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<SchoolProductSum>(prodSum, prodSum.id, new PartitionKey($"{prodSum.code}"));
            }
            catch (CosmosException ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Product()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Product()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
        }


        /// <summary>
        /// 批量复制文件
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        [Function("CopyStandardFile")]
        public async Task BatchCopyBlobFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "copy-standard-file", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                //await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-Blob复制文件-CopyStandardFile\n{msg}", GroupNames.醍摩豆服務運維群組);
                var jsonMsg = JsonDocument.Parse(msg);
                BatchCopyFile bIBatchCopyFile = msg.ToObject<BatchCopyFile>();

                //批量复制文件
                var result = await BatchCopyFileService.CopyFile(_dingDing, _azureStorage, bIBatchCopyFile);
                if (result == 200)
                {
                    //发送消息实体
                    Notification notification = new Notification
                    {
                        hubName = "hita",
                        type = "msg",
                        from = $"BI:{_option.Location}:private",
                        to = bIBatchCopyFile.tmdIds,
                        label = $"{bIBatchCopyFile.codeKey}_finish",
                        body = new { location = $"{Environment.GetEnvironmentVariable("Option:Location")}", biz = $"{bIBatchCopyFile.codeKey}", tmdid = $"{bIBatchCopyFile.tmdid}", tmdname = $"{bIBatchCopyFile.tmdName}", 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 = $"{Environment.GetEnvironmentVariable("Option:Location")}";
                    await _notificationService.SendNotification(clientID, clientSecret, location, url, notification); //站内发送消息
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-Blob复制文件-CopyStandardFile\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }
        }
        /// <summary>
        /// 更新开课数据事件
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        [Function("LessonRecordEvent")]
        public async Task LessonRecordFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "lesson-record-event", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            JsonElement data = msg.ToObject<JsonElement>();
            string scope = "";
            string tmdid = "";
            string lessonId;
            string school;
            string tbname;
            string code;
            string blobname;
            List<LessonUpdate> updates = new List<LessonUpdate>();
            //更新课堂记录
            if (data.TryGetProperty("lesson_id", out JsonElement _lessonId) && !string.IsNullOrEmpty($"{_lessonId}"))
            {
                if (!data.TryGetProperty("tmdid", out JsonElement _tmdid)) return;
                if (!data.TryGetProperty("scope", out JsonElement _scope)) return;
                if (!data.TryGetProperty("grant_types", out JsonElement _grant_types)) return;
                data.TryGetProperty("school", out JsonElement _school);
                school = $"{_school}";
                scope = $"{_scope}";
                tmdid = $"{_tmdid}";
                lessonId = $"{_lessonId}";
                updates = _grant_types.ToObject<List<LessonUpdate>>();

            }//创建课堂记录
            else if (data.TryGetProperty("id", out JsonElement _id) && !string.IsNullOrEmpty($"{_id}")
                && data.TryGetProperty("tmdid", out JsonElement _tmdid) && !string.IsNullOrEmpty($"{_tmdid}")
                && data.TryGetProperty("scope", out JsonElement _scope) && !string.IsNullOrEmpty($"{_scope}"))
            {
                data.TryGetProperty("school", out JsonElement _school);
                school = $"{_school}";
                scope = $"{_scope}";
                tmdid = $"{_tmdid}";
                lessonId = $"{_id}";
                updates.Add(new LessonUpdate { grant_type = "create" });
            }//删除课堂记录
            else if (data.TryGetProperty("delete_id", out JsonElement _delete_id) && !string.IsNullOrEmpty($"{_delete_id}")
                && data.TryGetProperty("tmdid", out JsonElement _dtmdid) && !string.IsNullOrEmpty($"{_dtmdid}")
                && data.TryGetProperty("scope", out JsonElement _dscope) && !string.IsNullOrEmpty($"{_dscope}")
                && data.TryGetProperty("opt", out JsonElement _opt) && !string.IsNullOrEmpty($"{_opt}"))
            {
                data.TryGetProperty("school", out JsonElement _dschool);
                school = $"{_dschool}";
                if ($"{_opt}".Equals("delete"))
                {
                    scope = $"{_dscope}";
                    tmdid = $"{_dtmdid}";
                    lessonId = $"{_delete_id}";
                    updates.Add(new LessonUpdate { grant_type = "delete" });
                }
                else { return; }
            }
            else
            {
                return;
            }

            var client = _azureCosmos.GetCosmosClient();

            if ($"{scope}".Equals("school") && !string.IsNullOrEmpty($"{school}"))
            {
                blobname = $"{school}";
                code = $"LessonRecord-{school}";
                tbname = "School";
            }
            else if ($"{scope}".Equals("private"))
            {
                blobname = $"{tmdid}";
                code = $"LessonRecord";
                tbname = "Teacher";
            }
            else
            {
                return;
            }
            LessonDis lessonDis = new LessonDis();
            List<LessonUpdate> msgs = new List<LessonUpdate>();
            try
            {
                LessonRecord oldlessonRecord = null;
                LessonRecord lessonRecord = null;
                Azure.Response response = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemStreamAsync(lessonId, new PartitionKey(code));
                if (response.Status == 200)
                {
                    var doc = JsonDocument.Parse(response.ContentStream);
                    lessonRecord = doc.RootElement.ToObject<LessonRecord>();
                    oldlessonRecord = doc.RootElement.ToObject<LessonRecord>();
                }
                else
                {
                    lessonRecord = null;
                }

                bool isReplace = true;
                if (updates.IsNotEmpty())
                {
                    Teacher teacher = await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemAsync<Teacher>(tmdid, new PartitionKey("Base"));
                    foreach (LessonUpdate update in updates)
                    {
                        switch (update.grant_type)
                        {
                            //更新课堂时长
                            case "up-duration":
                                double.TryParse($"{update.data}", out double duration);
                                lessonRecord.duration = duration;
                                msgs.Add(update);
                                try
                                {
                                    BlobDownloadResult Recording = await _azureStorage.GetBlobContainerClient(blobname).GetBlobClient($"records/{_lessonId}/Record/.Recording.json").DownloadContentAsync();
                                    var RecordingJson = JsonDocument.Parse(new MemoryStream(Encoding.UTF8.GetBytes(Recording.Content.ToString()))).RootElement;
                                    if (RecordingJson.TryGetProperty("duration", out JsonElement _duration) && _duration.ValueKind.Equals(JsonValueKind.Number))
                                    {
                                        var durationFile = double.Parse($"{_duration}");
                                        if (duration < durationFile)
                                        {
                                            lessonRecord.duration = durationFile;
                                        }
                                    }
                                    if (RecordingJson.TryGetProperty("streamUrl", out JsonElement _streamUrl) && !string.IsNullOrWhiteSpace($"{_streamUrl}"))
                                    {
                                        lessonRecord.hasVideo = 1;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    // await _dingDing.SendBotMsg($"{_option.Location}/LessonRecordEvent/课堂记录更新课堂时长出错records/{_lessonId}/Record/.Recording.json\n{ex.Message}\n{ex.StackTrace}{msg}", GroupNames.醍摩豆服務運維群組);
                                }
                                isReplace = true;
                                break;
                            //更新T分
                            case "up-tScore":
                                var tScore = int.Parse($"{update.data}");
                                lessonRecord.tScore = tScore;
                                msgs.Add(update);
                                break;
                            //更新课P分
                            case "up-pScore":
                                var pScore = int.Parse($"{update.data}");
                                lessonRecord.pScore = pScore;
                                msgs.Add(update);
                                break;
                            //更新 学生人数
                            case "up-mCount":
                                var mCount = int.Parse($"{update.data}");
                                lessonRecord.mCount = mCount;
                                msgs.Add(update);
                                break;
                            //更新 议课次数
                            case "up-techCount":
                                var techCount = int.Parse($"{update.data}");
                                lessonRecord.mCount = techCount;
                                msgs.Add(update);
                                break;
                            //更新 基础统计信息
                            case "up-base":
                                //如果有更新 则去读取/{_lessonId}/IES/base.json
                                try
                                {
                                    // await _dingDing.SendBotMsg($"{_option.Location},课堂id:{_lessonId} 收到更新", GroupNames.醍摩豆服務運維群組);
                                    BlobDownloadResult baseblobDownload = await _azureStorage.GetBlobContainerClient(blobname).GetBlobClient($"/records/{_lessonId}/IES/base.json").DownloadContentAsync();
                                    LessonBase lessonBase = baseblobDownload.Content.ToObjectFromJson<LessonBase>();
                                    //await  _dingDing.SendBotMsg($"课例记录文件base.json:{lessonBase.ToJsonString()}", GroupNames.成都开发測試群組);
                                    if (lessonBase != null && lessonBase.summary != null)
                                    {
                                        //lessonRecord.name = lessonBase.summary.activityName;
                                        lessonRecord.attendCount = lessonBase.summary.attendCount;
                                        lessonRecord.clientCount = lessonBase.summary.clientCount;
                                        lessonRecord.attendRate = lessonBase.summary.attendRate;
                                        lessonRecord.groupCount = lessonBase.summary.groupCount;
                                        lessonRecord.collateTaskCount = lessonBase.summary.collateTaskCount;
                                        lessonRecord.collateCount = lessonBase.summary.collateCount;
                                        lessonRecord.pushCount = lessonBase.summary.pushCount;
                                        lessonRecord.totalPoint = lessonBase.summary.totalPoint;
                                        lessonRecord.examQuizCount = lessonBase.summary.examQuizCount;
                                        lessonRecord.interactionCount = lessonBase.summary.interactionCount;
                                        lessonRecord.examPointRate = lessonBase.summary.examPointRate;
                                        lessonRecord.clientInteractionCount = lessonBase.summary.clientInteractionCount;
                                        lessonRecord.clientInteractionAverge = lessonBase.summary.clientInteractionAverge;
                                        lessonRecord.examCount = lessonBase.summary.examCount;
                                        lessonRecord.totalInteractPoint = lessonBase.summary.totalInteractPoint;
                                        lessonRecord.learningCategory = lessonBase.summary.learningCategory;
                                        if (!string.IsNullOrWhiteSpace(lessonRecord.school))
                                        {
                                            lessonBase.student.ForEach(x =>
                                            {
                                                if (string.IsNullOrWhiteSpace(x.school))
                                                {
                                                    x.school = lessonRecord.school;
                                                }
                                            });
                                        }
                                        //LessonStudentRecord lessonStudentRecord = new LessonStudentRecord
                                        //{
                                        //    clientSummaryList = lessonBase.report.clientSummaryList,
                                        //    students = lessonBase.student,
                                        //    name = lessonRecord.name,
                                        //    school = lessonRecord.school,
                                        //    id = lessonRecord.id,
                                        //    scope = lessonRecord.scope,
                                        //    tmdid = lessonRecord.tmdid,
                                        //    code = "LessonStudentRecord",
                                        //    pk = "LessonStudentRecord",
                                        //    courseId =lessonRecord.courseId,
                                        //    groupIds= lessonRecord.groupIds,
                                        //    periodId = lessonRecord.periodId,
                                        //    subjectId = lessonRecord.subjectId,
                                        //};
                                        //await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS,Constant.Student).UpsertItemAsync<LessonStudentRecord>(lessonStudentRecord, new PartitionKey("LessonStudentRecord"));
                                    }
                                    //有上传 base.josn.
                                    lessonRecord.upload = 1;
                                    // await _dingDing.SendBotMsg($"{_option.Location},课堂id:{_lessonId} 更新完成", GroupNames.醍摩豆服務運維群組);

                                    LessonService.DoAutoDeleteSchoolLessonRecord(lessonRecord, scope, client, school, tmdid, teacher, _notificationService, _serviceBus, _azureStorage, _configuration);
                                    long? size = await _azureStorage.GetBlobContainerClient(blobname).GetBlobsSize($"records/{_lessonId}");
                                    Bloblog bloblog = new Bloblog
                                    {
                                        id = lessonRecord.id,
                                        code = $"Bloblog-{blobname}",
                                        name = lessonRecord.name,
                                        pk = "Bloblog",
                                        time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                                        type = "records",
                                        url = $"records/{_lessonId}",
                                        subjectId = string.IsNullOrWhiteSpace(lessonRecord.subjectId) ? new List<string>() : new List<string> { lessonRecord.subjectId },
                                        periodId = string.IsNullOrWhiteSpace(lessonRecord.periodId) ? new List<string>() : new List<string> { lessonRecord.periodId },
                                        size = size.HasValue ? size.Value : 0,
                                    };
                                    await client.GetContainer(Constant.TEAMModelOS, tbname).UpsertItemAsync(bloblog);
                                    var messageBlob = new ServiceBusMessage(new { id = Guid.NewGuid().ToString(), progress = "update", root = "records", name = $"{blobname}" }.ToJsonString()); ;
                                    messageBlob.ApplicationProperties.Add("name", "BlobRoot");
                                    var ActiveTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");
                                    await _serviceBus.GetServiceBusClient().SendMessageAsync(ActiveTask, messageBlob);
                                    //await _dingDing.SendBotMsg($"{_option.Location},课堂id:{_lessonId} blob刷新完成！", GroupNames.醍摩豆服務運維群組);
                                    msgs.Add(update);

                                    DoLessonStudentRecord(_dingDing, _snowflakeId, lessonRecord, scope, client, school, tmdid, teacher, _notificationService, _serviceBus, _azureStorage, _configuration, lessonBase);
                                }
                                catch (Exception ex)
                                {
                                    await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}课程读取base.json,{_lessonId}\n{ex.Message}\n{ex.StackTrace}\n\n{lessonRecord.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
                                }
                                break;
                            //更新 时间线
                            case "up-TimeLine":
                                //BlobDownloadResult TimeLineblobDownload = await _azureStorage.GetBlobContainerClient(blobname).GetBlobClient($"/{_lessonId}/IES/TimeLine.json").DownloadContentAsync();
                                //var timeline = TimeLineblobDownload.Content.ToObjectFromJson<List<LessonTimeLine>>();
                                msgs.Add(update);
                                break;
                            //更新 课堂总览信息
                            case "up-ActivityInfo":
                                //BlobDownloadResult ActivityInfoblobDownload = await _azureStorage.GetBlobContainerClient(blobname).GetBlobClient($"/{_lessonId}/IES/ActivityInfo.json").DownloadContentAsync();
                                //var activityInfos = ActivityInfoblobDownload.Content.ToObjectFromJson<List<LessonActivityInfo>>();
                                msgs.Add(update);
                                break;
                            case "up-baseinfo":///更新基础信息，名称科目，年级，分类等,不能删除 ，由update-lesson-baseinfo 触发。
                                isReplace = true;
                                msgs.Add(update);
                                break;
                            case "up-expire"://消除过期时间,消除后需要取消已经排程的通知订阅
                                try
                                {
                                    var table = _azureStorage.GetCloudTableClient().GetTableReference("ChangeRecord");
                                    List<ChangeRecord> records = await table.FindListByDict<ChangeRecord>(new Dictionary<string, object>() { { "RowKey", lessonRecord.id } });
                                    foreach (var record in records)
                                    {
                                        try
                                        {
                                            await table.DeleteSingle<ChangeRecord>(record.PartitionKey, record.RowKey);
                                            await _serviceBus.GetServiceBusClient().CancelMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), record.sequenceNumber);
                                        }
                                        catch (Exception)
                                        {
                                            continue;
                                        }
                                    }
                                }
                                catch (Exception)
                                {
                                    break;
                                }
                                isReplace = true;
                                msgs.Add(update);
                                break;
                            case "delete":
                                try
                                {
                                    if (lessonRecord.expire > 0)
                                    {
                                        var table = _azureStorage.GetCloudTableClient().GetTableReference("ChangeRecord");
                                        List<ChangeRecord> records = await table.FindListByDict<ChangeRecord>(new Dictionary<string, object>() { { "RowKey", lessonRecord.id } });
                                        foreach (var record in records)
                                        {
                                            try
                                            {
                                                await table.DeleteSingle<ChangeRecord>(record.PartitionKey, record.RowKey);
                                                await _serviceBus.GetServiceBusClient().CancelMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), record.sequenceNumber);
                                            }
                                            catch (Exception)
                                            {
                                                continue;
                                            }
                                        }
                                    }
                                    await _azureStorage.GetBlobServiceClient().DeleteBlobs(_dingDing, blobname, new List<string> { $"records/{_lessonId}" });
                                    await client.GetContainer(Constant.TEAMModelOS, tbname).DeleteItemStreamAsync(lessonRecord.id, new PartitionKey($"Bloblog-{blobname}"));
                                    var messageBlob = new ServiceBusMessage(new { id = Guid.NewGuid().ToString(), progress = "update", root = "records", name = $"{blobname}" }.ToJsonString()); ;
                                    messageBlob.ApplicationProperties.Add("name", "BlobRoot");
                                    var ActiveTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");
                                    await _serviceBus.GetServiceBusClient().SendMessageAsync(ActiveTask, messageBlob);
                                    msgs.Add(update);
                                }
                                catch (CosmosException)
                                {
                                    msgs.Add(update);
                                }
                                lessonRecord = null;
                                isReplace = false;
                                break;
                            case "create":
                                oldlessonRecord = null;
                                //处理课堂选用的课程信息

                                lessonRecord.show = teacher.lessonShow;
                                lessonRecord.upload = 0;
                                if (!string.IsNullOrEmpty(lessonRecord.courseId))
                                {
                                    Course course = null;
                                    try
                                    {
                                        var cresponse = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync(lessonRecord.courseId, new PartitionKey($"Course-{lessonRecord.school}"));
                                        if (cresponse.Status == 200)
                                        {
                                            using var cJson = await JsonDocument.ParseAsync(cresponse.ContentStream);
                                            course = cJson.ToObject<Course>();
                                        }
                                        else
                                        {
                                            var sresponse = await client.GetContainer(Constant.TEAMModelOS, "Teacher").ReadItemStreamAsync(lessonRecord.courseId, new PartitionKey($"Course-{lessonRecord.tmdid}"));
                                            if (sresponse.Status == 200)
                                            {
                                                using var cJson = await JsonDocument.ParseAsync(sresponse.ContentStream);
                                                course = cJson.ToObject<Course>();
                                            }
                                            else
                                            {
                                                course = null;
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-查询课程-CosmosDB异常{ex.Message}\n{ex.StackTrace}\n", GroupNames.醍摩豆服務運維群組);
                                    }
                                    /*catch (CosmosException ex) when (ex.Status != 404)
                                    {
                                        try
                                        {
                                            course = await client.GetContainer(Constant.TEAMModelOS, "Teacher").ReadItemAsync<Course>(lessonRecord.courseId, new PartitionKey($"Course-{lessonRecord.tmdid}"));
                                        }
                                        catch (CosmosException e) when (e.Status != 404)
                                        {
                                            course = null;
                                        }
                                    }*/
                                    if (course != null)
                                    {
                                        lessonRecord.periodId = course.period?.id;
                                        lessonRecord.subjectId = course.subject?.id;
                                    }
                                }
                                //处理课堂选用的名单
                                if (lessonRecord.groupIds.IsNotEmpty())
                                {
                                    HashSet<string> grades = new HashSet<string>();
                                    List<GroupListDto> groups = await GroupListService.GetGroupListByListids(client, _dingDing, lessonRecord.groupIds, lessonRecord.school);

                                    List<GroupListDto> groupLists = groups?.FindAll(x => !string.IsNullOrEmpty(x.periodId) && x.year > 0 && !string.IsNullOrEmpty(x.school));
                                    if (groupLists.IsNotEmpty() && !string.IsNullOrWhiteSpace(lessonRecord.periodId))
                                    {
                                        try
                                        {
                                            var gplist = groupLists.FindAll(x => lessonRecord.groupIds.Contains(x.id));
                                            School schoolObj = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(lessonRecord.school, new PartitionKey("Base"));
                                            //年级算法
                                            var period = schoolObj.period.Find(x => x.id.Equals(lessonRecord.periodId));
                                            int? Count = period?.grades?.Count;
                                            if (Count.HasValue)
                                            {
                                                int Day = DateTimeOffset.UtcNow.Day;
                                                int Month = DateTimeOffset.UtcNow.Month;
                                                int Year = DateTimeOffset.UtcNow.Year;
                                                int start = int.Parse($"{Year}0901");
                                                var se = period.semesters.Find(x => x.start == 1);
                                                if (se == null)
                                                {
                                                    se = period.semesters.First();
                                                }
                                                if (se != null)
                                                {
                                                    string sm = se.month >= 10 ? $"{se.month}" : $"0{se.month}";
                                                    string sd = se.day >= 10 ? $"{se.day}" : $"0{se.day}";
                                                    start = int.Parse($"{Year}{sm}{sd}");
                                                }
                                                int curr = int.Parse(DateTimeOffset.UtcNow.ToString("yyyyMMdd"));
                                                //新学年开学时间大于当前时间，计算年级需要减1   20220901-20220408 > 0 则当前20220408是2021年入学的，
                                                //当前时间大于新学年开学时间，计算年级则不需要  20220901-20221203 < 1 则当前20221203是2022年入学的，
                                                //20230901-20230101 > 0 则当前20230101是2022年入学的，         
                                                int dis = start - curr;
                                                foreach (int year in gplist.Select(x => x.year))
                                                {
                                                    int grade;
                                                    if (dis > 0)
                                                    {
                                                        grade = (Year - year - 1) % Count.Value;
                                                    }
                                                    else
                                                    {
                                                        grade = (Year - year) % Count.Value;
                                                    }
                                                    grades.Add($"{grade}");
                                                }
                                            }
                                        }
                                        catch (CosmosException ex) when (ex.Status == 404)
                                        {

                                        }
                                        catch (Exception ex)
                                        {
                                            await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-处理课堂记录的-年级处理异常{ex.Message}\n{ex.StackTrace}\n\n{lessonRecord.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
                                        }
                                    }
                                    lessonRecord.grade = grades.ToList();
                                }
                                //个人课例保存规则
                                try
                                {
                                    if (scope.Equals("private"))
                                    {
                                        int lessonLimit = teacher.lessonLimit;
                                        //获取已经使用的空间大小
                                        long blobsize = 0;
                                        var value = _azureRedis.GetRedisClient(8).HashGet($"Blob:Record", tmdid);
                                        if (value != default && !value.IsNullOrEmpty)
                                        {
                                            JsonElement record = value.ToString().ToObject<JsonElement>();
                                            if (record.TryGetInt64(out blobsize))
                                            {
                                            }
                                        }
                                        int blobTotal = teacher.size;
                                        blobTotal = teacher.size;
                                        //累加学校分配的空间
                                        foreach (var schoolInfo in teacher.schools)
                                        {
                                            SchoolTeacher st = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<SchoolTeacher>(lessonRecord.tmdid, new PartitionKey($"Teacher-{schoolInfo.schoolId}"));
                                            blobTotal += st.size;
                                        }
                                        //剩余空间大于2G 
                                        if (blobTotal * 1073741824 - blobsize > 2147483648)
                                        {
                                            //大于2G 不限制
                                            lessonLimit = -1;
                                        }
                                        if (lessonLimit != -1)
                                        {

                                            HashSet<string> ids = new HashSet<string>();
                                            //未定义的 以及过期时间小于等于0 的 课例
                                            string private_count_sql = $"select value(c.id) from  c where  ( c.expire<=0 or IS_DEFINED(c.expire) = false  ) and c.tmdid='{tmdid}'  ";
                                            await foreach (var item in client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetItemQueryIterator<string>(
                                                queryText: private_count_sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey(code) }))
                                            {

                                                ids.Add(item);
                                            }

                                            // 220601  收藏不限條數，但空間不足時，僅保留最後一次上傳的課例   （）
                                            //包含收藏的本人的个人课例
                                            //string favorite_count_sql = $"select value(c.id) from  c where c.type='LessonRecord' and c.owner='{tmdid}'   and c.scope='private' ";
                                            //await foreach (var item in client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetItemQueryIterator<string>(
                                            //    queryText: favorite_count_sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"Favorite-{tmdid}") }))
                                            //{
                                            //    ids.Add(item);
                                            //}

                                            //教师个人预设的，可以通过设置的方式增加
                                            int limit = teacher.lessonLimit;
                                            if (teacher.lessonLimit == 0)
                                            {
                                                //未设置的的采用系统设置的默认值50
                                                limit = Constant.private_lesson_limit;
                                            }

                                            if (ids.Count >= limit)
                                            {
                                                LessonRecord lessonRecordExpire = null;
                                                //获取一条最新的 且没有被收藏，且没有被标记为过期的记录，且不是当前触发的id 。
                                                //220712 讨论，将desc去掉，获取最旧的那一笔数据。删除最旧的
                                                string sql = $"SELECT top 1 value(c)  FROM c  where  ( c.expire<=0 or IS_DEFINED(c.expire) = false  ) and  c.tmdid='{tmdid}' " +
                                                    $"and  c.favorite<=0  and c.id<>'{lessonRecord.id}' and c.status<>404  order by c.startTime   ";
                                                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).GetItemQueryIterator<LessonRecord>(
                                                    queryText: sql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey($"{code}") }))
                                                {
                                                    lessonRecordExpire = item; break;
                                                }
                                                if (lessonRecordExpire != null)
                                                {
                                                    // 1-时间戳，7-时间戳
                                                    Dictionary<int, ExpireTag> result = new Dictionary<int, ExpireTag>();
                                                    //暂定7天 
                                                    var now = DateTimeOffset.UtcNow;
                                                    //剩余3天的通知
                                                    //var day3= now.AddDays(Constant.private_lesson_expire - 3).ToUnixTimeMilliseconds();
                                                    //result.Add(3, day3);
                                                    //剩余1天的通知
                                                    var day1 = now.AddDays(Constant.private_lesson_expire - (Constant.private_lesson_expire - 1)).ToUnixTimeMilliseconds();
                                                    result.Add(1, new ExpireTag { expire = day1, tag = "notification" });
                                                    //到期通知

                                                    //不到五点上传的课例，七天之后直接删除。
                                                    int addSecond = 0;
                                                    if (now.Hour > 5)
                                                    {
                                                        // 到凌晨00点还差 (24 - now.Hour) *60 * 60 分钟，再加天数;
                                                        addSecond = Constant.private_lesson_expire * 86400 + (24 - now.Hour) * 3600;
                                                        //再加 00到05小时内的 随机秒数
                                                        Random rand = new Random();
                                                        int randInt = rand.Next(0, 18000);
                                                        addSecond += randInt;
                                                    }
                                                    else
                                                    {
                                                        addSecond = Constant.private_lesson_expire * 24 * 60 * 60;
                                                    }

                                                    lessonRecordExpire.expire = now.AddSeconds(addSecond).ToUnixTimeMilliseconds();
                                                    //result.Add(Constant.private_lesson_expire, lessonRecordExpire.expire);
                                                    result.Add(Constant.private_lesson_expire, new ExpireTag { expire = lessonRecordExpire.expire, tag = "delete" });
                                                    string biz = "expire";
                                                    Notification notification = new Notification
                                                    {
                                                        hubName = "hita",
                                                        type = "msg",
                                                        from = $"ies5:{Environment.GetEnvironmentVariable("Option:Location")}:private",
                                                        to = new List<string> { tmdid },
                                                        label = $"{biz}_lessonRecord",
                                                        body = new
                                                        {
                                                            location = $"{Environment.GetEnvironmentVariable("Option:Location")}",
                                                            biz = biz,
                                                            tmdid = teacher.id,
                                                            tmdname = teacher.name,
                                                            sid = lessonRecordExpire.id,
                                                            sname = lessonRecordExpire.name,
                                                            scope = scope,
                                                            stime = lessonRecordExpire.startTime,
                                                            expire = lessonRecordExpire.expire,
                                                            status = 1,
                                                            //day = Constant.private_lesson_expire,
                                                            time = now
                                                        }.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 = $"{Environment.GetEnvironmentVariable("Option:Location")}";
                                                    await _notificationService.SendNotification(clientID, clientSecret, location, url, notification); //站内发送消息

                                                    var table = _azureStorage.GetCloudTableClient().GetTableReference("ChangeRecord");
                                                    List<ChangeRecord> records = await table.FindListByDict<ChangeRecord>(new Dictionary<string, object>() { { "RowKey", lessonRecordExpire.id } });
                                                    if (records.Count <= 0)
                                                    {
                                                        foreach (var item in result)
                                                        {
                                                            string PartitionKey = string.Format("{0}{1}{2}", lessonRecordExpire.code, "-", $"expire-{item.Key}");
                                                            //课堂的id ,
                                                            //课堂的通知时间类型progress， 默认就会发送一条，到期前一天发送一条，最后已到期发送一条。
                                                            var message = new ServiceBusMessage(new
                                                            {
                                                                id = lessonRecordExpire.id,
                                                                progress = item.Key,
                                                                code = lessonRecordExpire.code,
                                                                scope = lessonRecordExpire.scope,
                                                                school = lessonRecordExpire.school,
                                                                opt = "delete",
                                                                expire = lessonRecordExpire.expire,
                                                                tmdid = tmdid,
                                                                tmdname = teacher.name,
                                                                name = lessonRecordExpire.name,
                                                                startTime = lessonRecordExpire.startTime,
                                                                tag = item.Value.tag
                                                            }.ToJsonString());
                                                            message.ApplicationProperties.Add("name", "LessonRecordExpire");
                                                            long start = await _serviceBus.GetServiceBusClient().SendScheduleMessageAsync(Environment.GetEnvironmentVariable("Azure:ServiceBus:ActiveTask"), message, DateTimeOffset.FromUnixTimeMilliseconds(item.Value.expire));
                                                            ChangeRecord changeRecord = new ChangeRecord
                                                            {
                                                                RowKey = lessonRecordExpire.id,
                                                                PartitionKey = PartitionKey,
                                                                sequenceNumber = start,
                                                                msgId = message.MessageId
                                                            };
                                                            await table.Save<ChangeRecord>(changeRecord);
                                                        }
                                                    }
                                                    await client.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReplaceItemAsync(lessonRecordExpire, lessonRecordExpire.id, new PartitionKey(lessonRecordExpire.code));
                                                }

                                            }
                                        }
                                        else
                                        {
                                            //=-1 则表示不限制上传数量
                                        }
                                    }
                                }
                                catch (Exception e)
                                {
                                    await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-处理课堂记录的-CosmosDB异常{e.Message}\n{e.StackTrace}\n\n{lessonRecord.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
                                }

                                msgs.Add(update);
                                break;
                            default:
                                break;
                        }
                    }
                    //如果被删除则不能再被更新
                    if (isReplace)
                    {
                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, tbname).ReplaceItemAsync<LessonRecord>(lessonRecord, lessonId, new PartitionKey(code));
                    }
                    //计算课堂更新前后的差值
                    lessonDis = LessonService.DisLessonCount(oldlessonRecord, lessonRecord, lessonDis);
                    await LessonService.FixLessonCount(client, _dingDing, lessonRecord, oldlessonRecord, lessonDis);
                }
            }
            catch (CosmosException e)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-更新课堂记录出错-CosmosDB异常{e.Message}\n{e.StackTrace}\n", GroupNames.醍摩豆服務運維群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-更新课堂记录出错\n{ex.Message}\n{ex.StackTrace}\n\n{data}\n{code}\n{updates}\n", GroupNames.醍摩豆服務運維群組);
            }
        }
        [Function("LessonRecordExpire")]
        public async Task LessonRecordExpireFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "lesson-record-expire", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                var jsonMsg = JsonDocument.Parse(msg).RootElement;
                jsonMsg.TryGetProperty("id", out JsonElement id);
                jsonMsg.TryGetProperty("progress", out JsonElement progress);
                jsonMsg.TryGetProperty("code", out JsonElement _code);
                jsonMsg.TryGetProperty("tmdid", out JsonElement tmdid);
                jsonMsg.TryGetProperty("tmdname", out JsonElement tmdname);
                jsonMsg.TryGetProperty("name", out JsonElement name);
                jsonMsg.TryGetProperty("startTime", out JsonElement startTime);
                jsonMsg.TryGetProperty("expire", out JsonElement expire);
                jsonMsg.TryGetProperty("scope", out JsonElement scope);
                jsonMsg.TryGetProperty("school", out JsonElement _school);
                jsonMsg.TryGetProperty("tag", out JsonElement _tag);
                var client = _azureCosmos.GetCosmosClient();
                //处理到期删除
                if (_tag.ValueKind.Equals(JsonValueKind.String) && $"{_tag}".Equals("delete"))
                {
                    string lessonId = $"{id}";
                    string tbname;
                    string school = $"{_school}";
                    string code = "";
                    if ($"{scope}".Equals("school") && !string.IsNullOrEmpty($"{school}"))
                    {
                        code = $"LessonRecord-{school}";
                        tbname = "School";
                    }
                    else if ($"{scope}".Equals("private"))
                    {
                        code = $"LessonRecord";
                        tbname = "Teacher";
                    }
                    else
                    {
                        return;
                    }
                    Azure.Response response = await client.GetContainer(Constant.TEAMModelOS, tbname).ReadItemStreamAsync(lessonId, new PartitionKey(code));
                    if (response.Status == 200)
                    {
                        LessonRecord lessonRecord;
                        var doc = JsonDocument.Parse(response.ContentStream);
                        lessonRecord = doc.RootElement.ToObject<LessonRecord>();
                        lessonRecord.status = 404;
                        await client.GetContainer(Constant.TEAMModelOS, tbname).ReplaceItemAsync(lessonRecord, lessonRecord.id, new PartitionKey(lessonRecord.code));
                        var ActiveTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");
                        var messageChange = new ServiceBusMessage(new { delete_id = lessonId, tmdid = tmdid, scope = scope, opt = "delete", school = school }.ToJsonString());
                        messageChange.ApplicationProperties.Add("name", "LessonRecordEvent");
                        await _serviceBus.GetServiceBusClient().SendMessageAsync(ActiveTask, messageChange);
                        await _dingDing.SendBotMsg($"课例：【{lessonRecord.name}】\n课例ID：【{lessonRecord.id}】\n因时间到期，即将被自动删除,到期时间：" +
                            $"{lessonRecord.expire}\n{lessonRecord.ToJsonString()}", GroupNames.成都开发測試群組);
                    }
                }
                string biz = "expire";
                Notification notification = new Notification
                {
                    hubName = "hita",
                    type = "msg",
                    from = $"ies5:{_option.Location}:private",
                    to = new List<string> { $"{tmdid}" },
                    label = $"{biz}_lessonRecord",
                    body = new
                    {
                        location = $"{Environment.GetEnvironmentVariable("Option:Location")}",
                        biz = biz,
                        tmdid = $"{tmdid}",
                        tmdname = tmdname,
                        sid = $"{id}",
                        sname = $"{name}",
                        stime = long.Parse($"{startTime}"),
                        expire = long.Parse($"{expire}"),
                        status = 1,
                        //day = Constant.private_lesson_expire,
                        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 = $"{Environment.GetEnvironmentVariable("Option:Location")}";
                await _notificationService.SendNotification(clientID, clientSecret, location, url, notification); //站内发送消息
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,LessonRecordExpire()\n{ex.Message}\n{ex.StackTrace}\n\n{msg}", GroupNames.醍摩豆服務運維群組);
            }

        }

        /// <summary>
        /// 完善课程变更
        /// </summary>
        /// <data msg>
        /// CourseChange
        ///// </data>
        /// <param name="msg"></param>
        /// <returns></returns>
        [Function("Course")]
        public async Task CourseFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "course", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            var client = _azureCosmos.GetCosmosClient();
            try
            {
                //await _dingDing.SendBotMsg($"ServiceBus,CourseChange:{msg}", GroupNames.醍摩豆服務運維群組);
                var jsonMsg = JsonDocument.Parse(msg);
                CourseChange courseChange = msg.ToObject<CourseChange>();
                if (courseChange == null)
                {
                    return;
                }
                foreach (var cls in courseChange.addClass)
                {
                    (List<RMember> tchList, List<RGroupList> classLists) = await GroupListService.GetMemberByListids(_coreAPIHttpService, client, _dingDing, new List<string> { cls }, courseChange.school);
                    var addStudentsCls = tchList.FindAll(x => x.type == 2);
                    var addTmdidsCls = tchList.FindAll(x => x.type == 1);
                    foreach (var stu in addStudentsCls)
                    {
                        try
                        {
                            ItemResponse<StuCourse> stuCourse = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{courseChange.school}-{stu.id}"));
                            if (!stuCourse.Value.classId.Contains(cls))
                            {
                                stuCourse.Value.classId.Add(cls);
                            }
                            await client.GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuCourse>(stuCourse, courseChange.id, new PartitionKey($"StuCourse-{courseChange.school}-{stu.id}"));
                        }
                        catch (CosmosException ex)
                        {
                            if (ex.Response.Status == 404)
                            {
                                var course = new StuCourse
                                {
                                    id = courseChange.id,
                                    scode = courseChange.code,
                                    name = courseChange.name,
                                    code = $"StuCourse-{courseChange.school}-{stu.id}",
                                    scope = courseChange.scope,
                                    school = courseChange.school,
                                    creatorId = courseChange.creatorId,
                                    classId = new List<string> { cls },
                                    pk = "StuCourse",
                                    createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
                                };
                                await client.GetContainer(Constant.TEAMModelOS, "Student").CreateItemAsync(course, new PartitionKey(course.code));

                            }
                            else
                            {

                                await _dingDing.SendBotMsg($"OS,{Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -CosmosDB异常\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                            }
                        }
                    }
                    foreach (var tmd in addTmdidsCls)
                    {
                        try
                        {
                            ItemResponse<StuCourse> stuCourse = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));
                            if (!stuCourse.Value.classId.Contains(cls))
                            {
                                stuCourse.Value.classId.Add(cls);
                            }
                            await client.GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuCourse>(stuCourse, courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));
                        }
                        catch (CosmosException ex)
                        {
                            if (ex.Response.Status == 404)
                            {
                                var course = new StuCourse
                                {
                                    id = courseChange.id,
                                    scode = courseChange.code,
                                    name = courseChange.name,
                                    code = $"StuCourse-{tmd.id}",
                                    scope = courseChange.scope,
                                    school = courseChange.school,
                                    creatorId = courseChange.creatorId,
                                    classId = new List<string> { cls },
                                    pk = "StuCourse",
                                    createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
                                };
                                await client.GetContainer(Constant.TEAMModelOS, "Student").CreateItemAsync(course, new PartitionKey(course.code));
                            }
                            else
                            {

                                await _dingDing.SendBotMsg($"OS,{Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -CosmosDB异常\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                            }
                        }
                    }
                }

                foreach (var list in courseChange.addList)
                {
                    (List<RMember> tchList, List<RGroupList> classLists) = await GroupListService.GetMemberByListids(_coreAPIHttpService, client, _dingDing, new List<string> { list }, courseChange.school);
                    var addStudentsCls = tchList.FindAll(x => x.type == 2);
                    var addTmdidsCls = tchList.FindAll(x => x.type == 1);
                    foreach (var stu in addStudentsCls)
                    {
                        try
                        {
                            ItemResponse<StuCourse> stuCourse = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{stu.code}-{stu.id}"));
                            if (!stuCourse.Value.stulist.Contains(list))
                            {
                                stuCourse.Value.stulist.Add(list);
                                await client.GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuCourse>(stuCourse, courseChange.id, new PartitionKey($"StuCourse-{stu.code}-{stu.id}"));
                            }
                        }
                        catch (CosmosException ex)
                        {
                            if (ex.Response.Status == 404)
                            {
                                var course = new StuCourse
                                {
                                    id = courseChange.id,
                                    scode = courseChange.code,
                                    name = courseChange.name,
                                    code = $"StuCourse-{courseChange.school}-{stu.id}",
                                    scope = courseChange.scope,
                                    school = courseChange.school,
                                    creatorId = courseChange.creatorId,
                                    stulist = new List<string> { list },
                                    pk = "StuCourse",
                                    createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
                                };
                                await client.GetContainer(Constant.TEAMModelOS, "Student").CreateItemAsync(course, new PartitionKey(course.code));
                            }
                            else
                            {

                                await _dingDing.SendBotMsg($"OS,{Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -CosmosDB异常\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                            }
                        }
                    }
                    foreach (var tmd in addTmdidsCls)
                    {
                        try
                        {
                            ItemResponse<StuCourse> stuCourse = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));
                            if (!stuCourse.Value.stulist.Contains(list))
                            {
                                stuCourse.Value.stulist.Add(list);
                                await client.GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuCourse>(stuCourse, courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));
                            }

                        }
                        catch (CosmosException ex)
                        {
                            if (ex.Response.Status == 404)
                            {
                                var course = new StuCourse
                                {
                                    id = courseChange.id,
                                    scode = courseChange.code,
                                    name = courseChange.name,
                                    code = $"StuCourse-{tmd.id}",
                                    scope = courseChange.scope,
                                    school = courseChange.school,
                                    creatorId = courseChange.creatorId,
                                    stulist = new List<string> { list },
                                    pk = "StuCourse",
                                    createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
                                };
                                await client.GetContainer(Constant.TEAMModelOS, "Student").CreateItemAsync(course, new PartitionKey(course.code));
                            }
                            else
                            {

                                await _dingDing.SendBotMsg($"OS,{Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -CosmosDB异常\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                            }
                        }
                    }
                }

                foreach (var delCls in courseChange.delClass)
                {
                    (List<RMember> tchList, List<RGroupList> classLists) = await GroupListService.GetMemberByListids(_coreAPIHttpService, client, _dingDing, new List<string> { delCls }, courseChange.school);
                    var delStudentsCls = tchList.FindAll(x => x.type == 2);
                    var delTmdidsCls = tchList.FindAll(x => x.type == 1);
                    foreach (var stu in delStudentsCls)
                    {
                        try
                        {
                            ItemResponse<StuCourse> stuCourse = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{courseChange.school}-{stu.id}"));

                            if (stuCourse.Value.classId.Contains(delCls))
                            {
                                stuCourse.Value.classId.Remove(delCls);
                            }

                            if (!stuCourse.Value.classId.IsNotEmpty() && !stuCourse.Value.stulist.IsNotEmpty())
                            {
                                //当两个列表都不存在时则直接删除
                                await client.GetContainer(Constant.TEAMModelOS, "Student").DeleteItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{courseChange.school}-{stu.id}"));
                            }
                            else
                            {
                                await client.GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuCourse>(stuCourse, courseChange.id, new PartitionKey($"StuCourse-{courseChange.school}-{stu.id}"));
                            }

                        }
                        catch (CosmosException ex)
                        {
                            //await _dingDing.SendBotMsg($"OS,{ Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -CosmosDB异常\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                        }
                    }
                    foreach (var tmd in delTmdidsCls)
                    {
                        try
                        {
                            ItemResponse<StuCourse> stuCourse = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));

                            if (stuCourse.Value.classId.Contains(delCls))
                            {
                                stuCourse.Value.classId.Remove(delCls);
                            }

                            if (!stuCourse.Value.classId.IsNotEmpty() && !stuCourse.Value.stulist.IsNotEmpty())
                            {
                                //当两个列表都不存在时则直接删除
                                await client.GetContainer(Constant.TEAMModelOS, "Student").DeleteItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));
                            }
                            else
                            {
                                await client.GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuCourse>(stuCourse, courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));
                            }

                        }
                        catch (CosmosException ex)
                        {
                            await _dingDing.SendBotMsg($"OS,{Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -CosmosDB异常\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                        }
                    }
                }
                foreach (var delList in courseChange.delList)
                {
                    (List<RMember> tchList, List<RGroupList> classLists) = await GroupListService.GetMemberByListids(_coreAPIHttpService, client, _dingDing, new List<string> { delList }, courseChange.school);
                    var delStudentsCls = tchList.FindAll(x => x.type == 2);
                    var delTmdidsCls = tchList.FindAll(x => x.type == 1);
                    foreach (var stu in delStudentsCls)
                    {
                        try
                        {
                            ItemResponse<StuCourse> stuCourse = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{courseChange.school}-{stu.id}"));
                            if (stuCourse.Value.stulist.Contains(delList))
                            {
                                stuCourse.Value.stulist.Remove(delList);
                            }

                            if (!stuCourse.Value.classId.IsNotEmpty() && !stuCourse.Value.stulist.IsNotEmpty())
                            {
                                //当两个列表都不存在时则直接删除
                                await client.GetContainer(Constant.TEAMModelOS, "Student").DeleteItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{courseChange.school}-{stu.id}"));
                            }
                            else
                            {
                                await client.GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuCourse>(stuCourse, courseChange.id, new PartitionKey($"StuCourse-{courseChange.school}-{stu.id}"));
                            }

                        }
                        catch (CosmosException ex)
                        {
                            continue;
                            // await _dingDing.SendBotMsg($"OS,{ Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -CosmosDB异常\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                        }
                    }
                    foreach (var tmd in delTmdidsCls)
                    {
                        try
                        {
                            ItemResponse<StuCourse> stuCourse = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));

                            if (stuCourse.Value.stulist.Contains(delList))
                            {
                                stuCourse.Value.stulist.Remove(delList);
                            }

                            if (!stuCourse.Value.classId.IsNotEmpty() && !stuCourse.Value.stulist.IsNotEmpty())
                            {
                                //当两个列表都不存在时则直接删除
                                await client.GetContainer(Constant.TEAMModelOS, "Student").DeleteItemAsync<StuCourse>(courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));
                            }
                            else
                            {
                                await client.GetContainer(Constant.TEAMModelOS, "Student").ReplaceItemAsync<StuCourse>(stuCourse, courseChange.id, new PartitionKey($"StuCourse-{tmd.id}"));
                            }

                        }
                        catch (CosmosException ex)
                        {
                            await _dingDing.SendBotMsg($"OS,{Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -CosmosDB异常\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"OS,{Environment.GetEnvironmentVariable("Option:Location")},CourseServiceBus -Course\n{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
            }
        }

        [Function("Imei")]
        public async Task ImeiFunc([ServiceBusTrigger("%Azure:ServiceBus:ActiveTask%", "imei", Connection = "Azure:ServiceBus:ConnectionString")] string msg)
        {
            try
            {
                await _dingDing.SendBotMsg($"IES5，{_option.Location}，Imei AF call\n{msg.ToJsonString()}", GroupNames.成都开发測試群組);
                using var json = JsonDocument.Parse(msg);
                if (json.RootElement.TryGetProperty("channel", out JsonElement channel) &&
                    json.RootElement.TryGetProperty("userid", out JsonElement userid) &&
                    json.RootElement.TryGetProperty("school", out JsonElement school) &&
                    json.RootElement.TryGetProperty("stus", out JsonElement stus))
                {
                    var db = _azureCosmos.GetCosmosClient();
                    foreach (var stu in stus.EnumerateArray())
                    {
                        await foreach (Response item in db.GetContainer(Constant.TEAMModelOS, Constant.Student).GetItemQueryStreamIterator(
                            queryText: $"SELECT TOP 1 * FROM c WHERE c.stuid = '{stu.GetString()}'",
                            requestOptions: new() { PartitionKey = new($"Imei") }))
                        {
                            using var root = await JsonDocument.ParseAsync(item.ContentStream);
                            if (root.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetUInt16() > 0)
                            {
                                var doc = root.RootElement.GetProperty("Documents").EnumerateArray().First();
                                var imei = doc.ToObject<Imei>();
                                imei.channel = channel.GetString();
                                imei.userid = userid.GetString();
                                await db.GetContainer(Constant.TEAMModelOS, Constant.Student).ReplaceItemAsync<Imei>(imei, imei.id);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"IES5，{_option.Location}，Imei AF error\n{ex.Message}\n{ex.StackTrace}{msg.ToJsonString()}", GroupNames.醍摩豆服務運維群組);
            }
        }
    }
}