track/src/TrackCenter.Application/Services/TrackNode/TrackNodeService.cs

using Fake.Application.Dtos;
using TrackCenter.Application.Dtos.TrackNode;
using TrackCenter.Application.Dtos.TrackStatus;
using TrackCenter.Application.Helpers;
using TrackCenter.Domain.Aggregates.TrackNodeAggregate;
using TrackCenter.Domain.Aggregates.TrackStatusAggregate;
using TrackCenter.Domain.Dtos.TrackNode;

namespace TrackCenter.Application.Services.TrackNode;

/// <summary>
/// 轨迹节点服务
/// </summary>
[ApiExplorerSettings(GroupName = "轨迹节点")]
[Route("/Track/Node")]
public class TrackNodeService : ApplicationServiceBase
{
    private readonly ITrackNodeRepository _trackNodeRepository;
    private readonly ITrackStatusRepository _trackStatusRepository;

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

    /// <summary>
    /// 轨迹节点编辑
    /// </summary>
    /// <returns></returns>
    [HttpPost("Edit")]
    public async Task EditAsync(EditTrackNodeInput input)
    {
        switch (input.Options)
        {
            case OptionType.无:
                break;
            case OptionType.新增:
                await AddAsync(input);
                break;
            case OptionType.删除:
                await DeleteAsync(input);
                break;
            case OptionType.修改:
                await UpdateAsync(input);
                break;
            default:
                throw new BusinessException(message: "当前操作动作不合法");
        }
    }

    /// <summary>
    /// 获取分页轨迹节点
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("GetList")]
    public async Task<PagedResult<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<TrackNodeDto> GetDetail(int nodeid)
    {
        var resultDto = await _trackNodeRepository.GetDetail(nodeid);
        return resultDto;
    }

    /// <summary>
    /// 获取分页轨迹字典，下拉框用的
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("GetTrackNodeOption")]
    public async Task<PagedResult<TrackNodeDicDto>> GetTrackNodeOption(QueryTrackNodeRequest input)
    {
        var queryParam = ObjectMapper.Map<QueryTrackNodeRequest, TrackNodePageDto>(input);
        var resultDto = await _trackNodeRepository.GetPageDicList(queryParam);
        return resultDto;
    }

    #region 私有方法

    private async Task AddAsync(EditTrackNodeInput input)
    {
        #region 业务校验

        if (string.IsNullOrEmpty(input.NodeName) || string.IsNullOrEmpty(input.NodeEnName) ||
            !input.AppKey.HasValue)
        {
            throw new BusinessException("NodeName,NodeEnName,AppKey 必填");
        }

        var trackNodesEntitys = await _trackNodeRepository.GetListAsync(a =>
            a.AppKey == input.AppKey &&
            (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

        if (!StringHelper.IsValidEnglishString(input.NodeEnName))
        {
            throw new BusinessException("节点英文名称必须是英文和常用英文符号");
        }

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

    private async Task UpdateAsync(EditTrackNodeInput input)
    {
        #region 业务校验

        if (string.IsNullOrEmpty(input.NodeName) || string.IsNullOrEmpty(input.NodeEnName))
        {
            throw new BusinessException("NodeName,NodeEnName 必填");
        }

        var trackNodesEntitys = await _trackNodeRepository.GetFirstAsync(a => a.Id == input.Id);
        if (trackNodesEntitys == null)
        {
            throw new BusinessException("没有找到数据,更新失败");
        }

        #endregion

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

    private async Task DeleteAsync(EditTrackNodeInput input)
    {
        if (input.Id <= 0 || !input.AppKey.HasValue)
        {
            throw new BusinessException("AppKey 必填");
        }

        var trackStatus =
            await _trackStatusRepository.GetFirstAsync(val =>
                val.Node == input.Id && val.AppKey == input.AppKey);
        if (trackStatus != null)
        {
            throw new BusinessException("删除失败,该节点已被使用");
        }

        await _trackNodeRepository.DeleteById(input.Id);
    }

    #endregion
}