TEAMModelOS/TEAMModelOS/Controllers/Learn/HomeWorkController.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 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.AzureCosmosDBV3;
using TEAMModelOS.Service.Models.Core;
using TEAMModelOS.Service.Models.Courses;
using TEAMModelOS.Service.Models.Learn;
using static TEAMModelOS.Service.Models.Learn.HomeWork;

namespace TEAMModelOS.Controllers.Learn
{
    [Route("api/[controller]")]
    [ApiController]
    public class HomeWorkController : ControllerBase
    {
        private readonly IAzureCosmosDBV3Repository _cosmos;

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


        /// <summary>
        /// 新增或修改 作业活动 同时创建关联关系表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("SaveorUpdataHomeWork")]
        public async Task<BaseJosnRPCResponse> SaveorUpdataHomeWork(JosnRPCRequest<HomeWork> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();

            if (request.@params.publishModel.Equals("0"))
            {
                request.@params.startTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();

            }
            bool flg = false; 

            if (string.IsNullOrEmpty(request.@params.id)) {

                request.@params.id = Guid.NewGuid().ToString();

                flg = true;
            }


            HomeWork homeWork = await _cosmos.SaveOrUpdate<HomeWork>(request.@params);

            if (flg) {
                //根据作业发布对象查找到每一个具体学生生成关联关系表 HomeWorkStudent
                List<Target> targets = request.@params.target;
                List<ClassroomStudent> Classrooms = new List<ClassroomStudent>();
                List<HomeWorkStudent> homeWorkStudents = new List<HomeWorkStudent>();
                foreach (Target target in targets)
                {
                    List<ClassroomStudent> classroom = await _cosmos.FindByDict<ClassroomStudent>(new Dictionary<string, object> { { "id", target.classroomCode }, { "scopeCode", target.scopeCode } });

                    if (classroom.IsNotEmpty()) {
                        foreach (string studentid in classroom[0].studentId)
                        {
                            HomeWorkStudent homeWorkStudent = new HomeWorkStudent();
                            homeWorkStudent.id = Guid.NewGuid().ToString();
                            homeWorkStudent.homeWorkId = request.@params.id;
                            homeWorkStudent.studentId = studentid;
                            homeWorkStudent.classroomCode = target.classroomCode;
                            homeWorkStudents.Add(homeWorkStudent);
                        }
                    }
                    
                }
                if (homeWorkStudents.IsNotEmpty())
                {
                    foreach (HomeWorkStudent homeWorkStudents1 in homeWorkStudents)
                    {
                        Student student = await _cosmos.FindById<Student>(homeWorkStudents1.studentId);//FindByDict<Student>(new Dictionary<string, object> { { "id", homeWorkStudents1.studentId } });
                        if (student != null)
                        {
                            homeWorkStudents1.name = student.name;
                            homeWorkStudents1.TEAMModelId = student.TEAMModelId;
                            homeWorkStudents1.nativeroomCode = student.classroomCode;
                        }
                    }
                    await _cosmos.SaveOrUpdateAll<HomeWorkStudent>(homeWorkStudents);
                }



            }
           

            return builder.Data(homeWork).build();
        }


        /// <summary>
        /// 保存或修改学生作业关联表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("SaveorUpdataWorkStudents")]
        public async Task<BaseJosnRPCResponse> SaveorUpdataWorkStudents(JosnRPCRequest<List<HomeWorkStudent>> request) 
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            await _cosmos.SaveOrUpdateAll<HomeWorkStudent>(request.@params);
            return builder.Data(request.@params).build();
        }

        /// <summary>
        /// 查询作业活动
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("FindHomeWork")]
        public async Task<BaseJosnRPCResponse> FindHomeWork(JosnRPCRequest<Dictionary<string,object>> request) {

            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<HomeWork> data = new List<HomeWork>();
            if (request.@params.IsNotEmpty())
            {
                data = await _cosmos.FindByDict<HomeWork>(request.@params);
            }
            else
            {
                throw new BizException("参数异常", ResponseCode.PARAMS_ERROR);
                //builder.Error(false,ResponseCode.PARAMS_ERROR,"参数异常");
            }
            return builder.Data(data).Extend(new Dictionary<string, object> { { "count", data.Count } }).build();
        }

        /// <summary>
        /// 查询作业学生关联
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("FindStudent")]
        public async Task<BaseJosnRPCResponse> FindStudent(JosnRPCRequest<Dictionary<string, object>> request)
        {

            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<HomeWorkStudent> data = new List<HomeWorkStudent>();
            if (request.@params.IsNotEmpty())
            {
                data = await _cosmos.FindByDict<HomeWorkStudent>(request.@params);
            }
            else
            {
                throw new BizException("参数异常", ResponseCode.PARAMS_ERROR);
                //builder.Error(false,ResponseCode.PARAMS_ERROR,"参数异常");
            }
            return builder.Data(data).Extend(new Dictionary<string, object> { { "count", data.Count } }).build();
        }


        /// <summary>
        /// 查询教师教的课程的教室的详细信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("FindClassroom")]
        public async Task<BaseJosnRPCResponse> FindClassroom(JosnRPCRequest<string> request) 
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<Course> courses = await _cosmos.FindByDict<Course>(dict:new Dictionary<string, object> { { "assistTeacher[*]", request.@params },{ "scopeCode.|", request.@params } }, propertys: new List<string> { "classroom" });
            //List<Course> courses2 = await _cosmos.FindByDict<Course>(dict:new Dictionary<string, object> { { "scopeCode", request.@params } }, propertys: new List<string> { "classroom" });
            //List<Course> courses = new List<Course>();
            //courses.AddRange(courses1);
            //courses.AddRange(courses2);
            if (courses.IsNotEmpty())
            {

                List<string> classroom = new List<string>();
                foreach (Course course in courses)
                {
                    classroom.AddRange(course.classroom);
                }
                List<Classroom> classroom1 = await _cosmos.FindByDict<Classroom>(dict: new Dictionary<string, object> { { "classroomCode", classroom } }, propertys: new List<string> { "classroomCode", "classroomName", "headMaster", "periodCode", "gradeCode", "scopeCode", "id", "studentCount", "status" });

                if (classroom1.IsNotEmpty())
                {

                    builder.Data(classroom1);
                }
            }
            else {

                throw new BizException("没有找到该老师协同课程", ResponseCode.NOT_FOUND);
            }
            
           

            return builder.build();
        }



        /// <summary>
        /// 作业打分
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("Scoring")]
        public async Task<BaseJosnRPCResponse> HomeWorkScoring(JosnRPCRequest<HomeWorkScoringDto> request) 
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<HomeWorkStudent> homeWorkStudents = await _cosmos.FindByDict<HomeWorkStudent>(new Dictionary<string, object> { { "id", request.@params.id }, { "homeWorkId", request.@params.homeWorkId } });
            HomeWorkStudent data = new HomeWorkStudent();
            if (homeWorkStudents.IsNotEmpty()) {

                homeWorkStudents[0].score = request.@params.score;
                data = await _cosmos.Update(homeWorkStudents[0]);
            }
            return builder.Data(data).build() ;
        }


        /// <summary>
        /// 作业评论
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("Comment")]
        public async Task<BaseJosnRPCResponse> HomeWorkComment(JosnRPCRequest<HomeWorkCommentDto> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<HomeWorkStudent> homeWorkStudents = await _cosmos.FindByDict<HomeWorkStudent>(new Dictionary<string, object> { { "id", request.@params.id }, { "homeWorkId", request.@params.homeWorkId } });
            HomeWorkStudent data = new HomeWorkStudent();
            if (homeWorkStudents.IsNotEmpty())
            {
                if (string.IsNullOrEmpty(request.@params.commentid))
                {
                    //评论
                    HomeWorkComment comment = new HomeWorkComment();
                    comment.commentid = Guid.NewGuid().ToString();
                    comment.fromId = request.@params.fromId;
                    comment.toId = request.@params.toId;
                    comment.identity = request.@params.identity;
                    comment.comment = request.@params.comment;
                    comment.createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
                    homeWorkStudents[0].comments.Add(comment);
                }
                else 
                {
                    //回复评论
                    foreach (HomeWorkComment comment in homeWorkStudents[0].comments ) {
                        if (comment.commentid == request.@params.commentid) {
                            Reply reply = new Reply();
                            reply.fromId = request.@params.fromId;
                            reply.toId = request.@params.toId;
                            reply.identity = request.@params.identity;
                            reply.comment = request.@params.comment;
                            reply.createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
                            comment.reply.Add(reply);
                        }
                    }
                }

                //homeWorkStudents[0].comments[request.@params.TEAMModelId] = request.@params.comment;
                data = await _cosmos.Update(homeWorkStudents[0]);
            }
            return builder.Data(data).build();
        }

    }
}