TEAMModelOS/TEAMModelOS/Controllers/XTest/TestController.cs

using Azure.Cosmos;
using Azure.Messaging.ServiceBus;
using Azure.Storage.Blobs.Models;
using HTEXLib.COMM.Helpers;
using HTEXLib.Helpers.ShapeHelpers;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.International.Converters.PinYinConverter;
using Microsoft.International.Converters.TraditionalChineseToSimplifiedConverter;
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models;
using TEAMModelOS.SDK.Models.Cosmos.Common;
using TEAMModelOS.Services.Common;
using static TEAMModelOS.SDK.Models.Teacher;
using static TEAMModelOS.SDK.SchoolService;

namespace TEAMModelOS.Controllers
{
    [Route("test")]
    [ApiController]
    public class TestController : ControllerBase
    {
        private readonly HttpClient _httpClient;
        public IWebHostEnvironment _environment { get; set; }
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly AzureServiceBusFactory _serviceBus;
        public IConfiguration _configuration { get; set; }
        public TestController(HttpClient httpClient,IWebHostEnvironment environment, AzureCosmosFactory azureCosmos, AzureRedisFactory azureRedis, AzureStorageFactory azureStorage, IConfiguration configuration, AzureServiceBusFactory serviceBus, DingDing dingDing)
        {
            _azureCosmos = azureCosmos;
            _azureRedis = azureRedis;
            _azureStorage = azureStorage;
            _dingDing = dingDing;
            _serviceBus = serviceBus; _configuration = configuration;
            _environment = environment;
            _httpClient= httpClient;
        }
         
      
        /*
[
{"method":"台北市","params":{"CountryId":"TW","CityId":"30"}},1
{"method":"新北市","params":{"CountryId":"TW","CityId":"01"}},1
{"method":"桃园市","params":{"CountryId":"TW","CityId":"03"}},1
{"method":"台中市","params":{"CountryId":"TW","CityId":"66"}},1
{"method":"台南市","params":{"CountryId":"TW","CityId":"67"}},1
{"method":"高雄市","params":{"CountryId":"TW","CityId":"64"}},1
{"method":"基隆市","params":{"CountryId":"TW","CityId":"17"}},1
{"method":"新竹市","params":{"CountryId":"TW","CityId":"18"}},1
{"method":"嘉义市","params":{"CountryId":"TW","CityId":"20"}},1
{"method":"新竹县","params":{"CountryId":"TW","CityId":"04"}},1
{"method":"苗栗县","params":{"CountryId":"TW","CityId":"05"}},1
{"method":"彰化县","params":{"CountryId":"TW","CityId":"07"}},1
{"method":"南投县","params":{"CountryId":"TW","CityId":"08"}},1
{"method":"云林县","params":{"CountryId":"TW","CityId":"09"}},1
{"method":"嘉义县","params":{"CountryId":"TW","CityId":"10"}},1
{"method":"屏东县","params":{"CountryId":"TW","CityId":"13"}},1
{"method":"宜兰县","params":{"CountryId":"TW","CityId":"02"}},1
{"method":"花莲县","params":{"CountryId":"TW","CityId":"15"}},1
{"method":"台东县","params":{"CountryId":"TW","CityId":"14"}},1
{"method":"澎湖县","params":{"CountryId":"TW","CityId":"16"}},1
{"method":"金门县","params":{"CountryId":"TW","CityId":"71"}},
{"method":"连江县","params":{"CountryId":"TW","CityId":"72"}}
]
        
         */
        /// <summary>
        /// 测试blob多线程写入同一个文件
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-schools")]
        public async Task<IActionResult> GetSchools(JsonElement json) {

            string msg = "{\"standard\":\"standard3\",\"tmdids\":[\"1635136038\"],\"school\":\"pbjyey\",\"update\":[\"TeacherAbility\"],\"statistics\":0}";
            try
            {
                // await _dingDing.SendBotMsg($"teacher-train-change\n{msg}",GroupNames.成都开发測試群組);
                TeacherTrainChange change = msg.ToObject<TeacherTrainChange>();
                
                var client = _azureCosmos.GetCosmosClient();
                string insql = $"where c.id in ({string.Join(",", change.tmdids.Select(x => $"'{x}'"))})";
                string selsql = $"select value(c) from c {insql} ";
                List<TeacherTrain> teacherTrains = new List<TeacherTrain>();

                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Teacher").GetItemQueryIterator<TeacherTrain>(queryText: selsql,
                      requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"TeacherTrain-{change.school}") }))
                {
                    teacherTrains.Add(item);
                }

                if (change.statistics != 1)
                {

                    List<Task<ItemResponse<TeacherTrain>>> task = new List<Task<ItemResponse<TeacherTrain>>>();
                    teacherTrains.ForEach(x =>
                    {
                        x.update.UnionWith(change.update);
                        task.Add(client.GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync<TeacherTrain>(x, x.id, new PartitionKey($"TeacherTrain-{change.school}")));
                    });
                    await task.TaskPage(5);
                    var unchange = change.tmdids.Except(teacherTrains.Select(x => x.id));
                    if (unchange != null)
                    {
                        task.Clear();
                        unchange.ToList().ForEach(x =>
                        {
                            TeacherTrain teacherTrain = new TeacherTrain
                            {
                                pk = "TeacherTrain",
                                id = x,
                                code = $"TeacherTrain-{change.school}",
                                tmdid = x,
                                school = change.school,
                                update = new HashSet<string> {  StatisticsService.TeacherAbility,
                        StatisticsService.TeacherClass, StatisticsService.OfflineRecord }
                            };
                            teacherTrain.update.UnionWith(change.update);
                            task.Add(client.GetContainer(Constant.TEAMModelOS, "Teacher").UpsertItemAsync<TeacherTrain>(teacherTrain, new PartitionKey($"TeacherTrain-{change.school}")));
                        });
                        await task.TaskPage(1);
                    }
                }
                else
                {
                    Area area = null;
                    string sql = $"select value(c) from c where c.standard='{change.standard}'";
                    await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Area>(queryText: sql,
                          requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base-Area") }))
                    {
                        area = item;
                    }
                    AreaSetting setting = null;
                    if (area != null)
                    {
                        try
                        {
                            //优先找校级
                            setting = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<AreaSetting>(change.school, new PartitionKey("AreaSetting"));
                        }
                        catch (CosmosException)
                        {
                            try
                            {
                                setting = await client.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemAsync<AreaSetting>(area.id, new PartitionKey("AreaSetting"));
                            }
                            catch (CosmosException)
                            {
                                setting = null;
                            }
                        }
                    }
                    if (setting == null)
                    {
                        setting = new AreaSetting
                        {
                            allTime = 50,
                            classTime = 5,
                            submitTime = 15,
                            onlineTime = 20,
                            offlineTime = 10,
                            lessonMinutes = 45,
                        };
                    }
                    List<Task<TeacherTrain>> task = new List<Task<TeacherTrain>>();
                    teacherTrains.ForEach(x =>
                    {
                        x.update.UnionWith(change.update);
                        task.Add(StatisticsService.StatisticsTeacher(x, setting, area, client, null));
                    });
                    await task.TaskPage(1);
                    var unchange = change.tmdids.Except(teacherTrains.Select(x => x.id));
                    if (unchange != null)
                    {
                        task.Clear();
                        unchange.ToList().ForEach(x =>
                        {
                            task.Add(StatisticsService.StatisticsTeacher(new TeacherTrain
                            {
                                pk = "TeacherTrain",
                                id = x,
                                code = $"TeacherTrain-{change.school}",
                                tmdid = x,
                                school = change.school,
                                update = new HashSet<string> {  StatisticsService.TeacherAbility,
                                StatisticsService.TeacherClass, StatisticsService.OfflineRecord }
                            }, setting, area, client, null));
                        });
                        await task.TaskPage(1);
                    }
                }
            }
            catch (CosmosException ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-研修数据变更，重新统计-TeacherTrainChange\n{msg}\n{ex.Message}\n{ex.StackTrace}CosmosException{ex.Status}", GroupNames.成都开发測試群組);
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-研修数据变更，重新统计-TeacherTrainChange\n{msg}\n{ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
            }
            /*
            string path = $"{_environment.ContentRootPath}/JsonFile/Core/city.json";
            StreamReader streamReader = new StreamReader(new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.UTF8);
            StringBuilder stringBuilder = new StringBuilder();
            string text;
            while ((text = streamReader.ReadLine()) != null)
            {
                stringBuilder.Append(text.ToString());
            }

            streamReader.Close();
            string input = stringBuilder.ToString();
            List<string> region = new List<string>() {
                "110000", "110100", "110200",
                "120000", "120100", "120200",
                "310000", "310100", "310200",
                "500000", "500100", "810100",
                "810200", "810300", "820100",
                "820200", "820300"
            };
            List<string> cityids = new List<string>() {
                "30","01","03","66","67","64","17","18","20","04","05","07","08","09","10","13","02","15","14","16","71","72"
            };
            Dictionary<string, List<CodeName>> regions = input.ToObject<Dictionary<string, List<CodeName>>>();
            List<List<string>> datas = new List<List<string>>() { region };
            foreach (var r in regions)
            {
                if (!region.Contains(r.Key) && !r.Key.StartsWith("71"))
                {
                    datas.Add(r.Value.Select(x => x.code).ToList());
                }
            }
            List<Task<List<SchoolInfo>>> tasks = new List<Task<List<SchoolInfo>>>();
            //datas.ForEach(x =>
            //{
            //   tasks.Add(GetSchoolAsync(x));
            //});
            List<SchoolInfo> schoolInfos = new List<SchoolInfo>();
            //var schools = await Task.WhenAll(tasks);
            //var schools =await GetSchoolAsync(cityids);
            // schoolInfos.AddRange(schools);
            //foreach (var schs in schools)
            //{
            //    schoolInfos.AddRange(schs);
            //}
            List<string> nodatas = new List<string>();
            foreach (var data in datas) {
                (List<SchoolInfo> schoolIn, List<string> nodata)  = await GetSchoolAsync(data);
                schoolInfos.AddRange(schoolIn);
                nodatas.AddRange(nodata);
            }
            await _dingDing.SendBotMsg($"os,test,{nodatas.ToJsonString()}", GroupNames.成都开发測試群組);
            return Ok(schoolInfos);
            */
            return Ok();
        }

        public   async Task<(List<SchoolInfo> schoolInfos,List<string> nodata)> GetSchoolAsync(List<string> regions) {
            List < SchoolInfo > schools= new List<SchoolInfo>();
            List<string> nodata = new List<string>();
            foreach (var region in regions) {
                Dictionary<string, object> data = new Dictionary<string, object>();
                data.Add("method", "api/School/getSchool");
                data.Add("params", new { CountryId = "CN", CityId = region });
                HttpResponseMessage responseMessage = await _httpClient.PostAsJsonAsync("https://contest.teammodel.cn/api/School/getSchool", data);
                if (responseMessage.StatusCode == HttpStatusCode.OK)
                {
                    string Content = await responseMessage.Content.ReadAsStringAsync();
                    try {
                        Content.ToObject<JsonElement>().TryGetProperty("result", out JsonElement content);
                        if (content.ValueKind.Equals(JsonValueKind.Object) &&  content.TryGetProperty("data", out JsonElement _data))
                        {
                            if (_data.ValueKind.Equals(JsonValueKind.Array))
                            {
                                List<SchoolInfo> infos = _data.ToObject<List<SchoolInfo>>();
                                if (infos.IsNotEmpty())
                                {
                                    schools.AddRange(infos.Where(x => x.name != null && x.cityName != null).ToList());
                                }
                            }
                            else {
                                nodata.Add(data.ToJsonString());
                                continue;
                            }
                        }
                        else { nodata.Add(data.ToJsonString()); 
                            continue; }
                    } catch (Exception ex) {
                        nodata.Add(data.ToJsonString());
                        throw new Exception(ex.Message,ex.InnerException);
                    }
                }
            }
            return (schools, nodata); 
        
        }
        public class SchoolInfo
        {
            public string typeName { get; set; }
            public string provinceName { get; set; }
            public string provinceId { get; set; }
            public string id { get; set; }
            public string name { get; set; }
            public string cityId { get; set; }
            public string cityName { get; set; }
            public string address { get; set; }
        }
        public class CodeName
        {
            public string code { get; set; }
            public string name { get; set; }
        }
        /// <summary>
        /// 测试blob多线程写入同一个文件
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("generate-school-codes")]
        public async Task<IActionResult> GenerateSchoolCodes(JsonElement json)
        {
            List<SchoolData> schoolss = json.GetProperty("schools").ToObject<List<SchoolData>>();
            dynamic data = await  SchoolService.GenerateSchoolCode(schoolss, _dingDing, _environment);
            return Ok(data);
        }


        /// <summary>
        /// 测试blob多线程写入同一个文件
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("blobroot")]
        public async Task<IActionResult> MultipleBlob(JsonElement jsonMsg)
        {
            if (jsonMsg.TryGetProperty("name", out JsonElement name) && name.ValueKind == JsonValueKind.String
                    && jsonMsg.TryGetProperty("root", out JsonElement root) && root.ValueKind == JsonValueKind.String)
            {
                List<Dictionary<string, double?>> list = new List<Dictionary<string, double?>>();
                string u = System.Web.HttpUtility.UrlDecode($"{root}", Encoding.UTF8).Split("/")[0];
                var client = _azureStorage.GetBlobContainerClient($"{name}");
                var size = await client.GetBlobsSize(u);
                await _azureRedis.GetRedisClient(8).SortedSetRemoveAsync($"Blob:Catalog:{name}", u);
                await _azureRedis.GetRedisClient(8).SortedSetIncrementAsync($"Blob:Catalog:{name}", u, size.HasValue ? size.Value : 0);
                var scores = await _azureRedis.GetRedisClient(8).SortedSetRangeByRankWithScoresAsync($"Blob:Catalog:{name}");
                double blobsize = 0;
                if (scores != default && scores != null)
                {
                    foreach (var score in scores)
                    {
                        blobsize = blobsize + score.Score;
                        list.Add(new Dictionary<string, double?>() { { score.Element.ToString(), score.Score } });
                    }
                }
                await _azureRedis.GetRedisClient(8).HashSetAsync($"Blob:Record", new RedisValue($"{name}"), new RedisValue($"{blobsize}"));

                await _dingDing.SendBotMsg($"{Environment.GetEnvironmentVariable("Option:Location")}-ServiceBus,Blob() 容器:{name}使用:{root}，文件分类：{list.ToJsonString()}",
                    GroupNames.成都开发測試群組);
                return Ok(list);
            }
            else
            {
                return Ok();
            }

        }

        private async Task<int> SendNotification()
        {


            HttpClient _httpClient = new HttpClient();
            //  _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {token.AccessToken}");
            var pa = new { grant_type = "device", client_id = "9794e418-c4ef-4fd5-a42d-accaa2d96d6e", client_secret = "ruL?I79h0w1AZaZXtBaZeZuQLQXLa=:-" };
            HttpResponseMessage responseMessage = await _httpClient.PostAsJsonAsync("https://api2-rc.teammodel.net/oauth2/token", pa);
            if (responseMessage.StatusCode == HttpStatusCode.OK)
            {
                return 200;
            }
            else if (responseMessage.StatusCode == HttpStatusCode.Unauthorized)
            {
                return 401;
            }
            else
            {
                return 500;
            }
        }

        /// <summary>
        /// 测试redis通配符
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpGet("test-delete-read")]
        public async Task<IActionResult> TestDelete()
        {

            foreach (var cnt in _azureStorage.GetBlobServiceClient().GetBlobContainers())
            {
                Console.WriteLine(cnt.Name);
            }

            await SendNotification();
            var client = _azureCosmos.GetCosmosClient();
            string aaa = "0";
            try
            {
                ItemResponse<Student> a = await client.GetContainer(Constant.TEAMModelOS, "Student").DeleteItemAsync<Student>("1111111", new PartitionKey($"Course-111111"));
                Ok(a.GetRawResponse().Status);
            }
            catch (CosmosException ex)
            {
                if (ex.Response.Status == 404)
                {
                    aaa = "404";
                }
            }

            try
            {
                ItemResponse<Student> a = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemAsync<Student>("1111111", new PartitionKey($"Course-111111"));
                Ok(a.GetRawResponse().Status);
            }
            catch (CosmosException ex)
            {
                if (ex.Response.Status == 404)
                {
                    aaa = aaa + " 404";
                }
            }
            try
            {
                var a = await client.GetContainer(Constant.TEAMModelOS, "Student").DeleteItemStreamAsync("1111111", new PartitionKey($"Course-111111"));
                Ok(a.Status);
            }
            catch (CosmosException ex)
            {
                if (ex.Response.Status == 404)
                {
                    aaa = "404";
                }
            }

            try
            {
                var a = await client.GetContainer(Constant.TEAMModelOS, "Student").ReadItemStreamAsync("1111111", new PartitionKey($"Course-111111"));
                Ok(a.Status);
            }
            catch (CosmosException ex)
            {
                if (ex.Response.Status == 404)
                {
                    aaa = aaa + " 404";
                }
            }
            return Ok(new { aaa });
        }
        /// <summary>
        /// 测试redis通配符
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpGet("test-redis")]
        public async Task<IActionResult> TestRedis()
        {

            try
            {
                var client = _azureCosmos.GetCosmosClient();
                List<ItemInfo> items = new List<ItemInfo>();
                var queryslt = $"SELECT  value(c) FROM c where  c.pid = null ";
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<ItemInfo>(queryText: queryslt, requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Item-hbcn") }))
                {

                    items.Add(item);
                }
                List<ItemCond> itemConds = new List<ItemCond>();
                items.GroupBy(x => x.periodId).Select(y => new { key = y.Key, list = y.ToList() }).ToList().ForEach(z =>
                {
                    ItemCond cond = new ItemCond() { id = z.key, code = $"ItemCond-hbcn", pk = "ItemCond", ttl = -1, count = z.list.Count, grades = new List<GradeCount>(), subjects = new List<SubjectCount>() };
                    z.list.ForEach(y =>
                    {
                        ItemService.CountItemCond(y, null, cond);
                    });

                    itemConds.Add(cond);
                });
                itemConds.ForEach(async cond =>
                {
                    await client.GetContainer(Constant.TEAMModelOS, "School").UpsertItemAsync<ItemCond>(cond, new PartitionKey(cond.code));
                });
                return Ok(new { itemConds });
            }
            catch (Exception ex) { await _dingDing.SendBotMsg($"TEAMModelFunction，ActivityHttpTrigger，fix-itemcond()\n{ex.Message}{ex.StackTrace}", GroupNames.醍摩豆服務運維群組); }
            return Ok(new { });

        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("fix-blob-content")]
        public async Task<IActionResult> FixBlobContent(JsonElement request)
        {
            try
            {
                if (!request.TryGetProperty("name", out JsonElement name)) return BadRequest();
                if (!request.TryGetProperty("scope", out JsonElement _scope)) return BadRequest();


                var client = _azureCosmos.GetCosmosClient();
                List<string> prefixs = new List<string>() { "audio", "doc", "image", "other", "res", "video", "thum" };
                var ContainerClient = _azureStorage.GetBlobContainerClient($"{name}");
                string scope = "private";


                scope = $"{_scope}";

                var tb = "Teacher";
                if (scope != "private")
                {
                    tb = "School";
                }
                long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

                foreach (var prefix in prefixs)
                {
                    List<string> items = await ContainerClient.List(prefix);
                    foreach (var item in items)
                    {
                        var urlsSize = await ContainerClient.GetBlobsSize(item);
                        Bloblog bloblog = new Bloblog { id = Guid.NewGuid().ToString(), code = $"Bloblog-{name}", pk = "Bloblog", time = now, size = urlsSize != null && urlsSize.HasValue ? urlsSize.Value : 0, type = prefix };
                        await client.GetContainer(Constant.TEAMModelOS, tb).UpsertItemAsync(bloblog, new Azure.Cosmos.PartitionKey(bloblog.code));
                    }
                }


                return new OkObjectResult(new { });

            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"TEAMModelFunction，ActivityHttpTrigger，fix-blob-content()\n{ex.Message}{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
                return new BadRequestResult();
            }
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        //[AuthToken(Roles = "teacher")]
        [HttpPost("get-data")]
        public async Task<IActionResult> GetData(JsonElement request)
        {
            try
            {
                var client = _azureCosmos.GetCosmosClient();

                return Ok(new { code = 1 });
            }
            catch (Exception e)
            {
                return BadRequest(e.StackTrace);
            }
        }
    }

}