TEAMModelOS/TEAMModelBI/Controllers/BITest/TestController.cs

using Azure.Cosmos;
using DingTalk.Api;
using DingTalk.Api.Request;
using DingTalk.Api.Response;
using HTEXLib.COMM.Helpers;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Cosmos.Table;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelBI.Filter;
using TEAMModelBI.Models;
using TEAMModelBI.Tool;
using TEAMModelOS.Models;
using TEAMModelOS.SDK;//引用创建学校Code
using TEAMModelOS.SDK.Context.Attributes.Azure;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Helper.Common.DateTimeHelper;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Models.Cosmos.BI;
using TEAMModelOS.SDK.Models.Cosmos.Common;
using TEAMModelOS.SDK.Models.Service;
using TEAMModelOS.SDK.Models.Table;

//.Net 6新的特性
using System.Threading;
using System.Reflection;
using System.Numerics;
using System.Security.Cryptography;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.IdentityModel.Tokens.Jwt;
using TEAMModelBI.Tool.Extension;

namespace TEAMModelBI.Controllers.BITest
{
    [Route("apitest")]
    [ApiController]
    public class TestController : ControllerBase
    {
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly AzureStorageFactory _azureStorage;
        private readonly IWebHostEnvironment _environment; //读取文件
        //读取配置文件
        private readonly IConfiguration _configuration;

        public TestController(AzureCosmosFactory azureCosmos, DingDing dingDing, AzureStorageFactory azureStorage, IOptionsSnapshot<Option> option, IWebHostEnvironment hostingEnvironment, IConfiguration configuration)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _azureStorage = azureStorage;
            _option = option?.Value;
            _environment = hostingEnvironment;
            _configuration = configuration;
        }

        /// <summary>
        /// 删除册别，删除章节  创区
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("del-standard")]
        public async Task<IActionResult> DelStandard(JsonElement jsonElement)
        {
            if (!jsonElement.TryGetProperty("oldStandard", out JsonElement _oldStandard)) return BadRequest();
            var cosmosClient = _azureCosmos.GetCosmosClient();

            List<string> abilityIds = new List<string>();  //册别的ID集合

            //查询册别信息
            await foreach (var tempAbility in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Ability>(queryText: $"select value(c) from c", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Ability-{_oldStandard}") }))
            {
                abilityIds.Add(tempAbility.id);  //查询出来册别ID添加册别ID集合
            }
            //删除册别
            if (abilityIds.IsNotEmpty())
            {
                var sresponse = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemsStreamAsync(abilityIds, $"Ability-{_oldStandard}");
            }

            List<string> abilityTaskIds = new List<string>();  //章节ID集合

            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AbilityTask>(queryText: $"select value(c) from c", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"AbilityTask-{_oldStandard}") }))
            {
                abilityTaskIds.Add(item.id);   //查询出来的章节信息ID添加到战绩集合
            }
            //删除章节
            if (abilityTaskIds.IsNotEmpty())
            {
                var sresponse = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemsStreamAsync(abilityTaskIds, $"AbilityTask-{_oldStandard}");
            }

            return Ok(new { state = 200 });
        }

        /// <summary>
        /// 测试生产Code
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-schoolcode")]
        public async Task<IActionResult> GetTest(JsonElement jsonElement)
        {
            //string data = await SchoolCode.GenerateSchoolCode(jsonElement, _dingDing, _environment).ToString();
            CreateSchoolInfo createSchoolInfo = new CreateSchoolInfo();
            createSchoolInfo.province = "四川省";
            createSchoolInfo.id = "tmdplc";
            createSchoolInfo.name = "醍摩豆批量创校学校";
            createSchoolInfo.city = "成都市";
            createSchoolInfo.aname = "";
            createSchoolInfo.createCount = 0;

            //Random random = new Random();
            ////随机小写字母
            //int a = random.Next(0, 26);
            //char ch = (char)('a' + a);
            //string Number = GenerateRandom.Number(1);
            //string Number1 = GenerateRandom.Number(1, true);
            //string Str = GenerateRandom.Str(1);
            //string Str1 = GenerateRandom.Str(1, true);
            //string Str_char = GenerateRandom.Str_char(1);
            //string Str_char1 = GenerateRandom.Str_char(1, true);

            CreateSchoolInfo data = await SchoolCode.GenerateSchoolCode(createSchoolInfo, _dingDing, _environment);
            return Ok(new { state = 200, data, data.id });
        }

        /// <summary>
        /// 查询table数据
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("file-table")]
        public async Task<IActionResult> SaveTable(JsonElement jsonElement)
        {
            jsonElement.TryGetProperty("single", out JsonElement single);
            jsonElement.TryGetProperty("startDate", out JsonElement startDate);
            jsonElement.TryGetProperty("endDate", out JsonElement endDate);
            jsonElement.TryGetProperty("platform", out JsonElement platform);

            List<string> strlist = new List<string>();
            if (!string.IsNullOrEmpty($"{single}"))
                strlist.Add($"RowKey {QueryComparisons.Equal} {single}");
            if (!string.IsNullOrEmpty($"{startDate}"))
                strlist.Add($"RowKey {QueryComparisons.GreaterThanOrEqual} {startDate}");
            if (!string.IsNullOrEmpty($"{endDate}"))
                strlist.Add($"RowKey {QueryComparisons.LessThanOrEqual} {endDate}");
            if (!string.IsNullOrEmpty($"{platform}"))
                strlist.Add($"platform {QueryComparisons.Equal} {platform}");

            string sql = string.Join(" and ", strlist);

            var temp = _azureStorage.QueryWhereString<OptLog>(sql);
            return Ok(new { state = 200, temp });
        }

        /// <summary>
        /// 查询BI操作记录
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-operatelogbydate")]
        public async Task<IActionResult> GetOperateLogByDate(JsonElement jsonElement)
        {
            try
            {
                jsonElement.TryGetProperty("single", out JsonElement single);
                jsonElement.TryGetProperty("startDate", out JsonElement startDate);
                jsonElement.TryGetProperty("endDate", out JsonElement endDate);
                jsonElement.TryGetProperty("platform", out JsonElement platform);

                List<OptLog> operateLogs = null;
                StringBuilder tableSql = new StringBuilder();

                if (!string.IsNullOrEmpty($"{single}"))
                    tableSql.Append($"RowKey {QueryComparisons.Equal} '{single}' ");
                if (!string.IsNullOrEmpty($"{startDate}"))
                    tableSql.Append(!string.IsNullOrEmpty(tableSql.ToString()) ? $" {TableOperators.And} RowKey {QueryComparisons.GreaterThanOrEqual} '{startDate}' " : $"RowKey {QueryComparisons.GreaterThanOrEqual} '{startDate}' ");
                if (!string.IsNullOrEmpty($"{endDate}"))
                    tableSql.Append(!string.IsNullOrEmpty(tableSql.ToString()) ? $" {TableOperators.And} RowKey {QueryComparisons.LessThanOrEqual} '{endDate}' " : $" RowKey { QueryComparisons.LessThanOrEqual} '{endDate}' ");
                if (!string.IsNullOrEmpty($"{platform}"))
                    tableSql.Append(!string.IsNullOrEmpty(tableSql.ToString()) ? $" {TableOperators.And} platform {QueryComparisons.Equal} '{platform}' " : $" platform {QueryComparisons.Equal} '{platform}' ");

                operateLogs = await _azureStorage.QueryWhereString<OptLog>(tableSql.ToString());
                return Ok(new { state = 200, operateLogs });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI，{_option.Location}   /operatelog/get-operatelogbydate    {ex.Message}{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 查询离职信息
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("quitstaff")]
        public async Task<IActionResult> QuitStaff()
        {
            string appKey = _configuration["DingDingAuth:appKey"];
            string appSecret = _configuration["DingDingAuth:appSecret"];
            string agentld = _configuration["DingDingAuth:Agentld"];

            //获取access_token
            IDingTalkClient client = new DefaultDingTalkClient("https://oapi.dingtalk.com/gettoken");
            OapiGettokenRequest request = new OapiGettokenRequest() { Appkey = appKey, Appsecret = appSecret };
            request.SetHttpMethod("Get");
            OapiGettokenResponse response = client.Execute(request);
            if (response.IsError)
            {
                return BadRequest();
            }

            //access_token的有效期为7200秒（2小时），有效期内重复获取会返回相同结果并自动续期，过期后获取会返回新的access_token
            string access_token = response.AccessToken;
            List<string> datalist = new List<string>();
            IDingTalkClient quitStaffClient = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/smartwork/hrm/employee/querydimission");
            OapiSmartworkHrmEmployeeQuerydimissionRequest reqDimission = new OapiSmartworkHrmEmployeeQuerydimissionRequest() { Offset = 0L, Size = 50L };
            OapiSmartworkHrmEmployeeQuerydimissionResponse rspDimission = quitStaffClient.Execute(reqDimission, access_token);

            if (rspDimission.SubErrCode == "60011")
            {
                return Ok(new { state = 60011, message = "没有调用该接口的权限！" });
            }
            else if (rspDimission.Result != null)
            {
                datalist = rspDimission.Result.DataList;
                return Ok(new { state = 200, datalist = datalist });
            }
            else
            {
                return Ok(new { state = rspDimission.SubErrCode, message = rspDimission.Errmsg });
            }
        }

        /// <summary>
        /// 测试获取待入职人员的userId接口
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("Induction")]
        public async Task<IActionResult> Induction()
        {
            string appKey = _configuration["DingDingAuth:appKey"];
            string appSecret = _configuration["DingDingAuth:appSecret"];
            string agentld = _configuration["DingDingAuth:Agentld"];

            //获取access_token
            IDingTalkClient client = new DefaultDingTalkClient("https://oapi.dingtalk.com/gettoken");
            OapiGettokenRequest request = new OapiGettokenRequest() { Appkey = appKey, Appsecret = appSecret };
            request.SetHttpMethod("Get");
            OapiGettokenResponse response = client.Execute(request);
            if (response.IsError)
            {
                return BadRequest();
            }

            //access_token的有效期为7200秒（2小时），有效期内重复获取会返回相同结果并自动续期，过期后获取会返回新的access_token
            string access_token = response.AccessToken;

            IDingTalkClient InductionClient = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/smartwork/hrm/employee/querypreentry");
            OapiSmartworkHrmEmployeeQuerypreentryRequest reqInduction = new OapiSmartworkHrmEmployeeQuerypreentryRequest() { Offset = 0L, Size = 50 };
            reqInduction.SetHttpMethod("GET");
            OapiSmartworkHrmEmployeeQuerypreentryResponse rspInduction = InductionClient.Execute(reqInduction, access_token);
            if (rspInduction.Result.DataList != null)
            {
                foreach (var itemId in rspInduction.Result.DataList)
                {
                    IDingTalkClient client3 = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/v2/user/get");
                    OapiV2UserGetRequest v2GetRequest = new OapiV2UserGetRequest()
                    {
                        Userid = itemId,
                        Language = "zh_CN"
                    };
                    OapiV2UserGetResponse v2GetResponse = client3.Execute(v2GetRequest, access_token);

                }
                return Ok(new { state = 200, rspInduction.Result.DataList });
            }
            else
            {
                return Ok(new { state = 400, rspInduction.SubErrCode, rspInduction.SubErrMsg });
            }

        }

        /// <summary>
        /// 赋值默认的顾问角色和BI默认的功能权限
        /// </summary>
        /// <returns></returns>
        [HttpPost("set-rolesorperm")]
        public async Task<IActionResult> SetRolesOrPermissions() 
        {
            List<DingDingUserInfo> ddUserId = await _azureStorage.FindListByDict<DingDingUserInfo>(new Dictionary<string, object> { { "PartitionKey", "continent" } });
            List<string> read = new List<string>() { "abilitystandard-read", "batcharea-read", "batchschool-read", "orgusers-read" };
            List<DingDingUserInfo> tempUserInfo = new List<DingDingUserInfo>();
            foreach (var user in ddUserId) 
            {
                if (string.IsNullOrEmpty(user.roles)) 
                {
                    user.roles = "assist";
                }

                if (string.IsNullOrEmpty(user.permissions)) 
                {
                    user.permissions = string.Join(",", read);
                }
                List<string> tempRead = new List<string>(user.permissions.Split(","));

                foreach (var temp in read) 
                {
                    if (!tempRead.Contains(temp)) 
                    {
                        tempRead.Add(temp);
                    }
                }
                user.permissions = string.Join(",", tempRead);
                tempUserInfo.Add(user);
            }

            var response = await _azureStorage.SaveOrUpdateAll<DingDingUserInfo>(tempUserInfo);

            return Ok(new { state = 200, response });
        }

        /// <summary>
        /// 保存日志文件
        /// </summary>
        /// <returns></returns>
        [AuthToken(Roles = "assist")]
        [HttpPost("save-tablelog")]
        public async Task<IActionResult> SaveTableLogTest() 
        {
            //await OperateLogHelper.SaveTableLog(_azureStorage, "BI", "1636016499", "彭礼", "测试保存方法", "table-save", "save-tablelog");
            await _azureStorage.SaveLog(type:"table-save", msg:"测试保存方法01",dingDing: _dingDing,httpContext:HttpContext);
            return Ok(123);
        }

        /// <summary>
        /// 测试使用 CosmosDB中的COUNT 函数统计
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-count")]
        public async Task<IActionResult> GetCount(JsonElement jsonElement)
        {
            var cosmosClient = _azureCosmos.GetCosmosClient();
            List<KeyValuePair<int, int>> layerCount = new List<KeyValuePair<int, int>>();
            for (int i = 1; i <= 6; i++)
            {
                int total = 0;

                //string sqlText = $"select value(c.id) from c where c.pk='Item' and c.field={i}";
                string sqlText = $"select COUNT(c.id) AS totals from c where c.pk='Item' and c.field={i}";
                await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryText: sqlText, requestOptions: new QueryRequestOptions() { }))
                {
                    using var json = await JsonDocument.ParseAsync(item.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetInt32() > 0)
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            //total += obj.GetInt64();
                            total += obj.GetProperty("totals").GetInt32();
                        }
                        //total += count.GetInt64();
                    }
                }

                await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "Teacher").GetItemQueryStreamIterator(queryText: sqlText, requestOptions: new QueryRequestOptions() { }))
                {
                    using var json = await JsonDocument.ParseAsync(item.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetInt64() > 0)
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            //total += obj.GetInt64();
                            total += obj.GetProperty("totals").GetInt32();
                        }
                    }
                }

                layerCount.Add(new KeyValuePair<int, int>(i, total));
            }

            return Ok(new { state = 200, layerCount });
        }

        /// <summary>
        /// 测试算日期
        /// </summary>
        /// <returns></returns>
        [HttpPost("get-date")]
        public async Task<IActionResult> GetDate()
        {
            DateTimeOffset dateTime = DateTimeOffset.UtcNow.AddDays(0);
            int year = DateTimeOffset.UtcNow.Year;
            int month = DateTimeOffset.UtcNow.Month;

            List<string> strList = monthsOfYear("2021-1");

            var ere = DateTimeOffset.Parse("2024-02");
            var start = GetMonthStart(ere);
            var end = GetMonthEnd(ere);

            List<MonthStartEnd> endList = DateTimeHeloer.GetYearMonthlyStartEnd10(DateTimeOffset.UtcNow.Year);
            List<MonthStartEnd> endList1 = DateTimeHeloer.GetYearMonthlyStartEnd13(DateTimeOffset.UtcNow.Year);
            List<MonthStartEnd> endList2 = DateTimeHeloer.monthsOfYear(DateTimeOffset.UtcNow.ToString());

            return Ok(new { strList, dateTime, year, start, end, endList, endList1 , endList2 });
        }

        public static List<string> monthsOfYear(string yearMonth)
        {
            DateTime dateTime = DateTime.Parse(yearMonth);
            int year = dateTime.Year;
            int month = dateTime.Month;
            List<string> months = new List<string>();
            while (year > dateTime.Year - 1 || month > dateTime.Month) 
            {
                months.Add($"{year}-{(month < 10 ? "0" : "") + month}");
                month -= 1;
                if (month <= 0) 
                {
                    year -= 1;
                    month = 12;
                }
            }

            return months;
        }

        /// <summary>
        /// 统计一年中每月得新增校
        /// </summary>
        /// <returns></returns>
        [HttpPost("get-yearmonth")]
        public async Task<IActionResult> GetYearMonth()
        {
            var cosmosClient = _azureCosmos.GetCosmosClient();
            Dictionary<int, long> tempYear = new Dictionary<int, long>();
            List<TempSchool> tempSchools = new List<TempSchool>();
            for (int i = 1; i < 13; i++)
            {
                var start = 00022222330;
                long tempCount = 0;
                await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryText: $"SELECT c._ts,c.name,c.id FROM c WHERE c._ts>={start}L", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") }))
                {
                    using var json = await JsonDocument.ParseAsync(item.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetInt64() > 0)
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            TempSchool tempSchool = new TempSchool();
                            tempSchool.id = obj.GetProperty("id").GetString();
                            tempSchool.ts = obj.GetProperty("_ts").GetInt64();
                            tempSchool.name = obj.GetProperty("name").GetString();

                            tempSchools.Add(tempSchool);
                        }
                        tempCount += count.GetInt64();
                    }
                }
                if (tempCount != 0)
                {
                    tempYear.Add(i, tempCount);
                }
            }

            return Ok(new { state = 200, tempYear, tempSchools });
        }

        /// <summary>
        /// 测试.net 6 的一些特性
        /// </summary>
        /// <returns></returns>
        [HttpPost("get-newnet6")]
        public async Task<IActionResult> GetNewNet6()
        {
            ///PriorityQueue
            //.NET 6 新增的数据结构, PriorityQueue, 队列每个元素都有一个关联的优先级，它决定了出队顺序, 编号小的元素优先出列。
            PriorityQueue<string, int> priorityQueue = new();
            priorityQueue.Enqueue("Second", 2);
            priorityQueue.Enqueue("Fourth", 4);
            priorityQueue.Enqueue("Third 1", 3);
            priorityQueue.Enqueue("Third 2", 5);
            priorityQueue.Enqueue("First", 1);

            while (priorityQueue.Count > 0)
            {
                string item = priorityQueue.Dequeue();
                Console.WriteLine(item);
            }

            //PeriodicTimer
            //认识一个完全异步的“PeriodicTimer”, 更适合在异步场景中使用, 它有一个方法 WaitForNextTickAsync。
            //using PeriodicTimer timer = new(TimeSpan.FromSeconds(2));
            //while (await timer.WaitForNextTickAsync()) 
            //{
            //    Console.WriteLine(DateTime.UtcNow);
            //}

            //检查元素是否可为空的反射API
            var example = new Example();
            var nullabilityInfoContext = new NullabilityInfoContext();
            foreach (var propertyInfo in example.GetType().GetProperties())
            {
                var nullabilityInfo = nullabilityInfoContext.Create(propertyInfo);
                Console.WriteLine($"{propertyInfo.Name} property is {nullabilityInfo.WriteState}");
            }

            //直接通过 Environment 获取进程ID和路径。
            int processId = Environment.ProcessId;
            string path = Environment.ProcessPath;

            Console.WriteLine(processId);
            Console.WriteLine(path);

            //CSPNG 密码安全伪随机数生成器
            byte[] bytes = RandomNumberGenerator.GetBytes(300);
            Console.WriteLine(string.Join("", bytes.ToArray()));

            //Power of 2
            //.NET 6 引入了用于处理 2 的幂的新方法。

            //‘IsPow2’ 判断指定值是否为 2 的幂。
            //‘RoundUpToPowerOf2’ 将指定值四舍五入到 2 的幂
            Console.WriteLine(BitOperations.IsPow2(121));            // True
            Console.WriteLine(BitOperations.RoundUpToPowerOf2(260)); // 256

            //WaitAsync on Task 您可以更轻松地等待异步任务执行, 如果超时会抛出 “TimeoutException”
            Task operationTask = DoSomethingLongAsync();

            await operationTask.WaitAsync(TimeSpan.FromSeconds(5));

            async Task DoSomethingLongAsync()
            {
                Console.WriteLine("DoSomethingLongAsync started.");
                await Task.Delay(TimeSpan.FromSeconds(10));
                Console.WriteLine("DoSomethingLongAsync ended.");
            }

            //新的数学API
            // New methods SinCos, ReciprocalEstimate and ReciprocalSqrtEstimate
            // Simultaneously computes Sin and Cos
            (double sin, double cos) = Math.SinCos(1.57);
            Console.WriteLine($"Sin = {sin}\nCos = {cos}");

            // Computes an approximate of 1 / x
            double recEst = Math.ReciprocalEstimate(5);
            Console.WriteLine($"Reciprocal estimate = {recEst}");

            // Computes an approximate of 1 / Sqrt(x)
            double recSqrtEst = Math.ReciprocalSqrtEstimate(5);
            Console.WriteLine($"Reciprocal sqrt estimate = {recSqrtEst}");

            // New overloads
            // Min, Max, Abs, Clamp and Sign supports nint and nuint
            (nint a, nint b) = (5, 10);
            nint min = Math.Min(a, b);
            nint max = Math.Max(a, b);
            nint abs = Math.Abs(a);
            nint clamp = Math.Clamp(abs, min, max);
            nint sign = Math.Sign(a);
            Console.WriteLine($"Min = {min}\nMax = {max}\nAbs = {abs}");
            Console.WriteLine($"Clamp = {clamp}\nSign = {sign}");

            // DivRem variants return a tuple
            (int quotient, int remainder) = Math.DivRem(2, 7);
            Console.WriteLine($"Quotient = {quotient}\nRemainder = {remainder}");

            //CollectionsMarshal.GetValueRefOrNullRef
            //这个是在字典中循环或者修改结可变结构体时用, 可以减少结构的副本复制, 也可以避免字典重复进行哈希计算，这个有点晦涩难懂
            Dictionary<int, MyStruct> dictionary = new()
            {
                { 1, new MyStruct { Count = 100 } }
            };
            int key = 1;
            MyStruct values = CollectionsMarshal.GetValueRefOrNullRef(dictionary, key);
            // Returns Unsafe.NullRef<TValue>() if it doesn't exist; check using Unsafe.IsNullRef(ref value)
            if (!Unsafe.IsNullRef(ref values))
            {
                Console.WriteLine(values.Count); // Output: 100

                // Mutate in-place
                values.Count++;
                Console.WriteLine(values.Count); // Output: 101
            }

            return Ok(new { state = 200 });
        }

        /// <summary>
        /// 去重、判断
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-repeat")]
        public async Task<IActionResult> GetRepeat(JsonElement jsonElement) 
        {
            jsonElement.TryGetProperty("datetime", out JsonElement _datetime);
            Dictionary<string, string> prodict = new Dictionary<string, string>() { { "YMPCVCIM", "学情分析模组" }, { "IPDYZYLC", "智慧学校管理服务" }, { "3CLYJ6NP", "AClass ONE智慧学伴" }, { "IPALJ6NY", "数据储存服务空间" },{ "VABAJ6NV", "卷卡合一阅卷系统" } };
            var ste = prodict["IPDYZYLC"];

            List<string> str_str = new List<string>() { "12", "20", "13", "13", "14", "16" };
            List<strend> strends = new List<strend> { new strend { id = 1, name = "12", age = 20 }, new strend { id = 1, name = "13", age = 20 }, new strend { id = 2, name = "22", age = 22 }, new strend { id = 3, name = "23", age = 23 } };
            //str_str.Distinct().ToList();
            strends.Where((x, i) => strends.FindIndex(z => z.id.Equals(x.id)) == i).ToList();
            List<strend> str_strend1 = strends.Where((x, i) => strends.FindIndex(z => z.id.Equals(x.id)) == i).ToList();
            List<strend> str_strend2 = strends.GroupBy(p => p).Select(p => p.Key).ToList();//去重复

            DateTime dt = DateTime.Parse($"{_datetime}");
            int year = dt.Year;

            DateTime dt0 = new DateTime(year, 1, 1);
            int days = (dt.Date - dt0.Date).Days + 1;

            //int pydays = ((lastYear + 1) % 4 == 0 && (lastYear + 1) % 100 != 0 || (lastYear + 1) % 400 == 0) ? 366 : 365;
            int pydays = (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) ? 366 : 365;
            //int pydays = DateTimeHelper.getDays(year);

            return Ok(new { state = 200, pydays, days, strends , str_strend1, str_strend2 , ste  });
        }

        /// <summary>
        /// 计算天数
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-dateday")]
        public async Task<IActionResult> GetDateDay(JsonElement jsonElement) 
        {
            jsonElement.TryGetProperty("year", out JsonElement _year);
            jsonElement.TryGetProperty("moth", out JsonElement _moth);
            int year = int.Parse($"{_year}");
            int day = 0;
            List<int> moths = _moth.ToObject<List<int>>();
            foreach (var item in moths)
            {
                int days = 0;
                switch (item)
                {
                    case 1:
                    case 3:
                    case 5:
                    case 7:
                    case 8:
                    case 10:
                    case 12:
                        days = 31;
                        break;
                    case 4:
                    case 6:
                    case 9:
                    case 11:
                        days = 30;
                        break;

                    case 2:
                        int years = 0;
                        if (item <= 8 && item >= 3)
                            years = year;
                        else
                            years = year+1;

                        if (years % 4 == 0 && year % 100 != 0 || year % 400 == 0)                        
                            days = 29;                        
                        else
                            days = 28;
                        break;                        
                }

                day += days;
            }

            return Ok(new { state = 200, day });
            
        }
        
        /// <summary>
        /// 测试获取传过来的头部
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-xauth")]
        public async Task<IActionResult> GetXAuth(JsonElement jsonElement) 
        {
            string authHeader = this.Request.Headers["Authorization"];//Header中的token
            string _auth = HttpContext.GetXAuth("AuthToken");

            //var (id, name, pic, did, dname, dpic) = HttpJwtAnalysis.GetAuthTokenInfo(HttpContext);


            //var (tmdId, tmdName) = HttpJwtAnalysis.JwtXAuth(_auth, _option);
            var (tmdId, tmdName, pic, did, dname, dpic) = HttpJwtAnalysis.JwtXAuthBI(_auth, _option);

            // var (id, name) = httpXAuth(_auth, _option);

            //string id = null;
            //string name = null;

            //if (!string.IsNullOrWhiteSpace(_auth) && JwtAuthExtension.ValidateApiToken(_auth, _option.JwtSecretKey))
            //{
            //    var jwt = new JwtSecurityTokenHandler().ReadJwtToken(_auth);
            //    id = jwt.Payload.Sub;
            //    name = jwt.Claims.FirstOrDefault(claim => claim.Type.Equals("name"))?.Value;
            //}

            return Ok(new { state = 200, tmdId, tmdName });

        }

        /// <summary>
        /// 测试CosmosDB分页查询
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [HttpPost("get-page")]
        public async Task<IActionResult> cosmosDBPage(JsonElement jsonElement) 
        {
            if (!jsonElement.TryGetProperty("pageSize", out JsonElement pageSize)) return BadRequest();
            if (!jsonElement.TryGetProperty("endPosition", out JsonElement endPosition)) return BadRequest();
            var cosmosClient = _azureCosmos.GetCosmosClient();
            List<School> schools = new List<School>();
            //string sqlTxt = $"SELECT * FROM c where c.code='Base' order by c.id offset {endPosition} limit {pageSize}";
            string sqlTxt = $"SELECT * FROM c order by c.id offset {pageSize} limit {endPosition}";
            await foreach (var tempPage in cosmosClient.GetContainer("TEAMModelOS", "School").GetItemQueryStreamIterator(queryText: sqlTxt, requestOptions:new QueryRequestOptions { PartitionKey = new PartitionKey("Base") }))
            {
                using var json = await JsonDocument.ParseAsync(tempPage.ContentStream);
                if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetInt16() > 0)
                {
                    foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                    {
                        schools.Add(obj.ToObject<School>());
                    }
                }
            }

            return Ok(new { state = 200, schools });
        }


        public class strend
        {
            public int id { get; set; }

            public string name { get; set; }

            public int age { get; set; }
        }

        struct MyStruct
        {
            public int Count { get; set; }
        }

        class Example
        {
            public string? Name { get; set; }
            public string Value { get; set; }
        }

        public record TempSchool
        {
            public long ts { get; set; }
            public string id { get; set; }
            public string name { get; set; }

        }

        public static long GetMonthEnd(DateTimeOffset dt) 
        {
            DateTime dtNew = new DateTime(dt.Year, dt.Month, 1);
            var ste = dtNew.AddMonths(1).AddDays(-1).Day;
            long iLastDay = DateTimeOffset.Parse($"{dt.Year}-{dt.Month}-{ste} 23:59:59").ToUnixTimeSeconds();
            return iLastDay;
        }

        public static long GetMonthStart(DateTimeOffset dt)
        {
            DateTime dtNew = new DateTime(dt.Year, dt.Month, 1);
            long iLastDay = DateTimeOffset.Parse($"{dtNew}").ToUnixTimeSeconds();
            return iLastDay;
        }

        public record lessons 
        {
            public long countB { get; set; }
            public long countP { get; set; }
            public long countT { get; set; }
            public long countPT { get; set; }
            public LessonCount lesson { get; set; }
        }

        public record pageTest
        {
            public string keyt { get; set; }
            public string listv { get; set; }
        }

        public record pageTest1
        {
            public string keyt { get; set; }
            public List<string> listv { get; set; }
        }

        public class GenerateRandom
        {
            /// <summary>
            /// 生成随机数字
            /// </summary>
            /// <param name="length">生成长度</param>
            /// <returns></returns>
            public static string Number(int Length)
            {
                return Number(Length, false);
            }

            /// <summary>
            /// 生成随机数字
            /// </summary>
            /// <param name="Length">生成长度</param>
            /// <param name="Sleep">是否要在生成前将当前线程阻止以避免重复</param>
            /// <returns></returns>
            public static string Number(int Length, bool Sleep)
            {
                if (Sleep)
                    System.Threading.Thread.Sleep(3);
                string result = "";
                System.Random random = new Random();
                for (int i = 0; i < Length; i++)
                {
                    result += random.Next(10).ToString();
                }
                return result;
            }

            /// <summary>
            /// 生成随机字母与数字
            /// </summary>
            /// <param name="IntStr">生成长度</param>
            /// <returns></returns>
            public static string Str(int Length)
            {
                return Str(Length, false);
            }
            /// <summary>
            /// 生成随机字母与数字
            /// </summary>
            /// <param name="Length">生成长度</param>
            /// <param name="Sleep">是否要在生成前将当前线程阻止以避免重复</param>
            /// <returns></returns>
            public static string Str(int Length, bool Sleep)
            {
                if (Sleep)
                    System.Threading.Thread.Sleep(3);
                char[] Pattern = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
                string result = "";
                int n = Pattern.Length;
                System.Random random = new Random(~unchecked((int)DateTime.Now.Ticks));
                for (int i = 0; i < Length; i++)
                {
                    int rnd = random.Next(0, n);
                    result += Pattern[rnd];
                }
                return result;
            }


            /// <summary>
            /// 生成随机纯字母随机数
            /// </summary>
            /// <param name="IntStr">生成长度</param>
            /// <returns></returns>
            public static string Str_char(int Length)
            {
                return Str_char(Length, false);
            }

            /// <summary>
            /// 生成随机纯字母随机数
            /// </summary>
            /// <param name="Length">生成长度</param>
            /// <param name="Sleep">是否要在生成前将当前线程阻止以避免重复</param>
            /// <returns></returns>
            public static string Str_char(int Length, bool Sleep)
            {
                if (Sleep) System.Threading.Thread.Sleep(3);
                //char[] Pattern = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
                char[] Pattern = new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };
                string result = "";
                int n = Pattern.Length;
                System.Random random = new Random(~unchecked((int)DateTime.Now.Ticks));
                for (int i = 0; i < Length; i++)
                {
                    int rnd = random.Next(0, n);
                    result += Pattern[rnd];
                }
                return result;
            }
        }
    }
}