itfx/src/InterfaceForward.Application/Services/Parameter/FixedParameterService.cs

using System.ComponentModel.DataAnnotations;
using Fake.Auditing;
using Fake.UnitOfWork;
using InterfaceForward.Application.Contracts.Dtos.ServiceProvider;
using InterfaceForward.Application.Helpers;
using InterfaceForward.Domain.Shared;
using InterfaceForward.Domain.Shared.Enum;
using InterfaceForward.Repositories.ServiceProvider.Entitys;
using InterfaceForward.Repositories.ServiceProvider.Services;
using Microsoft.AspNetCore.Mvc;

namespace InterfaceForward.Application.Services.Parameter;

/// <summary>
/// 固定参数配置
/// </summary>
[ApiExplorerSettings(GroupName = "参数服务")]
public class FixedParameterService : ApplicationService, IAuditingEnabled
{
    private readonly IFixedParameterRepository _fixedParameterRepository;
    private readonly IServiceProviderRepository _serviceProviderRepository;

    /// <inheritdoc />
    public FixedParameterService(
        IFixedParameterRepository fixedParameterRepository,
        IServiceProviderRepository serviceProviderRepository)
    {
        _fixedParameterRepository = fixedParameterRepository;
        _serviceProviderRepository = serviceProviderRepository;
    }

    /// <summary>
    /// 获取固定参数列表
    /// </summary>
    /// <param name="serviceProviderId">服务商id</param>
    /// <param name="interfaceId">接口id</param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpGet("FixedParameter/GetFixedParameterList")]
    public async Task<List<FixedParameterItemOutput>> GetFixedParameterList([Required] int serviceProviderId,
        int? interfaceId)
    {
        var list = interfaceId == null
            ? await _fixedParameterRepository.GetListAsync(x => x.ServiceProviderId == serviceProviderId)
            : await _fixedParameterRepository.GetListAsync(x =>
                x.ServiceProviderId == serviceProviderId || x.InterfaceId == interfaceId);
        var res = ObjectMapper.Map<List<FixedParameterEntity>, List<FixedParameterItemOutput>>(list);
        for (var i = 0; i < res.Count; i++)
        {
            var item = res[i];

            item.FieldPositionList = string.IsNullOrWhiteSpace(list[i].FieldPositions)
                ? new List<FieldPosition>()
                : list[i].FieldPositions.Split(",").Select(Enum.Parse<FieldPosition>).ToList();

            item.DisableEdit = interfaceId != null && list[i].ServiceProviderId != null;
        }

        return res.OrderByDescending(x => x.DisableEdit).ToList();
    }


    /// <summary>
    /// 维护固定参数
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("FixedParameter/MaintainParameter")]
    public virtual async Task<bool> MaintainParameterAsync([FromBody] FixedParameterInput input)
    {
        // 校验服务商是否存在
        if (!await _serviceProviderRepository.IsAnyAsync(x => x.Id == input.ServiceProviderId))
        {
            throw new BusinessException("服务商不存在");
        }

        // 校验账户字段是否合法
        await ValidationAccountFieldAsync(input);

        using var ts = TransacationHelper.GetReadCommitted();
        var delIds = input.Items
            .Where(x => x.Options == OptionType.删除)
            .Select(x => x.Id).ToArray();
        await _fixedParameterRepository.SoftDeleteAsync(x => delIds.Contains(x.Id));
        await UpdateFieldAsync(input);
        await CreateFieldAsync(input);

        ts.Complete();
        return true;
    }


    /// <summary>
    /// 更新字段
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private async Task UpdateFieldAsync(FixedParameterInput input)
    {
        using var ts = TransacationHelper.GetReadCommitted();

        foreach (var item in input.Items.Where(x => x.Options == OptionType.修改).ToList())
        {
            if (input.InterfaceId != null)
            {
                if (await _fixedParameterRepository.IsAnyAsync(x =>
                        input.InterfaceId == x.InterfaceId &&
                        x.FieldName == item.FieldName && x.Id != item.Id))
                {
                    throw new BusinessException($"参数{item.FieldName}已存在");
                }
            }
            else
            {
                if (await _fixedParameterRepository.IsAnyAsync(x =>
                        input.ServiceProviderId == x.ServiceProviderId &&
                        x.FieldName == item.FieldName && x.Id != item.Id))
                {
                    throw new BusinessException($"参数{item.FieldName}已存在");
                }
            }


            var entity = ObjectMapper.Map<FixedParameterItem, FixedParameterEntity>(item);

            entity.FieldPositions = item.FieldPositionList.JoinAsString(",");

            await _fixedParameterRepository.UpdateFieldAsync(entity);
        }

        ts.Complete();
    }

    /// <summary>
    /// 创建字段
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private async Task CreateFieldAsync(FixedParameterInput input)
    {
        foreach (var item in input.Items.Where(x => x.Options == OptionType.新增))
        {
            if ((input.InterfaceId != null &&
                 await _fixedParameterRepository.IsAnyAsync(x =>
                     input.InterfaceId == x.InterfaceId && x.FieldName == item.FieldName))
                || (input.InterfaceId == null &&
                    await _fixedParameterRepository.IsAnyAsync(x =>
                        input.ServiceProviderId == x.ServiceProviderId && x.FieldName == item.FieldName))
               )
            {
                throw new BusinessException($"参数{item.FieldName}已存在");
            }

            var entity = ObjectMapper.Map<FixedParameterItem, FixedParameterEntity>(item);

            if (input.InterfaceId != null)
            {
                entity.InterfaceId = input.InterfaceId;
            }
            else
            {
                entity.ServiceProviderId = input.ServiceProviderId;
            }

            entity.FieldPositions = item.FieldPositionList.JoinAsString(",");

            await _fixedParameterRepository.InsertAsync(entity);
        }
    }

    private async Task ValidationAccountFieldAsync(FixedParameterInput input)
    {
        var accountFields =
            await _serviceProviderRepository.GetAccountParameterDropdownListAsync(input.ServiceProviderId);

        foreach (var item in input.Items.Where(x => x.Options == OptionType.新增 || x.Options == OptionType.修改))
        {
            if (item.FieldValue.Equals(GlobalConst.FromAccount))
            {
                var fieldName = item.FieldName;

                if (item.FieldPositionList.Contains(FieldPosition.Body))
                {
                    var idx = fieldName.LastIndexOf('.');
                    if (idx != -1 && idx + 1 < fieldName.Length)
                    {
                        fieldName = fieldName.Substring(idx + 1);
                    }
                }

                if (accountFields.All(x => x.Value != fieldName))
                {
                    throw new BusinessException($"账户中不存在字段：{fieldName}");
                }
            }
        }
    }
}