ideship/itfx
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
Antinew 2024-03-23 09:29:40 +09:00
parent ba53652de6
commit bf8c250e96
5 changed files with 653 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/InterfaceForward.Api/Controllers/Interface/InterfaceReturnConfigService.cs Normal file
View File

@ -0,0 +1,84 @@
using System.ComponentModel.DataAnnotations;
using Fake;
using Fake.AspNetCore;
using InterfaceForward.Domain.Aggregates.InterfaceAggregate;
using Microsoft.AspNetCore.Mvc;
namespace SJZY.InterfaceRelay.Application.Services.Interface;
/// <summary>
/// 接口返回配置
/// </summary>
[ApiExplorerSettings(GroupName = "接口服务")]
public class InterfaceReturnConfigService : ApplicationService
{
private readonly IInterfaceReturnConfigRepository _interfaceReturnConfigRepository;
private readonly IInterfaceRepository _interfaceRepository;
/// <summary>
///
/// </summary>
public InterfaceReturnConfigService(
IInterfaceReturnConfigRepository interfaceReturnConfigRepository
, IInterfaceRepository interfaceRepository)
{
_interfaceRepository = interfaceRepository;
_interfaceReturnConfigRepository = interfaceReturnConfigRepository;
}
/// <summary>
/// 接口配置列表，配置类型传null则全查
/// </summary>
/// <param name="interfaceId">接口ID</param>
/// <returns></returns>
[HttpGet("InterfaceReturnConfig/GetList")]
public async Task<List<InterfaceReturnConfigVO>> GetList([Required] int interfaceId)
{
return await _interfaceReturnConfigRepository.GetListAsync(interfaceId);
}
/// <summary>
/// 更新或新增
/// </summary>
/// <param name="input">入参</param>
/// <returns></returns>
[HttpPost("InterfaceReturnConfig/Save")]
public async Task<bool> SaveAsync(InterfaceReturnConfigInput input)
{
if (!await _interfaceRepository.IsAnyAsync(x => x.Id == input.InterfaceId))
{
throw new BusinessException(message: "接口不存在");
}
// 开启事务
using var ts = TransacationHelper.GetReadCommitted();
foreach (var item in input.Items)
{
var entity =
ObjectMapper
.Map<InterfaceReturnConfigInput.InterfaceReturnConfigInputItem, InterfaceReturnConfigEntity>(item);
entity.InterfaceId = input.InterfaceId;
entity.Value ??= "";
switch (item.OptionType)
{
case OptionType.无:
break;
case OptionType.新增:
await _interfaceReturnConfigRepository.InsertOrUpdateAsync(entity, default);
break;
case OptionType.删除:
await _interfaceReturnConfigRepository.DeleteConfigByIdAsync(entity.Id);
break;
case OptionType.修改:
await _interfaceReturnConfigRepository.UpdateAsync(entity, ignoreAllNullColumns:true);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
ts.Complete();
return true;
}
}

287
src/InterfaceForward.Api/Controllers/Interface/ServiceProviderInterfaceService.cs Normal file
View File

@ -0,0 +1,287 @@
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using Newtonsoft.Json;
using SJZY.Expand.ABP.Common.Enums;
using SJZY.InterfaceRelay.Application.Dtos.Interface;
using SJZY.InterfaceRelay.Application.Services.Parameter;
using SJZY.InterfaceRelay.Repository.Interface.Entitys;
using SJZY.InterfaceRelay.Repository.Interface.Services;
using SJZY.InterfaceRelay.Repository.Interface.ValueObjects;
using SJZY.InterfaceRelay.Repository.ServiceProvider.Entitys;
namespace SJZY.InterfaceRelay.Application.Services.Interface;
/// <summary>
/// 服务商接口
/// </summary>
[ApiExplorerSettings(GroupName = "接口服务")]
public class ServiceProviderInterfaceService : ApplicationService
{
private ParameterService ParameterService => LazyServiceProvider.LazyGetRequiredService<ParameterService>();
private FormParameterService FormParameterService =>
LazyServiceProvider.LazyGetRequiredService<FormParameterService>();
private IInterfaceRepository InterfaceRepository =>
LazyServiceProvider.LazyGetRequiredService<IInterfaceRepository>();
private IBasicRepository<ServiceProviderEntity> ServiceProviderRepository =>
LazyServiceProvider.LazyGetRequiredService<IBasicRepository<ServiceProviderEntity>>();
private IBasicRepository<InterfaceMapEntity> InterfaceMapRepository =>
LazyServiceProvider.LazyGetRequiredService<IBasicRepository<InterfaceMapEntity>>();
/// <summary>
/// 服务商接口分页列表
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("Interface/ServiceProviderInterfacePaginatedList")]
public async Task<UnifyPageResultDto<ServiceProviderInterfacePaginatedOutputValueObject>>
ServiceProviderInterfacePaginatedListAsync(ServiceProviderInterfacePaginatedInputObjectValue input)
{
return await InterfaceRepository.GetServiceProviderInterfacePaginatedListAsync(input);
}
/// <summary>
/// 获取服务商接口下拉列表
/// </summary>
/// <param name="serviceProviderId">服务商id</param>
/// <returns></returns>
[HttpGet("Interface/GetServiceProviderInterfaceDropdownList")]
public async Task<List<ServiceProviderInterfaceDropdownListItem>> GetServiceProviderInterfaceDropdownListAsync(
[Required] int serviceProviderId)
{
var res = await InterfaceRepository.GetListAsync(x => x.ServiceProviderId == serviceProviderId,
x => new { x.Id, x.Code, x.Name });
return res.Select(x => new ServiceProviderInterfaceDropdownListItem
{
Id = x.Id,
Name = x.Name,
Code = x.Code
}).ToList();
}
/// <summary>
/// 获取服务商接口明细
/// </summary>
/// <param name="id">服务商接口id</param>
/// <returns></returns>
[HttpGet("Interface/GetServiceProviderInterfaceById")]
public async Task<ServiceProviderInterfaceOutput> GetServiceProviderInterfaceByIdAsync([Required] int id)
{
// 接口基本信息
var interfaceEntity = await InterfaceRepository.GetFirstAsync(x => x.Id == id && !x.IsUpStream);
if (interfaceEntity == null)
{
throw new BusinessException(message: "服务商接口不存在");
}
var res = ObjectMapper.Map<InterfaceEntity, ServiceProviderInterfaceOutput>(interfaceEntity);
// 构造参数
var paras = await InterfaceRepository.GetParameterListByIdAsync(id);
// 入参树形列表
res.InParameterList = paras.Where(x => x.IsInPara).ToList();
// 出参树形列表
res.OutParameterList = paras.Where(x => !x.IsInPara).ToList();
// 表单列表
res.FormParameterList = await FormParameterService.GetParameterListAsync(id);
return res;
}
/// <summary>
/// 保存服务商接口
/// </summary>
/// <remarks>
/// 用OptionType来区分操作目的，1：新增，2：删除，3：修改
///<para>tips：新增时，参数id由调用者伪造，以表现层级关系，不能小于1，你必须真实的表达id和pid的关系</para>
/// </remarks>
/// <param name="input"></param>
/// <returns></returns>
/// <exception cref="BusinessException"></exception>
[HttpPost("Interface/SaveServiceProviderInterface")]
public async Task<IdBaseDto> SaveServiceProviderInterfaceAsync(ServiceProviderInterfaceInput input)
{
var res = new IdBaseDto();
switch (input.OptionType)
{
case OptionType.新增:
res.Id = await CreateServiceProviderInterfaceAsync(input);
break;
case OptionType.修改:
res.Id = await UpdateServiceProviderInterfaceAsync(input);
break;
case OptionType.删除:
await BatchDeleteServiceProviderInterfaceByIdsAsync(new List<int> { input.Id ?? 0 });
break;
default:
res.Id = res.Id;
break;
}
return res;
}
/// <summary>
/// 批量删除服务商接口
/// </summary>
/// <param name="ids">服务商接口id集合</param>
/// <returns></returns>
[HttpPost("Interface/BatchDeleteServiceProviderInterfaceByIds")]
public async Task<bool> BatchDeleteServiceProviderInterfaceByIdsAsync([FromBody] List<int> ids)
{
using var tran = TransacationHelper.GetReadCommitted();
// 删除接口
await InterfaceRepository.SoftDeleteAsync(x => !x.IsUpStream && ids.Contains(x.Id));
// 删除接口映射
var mapIds = await InterfaceMapRepository.GetListAsync(x => ids.Contains(x.DownStreamId), x => x.Id);
if (mapIds.Count > 0)
{
await InterfaceMapRepository.SoftDeleteAsync(x => mapIds.Contains(x.Id));
}
tran.Complete();
return true;
}
internal async Task<int> CreateServiceProviderInterfaceAsync(ServiceProviderInterfaceInput input)
{
// 校验参数合法性
ParameterService.ValidateParameter(
JsonConvert.DeserializeObject<List<ParameterInput>>(
JsonConvert.SerializeObject(input.InParameterList)));
ParameterService.ValidateParameter(
JsonConvert.DeserializeObject<List<ParameterInput>>(
JsonConvert.SerializeObject(input.OutParameterList)));
/*
* 1.校验业务逻辑
* 接口名唯一性，接口简码唯一性，请求地址唯一性
* 2.清洗数据结构
* 参数合并，参数合法性，参数扁平化bfs
* 3.数据持久化
* 由于业务的观测粒度是保存行为（即取消不做任何数据保存），因此保持行为可以直接覆盖上次行为，注意事务
*/
#region 校验业务逻辑
if (await InterfaceRepository.IsAnyAsync(x =>
!x.IsUpStream && x.Name.Equals(input.Name) && x.ServiceProviderId == input.ServiceProviderId))
{
throw new BusinessException(message: $"接口名:{input.Name} 已存在");
}
#endregion
var interfaceEntity = ObjectMapper.Map<ServiceProviderInterfaceInput, InterfaceEntity>(input);
interfaceEntity.IsUpStream = false;
// 开启事务
using var ts = TransacationHelper.GetReadCommitted();
// step1、生成接口编码
interfaceEntity.Code = await GenerateServiceProviderInterfaceCode(input.ServiceProviderId);
// step2、持久化接口
var interfaceId = await InterfaceRepository.InsertReturnIdentityAsync(interfaceEntity);
// 接口代码生成时并发兜底方案
if (await InterfaceRepository.CountAsync(x => x.Code.Equals(interfaceEntity.Code)) > 1)
{
throw new BusinessException(message: "接口代码生成异常，请稍后重试");
}
// step3、持久化参数
await ParameterService.CreateParametersAsync(input.InParameterList, interfaceId, true);
await ParameterService.CreateParametersAsync(input.OutParameterList, interfaceId, false);
// step4、持久化表单参数
if (input.FormParameterList.Count > 0)
{
await FormParameterService.CreateParametersAsync(input.FormParameterList, interfaceId);
}
// 提交事务
ts.Complete();
return interfaceId;
}
private async Task<string> GenerateServiceProviderInterfaceCode(int serviceProviderId)
{
// 系统生成，由服务商代码+3位数字组成（0-999按顺序生成）
// tips：唯一性
var entity = await ServiceProviderRepository.GetFirstAsync(x => x.Id == serviceProviderId);
if (entity == null) throw new BusinessException(message: "服务商不存在");
string res = entity.Code;
// tips：要考虑并发
var code = await InterfaceRepository.GetCurrentCodeBySpId(serviceProviderId);
int count = 0;
if (!string.IsNullOrEmpty(code)) count = int.Parse(code.Substring(code.Length - 3, 3));
res += (count + 1).ToString().PadLeft(3, '0');
return res;
}
private async Task<int> UpdateServiceProviderInterfaceAsync(ServiceProviderInterfaceInput input)
{
#region 校验业务逻辑
if (!await InterfaceRepository.IsAnyAsync(x => x.Id == input.Id))
{
throw new BusinessException(message: "服务商接口不存在");
}
if (await InterfaceRepository.IsAnyAsync(x =>
x.Name.Equals(input.Name) && x.Id != input.Id && !x.IsUpStream &&
x.ServiceProviderId == input.ServiceProviderId))
{
throw new BusinessException(message: $"接口名:{input.Name} 已存在");
}
#endregion
Debug.Assert(input.Id != null, $"{input.Id} 不能为空");
var interfaceEntity = ObjectMapper.Map<ServiceProviderInterfaceInput, InterfaceEntity>(input);
// 开启事务
using var ts = TransacationHelper.GetReadCommitted();
// step1、更新接口
await InterfaceRepository.UpdateAsync(interfaceEntity, x => new
{
x.Code,
x.IsUpStream,
x.ServiceProviderId,
x.CreateTime,
x.CreateUserId,
x.IsDeleted
});
// step2、维护参数（增删改）
await ParameterService.MaintainParametersAsync(input.InParameterList, (int)input.Id, true);
await ParameterService.MaintainParametersAsync(input.OutParameterList, (int)input.Id, false);
// step3、更新表单参数
await FormParameterService.MaintainParametersAsync(input.FormParameterList, interfaceEntity.Id);
// 提交事务
ts.Complete();
return (int)input.Id;
}
}

279
src/InterfaceForward.Api/Controllers/Interface/SystemInterfaceService.cs Normal file
View File

@ -0,0 +1,279 @@
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using Newtonsoft.Json;
using SJZY.Expand.ABP.Common.Enums;
using SJZY.Expand.ABP.Core;
using SJZY.Expand.ABP.Core.PublicMethords;
using SJZY.InterfaceRelay.Application.Dtos.Interface;
using SJZY.InterfaceRelay.Application.Services.Parameter;
using SJZY.InterfaceRelay.Repository.Interface.Entitys;
using SJZY.InterfaceRelay.Repository.Interface.Services;
using SJZY.InterfaceRelay.Repository.Interface.ValueObjects;
namespace SJZY.InterfaceRelay.Application.Services.Interface;
/// <summary>
/// 系统接口
/// </summary>
[ApiExplorerSettings(GroupName = "接口服务")]
public class SystemInterfaceService : ApplicationService
{
#region ctor
private readonly ParameterService _parameterService;
private readonly IInterfaceRepository _interfaceRepository;
private readonly IBasicRepository<InterfaceMapEntity> _interfaceMapRepository;
/// <summary>
/// 系统接口下拉列表缓存key
/// </summary>
private const string SystemInterfaceDropdownCacheKey = "SystemInterfaceDropdownCacheKey";
/// <inheritdoc />
public SystemInterfaceService(
IInterfaceRepository interfaceRepository
, ParameterService parameterService
, IBasicRepository<InterfaceMapEntity> interfaceMapRepository)
{
_parameterService = parameterService;
_interfaceMapRepository = interfaceMapRepository;
_interfaceRepository = interfaceRepository;
}
#endregion
/// <summary>
/// 系统接口分页列表
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("Interface/SystemInterfacePaginatedList")]
public async Task<UnifyPageResultDto<SystemInterfacePaginatedOutputValueObject>>
SystemInterfacePaginatedListAsync(SystemInterfacePaginatedInputObjectValue input)
{
return await _interfaceRepository.GetSystemInterfacePaginatedListAsync(input);
}
/// <summary>
/// 获取系统接口明细
/// </summary>
/// <param name="id">系统接口id</param>
/// <returns></returns>
[HttpGet("Interface/GetSystemInterfaceById")]
public async Task<SystemInterfaceOutput> GetSystemInterfaceByIdAsync([Required] int id)
{
// 接口基本信息
var interfaceEntity = await _interfaceRepository.GetFirstAsync(x => x.Id == id && x.IsUpStream);
if (interfaceEntity == null)
{
throw new BusinessException(message: "系统接口不存在");
}
var res = ObjectMapper.Map<InterfaceEntity, SystemInterfaceOutput>(interfaceEntity);
// 构造参数
var paras = await _interfaceRepository.GetParameterListByIdAsync(id);
// 入参树形列表
res.InParameterList = paras.Where(x => x.IsInPara).ToList();
// 出参树形列表
res.OutParameterList = paras.Where(x => !x.IsInPara).ToList();
return res;
}
/// <summary>
/// 获取系统接口下拉列表
/// </summary>
/// <returns></returns>
[HttpGet("Interface/GetSystemInterfaceDropdownList")]
public async Task<List<SystemInterfaceDropdownValueObject>> GetSystemInterfaceDropdownListAsync()
{
var res =
(await RedisHelper.Client.GetAsync<string>(SystemInterfaceDropdownCacheKey))
.ToObject<List<SystemInterfaceDropdownValueObject>>();
if (res == null)
{
res = await _interfaceRepository.GetSystemInterfaceDropdownListAsync();
await RedisHelper.Client.SetAsync(SystemInterfaceDropdownCacheKey, res.ToJson(), 2 * 60 * 60);
}
return res;
}
/// <summary>
/// 保存系统接口
/// </summary>
/// <remarks>
/// 用OptionType来区分操作目的，1：新增，2：删除，3：修改
///<para>注意！新增时，参数id由调用者伪造，以表现层级关系，不能小于1，你必须真实的表达id和pid的关系</para>
/// </remarks>
/// <param name="input"></param>
/// <returns></returns>
/// <exception cref="BusinessException"></exception>
[HttpPost("Interface/SaveSystemInterface")]
public async Task<IdBaseDto> SaveSystemInterfaceAsync(SystemInterfaceInput input)
{
var res = new IdBaseDto();
switch (input.OptionType)
{
case OptionType.新增:
res.Id = await CreateSystemInterfaceAsync(input);
break;
case OptionType.修改:
res.Id = await UpdateSystemInterfaceAsync(input);
break;
case OptionType.删除:
await BatchDeleteSystemInterfaceByIdsAsync(new List<int> { input.Id ?? 0 });
break;
default:
res.Id = res.Id;
break;
}
// 干掉缓存
await RedisHelper.Client.DelAsync(SystemInterfaceDropdownCacheKey);
return res;
}
/// <summary>
/// 批量删除系统接口
/// </summary>
/// <param name="ids">系统接口id集合</param>
/// <returns></returns>
[HttpPost("Interface/BatchDeleteSystemInterfaceByIds")]
public async Task<bool> BatchDeleteSystemInterfaceByIdsAsync([FromBody] List<int> ids)
{
using var tran = TransacationHelper.GetReadCommitted();
// 删除接口
await _interfaceRepository.SoftDeleteAsync(x => x.IsUpStream && ids.Contains(x.Id));
// 删除接口映射
var mapIds = await _interfaceMapRepository.GetListAsync(x => ids.Contains(x.UpStreamId), x => x.Id);
if (mapIds.Count > 0)
{
await _interfaceMapRepository.SoftDeleteAsync(x => mapIds.Contains(x.Id));
}
// 删缓存
await RedisHelper.Client.DelAsync(SystemInterfaceDropdownCacheKey);
tran.Complete();
return true;
}
#region private
/// <summary>
/// 更新系统接口
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
private async Task<int> UpdateSystemInterfaceAsync(SystemInterfaceInput input)
{
#region 校验业务逻辑
var entity = await _interfaceRepository.GetFirstAsync(x => x.Id == input.Id && x.IsUpStream);
if (entity == null)
{
throw new BusinessException(message: "系统接口不存在");
}
if (await _interfaceRepository.IsAnyAsync(x =>
x.Id != input.Id && x.IsUpStream && x.Name.Equals(input.Name)))
{
throw new BusinessException(message: $"接口名:{input.Name} 已存在");
}
if (await _interfaceRepository.IsAnyAsync(
x => x.Id != input.Id && x.IsUpStream && x.Code.Equals(input.Code)))
{
throw new BusinessException(message: "接口code已存在");
}
#endregion
Debug.Assert(input.Id != null, $"{input.Id} 不能为空");
var interfaceEntity = ObjectMapper.Map<SystemInterfaceInput, InterfaceEntity>(input);
// 开启事务
using var ts = TransacationHelper.GetReadCommitted();
// step1、更新接口
await _interfaceRepository.UpdateAsync(interfaceEntity, x => new
{
x.IsUpStream,
x.ServiceProviderId,
x.CreateTime,
x.CreateUserId,
x.IsDeleted
});
// step2、维护参数（增删改）
await _parameterService.MaintainParametersAsync(input.InParameterList, (int)input.Id, true);
await _parameterService.MaintainParametersAsync(input.OutParameterList, (int)input.Id, false);
// 这里再做参数校验，回滚代价是不是有点大了。。
// 提交事务
ts.Complete();
return (int)input.Id;
}
private async Task<int> CreateSystemInterfaceAsync(SystemInterfaceInput input)
{
// 校验参数合法性
_parameterService.ValidateParameter(
JsonConvert.DeserializeObject<List<ParameterInput>>(
JsonConvert.SerializeObject(input.InParameterList)));
_parameterService.ValidateParameter(
JsonConvert.DeserializeObject<List<ParameterInput>>(
JsonConvert.SerializeObject(input.OutParameterList)));
/*
* 1.校验业务逻辑
* 接口名唯一性，接口简码唯一性，请求地址唯一性
* 2.清洗数据结构
* 参数合并，参数合法性，参数扁平化bfs
* 3.数据持久化
* 由于业务的观测粒度是保存行为（即取消不做任何数据保存），因此保持行为可以直接覆盖上次行为，注意事务
*/
#region 校验业务逻辑
if (await _interfaceRepository.IsAnyAsync(x => x.IsUpStream && x.Name.Equals(input.Name)))
{
throw new BusinessException(message: $"接口名:{input.Name} 已存在");
}
if (await _interfaceRepository.IsAnyAsync(x => x.IsUpStream && x.Code.Equals(input.Code)))
{
throw new BusinessException(message: "接口code已存在");
}
#endregion
var interfaceEntity = ObjectMapper.Map<SystemInterfaceInput, InterfaceEntity>(input);
interfaceEntity.IsUpStream = true;
// 开启事务
using var ts = TransacationHelper.GetReadCommitted();
// step1、持久化接口
var interfaceId = await _interfaceRepository.InsertReturnIdentityAsync(interfaceEntity);
// step2、持久化参数
await _parameterService.CreateParametersAsync(input.InParameterList, interfaceId, true);
await _parameterService.CreateParametersAsync(input.OutParameterList, interfaceId, false);
// 提交事务
ts.Complete();
return interfaceId;
}
#endregion
}

1
src/InterfaceForward.Api/InterfaceForwardApiModule.cs
View File

@ -1,5 +1,6 @@
using Fake.AspNetCore;
using Fake.Authorization;
using Fake.Helpers;
using Fake.Modularity;
using InterfaceForward.Api.Contract;
using InterfaceForward.Api.Filters;

3
src/InterfaceForward.Domain/InterfaceForwardDomainModule.cs
View File

@ -1,8 +1,9 @@
using System;
using Fake.Modularity;
namespace InterfaceForward.Domain
{
public class InterfaceForwardDomainModule
public class InterfaceForwardDomainModule : FakeModule
{
}
}