处理统计增/减量统计方法，处理版本的问题。

TEAMModelBI/Controllers/BITest/TestController.cs

@@ -1724,45 +1724,11 @@ namespace TEAMModelBI.Controllers.BITest
             if (!jsonElement.TryGetProperty("scId", out JsonElement scId)) return BadRequest();
 
             List<object> server = new();
-
-            _ = UpSchoolEdition(cosmosClient, server, "hbcn");
+            _ = BISchoolService.UpSchoolEdition(cosmosClient, server, "hbcn");
 
             return Ok(new { state = 200 });
         }
 
-        /// <summary>
-        /// 版本信息
-        /// </summary>
-        /// <param name="cosmosClient"></param>
-        /// <param name="server"></param>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        public static async Task<string> UpSchoolEdition(CosmosClient cosmosClient, List<object> server, string id)
-        {
-            School school = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(id, new PartitionKey("Base"));
-            int edition = 0;
-            if (school.size <= 100 && school.scale == 0)
-                edition = 1;
-            else if (school.size >= 300 && school.scale >= 500 && server.Contains(""))
-                edition = 2;
-            else if (school.size >= 300 && school.scale >= 500 && server.Contains("") && server.Count > 2)
-                edition = 3;
-
-            //if (school.edition != null) 
-            //{
-            //    school.edition.current = edition;
-            //    if (school.edition.record < edition) 
-            //        school.edition.record = edition;
-            //}
-            //school
-            //await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, id, new PartitionKey("Base"));
-            BIRelation biRel = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<BIRelation>(id, new PartitionKey("BIRel"));
-            //biRel.edition = school.edition;
-            //await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<BIRelation>(biRel, id, new PartitionKey("BIRel"));
-
-
-            return "";
-        }
 
 
         /// <summary>
@@ -1919,7 +1885,7 @@ namespace TEAMModelBI.Controllers.BITest
                     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.lastWeek = ((int)lessList.SubMatrix(lWeekDayS.DayOfYear, lWeekDayE.DayOfYear - lWeekDayS.DayOfYear, 0, lessList.ColumnCount).ColumnSums().Sum());
                     statsInfo.lesson.week = ((int)lessList.SubMatrix(weekDayS.DayOfYear, (dateOff.DayOfYear - weekDayS.DayOfYear), 0, lessList.ColumnCount).ColumnSums().Sum());
 
                     StatsInfo lastStats = null;
@@ -1930,49 +1896,29 @@ namespace TEAMModelBI.Controllers.BITest
                         lastStats = fileJson.ToObject<StatsInfo>();
                     }
 
+                    int lastTerm = 0;
                     if (lTermDayS.Year < dateOff.Year)
                     {
-                        int lastTerm = 0;
                         if (lastStats != null) 
                         {
-                        
-                        }
-                    }
-
-
-
-
-                    if (lastTermS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= lastTermE)
-                    {
-                        if (lTermDayS.Year < dateOff.Year)
-                        {
-                            var lastLessSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
-                            if (lastLessSts.Status == 200)
-                            {
-                                using var fileJson = await JsonDocument.ParseAsync(lastLessSts.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());
-                            }
+                            var actYer = DenseMatrix.OfColumns(new List<List<double>>() { lastStats.lesson.year });
+                            lastTerm += ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lastStats.lesson.year.Count - lTermDayS.DayOfYear, 0, 1).ColumnSums().Sum());
                         }
+                        lastTerm += ((int)lessList.SubMatrix(0, lTermDayE.DayOfYear, 0, lessList.ColumnCount).ColumnSums().Sum());
                     }
+                    else
+                        lastTerm += ((int)lessList.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear - lTermDayS.DayOfYear, 0, lessList.ColumnCount).ColumnSums().Sum());
+                    statsInfo.lesson.lastTerm = lastTerm;
 
-                    if (termS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= termE)
+                    int term = 0;
+                    if (termDayE.Year > dateOff.Year)
                     {
-                        if (termDayS.Year < dateOff.Year)
-                        {
-                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").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 += count;
-                        }
+                        if (lastStats != null)
+                            term = ((int)lessList.SubMatrix(termDayS.DayOfYear, (statsInfo.lesson.year.Count - termDayS.DayOfYear), 0, lessList.ColumnCount).ColumnSums().Sum());
                     }
+                    else
+                        term = ((int)lessList.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear - termDayS.DayOfYear, 0, lessList.ColumnCount).ColumnSums().Sum());
+                    statsInfo.lesson.term = term;
 
                     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());
@@ -1987,21 +1933,13 @@ namespace TEAMModelBI.Controllers.BITest
                     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)
+                    int lastTermI = 0;
+                    if (lastStats != null)
                     {
-                        if (lTermDayS.Year < dateOff.Year)
-                        {
-                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
-                            if (lastSts.Status == 200)
-                            {
-                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
-                                var tempSts = fileJson.ToObject<StatsInfo>();
-                                statsInfo.lesson.lastYearInter = ((int)tempSts.lesson.yearInters.Sum());
-                            }
-                            else
-                                statsInfo.lesson.lastYearInter = 0;
-                        }
+                        var actYer = DenseMatrix.OfColumns(new List<List<double>>() { lastStats.lesson.year });
+                        lastTermI += ((int)actYer.SubMatrix(0, lastStats.lesson.year.Count, 0, actYer.ColumnCount).ColumnSums().Sum());
                     }
+                    statsInfo.lesson.lastYearInter = lastTermI;
 
                     statsInfo.lesson.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                     break;
@@ -2041,53 +1979,51 @@ namespace TEAMModelBI.Controllers.BITest
                         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.lastWeek = ((int)matris.SubMatrix(lWeekDayS.DayOfYear, lWeekDayE.DayOfYear- lWeekDayS.DayOfYear, 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)
+
+                        StatsInfo lastStats = null;
+                        var resLast = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
+                        if (resLast.Status == 200)
                         {
-                            if (lTermDayS.Year < dateOff.Year)
-                            {
-                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").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;
-                            }
+                            using var fileJson = await JsonDocument.ParseAsync(resLast.ContentStream);
+                            lastStats = fileJson.ToObject<StatsInfo>();
                         }
 
-                        if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
+                        int lastTerm = 0;
+                        if (lTermDayS.Year < dateOff.Year)
                         {
-                            if (termDayS.Year < dateOff.Year)
+                            if (lastStats != null)
                             {
-                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").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 += count;
+                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { lastStats.lesson.year });
+                                lastTerm += ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lastStats.lesson.year.Count - lTermDayS.DayOfYear, 0, 1).ColumnSums().Sum());
                             }
-                            else
+                            lastTerm += ((int)matris.SubMatrix(0, lTermDayE.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
+                        }
+                        else
+                            lastTerm += ((int)matris.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear- lTermDayS.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
+                        statsInfo.activity.lastTerm = lastTerm;
+
+
+                        int term = 0;
+                        if (termDayS.Year > dateOff.Year)
+                        {
+                            if (lastStats != null)
                             {
-                                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());
+                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { lastStats.lesson.year });
+                                term += ((int)actYer.SubMatrix(termDayS.DayOfYear, lastStats.lesson.year.Count - termDayS.DayOfYear, 0, 1).ColumnSums().Sum());
                             }
+                            term += ((int)matris.SubMatrix(0, termDayE.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
                         }
+                        else
+                            term += ((int)matris.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear - termDayS.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
+                        statsInfo.activity.term = term;
 
                         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)

TEAMModelOS.SDK/Models/Cosmos/School/School.cs

@@ -88,7 +88,7 @@ namespace TEAMModelOS.SDK.Models
         /// <summary>
         /// 版本
         /// </summary>
-        //public Edition edition { get; set; }
+        public Edition edition { get; set; }
 
         /// <summary>
         /// 创建时间  十位 时间戳

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

@@ -0,0 +1,51 @@
+using Azure.Cosmos;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TEAMModelOS.SDK.DI;
+using TEAMModelOS.SDK.Models.Cosmos.BI.BISchool;
+
+namespace TEAMModelOS.SDK.Models.Service.BI
+{
+    public static class BISchoolService
+    {
+        /// <summary>
+        /// 更新版本信息
+        /// </summary>
+        /// <param name="cosmosClient"></param>
+        /// <param name="server"></param>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public static async Task UpSchoolEdition(CosmosClient cosmosClient, List<object> server, string id)
+        {
+            School school = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(id, new PartitionKey("Base"));
+            int edition = 0;
+            if (school.size <= 100 && school.scale == 0)
+                edition = 1;
+            else if (school.size >= 300 && school.scale >= 500 && server.Contains("YMPCVCIM"))
+                edition = 2;
+            else if (school.size >= 300 && school.scale >= 1000 && server.Contains("YMPCVCIM") && server.Count > 2)
+                edition = 3;
+
+            if (school.edition != null)
+            {
+                school.edition.current = edition;
+                if (school.edition.record < edition)
+                    school.edition.record = edition;
+            }
+            else
+            {
+                school.edition.current = edition;
+                school.edition.record = edition;
+            }
+            await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, id, new PartitionKey("Base"));
+            BIRelation biRel = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<BIRelation>(id, new PartitionKey("BIRel"));
+            biRel.edition = school.edition;
+            await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<BIRelation>(biRel, id, new PartitionKey("BIRel"));
+        }
+
+
+    }
+}

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

@@ -136,40 +136,40 @@ namespace TEAMModelOS.SDK.Models.Service.BI
                         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.lastWeek = ((int)lessList.SubMatrix(lWeekDayS.DayOfYear, lWeekDayE.DayOfYear - lWeekDayS.DayOfYear, 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.lesson.upTime && statsInfo.lesson.upTime <= lastTermE)
+                        StatsInfo lastStats = null;
+                        var resLast = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
+                        if (resLast.Status == 200)
                         {
-                            if (lTermDayS.Year < dateOff.Year)
-                            {
-                                var lastLessSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
-                                if (lastLessSts.Status == 200)
-                                {
-                                    using var fileJson = await JsonDocument.ParseAsync(lastLessSts.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());
-                                }
-                            }
+                            using var fileJson = await JsonDocument.ParseAsync(resLast.ContentStream);
+                            lastStats = fileJson.ToObject<StatsInfo>();
                         }
 
-                        if (termS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= termE)
+                        int lastTerm = 0;
+                        if (lTermDayS.Year < dateOff.Year)
                         {
-                            if (termDayS.Year < dateOff.Year)
+                            if (lastStats != null)
                             {
-                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").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 += count;
+                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { lastStats.lesson.year });
+                                lastTerm += ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lastStats.lesson.year.Count - lTermDayS.DayOfYear, 0, 1).ColumnSums().Sum());
                             }
+                            lastTerm += ((int)lessList.SubMatrix(0, lTermDayE.DayOfYear, 0, lessList.ColumnCount).ColumnSums().Sum());
                         }
+                        else
+                            lastTerm += ((int)lessList.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear - lTermDayS.DayOfYear, 0, lessList.ColumnCount).ColumnSums().Sum());
+                        statsInfo.lesson.lastTerm = lastTerm;
+
+                        int term = 0;
+                        if (termDayE.Year > dateOff.Year)
+                        {
+                            if (lastStats != null)
+                                term = ((int)lessList.SubMatrix(termDayS.DayOfYear, (statsInfo.lesson.year.Count - termDayS.DayOfYear), 0, lessList.ColumnCount).ColumnSums().Sum());
+                        }
+                        else
+                            term = ((int)lessList.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear - termDayS.DayOfYear, 0, lessList.ColumnCount).ColumnSums().Sum());
+                        statsInfo.lesson.term = term;
 
                         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());
@@ -184,21 +184,13 @@ namespace TEAMModelOS.SDK.Models.Service.BI
                         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)
+                        int lastTermI = 0;
+                        if (lastStats != null)
                         {
-                            if (lTermDayS.Year < dateOff.Year)
-                            {
-                                var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
-                                if (lastSts.Status == 200)
-                                {
-                                    using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
-                                    var tempSts = fileJson.ToObject<StatsInfo>();
-                                    statsInfo.lesson.lastYearInter = ((int)tempSts.lesson.yearInters.Sum());
-                                }
-                                else
-                                    statsInfo.lesson.lastYearInter = 0;
-                            }
+                            var actYer = DenseMatrix.OfColumns(new List<List<double>>() { lastStats.lesson.year });
+                            lastTermI += ((int)actYer.SubMatrix(0, lastStats.lesson.year.Count, 0, actYer.ColumnCount).ColumnSums().Sum());
                         }
+                        statsInfo.lesson.lastYearInter = lastTermI;
 
                         statsInfo.lesson.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                         break;
@@ -238,53 +230,51 @@ namespace TEAMModelOS.SDK.Models.Service.BI
                             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.lastWeek = ((int)matris.SubMatrix(lWeekDayS.DayOfYear, lWeekDayE.DayOfYear - lWeekDayS.DayOfYear, 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)
+
+                            StatsInfo lastStats = null;
+                            var resLast = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
+                            if (resLast.Status == 200)
                             {
-                                if (lTermDayS.Year < dateOff.Year)
-                                {
-                                    var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").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;
-                                }
+                                using var fileJson = await JsonDocument.ParseAsync(resLast.ContentStream);
+                                lastStats = fileJson.ToObject<StatsInfo>();
                             }
 
-                            if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
+                            int lastTerm = 0;
+                            if (lTermDayS.Year < dateOff.Year)
                             {
-                                if (termDayS.Year < dateOff.Year)
+                                if (lastStats != null)
                                 {
-                                    var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").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 += count;
+                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { lastStats.lesson.year });
+                                    lastTerm += ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lastStats.lesson.year.Count - lTermDayS.DayOfYear, 0, 1).ColumnSums().Sum());
                                 }
-                                else
+                                lastTerm += ((int)matris.SubMatrix(0, lTermDayE.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
+                            }
+                            else
+                                lastTerm += ((int)matris.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear - lTermDayS.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
+                            statsInfo.activity.lastTerm = lastTerm;
+
+
+                            int term = 0;
+                            if (termDayS.Year > dateOff.Year)
+                            {
+                                if (lastStats != null)
                                 {
-                                    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());
+                                    var actYer = DenseMatrix.OfColumns(new List<List<double>>() { lastStats.lesson.year });
+                                    term += ((int)actYer.SubMatrix(termDayS.DayOfYear, lastStats.lesson.year.Count - termDayS.DayOfYear, 0, 1).ColumnSums().Sum());
                                 }
+                                term += ((int)matris.SubMatrix(0, termDayE.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
                             }
+                            else
+                                term += ((int)matris.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear - termDayS.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
+                            statsInfo.activity.term = term;
 
                             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)
@@ -526,7 +516,6 @@ namespace TEAMModelOS.SDK.Models.Service.BI
 
                         item.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
 
-
                         statsInfos.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync<StatsInfo>(item, item.id, new PartitionKey("Statistics")));
                     }