private async Task <IEnumerable <ValidationError> > ValidateForForbiddenCharsAsync
(string baseAddress, string addressExtension, string blockchainType)
{
var errors = new List <ValidationError>(1);
var(isAddressExtensionSupported,
prohibitedCharsBase,
prohibitedCharsExtension) = await IsAddressExtensionSupported(blockchainType);
var baseAddressContainsProhibitedChars = baseAddress.IndexOfAny(prohibitedCharsBase?.ToArray()) != -1;
if (baseAddressContainsProhibitedChars)
{
errors.Add(ValidationError.Create(ValidationErrorType.AddressIsNotValid,
$"Base address should not contain a separator symbol [{string.Join(',', prohibitedCharsBase)}]"));
}
if (!string.IsNullOrEmpty(addressExtension))
{
var addressExtensionContainsProhibitedChars =
addressExtension.IndexOfAny(prohibitedCharsExtension?.ToArray()) != -1;
if (addressExtensionContainsProhibitedChars)
{
errors.Add(ValidationError.Create(ValidationErrorType.AddressIsNotValid,
$"Extension address should not contain a separator [{string.Join(',', prohibitedCharsBase)}]"));
}
}
return(errors.Any() ? errors : null);
}
public Validator AddError(string name, string message)
{
ValidationError error = ValidationError.Create(name.EmptyStringIfNull(), message);
Errors.Add(error);
_LastError = error;
return(this);
}
private Validation <ValidationError, IEnumerable <string> > Validate(AddTitles param)
{
if (param.Titles.Any())
{
return(Success <ValidationError, IEnumerable <string> >(param.Titles));
}
var error = ValidationError.Create(nameof(AddTitles.Titles), new[] { "Titles collection is empty" });
return(Fail <ValidationError, IEnumerable <string> >(error));
}
protected override IEnumerable <ValidationError> Validation()
{
var errors = new List <ValidationError>();
if (string.IsNullOrWhiteSpace(Name))
{
errors.Add(ValidationError.Create(() => Name, "Name cannot be empty"));
}
return(errors);
}
private static List <ValidationError> Valid(Employee employee)
{
const int maxName = 100;
var validationErrors = new List <ValidationError>();
if (!MaxLengthValidation.IsValid(employee.Name, maxName))
{
validationErrors.Add(ValidationError.Create("Name", $"Name must contain a maximum of {maxName} characters"));
}
return(validationErrors);
}
private static List <ValidationError> Required(InflationAdjust inflationAdjust)
{
var validationErrors = new List <ValidationError>();
if (!RequiredValidation.IsValid(inflationAdjust.Percentage))
{
validationErrors.Add(ValidationError.Create("Percentage", "Percentage is required"));
}
if (!RequiredValidation.IsValid(inflationAdjust.AdjustmentDate))
{
validationErrors.Add(ValidationError.Create("AdjustmentDate", "AdjustmentDate is required"));
}
return(validationErrors);
}
private static List <ValidationError> Required(Employee employee)
{
var validationErrors = new List <ValidationError>();
if (!RequiredValidation.IsValid(employee.Name))
{
validationErrors.Add(ValidationError.Create("Name", "Name is required"));
}
if (!RequiredValidation.IsValid(employee.BirthDate))
{
validationErrors.Add(ValidationError.Create("BirthDate", "BirthDate is required"));
}
if (!RequiredValidation.IsValid(employee.MonthlySalary))
{
validationErrors.Add(ValidationError.Create("MonthlySalary", "MonthlySalary is required"));
}
return(validationErrors);
}
private static List <ValidationError> Required(SharedFund sharedFund)
{
var validationErrors = new List <ValidationError>();
if (!RequiredValidation.IsValid(sharedFund.EmployeeId))
{
validationErrors.Add(ValidationError.Create("EmployeeId", "EmployeeId is required"));
}
if (RequiredValidation.IsValid(sharedFund.Value))
{
validationErrors.Add(ValidationError.Create("Value", "Value will be created automatically"));
}
if (!RequiredValidation.IsValid(sharedFund.ContributionDate))
{
validationErrors.Add(ValidationError.Create("ContributionDate", "ContributionDate is required"));
}
return(validationErrors);
}
internal static Validation <ValidationError, NonEmptyString> IdListMustHaveElements(string animeId) =>
!string.IsNullOrEmpty(animeId)
? Success <ValidationError, NonEmptyString>(NonEmptyString.FromString(animeId))
: Fail <ValidationError, NonEmptyString>(ValidationError.Create("AnimeId", new[] { "AnimeId must have a value" }));
internal static Validation <ValidationError, Email> SubscriberMustBeValid(string subscriber) =>
Email.FromString(subscriber)
.ToValidation(ValidationError.Create("Subscriber", new[] { "Subscriber must be a valid email address" }));
/// <summary>
///
/// </summary>
/// <param name="cashoutModel"></param>
/// <returns>
/// ValidationError - client error
/// ArgumentValidationException - developer error
/// </returns>
public async Task <IReadOnlyCollection <ValidationError> > ValidateAsync(CashoutModel cashoutModel)
{
var errors = new List <ValidationError>(1);
if (cashoutModel == null)
{
return(FieldNotValidResult("cashoutModel can't be null"));
}
if (string.IsNullOrEmpty(cashoutModel.AssetId))
{
return(FieldNotValidResult("cashoutModel.AssetId can't be null or empty"));
}
Asset asset;
try
{
asset = await _assetsService.TryGetAssetAsync(cashoutModel.AssetId);
}
catch (Exception)
{
throw new ArgumentValidationException($"Asset with Id-{cashoutModel.AssetId} does not exists",
"assetId");
}
if (asset.IsDisabled)
{
errors.Add(ValidationError.Create(ValidationErrorType.None, $"Asset {asset.Id} is disabled"));
}
if (asset == null)
{
throw new ArgumentValidationException($"Asset with Id-{cashoutModel.AssetId} does not exists",
"assetId");
}
var isAddressValid = true;
IBlockchainApiClient blockchainClient = null;
if (asset.Id != LykkeConstants.SolarAssetId)
{
if (string.IsNullOrEmpty(asset.BlockchainIntegrationLayerId))
{
throw new ArgumentValidationException(
$"Given asset Id-{cashoutModel.AssetId} is not a part of Blockchain Integration Layer",
"assetId");
}
blockchainClient = _blockchainApiClientProvider.Get(asset.BlockchainIntegrationLayerId);
}
if (string.IsNullOrEmpty(cashoutModel.DestinationAddress) ||
!cashoutModel.DestinationAddress.IsValidPartitionOrRowKey() ||
asset.Id != LykkeConstants.SolarAssetId && blockchainClient != null &&
!await blockchainClient.IsAddressValidAsync(cashoutModel.DestinationAddress) ||
asset.Id == LykkeConstants.SolarAssetId &&
!SolarCoinValidation.ValidateAddress(cashoutModel.DestinationAddress)
)
{
isAddressValid = false;
errors.Add(ValidationError.Create(ValidationErrorType.AddressIsNotValid, "Address is not valid"));
}
if (isAddressValid)
{
if (asset.Id != LykkeConstants.SolarAssetId)
{
var isBlocked = await _blackListService.IsBlockedWithoutAddressValidationAsync
(
asset.BlockchainIntegrationLayerId,
cashoutModel.DestinationAddress
);
if (isBlocked)
{
errors.Add(ValidationError.Create(ValidationErrorType.BlackListedAddress, "Address is in the black list"));
}
}
if (cashoutModel.Volume.HasValue && Math.Abs(cashoutModel.Volume.Value) < (decimal)asset.CashoutMinimalAmount)
{
var minimalAmount = asset.CashoutMinimalAmount.GetFixedAsString(asset.Accuracy).TrimEnd('0');
errors.Add(ValidationError.Create(ValidationErrorType.LessThanMinCashout,
$"Please enter an amount greater than {minimalAmount}"));
}
if (asset.Id != LykkeConstants.SolarAssetId)
{
var blockchainSettings = _blockchainSettingsProvider.Get(asset.BlockchainIntegrationLayerId);
if (cashoutModel.DestinationAddress == blockchainSettings.HotWalletAddress)
{
errors.Add(ValidationError.Create(ValidationErrorType.HotwalletTargetProhibited,
"Hot wallet as destitnation address prohibited"));
}
var isPublicExtensionRequired =
_blockchainWalletsCacheService.IsPublicExtensionRequired(asset.BlockchainIntegrationLayerId);
if (isPublicExtensionRequired)
{
var hotWalletParseResult = await _blockchainWalletsClient.ParseAddressAsync(
asset.BlockchainIntegrationLayerId,
blockchainSettings.HotWalletAddress);
var destAddressParseResult = await _blockchainWalletsClient.ParseAddressAsync(
asset.BlockchainIntegrationLayerId,
cashoutModel.DestinationAddress);
if (hotWalletParseResult.BaseAddress == destAddressParseResult.BaseAddress)
{
var existedClientIdAsDestination = await _blockchainWalletsClient.TryGetClientIdAsync(
asset.BlockchainIntegrationLayerId,
cashoutModel.DestinationAddress);
if (existedClientIdAsDestination == null)
{
errors.Add(ValidationError.Create(ValidationErrorType.DepositAddressNotFound,
$"Deposit address {cashoutModel.DestinationAddress} not found"));
}
}
var forbiddenCharacterErrors = await ValidateForForbiddenCharsAsync(
destAddressParseResult.BaseAddress,
destAddressParseResult.AddressExtension,
asset.BlockchainIntegrationLayerId);
if (forbiddenCharacterErrors != null)
{
errors.AddRange(forbiddenCharacterErrors);
}
if (!string.IsNullOrEmpty(destAddressParseResult.BaseAddress))
{
if (!cashoutModel.DestinationAddress.Contains(destAddressParseResult.BaseAddress))
{
errors.Add(ValidationError.Create(ValidationErrorType.FieldIsNotValid,
"Base Address should be part of destination address"));
}
// full address is already checked by integration,
// we don't need to validate it again,
// just ensure that base address is not black-listed
var isBlockedBase = await _blackListService.IsBlockedWithoutAddressValidationAsync(
asset.BlockchainIntegrationLayerId,
destAddressParseResult.BaseAddress);
if (isBlockedBase)
{
errors.Add(ValidationError.Create(ValidationErrorType.BlackListedAddress,
"Base Address is in the black list"));
}
}
}
}
if (cashoutModel.ClientId.HasValue)
{
var destinationClientId = await _blockchainWalletsClient.TryGetClientIdAsync
(
asset.BlockchainIntegrationLayerId,
cashoutModel.DestinationAddress
);
if (destinationClientId.HasValue && destinationClientId == cashoutModel.ClientId.Value)
{
var error = ValidationError.Create
(
ValidationErrorType.CashoutToSelfAddress,
"Withdrawals to the deposit wallet owned by the customer himself prohibited"
);
errors.Add(error);
}
}
}
return(errors);
}
private static IReadOnlyCollection <ValidationError> FieldNotValidResult(string message)
{
return(new[] { ValidationError.Create(ValidationErrorType.FieldIsNotValid, message) });
}