TEAMModelOS/TEAMModelOS/Controllers/Task/LearnController.cs

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

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

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

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

        /// <summary>
        /// 查询学习任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findTask")]
        public async Task<BaseResponse> FindTask(JosnRequest<Dictionary<string,object>> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (request.@params.ContainsKey("id") || request.@params.ContainsKey("code"))
            {
                List<LearnTask> tasks = await cosmosDBV3Repository.FindByDict<LearnTask>(request.@params);
                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(JosnRequest<IdPk> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            return builder.Data(await cosmosDBV3Repository.DeleteAsync<LearnTask>(request.@params)).build();
        }

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

   

    /// <summary>
    /// 查询学习单元
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpPost("findUnit")]
        public async Task<BaseResponse> FindUnit(JosnRequest<Dictionary<string, object>> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (request.@params.Keys.Count > 0)
            {
                return builder.Data(await cosmosDBV3Repository.FindByDict<LearnUnit>(request.@params)).build();
            }
            else {
                return builder.build();
            }
            
        }
        /// <summary>
        /// 删除学习单元
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("deleteUnit")]
        public async Task<BaseResponse> DeleteUnit(JosnRequest<IdPk> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            return builder.Data(await cosmosDBV3Repository.DeleteAsync<LearnUnit>(request.@params)).build();
        }

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

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

        /// <summary>
        /// 查询编序学习活动
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("findProcess")]
        public async Task<BaseResponse> FindProcess(JosnRequest<Dictionary<string, object>> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (request.@params.Keys.Count>0) {

                builder.Data(await cosmosDBV3Repository.FindByDict<LearnProcess>(request.@params));
            }

            return builder.build();
        }

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

        /// <summary>
        /// 保存或新增作答记录
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("upsertRecord")]
        public async Task<BaseResponse> UpsertRecord(JosnRequest<List<LearnRecord>> request)
        {
            ResponseBuilder builder = ResponseBuilder.custom();
            if (ValidateHelper.IsValid(request.@params))
            {
                request.@params.ForEach(x =>
                {
                    if (string.IsNullOrEmpty(x.id))
                    {
                     
                    }
                });
                List<LearnRecord> leanProcesses = await cosmosDBV3Repository.SaveOrUpdateAll<LearnRecord>(request.@params);
                builder.Data(leanProcesses);
            }
            return builder.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();
            if (request.@params.Keys.Count > 0)
            {
                builder.Data(await cosmosDBV3Repository.FindByDict<LearnRecord>(request.@params));
            }
            return builder.build();
        }


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