hotline/src/Hotline.Repository.SqlSugar/Service/ApiService.cs

using Exam.Infrastructure.Data.Entity;
using FluentValidation;
using Hotline.Repository.SqlSugar.Entitys;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Repository.SqlSugar.Interface;
using Mapster;
using MapsterMapper;
using SqlSugar;
using XF.Domain.Entities;

namespace Exam.Insfrastructure.Service.Service
{
    public class ApiService<T, TActionRequest, TDBContext> : IApiService<TActionRequest,T> where TActionRequest : ActionRequest
        where T : class, IEntity<string>, IHasCreationTime, IDataPermission, new()
        where TDBContext : SugarUnitOfWork, new()
    {
        #region ctor
        private readonly IExamRepository<T, TDBContext> _repository;

        private AbstractValidator<T> _validator;

        private IMapper _mapper;
        public ApiService(IExamRepository<T, TDBContext> repository,IMapper mapper)
        {
            _repository = repository;
            _validator = _repository.Validator;
            _mapper = mapper;
        } 
        #endregion

        #region public method
        /// <summary>
        /// 单表新增
        /// </summary>
        /// <param name="actionRequest"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task AddAsync(TActionRequest actionRequest, CancellationToken cancellationToken)
        {
            var entity = actionRequest.Adapt<T>();

            entity.ToInsert(actionRequest);


            await _repository.AddWithValidateAsync(entity, cancellationToken);
        }

        /// <summary>
        /// 单表批量新增
        /// </summary>
        /// <param name="actionRequests"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task AddAsync(List<TActionRequest> actionRequests, CancellationToken cancellationToken)
        {
            var entities = _mapper.Map<List<T>>(actionRequests);

            entities.ToInsert(actionRequests);

            await _repository.AddWithValidateAsync(entities, cancellationToken);
        }

        /// <summary>
        /// 单表删除
        /// </summary>
        /// <param name="entityQueryRequest"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task DeleteAsync(EntityQueryRequest entityQueryRequest, CancellationToken cancellationToken)
        {           
            await _repository.DeleteWithValidateAsync(entityQueryRequest,cancellationToken);
        }

        /// <summary>
        /// 单表修改
        /// </summary>
        /// <param name="actionRequest"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task UpdateAsync(TActionRequest actionRequest, CancellationToken cancellationToken)
        {
            var entity = await _repository.GetAsync(actionRequest.Id);

            entity = _mapper.Map<TActionRequest, T>(actionRequest,entity);

            entity.ToUpdate(actionRequest);

            await _repository.UpdateWithValidateAsync(entity, cancellationToken);
        }

        /// <summary>
        /// 单表修改
        /// </summary>
        /// <param name="actionRequests"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task UpdateAsync(List<TActionRequest> actionRequests, CancellationToken cancellationToken)
        {
            var ids = actionRequests.Select(x => x.Id).ToList();
            var entities = await _repository.QueryAsync(x => ids.Contains(x.Id));

            entities = _mapper.Map<List<TActionRequest>, List<T>>(actionRequests,entities);

            entities.ToUpdate(actionRequests);

            await _repository.UpdateWithValidateAsync(entities, cancellationToken);
        }

        /// <summary>
        /// 修改状态
        /// </summary>
        /// <param name="statusActionRequests"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task UpdateStatus(List<StatusActionRequest> statusActionRequests, CancellationToken cancellationToken)
        {
            var ids = statusActionRequests.Select(x => x.Id).ToList();
            var entities = await _repository.QueryAsync(x => ids.Contains(x.Id));

            entities = _mapper.Map<List<StatusActionRequest>, List<T>>(statusActionRequests,entities);

            entities.ToUpdate(statusActionRequests);

            await _repository.UpdateWithValidateAsync(entities, cancellationToken);
        }
        #endregion
    }
}