Merge branch 'PL/develop-BI' into develop

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>
@@ -1789,10 +1755,11 @@ namespace TEAMModelBI.Controllers.BITest
 
             string scId = null, type = null;
             long careDate = 0;
-            int all = 0;
+            int count = 0;
             int interaction = 0;
             int lessType = 0;
 
+            DateTimeOffset cuurDateOff = DateTimeOffset.UtcNow;
             DateTimeOffset dateOff = DateTimeOffset.UtcNow;
             if (json.TryGetProperty("scId", out JsonElement _schoolId))
                 scId = $"{_schoolId}";
@@ -1804,7 +1771,7 @@ namespace TEAMModelBI.Controllers.BITest
                 return Ok(new { state = RespondCode.ParamsError, msg = "参数错误!" });
             }
             if (json.TryGetProperty("cnt", out JsonElement _cnt))
-                all = _cnt.GetInt32();
+                count = _cnt.GetInt32();
 
             if(json.TryGetProperty("interaction", out JsonElement _interaction))
                 interaction = _interaction.GetInt32();
@@ -1815,7 +1782,22 @@ namespace TEAMModelBI.Controllers.BITest
                 careDate = _date.GetInt64();
             else
                 careDate = dateOff.ToUnixTimeMilliseconds();
-            var (DayS, DayE) = TimeHelper.GetStartOrEnd(dateOff);      //今天开始时间结束时间
+
+            if (string.IsNullOrEmpty(scId))
+                return Ok(new { state = 400});
+
+            //DateTimeOffset cuurDateOff = DateTimeOffset.UtcNow;
+            //DateTimeOffset dateOff = DateTimeOffset.UtcNow;
+            if (careDate > 1000000000000)
+                dateOff = DateTimeOffset.FromUnixTimeMilliseconds(careDate);
+            else
+                dateOff = DateTimeOffset.FromUnixTimeSeconds(careDate);
+            if (careDate == 0)
+            {
+                dateOff = DateTimeOffset.UtcNow;
+                careDate = dateOff.ToUnixTimeMilliseconds();
+            }
+
             var (lastWeekS, lastWeekE) = TimeHelper.GetStartOrEnd(dateOff, "lastweek");   //计算上周开始/结束时间
             var (weekS, weekE) = TimeHelper.GetStartOrEnd(dateOff, "week");             //计算本周开始/结束时间
             var (lastMonthS, lastMonthE) = TimeHelper.GetStartOrEnd(dateOff, "lastMonth");   //上月开始/结束时间
@@ -1823,6 +1805,8 @@ namespace TEAMModelBI.Controllers.BITest
             var (lastTermS, lastTermE) = TimeHelper.GetStartOrEnd(dateOff, "lastterm");   //计算上学期开始/结束时间
             var (termS, termE) = TimeHelper.GetStartOrEnd(dateOff, "term");   //计算本学期开始/结束时间
 
+            var (yearS, yearE) = TimeHelper.GetStartOrEnd(cuurDateOff, "year");   //计算本学期开始/结束时间
+
             var (weekDayS, weekDayE) = TimeHelper.GetLongToTime(weekS, weekE);
             var (lWeekDayS, lWeekDayE) = TimeHelper.GetLongToTime(lastWeekS, lastWeekE);
             var (lTermDayS, lTermDayE) = TimeHelper.GetLongToTime(lastTermS, lastTermE);
@@ -1856,7 +1840,7 @@ namespace TEAMModelBI.Controllers.BITest
                 }
                 else
                 {
-                    ScBase scBase = await cosmosClient.GetContainer("TEAMModelOS", "Common").ReadItemAsync<ScBase>(scId, new PartitionKey("Base"));
+                    ScBase scBase = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemAsync<ScBase>(scId, new PartitionKey("Base"));
                     statsInfo.id = $"{dateOff.Year}-{scBase.id}";
                     statsInfo.schoolId = scBase.id;
                     statsInfo.name = scBase.name;
@@ -1865,71 +1849,76 @@ namespace TEAMModelBI.Controllers.BITest
                     statsInfo.scCreateTime = scBase.createTime;
                     statsInfo.areaId = scBase.areaId;
                     statsInfo.upTime = careDate;
+                    statsInfo.stuYear = new double[366].ToList();
+                    statsInfo.tchYear = new double[366].ToList();
+                    statsInfo.lesson.year = new double[366].ToList();
+                    statsInfo.lesson.yearInters = new double[366].ToList();
+                    statsInfo.activity.year = new double[366].ToList();
                 }
             }
 
             switch ($"{type}")
             {
                 case "Exam":
-                    statsInfo.activity.exam += all;
+                    statsInfo.activity.exam += count;
                     break;
                 case "Survey":
-                    statsInfo.activity.survey += all;
+                    statsInfo.activity.survey += count;
                     break;
                 case "Vote":
-                    statsInfo.activity.vote += all;
+                    statsInfo.activity.vote += count;
                     break;
                 case "Homework":
-                    statsInfo.activity.homework += all;
+                    statsInfo.activity.homework += count;
                     break;
                 case "Less":
                     //课例
-                    statsInfo.lesson.year[dateOff.DayOfYear] += all;
-                    statsInfo.lesson.all += all;
+                    statsInfo.lesson.year[dateOff.DayOfYear] += count;
+                    statsInfo.lesson.all += count;
 
-                    if (lessType == 0) 
-                        statsInfo.lesson.open += all;
+                    if (lessType == 0)
+                        statsInfo.lesson.open += count;
                     else
-                        statsInfo.lesson.less += all;
+                        statsInfo.lesson.less += count;
 
                     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.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 += all;
+                            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());
@@ -1944,27 +1933,19 @@ 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;
-                case "stu":
-                    statsInfo.stuYear[dateOff.DayOfYear] += all;
-                    statsInfo.stu += all;
+                case "Student":
+                    statsInfo.stuYear[dateOff.DayOfYear] += count;
+                    statsInfo.stu += count;
 
                     statsInfo.dayStu = ((int)statsInfo.stuYear[dateOff.DayOfYear]);
                     var stuList = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.stuYear });
@@ -1973,10 +1954,10 @@ namespace TEAMModelBI.Controllers.BITest
 
                     statsInfo.stuUpTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                     break;
-                case "tch":
+                case "Teacher":
 
-                    statsInfo.tchYear[dateOff.DayOfYear] += all;
-                    statsInfo.tch += all;
+                    statsInfo.tchYear[dateOff.DayOfYear] += count;
+                    statsInfo.tch += count;
 
                     statsInfo.dayTch = ((int)statsInfo.tchYear[dateOff.DayOfYear]);
                     var tchList = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.tchYear });
@@ -1989,59 +1970,64 @@ namespace TEAMModelBI.Controllers.BITest
 
             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)
+                statsInfo.activity.all += count;
+                if (careDate >= yearS && careDate <= yearE)
                 {
-                    if (lTermDayS.Year < dateOff.Year)
+                    if (count > 0)
                     {
-                        var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
-                        if (lastSts.Status == 200)
+                        statsInfo.activity.year[dateOff.DayOfYear] += count;
+                        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, 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());
+
+                        StatsInfo lastStats = null;
+                        var resLast = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
+                        if (resLast.Status == 200)
+                        {
+                            using var fileJson = await JsonDocument.ParseAsync(resLast.ContentStream);
+                            lastStats = fileJson.ToObject<StatsInfo>();
+                        }
+
+                        int lastTerm = 0;
+                        if (lTermDayS.Year < dateOff.Year)
                         {
-                            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());
+                            if (lastStats != null)
+                            {
+                                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)matris.SubMatrix(0, lTermDayE.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
                         }
                         else
-                            statsInfo.activity.lastTerm = 0;
-                    }
-                }
+                            lastTerm += ((int)matris.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear- lTermDayS.DayOfYear, 0, matris.ColumnCount).ColumnSums().Sum());
+                        statsInfo.activity.lastTerm = lastTerm;
 
-                if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
-                {
-                    if (termDayS.Year < dateOff.Year)
-                    {
-                        var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
-                        if (lastSts.Status == 200)
+
+                        int term = 0;
+                        if (termDayS.Year > dateOff.Year)
                         {
-                            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());
+                            if (lastStats != null)
+                            {
+                                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
-                            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());
+                            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();
                     }
                 }
-
-                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, "Common").ReplaceItemAsync<StatsInfo>(statsInfo, scId, new PartitionKey("Statistics"));
+                statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").ReplaceItemAsync<StatsInfo>(statsInfo, statsInfo.id, new PartitionKey("Statistics"));
             else
                 statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Common").CreateItemAsync<StatsInfo>(statsInfo, new PartitionKey("Statistics"));
 

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")));
                     }