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

using Azure.Cosmos;
using DocumentFormat.OpenXml.Bibliography;
using DocumentFormat.OpenXml.Math;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models.Cosmos.BI;
using TEAMModelOS.SDK.Models.Service.BI;

namespace TEAMModelOS.SDK.Models.Service.BIStatsWay
{
    public static class SchoolStatsWay
    {

        /// <summary>
        /// 统计单个学校
        /// </summary>
        /// <param name="cosmosClient"></param>
        /// <param name="scId"></param>
        /// <returns></returns>
        public static async Task<StatsInfo> GetSingleSc(CosmosClient cosmosClient, string scId)
        {
            StatsInfo statsInfo = new() { id = $"{scId}" };

            DateTimeOffset dateTime = DateTimeOffset.UtcNow;
            var (dayS, dayE) = TimeHelper.GetStartOrEnd(dateTime);  //今天开始时间    13位
            var (lastWeekS, lastWeekE) = TimeHelper.GetStartOrEnd(dateTime, "lastweek");   //计算上周开始/结束时间
            var (weekS, weekE) = TimeHelper.GetStartOrEnd(dateTime, "week");             //计算本周开始/结束时间

            var (lastTermS, lastTermE) = TimeHelper.GetStartOrEnd(dateTime, "lastterm");   //计算上学期开始/结束时间
            var (termS, termE) = TimeHelper.GetStartOrEnd(dateTime, "term");   //计算本学期开始/结束时间

            var (lastMthS, LastmthE) = TimeHelper.GetStartOrEnd(dateTime, "lastMonth");  //上月开始/结束时间
            var (mthS, mthE) = TimeHelper.GetStartOrEnd(dateTime, "month");  //本月开始/结束时间

            var (lastYearS, lastYearE) = TimeHelper.GetStartOrEnd(DateTimeOffset.Parse($"{dateTime.Year - 1}-1-1"), "year"); //计算去年开始/结束时间
            var (yearS, yearE) = TimeHelper.GetStartOrEnd(dateTime, "year");         //计算今年开始/结束时间

            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}";
            string monthWhereSql = $"c.createTime >= {mthS} and c.createTime <= {mthE}";

            ScBase scBase = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemAsync<ScBase>(statsInfo.id, new PartitionKey("Base"));
            statsInfo.name = scBase.name;
            statsInfo.picture = scBase.picture;
            statsInfo.size = scBase.size;
            statsInfo.scCreateTime = scBase.createTime;

            string tchSql = $"{currSql} where ARRAY_CONTAINS(c.roles, 'teacher', true) AND c.status = 'join'";
            statsInfo.tch = await JointlySingleQuery.GetValueInt(cosmosClient, "School", tchSql, code: $"Teacher-{scBase.id}");
            statsInfo.dayTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School", $"{tchSql} and {dayWhereSql} ", code: $"Teacher-{scBase.id}");
            statsInfo.weekTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School", $"{tchSql} and  {weekWhereSql}", code: $"Teacher-{scBase.id}");
            statsInfo.monthTch = await JointlySingleQuery.GetValueInt(cosmosClient, "School", $"{tchSql} and  {monthWhereSql}", code: $"Teacher-{scBase.id}");

            statsInfo.stu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", currSql, code: $"Base-{scBase.id}");
            statsInfo.dayStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"{currSql} where {dayWhereSql}", code: $"Base-{scBase.id}");
            statsInfo.weekStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"{currSql} where {weekWhereSql}", code: $"Base-{scBase.id}");
            statsInfo.monthStu = await JointlySingleQuery.GetValueInt(cosmosClient, "Student", $"{currSql} where {monthWhereSql}", code: $"Base-{scBase.id}");

            statsInfo.room = await JointlySingleQuery.GetValueInt(cosmosClient, "School", currSql, code: $"Room-{scBase.id}");
            statsInfo.witRoom = await JointlySingleQuery.GetValueInt(cosmosClient, "School", $"{currSql} where (c.serial != null or c.serial != '' or IS_DEFINED(c.serial) = true)", code: $"Room-{scBase.id}");

            statsInfo.lesson = await LessonRecordStatsWay.GetSchoolAll(cosmosClient, statsInfo.id);
            statsInfo.activity = await ActivityStatsWay.GetSchoolAll(cosmosClient, statsInfo.id);
            statsInfo.study = await StudyStatsWay.GetSchoolAll(cosmosClient, statsInfo.id);

            return statsInfo;
        }


        /// <summary>
        /// 多个学校统计
        /// </summary>
        /// <param name="cosmosClient"></param>
        /// <param name="statsInfos"></param>
        /// <param name="_httpTrigger"></param>
        /// <param name="_option"></param>
        /// <param name="area"></param>
        /// <returns></returns>
        public static async Task<StatsInfo> GetAreaStats(CosmosClient cosmosClient, HttpTrigger _httpTrigger, Option _option, List<StatsInfo> statsInfos, List<string> scIds = null, Area area = null) 
        {
            StatsInfo areaInfo = new()
            {
                id = area == null ? "" : area.id,
                pk = "Stats",
                code = "Stats",
                name = area == null ? "" : area.name,
                picture = "",
                tch = statsInfos.Select(s => s.tch).Sum(),
                dayTch = statsInfos.Select(s => s.dayTch).Sum(),
                weekTch = statsInfos.Select(s => s.weekTch).Sum(),
                monthTch = statsInfos.Select(s => s.monthTch).Sum(),
                stu = statsInfos.Select(s => s.stu).Sum(),
                dayStu = statsInfos.Select(s => s.dayStu).Sum(),
                weekStu = statsInfos.Select(s => s.weekStu).Sum(),
                monthStu = statsInfos.Select(s => s.monthStu).Sum(),
                room = statsInfos.Select(s => s.room).Sum(),
                witRoom = statsInfos.Select(s => s.witRoom).Sum(),
                size = statsInfos.Select(s => s.size).Sum()
            };
            areaInfo.lesson.open = statsInfos.Select(s => s.lesson.open).Sum();
            areaInfo.lesson.less = statsInfos.Select(s => s.lesson.less).Sum();
            areaInfo.lesson.lastDay = statsInfos.Select(s => s.lesson.lastDay).Sum();
            areaInfo.lesson.day = statsInfos.Select(s => s.lesson.day).Sum();
            areaInfo.lesson.lastWeek = statsInfos.Select(s => s.lesson.lastWeek).Sum();
            areaInfo.lesson.week = statsInfos.Select(s => s.lesson.week).Sum();
            areaInfo.lesson.lastTerm = statsInfos.Select(s => s.lesson.lastTerm).Sum();
            areaInfo.lesson.term = statsInfos.Select(s => s.lesson.term).Sum();
            areaInfo.lesson.lastDayInter = statsInfos.Select(s => s.lesson.lastDayInter).Sum();
            areaInfo.lesson.dayInter = statsInfos.Select(s => s.lesson.dayInter).Sum();
            areaInfo.lesson.lastMonthInter = statsInfos.Select(s => s.lesson.lastMonthInter).Sum();
            areaInfo.lesson.monthInter = statsInfos.Select(s => s.lesson.monthInter).Sum();
            areaInfo.lesson.lastYearInter = statsInfos.Select(s => s.lesson.lastYearInter).Sum();
            areaInfo.lesson.yearInter = statsInfos.Select(s => s.lesson.yearInter).Sum();

            areaInfo.activity.cnt = statsInfos.Select(s => s.activity.cnt).Sum();
            areaInfo.activity.exam = statsInfos.Select(s => s.activity.exam).Sum();
            areaInfo.activity.survey = statsInfos.Select(s => s.activity.survey).Sum();
            areaInfo.activity.vote = statsInfos.Select(s => s.activity.vote).Sum();
            areaInfo.activity.homework = statsInfos.Select(s => s.activity.homework).Sum();
            areaInfo.activity.lastDay = statsInfos.Select(s => s.activity.lastDay).Sum();
            areaInfo.activity.dayCnt = statsInfos.Select(s => s.activity.dayCnt).Sum();
            areaInfo.activity.lastWeek = statsInfos.Select(s => s.activity.lastWeek).Sum();
            areaInfo.activity.week = statsInfos.Select(s => s.activity.week).Sum();
            areaInfo.activity.lastTerm = statsInfos.Select(s => s.activity.lastTerm).Sum();
            areaInfo.activity.term = statsInfos.Select(s => s.activity.term).Sum();

            List<Task<ItemResponse<StatsInfo>>> taskStatsInfos = new();

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

                bool isnew = false;
                DateTimeOffset dateTime = DateTimeOffset.UtcNow;
                long now = dateTime.ToUnixTimeMilliseconds();

                if (statsInfo.upTime > 0 && !isnew)
                {
                    long timedis = 20 * 60 * 1000;//20分钟
                    if (now - statsInfo.upTime < timedis)
                        isnew = true;
                }
                if (statsInfo.upTime == 0 && isnew)
                    statsInfo.upTime = now;
                if (statsInfo.upTime == 0 && isnew)
                    statsInfo.upTime = DateTimeOffset.UtcNow.Add(new TimeSpan(-1, 0, 0, 0)).ToUnixTimeMilliseconds();
                if (!isnew)
                {
                    ////Function 处理Function 更新或者新增
                    //_ = _httpTrigger.RequestHttpTrigger(new { schoolId = $"{itemId}"}, _option.Location, "stats-sc-info");

                    //异步方法处理 同步更新
                    statsInfo = await SchoolStatsWay.GetSingleSc(cosmosClient, itemId);

                    statsInfo.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    if (isExist)
                        taskStatsInfos.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<StatsInfo>(statsInfo, statsInfo.id, new PartitionKey("Stats")));
                    else
                        taskStatsInfos.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<StatsInfo>(statsInfo, new PartitionKey("Stats")));
                }
            }

            if (taskStatsInfos.Count < 256)
                await Task.WhenAll(taskStatsInfos);
            else 
            {
                int pages = (taskStatsInfos.Count + 256) / 256;
                for (int i = 0; i < pages; i++)
                {
                    List<Task<ItemResponse<StatsInfo>>> tempStatsInfos = taskStatsInfos.Skip((i) * 256).Take(256).ToList();
                    await Task.WhenAll(tempStatsInfos);
                }
            }

            return areaInfo;
        }
    }
}