TEAMModelOS/TEAMModelOS/Controllers/Task/LearnController.cs

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.Models.StudentInfo;
using TEAMModelOS.Models.TeacherInfo;
using TEAMModelOS.SDK;
using TEAMModelOS.SDK.Context.Constant.Common;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Helper.Common.StringHelper;
using TEAMModelOS.SDK.Helper.Common.ValidateHelper;

namespace TEAMModelOS.Controllers.Learn
{
    /// <summary>
    /// 学习活动
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class LearnController: BaseController
    {
        private readonly SnowflakeId _snowflakeId;
        private readonly AzureCosmosFactory _azureCosmos;
        private readonly AzureServiceBusFactory _serviceBus;
        public LearnController(AzureCosmosFactory azureCosmos, AzureServiceBusFactory serviceBus, SnowflakeId snowflakeId)
        {
            _snowflakeId = snowflakeId;
            _serviceBus = serviceBus;
            _azureCosmos = azureCosmos;
        }

        /// <summary>
        /// 保存或更新学习任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertTask")]
        public async Task<BaseResponse> UpsertTask(LearnTask request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (request.createTime <= 0) {
                request.createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
            }

            if (request.endTime > 0) {
                //设定结束时间
                string msgEndId = _snowflakeId.NextId()+"";
                await _serviceBus.GetServiceBusClient().SendLeamMessage<LearnTask>(Constants.TopicName, request.id, request.code, request.endTime, 300, msgEndId);
            }
            await _azureCosmos.Save(request);
            return builder.Data(request).build();
        }

        /// <summary>
        /// 查询学习任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findTask")]
        public async Task<BaseResponse> FindTask(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (request.TryGetProperty("id",out _) || request.TryGetProperty("code",out _))
            {
                List<LearnTask> tasks = await _azureCosmos.FindByDict<LearnTask>(request);
                return builder.Data(tasks).build();
            }
            else {
                return builder.Error(ResponseCode.PARAMS_ERROR, "参数异常！").build(); 
            }
            
        }
        /// <summary>
        /// 删除学习任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("deleteTask")]
        public async Task<BaseResponse> DeleteTask(IdPk request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            return builder.Data(await _azureCosmos.DeleteAsync<LearnTask>(request)).build();
        }

        /// <summary>
        /// 保存或更新学习单元单元
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertUnit")]
        public async Task<BaseResponse> UpsertUnit(LearnUnit request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (string.IsNullOrEmpty(request.id))
            {
                request.id = _snowflakeId.NextId() + "";
                request.createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
                await _azureCosmos.Save(request);
            }
            else
            {
                await _azureCosmos.Update(request);
            }
            return builder.Data(request).build();
        }

   

    /// <summary>
    /// 查询学习单元
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpPost("findUnit")]
        public async Task<BaseResponse> FindUnit(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();

            if (StringHelper.getKeyCount(request) > 0)
            {
                return builder.Data(await _azureCosmos.FindByDict<LearnUnit>(request)).build();
            }
            else {
                return builder.build();
            }
            
        }
        /// <summary>
        /// 删除学习单元
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("deleteUnit")]
        public async Task<BaseResponse> DeleteUnit(IdPk request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            return builder.Data(await _azureCosmos.DeleteAsync<LearnUnit>(request)).build();
        }

        /// <summary>
        /// 保存或新增编序学习活动
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertProcess")]
        public async Task<BaseResponse> UpsertProcess(LearnProcess request) {
            ResponseBuilder builder = ResponseBuilder.custom();

            if (string.IsNullOrEmpty(request.id))
            {
                request.id = _snowflakeId.NextId() + "";
                request.createTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
                await _azureCosmos.Save<LearnProcess>(request);
            }
            else {
                await _azureCosmos.Update<LearnProcess>(request);
            }
           
            return builder.Data(request).build();
        }

        /// <summary>
        /// 查询编序学习活动
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findProcess")]
        public async Task<BaseResponse> FindProcess(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();

            if (StringHelper.getKeyCount(request) > 0) {

                builder.Data(await _azureCosmos.FindByDict<LearnProcess>(request));
            }

            return builder.build();
        }

        /// <summary>
        /// 删除编序学习活动
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("deleteProcess")]
        public async Task<BaseResponse> DeleteProcess(IdPk request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (request != null)
            {
                builder.Data(await _azureCosmos.DeleteAsync<LearnProcess>(request));
            }
            return builder.build();
        }

        /// <summary>
        /// 保存或新增作答记录
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertRecord")]
        public async Task<BaseResponse> UpsertRecord(List<LearnRecord> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (ValidateHelper.IsValid(request))
            {
                request.ForEach(x =>
                {
                    if (string.IsNullOrEmpty(x.id))
                    {
                     
                    }
                });
                List<LearnRecord> leanProcesses = await _azureCosmos.SaveOrUpdateAll<LearnRecord>(request);
                builder.Data(leanProcesses);
            }
            return builder.build();
        }

        /// <summary>
        /// 查询编序作答记录
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findRecord")]
        public async Task<BaseResponse> FindRecord(JsonElement request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (StringHelper.getKeyCount(request) > 0)
            {
                builder.Data(await _azureCosmos.FindByDict<LearnRecord>(request));
            }
            return builder.build();
        }


        /// <summary>
        /// 删除作答记录
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("deleteRecord")]
        public async Task<BaseResponse> DeleteRecord(IdPk request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (request != null)
            {
                builder.Data(await _azureCosmos.DeleteAsync<LearnRecord>(request));
            }
            return builder.build();
        }
    }
}