TEAMModelOS/TEAMModelBI/Controllers/BINormal/BatchAreaController.cs

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Models;
using Azure.Cosmos;
using System.Text.Json;
using HTEXLib.COMM.Helpers;
using TEAMModelOS.SDK.Models.Cosmos.Common;
using TEAMModelOS.SDK.Models.Cosmos.BI;
using Azure.Messaging.ServiceBus;
using TEAMModelOS.SDK.Extension;
using TEAMModelBI.Filter;
using TEAMModelBI.Tool.Extension;
using TEAMModelBI.Tool;
using Azure.Storage.Blobs.Models;
using Azure;
using Azure.Storage.Blobs.Specialized;
using System.Net.Http;
using System.Net.Http.Json;
using System.Net;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.Context.BI;
using TEAMModelOS.SDK.DI.CoreAPI;
using System.Text;
using DocumentFormat.OpenXml.Bibliography;
using Microsoft.Extensions.Hosting;
using Microsoft.AspNetCore.Hosting;
using static TEAMModelBI.Controllers.RepairApi.InitialAreaController;
using TEAMModelOS.SDK.Context.Constant;

namespace TEAMModelBI.Controllers.BINormal
{
    [Route("batcharea")]
    [ApiController]
    public class BatchAreaController : ControllerBase
    {
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly DingDing _dingDing;
        private readonly Option _option;
        private readonly AzureStorageFactory _azureStorage;
        private readonly IConfiguration _configuration;
        private readonly NotificationService _notificationService;
        private readonly AzureServiceBusFactory _serviceBus;
        private readonly IHttpClientFactory _http;
        private readonly CoreAPIHttpService _coreAPIHttpService;
        private readonly IWebHostEnvironment _environment; //读取文件

        public BatchAreaController(AzureCosmosFactory azureCosmos, DingDing dingDing, AzureStorageFactory azureStorage, IOptionsSnapshot<Option> option, IConfiguration configuration, NotificationService notificationService, AzureServiceBusFactory serviceBus, IHttpClientFactory http, CoreAPIHttpService coreAPIHttpService, IWebHostEnvironment hostingEnvironment) 
        {
            _azureCosmos = azureCosmos;
            _dingDing = dingDing;
            _azureStorage = azureStorage;
            _option = option?.Value;
            _configuration = configuration;
            _notificationService = notificationService;
            _serviceBus = serviceBus;
            _http = http;
            _coreAPIHttpService = coreAPIHttpService;
            _environment = hostingEnvironment;
        }

        /// <summary>
        /// 查询所有的区域标准    //已对接
        /// </summary>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-areas")]
        public async Task<IActionResult> GetArea(JsonElement jsonElement)
        {
            try
            {
                jsonElement.TryGetProperty("id", out JsonElement id);
                jsonElement.TryGetProperty("name", out JsonElement name);
                //jsonElement.TryGetProperty("site", out JsonElement site);//分开部署，就不需要，一站多用时，取消注释

                int? pageSize = 100;      //默认不指定返回大小        
                string continuationToken = string.Empty;     //返给前端分页token           
                string pageToken = default;//接受前端的分页Tolen
                bool iscontinuation = false;//是否需要进行分页查询，默认不分页
                if (jsonElement.TryGetProperty("pageSize", out JsonElement jsonPageSize))
                {
                    if (!jsonPageSize.ValueKind.Equals(JsonValueKind.Undefined) && !jsonPageSize.ValueKind.Equals(JsonValueKind.Null) && jsonPageSize.TryGetInt32(out int tempPageSize))
                    {
                        pageSize = tempPageSize;
                    }
                }
                if (pageSize != null && pageSize.Value > 0)
                {
                    iscontinuation = true;
                }
                if (jsonElement.TryGetProperty("contToken", out JsonElement ContToken))
                {
                    pageToken = ContToken.GetString();
                }

                List<RecArea> areas = new();
                var table = _azureStorage.GetCloudTableClient().GetTableReference("IESLogin");
                var cosmosClient = _azureCosmos.GetCosmosClient();
                ////分开部署，就不需要，一站多用时，取消注释
                //if ($"{site}".Equals(BIConst.Global))
                //{
                //    cosmosClient = _azureCosmos.GetCosmosClient(name: BIConst.Global);
                //    table = _azureStorage.GetCloudTableClient(BIConst.Global).GetTableReference("IESLogin");
                //}

                StringBuilder areaSql = new($"select c.id,c.code,c.pk,c.name,c.provCode,c.provName,c.cityCode,c.cityName,c.standard,c.standardName,c.institution,c.updateTime,c.quoteId from c");
                if (!string.IsNullOrEmpty($"{id}") && string.IsNullOrEmpty($"{name}"))
                    areaSql.Append($" where c.id='{id}'");

                if (string.IsNullOrEmpty($"{id}") && !string.IsNullOrEmpty($"{name}"))
                    areaSql.Append($" where Contains(c.name,'{name}')");

                await foreach (var itemArea in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryStreamIterator(queryText: areaSql.ToString(), continuationToken: pageToken, requestOptions: new QueryRequestOptions() { MaxItemCount = pageSize, PartitionKey = new PartitionKey("Base-Area") })) 
                {
                    using var json = await JsonDocument.ParseAsync(itemArea.ContentStream);
                    if (json.RootElement.TryGetProperty("_count", out JsonElement count) && count.GetInt16() > 0) 
                    {
                        foreach (var obj in json.RootElement.GetProperty("Documents").EnumerateArray())
                        {
                            areas.Add(obj.ToObject<RecArea>());
                        }

                        if (iscontinuation) 
                        {
                            continuationToken = itemArea.GetContinuationToken();
                            break;
                        }
                    } 
                }

                //areas.ForEach(async area =>
                //{
                //    area.schoolCount = await CommonFind.GetSqlValueCount(cosmosClient, "School", $"select value(count(c.id)) from c where c.areaId='{area.id}' and c.standard='{area.standard}'", "Base");

                //    area.aquoteRec = await table.QueryWhereString<AreaQuoteRecord>($"PartitionKey eq 'QuoteRecord' and  areaId eq '{area.id}'");
                //    //List<AreaQuoteRecord> aqr = await table.QueryWhereString<AreaQuoteRecord>($"PartitionKey eq 'QuoteRecord' and  areaId eq '{area.id}'");
                //    //aqr.Sort((x, y) => y.RowKey.CompareTo(x.RowKey));

                //    await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<string>(queryText: $"select value(c.accessConfig) from c where c.id='{area.id}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("AreaSetting") }))
                //    {
                //        if (string.IsNullOrEmpty(item))
                //            area.cutArea = false;
                //        else
                //            area.cutArea = true;
                //    };
                //});

                foreach (var area in areas)
                {
                    area.schoolCount = await CommonFind.GetSqlValueCount(cosmosClient, "School", $"select value(count(c.id)) from c where c.areaId='{area.id}' and c.standard='{area.standard}'", "Base");

                    area.aquoteRec = await table.QueryWhereString<AreaQuoteRecord>($"PartitionKey eq 'QuoteRecord' and  areaId eq '{area.id}'");
                    //List<AreaQuoteRecord> aqr = await table.QueryWhereString<AreaQuoteRecord>($"PartitionKey eq 'QuoteRecord' and  areaId eq '{area.id}'");
                    //aqr.Sort((x, y) => y.RowKey.CompareTo(x.RowKey));

                    await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<string>(queryText: $"select value(c.accessConfig) from c where c.id='{area.id}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("AreaSetting") }))
                    {
                        if (string.IsNullOrEmpty(item))
                            area.cutArea = false;
                        else
                            area.cutArea = true;
                    };
                }

                return Ok(new { state = 200, areas, continuationToken });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location} batcharea/get-areas \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 批量创区 新接口     //已对接
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin,rdc")]
        [HttpPost("batch-area")]
        public async Task<IActionResult> batchArea(JsonElement jsonElement)
        {
            try
            {
                if (!jsonElement.TryGetProperty("name", out JsonElement name)) return BadRequest();
                jsonElement.TryGetProperty("provCode", out JsonElement provCode);
                jsonElement.TryGetProperty("provName", out JsonElement provName);
                jsonElement.TryGetProperty("cityCode", out JsonElement cityCode);
                jsonElement.TryGetProperty("cityName", out JsonElement cityName);
                jsonElement.TryGetProperty("areaAdmin", out JsonElement areadAdmin);
                if (!jsonElement.TryGetProperty("standard", out JsonElement standard)) return BadRequest();
                if (!jsonElement.TryGetProperty("standardName", out JsonElement standardName)) return BadRequest();
                jsonElement.TryGetProperty("institution", out JsonElement institution);
                jsonElement.TryGetProperty("oldId", out JsonElement _oldId);
                jsonElement.TryGetProperty("oldStandard", out JsonElement oldStandard);
                jsonElement.TryGetProperty("oldName", out JsonElement oldName);
                //jsonElement.TryGetProperty("site", out JsonElement site);//分开部署，就不需要，一站多用时，取消注释

                var (_tmdId, _tmdName, pic, did, dname, dpic) = HttpJwtAnalysis.JwtXAuthBI(HttpContext.GetXAuth("AuthToken"), _option);

                //操作记录实体
                var tempStandard = !string.IsNullOrEmpty($"{oldStandard}") && !string.IsNullOrEmpty($"{_oldId}") ? $"{oldStandard}" : "standard2";

                var cosmosClient = _azureCosmos.GetCosmosClient();//数据库连接
                var tableClient = _azureStorage.GetCloudTableClient();
                var blobClient = _azureStorage.GetBlobContainerClient(containerName: "0-public");

                ServiceBusClient serBusClient;
                try
                {
                    serBusClient = _serviceBus.GetServiceBusClient();
                }
                catch
                {
                    return Ok(new { state = 403, msg = "Functionn未启动，请联系管理员" });
                }

                var activeTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");//秘钥地址
                //分开部署，就不需要，一站多用时，取消注释
                //if ($"{site}".Equals(BIConst.Global))
                //{
                //    cosmosClient = _azureCosmos.GetCosmosClient(name: BIConst.Global);
                //    tableClient = _azureStorage.GetCloudTableClient(BIConst.Global);
                //    blobClient = _azureStorage.GetBlobContainerClient(containerName: "0-public", name: BIConst.Global);
                //}

                var table = tableClient.GetTableReference("IESLogin");

                //查询新的是否存在
                await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Area>(queryText: $"select value(c) from c where c.standard='{standard}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base-Area") }))
                {
                    if (item.standard.Equals($"{standard}"))
                        return Ok(new { state = 1, message = "新创区的standard已存在请检查" });
                }

                //查询新的区级名称是否存在
                await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Area>(queryText: $"select value(c) from c where c.name='{name}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base-Area") }))
                {
                    if (item.name.Equals($"{standard}"))
                        return Ok(new { state = 1, message = "区级名称相同，请检测区级名称！" });
                }

                //区级的ID
                string areaId = Guid.NewGuid().ToString();
                Area addArea = new()
                {
                    id = areaId,
                    code = $"Base-Area",
                    name = $"{name}",
                    provCode = $"{provCode}",
                    provName = $"{provName}",
                    cityCode = $"{cityCode}",
                    cityName = $"{cityName}",
                    standard = $"{standard}",
                    standardName = $"{standardName}",
                    institution = $"{institution}",
                    quoteId = $"{_oldId}"
                };

                #region  区级管理员

                var coreUser = await _coreAPIHttpService.GetUserInfo(new Dictionary<string, string> { { "key", $"{areadAdmin}" } }, _option.Location, _configuration);
                if (coreUser == null || coreUser.id == null)
                    return Ok(new { state = 404, msg = "未找到改账户的管理员" });

                //string tmdId = !string.IsNullOrEmpty(tempTmdId) ? tempTmdId : $"{areadAdmin}";
                Teacher teacher = null;
                try
                {
                    //查询该教师是否存在
                    teacher = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Teacher").ReadItemAsync<Teacher>($"{coreUser.id}", new PartitionKey("Base"));
                }
                catch
                {
                }

                if (teacher != null)
                {
                    //教师存在，在该教师信息中添加要管理的学校信息
                    teacher.areas.Add(new Teacher.TeacherArea { areaId = addArea.id, status = "join", name = addArea.name });
                    await cosmosClient.GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync<Teacher>(teacher, teacher.id, new PartitionKey("Base"));
                }
                else
                {
                    teacher.id = coreUser.id;
                    teacher.name = coreUser.name;
                    teacher.picture = coreUser.picture;
                    teacher.pk = "Base";
                    teacher.code = "Base";
                    teacher.size = 1;
                    teacher.createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    //教师存在，在该教师信息中添加要管理的学校信息
                    teacher.areas.Add(new Teacher.TeacherArea { areaId = addArea.id, status = "join", name = addArea.name });
                    await cosmosClient.GetContainer(Constant.TEAMModelOS, "Teacher").CreateItemAsync<Teacher>(teacher, new PartitionKey("Base"));
                }

                #endregion

                //创建区域
                await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync<Area>(addArea, new PartitionKey("Base-Area"));

                //保存引用记录
                await table.SaveOrUpdate<AreaQuoteRecord>(new AreaQuoteRecord() { PartitionKey = "QuoteRecord", RowKey = $"{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}", areaId = $"{areaId}", quoteId = $"{_oldId}", quoteName = $"{oldName}", standard = tempStandard });

                //消息分区键
                string partitionCode = "copyAbility-mark";

                #region 使用Function创区
                //string areaCode = "copyArea-mark";
                //BatchCopyAreaRelevant bCopyArea = new BatchCopyAreaRelevant()
                //{
                //    tmdid = $"{_tmdId}",
                //    tmdName = $"{_tmdName}",
                //    codeKey = areaCode,
                //    tmdIds = new List<string> { $"{_tmdId}"},
                //    oldStandard = $"{oldStandard}",
                //    oldId = $"{_oldId}",
                //    standard = $"{standard}",
                //    areaId = areaId,
                //    cut="",
                //};
                //var messageBatchCopyArea = new ServiceBusMessage(bCopyArea.ToJsonString());
                //messageBatchCopyArea.ApplicationProperties.Add("name", "CopyAreaRelevant");
                //var activeTaskArea = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");
                //await _serviceBus.GetServiceBusClient().SendMessageAsync(activeTaskArea, messageBatchCopyArea);
                #endregion

                #region 旧的批量创区

                List<Task<ItemResponse<Ability>>> abilities = new List<Task<ItemResponse<Ability>>>();      //存储区域数据
                List<Task<ItemResponse<AbilityTask>>> abilityTasks = new List<Task<ItemResponse<AbilityTask>>>();  //存储章节

                if (!string.IsNullOrEmpty($"{oldStandard}") && !string.IsNullOrEmpty($"{_oldId}"))
                {
                    //查询要复制区域的能力标准点 
                    await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Ability>(queryText: $"select value(c) from c", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Ability-{oldStandard}") }))
                    {
                        if (!string.IsNullOrEmpty(item.blob))
                        {
                            item.blob = item.blob.Replace($"/{oldStandard}/", $"/{standard}/");
                        };

                        item.standard = $"{standard}";
                        item.code = $"Ability-{standard}";
                        item.school = $"{standard}";

                        //添加区能力标准点
                        abilities.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(item, new PartitionKey($"Ability-{standard}")));
                    }
                    try
                    {
                        if (abilities.Count < 256)
                        {
                            await Task.WhenAll(abilities);
                        }
                        else
                        {
                            int pages = (abilities.Count + 255) / 256;
                            for (int i = 0; i < pages; i++)
                            {
                                List<Task<ItemResponse<Ability>>> tempAbility = abilities.Skip((i) * 256).Take(256).ToList();
                                await Task.WhenAll(tempAbility);
                            }
                        }
                    }
                    catch
                    {
                        return Ok(new { state = 200, msg = "创区成功,能力标准点复制失败，遗留数据影响！" });
                    }

                    try
                    {
                        //微能力点
                        await foreach (var atask in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AbilityTask>(queryText: $"select value(c) from c ", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"AbilityTask-{oldStandard}") }))
                        {
                            List<Tnode> tnodes = new List<Tnode>();
                            foreach (Tnode tnode in atask.children)
                            {
                                if (tnode.rnodes != null)
                                {
                                    List<Rnode> rnodes = new List<Rnode>();
                                    foreach (Rnode rnode in tnode.rnodes)
                                    {
                                        if (!string.IsNullOrEmpty($"{rnode.link}"))
                                        {
                                            rnode.link = rnode.link.Replace($"/{oldStandard}/", $"/{standard}/");
                                        }
                                        rnodes.Add(rnode);
                                    }
                                    tnode.rnodes = rnodes;
                                }
                                tnodes.Add(tnode);
                            }

                            atask.children = tnodes;
                            atask.code = $"AbilityTask-{standard}";
                            atask.standard = $"{standard}";
                            atask.codeval = $"{standard}";

                            //添加区能力标准点中的节点 
                            //abilityTasks.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(atask, new PartitionKey($"AbilityTask-{standard}")));
                            await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(atask, new PartitionKey($"AbilityTask-{standard}"));
                        }
                    }
                    catch
                    {
                        return Ok(new { state = 200, msg = "创区成功,能力标准创建成功，微能力点复制失败，遗留数据影响！" });
                    }

                    //if (abilityTasks.Count > 0) 
                    //{
                    //    for (int i = 0; i < abilityTasks.Count; i++)
                    //    {
                    //        List<Task<ItemResponse<AbilityTask>>> tempAbilityTasks = abilityTasks.Skip((i)).Take(1).ToList();
                    //        await Task.WhenAll(tempAbilityTasks);
                    //    }
                    //}

                    //新政策文件
                    await foreach (StandardFile standardFile in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<StandardFile>(queryText: $"select value(c) from c where  c.id='{_oldId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"StandardFile") }))
                    {
                        if (standardFile != null)
                        {
                            standardFile.standard = $"{standard}";
                            standardFile.id = areaId;
                            await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(standardFile, new PartitionKey($"StandardFile"));
                        }
                    }

                    //新的区域设置
                    await foreach (AreaSetting areaSetting in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AreaSetting>(queryText: $"select value(c) from c where c.id='{_oldId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("AreaSetting") }))
                    {
                        if (areaSetting != null)
                        {
                            areaSetting.accessConfig = null;
                            areaSetting.id = areaId;
                            await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(areaSetting, new PartitionKey($"AreaSetting"));
                        }
                    }
                }
                else
                {
                    Area area = null;
                    await foreach (var tempArea in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Area>(queryText: $"select value(c) from c where c.standard='standard2'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Base-Area") }))
                    {
                        area = tempArea;
                    }
                    if (area != null)
                    {
                        //查询要复制区域的能力标准点 
                        await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Ability>(queryText: $"select value(c) from c", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Ability-{area.standard}") }))
                        {
                            if (!string.IsNullOrEmpty(item.blob))
                            {
                                item.blob = item.blob.Replace($"/{area.standard}/", $"/{standard}/");
                            };

                            item.standard = $"{standard}";
                            item.code = $"Ability-{standard}";
                            item.school = $"{standard}";

                            //添加区能力标准点
                            abilities.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(item, new PartitionKey($"Ability-{standard}")));
                        }

                        try
                        {
                            if (abilities.Count < 256)
                            {
                                await Task.WhenAll(abilities);
                            }
                            else
                            {
                                int pages = (abilities.Count + 255) / 256;
                                for (int i = 0; i < pages; i++)
                                {
                                    List<Task<ItemResponse<Ability>>> tempAbility = abilities.Skip((i) * 256).Take(256).ToList();
                                    await Task.WhenAll(tempAbility);
                                }
                            }
                        }
                        catch
                        {
                            return Ok(new { state = 200, msg = "创区成功,能力标准点复制失败，遗留数据影响！" });
                        }

                        try
                        {
                            //微能力点
                            await foreach (var atask in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AbilityTask>(queryText: $"select value(c) from c ", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"AbilityTask-{area.standard}") }))
                            {
                                List<Tnode> tnodes = new List<Tnode>();
                                foreach (Tnode tnode in atask.children)
                                {
                                    if (tnode.rnodes != null)
                                    {
                                        List<Rnode> rnodes = new List<Rnode>();
                                        foreach (Rnode rnode in tnode.rnodes)
                                        {
                                            if (!string.IsNullOrEmpty($"{rnode.link}"))
                                            {
                                                rnode.link = rnode.link.Replace($"/{area.standard}/", $"/{standard}/");
                                            }
                                            rnodes.Add(rnode);
                                        }
                                        tnode.rnodes = rnodes;
                                    }
                                    tnodes.Add(tnode);
                                }

                                atask.children = tnodes;
                                atask.code = $"AbilityTask-{standard}";
                                atask.standard = $"{standard}";
                                atask.codeval = $"{standard}";

                                //添加区能力标准点中的节点 
                                //abilityTasks.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(atask, new PartitionKey($"AbilityTask-{standard}")));
                                await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(atask, new PartitionKey($"AbilityTask-{standard}"));
                            }
                        }
                        catch
                        {
                            return Ok(new { state = 200, msg = "创区成功,能力标准创建成功，微能力点复制失败，遗留数据影响！" });
                        }


                        //if (abilityTasks.Count > 0)
                        //{
                        //    for (int i = 0; i < abilityTasks.Count; i++)
                        //    {
                        //        List<Task<ItemResponse<AbilityTask>>> tempAbilityTasks = abilityTasks.Skip(i).Take(1).ToList();
                        //        await Task.WhenAll(tempAbilityTasks);
                        //    }
                        //}

                        //新政策文件
                        await foreach (StandardFile standardFile in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<StandardFile>(queryText: $"select value(c) from c where  c.id='{area.id}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"StandardFile") }))
                        {
                            if (standardFile != null)
                            {
                                standardFile.standard = $"{standard}";
                                standardFile.id = areaId;
                                await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(standardFile, new PartitionKey($"StandardFile"));
                            }
                        }

                        //新的区域设置
                        await foreach (AreaSetting areaSetting in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AreaSetting>(queryText: $"select value(c) from c where c.id='{area.id}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("AreaSetting") }))
                        {
                            if (areaSetting != null)
                            {
                                areaSetting.accessConfig = null;
                                areaSetting.id = areaId;
                                await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(areaSetting, new PartitionKey($"AreaSetting"));
                            }
                        }
                    }
                    else return Ok(new { state = 201, message = "未找到默认能力点!" });
                }

                #endregion

                //执行复制操作
                BatchCopyFile batchCopyFile = new BatchCopyFile();
                batchCopyFile.blobCntr = "teammodelos";
                batchCopyFile.oldFileName = $"{oldStandard}";
                batchCopyFile.newFileName = $"{standard}";
                batchCopyFile.tmdid = $"{_tmdId}";
                batchCopyFile.tmdIds = new List<string> { $"{ _tmdId}" };
                batchCopyFile.codeKey = partitionCode;
                batchCopyFile.tmdName = $"{_tmdName}";
                var messageBatchCopyFile = new ServiceBusMessage(batchCopyFile.ToJsonString());
                messageBatchCopyFile.ApplicationProperties.Add("name", "CopyStandardFile");
                //var activeTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");

                try
                {
                    //await  _serviceBus.GetServiceBusClient().SendMessageAsync(activeTask, messageBatchCopyFile);
                    await serBusClient.SendMessageAsync(activeTask, messageBatchCopyFile);
                }
                catch (Exception)
                {
                    return Ok(new { state = 201, msg = "能力点复制成功，复制能力点的文件失败，" });
                }

                //发送消息实体
                Notification notification = new Notification
                {
                    hubName = "hita",
                    type = "msg",
                    from = $"BI:{_option.Location}:private",
                    to = new List<string> { $"{ _tmdId}" },
                    label = $"{partitionCode}_start",
                    body = new { location = _option.Location, biz = partitionCode, tmdid = $"{_tmdId}", tmdname = $"{_tmdName}", status = 1, time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() }.ToJsonString(),
                    expires = DateTimeOffset.UtcNow.AddDays(7).ToUnixTimeSeconds()
                };

                var notiUrl = _configuration.GetValue<string>("HaBookAuth:CoreService:sendnotification");
                var clientID = _configuration.GetValue<string>("HaBookAuth:CoreService:clientID");
                var clientSecret = _configuration.GetValue<string>("HaBookAuth:CoreService:clientSecret");
                var location = _option.Location;
                await _notificationService.SendNotification(clientID, clientSecret, location, notiUrl, notification); //站内发送消息

                //保存操作记录
                //await _azureStorage.SaveBILog("area-add", $"{_tmdName}【{_tmdId}】已操作创区功能模块：{name}，当前标准【{standard}】，复制的微能力点：{tempStandard}", _dingDing, httpContext: HttpContext);
                await AzureStorageBlobExtensions.SaveBILog(blobClient, tableClient, "area-add", $"{_tmdName}【{_tmdId}】已操作创区功能模块：{name}，当前标准【{standard}】，复制的微能力点：{tempStandard}", _dingDing, httpContext: HttpContext);
                return Ok(new { state = 200, area = addArea });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location}  /batcharea/batch-area \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 创区后切换能力点， 先删除原来的能力点，后复制新的能力点     //已对接
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin,rdc")]
        [HttpPost("cut-standard")]
        public async Task<IActionResult> CutStandard(JsonElement jsonElement)
        {
            try
            {
                if (!jsonElement.TryGetProperty("oldId", out JsonElement _oldId)) return BadRequest();
                if (!jsonElement.TryGetProperty("oldStandard", out JsonElement _oldStandard)) return BadRequest();
                if (!jsonElement.TryGetProperty("newId", out JsonElement _newId)) return BadRequest();
                if (!jsonElement.TryGetProperty("newStandard", out JsonElement _newStandard)) return BadRequest();
                jsonElement.TryGetProperty("newName", out JsonElement newName);
                //jsonElement.TryGetProperty("site", out JsonElement site);//分开部署，就不需要，一站多用时，取消注释

                var (_tmdId, _tmdName, pic, did, dname, dpic) = HttpJwtAnalysis.JwtXAuthBI(HttpContext.GetXAuth("AuthToken"), _option);
                //操作记录实体
                string blobOrTable = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds().ToString();
                var tableClient = _azureStorage.GetCloudTableClient();
                var blobClient = _azureStorage.GetBlobContainerClient(containerName: "0-public");
                var cosmosClient = _azureCosmos.GetCosmosClient();
                var serBusClient = _serviceBus.GetServiceBusClient();
                var activeTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");//秘钥地址
                ////分开部署，就不需要，一站多用时，取消注释
                //if ($"{site}".Equals(BIConst.Global))
                //{
                //    cosmosClient = _azureCosmos.GetCosmosClient(name: BIConst.Global);
                //    tableClient = _azureStorage.GetCloudTableClient(BIConst.Global);
                //    blobClient = _azureStorage.GetBlobContainerClient(containerName: "0-public", BIConst.Global);
                //    serBusClient = _serviceBus.GetServiceBusClient(BIConst.Global);    //暂未确定使用默认 
                //    //activeTask = _configuration.GetValue<string>("GlobalAzure:ServiceBus:ActiveTask");  //暂未确定使用默认
                //}
                var table = tableClient.GetTableReference("IESLogin");

                var responseSet = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync($"{_oldId}", new PartitionKey("AreaSetting"));
                if (responseSet.Status == 200)
                {
                    using var fileJson = await JsonDocument.ParseAsync(responseSet.ContentStream);
                    AreaSetting delSet = fileJson.ToObject<AreaSetting>();
                    if (!string.IsNullOrEmpty(delSet.accessConfig))
                        return Ok(new { state = 401, msg = "区域已经规定了，不能切换能能力" });
                }

                //保存引用记录
                await table.SaveOrUpdate<AreaQuoteRecord>(new AreaQuoteRecord() { PartitionKey = "QuoteRecord", RowKey = $"{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}", areaId = $"{_oldId}", quoteId = $"{_newId}", quoteName = $"{newName}", standard = $"{_newStandard}" });

                List<string> abilityIds = new();  //册别的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();  //章节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}");
                }

                List<Task<ItemResponse<Ability>>> abilities = new();      //存储册别数据
                List<Task<ItemResponse<AbilityTask>>> abilityTasks = new();  //存储章节

                //查询要复制区域的能力标准点 
                await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Ability>(queryText: $"select value(c) from c", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Ability-{_newStandard}") }))
                {
                    if (!string.IsNullOrEmpty(item.blob))
                    {
                        item.blob = item.blob.Replace($"/{_newStandard}/", $"/{_oldStandard}/");
                    };

                    item.standard = $"{_oldStandard}";
                    item.code = $"Ability-{_oldStandard}";
                    item.school = $"{_oldStandard}";

                    //添加区能力标准点
                    abilities.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(item, new PartitionKey($"Ability-{_oldStandard}")));
                }

                try
                {
                    if (abilities.Count < 256)
                    {
                        await Task.WhenAll(abilities);
                    }
                    else
                    {
                        int pages = (abilities.Count + 255) / 256;
                        for (int i = 0; i < pages; i++)
                        {
                            List<Task<ItemResponse<Ability>>> tempAbility = abilities.Skip((i) * 256).Take(256).ToList();
                            await Task.WhenAll(tempAbility);
                        }
                    }
                }
                catch
                {
                    return Ok(new { state = 200, msg = "能力标准点复制失败，遗留数据影响！" });
                }

                try
                {
                    //微能力点
                    await foreach (var atask in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AbilityTask>(queryText: $"select value(c) from c ", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"AbilityTask-{_newStandard}") }))
                    {
                        List<Tnode> tnodes = new();
                        foreach (Tnode tnode in atask.children)
                        {
                            if (tnode.rnodes != null)
                            {
                                List<Rnode> rnodes = new();
                                foreach (Rnode rnode in tnode.rnodes)
                                {
                                    if (!string.IsNullOrEmpty($"{rnode.link}"))
                                    {
                                        rnode.link = rnode.link.Replace($"/{_newStandard}/", $"/{_oldStandard}/");
                                    }
                                    rnodes.Add(rnode);
                                }
                                tnode.rnodes = rnodes;
                            }
                            tnodes.Add(tnode);
                        }

                        atask.children = tnodes;
                        atask.code = $"AbilityTask-{_oldStandard}";
                        atask.standard = $"{_oldStandard}";
                        atask.codeval = $"{_oldStandard}";

                        ////添加区能力标准点中的节点 
                        //abilityTasks.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(atask, new PartitionKey($"AbilityTask-{_oldStandard}")));
                        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(atask, new PartitionKey($"AbilityTask-{_oldStandard}"));
                    }
                }
                catch
                {
                    return Ok(new { state = 200, msg = "能力标准创建成功，微能力点复制失败，遗留数据影响！" });
                }

                StandardFile saveFile = new();

                //新政策文件
                await foreach (StandardFile standardFile in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<StandardFile>(queryText: $"select value(c) from c where  c.id='{_newId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"StandardFile") }))
                {
                    if (standardFile != null)
                    {
                        standardFile.standard = $"{_oldStandard}";
                        standardFile.id = $"{_oldId}";

                        saveFile = standardFile;
                    }
                }
                StandardFile tempFile = new();
                if (saveFile.id != null)
                {
                    var respFile = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync(saveFile.id, new PartitionKey("StandardFile"));
                    if (respFile.Status == 200)
                    {
                        using var json = await JsonDocument.ParseAsync(respFile.ContentStream);
                        tempFile = json.ToObject<StandardFile>();
                        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemAsync<StandardFile>(tempFile.id, new PartitionKey("StandardFile"));
                    }

                    await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(saveFile, new PartitionKey($"StandardFile")); // 需要删除原来的政策文件数据在进行添加
                }

                //新的区域设置
                AreaSetting saveSetting = new AreaSetting();
                await foreach (AreaSetting areaSetting in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AreaSetting>(queryText: $"select value(c) from c where c.id='{_newId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("AreaSetting") }))
                {
                    if (areaSetting != null)
                    {
                        areaSetting.accessConfig = null;
                        areaSetting.id = $"{_oldId}";

                        saveSetting = areaSetting;
                    }
                }

                AreaSetting tempSetting = new();
                if (saveSetting.id != null)
                {
                    var respSetting = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync(saveSetting.id, new PartitionKey("AreaSetting"));
                    if (respSetting.Status == 200)
                    {
                        using var json = await JsonDocument.ParseAsync(respSetting.ContentStream);
                        tempSetting = json.ToObject<AreaSetting>();
                        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemAsync<AreaSetting>(tempFile.id, new PartitionKey("AreaSetting"));
                    }

                    tempSetting = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(saveSetting, new PartitionKey($"AreaSetting"));  //需要删除原来的区域设置数据在进行添加
                }

                //修改切换区级能力引用id
                Area area = new();
                area = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemAsync<Area>($"{_oldId}", new PartitionKey("Base-Area"));
                area.quoteId = $"{_newId}";
                await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReplaceItemAsync<Area>(area, area.id, new PartitionKey(area.code));

                //发送消息分区键
                string partitionCode = "DelBeforeCopyAbility-mark";
                //v2通知
                Teacher targetTeacher = await cosmosClient.GetContainer(Constant.TEAMModelOS, Constant.Teacher).ReadItemAsync<Teacher>($"{_tmdId}", new PartitionKey($"Base"));
                _coreAPIHttpService.PushNotify(new List<IdNameCode> { new IdNameCode { id = targetTeacher.id, name = targetTeacher.name, code = targetTeacher.lang } }, "copy-file_area", Constant.NotifyType_IES5_Management, new Dictionary<string, object> { { "tmdname", $"{_tmdName}" } }, _option.Location, _configuration, _dingDing, _environment.ContentRootPath);

                //执行复制操作
                BatchCopyFile batchCopyFile = new();
                batchCopyFile.blobCntr = "teammodelos";
                batchCopyFile.oldFileName = $"{_newStandard}";
                batchCopyFile.newFileName = $"{_oldStandard}";
                batchCopyFile.tmdid = $"{_tmdId}";
                batchCopyFile.tmdIds = new List<string> { $"{ _tmdId}" };
                batchCopyFile.codeKey = partitionCode;
                batchCopyFile.tmdName = $"{_tmdName}";
                var messageBatchCopyFile = new ServiceBusMessage(batchCopyFile.ToJsonString());
                messageBatchCopyFile.ApplicationProperties.Add("name", "CopyStandardFile");  
                try
                {
                    //await _serviceBus.GetServiceBusClient().SendMessageAsync(activeTask, messageBatchCopyFile);  //先执行删除操作，在执行复制  单一
                    await serBusClient.SendMessageAsync(activeTask, messageBatchCopyFile);  //先执行删除操作，在执行复制
                }
                catch (Exception)
                {
                    return Ok(new { state = 201 ,msg = "能力点复制成功，复制能力点的文件失败，" });
                }

                //发送消息实体
                Notification notification = new()
                {
                    hubName = "hita",
                    type = "msg",
                    from = $"BI:{_option.Location}:private",
                    to = new List<string> { $"{ _tmdId}" },
                    label = $"{partitionCode}_start",
                    body = new { location = _option.Location, biz = partitionCode, tmdid = $"{_tmdId}", tmdname = $"{_tmdName}", status = 1, time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() }.ToJsonString(),
                    expires = DateTimeOffset.UtcNow.AddDays(7).ToUnixTimeSeconds()
                };

                var url = _configuration.GetValue<string>("HaBookAuth:CoreService:sendnotification");
                var clientID = _configuration.GetValue<string>("HaBookAuth:CoreService:clientID");
                var clientSecret = _configuration.GetValue<string>("HaBookAuth:CoreService:clientSecret");
                var location = _option.Location;
                await _notificationService.SendNotification(clientID, clientSecret, location, url, notification); //发送站内发送消息

                //保存操作记录
                await AzureStorageBlobExtensions.SaveBILog(blobClient, tableClient, "area-cut", $"{_tmdName}【{_tmdId}】已操作【{_oldStandard}】切换至{_newStandard}微能力点，复制标准：{_newStandard}", _dingDing, httpContext: HttpContext);
                return Ok(new { state = 200 });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location}   batcharea/cut-standard \n  {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 删除区域和区域的册别、能力点、区域文件、区域设置
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("del-area")]
        public async Task<IActionResult> DelArea(JsonElement jsonElement)
        {
            if (!jsonElement.TryGetProperty("areaId", out JsonElement areaId)) return BadRequest();
            if (!jsonElement.TryGetProperty("standard", out JsonElement standard)) return BadRequest();
            //jsonElement.TryGetProperty("site", out JsonElement site);//分开部署，就不需要，一站多用时，取消注释
            var blobClient = _azureStorage.GetBlobContainerClient(containerName: "teammodelos");
            var cosmosClient = _azureCosmos.GetCosmosClient();
            ////分开部署，就不需要，一站多用时，取消注释
            //if ($"{site}".Equals(BIConst.Global))
            //{
            //    cosmosClient = _azureCosmos.GetCosmosClient(name: BIConst.Global);
            //    blobClient = _azureStorage.GetBlobContainerClient(containerName: "teammodelos", BIConst.Global);
            //}

            var response = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync($"{areaId}", new PartitionKey("Base-Area"));
            if (response.Status == 200)
            {
                using var json = await JsonDocument.ParseAsync(response.ContentStream);
                Area area = json.ToObject<Area>();
                if (area.standard == $"{standard}") 
                {
                    await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemAsync<Area>(area.id, new PartitionKey("Base-Area")); //删除区

                    List<Teacher> teachers = new();
                    await foreach (var item in cosmosClient.GetContainer("TEAMModelOS", "Teacher").GetItemQueryIterator<Teacher>(queryText: $"SELECT distinct value(c) FROM c join a in c.areas join s in c.schools where a.areaId='{area.id}' or s.areaId='{area.id}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Base") })) 
                    {
                        teachers.Add(item);
                    }

                    foreach (var item in teachers)
                    {
                        var tempArea = item.areas.Find(f => f.areaId.Equals(area.id));
                        if (tempArea != null)
                        {
                            item.areas.Remove(tempArea);
                        }
                        item.schools.ForEach(fe => { if (fe.areaId.Equals(area.id)) fe.areaId = ""; });
                        await cosmosClient.GetContainer("TEAMModelOS", "Teacher").ReplaceItemAsync<Teacher>(item, item.id, new PartitionKey("Base"));
                    }

                    List<string> scIds = await CommonFind.FindScIds(cosmosClient, $"select c.id from c where c.areaId='{area.id}' and c.standard ='{area.standard}'", "Base");

                    foreach (var item in scIds)
                    {
                        School school = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>(item, new PartitionKey("Base"));
                        school.areaId = "";
                        school.standard = "";
                        school = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<School>(school, school.id, new PartitionKey("Base"));
                    }

                    List<string> abilityIds = new();  //册别的ID集合
                    List<string> abilityTaskIds = new();  //章节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-{area.standard}") }))
                    {
                        abilityIds.Add(tempAbility.id);  //查询出来册别ID添加册别ID集合
                    }
                    //删除册别
                    if (abilityIds.IsNotEmpty())
                    {
                        var sresponse = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemsStreamAsync(abilityIds, $"Ability-{area.standard}");
                    }

                    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-{area.standard}") }))
                    {
                        abilityTaskIds.Add(item.id);   //查询出来的章节信息ID添加到战绩集合
                    }
                    //删除章节
                    if (abilityTaskIds.IsNotEmpty())
                    {
                        var sresponse = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemsStreamAsync(abilityTaskIds, $"AbilityTask-{standard}");
                    }
                    //区域政策文件
                    StandardFile delFile = new();
                    var responseFile = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync(area.id, new PartitionKey("StandardFile"));
                    if(responseFile.Status == 200)
                    {
                        using var fileJson = await JsonDocument.ParseAsync(responseFile.ContentStream);
                        delFile = fileJson.ToObject<StandardFile>();
                        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemAsync<StandardFile>(delFile.id, new PartitionKey("StandardFile"));
                    }

                    //区域设置
                    AreaSetting delSet = new();
                    var responseSet = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync(area.id, new PartitionKey("AreaSetting"));
                    if (responseSet.Status == 200)
                    {
                        using var fileJson = await JsonDocument.ParseAsync(responseSet.ContentStream);
                        delSet = fileJson.ToObject<AreaSetting>();
                        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemAsync<AreaSetting>(delSet.id, new PartitionKey("AreaSetting"));
                    }

                    List<object> fileobj = new();
                    //先删除原有的文件
                    List<Task<Response<bool>>> DelList = new();
                    await foreach (BlobItem blobItem in blobClient.GetBlobsAsync(BlobTraits.None, BlobStates.None, $"yxpt/{area.standard}/"))
                    {
                        fileobj.Add(blobItem.Name);
                        DelList.Add(blobClient.GetBlobBaseClient(blobItem.Name).DeleteIfExistsAsync());
                    }

                    if (DelList.Count <= 256)
                    {
                        await Task.WhenAll(DelList);
                    }
                    else
                    {
                        int pages = (DelList.Count + 255) / 256;
                        for (int i = 0; i < pages; i++)
                        {
                            List<Task<Response<bool>>> delList = DelList.Skip((i) * 256).Take(256).ToList();
                            await Task.WhenAll(delList);
                        }
                    }

                    return Ok(new { state = 200,area, scIds, abilityIds, abilityTaskIds, delFile, delSet, fileobj });
                }
                else return Ok(new { state = 400, msg = "id和standard不匹配！" });
            }
            else return Ok(new { state = 404,msg="依据Id未找到该区！" });
        }


        /// <summary>
        /// 同步两个区到新的区中
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "admin")]
        [HttpPost("cut-full-statndard")]
        public async Task<IActionResult> CutFullStandard(JsonElement jsonElement)
        {
            try
            {
                string _oldId = "bde5c011-2ae4-461a-b46c-5483ba72ae45";
                //string _oldStandard = "standard27";
                string standardFileId = "02944f32-f534-3397-ea56-e6f1fc6c3714";
                string standard = "standard2";

                List<CopyStandard> copyStand = new()
                {
                    new CopyStandard() { id = standardFileId, standard = standard },
                    new CopyStandard() { id = "99a4a33b-e21b-44ac-80a1-b31dc40496e0", standard = "standard3" }
                };

                var (_tmdId, _tmdName, pic, did, dname, dpic) = HttpJwtAnalysis.JwtXAuthBI(HttpContext.GetXAuth("AuthToken"), _option);
                var tableClient = _azureStorage.GetCloudTableClient();
                var blobClient = _azureStorage.GetBlobContainerClient(containerName: "0-public");
                var cosmosClient = _azureCosmos.GetCosmosClient();
                var serBusClient = _serviceBus.GetServiceBusClient();
                var activeTask = _configuration.GetValue<string>("Azure:ServiceBus:ActiveTask");//秘钥地址

                var table = tableClient.GetTableReference("IESLogin");

                Area area = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemAsync<Area>($"{_oldId}", new PartitionKey("Base-Area"));
                if (area != null)
                {
                    var responseSet = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync($"{_oldId}", new PartitionKey("AreaSetting"));
                    if (responseSet.Status == 200)
                    {
                        using var fileJson = await JsonDocument.ParseAsync(responseSet.ContentStream);
                        AreaSetting delSet = fileJson.ToObject<AreaSetting>();
                        if (!string.IsNullOrEmpty(delSet.accessConfig))
                            return Ok(new { state = 401, msg = "区域已经规定了，不能切换能能力" });
                    }

                    List<string> abilityIds = new();  //册别的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-{area.standard}") }))
                    {
                        abilityIds.Add(tempAbility.id);  //查询出来册别ID添加册别ID集合
                    }
                    //删除册别
                    if (abilityIds.IsNotEmpty())
                    {
                        var sresponse = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemsStreamAsync(abilityIds, $"Ability-{area.standard}");
                    }

                    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-{area.standard}") }))
                    {
                        abilityTaskIds.Add(item.id);   //查询出来的章节信息ID添加到战绩集合
                    }
                    //删除章节
                    if (abilityTaskIds.IsNotEmpty())
                    {
                        var sresponse = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemsStreamAsync(abilityTaskIds, $"AbilityTask-{area.standard}");
                    }
                    List<Task<ItemResponse<Ability>>> abilities = new();      //存储册别数据
                    List<Task<ItemResponse<AbilityTask>>> abilityTasks = new();  //存储章节

                    List<string> repeatAbilityId = new();
                    List<string> repeatAbilityTaskId = new();

                    foreach (var newstand in copyStand)
                    {
                        try
                        {
                            //查询要复制区域的能力标准点 
                            await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<Ability>(queryText: $"select value(c) from c", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Ability-{newstand.standard}") }))
                            {
                                if (!string.IsNullOrEmpty(item.blob))
                                    item.blob = item.blob.Replace($"/{newstand.standard}/", $"/{area.standard}/");

                                item.standard = $"{area.standard}";
                                item.code = $"Ability-{area.standard}";
                                item.school = $"{area.standard}";

                                //添加区能力标准点
                                //abilities.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(item, new PartitionKey($"Ability-{_oldStandard}")));
                                //await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(item, new PartitionKey($"Ability-{_oldStandard}"));

                                var respond = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync(item.id, new PartitionKey(item.code));
                                if (respond.Status != 200)
                                    abilities.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(item, new PartitionKey($"Ability-{area.standard}")));
                                else
                                    repeatAbilityId.Add(item.id);
                            }
                        }
                        catch
                        {
                            return Ok(new { state = 200, msg = "创区成功,能力标准点复制失败，遗留数据影响！" });
                        }

                        try
                        {
                            if (abilities.Count < 256)
                            {
                                await Task.WhenAll(abilities);
                            }
                            else
                            {
                                int pages = (abilities.Count + 255) / 256;
                                for (int i = 0; i < pages; i++)
                                {
                                    List<Task<ItemResponse<Ability>>> tempAbility = abilities.Skip((i) * 256).Take(256).ToList();
                                    await Task.WhenAll(tempAbility);
                                }
                            }
                        }
                        catch
                        {
                            return Ok(new { state = 200, msg = "创区成功,能力标准点复制失败，遗留数据影响！" });
                        }

                        try
                        {
                            //微能力点
                            await foreach (var atask in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AbilityTask>(queryText: $"select value(c) from c ", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"AbilityTask-{newstand.standard}") }))
                            {
                                List<Tnode> tnodes = new();
                                foreach (Tnode tnode in atask.children)
                                {
                                    if (tnode.rnodes != null)
                                    {
                                        List<Rnode> rnodes = new();
                                        foreach (Rnode rnode in tnode.rnodes)
                                        {
                                            if (!string.IsNullOrEmpty($"{rnode.link}"))
                                            {
                                                rnode.link = rnode.link.Replace($"/{newstand.standard}/", $"/{area.standard}/");
                                            }
                                            rnodes.Add(rnode);
                                        }
                                        tnode.rnodes = rnodes;
                                    }
                                    tnodes.Add(tnode);
                                }

                                atask.children = tnodes;
                                atask.code = $"AbilityTask-{area.standard}";
                                atask.standard = $"{area.standard}";
                                atask.codeval = $"{area.standard}";

                                var respond = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync(atask.id, new PartitionKey(atask.code));
                                if (respond.Status != 200)
                                    ////添加区能力标准点中的节点 
                                    //abilityTasks.Add(cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(atask, new PartitionKey($"AbilityTask-{_oldStandard}")));
                                    await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(atask, new PartitionKey($"AbilityTask-{area.standard}"));
                                else
                                    repeatAbilityTaskId.Add(atask.id);
                            }
                        }
                        catch
                        {
                            return Ok(new { state = 200, msg = "创区成功,能力标准创建成功，微能力点复制失败，遗留数据影响！" });
                        }

                        //发送消息分区键
                        string partitionCode = "DelBeforeCopyAbility-mark";

                        //执行复制操作
                        BatchCopyFile batchCopyFile = new();
                        batchCopyFile.blobCntr = "teammodelos";
                        batchCopyFile.oldFileName = $"{newstand.standard}";
                        batchCopyFile.newFileName = $"{area.standard}";
                        batchCopyFile.tmdid = $"{_tmdId}";
                        batchCopyFile.tmdIds = new List<string> { $"{_tmdId}" };
                        batchCopyFile.codeKey = partitionCode;
                        batchCopyFile.tmdName = $"{_tmdName}";
                        var messageBatchCopyFile = new ServiceBusMessage(batchCopyFile.ToJsonString());
                        messageBatchCopyFile.ApplicationProperties.Add("name", "CopyStandardFile");
                        try
                        {
                            //await _serviceBus.GetServiceBusClient().SendMessageAsync(activeTask, messageBatchCopyFile);  //先执行删除操作，在执行复制  单一
                            await serBusClient.SendMessageAsync(activeTask, messageBatchCopyFile);  //先执行删除操作，在执行复制
                        }
                        catch (Exception)
                        {
                            return Ok(new { state = 201, msg = "能力点复制成功，复制能力点的文件失败，" });
                        }

                        //发送消息实体
                        Notification notification = new()
                        {
                            hubName = "hita",
                            type = "msg",
                            from = $"BI:{_option.Location}:private",
                            to = new List<string> { $"{_tmdId}" },
                            label = $"{partitionCode}_start",
                            body = new { location = _option.Location, biz = partitionCode, tmdid = $"{_tmdId}", tmdname = $"{_tmdName}", status = 1, time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() }.ToJsonString(),
                            expires = DateTimeOffset.UtcNow.AddDays(7).ToUnixTimeSeconds()
                        };

                        var url = _configuration.GetValue<string>("HaBookAuth:CoreService:sendnotification");
                        var clientID = _configuration.GetValue<string>("HaBookAuth:CoreService:clientID");
                        var clientSecret = _configuration.GetValue<string>("HaBookAuth:CoreService:clientSecret");
                        var location = _option.Location;
                        await _notificationService.SendNotification(clientID, clientSecret, location, url, notification); //发送站内发送消息
                    }

                    StandardFile saveFile = new();
                    //新政策文件
                    await foreach (StandardFile standardFile in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<StandardFile>(queryText: $"select value(c) from c where  c.id='{standardFileId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"StandardFile") }))
                    {
                        if (standardFile != null)
                        {
                            standardFile.standard = $"{area.standard}";
                            standardFile.id = $"{_oldId}";

                            saveFile = standardFile;
                        }
                    }

                    StandardFile tempFile = new();
                    if (saveFile.id != null)
                    {
                        var respFile = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync(saveFile.id, new PartitionKey("StandardFile"));
                        if (respFile.Status == 200)
                        {
                            using var json = await JsonDocument.ParseAsync(respFile.ContentStream);
                            tempFile = json.ToObject<StandardFile>();
                            await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemAsync<StandardFile>(tempFile.id, new PartitionKey("StandardFile"));
                        }

                        tempFile = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(saveFile, new PartitionKey($"StandardFile")); // 需要删除原来的政策文件数据在进行添加
                    }

                    //if (tempFile.id != null)
                    //{
                    //    if (tempFile.id.Equals(saveFile.id))
                    //        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReplaceItemAsync<StandardFile>(saveFile, saveFile.id, new PartitionKey("StandardFile")); //直接替换以前的数据
                    //    else
                    //        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(saveFile, new PartitionKey($"StandardFile")); // 需要删除原来的政策文件数据在进行添加
                    //}

                    //新的区域设置
                    AreaSetting saveSetting = new();
                    await foreach (AreaSetting areaSetting in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AreaSetting>(queryText: $"select value(c) from c where c.id='{standardFileId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("AreaSetting") }))
                    {
                        if (areaSetting != null)
                        {
                            areaSetting.accessConfig = null;
                            areaSetting.id = $"{_oldId}";

                            saveSetting = areaSetting;
                        }
                    }

                    AreaSetting tempSetting = new();
                    if (saveSetting.id != null)
                    {
                        var respSetting = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemStreamAsync(saveSetting.id, new PartitionKey("AreaSetting"));
                        if (respSetting.Status == 200)
                        {
                            using var json = await JsonDocument.ParseAsync(respSetting.ContentStream);
                            tempSetting = json.ToObject<AreaSetting>();
                            await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemAsync<AreaSetting>(saveSetting.id, new PartitionKey("AreaSetting"));
                        }

                        tempSetting = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(saveSetting, new PartitionKey($"AreaSetting"));  //需要删除原来的区域设置数据在进行添加
                    }
                    //if (tempSetting.id != null)
                    //{
                    //    if (tempSetting.id.Equals(saveSetting.id))
                    //        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReplaceItemAsync<AreaSetting>(saveSetting, saveSetting.id, new PartitionKey($"AreaSetting"));   //直接替换以前的数据
                    //    else
                    //        await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").CreateItemAsync(saveSetting, new PartitionKey($"AreaSetting"));  //需要删除原来的区域设置数据在进行添加
                    //}

                    return Ok(new { state = RespondCode.Ok, repeatAbilityId, repeatAbilityTaskId });
                }
                else
                    return Ok(new { state = RespondCode.NotFound, msg = "标准为空"}) ;

            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location} batcharea/cut-full-statndard \n {ex.Message}\n{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 区域列表
        /// </summary>
        public record RecArea
        {
            public string id { get; set; }
            public string code { get; set; }
            public string pk { get; set; }
            public string name { get; set; }
            public string provCode { get; set; }
            public string provName { get; set; }
            public string cityCode { get; set; }
            public string cityName { get; set; }
            public string standard { get; set; }
            public string standardName { get; set; }
            public string institution { get; set; }
            public int schoolCount { get; set; }
            public long updateTime { get; set; }
            public string quoteId { get; set; } = null;
            public bool cutArea { get; set; } = false;
            public List<AreaQuoteRecord> aquoteRec { get; set; } = new List<AreaQuoteRecord>();
        }
    }
}