TEAMModelOS/TEAMModelOS/Controllers/Core/ClassStudentController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
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.Helper.Common.ValidateHelper;
using TEAMModelOS.SDK.Module.AzureCosmosDBV3;
using TEAMModelOS.Service.Models;
 

namespace TEAMModelOS.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ClassStudentController : BaseController
    {

        private IAzureCosmosDBV3Repository _cosmos;

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

        /// <summary>
        ///  获取实时的学生-班级关联信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("find")]
        public async Task<BaseJosnRPCResponse> find(JosnRPCRequest<Dictionary<string,string>> request) {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            // 班级编码
            if (request.@params.TryGetValue("classroomCode", out string classroomCode)
                ///学校编码
                 && request.@params.TryGetValue("schoolCode", out string schoolCode)
                )
            {
                List<ClassStudent> classroomStudents = await _cosmos.FindByDict<ClassStudent>(new Dictionary<string, object> { { "id", classroomCode }});
                List<Student> students = await _cosmos.FindByDict<Student>(new Dictionary<string, object>() { { "classroomCode", classroomCode }, { "code", schoolCode } });
                List<dynamic> stus = new List<dynamic>();
                List<ClassStudent> newClassStudents = new List<ClassStudent>();
                ///新增的学生
                if (students.IsNotEmpty())
                {
                    students.ForEach(x =>
                    {
                        if (!classroomStudents.Select(m=>m.code).Contains(x.studentId))
                        {
                            newClassStudents.Add(new ClassStudent() { id = classroomCode, code = x.studentId });
                        }
                        var stu = new { x.id, x.name, x.code, x.seatNo, x.studentId, x.classroomCode };
                        stus.Add(stu);
                    });
                }
                 ///反射已存在的id信息
                if (classroomStudents.IsNotEmpty())
                {
                    var sts = await _cosmos.FindByDict<Student>(new Dictionary<string, object>() { { "studentId", classroomStudents.Select(x=>x.code).ToArray() } });
                    sts.ForEach(x => {
                        var stu = new { x.id, x.name, x.code, x.seatNo, x.studentId, x.classroomCode };
                        stus.Add(stu);
                    });
                }
                //保存新增学生
                if (newClassStudents.IsNotEmpty()) {
                    classroomStudents.AddRange( await _cosmos.SaveOrUpdateAll(newClassStudents));
                }
                return builder.Data(classroomStudents).Extend(new Dictionary<string, object> { { "students", stus }, { "count", stus.Count } }).build();
            }
            else { throw new BizException("参数异常classroomCode，code", ResponseCode.PARAMS_ERROR); }
        }

        /// <summary>
        /// 保存或修改教室学生关联
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("save")]
        public async Task<BaseJosnRPCResponse> Save(JosnRPCRequest<List<ClassStudent>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();

            if (ValidateHelper.IsValid(request.@params))
            {
                List<ClassStudent> students = await _cosmos.SaveOrUpdateAll(request.@params);
                builder.Data(students);
            }
            return builder.build();
        }


        /// <summary>
        /// 学生加入教室 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("addStudent")]
        public async Task<BaseJosnRPCResponse> addStudent(JosnRPCRequest<List<ClassStudent>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (ValidateHelper.IsValid(request.@params))
            {
                List<ClassStudent> students = await _cosmos.SaveOrUpdateAll(request.@params);
                builder.Data(students);
            }
            return builder.build();
        }
        /// <summary>
        /// 学生退出教室,只能退出非原生班级的教室
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("Exit")]
        public async Task<BaseJosnRPCResponse> Exit(JosnRPCRequest<List<ClassStudent>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (ValidateHelper.IsValid(request.@params) && request.@params.Count>0)
            {
                List<Student> students = await _cosmos.FindByDict<Student>(new Dictionary<string, object> { { "studentId", request.@params.GroupBy(x => x.id).ToList().Select(x => x.Key).ToArray() } });
                students.ForEach(x => {
                    if (!string.IsNullOrEmpty(x.classroomCode)) {
                        request.@params.ForEach(m =>
                        {
                            if (x.classroomCode.Equals(m.id) && x.studentId.Equals(m.code)) {
                                request.@params.Remove(m);
                            }
                        });
                    }
                });
                List<IdPk> idPks = await _cosmos.DeleteAll<ClassStudent>(request.@params.Select(x=> new IdPk { id=x.id,pk=x.code}).ToList());
                builder.Data(idPks);
            }
            return builder.build();
        }
      
        /// <summary>
        /// 查询教室学生关联 根据id
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findById")]
        public async Task<BaseJosnRPCResponse> FindById(JosnRPCRequest<IdPk> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (ValidateHelper.IsValid(request.@params))
            {
                ClassStudent classStudent = await _cosmos.FindByIdPk<ClassStudent>(request.@params.id,request.@params.pk);
                List<Student> students = await _cosmos.FindByDict<Student>(new Dictionary<string, object> { { "studentId",request.@params.pk } });
                builder.Data(classStudent).Extend(new Dictionary<string, object> { { "student",students.IsNotEmpty()? students[0]:null } });
            }
            return builder.build();
        }
        /// <summary>
        /// 查询学生在哪些教室
        /// </summary>
        /// <param name="studentId"></param>
        /// <returns></returns>
        [HttpPost("findByStu")]
        public async Task<BaseJosnRPCResponse> FindByStu(JosnRPCRequest<string> studentId)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (!string.IsNullOrEmpty(studentId.@params))
            {
                List<ClassStudent> sc = await _cosmos.FindByDict<ClassStudent>(new Dictionary<string, object> { { "code",studentId.@params} });
                List<Classroom> classrooms = await _cosmos.FindByDict<Classroom>(new Dictionary<string, object> { { "classroomCode", sc.GroupBy(x => x.id).Select(x => x.Key).ToArray() } });
                builder.Data(classrooms).Extend(new Dictionary<string, object> { { "count", classrooms.Count } });
            }
            return builder.build();
        }

    }
}