public async void Validate_if_transfer_quantity_perWeek_less_than_MaxTransactionPerWeek()
{
// Arrange
_paymentTestHelper.MakeDeposit(_playerId, 10);
_previousTransferDaysShift = -8;
_transferFundTestHelper.AddTransfer(_brand, _playerId, _walletTemplateId, _repository, _previousTransferDaysShift);
var transferSettings = new SaveTransferSettingsCommand {
MaxTransactionPerWeek = 1, Wallet = _walletTemplateId.ToString()
};
_transferFundTestHelper.CreateTransferSettings(_brand, transferSettings, _walletTemplateId);
var transferFundRequest = new TransferFundRequest
{
Amount = 1,
PlayerId = _playerId,
TransferType = TransferFundType.FundIn,
WalletId = _walletTemplateId.ToString()
};
//Act
(await _validationService.Validate(transferFundRequest)).IsValid
.Should().BeTrue();
}
public async void Not_validate_if_transfer_quantity_perMonth_greater_than_MaxTransactionPerMonth()
{
// Arrange
_paymentTestHelper.MakeDeposit(_playerId, 10);
_previousTransferDaysShift = -29;
_transferFundTestHelper.AddTransfer(_brand, _playerId, _walletTemplateId, _repository, _previousTransferDaysShift);
var transferSettings = new SaveTransferSettingsCommand {
MaxTransactionPerMonth = 1, Wallet = _walletTemplateId.ToString()
};
_transferFundTestHelper.CreateTransferSettings(_brand, transferSettings, _walletTemplateId);
var transferFundRequest = new TransferFundRequest
{
Amount = 1,
PlayerId = _playerId,
TransferType = TransferFundType.FundIn,
WalletId = _walletTemplateId.ToString()
};
//Act
(await _validationService.Validate(transferFundRequest)).ErrorMessage
.Should().Contain("transfers per day exceed monthly limit");
}
public void Should_throw_exception_when_required_parameters_missed_in_request()
{
// Arrange
var transferFundRequest = new TransferFundRequest();
//Act
Assert.Throws <ArgumentNullException>(async() => await _validationService.Validate(transferFundRequest));
}
public async void Not_validate_if_zero_or_negative_Amount_in_request()
{
// Arrange
var transferFundRequest = new TransferFundRequest
{
PlayerId = _playerId,
TransferType = TransferFundType.FundIn,
WalletId = _walletTemplateId.ToString()
};
//Act
(await _validationService.Validate(transferFundRequest)).ErrorMessage
.Should().BeEquivalentTo("app:payment.amountMustBeGreaterThanZero");
}
public async void Not_validate_if_Wallet_not_exist()
{
// Arrange
var transferFundRequest = new TransferFundRequest
{
PlayerId = _playerId,
TransferType = TransferFundType.FundIn,
WalletId = new Guid("00000000-0000-0000-0000-000000000000").ToString()
};
//Act
(await _validationService.Validate(transferFundRequest)).ErrorMessage
.Should().BeEquivalentTo("Wallet with id 00000000-0000-0000-0000-000000000000 not found.");
}
public async void Not_validate_if_Amount_greater_than_MainBalance()
{
BonusBalance.Main = 0;
// Arrange
var transferFundRequest = new TransferFundRequest
{
Amount = 1,
PlayerId = _playerId,
TransferType = TransferFundType.FundIn,
WalletId = _walletTemplateId.ToString()
};
//Act
(await _validationService.Validate(transferFundRequest)).ErrorMessage
.Should().BeEquivalentTo("app:payment.amountExceedsBalance");
}
public async void Validate_if_Amount_less_or_equal_than_MainBalance()
{
// Arrange
_paymentTestHelper.MakeDeposit(_playerId, 1);
BonusBalance.Main = 1;
var transferFundRequest = new TransferFundRequest
{
Amount = 1,
PlayerId = _playerId,
TransferType = TransferFundType.FundIn,
WalletId = _walletTemplateId.ToString()
};
//Act
(await _validationService.Validate(transferFundRequest)).IsValid
.Should().BeTrue();
}
public async Task <FundResponse> FundIn(FundRequest request)
{
ValidateAccountFrozenStatus();
var transferFundRequest = new TransferFundRequest
{
PlayerId = PlayerId,
Amount = request.Amount,
TransferType = Mapper.Map <Core.Common.Data.TransferFundType>(request.TransferFundType),
WalletId = request.WalletId.ToString(),
BonusCode = request.BonusCode
};
return(new FundResponse
{
TransferId = await _transferFundCommands.AddFund(transferFundRequest)
});
}
public async void Not_validate_if_Amount_greater_than_MaxAmountPerDay()
{
// Arrange
_paymentTestHelper.MakeDeposit(_playerId, 10);
var transferSettings = new SaveTransferSettingsCommand {
MaxAmountPerDay = 1, Wallet = _walletTemplateId.ToString()
};
_transferFundTestHelper.CreateTransferSettings(_brand, transferSettings, _walletTemplateId);
var transferFundRequest = new TransferFundRequest
{
Amount = 2,
PlayerId = _playerId,
TransferType = TransferFundType.FundIn,
WalletId = _walletTemplateId.ToString()
};
//Act
(await _validationService.Validate(transferFundRequest)).ErrorMessage
.Should().Contain("amounts exceed the daily limit");
}
public async void Not_validate_if_Amount_less_than_MinAmountPerTransaction()
{
// Arrange
_paymentTestHelper.MakeDeposit(_playerId, 10);
var transferSettings = new SaveTransferSettingsCommand {
MinAmountPerTransaction = 2, Wallet = _walletTemplateId.ToString()
};
_transferFundTestHelper.CreateTransferSettings(_brand, transferSettings, _walletTemplateId);
var transferFundRequest = new TransferFundRequest
{
Amount = 1,
PlayerId = _playerId,
TransferType = TransferFundType.FundIn,
WalletId = _walletTemplateId.ToString()
};
//Act
(await _validationService.Validate(transferFundRequest)).ErrorMessage
.Should().Contain("amount is below the allowed value");
}
public async Task <TransferFundValidationDTO> Validate(TransferFundRequest request)
{
var walletTemplate = _brandQueries.GetWalletTemplate(new Guid(request.WalletId));
if (walletTemplate == null)
{
return new TransferFundValidationDTO {
ErrorMessage = string.Format("Wallet with id {0} not found.", request.WalletId)
}
}
;
var timezoneId = walletTemplate.Brand.TimezoneId;
var transferSetting = _paymentQueries.GetTransferSetting(
request.WalletId,
request.TransferType,
SettingsActive);
var allRequestsFromPlayer =
_paymentRepository
.TransferFunds
.Where(x =>
x.WalletId == request.WalletId &&
x.CreatedBy == request.PlayerId.ToString() &&
x.TransferType == request.TransferType &&
x.Status == TransferFundStatus.Approved)
.ToList();
if (request.Amount > MaxServerDecimal)
{
return new TransferFundValidationDTO {
ErrorMessage = "Amount must not contain more than {18} characters."
}
}
;
if (request.Amount <= 0)
{
return new TransferFundValidationDTO {
ErrorMessage = "app:payment.amountMustBeGreaterThanZero"
}
}
;
var walletTemplateId = request.TransferType == TransferFundType.FundIn ? null : (Guid?)new Guid(request.WalletId);
try
{
var playerBalance = await _walletQueries.GetPlayerBalance(request.PlayerId, walletTemplateId);
if (request.Amount > playerBalance.Main)
{
return new TransferFundValidationDTO {
ErrorMessage = "app:payment.amountExceedsBalance"
}
}
;
}
catch (RegoException)
{
return(new TransferFundValidationDTO {
ErrorMessage = string.Format("Wallet not found for Player with id {0}.", request.PlayerId)
});
}
if (transferSetting != null)
{
//Verify amount per transaction
if ((transferSetting.MaxAmountPerTransaction > 0) && (request.Amount > transferSetting.MaxAmountPerTransaction))
{
return new TransferFundValidationDTO {
ErrorMessage = string.Format("The entered amount exceeds the allowed value. Maximum value is {0}.", transferSetting.MaxAmountPerTransaction)
}
}
;
if ((transferSetting.MinAmountPerTransaction > 0) && request.Amount < transferSetting.MinAmountPerTransaction)
{
return new TransferFundValidationDTO {
ErrorMessage = string.Format("The entered amount is below the allowed value. Minimum value is {0}.", transferSetting.MinAmountPerTransaction)
}
}
;
//Verify amount per day
decimal amount = 0;
allRequestsFromPlayer
.Where(x => (DateTimeOffset.Now.ToBrandOffset(timezoneId) - x.Created) <= TimeSpan.FromDays(1))
.ToList()
.ForEach(x => amount += x.Amount);
if (amount + request.Amount > transferSetting.MaxAmountPerDay && transferSetting.MaxAmountPerDay != 0)
{
return new TransferFundValidationDTO {
ErrorMessage = string.Format("Total entered amounts exceed the daily limit. Maximum value is {0}.", transferSetting.MaxAmountPerDay)
}
}
;
//Verify transactions per day
var transactionsPerDayCount = allRequestsFromPlayer
.Count(x => (DateTimeOffset.Now.ToBrandOffset(timezoneId) - x.Created)
<= TimeSpan.FromDays(1));
if (transactionsPerDayCount + 1 > transferSetting.MaxTransactionPerDay && transferSetting.MaxTransactionPerDay != 0)
{
return new TransferFundValidationDTO {
ErrorMessage = string.Format("Total number of transfers per day exceed daily limit. Maximum value is {0}.", transferSetting.MaxTransactionPerDay)
}
}
;
//Verify transactions per week
var transactionsPerWeekCount = allRequestsFromPlayer
.Count(x => (DateTimeOffset.Now.ToBrandOffset(timezoneId) - x.Created)
<= TimeSpan.FromDays(DaysInWeek));
if (transactionsPerWeekCount + 1 > transferSetting.MaxTransactionPerWeek && transferSetting.MaxTransactionPerWeek != 0)
{
return new TransferFundValidationDTO {
ErrorMessage = string.Format("Total number of transfers per day exceed weekly limit. Maximum value is {0}.", transferSetting.MaxTransactionPerWeek)
}
}
;
//Verify transactions per month
var transactionsPerMonthCount = allRequestsFromPlayer
.Count(x => (DateTimeOffset.Now.ToBrandOffset(timezoneId) - x.Created)
<= TimeSpan.FromDays(DaysInMonth));
if (transactionsPerMonthCount + 1 > transferSetting.MaxTransactionPerMonth && transferSetting.MaxTransactionPerMonth != 0)
{
return new TransferFundValidationDTO {
ErrorMessage = string.Format("Total number of transfers per day exceed monthly limit. Maximum value is {0}.", transferSetting.MaxTransactionPerMonth)
}
}
;
}
return(new TransferFundValidationDTO {
IsValid = true
});
}
}
}
public async Task <string> AddFund(TransferFundRequest request)
{
var validationResult = await _validationService.Validate(request);
var transferFund = new TransferFund();
var transactionNumber = GenerateTransactionNumber();
using (var scope = CustomTransactionScope.GetTransactionScope())
{
var requestWalletId = new Guid(request.WalletId);
var requestWalletTemplate = _brandQueries.GetWalletTemplate(requestWalletId);
var mainWalletTemplate = _brandQueries.GetWalletTemplates(requestWalletTemplate.Brand.Id).Single(wt => wt.IsMain);
var timezoneId = requestWalletTemplate.Brand.TimezoneId;
_repository.TransferFunds.Add(transferFund);
transferFund.Id = Guid.NewGuid();
transferFund.TransferType = request.TransferType;
transferFund.TransactionNumber = transactionNumber;
transferFund.Amount = request.Amount;
transferFund.WalletId = request.WalletId;
transferFund.CreatedBy = request.PlayerId.ToString();
transferFund.Created = DateTimeOffset.Now.ToBrandOffset(timezoneId);
transferFund.Remarks = transferFund.Remarks = !validationResult.IsValid ? validationResult.ErrorMessage : string.Empty;
transferFund.Status = validationResult.IsValid ? TransferFundStatus.Approved : TransferFundStatus.Rejected;
transferFund.BonusCode = request.BonusCode;
if (validationResult.IsValid)
{
var sourceWalletId = request.TransferType == TransferFundType.FundIn
? mainWalletTemplate.Id
: requestWalletId;
var destinationWalletId = request.TransferType == TransferFundType.FundIn
? requestWalletId
: mainWalletTemplate.Id;
//_walletCommands.TransferFunds(request.PlayerId, sourceWalletId, destinationWalletId, request.Amount, transactionNumber);
if (request.BonusId.HasValue || string.IsNullOrWhiteSpace(request.BonusCode) == false && transferFund.Status == TransferFundStatus.Approved)
{
await _bonusApiProxy.ApplyForBonusAsync(new FundInBonusApplication
{
PlayerId = request.PlayerId,
BonusId = request.BonusId,
BonusCode = request.BonusCode,
Amount = request.Amount,
DestinationWalletTemplateId = destinationWalletId
});
}
transferFund.DestinationWalletId = destinationWalletId;
}
_eventBus.Publish(new TransferFundCreated
{
PlayerId = new Guid(transferFund.CreatedBy),
TransactionNumber = transferFund.TransactionNumber,
Amount = transferFund.Amount,
Remarks = transferFund.Remarks,
BonusCode = transferFund.BonusCode,
DestinationWalletStructureId = transferFund.DestinationWalletId,
Type = transferFund.TransferType,
Status = transferFund.Status,
Description = string.Format("Transaction #{0}", transferFund.TransactionNumber)
});
_repository.SaveChanges();
scope.Complete();
}
if (!validationResult.IsValid)
{
throw new ArgumentException(validationResult.ErrorMessage);
}
return(transactionNumber);
}
