track/src/SJZY.Track.Application/Services/TrackNode/TrackNodeService.cs

using SJZY.Track.Application.Contract.Dtos.TrackNode;
using SJZY.Track.Application.Contract.Dtos.TrackStatus;
using SJZY.Track.Domain.Aggregates.TrackNodeAggregate;
using SJZY.Track.Domain.Aggregates.TrackStatusAggregate;
using SJZY.Track.Domain.Dtos.TrackNode;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.Services.TrackNode
{
    /// <summary>
    /// 轨迹节点服务
    /// </summary>
    [ApiExplorerSettings(GroupName = "轨迹节点")]
    [Route("/Track/Node")]
    public class TrackNodeService : ApplicationService, ITransientDependency
    {   
        private readonly ITrackStatusRepository _trackStatusRepository;
        private readonly ITrackNodeRepository _trackNodeRepository;

        public TrackNodeService(
            ITrackNodeRepository trackNodeRepository, ITrackStatusRepository trackStatusRepository)
        {
            this._trackNodeRepository = trackNodeRepository;
            _trackStatusRepository = trackStatusRepository;
        }

        /// <summary>
        /// 轨迹节点编辑
        /// </summary>
        /// <returns></returns>
        [HttpPost("Edit")]
        public async Task<UnifyResultDto> EditAsync(EditTrackNodeInput input)
        {
            return input.Options switch
            {
                OptionType.新增 => await AddAsync(input),
                OptionType.修改 => await UpdateAsync(input),
                OptionType.删除 => await DeleteAsync(input),
                _ => throw new BusinessException(message: "当前操作动作不合法")
            };
        }
        
        /// <summary>
        /// 获取分页轨迹节点
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("GetList")]
        public async Task<UnifyPageResultDto<TrackNodeDto>> GetPageTrackNode(QueryTrackNodeRequest input)
        {
            var queryParam = ObjectMapper.Map<QueryTrackNodeRequest, TrackNodePageDto>(input);
            var resultDto = await _trackNodeRepository.GetPageList(queryParam);
            return resultDto;
        }
        
        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="nodeid">节点id</param>
        /// <returns></returns>
        [HttpPost("GetDetail")]
        public async Task<UnifyResultDto> GetDetail(int nodeid)
        {
            var resultDto = await _trackNodeRepository.GetDetail(nodeid);
            return new UnifyResultDto(true,resultDto);
        }
                
        /// <summary>
        /// 获取分页轨迹字典，下拉框用的
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("GetTrackNodeOption")]
        public async Task<UnifyPageResultDto<TrackNodeDicDto>> GetTrackNodeOption(QueryTrackNodeRequest input)
        {
            var queryParam = ObjectMapper.Map<QueryTrackNodeRequest, TrackNodePageDto>(input);
            var resultDto = await _trackNodeRepository.GetPageDicList(queryParam);
            return resultDto;
        }

        #region 私有方法

        private async Task<UnifyResultDto> AddAsync(EditTrackNodeInput input)
        {
            #region 业务校验
            if(string.IsNullOrEmpty(input.NodeName)|| string.IsNullOrEmpty(input.NodeEnName) || !input.SubSystemId.HasValue)
            {
                return new UnifyResultDto("200", "NodeName,NodeEnName,SubSystemId 必填", false);
            }
            
            var trackNodesEntitys = await _trackNodeRepository.GetListAsync(a =>
                a.SubSystemId == input.SubSystemId && (a.NodeName == input.NodeName || a.NodeEnName == input.NodeEnName));
            if (trackNodesEntitys.Any())
            {
                var trackNodeName = trackNodesEntitys.FirstOrDefault(a => a.NodeName == input.NodeName);
                if (trackNodeName != null)
                {
                    throw new BusinessException(message: "该子系统下节点名称已存在");
                }
                var trackNodeEnName = trackNodesEntitys.FirstOrDefault(a => a.NodeEnName == input.NodeEnName);
                if (trackNodeEnName != null)
                {
                    throw new BusinessException(message: "该子系统下节点英文名称已存在");
                }
            }
            #endregion

            var entity = ObjectMapper.Map<EditTrackNodeInput, TrackNodeEntity>(input);
            var isTrue = await _trackNodeRepository.InsertAsync(entity);

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

        private async Task<UnifyResultDto> UpdateAsync(EditTrackNodeInput input)
        {
            #region 业务校验
            if(string.IsNullOrEmpty(input.NodeName)|| string.IsNullOrEmpty(input.NodeEnName) )
            {
                return new UnifyResultDto("200", "NodeName,NodeEnName 必填", false);
            }
            
            var trackNodesEntitys = await _trackNodeRepository.GetFirstAsync(a => a.Id == input.Id);
            if (trackNodesEntitys == null)
            {
                return new UnifyResultDto("200", "没有找到数据,更新失败", false);
            }

            #endregion

            trackNodesEntitys.NodeEnName = input.NodeEnName;
            trackNodesEntitys.NodeName = input.NodeName;
            var isTrue = await _trackNodeRepository.UpdateAsync(trackNodesEntitys);

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

        private async Task<UnifyResultDto> DeleteAsync(EditTrackNodeInput input)
        {
            if(input.Id <=0 || !input.SubSystemId.HasValue)
            {
                return new UnifyResultDto("200", "SubSystemId 必填", false);
            }
            
            var trackStatus = await _trackStatusRepository.GetFirstAsync(val => val.Node == input.Id && val.SubSystemId == input.SubSystemId);
            if(trackStatus!=null)
            {
                return new UnifyResultDto("200", "删除失败,该节点已被使用", false);
            }
            
            var rows = await _trackNodeRepository.DeleteById(input.Id);
            return new UnifyResultDto("200", "删除成功", rows>0);
        }

        #endregion
    }
}