TEAMModelOS/TEAMModelOS/Controllers/Syllabus/SyllabusController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;
using TEAMModelOS.Service.Models.Syllabus;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK.Extension.DataResult.JsonRpcRequest;
using TEAMModelOS.SDK.Extension.DataResult.JsonRpcResponse;
using TEAMModelOS.SDK.Extension.SnowFlake;
using TEAMModelOS.SDK.Module.AzureCosmosDB.Interfaces;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using System;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using System.Linq;

namespace TEAMModelOS.Controllers.Syllabus
{
    [Route("api/[controller]")]
    [ApiController]
    //[Authorize]
    public class SyllabusController : BaseController
    {
        private readonly IAzureCosmosDBRepository azureCosmosDBRepository;
        public SyllabusController(IAzureCosmosDBRepository _azureCosmosDBRepository)
        {
            azureCosmosDBRepository = _azureCosmosDBRepository;
        }
        /// <summary>
        /// 批量保存或更新课纲
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("SaveOrUpdateAsTree")]
        public async Task<BaseJosnRPCResponse> SaveOrUpdateAsTree(JosnRPCRequest<List<SyllabusTree>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<SyllabusNode> nodes = new List<SyllabusNode>();
            TreeToList(request.@params, nodes);
           // List<SyllabusNode> nods = nodes.ToJson().FromJson<List<SyllabusNode>>() ;
        
            await azureCosmosDBRepository.SaveAll<SyllabusNode>(nodes);
            List<SyllabusTree> treess = ListToTree(nodes);
            return builder.Data(treess).build();
        }
        public static List<SyllabusNode> TreeToList(List<SyllabusTree> trees, List<SyllabusNode> nodes)
        {
            trees = trees.OrderBy(x => x.order).ToList(); 
            nodes.AddRange(trees.ToJson().FromJson<List<SyllabusNode>>());

            foreach (SyllabusTree tree in trees)
            {
                if (null != tree.children && tree.children.Count > 0)
                {
                    TreeToList(tree.children, nodes);
                }
            }
            return nodes;
        }

        /// <summary>
        /// 批量保存或更新课纲
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("SaveOrUpdateAsNodes")]
        public async Task<BaseJosnRPCResponse> SaveOrUpdateAsNodes(JosnRPCRequest<List<SyllabusNode>> request) {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<SyllabusNode> nodes = await azureCosmosDBRepository.SaveAll<SyllabusNode>(request.@params);
            return builder.Data(nodes).build();
        }

        private static List<SyllabusTree> ListToTree(List<SyllabusNode> noes)
        {
            List<SyllabusTree> list = noes.ToJson().FromJson<List<SyllabusTree>>();
            //var lookup = list.ToDictionary(n => n.RowKey, n => n);

            var res = from r in list group r by r.id into g select g;
            Dictionary<string, SyllabusTree> blockDict = new Dictionary<string, SyllabusTree>();
            foreach (var s in res)
            {
                blockDict.TryAdd(s.First().id, s.First());
            }
            return GetChild(list, blockDict);
        }

        public static List<SyllabusTree> GetChild(List<SyllabusTree> list, Dictionary<string, SyllabusTree> dict)
        {
          //  list = list.OrderBy(m => m.Order).ToList();
            List<SyllabusTree> trees = new List<SyllabusTree>();
            foreach (SyllabusTree node in list)
            {
               
                bool flag = dict.TryGetValue(node.pid, out SyllabusTree syllabus);
                if (flag && syllabus != null)
                {
                    syllabus.children.Add(node);
                }
                else
                {
                    trees.Add(node);
                }
            }
            return trees;
        }
        /// <summary>
        /// 删除课纲
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("Delete")]
        public async Task<BaseJosnRPCResponse> Delete(JosnRPCRequest<Dictionary<string, object>> request)
        {
            bool flag = false;
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<SyllabusNode> nodes = new List<SyllabusNode>();
            List<SyllabusNode> data = await azureCosmosDBRepository.FindByDict<SyllabusNode>(request.@params, true);
            if (data.IsNotEmpty())
            {
                await FindByPid(data, nodes, azureCosmosDBRepository);
                if (nodes.IsNotEmpty()) {
                    nodes.ForEach(async e => {
                        await azureCosmosDBRepository.DeleteAsync<SyllabusNode>(e.id, e.volumeCode);
                    });
                    flag = true;
                }
            }
            else {
                throw new BizException("数据不存在", ResponseCode.DATA_EMPTY_NULL);
            }
            return builder.Data(flag).Extend(new Dictionary<string, object>() { { "deleteData",nodes } }).build();
        }



        public static async Task<List<SyllabusNode>>  FindByPid(List<SyllabusNode> data, List<SyllabusNode> nodes , IAzureCosmosDBRepository azureCosmosDBRepository) {
            nodes.AddRange(data);
            foreach (SyllabusNode node  in data)
            {
                List<SyllabusNode>  syllabusNodes=  await  azureCosmosDBRepository.FindByDict<SyllabusNode>(new Dictionary<string, object>() { { "pid", node.id } }, true);
                if (syllabusNodes.IsNotEmpty()) {
                   await FindByPid(syllabusNodes, nodes ,azureCosmosDBRepository);
                }
            }
            return nodes;
        }
        /// <summary>
        /// 查找课纲 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("Find")]
        public async Task<BaseJosnRPCResponse> Find(JosnRPCRequest<Dictionary<string, object>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<SyllabusNode> data =await azureCosmosDBRepository.FindByDict<SyllabusNode>(request.@params);

            if (request.@params.TryGetValue("id", out object id))
            {
                List<SyllabusNode> nodes = new List<SyllabusNode>();
                if (data.IsNotEmpty()) {
                    await FindByPid(data, nodes, azureCosmosDBRepository);
                    data = nodes;
                }
            }
            List<SyllabusTree> treess = ListToTree(data);
            return builder.Data(treess).build();
        }
    }
}