TEAMModelOS/TEAMModelOS/Controllers/Syllabus/VolumeController.cs

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.Extension.SnowFlake;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Helper.Security.ShaHash;
using TEAMModelOS.SDK.DI; 
using TEAMModelOS.Service.Models;
using Org.BouncyCastle.Ocsp;
using TEAMModelOS.Service.Services.Implement;
using System.Text.Json;

namespace TEAMModelOS.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class VolumeController : BaseController
    {
        private AzureCosmosFactory azureCosmosDBRepository;

        public VolumeController(AzureCosmosFactory azureCosmosDBRepository )
        {
            this.azureCosmosDBRepository = azureCosmosDBRepository;
            
        }


        /// <summary>
        /// 新增册别
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsert")]
        public async Task<BaseResponse> Upsert(Volume request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            List<Volume> volume = await VolumeService.SaveOrUpdateVolume(azureCosmosDBRepository,request);
            return builder.Data(volume.IsEmpty() ? null : volume[0]).build();
        }

       
        /// <summary>
        /// 删除册别
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("delete")]
        public async Task<BaseResponse> Delete(Volume request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            bool flag = false;
            if (!string.IsNullOrEmpty(request.id))
            {
                //if (request.@params.type == 0)
                //{
                    request.status = 0;
                    List<Volume> volumes = new List<Volume>
                    {
                        request
                    };
                    await azureCosmosDBRepository.SaveOrUpdateAll<Volume>(volumes);
                    flag = true;
                //}
                //else
                //{
                //    await azureCosmosDBRepository.DeleteAsync<Volume>(request.@params.id, request.@params.schoolCode);
                //    await azureCosmosDBRepository.DeleteAll<SyllabusNode>(new Dictionary<string, object>() { { "volumeCode", request.@params.id } });
                //    flag = true;
                //}
            }
            return builder.Data(flag).build();
        }


        /// <summary>
        /// 查找册别
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("find")]
        public async Task<BaseResponse> Find(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            List<Volume> volumes ;
            if (dict.TryGetValue("code", out object code))
            {
                List<Syllabus> syllabuses = await azureCosmosDBRepository.FindByDict<Syllabus>(new Dictionary<string, object> { { "code",code.ToString() } });
                volumes = await azureCosmosDBRepository.FindByDict<Volume>(request);
                //处理单个册别下面的资源和题目
                volumes.ForEach(v => {
                    
                    HashSet<string> rCount = new HashSet<string>();
                    HashSet<string> iCount = new HashSet<string>();
                    
                    syllabuses.ForEach(s => {
                        if (v.volumeCode.Equals(s.code)) {
                            s.children.ForEach(c => {
                                if (c.resources.IsNotEmpty())
                                {
                                    c.resources.ForEach(r => {
                                        rCount.Add(r);
                                    });
                                }
                                if (c.items.IsNotEmpty())
                                {
                                    c.items.ForEach(i => {
                                        iCount.Add(i);
                                    });
                                }
                            });
                        }                      
                    });
                    v.resourceCount = rCount.Count;
                    v.itemCount = iCount.Count;
                });
            }
            else
            {
                return builder.Error(ResponseCode.PARAMS_ERROR, "参数异常！").build();
                
            }
            return builder.Data(volumes).build();
        }

        /// <summary>
        /// 查找册别数量
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("count")]
        public async Task<BaseResponse> count(JsonElement request)
        {
            //List<List<List<List<int>>>> allCount = new List<List<List<List<int>>>>();
            ResponseBuilder builder = ResponseBuilder.custom();
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            while (emobj.MoveNext())
            {
                dict[emobj.Current.Name] = emobj.Current.Value;
            }
            List<List<List<int>>> sCount = new List<List<List<int>>>();
            if (dict.Keys.Count > 0) {
                List<School> sc = await azureCosmosDBRepository.FindByDict<School>(dict);
                //查询校本所有册别数据
                Dictionary<string, object> scMap = new Dictionary<string, object>
            {
                 { "status", 1}
            };
                List<Volume> volumeo = await azureCosmosDBRepository.FindByDict<Volume>(scMap);
                
                for (int i = 0; i < sc.Count; i++)
                {
                    for (int j = 0; j < sc[i].period.Count; j++)
                    {
                        List<List<int>> pCount = new List<List<int>>();
                        for (int k = 0; k < sc[i].period[j].subjects.Count; k++)
                        {
                            List<int> listCount = new List<int>() { 0, 0 };
                            //查询校本册别
                            //计数校本数量
                            int n = 0;
                            int s = 0;
                            for (int m = 0; m < volumeo.Count; m++)
                            {
                                if (volumeo[m].type == 0 && sc[i].schoolCode.Equals(volumeo[m].code) &&
                                    sc[i].period[j].periodCode.Equals(volumeo[m].periodCode) &&
                                    sc[i].period[j].subjects[k].subjectCode.Equals(volumeo[m].subjectCode))
                                {
                                    n++;
                                }
                                if (volumeo[m].type == 1 && sc[i].schoolCode.Equals(volumeo[m].code) &&
                                    sc[i].period[j].periodCode.Equals(volumeo[m].periodCode) &&
                                    sc[i].period[j].subjects[k].subjectCode.Equals(volumeo[m].subjectCode) && volumeo[m].TEAMModelId.Equals("habook#0001"))
                                {
                                    s++;
                                }
                            }
                            //册别数量
                            listCount[0] = n;
                            listCount[1] = s;
                            pCount.Add(listCount);
                        }
                        sCount.Add(pCount);
                    }
                }
            }
            
            return builder.Data(sCount).build();
        }
    }
}