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);
}
public async Task <SubmitOnlineDepositRequestResult> SubmitOnlineDepositRequest(OnlineDepositRequest request)
{
var validationResult = new OnlineDepositRequestValidator(_repository).Validate(request);
if (!validationResult.IsValid)
{
throw new RegoValidationException(validationResult);
}
var player = _repository.Players.FirstOrDefault(x => x.Id == request.PlayerId);
var paymentGetewaySettings = _paymentGatewaySettingsQueries.GetOnePaymentGatewaySettingsByPlayerId(player.Id);
if (paymentGetewaySettings == null)
{
throw new RegoException("PaymentGatewaySettings not found");
}
var method = paymentGetewaySettings.OnlinePaymentMethodName;
var channel = paymentGetewaySettings.Channel;
var paymentUrl = paymentGetewaySettings.EntryPoint;
_validator.ValidatePaymentSetting(request.PlayerId, method, request.Amount, player.CurrencyCode);
var number = GenerateOrderId(method, channel);
var merchantId = GetDepositMerchantId();
var hashKey = GetDepositHashKey();
var depositParams = new OnlineDepositParams();
depositParams.Method = method;
depositParams.Channel = channel;
depositParams.Amount = request.Amount;
depositParams.MerchantId = merchantId;
depositParams.OrderId = number;
depositParams.Currency = player.CurrencyCode;
depositParams.Language = request.CultureCode;
depositParams.ReturnUrl = request.ReturnUrl;
depositParams.NotifyUrl = request.NotifyUrl;
depositParams.Signature = EncryptHelper.GetMD5HashInHexadecimalFormat(depositParams.SignParams + hashKey);
var id = Guid.NewGuid();
var brandId = player.BrandId;
var now = _paymentQueries.GetBrandDateTimeOffset(brandId);
var onlineDepositEntity = new Entities.OnlineDeposit(id, number, request, depositParams, brandId, now);
var submitEvent = onlineDepositEntity.Submit();
using (var scope = CustomTransactionScope.GetTransactionScopeAsync())
{
if (!string.IsNullOrWhiteSpace(request.BonusCode) || (request.BonusId.HasValue && request.BonusId != Guid.Empty))
{
var bonusRedemptionId = await _bonusApiProxy.ApplyForBonusAsync(new DepositBonusApplication
{
PlayerId = request.PlayerId,
BonusId = request.BonusId,
Amount = request.Amount,
DepositId = onlineDepositEntity.Data.Id,
BonusCode = onlineDepositEntity.Data.BonusCode
});
onlineDepositEntity.SetBonusRedemption(bonusRedemptionId);
}
_repository.OnlineDeposits.Add(onlineDepositEntity.Data);
_eventBus.Publish(submitEvent);
_repository.SaveChanges();
scope.Complete();
}
return(new SubmitOnlineDepositRequestResult
{
DepositId = id,
RedirectUrl = new Uri(paymentUrl),
RedirectParams = depositParams
});
}
//[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);
}
