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) }); }