TEAMModelOS/TEAMModelBI/Controllers/RepairApi/SchoolRepController.cs

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Options;
using System.Net.Http;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK;
using TEAMModelOS.Models;
using System.Threading.Tasks;
using System.Text.Json;
using System.IO;
using TEAMModelBI.Models;
using System.Collections.Generic;
using System.Text;
using TEAMModelOS.SDK.Extension;
using System;
using TEAMModelOS.SDK.Models;
using Azure.Cosmos;
using System.Linq;
using TEAMModelOS.SDK.Context.Constant;
using Pipelines.Sockets.Unofficial.Arenas;
using TEAMModelBI.Tool;
using TEAMModelOS.SDK.Models.Cosmos.BI.BISchool;
using TEAMModelOS.SDK.Models.Cosmos.BI;

namespace TEAMModelBI.Controllers.RepairApi
{
    [Route("sccholrep")]
    [ApiController]
    public class SchoolRepController : ControllerBase
    {

        private readonly AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly IConfiguration _configuration;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        private readonly IWebHostEnvironment _environment; //读取文件
        private readonly IHttpClientFactory _httpClient;

        public SchoolRepController(AzureCosmosFactory azureCosmos, DingDing dingDing, AzureStorageFactory azureStorage, IOptionsSnapshot<Option> option, AzureRedisFactory azureRedis, IConfiguration configuration, CoreAPIHttpService coreAPIHttpService, IHttpClientFactory httpClient, IWebHostEnvironment hostingEnvironment)
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _azureStorage = azureStorage;
            _option = option?.Value;
            _azureRedis = azureRedis;
            _configuration = configuration;
            _coreAPIHttpService = coreAPIHttpService;
            _httpClient = httpClient;
            _environment = hostingEnvironment;
        }

        /// <summary>
        /// 添加新学段的学校
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-allscperiod")]
        public async Task<IActionResult> SetAllScPeriod(JsonElement jsonElement)
        {
            jsonElement.TryGetProperty("Language", out JsonElement Language);
            jsonElement.TryGetProperty("scId", out JsonElement scId);
            jsonElement.TryGetProperty("periodName", out JsonElement periodName);
            var cosmosClient = _azureCosmos.GetCosmosClient();
            var builder = $"{_environment.ContentRootPath}/JsonFile/Preset/LangSchoolConfig.json";
            StreamReader streamReader = new(new FileStream(builder, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.UTF8);
            StringBuilder stringBuilder = new();
            string text;
            string scName = "默认学段";
            while ((text = streamReader.ReadLine()) != null)
            {
                stringBuilder.Append(text.ToString());
            }
            streamReader.Close();
            string input = stringBuilder.ToString();
            List<SchoolConfig> schoolConfigs = input.ToObject<List<SchoolConfig>>();
            SchoolConfig schoolConfig = null;
            if (!string.IsNullOrEmpty($"{Language}"))
                schoolConfig = schoolConfigs.Find(x => x.Lang.Contains($"{Language}"));

            if (schoolConfig == null)
            {
                if ($"{Language}".Contains("en"))
                    schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("en-US"));
                else
                    schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("zh-CN"));
            }
            string campusId = Guid.NewGuid().ToString();

            StringBuilder noPeriodScSql = new("SELECT value(c) FROM c ");
            List<School> allSc = new();

            if (!string.IsNullOrEmpty($"{scId}"))
                noPeriodScSql.Append($" where c.id='{scId}'");
            else
                noPeriodScSql.Append($" join sp in c.period where c.code = 'Base' AND ARRAY_LENGTH(sp.grades) = 0 OR ARRAY_LENGTH(sp.subjects) = 0");

            if (!string.IsNullOrEmpty($"{periodName}"))
                scName = $"{periodName}";

            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<School>(queryText: "select value(c) from c where c.code='Base' and c.period=[]", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") }))
            {
                allSc.Add(item);
            }

            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<School>(queryText: noPeriodScSql.ToString(), requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") }))
            {
                allSc.Add(item);
            }

            foreach (var school in allSc)
            {
                if (school.name.Contains("幼儿园"))
                {
                    string name = null;
                    List<Subject> subjects = new();
                    switch ($"{Language}")
                    {
                        case "zh-CN":
                            name = "学前";
                            subjects.Add(new Subject { id = Guid.NewGuid().ToString(), name = "语言", type = 1 });
                            break;
                        case "zh-TW":
                            name = "學前";
                            subjects.Add(new Subject { id = Guid.NewGuid().ToString(), name = "語言", type = 1 });
                            break;
                        case "en-US":
                            name = "Pre-school";
                            subjects.Add(new Subject { id = Guid.NewGuid().ToString(), name = "language", type = 1 });
                            break;
                    }
                    if (school.period.Count > 0)
                    {
                        var grade = school.period.Find(sg => sg.grades.Count == 0);
                        if (grade.grades.Count == 0)
                            grade.grades = new List<string>() { name };

                        var tempSub = school.period.Find(sg => sg.semesters.Count == 0);
                        if (tempSub.semesters.Count == 0)
                            tempSub.subjects = subjects;
                    }
                    else
                    {
                        if (school.campuses.Count > 0)
                            campusId = school.campuses.Select(x => x.id).FirstOrDefault().ToString();

                        school.period.Add(new Period
                        {
                            id = Guid.NewGuid().ToString(),
                            name = scName,
                            grades = new List<string>() { name },
                            campusId = campusId,
                            subjects = subjects,
                            semesters = new List<Semester>() { new Semester { name = schoolConfig.semester[0].term, start = schoolConfig.semester[0].start, month = schoolConfig.semester[0].month, day = schoolConfig.semester[0].day, id = Guid.NewGuid().ToString() } }
                        });

                        if (!school.campuses.Select(x => x.id).Contains(campusId))
                            school.campuses.Add(new Campus { name = school.name, id = campusId });
                    }
                }
                else
                {
                    if (school.period.Count > 0)
                    {
                        var grade = school.period.Find(sg => sg.grades.Count == 0);
                        if (grade.grades.Count == 0)
                            grade.grades = schoolConfig.grades;

                        var subject = school.period.Find(sg => sg.subjects.Count == 0);
                        if (subject.subjects.Count == 0)
                        {
                            subject.subjects = new List<Subject>() {
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[0].name,type=schoolConfig.PresetSubject[0].type },
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[1].name,type=schoolConfig.PresetSubject[1].type },
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[2].name,type=schoolConfig.PresetSubject[2].type }
                            };
                        }
                    }
                    else
                    {
                        if (school.campuses.Count > 0)
                            campusId = school.campuses.Select(x => x.id).FirstOrDefault().ToString();

                        school.period.Add(new Period
                        {
                            id = Guid.NewGuid().ToString(),
                            name = scName,
                            campusId = campusId,
                            semesters = new List<Semester>() {
                                new Semester { name = schoolConfig.semester[0].term, start = schoolConfig.semester[0].start, month = schoolConfig.semester[0].month, day = schoolConfig.semester[0].day, id = Guid.NewGuid().ToString() },
                                new Semester { name = schoolConfig.semester[1].term, start = schoolConfig.semester[1].start, month = schoolConfig.semester[1].month, day = schoolConfig.semester[1].day, id = Guid.NewGuid().ToString() }
                            },
                            subjects = new List<Subject>() {
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[0].name,type=schoolConfig.PresetSubject[0].type },
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[1].name,type=schoolConfig.PresetSubject[1].type },
                                new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[2].name,type=schoolConfig.PresetSubject[2].type }
                            },
                            grades = schoolConfig.grades,
                            analysis = new Analysis()
                            {
                                type = new List<ExamSimple>() {
                                    new ExamSimple { id = Guid.NewGuid().ToString(), name = schoolConfig.PresetExam[0].type[0].name },
                                    new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[1].name },
                                    new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[2].name },
                                    new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[3].name }
                                },
                                income = schoolConfig.PresetExam[0].income,
                                eugenics = schoolConfig.PresetExam[0].eugenics,
                                touch = schoolConfig.PresetExam[0].touch
                            }
                        });
                        if (!school.campuses.Select(x => x.id).Contains(campusId))
                            school.campuses.Add(new Campus { name = school.name, id = campusId });
                    }
                }

                School rSchool = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, school.id, new PartitionKey("Base"));
            }

            return Ok(new { state = RespondCode.Ok });
        }

        /// <summary>
        /// 新增学校学段（多个）
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-scperiod")]
        public async Task<IActionResult> SetScPeriod(JsonElement jsonElement)
        {
            if (!jsonElement.TryGetProperty("scId", out JsonElement scId)) return BadRequest();
            if (!jsonElement.TryGetProperty("periodName", out JsonElement periodName)) return BadRequest();

            List<string> periodNames = $"{periodName}".ToObject<List<string>>();
            jsonElement.TryGetProperty("Language", out JsonElement Language);

            var cosmosClient = _azureCosmos.GetCosmosClient();
            var builder = $"{_environment.ContentRootPath}/JsonFile/Preset/LangSchoolConfig.json";
            StreamReader streamReader = new(new FileStream(builder, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.UTF8);
            StringBuilder stringBuilder = new();
            string text;
            while ((text = streamReader.ReadLine()) != null)
            {
                stringBuilder.Append(text.ToString());
            }
            streamReader.Close();
            string input = stringBuilder.ToString();
            List<SchoolConfig> schoolConfigs = input.ToObject<List<SchoolConfig>>();
            SchoolConfig schoolConfig = null;
            if (!string.IsNullOrEmpty($"{Language}"))
                schoolConfig = schoolConfigs.Find(x => x.Lang.Contains($"{Language}"));

            if (schoolConfig == null)
            {
                if ($"{Language}".Contains("en"))
                    schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("en-US"));
                else
                    schoolConfig = schoolConfigs.Find(x => x.Lang.Contains("zh-CN"));
            }
            string campusId = Guid.NewGuid().ToString();
            School school = null;

            school = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>($"{scId}", new PartitionKey("Base"));

            if (school != null)
            {
                foreach (var item in periodNames)
                {
                    if (school.campuses.Count > 0)
                        campusId = school.campuses.Select(x => x.id).FirstOrDefault().ToString();

                    school.period.Add(new Period
                    {
                        id = Guid.NewGuid().ToString(),
                        name = item,
                        campusId = campusId,
                        semesters = new List<Semester>() { new Semester { name = schoolConfig.semester[0].term, start = schoolConfig.semester[0].start, month = schoolConfig.semester[0].month, day = schoolConfig.semester[0].day, id = Guid.NewGuid().ToString() },
                        new Semester { name = schoolConfig.semester[1].term, start = schoolConfig.semester[1].start, month = schoolConfig.semester[1].month, day = schoolConfig.semester[1].day, id = Guid.NewGuid().ToString() } },
                        subjects = new List<Subject>() {
                        new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[0].name,type=schoolConfig.PresetSubject[0].type },
                        new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[1].name,type=schoolConfig.PresetSubject[1].type },
                        new Subject { id=Guid.NewGuid().ToString(),name=schoolConfig.PresetSubject[2].name,type=schoolConfig.PresetSubject[2].type }
                        },
                        grades = schoolConfig.grades,
                        analysis = new Analysis()
                        {
                            type = new List<ExamSimple>() { new ExamSimple { id = Guid.NewGuid().ToString(), name = schoolConfig.PresetExam[0].type[0].name },
                        new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[1].name },
                        new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[2].name },
                        new ExamSimple { id = Guid.NewGuid().ToString(), name =  schoolConfig.PresetExam[0].type[3].name } },
                            income = schoolConfig.PresetExam[0].income,
                            eugenics = schoolConfig.PresetExam[0].eugenics,
                            touch = schoolConfig.PresetExam[0].touch
                        }
                    });
                }

                if (!school.campuses.Select(x => x.id).Contains(campusId))
                    school.campuses.Add(new Campus { name = school.name, id = campusId });
            }

            school = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, school.id, new PartitionKey("Base"));

            return Ok(new { state = RespondCode.Ok, school });
        }

        /// <summary>
        /// 学校信息中间件查询和修复接口
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("set-allscinfos")]
        public async Task<IActionResult> SetAllScInfos(JsonElement jsonElement)
        {
            try
            {
                var cosmosClient = _azureCosmos.GetCosmosClient();
                List<string> scId = await CommonFind.FindScIds(cosmosClient, "select value(c.id) from c ", "Base");
                List<BIRelation> scInfos = new();
                foreach (var itemId in scId)
                {
                    BIRelation bIRelation = null;
                    var resRel = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync(itemId, new PartitionKey("BIRel"));
                    if (resRel.Status == 200)
                    {
                        continue;
                        //using var fileJson = await JsonDocument.ParseAsync(resRel.ContentStream);
                        //bIRelation = fileJson.ToObject<BIRelation>();
                    }
                    else
                    {
                        ScBaseInfo scBaseInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<ScBaseInfo>(itemId, new PartitionKey("Base"));
                        string areaName = null;
                        if (!string.IsNullOrEmpty(scBaseInfo.areaId))
                        {
                            await foreach (var itemName in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<string>(queryText: $"select value(c.name) from c where c.pk='Area' and c.id='{scBaseInfo.areaId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base-Area") }))
                            {
                                areaName = itemName;
                            }
                        }

                        bIRelation = new BIRelation()
                        {
                            id = scBaseInfo.id,
                            name = scBaseInfo.name,
                            picture = scBaseInfo.picture,
                            size = scBaseInfo.size,
                            createDate = scBaseInfo.createTime,
                            region = scBaseInfo.region,
                            province = scBaseInfo.province,
                            city = scBaseInfo.city,
                            dist = scBaseInfo.dist,
                            address = scBaseInfo.address,
                            areaId = scBaseInfo.areaId,
                            scale = scBaseInfo.scale,
                            areaName = areaName,
                            upDate = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
                        };

                        var response = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync(itemId, new PartitionKey("ProductSum"));
                        if (response.Status == 200)
                        {
                            using var json = await JsonDocument.ParseAsync(response.ContentStream);
                            if (json.RootElement.TryGetProperty("serial", out JsonElement serial) && !serial.ValueKind.Equals(JsonValueKind.Null))
                            {
                                List<string> serials = serial.ToObject<List<SchoolProductSumData>>().Select(x => x.prodCode).ToList();
                                bIRelation.serial = serials;
                            }
                            if (json.RootElement.TryGetProperty("service", out JsonElement service) && !service.ValueKind.Equals(JsonValueKind.Null))
                            {
                                List<string> services = service.ToObject<List<SchoolProductSumData>>().Select(x => x.prodCode).ToList();
                                bIRelation.service = services;
                            }
                            if (json.RootElement.TryGetProperty("hard", out JsonElement hard) && !hard.ValueKind.Equals(JsonValueKind.Null))
                            {
                                List<string> hards = hard.ToObject<List<SchoolProductSumDataHard>>().Select(x => x.prodCode).ToList();
                                bIRelation.hard = hards;
                            }
                        }
                        bIRelation = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<BIRelation>(bIRelation, new PartitionKey("BIRel"));
                    }

                    scInfos.Add(bIRelation);
                }

                return Ok(new { state = RespondCode.Ok, cnt = scId.Count, scInfos });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI，{_option.Location}，/sccholrep/set-allscinfos \n{ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

    }
}