TEAMModelOS/TEAMModelOS.FunctionV4/HttpTrigger/BIHttpTrigger.cs

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
using Azure.Cosmos;
using Azure.Storage.Blobs;
using DocumentFormat.OpenXml.Bibliography;
using MathNet.Numerics.LinearAlgebra.Double;
using Microsoft.AspNetCore.Http;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using NUnit.Framework.Constraints;
using StackExchange.Redis;
using TEAMModelOS.SDK.Context.Constant;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Models.Cosmos.BI;
using TEAMModelOS.SDK.Models.Cosmos.BI.BISchool;
using TEAMModelOS.SDK.Models.Service.BI;
using TEAMModelOS.SDK.Models.Service.BIStatsWay;

namespace TEAMModelOS.FunctionV4.HttpTrigger
{
    public class BIHttpTrigger
    {
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;

        public BIHttpTrigger(AzureCosmosFactory azureCosmos, DingDing dingDing, AzureStorageFactory azureStorage, AzureRedisFactory azureRedis)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _azureStorage = azureStorage;
            _azureRedis = azureRedis;
        }

        /// <summary>
        /// 学校信息BI中间件更新
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [Function("set-sc-birelation")]
        public async Task<HttpResponseData> upSchoolBIRelation([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestData req)
        {
            var response = req.CreateResponse(HttpStatusCode.OK);
            dynamic jsondata = new ExpandoObject();
            try
            {
                var cosmosClient = _azureCosmos.GetCosmosClient();
                var tableClient = _azureStorage.GetCloudTableClient();
                var blobClient = _azureStorage.GetBlobContainerClient(containerName: "0-public");

                string data = await new StreamReader(req.Body).ReadToEndAsync();
                var json = JsonDocument.Parse(data).RootElement;
                School school = new();
                jsondata = json;
                if (json.TryGetProperty("school", out JsonElement _school))
                {
                    school = _school.ToObject<School>();
                }
                string type = "";

                BIRelation bIRelation = new();
                var resBiRel =  await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync(school.id, new PartitionKey("BIRel"));
                if (resBiRel.Status == 200)
                {
                    using var fileJson = await JsonDocument.ParseAsync(resBiRel.ContentStream);
                    bIRelation = fileJson.ToObject<BIRelation>();

                }
                else
                    bIRelation.id = school.id;

                string aName = null;
                if (!string.IsNullOrEmpty($"{school.areaId}"))
                    aName = await CosmosQueryHelper.GetStr(cosmosClient, "Normal", $"select value(c.name) from c where c.id='{school.areaId}'", "Base-Area");
                bIRelation.name = school.name;
                bIRelation.picture = school.picture;
                bIRelation.region = school.region;
                bIRelation.province = school.province;
                bIRelation.city = school.city;
                bIRelation.dist = school.dist;
                bIRelation.address = school.address;
                bIRelation.areaId = school.areaId;
                bIRelation.size = school.size;
                bIRelation.scale = school.scale;
                bIRelation.upDate = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                bIRelation.areaName = aName;

                if (resBiRel.Status == 200)
                {
                    await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<BIRelation>(bIRelation, bIRelation.id, new PartitionKey("BIRel"));
                    type = "update";
                }
                else
                {
                    await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<BIRelation>(bIRelation, new PartitionKey("BIRel"));
                    type = "add";
                }

                //保存操作记录
                await AzureStorageBlobExtensions.SaveBILog(blobClient, tableClient, $"birelation-{type}", $"触发更新学校信息表中间件", _dingDing);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"stats-sc-info,{ex.Message}\n{ex.StackTrace}\n{jsondata.ToJsonString()}", GroupNames.成都开发測試群組);
            }

            return response;
        }

        /// <summary>
        /// 统计学校的信息
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [Function("stats-sc-info")]
        public async Task<HttpResponseData> StatsSchoolInfo([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestData req)
        {
            var response = req.CreateResponse(HttpStatusCode.OK);

            dynamic jsondata = new ExpandoObject();
            try
            {
                string scId = null;
                var cosmosClient = _azureCosmos.GetCosmosClient();
                var tableClient = _azureStorage.GetCloudTableClient();
                var blobClient = _azureStorage.GetBlobContainerClient(containerName: "0-public");
                string data = await new StreamReader(req.Body).ReadToEndAsync();
                var json = JsonDocument.Parse(data).RootElement;
                jsondata = json;
                if (json.TryGetProperty("schoolId", out JsonElement _schoolId))
                {
                    scId = $"{_schoolId}";
                }
                if (string.IsNullOrEmpty(scId))
                {
                    return response;
                }

                bool locKey = await _azureRedis.GetRedisClient(8).KeyExistsAsync($"Train:Statistics:Lock:{scId}");
                if (!locKey)
                {
                    await _azureRedis.GetRedisClient(8).SetAddAsync($"Train:Statistics:Lock:{scId}", new RedisValue(scId));
                    DateTime minutes = DateTime.UtcNow.AddMinutes(15);   //15分钟
                    await _azureRedis.GetRedisClient(8).KeyExpireAsync($"Train:Statistics:Lock:{scId}", minutes);

                    bool isExist = true;
                    StatsInfo statsInfo = new();
                    var scDataStats = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{scId}", new PartitionKey("Stats"));
                    if (scDataStats.Status == 200)
                    {
                        using var fileJson = await JsonDocument.ParseAsync(scDataStats.ContentStream);
                        statsInfo = fileJson.ToObject<StatsInfo>();
                    }
                    else                    
                        isExist = false;

                    statsInfo = await SchoolStatsWay.GetSingleSc(cosmosClient, scId);
                    statsInfo.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

                    if (isExist)
                        statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<StatsInfo>(statsInfo, statsInfo.id, new PartitionKey("Stats"));
                    else
                        statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<StatsInfo>(statsInfo, new PartitionKey("Stats"));
                }

                //保存操作记录
                await AzureStorageBlobExtensions.SaveBILog(blobClient, tableClient, "trigger-schoolStats", $"触发更新统计数据库", _dingDing);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"stats-sc-info,{ex.Message}\n{ex.StackTrace}\n{jsondata.ToJsonString()}", GroupNames.成都开发測試群組);
            }

            return response;
        }

        /// <summary>
        /// 处理传过来的信息加入到统计信息中
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [Function("set-scstats-type")]
        public async Task<HttpResponseData> SetSchoolStatsType([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestData req) 
        {
            var response = req.CreateResponse(HttpStatusCode.OK);
            dynamic jsondata = new ExpandoObject();
            try
            {
                string data = await new StreamReader(req.Body).ReadToEndAsync();
                var json = JsonDocument.Parse(data).RootElement;
                jsondata = json;

                string scId = null, type = null;
                var cosmosClient = _azureCosmos.GetCosmosClient();
                var tableClient = _azureStorage.GetCloudTableClient();
                var blobClient = _azureStorage.GetBlobContainerClient(containerName: "0-public");
                long careDate = 0;
                int all = 0;

                DateTimeOffset dateOff = DateTimeOffset.UtcNow;
                if (json.TryGetProperty("scId", out JsonElement _schoolId))
                    scId = $"{_schoolId}";
                if (json.TryGetProperty("type", out JsonElement _type))
                    type = $"{_type}";
                if (string.IsNullOrEmpty($"{_schoolId}") && string.IsNullOrEmpty($"{_type}"))
                {
                    await _dingDing.SendBotMsg($"set-scstats-type, {json}", GroupNames.成都开发測試群組);
                    return response;
                }
                if (json.TryGetProperty("cnt", out JsonElement _cnt))
                    all = _cnt.GetInt32();

                json.TryGetProperty("interaction", out JsonElement interaction);

                if (json.TryGetProperty("date", out JsonElement _date))
                    careDate = _date.GetInt64();
                else
                    careDate = dateOff.ToUnixTimeMilliseconds();
                var (lastDayS, lastDayE) = TimeHelper.GetStartOrEnd(dateOff.AddDays(-1));//昨天开始/结束时间
                var (DayS, DayE) = TimeHelper.GetStartOrEnd(dateOff);      //今天开始时间结束时间
                var (lastWeekS, lastWeekE) = TimeHelper.GetStartOrEnd(dateOff, "lastweek");   //计算上周开始/结束时间
                var (weekS, weekE) = TimeHelper.GetStartOrEnd(dateOff, "week");             //计算本周开始/结束时间
                var (lastMonthS, lastMonthE) = TimeHelper.GetStartOrEnd(dateOff, "lastMonth");   //计算上月开始/结束时间
                var (monthS, monthE) = TimeHelper.GetStartOrEnd(dateOff, "month");             //计算本月开始/结束时间
                var (lastTermS, lastTermE) = TimeHelper.GetStartOrEnd(dateOff, "lastterm");   //计算上学期开始/结束时间
                var (termS, termE) = TimeHelper.GetStartOrEnd(dateOff, "term");   //计算本学期开始/结束时间
                var (lastYearS, lastYearE) = TimeHelper.GetStartOrEnd(dateOff, "lastYear"); //计算去年开始/结束时间
                var (yearS, yearE) = TimeHelper.GetStartOrEnd(dateOff, "year");         //计算今年开始/结束时间

                var (weekDayS, weekDayE) = TimeHelper.GetLongToTime(lastWeekS, lastWeekE);
                var (lTermDayS, lTermDayE) = TimeHelper.GetLongToTime(lastTermS, lastTermE);
                var (termDayS, termDayE) = TimeHelper.GetLongToTime(lastTermS, lastTermE);
                var lastDay = dateOff.AddDays(-1);

                StatsInfo statsInfo = new();
                var resStsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{dateOff.Year}-{scId}", new PartitionKey("Statistics"));
                if (resStsInfo.Status == 200)
                {
                    using var fileJson = await JsonDocument.ParseAsync(resStsInfo.ContentStream);
                    statsInfo = fileJson.ToObject<StatsInfo>();
                }
                else
                {
                    ScBase scBase = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemAsync<ScBase>(scId, new PartitionKey("Base"));

                    //var resLastStsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{dateOff.Year - 1}-{scId}", new PartitionKey("Statistics"));
                    //if (resLastStsInfo.Status == 200)
                    //{
                    //    using var fileJson = await JsonDocument.ParseAsync(resStsInfo.ContentStream);
                    //    statsInfo = fileJson.ToObject<StatsInfo>();
                    //    statsInfo.id = $"{dateOff.Year}-{scBase.id}";
                    //}
                    //else 
                    //{
                    statsInfo.id = $"{dateOff.Year}-{scBase.id}";
                    statsInfo.name = scBase.name;
                    statsInfo.picture = scBase.picture;
                    statsInfo.size = scBase.size;
                    statsInfo.scCreateTime = scBase.createTime;
                    statsInfo.areaId = scBase.areaId;
                    statsInfo.upTime = careDate;
                    //}
                }

                switch ($"{type}")
                {
                    case "Exam":
                        statsInfo.activity.year[dateOff.DayOfYear] += all;
                        statsInfo.activity.exam += all;
                        statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
                        statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);

                        if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                        {
                            var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
                            statsInfo.activity.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                            //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                        }

                        if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
                            statsInfo.activity.week += all;

                        if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
                        {
                            if (lTermDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                    statsInfo.activity.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.activity.lastTerm = 0;
                            }
                        }

                        if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
                        {
                            if (termDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                    statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.activity.term += all;
                            }
                        }

                        statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                        statsInfo.activity.all += all;
                        break;
                    case "Survey":
                        statsInfo.activity.year[dateOff.DayOfYear] += all;
                        statsInfo.activity.survey += all;
                        statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
                        statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);

                        if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                        {
                            var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
                            statsInfo.activity.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                            //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                        }

                        if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
                            statsInfo.activity.week += all;

                        if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
                        {
                            if (lTermDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                    statsInfo.activity.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.activity.lastTerm = 0;
                            }
                        }

                        if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
                        {
                            if (termDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                    statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.activity.term += all;
                            }
                        }

                        statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                        statsInfo.activity.all += all;
                        break;
                    case "Vote":
                        statsInfo.activity.year[dateOff.DayOfYear] += all;
                        statsInfo.activity.vote += all;
                        statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
                        statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);

                        if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                        {
                            var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
                            statsInfo.activity.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                            //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                        }

                        if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
                            statsInfo.activity.week += all;

                        if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
                        {
                            if (lTermDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                    statsInfo.activity.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.activity.lastTerm = 0;
                            }
                        }

                        if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
                        {
                            if (termDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                    statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.activity.term += all;
                            }
                        }

                        statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                        statsInfo.activity.all += all;
                        break;
                    case "Homework":
                        statsInfo.activity.year[dateOff.DayOfYear] += all;
                        statsInfo.activity.homework += all;
                        statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
                        statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);

                        if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                        {
                            var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
                            statsInfo.activity.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                            //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                        }

                        if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
                            statsInfo.activity.week += all;

                        if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
                        {
                            if (lTermDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                    statsInfo.activity.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.activity.lastTerm = 0;
                            }
                        }

                        if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
                        {
                            if (termDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                    statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.activity.term += all;
                            }
                        }

                        statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                        statsInfo.activity.all += all;
                        break;
                    case "Less":

                        statsInfo.lesson.year[dateOff.DayOfYear] += all;
                        statsInfo.lesson.lastDay = ((int)statsInfo.lesson.year[lastDay.DayOfYear]);
                        statsInfo.lesson.day = ((int)statsInfo.lesson.year[dateOff.DayOfYear]);

                        if (DayS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= DayE)
                            statsInfo.lesson.dayInter += interaction.GetInt32();
                        else
                            statsInfo.lesson.dayInter = 0;

                        //if (monthS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= monthE)
                        //    statsInfo.lesson.monthInter += interaction.GetInt32();
                        //else
                        //    statsInfo.lesson.monthInter = 0;

                        if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                        {
                            var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.lesson.year });
                            statsInfo.lesson.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                            //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                        }

                        if (weekS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= weekE)
                            statsInfo.activity.week += all;

                        if (lastTermS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= lastTermE)
                        {
                            if (lTermDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.lesson.year, statsInfo.lesson.year });
                                    statsInfo.lesson.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.lesson.lastTerm = 0;
                            }
                        }

                        if (termS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= termE)
                        {
                            if (termDayS.Year < dateOff.Year)
                            {
                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                                if (lastSts.Status == 200)
                                {
                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                    var tempSts = fileJson.ToObject<StatsInfo>();
                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.lesson.year, statsInfo.lesson.year });
                                    statsInfo.lesson.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                                }
                                else
                                    statsInfo.lesson.term += all;
                            }
                        }

                        statsInfo.lesson.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                        statsInfo.lesson.all += all;
                        break;
                    case "stu":
                        if (DayS <= statsInfo.stuUpTime && statsInfo.stuUpTime < DayE)
                            statsInfo.dayStu += 1;
                        else
                            statsInfo.dayStu = 0;


                        if (weekS <= statsInfo.stuUpTime && statsInfo.stuUpTime < weekE)
                            statsInfo.weekStu += 1;
                        else
                            statsInfo.weekStu = 0;

                        if (monthS <= statsInfo.stuUpTime && statsInfo.stuUpTime < monthE)
                            statsInfo.monthStu += 1;
                        else
                            statsInfo.monthStu = 0;

                        statsInfo.stuUpTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                        statsInfo.stu += all;
                        break;
                    case "tch":
                        if (DayS <= statsInfo.tchUpTime && statsInfo.tchUpTime < DayE)
                            statsInfo.dayTch += 1;
                        else
                            statsInfo.dayTch = 0;

                        if (weekS <= statsInfo.tchUpTime && statsInfo.tchUpTime < weekE)
                            statsInfo.weekTch += 1;
                        else
                            statsInfo.weekTch = 0;

                        if (monthS <= statsInfo.tchUpTime && statsInfo.tchUpTime < monthE)
                            statsInfo.monthTch += 1;
                        else
                            statsInfo.monthTch = 0;

                        statsInfo.tchUpTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                        statsInfo.stu += all;

                        statsInfo.tch += all;
                        break;
                }

                if (resStsInfo.Status == 200)
                    statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<StatsInfo>(statsInfo, scId, new PartitionKey("Stats"));
                else
                    statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<StatsInfo>(statsInfo, new PartitionKey("Stats"));

            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"set-scstats-type,{ex.Message}\n{ex.StackTrace}\n{jsondata.ToJsonString()}", GroupNames.成都开发測試群組);
            }

            return response;
        }

    }
}