TEAMModelOS/TEAMModelOS/Controllers/Exam/ExamController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.Service.Models; 
using TEAMModelOS.SDK.Context.Constant.Common;
using TEAMModelOS.Service.Services.Learn.Implements;
using System.Text.Json;

namespace TEAMModelOS.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ExamController : BaseController
    {
        private readonly SnowflakeId SnowflakeId;
        private readonly AzureCosmosFactory cosmosDBV3Repository;
        private readonly AzureServiceBusFactory _serviceBus;
        public ExamController(AzureCosmosFactory _cosmosDBV3Repository, AzureServiceBusFactory serviceBus, SnowflakeId _SnowflakeId)
        {
            
            cosmosDBV3Repository = _cosmosDBV3Repository;
            _serviceBus = serviceBus;
            SnowflakeId = _SnowflakeId;
        }

        /// <summary>
        /// 保存考试信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("save")]
        public async Task<BaseResponse> Save(ExamInfo request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            
            if (string.IsNullOrEmpty(request.id))
            {
                request.id = SnowflakeId.NextId()+"";
                request.status = 100;
                // await cosmosDBV3Repository.SaveOrUpdate(request.@params);
            }
            if (request.publish.Equals("0"))
            {
                request.startTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
                request.status = 200;
            }
            else if (request.publish.Equals("1"))
            {
                //设定开始时间
                string msgId = SnowflakeId.NextId() + "";
                long SequenceNumber = await _serviceBus.SendMessage<ExamInfo>(Constants.TopicName, request.id, request.code, request.startTime, 200, msgId);
                request.sequenceNumber = SequenceNumber;
            }
            if (request.status == 0)
            {
                if (request.startTime < new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds()) request.status = 200;
                else request.status = 100;
            }
            await cosmosDBV3Repository.SaveOrUpdate(request);
            //设定结束时间
            string msgEndId = SnowflakeId.NextId() + "";
            await _serviceBus.SendMessage<ExamInfo>(Constants.TopicName, request.id, request.code, request.endTime, 300, msgEndId);
            return builder.Data(request).build();
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("delete")]
        public async Task<BaseResponse> Delete(IdPk request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            IdPk items = await cosmosDBV3Repository.DeleteAsync<ExamInfo>(request.id, request.pk);
            await cosmosDBV3Repository.DeleteAll<Paper>(new Dictionary<string, object>() { { "code", request.id } });
            return builder.Data(items).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();
            int keys = 0;
            while (emobj.MoveNext())
            {
                keys++;
                //dict[emobj.Current.Name] = emobj.Current.Value;
            }
            if (keys > 0)
            {
                return builder.Data(await cosmosDBV3Repository.FindByDict<ExamInfo>(request)).build();
            }
            else {
                return builder.build();
            }
        }
        /// <summary>
        /// 教师阅卷
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("marking")]
        public async Task<BaseResponse> Marking(ExamRecord request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            //判断是否每一个题目都有分数
            List<ExamInfo> exams = await cosmosDBV3Repository.FindByDict<ExamInfo>(new Dictionary<string, object> { { "id", request.examCode } });

            if (exams.IsNotEmpty())
            {
                ExamInfo examInfo = exams[0];
                //提交答案时间必须是状态已发布，且时间在起止时间内
                if ( examInfo.status == 300 &&
                   examInfo.endTime <= new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds())
                {
                    return builder.Data(await cosmosDBV3Repository.SaveOrUpdate(request)).build();
                }
                else
                {
                    return builder.Error(ResponseCode.FAILED, "请在作答时间段内提交答案!").build();
                }
            }
            else
            {
                return builder.Error(ResponseCode.DATA_EXIST, "考试不存在!").build();
            }
        }


        /// <summary>
        /// 学生回答问题
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertAllRecord")]
        public async Task<BaseResponse> upsertRecord(List<ExamRecord> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (request.IsNotEmpty())
            {
                //要先处理状态，判断卷子是否存在，并判断卷子归属的考试是否允许再次提交
                List<ExamInfo> exams = await cosmosDBV3Repository.FindByDict<ExamInfo>(new Dictionary<string, object> { { "id", request[0].examCode } });
                if (exams.IsNotEmpty())
                {
                    
                    return builder.Data(await cosmosDBV3Repository.SaveOrUpdateAll(request)).build();
                }
                else
                {
                    return builder.Error(ResponseCode.DATA_EXIST, "考试不存在!").build();
                    
                }
            }
            else {
                return builder.Error(ResponseCode.PARAMS_ERROR, "作答数据为空!").build();
            }
        }
        /// <summary>
        /// 学生回答问题
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertRecord")]
        public async Task<BaseResponse> upsertRecord(ExamRecord request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            //要先处理状态，判断卷子是否存在，并判断卷子归属的考试是否允许再次提交
            List<ExamInfo> exams=  await cosmosDBV3Repository.FindByDict<ExamInfo>(new Dictionary<string, object> { { "id", request.examCode } });
            if (exams.IsNotEmpty())
            {
                ExamInfo examInfo = exams[0];
                //提交答案时间必须是状态已发布，且时间在起止时间内
                if (examInfo.startTime <= new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds() && examInfo.status == 200 &&
                   examInfo.endTime >= new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds())
                {
                    return builder.Data(await cosmosDBV3Repository.SaveOrUpdate(request)).build();
                }
                else
                {
                    return builder.Error(ResponseCode.FAILED, "请在作答时间段内提交答案!").build();
                }
            }
            else {
                return builder.Error(ResponseCode.DATA_EXIST, "考试不存在!").build();
            }
        }

        /// <summary>
        /// 查询作答摘要信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findSummaryRecord")]
        public async Task<BaseResponse> findSummaryRecord(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            //Dictionary<string, object> dict = new Dictionary<string, object>();
            var emobj = request.EnumerateObject();
            int keys = 0;
            List<string> skey = new List<string>();
            while (emobj.MoveNext())
            {
                keys++;
                skey.Add(emobj.Current.Name);
                //dict[emobj.Current.Name] = emobj.Current.Value;
            }

            //request.TryGetProperty("code",out JsonElement code);
            // 如果只有学生id则返回学生参加过的考试 只返回相关摘要信息
            if (keys == 1 && skey.Contains("code"))
            {
                List<string> props = new List<string> { "id", "code", "examCode", "status", "mark", "score" };
                List<ExamRecord> examRecords = await cosmosDBV3Repository.FindByDict<ExamRecord>(request, props);
                return builder.Data(examRecords).Extend(new Dictionary<string, object> { { "props", props } }).build();
            }
            else {
                if (skey.Contains("examCode"))
                {
                    List<string> props = new List<string> { "id", "code", "examCode", "status", "mark", "score" };
                    List<ExamRecord> examRecords = await cosmosDBV3Repository.FindByDict<ExamRecord>(request, props);
                    return builder.Data(examRecords).Extend(new Dictionary<string, object> { { "props", props } }).build();
                }
                else {
                    return builder.Error(ResponseCode.PARAMS_ERROR, "参数错误！").build();
                }
            }
        }
        /// <summary>
        /// 查询单个作答信息  试卷id ,
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findByIdPk")]
        public async Task<BaseResponse> findByIdPk(IdPk request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            ExamRecord record = await cosmosDBV3Repository.FindByIdPk<ExamRecord>(request.id,request.pk);
            if (record != null) {
                //处理客观题自动阅卷
                Paper paper = await cosmosDBV3Repository.FindByIdPk<Paper>(record.id, record.examCode);
                //允许自动对客观题阅卷及，及阅卷状态大于2 已完成.
                if (paper.markConfig != null && paper.markConfig.auto && record.mark<2) {
                    // TODO 需要处理已经打分的作答，以防止手动改分后被冲掉。

                    if (paper.answers.IsNotEmpty() && record.answers.IsNotEmpty()) {
                        autoMark(paper.item, paper.answers, record.answers, paper.markConfig);
                    }
                }
            }
            return builder.Data(record).build();
        }

        public static List<Answer> autoMark(List<ItemInfo> items ,List<Answer> stdAnswers, List<Answer> stuAnswers ,MarkConfig markConfig) {
            int size = stuAnswers.Count;
            for (int i = 0; i < size; i++) {
                //如果当前题目已经打分则直接跳过。
                if (stuAnswers[i].score > 0) {
                    stuAnswers[i].mark = 1;
                    continue;
                }
                //客观题
                if (stuAnswers[i].type.Equals("Single") || stuAnswers[i].type.Equals("Multiple") || stuAnswers[i].type.Equals("Judge")) {
                    stuAnswers[i].mark = 1;
                    //多选题单独处理
                    if (stuAnswers[i].type.Equals("Multiple"))
                    {
                        List<string> stuAns = stuAnswers[i].ans;
                        Answer stdAnswer = stdAnswers.Where(x =>x.num== stuAnswers[i].num).FirstOrDefault();
                        if (stdAnswer != null) {
                            //处理多选答案是否有选错的 选错的则直接0分 ，如果少选则处理部分分数
                            bool right = true;
                            List<string> rightStr = new List<string>();
                            if (stuAns.IsNotEmpty())
                            {
                                foreach (string stuAn in stuAns)
                                {
                                    if (!stdAnswer.ans.Contains(stuAn))
                                    {
                                        right = false;
                                        break;
                                    }
                                    else {
                                        rightStr.Add(stuAn);
                                    }
                                }
                            }
                            else {
                                right = false;
                            }
                            if (right && rightStr.IsNotEmpty() && rightStr.Count != stdAnswer.ans.Count)
                            {

                                if (markConfig.type == 1)
                                {
                                    //1多选漏选不得分
                                    stuAnswers[i].score = 0;
                                }
                                else if(markConfig.type==3){
                                    stuAnswers[i].score=Math.Floor((double)(1.0 * rightStr.Count / stdAnswer.ans.Count * stdAnswer.score));
                                    if (stuAnswers[i].score == 0) {
                                        stuAnswers[i].score = 1;
                                    }
                                }
                                else if (markConfig.type == 4)
                                {
                                    stuAnswers[i].score = markConfig.score;
                                }
                                else
                                {   //2多选漏选得一半的分数（默认）
                                    stuAnswers[i].score = stdAnswer.score/2;

                                }
                            }
                            else {
                                //选错不得分
                                stuAnswers[i].score = 0;
                            }
                        }
                    }
                    else {
                        List<string> stuAns = stuAnswers[i].ans;
                        Answer stdAnswer = stdAnswers.Where(x => x.num == stuAnswers[i].num).FirstOrDefault();
                        if (stdAnswer != null&&stdAnswer.ans.IsNotEmpty()&& stuAns.IsNotEmpty()) {
                            if (stuAns[0].Equals(stdAnswer.ans[0]))
                            {
                                stuAnswers[i].score = stdAnswer.score;
                            }
                            else {
                                stuAnswers[i].score = 0;
                            }
                        }
                    }
                }
            }
            return stuAnswers;
        } 
    }
}