TEAMModelOS/TEAMModelBI/Controllers/BIAbility/AbilityTaskMgmtController.cs

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.Models;
using Microsoft.Extensions.Options;
using System.Text.Json;
using TEAMModelOS.SDK.Models;
using Azure.Cosmos;
using HTEXLib.COMM.Helpers;
using TEAMModelOS.SDK.Models.Cosmos.Common;
using System.Text;
using TEAMModeBI.Filter;
using TEAMModelOS.SDK.Services;

namespace TEAMModeBI.Controllers.BIAbility
{
    [Route("biabilitytask")]
    [ApiController]
    public class AbilityTaskMgmtController : ControllerBase
    {
        //获取配置信息
        private readonly IConfiguration _configuration;
        //数据容器
        private readonly AzureCosmosFactory _azureCosmos;
        //文件容器
        private readonly AzureStorageFactory _azureStorage;
        //钉钉提示信息
        private readonly DingDing _dingDing;
        private readonly Option _option;
        public readonly string mobel = "章节";

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

        /// <summary>
        /// 依据区级标准和能力编号查询能力点信息 章节集合
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [HttpPost("get-abilitytasksid")]
        public async Task<IActionResult> GetAbilityTasksId(JsonElement jsonElement)
        {
            try
            {
                if (!jsonElement.TryGetProperty("standard", out JsonElement standard)) return BadRequest();
                if (!jsonElement.TryGetProperty("abilityId", out JsonElement abilityId)) return BadRequest();
                var cosmosClient = _azureCosmos.GetCosmosClient();
                Ability ability = null;
                List<AbilityTaskTreeNode> abilityTaskTreeNodes = new List<AbilityTaskTreeNode>();//原始数据未排序
                List<AbilityTaskTreeNode> redtAbilityTaskTreeNodes = new List<AbilityTaskTreeNode>();//排序后的数据

                int rnodeCount = 0;
                try
                {
                    ability = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").ReadItemAsync<Ability>($"{abilityId}", new PartitionKey($"Ability-{standard}"));
                }
                catch
                {
                    return Ok(new { state = 400,message="该ID未找到章节" });
                }
                await foreach (var item in cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").GetItemQueryIterator<AbilityTask>(queryText: $"select value(c) from c where c.abilityId='{abilityId}'", requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"AbilityTask-{standard}") }))
                {
                    var rns = item.children.Select(x => x.rnodes);
                    if (rns != null)
                    {
                        var list = rns.ToList();
                        list.ForEach(x => { if (x.IsNotEmpty()) { rnodeCount += 1; } });
                    }
                    List<AbilityTaskTree> trees = AbilityService.ListToTree(item.children);
                    AbilityTaskTreeNode abilityTaskTreeNode = new AbilityTaskTreeNode() { id = item.id, scope = item.scope, trees = trees, abilityId = item.abilityId, auth = item.auth, codeval = ability.school };
                    abilityTaskTreeNodes.Add(abilityTaskTreeNode);
                }

                if (ability.abilityTaskIds.IsNotEmpty())
                {
                    ability.abilityTaskIds.ForEach(x =>
                    {
                        for (int i = 0; i < abilityTaskTreeNodes.Count; i++)
                        {
                            if (abilityTaskTreeNodes[i].id.Equals(x))
                            {
                                redtAbilityTaskTreeNodes.Add(abilityTaskTreeNodes[i]);
                                abilityTaskTreeNodes.RemoveAt(i);
                            }
                        }
                    });
                    redtAbilityTaskTreeNodes.AddRange(abilityTaskTreeNodes);
                    return Ok(new { state = 200, abilityTaskTreeNodes = redtAbilityTaskTreeNodes });
                }
                else
                {
                    return Ok(new { state = 200, abilityTaskTreeNodes = abilityTaskTreeNodes, rnodeCount });
                }
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location} /biabilitytask/get-abilitytasksid \n {ex.Message}{ex.StackTrace}", GroupNames.成都开发測試群組);
                return BadRequest();
            }
        }

        /// <summary>
        /// 修改和新增章节数据
        /// </summary>
        /// <param name="abilityTask"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles= "assist")]
        [HttpPost("upd-abilitytask")]
        public async Task<IActionResult> UpdAbilityTask(RecordAbilityTask recordAbilityTask)//AbilityTask abilityTask) 
        {
            try
            {
                var cosmosClient = _azureCosmos.GetCosmosClient();

                StringBuilder msgBuilder = new StringBuilder($"{recordAbilityTask.tmdName}【{recordAbilityTask.tmdId}】");
                string type = null;
                long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                foreach (var abilityTaskTree in recordAbilityTask.abilityTask)
                {
                    if (!string.IsNullOrEmpty(abilityTaskTree.id))
                    {
                        AbilityTask abilityTask = null;
                        try
                        {
                            abilityTask = await cosmosClient.GetContainer("TEAMModelOS", "Normal").ReadItemAsync<AbilityTask>(abilityTaskTree.id, new PartitionKey($"AbilityTask-{recordAbilityTask.standard}"));
                        }
                        catch
                        {
                        }

                        if (abilityTask == null)
                        {
                            if (abilityTaskTree.trees.IsNotEmpty())
                            {
                                abilityTaskTree.trees.ForEach(x => x.id = abilityTaskTree.id);
                            }
                            List<Tnode> nodes = new List<Tnode>();
                            AbilityService.TreeToList(abilityTaskTree.trees, nodes, now);
                            abilityTask = new AbilityTask();
                            abilityTask.id = abilityTaskTree.id;
                            abilityTask.children = nodes;
                            abilityTask.code = $"AbilityTask-{recordAbilityTask.standard}";
                            abilityTask.pk = "AbilityTask";
                            abilityTask.ttl = -1;
                            abilityTask.abilityId = abilityTaskTree.abilityId;
                            abilityTask.scope = abilityTaskTree.scope;
                            abilityTask.codeval = $"{recordAbilityTask.standard}";
                            abilityTask.standard = $"{recordAbilityTask.standard}";
                            await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "Normal").CreateItemAsync<AbilityTask>(abilityTask, new Azure.Cosmos.PartitionKey($"AbilityTask-{recordAbilityTask.standard}"));
                            msgBuilder.Append($"新增章节功能，章节ID：{abilityTask.id} 分区键：{abilityTask.code}");
                            type = "abilityTask-Add";
                        }
                        else
                        {
                            if (abilityTaskTree.trees.IsNotEmpty())
                            {
                                abilityTaskTree.trees.ForEach(x => x.id = abilityTaskTree.id);
                            }
                            List<Tnode> nodes = new List<Tnode>();
                            AbilityService.TreeToList(abilityTaskTree.trees, nodes, now);
                            abilityTask.children = nodes;
                            abilityTaskTree.auth = abilityTask.auth;
                            await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "Normal").ReplaceItemAsync<AbilityTask>(abilityTask, abilityTask.id, new Azure.Cosmos.PartitionKey($"AbilityTask-{recordAbilityTask.standard}"));
                            msgBuilder.Append($"修改章节功能，章节ID：{abilityTask.id} 分区键：{abilityTask.code}");
                            type = "abilityTask-update";
                        }
                    }
                    else
                    {
                        string id = Guid.NewGuid().ToString();
                        abilityTaskTree.id = id;
                        if (abilityTaskTree.trees.IsNotEmpty())
                        {
                            abilityTaskTree.trees.ForEach(x => x.id = abilityTaskTree.id);
                        }
                        List<Tnode> nodes = new List<Tnode>();
                        AbilityService.TreeToList(abilityTaskTree.trees, nodes, now);
                        AbilityTask abilityTask = new AbilityTask
                        {
                            id = id,
                            code = $"AbilityTask-{recordAbilityTask.standard}",
                            pk = "AbilityTask",
                            ttl = -1,
                            abilityId = abilityTaskTree.abilityId,
                            children = nodes,
                            scope = abilityTaskTree.scope,
                            codeval = $"{recordAbilityTask.standard}",
                            standard = $"{recordAbilityTask.standard}"
                        };
                        await _azureCosmos.GetCosmosClient().GetContainer("TEAMModelOS", "Normal").CreateItemAsync<AbilityTask>(abilityTask, new Azure.Cosmos.PartitionKey($"AbilityTask-{recordAbilityTask.standard}"));

                        msgBuilder.Append($"新增章节功能，章节ID：{abilityTask.id} 分区键：{abilityTask.code}");
                        type = "abilityTask-add";
                    }
                }

                //保存操作记录
                await _azureStorage.SaveLog(type, msgBuilder?.ToString(), _dingDing, httpContext: HttpContext);

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

        /// <summary>
        /// 依据id删除章节
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <returns></returns>
        [ProducesDefaultResponseType]
        [AuthToken(Roles = "assist")]
        [HttpPost("del-abilitytask")]
        public async Task<IActionResult> DelAbilityTask(JsonElement jsonElement) 
        {
            try
            {
                if (!jsonElement.TryGetProperty("standard", out JsonElement standard)) return BadRequest();
                if (!jsonElement.TryGetProperty("id", out JsonElement id)) return BadRequest();
                if (!jsonElement.TryGetProperty("tmdId", out JsonElement _tmdId)) return BadRequest();   //醍摩豆账户
                if (!jsonElement.TryGetProperty("tmdName", out JsonElement _tmdName)) return BadRequest(); //醍摩豆账号名称
                
                var cosmosClient = _azureCosmos.GetCosmosClient();
                var response = await cosmosClient.GetContainer(Constant.TEAMModelOS, "Normal").DeleteItemStreamAsync(id.ToString(), new PartitionKey($"AbilityTask-{standard}"));

                string msg = $"{_tmdName}【{_tmdId}】删除册别，删除状态：{response.Status}，删除ID:{id}";

                //保存操作记录
                await _azureStorage.SaveLog("abilitytask-del", msg, _dingDing, httpContext: HttpContext);

                if (response.Status == 204)
                    return Ok(new { state = 200 });
                else
                    return Ok(new { state = response.Status });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"BI,{_option.Location}   /biabilitytask/del-abilitytask    \n  {ex.Message} {ex.StackTrace}", GroupNames.成都开发測試群組);
                return Ok(new { state = 404 });
            }
        }

        public record RecordAbilityTask() 
        {
            /// <summary>
            /// 醍摩豆账户ID
            /// </summary>
            public string tmdId { get; set; }

            /// <summary>
            /// 醍摩豆账户名称
            /// </summary>
            public string tmdName { get; set; }

            public string standard { get; set; }

            /// <summary>
            /// 章节信息
            /// </summary>
            //public List<AbilityTask> abilityTask { get; set; }
            public List<AbilityTaskTreeNode> abilityTask { get; set; }
        }

    }
}