TEAMModelOS/TEAMModelOS/Controllers/School/CourseController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using OpenXmlPowerTools;
using Org.BouncyCastle.Ocsp;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK.Extension.DataResult.JsonRpcRequest;
using TEAMModelOS.SDK.Extension.DataResult.JsonRpcResponse;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Module.AzureCosmosDB.Interfaces;
using TEAMModelOS.SDK.Module.AzureCosmosDBV3;
using TEAMModelOS.Service.Models;

namespace TEAMModelOS.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class CourseController : BaseController
    {
        private IAzureCosmosDBV3Repository _cosmos;

        public CourseController(IAzureCosmosDBV3Repository cosmos)
        {
            _cosmos = cosmos;
        }

        /// <summary>
        /// 更新保存课程
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsert")]
        public async Task<BaseJosnRPCResponse> upsert(JosnRPCRequest<Course> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (string.IsNullOrEmpty(request.@params.id)) {
                List<int> count =await _cosmos.FindCountByDict<Course>(new Dictionary<string, object> { { "courseCode", request.@params.courseCode },{ "code",request.@params.code} });
                if (count.IsNotEmpty() && count[0] > 0) {
                    throw new BizException("课程编码已经存在！",ResponseCode.DATA_EXIST);
                }
                request.@params.id = request.@params.code.Replace("#", "") +"-"+ request.@params.courseCode;
            }
            Course  response = await _cosmos.SaveOrUpdate<Course>(request.@params);
            return builder.Data(response).build();
        }
        /// <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<Course> data = new List<Course>();
            if (request.@params.Keys.Count > 0) {
                data = await _cosmos.FindByDict<Course>(request.@params);
            }
            return builder.Data(data).Extend(new Dictionary<string, object> { { "count", data.Count } }).build();
        }
        /// <summary>
        /// 删除课程
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("delete")]
        public async Task<BaseJosnRPCResponse> Delete(JosnRPCRequest<IdPk> request) 
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            IdPk idPk=  await _cosmos.DeleteAsync<Course>(request.@params);
            return builder.Data(idPk).build();
        }
        /// <summary>
        /// 删除课程
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("deleteAll")]
        public async Task<BaseJosnRPCResponse> DeleteAll(JosnRPCRequest<List<IdPk>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<IdPk> idPk = await _cosmos.DeleteAll<Course>(request.@params);
            return builder.Data(idPk).build();
        }


        /// <summary>
        /// 保存更新课程安排
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertAllPlan")]
        public async Task<BaseJosnRPCResponse> UpsertAllPlan(JosnRPCRequest<List<CoursePlanDto>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<CoursePlan> coursePlans = new List<CoursePlan>();
            foreach (IGrouping<dynamic, CoursePlanDto> group in request.@params.GroupBy(c => new { c.courseId, c.code })) {
                List<CoursePlan> datas = await _cosmos.FindByDict<CoursePlan>(new Dictionary<string, object> 
                { { "id",group.Key.courseId }, { "code", group.Key.code } });
                var list = request.@params.Where(x => x.code == group.Key.code  && x.courseId == group.Key.courseId).ToList();
                if (datas.IsNotEmpty())
                {
                    CoursePlan data = datas[0];
                    
                    foreach (IGrouping<string, CoursePlanDto> groupClass in list.GroupBy(c => c.classroomCode)) {
                        var listclass = request.@params.Where(x => x.code == group.Key.code &&x.classroomCode==groupClass.Key  && x.courseId == group.Key.courseId).ToList();
                        if (listclass.IsNotEmpty()) {
                            List<CourseTime> courseTimes = new List<CourseTime>();
                            listclass.ForEach(x => {
                                if (!data.classes.Select(m=>m.classroomCode).Contains(x.classroomCode)) {
                                    courseTimes.Add(x.courseTime);
                                }
                            });
                            if (courseTimes.IsNotEmpty()) {
                                data.classes.Add(new CourseClass { classroomCode = groupClass.Key, courseTimes = courseTimes });
                                coursePlans.Add(data);
                            }
                            
                        }
                    }
                }
                else {

                    CoursePlan data = new CoursePlan { 
                        id = group.Key.courseId, 
                        code = group.Key.code, 
                       // courseId = group.Key.courseId ,
                         
                    };
                    foreach (IGrouping<string, CoursePlanDto> groupClass in list.GroupBy(c => c.classroomCode))
                    {
                        var listclass = request.@params.Where(x => x.code == group.Key.code && x.classroomCode == groupClass.Key && x.courseId == group.Key.courseId).ToList();
                        if (listclass.IsNotEmpty())
                        {
                            List<CourseTime> courseTimes = new List<CourseTime>();
                            listclass.ForEach(x => { courseTimes.Add(x.courseTime); });
                            data.classes.Add(new CourseClass { classroomCode = groupClass.Key, courseTimes = courseTimes });
                            coursePlans.Add(data);
                        }
                    }
                    coursePlans.Add(data);
                }
            }
            if (coursePlans.IsNotEmpty()) {
                await _cosmos.SaveOrUpdateAll(coursePlans);
            }
            return builder.Data(coursePlans).build();
        }



        /// <summary>
        /// 教师更新副属信息,助教，分组等。
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertPlan")]
        public async Task<BaseJosnRPCResponse> UpsertPlan(JosnRPCRequest<CoursePlan> request) {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            CoursePlan datas = await _cosmos.FindByIdPk<CoursePlan>(request.@params.id,request.@params.code);
            if (datas!=null) {
                request.@params.semesterCode = datas.semesterCode;
                request.@params.classes.ForEach(x => {
                    datas.classes.ForEach(m => { 
                    if (m.classroomCode == x.classroomCode) {
                        x.courseTimes = m.courseTimes;
                    } }); 
                });
                await _cosmos.Update(request.@params);
            }
            return builder.Data(request.@params).build();
        }

        /// <summary>
        /// 查询课程安排
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findPlan")]
        public async Task<BaseJosnRPCResponse> FindPlan(JosnRPCRequest<Dictionary<string, object>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<CoursePlan> data = new List<CoursePlan>();
            if (request.@params.Keys.Count > 0 
                &&
                //必须保证这几个参数之一有传递
                (request.@params.ContainsKey("id")|| request.@params.ContainsKey("code") ||
                request.@params.ContainsKey("classes[*].classroomCode"))
                )
            {
                data = await _cosmos.FindByDict<CoursePlan>(request.@params);
            }
            return builder.Data(data).Extend(new Dictionary<string, object> { { "count", data.Count } }).build();
        }


        /// <summary>
        /// 查询课程安排
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findTeach")]
        public async Task<BaseJosnRPCResponse> FindTeach(JosnRPCRequest<string> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<CoursePlan> data= await _cosmos.FindByDict<CoursePlan>(new Dictionary<string, object> { { "code", request.@params } }, new List<string> { "id" });
            List<Course> courses = new List<Course>();
            if (data.IsNotEmpty()) {
                courses= await  _cosmos.FindByDict<Course>(new Dictionary<string, object> { { "id", courses.Select(x => x.id).ToArray() } });
            }
            List<Course> coursesp = await _cosmos.FindByDict<Course>(new Dictionary<string, object> { { "code", request.@params } });
            if (courses.IsNotEmpty())
            {
                //个人教室
                if (coursesp.IsNotEmpty())
                {
                    coursesp.ForEach(x =>
                    {
                        ///处理重复
                        if (!courses.Select(y => y.id).Contains(x.id)) {
                            courses.Add(x);
                        }
                    });
                }
            }
            else {
                courses = coursesp;
            }
            return builder.Data(courses).build();
        }
        /// <summary>
        /// 查询执教助教的课程班级
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findTeachClass")]
        public async Task<BaseJosnRPCResponse> FindPlan(JosnRPCRequest<string> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            HashSet<string> data = new HashSet<string>();
            List<dynamic> room = new List<dynamic>();
            if (!string.IsNullOrEmpty(request.@params))
            {
                var prop = new List<string> { "classes" };
                var teachers= await _cosmos.FindByDict<CoursePlan>(new Dictionary<string, object> { { "code",request.@params} } , prop);
                if (teachers.IsNotEmpty()) {
                    teachers.Select(x => x.classes).ToList().ForEach(x => { x.ForEach(y => { data.Add(y.classroomCode); }); });
                   
                }
                var assistant = await _cosmos.FindByDict<CoursePlan>(new Dictionary<string, object> { { "assistant[*]", request.@params } }, prop);
                if (assistant.IsNotEmpty()) {
                    assistant.Select(x => x.classes).ToList().ForEach(x => { x.ForEach(y => { data.Add(y.classroomCode); }); });
                }
            }
            if (data.Count > 0) { 
                var classRoom=  await _cosmos.FindByDict<Classroom>(new Dictionary<string, object> { { "classroomCode",data.ToArray() } } );
                if (classRoom.IsNotEmpty()) {
                    classRoom.ForEach(x => {
                        room.Add(x);
                    });
                }
            }
            return builder.Data(room).Extend(new Dictionary<string, object> { { "count", room.Count } }).build();
        }
        /// <summary>
        /// 删除课程安排
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("deleteTime")]
        public async Task<BaseJosnRPCResponse> DeletePlan(JosnRPCRequest<Dictionary<string,object>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (request.@params.ContainsKey("id") && request.@params.ContainsKey("code") && request.@params.ContainsKey("classroomCode") && request.@params.ContainsKey("time") && request.@params.ContainsKey("day")) {
                CoursePlan coursePlan = await _cosmos.FindByIdPk<CoursePlan>(request.@params["id"].ToString(), request.@params["code"].ToString());
                List<CourseTime> courseTimes = new List<CourseTime>();
                coursePlan.classes.ForEach(x=> {
                    if (x.classroomCode == request.@params["classroomCode"].ToString()) {
                        x.courseTimes.ForEach(y => {
                            if (y.time == request.@params["time"].ToString() && y.day == request.@params["day"].ToString())
                            {
                                courseTimes.Add(y);
                            }
                        });
                    }
                });
               coursePlan.classes.ForEach(x => { if (x.classroomCode == request.@params["classroomCode"].ToString()) {
                       courseTimes.ForEach(y => { x.courseTimes.Remove(y); });
                   } });
               await _cosmos.Update(coursePlan);
                return builder.Data(coursePlan).build();
            }
            return builder.Data(null).build();
        }
        /// <summary>
        /// 删除课程安排
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("deletePlan")]
        public async Task<BaseJosnRPCResponse> DeletePlan(JosnRPCRequest<IdPk> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            IdPk idPk = await _cosmos.DeleteAsync<CoursePlan>(request.@params);
            return builder.Data(idPk).build();
        }
    }
}