track/src/SJZY.Track.Application/Services/TrackFlags/TrackFlagService.cs

using Microsoft.Extensions.Localization;
using SJZY.Track.Application.Contract.Dtos.TrackFlags;
using SJZY.Track.Application.Localization;
using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
using SJZY.Track.Domain.Aggregates.TrackFlagAggregate;
using SJZY.Track.Domain.Dtos.TrackFlags;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.Services.TrackFlags
{
    /// <summary>
    /// 轨迹标记服务
    /// </summary>
    [ApiExplorerSettings(GroupName = "轨迹标记")]
    [Route("/Track/Flag")]
    public class TrackFlagService : ApplicationService, ITransientDependency
    {
        private readonly IStringLocalizer<TrackLocalizationResource> _stringLocalizer;
        private readonly ITrackFlagRepository _trackFlagRepository;
        private readonly ITrackContentRepository _trackContentRepository;

        public TrackFlagService(
            IStringLocalizer<TrackLocalizationResource> stringLocalizer,
            ITrackFlagRepository trackFlagRepository,
            ITrackContentRepository trackContentRepository
        )
        {
            this._stringLocalizer = stringLocalizer;
            this._trackFlagRepository = trackFlagRepository;
            this._trackContentRepository=trackContentRepository;
        }

        /// <summary>
        /// 轨迹标记编辑
        /// </summary>
        /// <returns></returns>
        [HttpPost("Edit")]
        public async Task<UnifyResultDto> EditAsync(EditTrackFlagInput input)
        {
            return input.Options switch
            {
                OptionType.新增 => await AddAsync(input),
                OptionType.修改 => await UpdateAsync(input),
                OptionType.删除 => await DeleteAsync(input),
                _ => throw new BusinessException(message: "当前操作动作不合法")
            };
        }

        /// <summary>
        /// 根据标记id获取轨迹标记
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("GetDetail")]
        public async Task<UnifyResultDto<GetTrackFlagDetailDto>> GetDetailAsync(int id)
        {
            var detailInfo = await _trackFlagRepository.GetDetailAsync(id);
            if (detailInfo == null)
            {
                return new UnifyResultDto<GetTrackFlagDetailDto>(false, null, "未查询到轨迹状态");
            }

            var dto = ObjectMapper.Map<GetTrackFlagDetailVO, GetTrackFlagDetailDto>(detailInfo);
            return new UnifyResultDto<GetTrackFlagDetailDto>("200", "", dto);
        }

        /// <summary>
        /// 获取分页轨迹标记
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("GetList")]
        public async Task<UnifyPageResultDto<GetTrackFlagListDto>> GetPageTrackFlag(GetPageTrackFlagInput input)
        {
            var vo = ObjectMapper.Map<GetPageTrackFlagInput, GetPageTrackFlagVO>(input);
            var resultDto = await _trackFlagRepository.GetPageTrackFlag(vo);
            var pageResultDto =
                ObjectMapper.Map<UnifyPageResultDto<GetTrackFlagListVO>, UnifyPageResultDto<GetTrackFlagListDto>>(
                    resultDto);

            return pageResultDto;
        }

        #region 私有方法

        private async Task<UnifyResultDto> AddAsync(EditTrackFlagInput input)
        {
            #region 业务校验

            var trackStatusEntity = await _trackFlagRepository.GetFirstAsync(a =>
                a.SubSystemId == input.SubSystemId && (a.Code == input.Code || a.Name == input.Flag));
            if (trackStatusEntity != null)
            {
                throw new BusinessException(message: _stringLocalizer["TrackFlagExist"]);
            }

            #endregion

            var entity = ObjectMapper.Map<EditTrackFlagInput, TrackFlagEntity>(input);
            var isTrue = await _trackFlagRepository.InsertAsync(entity);

            return new UnifyResultDto("200", "新增成功", isTrue);
        }

        private async Task<UnifyResultDto> UpdateAsync(EditTrackFlagInput input)
        {
            #region 业务校验

            var trackStatusEntity = await _trackFlagRepository.GetFirstAsync(a => a.Id != input.Id &&
                a.SubSystemId == input.SubSystemId && (a.Code == input.Code ||
                                                       a.Name == input.Flag));
            if (trackStatusEntity != null)
            {
                throw new BusinessException(message: _stringLocalizer["TrackFlagExist"]);
            }

            #endregion

            var templateEntity = await _trackFlagRepository.GetFirstAsync(a => a.Id == input.Id);
            ObjectMapper.Map(input, templateEntity);
            var isTrue = await _trackFlagRepository.UpdateAsync(templateEntity);

            return new UnifyResultDto("200", "修改成功", isTrue);
        }

        private async Task<UnifyResultDto> DeleteAsync(EditTrackFlagInput input)
        {
            #region 业务校验
            var isExistContent = await _trackContentRepository.GetFirstAsync(a => a.TrackFlagId==input.Id);
            if (isExistContent!=null)
            {
                throw new BusinessException(message: _stringLocalizer["IsExistTrackFlag"]);
            }
            #endregion
            var isTrue = await _trackFlagRepository.SoftDeleteAsync(x => x.Id == input.Id);

            return new UnifyResultDto("200", "删除成功", isTrue);
        }

        #endregion
    }
}