TEAMModelOS/TEAMModelOS/Controllers/Task/HomeworkController.cs


using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.ServiceBus;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.Context.Configuration;
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.DateTimeHelper;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using TEAMModelOS.SDK.Module.AzureCosmosDBV3;
using TEAMModelOS.SDK.Module.AzureServiceBus;
using TEAMModelOS.Service.Models;
using TEAMModelOS.Service.Services.Learn;
using TEAMModelOS.Service.Services.Learn.Interfaces;
using TEAMModelOS.SDK.Context.Constant.Common;
namespace TEAMModelOS.Controllers.Learn
{
    /// <summary>
    /// 作业活动
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class HomeworkController : ControllerBase
    {
        private readonly IAzureCosmosDBV3Repository _cosmos;
       
        private readonly IServiceBusService _serviceBus;
        private readonly IServiceBusReviceService serviceBusReviceService;
        public HomeworkController(IAzureCosmosDBV3Repository cosmos , IServiceBusService serviceBus  , IServiceBusReviceService _serviceBusReviceService)
        {
            serviceBusReviceService = _serviceBusReviceService;
               _cosmos = cosmos;
          
            _serviceBus = serviceBus;
        }


        /// <summary>
        /// 撤消作业
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("cancel")]
        public async Task<BaseResponse> Cancel(JosnRequest<string> homeWorkId)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            List<Homework> homeWorks = await _cosmos.FindByDict<Homework>(new Dictionary<string, object> { { "id", homeWorkId.@params } });

            foreach (Homework homeWork in homeWorks)
            {
                homeWork.status = 100;
            }
            List<Homework> homeWorks1 = await _cosmos.UpdateAll<Homework>(homeWorks);

            //查询之前是否有 关联关系表 HomeWorkStudent 有则删除
            List<HomeworkRecord> homeWorkStudents = await _cosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "id", homeWorkId.@params } });
            if (homeWorkStudents.IsNotEmpty())
            {

                //TODO 删除上传的文件
                await _cosmos.DeleteAll(homeWorkStudents);
            }
            return builder.Data(homeWorks1).build();
        }

        /// <summary>
        /// 删除作业
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("delete")]
        public async Task<BaseResponse> Delete(JosnRequest<IdPk> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            IdPk idPk = await _cosmos.DeleteAsync<Homework>(request.@params);
            //按作业id删除提交记录
            List<HomeworkRecord> homeWorkStudents =  await _cosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "id", idPk.id } });
            //TODO 删除上传的文件
            await _cosmos.DeleteAll<HomeworkRecord>(homeWorkStudents);
            return builder.Data(idPk).build();
        }


        /// <summary>
        /// 新增或修改 作业活动 同时创建关联关系表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsert")]
        public async Task<BaseResponse> Upsert(JosnRequest<HomeworkDto> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            //新增
            if (string.IsNullOrEmpty(request.@params.homeWork.id))

            {
                request.@params.homeWork.id = Guid.NewGuid().ToString();
                request.@params.homeWork.status = 100;
                request.@params.reset = true;
                request.@params.homeWork.createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
            }

            
            if (request.@params.homeWork.publishModel.Equals("0"))
            {
                request.@params.homeWork.startTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
                request.@params.homeWork.status = 200;
            }
            else if (request.@params.homeWork.publishModel.Equals("1"))
            {
                //TimerWork<HomeWork>(request.@params.homeWork.startTime,new Dictionary<string, object> { { "id", request.@params.homeWork.id } });
                //设定开始时间
                string msgId = Guid.NewGuid().ToString();
                long SequenceNumber =  await _serviceBus.SendMessage<Homework>(Constants.TopicName, request.@params.homeWork.id, request.@params.homeWork.code, request.@params.homeWork.startTime,200, msgId);
                request.@params.homeWork.sequenceNumber = SequenceNumber;

                //serviceBusReviceService.ReciveMessageAsync();
                //await _serviceBus.ReciveMessageAsync<Homework>(Constants.SubName);
                //_timerWorkService.TimerWork<Homework>(request.@params.homeWork.startTime,200, new Dictionary<string, object> { { "id", request.@params.homeWork.id } });
            }

            if (request.@params.homeWork.status == 0) {

                if (request.@params.homeWork.startTime < new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds()) request.@params.homeWork.status = 200;
                else  request.@params.homeWork.status = 100;
            }

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

            //设定结束时间
            string msgEndId = Guid.NewGuid().ToString();
            await _serviceBus.SendMessage<Homework>(Constants.TopicName, request.@params.homeWork.id, request.@params.homeWork.code, request.@params.homeWork.endTime,300, msgEndId);
            //_timerWorkService.TimerWork<Homework>(request.@params.homeWork.endTime, 300, new Dictionary<string, object> { { "id", request.@params.homeWork.id } });
            //清除作业
            if (request.@params.reset)
            {
                //根据作业发布对象查找到每一个具体学生生成关联关系表 HomeWorkStudent
              //  List<Target> targets = request.@params.homeWork.target;
                //List<HomeworkRecord> homeWorkStudents = new List<HomeworkRecord>();
               // foreach (Target target in targets)
               // {
                    //查询之前是否有 关联关系表 HomeWorkStudent 有则删除
                    List<HomeworkRecord> homeWorks = await _cosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "id", request.@params.homeWork.id } });
                    if (homeWorks.IsNotEmpty())
                    {
                        await _cosmos.DeleteAll(homeWorks);
                    }
                    //List<ClassStudent> classroom = await _cosmos.FindByDict<ClassStudent>(new Dictionary<string, object> { { "id", target.classroomCode }});
                    //if (classroom.IsNotEmpty())
                    //{
                        
                    //    foreach (ClassStudent student in classroom)
                    //    {
                    //        HomeworkRecord homeWorkStudent = new HomeworkRecord();
                    //        homeWorkStudent.code = student.code;
                    //        homeWorkStudent.id = request.@params.homeWork.id;
                    //        homeWorkStudent.classroom.code = target.classroomCode;
                    //        homeWorkStudent.classroom.name = target.classroomName;
                    //        homeWorkStudents.Add(homeWorkStudent);
                    //    }
                        
                    //}
                //}
                //if (homeWorkStudents.IsNotEmpty())
                //{
                //    foreach (HomeworkRecord homeWorkStudents1 in homeWorkStudents)
                //    {
                //        List<Student> student = await _cosmos.FindById<Student>(homeWorkStudents1.code);//FindByDict<Student>(new Dictionary<string, object> { { "id", homeWorkStudents1.studentId } });
                //        if (student.IsNotEmpty())
                //        {
                          
                //            homeWorkStudents1.code = student[0].studentId;
                //          //  homeWorkStudents1.nativeroom.code = student[0].classroomCode;
                //        }
                //    }
                //    await _cosmos.SaveOrUpdateAll<HomeworkRecord>(homeWorkStudents);
                //}
            }
            return builder.Data(homeWork).build();
        }

        /// <summary>
        /// 新增或修改学生作业关联表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertRecord")]
        public async Task<BaseResponse> UpsertRecord(JosnRequest<List<HomeworkRecord>> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            await _cosmos.SaveOrUpdateAll<HomeworkRecord>(request.@params);
            return builder.Data(request.@params).build();
        }

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

            ResponseBuilder builder = ResponseBuilder.custom();
            List<Homework> data = new List<Homework>();
            List<HomeworkFindDto> homeWorkFindDtos = new List<HomeworkFindDto>();
            if (request.@params.Keys.Count>0)
            {
                data = await _cosmos.FindByDict<Homework>(request.@params);
                //判断作业提交信息
                if (data.IsNotEmpty())
                {
                    foreach (Homework homeWork in data)
                    {
                        HomeworkFindDto homeWorkFindDto = new HomeworkFindDto();
                        List<string> pro = new List<string>();
                        pro.Add("submit");
                        List<HomeworkRecord> homeWorkStudents = await _cosmos.FindByDict<HomeworkRecord>(dict: new Dictionary<string, object> { { "id", homeWork.id } }, propertys: pro);
                        int sub = 0;
                        Dictionary<string, object> dict = new Dictionary<string, object>();
                        dict.Add("Sum", homeWorkStudents.Count);
                        dict.Add("Finish", sub);
                        homeWorkFindDto = homeWork.ToJson().FromJson<HomeworkFindDto>();
                        homeWorkFindDto.statistics = dict;
                        homeWorkFindDtos.Add(homeWorkFindDto);
                    }
                }
            }
            else
            {
                return builder.Error(ResponseCode.PARAMS_ERROR, "参数异常！").build();
            }
            return builder.Data(homeWorkFindDtos).Extend(new Dictionary<string, object> { { "count", data.Count } }).build();
        }

        /// <summary>
        /// 查询作业学生关联
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findRecord")]
        public async Task<BaseResponse> FindRecord(JosnRequest<Dictionary<string, object>> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            List<HomeworkRecord> data = new List<HomeworkRecord>();
            if (request.@params.Keys.Count>0)
            {
                data = await _cosmos.FindByDict<HomeworkRecord>(request.@params);
            }
            else
            {
                return builder.Error(ResponseCode.PARAMS_ERROR, "参数异常！").build();
            }
            return builder.Data(data).Extend(new Dictionary<string, object> { { "count", data.Count } }).build();
        }




        /// <summary>
        /// 教师作业打分评论
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("tchScore")]
        public async Task<BaseResponse> TchScore(JosnRequest<HomeworkScoringDto> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            List<HomeworkRecord> homeWorkStudents = await _cosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "code", request.@params.studentId }, { "id", request.@params.homeWorkId } });
            HomeworkRecord data = new HomeworkRecord();
            if (homeWorkStudents.IsNotEmpty())
            {

                homeWorkStudents[0].score = request.@params.score ?? homeWorkStudents[0].score;
                HomeWorkComment homeWorkComment = new HomeWorkComment
                {
                    comment = request.@params.comments,
                    createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds(),
                    TEAMModelId = request.@params.TEAMModelId
                };

                homeWorkStudents[0].tchCmt = homeWorkComment;
                data = await _cosmos.SaveOrUpdate(homeWorkStudents[0]);
            }
            return builder.Data(data).build();
        }



        /// <summary>
        /// 学生作业打分评论
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("stuScore")]
        public async Task<BaseResponse> StuScore(JosnRequest<HomeworkCommentDto> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            List<HomeworkRecord> homeWorkStudents = await _cosmos.FindByDict<HomeworkRecord>(new Dictionary<string, object> { { "code", request.@params.studentId }, { "id", request.@params.homeWorkId } });
            List<Homework> homeWorks = await _cosmos.FindByDict<Homework>(new Dictionary<string, object> { { "id", request.@params.homeWorkId } });
            HomeworkRecord data = new HomeworkRecord();
            if (homeWorks.IsNotEmpty() && homeWorks[0].other.Contains("comment"))
            {
                if (homeWorkStudents.IsNotEmpty())
                {
                    if (string.IsNullOrEmpty(request.@params.commentid))
                    {
                        //评论
                        StudentComment homeWorkComment = new StudentComment
                        {
                            commentid = Guid.NewGuid().ToString(),
                            comment = request.@params.comment,
                            createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds(),
                            fromId = request.@params.fromId,
                            score = request.@params.score
                        };


                        homeWorkStudents[0].stuCmt.Add(homeWorkComment);
                    }
                    else
                    {
                        //回复评论
                        foreach (StudentComment comment in homeWorkStudents[0].stuCmt)
                        {
                            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);
                            }
                        }
                    }
                    data = await _cosmos.Update(homeWorkStudents[0]);
                }
                return builder.Data(data).build();
            }
            else {
                return builder.Error(ResponseCode.FAILED, "未开放互评！").build();
            } 
        }
    }
}