public OfflineDeposit(
OfflineDepositRequest request,
Data.BankAccount bankAccount,
AFT.RegoV2.Core.Payment.Data.Player player,
string createdBy)
{
if (request.Amount <= 0)
{
throw new ArgumentException("Amount must be greater than 0.");
}
var random = new Random();
var transactionNumber = "OD" + random.Next(10000000, 99999999);
Data = new Data.OfflineDeposit
{
Id = Guid.NewGuid(),
BrandId = player.BrandId,
TransactionNumber = transactionNumber,
Amount = request.Amount,
PlayerId = player.Id,
Player = player,
Created = DateTimeOffset.Now.ToBrandOffset(player.Brand.TimezoneId),
BankAccountId = bankAccount.Id,
CurrencyCode = bankAccount.CurrencyCode,
Status = OfflineDepositStatus.New,
PaymentMethod = PaymentMethod.OfflineBank,
DepositType = DepositType.Offline,
BankAccount = bankAccount,
DepositWagering = request.Amount,
PlayerRemark = request.PlayerRemark,
CreatedBy = createdBy
};
}
public async Task <OfflineDepositResponse> OfflineDeposit(OfflineDepositRequest request)
{
return(await _memberApiProxy.OfflineDepositAsync(request));
}
//[Permission(Permissions.Create, Module = Modules.OfflineDepositRequests)]
public async Task <OfflineDeposit> Submit(OfflineDepositRequest request)
{
var validationResult = _offlineDepositQueries.GetValidationResult(request);
if (validationResult.IsValid == false)
{
throw new RegoException(string.Join("/n", validationResult.Errors.Select(failure => failure.ErrorMessage)));
}
var player = _repository.Players
.Include(x => x.Brand)
.Single(p => p.Id == request.PlayerId);
var bankAccount = _repository.BankAccounts
.Include(x => x.Bank)
.Single(x => x.Id == request.BankAccountId);
_validator.Validate(request.PlayerId, bankAccount.CurrencyCode, request.Amount);
_identityValidator.Validate(request.PlayerId, TransactionType.Deposit);
var deposit = new Entities.OfflineDeposit(request, bankAccount, player, _actorInfoProvider.Actor.UserName);
using (var scope = CustomTransactionScope.GetTransactionScopeAsync())
{
var depositEvent = deposit.Submit();
_repository.OfflineDeposits.Add(deposit.Data);
if (request.BonusId.HasValue || string.IsNullOrWhiteSpace(request.BonusCode) == false)
{
var bonusRedemptionId = await _bonusApiProxy.ApplyForBonusAsync(new DepositBonusApplication
{
PlayerId = player.Id,
BonusId = request.BonusId,
BonusCode = request.BonusCode,
Amount = request.Amount,
DepositId = deposit.Data.Id
});
deposit.SetBonusRedemption(bonusRedemptionId);
}
_repository.SaveChanges();
_eventBus.Publish(depositEvent);
scope.Complete();
}
var messageModel = new OfflineDepositRequestedModel
{
BankName = bankAccount.Bank.BankName,
BankAccountName = bankAccount.AccountName,
BankAccountNumber = bankAccount.AccountNumber
};
_messageTemplateService.TrySendPlayerMessage(
player.Id,
MessageType.OfflineDepositRequested,
MessageDeliveryMethod.Email,
messageModel);
_messageTemplateService.TrySendPlayerMessage(
player.Id,
MessageType.OfflineDepositRequested,
MessageDeliveryMethod.Sms,
messageModel);
var data = Mapper.Map <OfflineDeposit>(deposit.Data);
return(data);
}
public async Task <CreatedNegotiatedContentResult <OfflineDepositResponse> > OfflineDeposit(OfflineDepositRequest request)
{
ValidateAccountFrozenStatus();
var offlineDepositRequest = Mapper.DynamicMap <Core.Payment.Interface.Data.Commands.OfflineDepositRequest>(request);
offlineDepositRequest.PlayerId = PlayerId;
var deposit = await _offlineDepositCommands.Submit(offlineDepositRequest);
var uri = RootToOfflineDeposit + deposit.Id;
return(Created(uri, new OfflineDepositResponse
{
Id = deposit.Id,
BonusRedemptionId = deposit.BonusRedemptionId,
UriToSubmittedOfflineDeposit = string.Empty
}));
}
public ValidationResult GetValidationResult(OfflineDepositRequest request)
{
var validator = new OfflineDepositValidator(_paymentRepository);
return(validator.Validate(request));
}
