TEAMModelOS/TEAMModelOS.Service/Syllabus/Implements/SyllabusService.cs

using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using TEAMModelOS.Model.Syllabus.Dtos;
using TEAMModelOS.Model.Syllabus.Models;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using TEAMModelOS.SDK.Module.AzureTable.Interfaces;
using TEAMModelOS.Service.Syllabus.Interfaces;

namespace TEAMModelOS.Service.Syllabus.Implements
{
    public class SyllabusService : ISyllabusService
    {

        private IAzureTableDBRepository _azureTableDBRepository;
        private IHttpContextAccessor _httpContextAccessor;
        public SyllabusService(IAzureTableDBRepository azureTableDBRepository , IHttpContextAccessor httpContextAccessor) {
            _azureTableDBRepository = azureTableDBRepository;
            _httpContextAccessor = httpContextAccessor;
        }


        public async Task<List<SyllabusTree>> SaveOrUpdateAll(List<SyllabusTree> trees)
        {
            List<SyllabusTree> nodes = new List<SyllabusTree>();
            TreeToList(trees, nodes);
            List<SyllabusNode> nods = MessagePackHelper.JsonToObject<List<SyllabusNode>>(MessagePackHelper.ObjectToJson(nodes));
            await _azureTableDBRepository.SaveOrUpdateAll<SyllabusNode>(nods);
            List<SyllabusTree> treess = ListToTree(nods);
            return treess;
           // return Task.Factory.StartNew(() => { return treess; });
        }

        public List<SyllabusTree> TreeToList(List<SyllabusTree> trees, List<SyllabusTree> nodes)
        {
            nodes.AddRange(MessagePackHelper.JsonToObject<List<SyllabusTree>>(MessagePackHelper.ObjectToJson(trees)));
            foreach (SyllabusTree tree in trees)
            {
                if (null != tree.Children && tree.Children.Count > 0)
                {
                    TreeToList(tree.Children, nodes);
                }
            }
            return nodes;
        }

        private  List<SyllabusTree> ListToTree(List<SyllabusNode> noes)
        {
            List<SyllabusTree> list = MessagePackHelper.JsonToObject<List<SyllabusTree>>(MessagePackHelper.ObjectToJson(noes));
 
            var lookup = list.ToDictionary(n => n.RowKey, n => n);
            return GetChild(list, lookup);
        }

        public List<SyllabusTree> GetChild(List<SyllabusTree> list ,Dictionary<string , SyllabusTree> dict) {
            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; 
        }

        public async  Task<SyllabusNode> SaveOrUpdate(SyllabusNode node )
        {

            return await _azureTableDBRepository.SaveOrUpdate<SyllabusNode>(node);
        }

        /// <summary>
        /// 获取教学段
        /// </summary>
        /// <param name="dict"></param>
        /// <returns></returns>
        public async Task<List<Period>> FindPeriodsByDict(Dictionary<string, object> dict){
            if (dict.Count <= 0)
            {
                return await _azureTableDBRepository.FindAll<Period>();
            }
            else {
                return await _azureTableDBRepository.FindListByDict<Period>(dict);
            }
            
        }
        /// <summary>
        /// 获取科目
        /// </summary>
        /// <param name="dict"></param>
        /// <returns></returns>
        public async Task<List<PeriodSubject>> FindSubjectsByDict(Dictionary<string, object> dict)
        {
            return await _azureTableDBRepository.FindListByDict<PeriodSubject>(dict);
        }
        /// <summary>
        /// 获取教材版本
        /// </summary>
        /// <param name="dict"></param>
        /// <returns></returns>
        public async Task<List<PeriodSubjectEdition>> FindEditionsByDict(Dictionary<string, object> dict)
        {
            return await _azureTableDBRepository.FindListByDict<PeriodSubjectEdition>(dict);
        }

        /// <summary>
        /// 获取册别
        /// </summary>
        /// <param name="dict"></param>
        /// <returns></returns>
        public async Task<List<PeriodSubjectEditionTerm>> FindTermsByDict(Dictionary<string, object> dict)
        {
            return await _azureTableDBRepository.FindListByDict<PeriodSubjectEditionTerm>(dict);
        }
        /// <summary>
        /// 获取标准教材
        /// </summary>
        /// <param name="params"></param>
        /// <returns></returns>
        public async Task<StandardTextbook> FindTextbooksByDict(Dictionary<string, object> dict) {

           

            Dictionary<string, object> parDict = new Dictionary<string, object>
            {
                { "Period", dict["Period"] },
                { "Subject", dict["Subject"] },
                { "Edition", dict["Edition"] },
                { "Term", dict["Term"] }
            };
            List<StandardTextbook> standardTextbooks= await _azureTableDBRepository.FindListByDict<StandardTextbook>(parDict);
            if (standardTextbooks != null && standardTextbooks.Count > 0)
            {
                int index = 0;
                foreach (StandardTextbook textbook in standardTextbooks)
                {
                    if (index > 0)
                    {
                        await _azureTableDBRepository.Delete<StandardTextbook>(textbook);
                    }
                    index++;
                }
                return standardTextbooks[0];
            }
            else
            {
                // 校验 几个Code 是否存在
                string RowKey = "RowKey";
                StandardTextbook textbook = dict.DictToObj<StandardTextbook>();
                List<Period> periods= await FindPeriodsByDict(new Dictionary<string, object> { { RowKey, textbook.Period} });
                List<PeriodSubject> subjects = await FindSubjectsByDict(new Dictionary<string, object> { { RowKey, textbook.Subject } });
                List<PeriodSubjectEdition> editions = await FindEditionsByDict(new Dictionary<string, object> { { RowKey, textbook.Edition } });
                List<PeriodSubjectEditionTerm> terms = await FindTermsByDict(new Dictionary<string, object> { { RowKey, textbook.Term } });
                if (periods.IsNotEmpty()&& subjects.IsNotEmpty()&& editions.IsNotEmpty()&& terms.IsNotEmpty())
                {
                    textbook.RowKey = Guid.NewGuid().ToString();
                    textbook.PartitionKey = Guid.NewGuid().ToString();
                    textbook = await _azureTableDBRepository.Save<StandardTextbook>(textbook);
                    return textbook;
                }
                else {
                    throw new BizException("Codes is required: Period,Subject,Edition,Term");
                }
            }
        }
    }
}