优化所有学区，以及相关增减量辅助方法

TEAMModelBI/Controllers/BITest/TestController.cs

@@ -1735,10 +1735,10 @@ namespace TEAMModelBI.Controllers.BITest
         {
             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;
+            int interaction = 0;
+            int lessType = 0;
 
             DateTimeOffset dateOff = DateTimeOffset.UtcNow;
             if (json.TryGetProperty("scId", out JsonElement _schoolId))
@@ -1753,13 +1753,15 @@ namespace TEAMModelBI.Controllers.BITest
             if (json.TryGetProperty("cnt", out JsonElement _cnt))
                 all = _cnt.GetInt32();
 
-            json.TryGetProperty("interaction", out JsonElement interaction);
+            if(json.TryGetProperty("interaction", out JsonElement _interaction))
+                interaction = _interaction.GetInt32();
+            if (json.TryGetProperty("lessType", out JsonElement _lessType))
+                lessType = _lessType.GetInt32();
 
             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");             //计算本周开始/结束时间
@@ -1767,17 +1769,17 @@ namespace TEAMModelBI.Controllers.BITest
             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 (weekDayS, weekDayE) = TimeHelper.GetLongToTime(weekS, weekE);
+            var (lWeekDayS, lWeekDayE) = TimeHelper.GetLongToTime(lastWeekS, lastWeekE);
             var (lTermDayS, lTermDayE) = TimeHelper.GetLongToTime(lastTermS, lastTermE);
             var (termDayS, termDayE) = TimeHelper.GetLongToTime(lastTermS, lastTermE);
             var (lMonthS, lMonthE) = TimeHelper.GetLongToTime(lastMonthS, lastMonthE);
+            var (monthDayS, monthDayE) = TimeHelper.GetLongToTime(monthS, monthE);
             var lastDay = dateOff.AddDays(-1);
-            var lastMonth = dateOff.AddMonths(-1);
-
+            int lmthDay = TimeHelper.GetDateDay(lMonthE);
             StatsInfo statsInfo = new();
+
             var resStsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{dateOff.Year}-{scId}", new PartitionKey("Statistics"));
             if (resStsInfo.Status == 200)
             {
@@ -1806,207 +1808,54 @@ namespace TEAMModelBI.Controllers.BITest
                 statsInfo.upTime = careDate;
                 //}
             }
-            DenseMatrix matris = null;
+
             switch ($"{type}")
             {
                 case "Exam":
-                    statsInfo.activity.year[dateOff.DayOfYear] += all;
                     statsInfo.activity.exam += all;
-                    statsInfo.activity.month += all;
-                    statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
-                    statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);
-
-                    matris = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
-                    if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
-                    {
-                        statsInfo.activity.lastWeek = ((int)matris.SubMatrix(weekDayS.DayOfYear, 7, 0, matris.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.lastWeek = ((int)matris.SubMatrix(lMonthS.DayOfYear, 20, 0, matris.ColumnCount).ColumnSums().Sum());
-
-                    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.month += 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.month += 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.month += all;
-                    statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
-                    statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);
+                    break;
+                case "Less":
+                    //课例
+                    statsInfo.lesson.year[dateOff.DayOfYear] += all;
+                    statsInfo.lesson.all += all;
 
-                    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 (lessType == 0) 
+                        statsInfo.lesson.open += all;
+                    else
+                        statsInfo.lesson.less += all;
 
-                    if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
-                        statsInfo.activity.week += all;
+                    statsInfo.lesson.lastDay = ((int)statsInfo.lesson.year[lastDay.DayOfYear]);
+                    statsInfo.lesson.day = ((int)statsInfo.lesson.year[dateOff.DayOfYear]);
+
+                    var lessList = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.lesson.year });
+                    statsInfo.lesson.lastWeek = ((int)lessList.SubMatrix(lWeekDayS.DayOfYear, 7, 0, lessList.ColumnCount).ColumnSums().Sum());
+                    statsInfo.lesson.week = ((int)lessList.SubMatrix(weekDayS.DayOfYear, (dateOff.DayOfYear - weekDayS.DayOfYear), 0, lessList.ColumnCount).ColumnSums().Sum());
 
-                    if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
+                    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)
+                            var lastLessSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
+                            if (lastLessSts.Status == 200)
                             {
-                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
+                                using var fileJson = await JsonDocument.ParseAsync(lastLessSts.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());
+                                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.activity.lastTerm = 0;
                         }
                     }
 
-                    if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
+                    if (termS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= termE)
                     {
                         if (termDayS.Year < dateOff.Year)
                         {
@@ -2015,42 +1864,26 @@ namespace TEAMModelBI.Controllers.BITest
                             {
                                 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());
+                                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.activity.term += all;
+                                statsInfo.lesson.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]);
-                    var artList = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.lesson.year });
-                    statsInfo.lesson.lastMonthInter = (int)artList.SubMatrix(lMonthS.DayOfYear, lMonthE.DayOfYear, 0, artList.ColumnCount).ColumnSums().Sum();
+                    statsInfo.lesson.lastMonth = ((int)lessList.SubMatrix(lMonthS.DayOfYear, lmthDay, 0, lessList.ColumnCount).ColumnSums().Sum());
+                    statsInfo.lesson.month += ((int)lessList.SubMatrix(monthDayS.DayOfYear, (dateOff.DayOfYear - monthDayS.DayOfYear), 0, lessList.ColumnCount).ColumnSums().Sum());
 
-                    if (DayS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= DayE)
-                        statsInfo.lesson.dayInter += interaction.GetInt32();
-                    else
-                        statsInfo.lesson.dayInter = 0;
+                    //课例互动
+                    statsInfo.lesson.yearInters[dateOff.DayOfYear] += interaction;
+                    statsInfo.lesson.allInter += interaction;
+                    statsInfo.lesson.lastDayInter = ((int)statsInfo.lesson.yearInters[lastDay.DayOfYear]);
+                    statsInfo.lesson.dayInter = ((int)statsInfo.lesson.yearInters[dateOff.DayOfYear]);
 
-                    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)
-                    {
-                        statsInfo.lesson.lastWeek = ((int)artList.SubMatrix(weekDayS.DayOfYear, 7, 0, artList.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;
+                    var interList = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.lesson.yearInters });
+                    statsInfo.lesson.lastMonthInter = ((int)interList.SubMatrix(lMonthS.DayOfYear, lmthDay, 0, interList.ColumnCount).ColumnSums().Sum());
+                    statsInfo.lesson.monthInter += ((int)interList.SubMatrix(monthDayS.DayOfYear, (dateOff.DayOfYear - monthDayS.DayOfYear), 0, interList.ColumnCount).ColumnSums().Sum());
 
                     if (lastTermS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= lastTermE)
                     {
@@ -2061,77 +1894,92 @@ namespace TEAMModelBI.Controllers.BITest
                             {
                                 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());
+                                statsInfo.lesson.lastYearInter = ((int)tempSts.lesson.yearInters.Sum());
                             }
                             else
-                                statsInfo.lesson.term += all;
+                                statsInfo.lesson.lastYearInter = 0;
                         }
                     }
 
                     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;
+                    statsInfo.stuYear[dateOff.DayOfYear] += all;
+                    statsInfo.stu += all;
 
-                    if (monthS <= statsInfo.stuUpTime && statsInfo.stuUpTime < monthE)
-                        statsInfo.monthStu += 1;
-                    else
-                        statsInfo.monthStu = 0;
+                    statsInfo.dayStu = ((int)statsInfo.stuYear[dateOff.DayOfYear]);
+                    var stuList = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.stuYear });
+                    statsInfo.weekStu = ((int)stuList.SubMatrix(weekDayS.DayOfYear, (dateOff.DayOfYear - weekDayS.DayOfYear), 0, stuList.ColumnCount).ColumnSums().Sum());
+                    statsInfo.monthStu = ((int)stuList.SubMatrix(monthDayS.DayOfYear, (dateOff.DayOfYear - monthDayS.DayOfYear), 0, stuList.ColumnCount).ColumnSums().Sum());
 
                     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;
+                    statsInfo.tchYear[dateOff.DayOfYear] += all;
+                    statsInfo.tch += all;
 
-                    if (monthS <= statsInfo.tchUpTime && statsInfo.tchUpTime < monthE)
-                        statsInfo.monthTch += 1;
-                    else
-                        statsInfo.monthTch = 0;
+                    statsInfo.dayTch = ((int)statsInfo.tchYear[dateOff.DayOfYear]);
+                    var tchList = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.tchYear });
+                    statsInfo.weekTch = ((int)tchList.SubMatrix(weekDayS.DayOfYear, (dateOff.DayOfYear - weekDayS.DayOfYear), 0, tchList.ColumnCount).ColumnSums().Sum());
+                    statsInfo.monthTch = ((int)tchList.SubMatrix(monthDayS.DayOfYear, (dateOff.DayOfYear - monthDayS.DayOfYear), 0, tchList.ColumnCount).ColumnSums().Sum());
 
                     statsInfo.tchUpTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
-                    statsInfo.stu += all;
-
-                    statsInfo.tch += all;
                     break;
             }
 
+            if ($"{type}".Equals("Exam") || $"{type}".Equals("Survey") || $"{type}".Equals("Vote") || $"{type}".Equals("Homework"))
+            {
+                statsInfo.activity.all += all;
+                statsInfo.activity.year[dateOff.DayOfYear] += all;
+                DenseMatrix matris = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
+                statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
+                statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);
+                statsInfo.activity.lastWeek = ((int)matris.SubMatrix(lWeekDayS.DayOfYear, 7, 0, matris.ColumnCount).ColumnSums().Sum());
+                statsInfo.activity.week = ((int)matris.SubMatrix(weekDayS.DayOfYear, weekDayE.DayOfYear - weekDayS.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());                
+                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;
+                    }
+                    else
+                    {
+                        var actYer = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
+                        statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
+                    }
+                }
+
+                statsInfo.activity.lastMonth = ((int)matris.SubMatrix(lMonthS.DayOfYear, lmthDay, 0, matris.ColumnCount).ColumnSums().Sum());
+                statsInfo.activity.month += ((int)matris.SubMatrix(monthDayS.DayOfYear, (dateOff.DayOfYear - monthDayS.DayOfYear), 0, matris.ColumnCount).ColumnSums().Sum());
+                statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+            }
 
             if (resStsInfo.Status == 200)
                 statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<StatsInfo>(statsInfo, scId, new PartitionKey("Stats"));

TEAMModelBI/Controllers/Census/SchoolController.cs

@@ -666,6 +666,9 @@ namespace TEAMModelBI.Controllers.Census
             Area area = null;
             ScStats areaScStats = new();
             List<string> scIds = new();
+            DateTimeOffset dateTime = DateTimeOffset.UtcNow;
+            List<ScStats> scStatss = new();
+            List<StatsInfo> statsInfos = new();
 
             StringBuilder scSql = new("select value(c.id) from c");
             StringBuilder lastScSql = new("select value(c.id) from c");
@@ -701,24 +704,21 @@ namespace TEAMModelBI.Controllers.Census
             }
 
             scIds = await CommonFind.FindScIds(cosmosClient, scSql.ToString(), "BIRel");
-            StringBuilder statsSql = new("select value(c) from c");
+            StringBuilder statsSql = new($"select value(c) from c where c.year={dateTime.Year}");
             if (scIds.Count > 0)
             {
-                statsSql.Append($" where {BICommonWay.ManyScSql("c.id", scIds, $"{DateTimeOffset.UtcNow.Year}-")}");
+                statsSql.Append($"  and {BICommonWay.ManyScSql("c.id", scIds, $"{dateTime.Year}-")}");
             }
 
-            DateTimeOffset dateTime = DateTimeOffset.UtcNow;
-            List<ScStats> scStatss = new();
-            List<StatsInfo> statsInfos = new();
             await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<StatsInfo>(queryText: statsSql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Statistics") }))
             {
                 statsInfos.Add(item);
             }
 
-            StringBuilder lastStsSql = new("select c.lesson,c.activity from c");
+            StringBuilder lastStsSql = new($"select c.lesson,c.activity from c where c.year={dateTime.Year}");
             if (scIds.Count > 0)
             {
-                lastStsSql.Append($" where {BICommonWay.ManyScSql("c.id", scIds, $"{DateTimeOffset.UtcNow.Year - 1}-")}");
+                lastStsSql.Append($" and {BICommonWay.ManyScSql("c.id", scIds, $"{DateTimeOffset.UtcNow.Year - 1}-")}");
             }
             List<LastYearLessAndAct> lastYear = new();
 
@@ -827,19 +827,19 @@ namespace TEAMModelBI.Controllers.Census
             }
             if (schoolInfos.Count > 0)
                 scIds = schoolInfos.Select(s => s.id).ToList();
-            StringBuilder statsSql = new("select value(c) from c");
+            StringBuilder statsSql = new($"select value(c) from c where c.year={dateTime.Year}");
             if (scIds.Count > 0)
-                statsSql.Append($" where {BICommonWay.ManyScSql("c.id", scIds, $"{DateTimeOffset.UtcNow.Year}-")}");
+                statsSql.Append($"  {BICommonWay.ManyScSql("c.id", scIds, $"{dateTime.Year}-")}");
 
             await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<StatsInfo>(queryText: statsSql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Statistics") }))
             {
                 statsInfos.Add(item);
             }
 
-            StringBuilder lastStsSql = new("select c.lesson,c.activity from c");
+            StringBuilder lastStsSql = new($"select c.lesson,c.activity from c where c.year={dateTime.Year}");
             if (scIds.Count > 0)
             {
-                lastStsSql.Append($" where {BICommonWay.ManyScSql("c.id", scIds, $"{DateTimeOffset.UtcNow.Year - 1}-")}");
+                lastStsSql.Append($" where {BICommonWay.ManyScSql("c.id", scIds, $"{dateTime.Year - 1}-")}");
             }
 
             List<LastYearLessAndAct> lastYear = new();
@@ -1083,16 +1083,21 @@ namespace TEAMModelBI.Controllers.Census
             int scWeekCnt = await JointlySingleQuery.GetValueInt(cosmosClient, "Normal", "Base", $"{sql} where c.createTime >= {weekS} and c.createTime <= {weekE}");
             int scMonthCnt = await JointlySingleQuery.GetValueInt(cosmosClient, "Normal", "Base", $"{sql} where c.createTime >= {mthS} and c.createTime <= {mthE}");
 
-            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<StatsInfo>(queryText: $"select value(c) from c", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Statistics") }))
+            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<StatsInfo>(queryText: $"select value(c) from c where c.year={dateTime.Year}", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Statistics") }))
             {
                 statsInfos.Add(item);
             }
-            var areaGrup = statsInfos.GroupBy(g => g.areaId).ToList().Select(s => s.Where(w => w.areaId.Equals(s.Key)));
+            var areaGroup = statsInfos.GroupBy(g => g.areaId).ToList().Select(s => s.Where(w => w.areaId.Equals(s.Key)));
+            
 
             StatsInfo statsInfo = null;
             statsInfo = SchoolStatsWay.GetAreaStats(cosmosClient, _httpTrigger, _option, statsInfos);
             if (statsInfo != null)
             {
+                allScStats.areaCnt = areaCnt;
+                allScStats.sc = scCnt;
+                allScStats.weekSc = scWeekCnt;
+                allScStats.monthSc = scMonthCnt;
                 allScStats.tch = statsInfo.tch;
                 allScStats.dayTch = statsInfo.dayTch;
                 allScStats.weekTch = statsInfo.weekTch;
@@ -1271,6 +1276,10 @@ namespace TEAMModelBI.Controllers.Census
         /// </summary>
         public record AllScStats
         {
+            public int areaCnt { get; set; }
+            public int sc { get; set; }
+            public int weekSc { get; set; }
+            public int monthSc { get; set; }
             public int tch { get; set; }
             public int dayTch { get; set; }
             public int weekTch { get; set; }

TEAMModelOS.SDK/Models/Cosmos/BI/StatsInfo.cs

@@ -59,6 +59,12 @@ namespace TEAMModelOS.SDK.Models.Cosmos.BI
         /// 本月新增教师
         /// </summary>
         public int monthTch { get; set; }
+
+        /// <summary>
+        /// 教师每年每天新增数量
+        /// </summary>
+        public List<double> tchYear { get; set; } = new List<double>(366);
+
         /// <summary>
         /// 教师更新时间
         /// </summary>
@@ -83,6 +89,11 @@ namespace TEAMModelOS.SDK.Models.Cosmos.BI
         /// </summary>
         public int monthStu { get; set; }
 
+        /// <summary>
+        /// 学生每年每天新增数量
+        /// </summary>
+        public List<double> stuYear { get; set; } = new List<double>(366);
+
         /// <summary>
         /// 学生信息更新时间
         /// </summary>

TEAMModelOS.SDK/Models/Service/BI/TimeHelper.cs

@@ -561,5 +561,42 @@ namespace TEAMModelOS.SDK.Models.Service.BI
             }
             return months;
         }
+
+        /// <summary>
+        /// 依据时间判定当月多少天
+        /// </summary>
+        /// <param name="dateTime"></param>
+        /// <returns></returns>
+        public static int GetDateDay(DateTimeOffset dateTime) 
+        {
+            int day = 0;
+            int month = dateTime.Month;
+            int year = dateTime.Year;
+            switch (month)
+            {
+                case 1:
+                case 3:
+                case 5:
+                case 7:
+                case 8:
+                case 10:
+                case 12:
+                    day = 31;
+                    break;
+                case 4:
+                case 6:
+                case 9:
+                case 11:
+                    day = 30;
+                    break;
+                case 2:
+                    if (year % 400 == 0 || (year % 100 != 0 && year % 4 == 0))
+                        day = 29;
+                    else
+                        day = 28;
+                    break;
+            }
+            return day;
+        }
     }
 }

TEAMModelOS.SDK/Models/Service/BIStatsWay/ActivityStatsWay.cs

@@ -155,21 +155,13 @@ namespace TEAMModelOS.SDK.Models.Service.BIStatsWay
 
             if (tempAll.Count > 0)
             {
-                //for (int i = 0; i < leveryDay.Count; i++)
-                //{
-                //    if (actStats.LastYear.Count == 366)
-                //        actStats.LastYear[i] = (double)tempAll.FindAll(f => (f.createTime >= leveryDay[i].start && f.createTime <= leveryDay[i].end)).Count;
-                //    else
-                //        actStats.LastYear.Add((double)tempAll.FindAll(f => (f.createTime >= leveryDay[i].start && f.createTime <= leveryDay[i].end)).Count);
-                //}
-
                 for (int i = 0; i < everyDay.Count; i++)
                 {
-                    if (actStats.year.Count == 366)
-                        actStats.year[i] = tempAll.FindAll(f => (f.createTime >= everyDay[i].start && f.createTime <= everyDay[i].end)).Count;
-                    else
-                        actStats.year.Add(tempAll.FindAll(f => (f.createTime >= everyDay[i].start && f.createTime <= everyDay[i].end)).Count);
+                    actStats.year.Add(tempAll.FindAll(f => (f.createTime >= everyDay[i].start && f.createTime <= everyDay[i].end)).Count);
                 }
+
+                if (actStats.year.Count < 366)
+                    actStats.year.Add(0);
             }
 
             //string lastDaySql = $"c.createTime >= {lastDayS} and c.createTime <= {lastdayE}";

TEAMModelOS.SDK/Models/Service/BIStatsWay/LessonRecordStatsWay.cs

@@ -69,24 +69,22 @@ namespace TEAMModelOS.SDK.Models.Service.BIStatsWay
             lessStats.lastYearInter = await JointlySingleQuery.GetValueInt(cosmosClient, "School", $"LessonRecord-{id}", $"select value(sum(c.clientInteractionCount)) from c where c.startTime >= {lastYearS} and c.startTime <= {lastYearE}");
             //lessStats.yearInter = lessRelStats.FindAll(f => f.startTime >= yearS && f.startTime <= yearE).ToList().Select(s => s.clientInteractionCount).Sum();
 
-            DateTimeOffset lyearDay = new(year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, TimeSpan.Zero);
-            List<StartEndTime> everyDay = TimeHelper.GetYearEveryDay(lyearDay);
+            DateTimeOffset yearDay = new(year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, TimeSpan.Zero);
+            List<StartEndTime> everyDay = TimeHelper.GetYearEveryDay(yearDay);
 
             for (int i = 0; i < everyDay.Count; i++)
             {
-                if (lessStats.yearInters.Count == 366)
-                    lessStats.yearInters[i] = (double)lessRelStats.FindAll(f => (f.startTime >= everyDay[i].start && f.startTime <= everyDay[i].end)).Select(s => s.clientInteractionCount).Sum();
-                else
-                    lessStats.yearInters.Add((double)lessRelStats.FindAll(f => (f.startTime >= everyDay[i].start && f.startTime <= everyDay[i].end)).Select(s => s.clientInteractionCount).Sum());
+                lessStats.yearInters.Add((double)lessRelStats.FindAll(f => (f.startTime >= everyDay[i].start && f.startTime <= everyDay[i].end)).Select(s => s.clientInteractionCount).Sum());
             }
+            if (lessStats.yearInters.Count < 366)
+                lessStats.yearInters.Add(0);
 
             for (int i = 0; i < everyDay.Count; i++)
             {
-                if (lessStats.year.Count == 366)
-                    lessStats.year[i] = lessRelStats.FindAll(f => (f.startTime >= everyDay[i].start && f.startTime <= everyDay[i].end)).Count;
-                else
-                    lessStats.year.Add(lessRelStats.FindAll(f => (f.startTime >= everyDay[i].start && f.startTime <= everyDay[i].end)).Count);
+                lessStats.year.Add(lessRelStats.FindAll(f => (f.startTime >= everyDay[i].start && f.startTime <= everyDay[i].end)).Count);
             }
+            if (lessStats.year.Count < 366)
+                lessStats.year.Add(0);
 
             lessStats.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); 
 

TEAMModelOS.SDK/Models/Service/BIStatsWay/SchoolStatsWay.cs

@@ -46,6 +46,9 @@ namespace TEAMModelOS.SDK.Models.Service.BIStatsWay
             var (lastYearS, lastYearE) = TimeHelper.GetStartOrEnd(DateTimeOffset.Parse($"{dateTime.Year - 1}-1-1"), "year"); //计算去年开始/结束时间
             var (yearS, yearE) = TimeHelper.GetStartOrEnd(dateTime, "year");         //计算今年开始/结束时间
 
+            var (weekDayS, weekDayE) = TimeHelper.GetLongToTime(weekS, weekE);
+            var (monthDayS, monthDayE) = TimeHelper.GetLongToTime(mthS, mthE);
+
             string currSql = "select value(count(c.id)) from c";
             string dayWhereSql = $"c.createTime >= {dayS} and c.createTime <= {dayE}";
             string weekWhereSql = $"c.createTime >= {weekS} and c.createTime <= {weekE}";
@@ -62,22 +65,41 @@ namespace TEAMModelOS.SDK.Models.Service.BIStatsWay
 
             string tchSql = $"{currSql} where ARRAY_CONTAINS(c.roles, 'teacher', true) AND c.status = 'join'";
             statsInfo.tch = await JointlySingleQuery.GetValueInt(cosmosClient, "School", $"Teacher-{scBase.id}", tchSql);
-            statsInfo.dayTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School",  $"Teacher-{scBase.id}", $"{tchSql} and {dayWhereSql} ");
-            statsInfo.weekTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School", $"Teacher-{scBase.id}", $"{tchSql} and  {weekWhereSql}");
-            statsInfo.monthTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School",  $"Teacher-{scBase.id}", $"{tchSql} and  {monthWhereSql}");
+
+            List<double> tchDoubles = await UserStatsWay.GetYearTecherStudent(cosmosClient, scBase.id, year, 1); 
+            statsInfo.tchYear = tchDoubles;
+            statsInfo.dayTch = ((int)tchDoubles[dateTime.DayOfYear]);
+            DenseMatrix tchDouble = DenseMatrix.OfColumns(new List<List<double>>() { tchDoubles });
+            int weekDay = 0;
+            if ((dateTime.DayOfYear - weekDayS.DayOfYear) <= 7) 
+                weekDay = dateTime.DayOfYear - weekDayS.DayOfYear;
+            else
+                weekDay = 7;
+
+            statsInfo.weekTch = ((int)tchDouble.SubMatrix(weekDayS.DayOfYear, weekDay, 0, tchDouble.ColumnCount).ColumnSums().Sum());
+            statsInfo.monthTch += ((int)tchDouble.SubMatrix(monthDayS.DayOfYear, (dateTime.DayOfYear - monthDayS.DayOfYear), 0, tchDouble.ColumnCount).ColumnSums().Sum());
+
+            //statsInfo.dayTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School",  $"Teacher-{scBase.id}", $"{tchSql} and {dayWhereSql} ");
+            //statsInfo.weekTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School", $"Teacher-{scBase.id}", $"{tchSql} and  {weekWhereSql}");
+            //statsInfo.monthTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School",  $"Teacher-{scBase.id}", $"{tchSql} and  {monthWhereSql}");
             statsInfo.tchUpTime = dateTime.ToUnixTimeMilliseconds();
 
             statsInfo.stu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"Base-{scBase.id}", currSql);
-            statsInfo.dayStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"Base-{scBase.id}", $"{currSql} where {dayWhereSql}");
-            statsInfo.weekStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"Base-{scBase.id}", $"{currSql} where {weekWhereSql}");
-            statsInfo.monthStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"Base-{scBase.id}", $"{currSql} where {monthWhereSql}");
+            List<double> stuDoubles = await UserStatsWay.GetYearTecherStudent(cosmosClient, scBase.id, year, 2);
+            statsInfo.stuYear = stuDoubles;
+            statsInfo.dayStu = ((int)stuDoubles[dateTime.DayOfYear]);
+            DenseMatrix stuDouble = DenseMatrix.OfColumns(new List<List<double>>() { stuDoubles });
+            statsInfo.weekStu = ((int)stuDouble.SubMatrix(weekDayS.DayOfYear, weekDay, 0, stuDouble.ColumnCount).ColumnSums().Sum());
+            statsInfo.monthStu += ((int)stuDouble.SubMatrix(monthDayS.DayOfYear, (dateTime.DayOfYear - monthDayS.DayOfYear), 0, stuDouble.ColumnCount).ColumnSums().Sum());
+
+            //statsInfo.dayStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"Base-{scBase.id}", $"{currSql} where {dayWhereSql}");
+            //statsInfo.weekStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"Base-{scBase.id}", $"{currSql} where {weekWhereSql}");
+            //statsInfo.monthStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"Base-{scBase.id}", $"{currSql} where {monthWhereSql}");
             statsInfo.stuUpTime = dateTime.ToUnixTimeMilliseconds();
 
             statsInfo.room = await JointlySingleQuery.GetValueInt(cosmosClient, "School",  $"Room-{scBase.id}" ,currSql);
             statsInfo.witRoom = await JointlySingleQuery.GetValueInt(cosmosClient, "School",  $"Room-{scBase.id}", $"{currSql} where (c.serial != null or c.serial != '' or IS_DEFINED(c.serial) = true)");
 
-            //statsInfo.lesson = 
-
             statsInfo.upTime = dateTime.ToUnixTimeMilliseconds();
             statsInfo.lesson = await LessonRecordStatsWay.GetSchoolAll(cosmosClient, statsInfo.schoolId, year);
             statsInfo.activity = await ActivityStatsWay.GetSchoolAll(cosmosClient, statsInfo.schoolId, year);

TEAMModelOS.SDK/Models/Service/BIStatsWay/UserStatsWay.cs

@@ -0,0 +1,61 @@
+using Azure.Cosmos;
+using DocumentFormat.OpenXml.Bibliography;
+using DocumentFormat.OpenXml.Office2010.PowerPoint;
+using OpenXmlPowerTools;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TEAMModelOS.SDK.Models.Cosmos.BI;
+using TEAMModelOS.SDK.Models.Cosmos.BI.BISchool;
+using TEAMModelOS.SDK.Models.Cosmos.BI.BITable;
+using TEAMModelOS.SDK.Models.Service.BI;
+
+namespace TEAMModelOS.SDK.Models.Service.BIStatsWay
+{
+    public class UserStatsWay
+    {
+        /// <summary>
+        /// 统计人数
+        /// </summary>
+        /// <param name="cosmosClient"></param>
+        /// <param name="id"></param>
+        /// <param name="year"></param>
+        /// <param name="userType"></param>
+        /// <returns></returns>
+        public static async Task<List<double>> GetYearTecherStudent(CosmosClient cosmosClient, string id, int year, int userType = 1)
+        {
+            List<double> result = new(366);
+            DateTimeOffset dateTime = DateTimeOffset.UtcNow;
+            if (year < dateTime.Year)
+                dateTime = new(year, 12, 31, 23, 59, 59, TimeSpan.Zero);
+            var (yearS, yearE) = TimeHelper.GetStartOrEnd(dateTime, "year");         //计算今年开始/结束时间
+
+            string code = $"Teacher-{id}";
+            string container = "School";
+            if (userType != 1)
+            {
+                code = $"Base-{id}";
+                container = "Student";
+            }
+
+            List<ArtRelStats> artRelStats = new();
+            string sql = $"select c.id,c.code,c.createTime from c where  c.startTime >= {yearS} and c.startTime <= {yearE}";
+            await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", container).GetItemQueryIterator<ArtRelStats>(queryText: sql, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"{code}") }))
+            {
+                artRelStats.Add(item);
+            }
+            DateTimeOffset yearDay = new(year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, TimeSpan.Zero);
+            List<StartEndTime> everyDay = TimeHelper.GetYearEveryDay(dateTime);
+            for (int i = 0; i < everyDay.Count; i++)
+            {
+                result.Add(artRelStats.FindAll(f => (f.createTime >= everyDay[i].start && f.createTime <= everyDay[i].end)).Count);
+            }
+            if (result.Count < 366) 
+                result.Add(0);
+
+            return result;
+        }
+    }
+}