public OnlineDeposit(Guid id,
string transactionNumber,
OnlineDepositRequest request,
OnlineDepositParams depositParams,
Guid brandId,
DateTimeOffset now)
{
if (request.Amount <= 0)
{
throw new ArgumentException("Amount must be greater than 0.");
}
Data = new Data.OnlineDeposit
{
Id = id,
BrandId = brandId,
PlayerId = request.PlayerId,
TransactionNumber = transactionNumber,
Amount = request.Amount,
CreatedBy = request.RequestedBy,
Created = now,
Status = OnlineDepositStatus.New,
Method = depositParams.Method,
Channel = depositParams.Channel,
MerchantId = depositParams.MerchantId,
Currency = depositParams.Currency,
Language = depositParams.Language,
ReturnUrl = depositParams.ReturnUrl,
NotifyUrl = depositParams.NotifyUrl,
BonusCode = request.BonusCode,
BonusId = request.BonusId
};
}
public async Task <OnlineDepositResponse> OnlineDeposit(OnlineDepositRequest request)
{
var settings = new AppSettings();
request.BrandId = _brandId;
request.CultureCode = System.Threading.Thread.CurrentThread.CurrentUICulture.Name;
request.NotifyUrl = settings.MemberWebsiteUrl + request.CultureCode + "/Home/OnlineDepositPayNotify";
request.ReturnUrl = settings.MemberWebsiteUrl + request.CultureCode + "/Home/OnlineDepositPayReceive";
return(await _memberApiProxy.OnlineDepositAsync(request));
}
private async Task <SubmitOnlineDepositRequestResult> SubmitOnlineDeposit(OnlineDepositRequest depositRequest)
{
var requestResult = await _onlineDepositCommands.SubmitOnlineDepositRequest(depositRequest);
requestResult.Should().NotBeNull();
requestResult.RedirectParams.Amount.Should().Be(depositRequest.Amount, "Amount");
//keep transactionNumber
_transactionNumber = requestResult.RedirectParams.OrderId;
return(requestResult);
}
public async void Can_submit_online_deposit_request()
{
var depositRequest = new OnlineDepositRequest
{
Amount = 200,
PlayerId = _testPlayer.Id,
RequestedBy = "Pl_QIOZZLVL4",
BonusCode = string.Empty,
CultureCode = "en-US",
NotifyUrl = "http://localhost/notifyurl",
ReturnUrl = "http://localhost/returnurl",
};
var requestResult = await _depositCommands.SubmitOnlineDepositRequest(depositRequest);
requestResult.RedirectUrl.Should().Be(new Uri(_testPaymentGatewaySettings.EntryPoint));
requestResult.RedirectParams.Amount.Should().Be(depositRequest.Amount, "Amount");
requestResult.RedirectParams.OrderId.Should().NotBeNullOrEmpty("OrderId");
requestResult.RedirectParams.Channel.Should().Be(_testPaymentGatewaySettings.Channel);
requestResult.RedirectParams.Method.Should().Be(_testPaymentGatewaySettings.PaymentGatewayName);
requestResult.RedirectParams.Currency.Should().Be(_testPlayer.CurrencyCode, "Currency");
requestResult.RedirectParams.Language.Should().Be("en-US", "Language");
requestResult.RedirectParams.NotifyUrl.Should().Be(depositRequest.NotifyUrl);
requestResult.RedirectParams.ReturnUrl.Should().Be(depositRequest.ReturnUrl);
//TODO:ONLINEDEPOSIT
requestResult.RedirectParams.MerchantId.Should().NotBeNullOrEmpty("MerchantId");
requestResult.RedirectParams.Signature.Should().NotBeNullOrEmpty("Signature");
var orderId = requestResult.RedirectParams.OrderId;
var onlineDeposit = _paymentRepositoryMock.OnlineDeposits.OrderByDescending(x => x.Created).First();
onlineDeposit.Should().NotBeNull();
if (onlineDeposit != null)
{
onlineDeposit.Amount.Should().Be(depositRequest.Amount, "Amount");
onlineDeposit.Status.Should().Be(OnlineDepositStatus.Processing, "Status");
onlineDeposit.PlayerId.Should().Be(depositRequest.PlayerId, "PlayerId");
onlineDeposit.CreatedBy.Should().Be(depositRequest.RequestedBy, "CreatedBy");
onlineDeposit.TransactionNumber.Should().Be(orderId, "TransactionNumber");
onlineDeposit.Method.Should().NotBeNullOrEmpty("Method");
onlineDeposit.MerchantId.Should().NotBeNullOrEmpty("MerchantId");
onlineDeposit.Language.Should().Be("en-US", "Language");
onlineDeposit.Currency.Should().Be(_testPlayer.CurrencyCode, "Currency");
onlineDeposit.ReturnUrl.Should().Be(depositRequest.ReturnUrl);
onlineDeposit.NotifyUrl.Should().Be(depositRequest.NotifyUrl);
onlineDeposit.OrderIdOfGateway.Should().BeNull("OrderIdOfGateway");
onlineDeposit.OrderIdOfRouter.Should().BeNull("OrderIdOfRouter");
onlineDeposit.BonusCode.Should().Be(depositRequest.BonusCode, "BonusCode");
}
}
public void Submit_command_should_throw_exception_if_amount_exceed_max_amount_per_transaction()
{
var depositRequest = new OnlineDepositRequest
{
Amount = 999999,
PlayerId = _testPlayer.Id,
RequestedBy = "Pl_QIOZZLVL4"
};
// Act
Func <Task> act = () => _depositCommands.SubmitOnlineDepositRequest(depositRequest);
// Assert
act.ShouldThrow <PaymentSettingsViolatedException>().WithMessage("{\"text\": \"app:payment.settings.amountExceedsAllowedValueError\", \"variables\": {\"value\": \"1000.00\"}}");
}
public async void Can_submit_online_deposit_request()
{
#region submit
var depositRequest = new OnlineDepositRequest
{
Amount = 200,
PlayerId = _testPlayer.Id,
RequestedBy = _testPlayer.Username,
};
var requestResult = SubmitOnlineDeposit(depositRequest);
requestResult.Should().NotBeNull("Deposit submit result should not be null");
//check PlayerActivityLog is inserted
var playerActivityLogs = GetPlayerActivityLog(_testPlayer.Id, "Deposit", "Create Online Deposit");
playerActivityLogs.Should().NotBeNull("PlayerActivityLogs-Create");
//Deposit Record
var depositReportNew = GetDepositRecords(_transactionNumber, OnlineDepositStatus.Processing.ToString());
depositReportNew.Should().NotBeNull();
#endregion
#region paynotify
var notifyResponse = NotifyOnlineDeposit(_transactionNumber);
notifyResponse.Should().Be("SUCCESS");
//Player Activity Logs
playerActivityLogs = GetPlayerActivityLog(_testPlayer.Id, "Deposit", "Approve Online Deposit");
playerActivityLogs.Should().NotBeNull("PlayerActivityLogs-Approve");
//Query Status
var statusAfterNotify = QueryOnlineDeposit(_transactionNumber);
statusAfterNotify.IsPaid.Should().Be(true);
statusAfterNotify.Amount.Should().Be(depositRequest.Amount);
//Deposit Record
var depositReportApproved = GetDepositRecords(_transactionNumber, OnlineDepositStatus.Approved.ToString());
depositReportApproved.Should().NotBeNull();
#endregion
//check wallet
var identity = Container.Resolve <ClaimsIdentityProvider>().GetActorIdentity(_testPlayer.Id, "Tests");
Thread.CurrentPrincipal = new ClaimsPrincipal(identity);
var wallet = await Container.Resolve <IWalletQueries>().GetPlayerBalance(_testPlayer.Id);
wallet.Main.Should().Be(depositRequest.Amount, "wallet amount");
}
public void Submit_command_should_throw_exception_if_exceed_max_trans_per_month()
{
//Arrange
GenerateOnlineDepositsDataForLimitChecking(true);
SetPaymentSettings(maxTransPerDay: 4, maxTransPerWeek: 4, maxTransPerMonth: 3);
var depositRequest = new OnlineDepositRequest
{
Amount = 200,
PlayerId = _testPlayer.Id,
RequestedBy = "Pl_QIOZZLVL4"
};
//Act
Func <Task> act = () => _depositCommands.SubmitOnlineDepositRequest(depositRequest);
// Assert
act.ShouldThrow <PaymentSettingsViolatedException>().WithMessage("{\"text\": \"app:payment.settings.numberTransactionsExceedsMonthLimitError\", \"variables\": {\"value\": \"3.00\"}}");
}
public void Submit_command_should_throw_exception_if_amount_exceed_max_amount_per_day()
{
//Arrange
GenerateOnlineDepositsDataForLimitChecking();
SetPaymentSettings(maxAmountPerDay: 600);
var depositRequest = new OnlineDepositRequest
{
Amount = 500,
PlayerId = _testPlayer.Id,
RequestedBy = "Pl_QIOZZLVL4"
};
// Act
Func <Task> act = () => _depositCommands.SubmitOnlineDepositRequest(depositRequest);
// Assert
act.ShouldThrow <PaymentSettingsViolatedException>().WithMessage("{\"text\": \"app:payment.settings.amountExceedsDailyLimitError\", \"variables\": {\"value\": \"600.00\"}}");
}
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
});
}
public async Task <IActionResult> PostPaywaloOnlineAsync([FromBody] TopupReqOnline value)
{
var user = _user.getUser(User.Claims.FirstOrDefault().Value);
if (user == null)
{
return(BadRequest(new { status = "FAILURE", desc = "Not found user from token" }));
}
if (!ModelState.IsValid)
{
return(BadRequest("Valid parameter!"));
}
if (_inv.getExistOrder(value.OrderNumber, user.CompCode))
{
return(BadRequest(new { status = "FAILURE", desc = "This order number has been used!" }));
}
var invoice = new Invoice
{
//MethodId = Constant.PayWalo.paywaloOnlineMethod,
//TranstypeId = Constant.PayWalo.deposit,
MethodId = _constant.OnlineBanking,
TranstypeId = _constant.Deposit,
MemberId = value.member_id,
CompCode = user.CompCode,
OrderNumber = value.OrderNumber,
OrderDate = DateTime.Now,
CreateDate = DateTime.Now,
ModifiedDate = DateTime.Now,
Amount = value.Amount,
Fee = 0,
CurrencyCode = "THB",
ExternalId = value.test == true ? "TEST-" + Guid.NewGuid().ToString().Substring(0, 30) : Guid.NewGuid().ToString(),
CallbackUrl = value.CallbackUrl,
Status = "pen"
};
var newInvoice = _inv.CreateDepositOnline(invoice);
if (newInvoice == null)
{
return(BadRequest("Cannot create invoice!"));
}
var p = new OnlineDepositRequest()
{
Amount = Convert.ToDecimal(newInvoice.Amount),
BankCode = value.BankCode,
OrderNumber = newInvoice.ExternalId,
Fullname = value.Fullname,
Currency = "THB"
};
OnlineDepositResponse response = await _paywalo.DepositOnline(p, invoice);
var transaction = _inv.getInvoiceById(newInvoice.InvoiceId);
if (response.Data != null)
{
if (response.Status.Equals("SUCCESS"))
{
//update invoice
_inv.Set_GTransID(newInvoice.InvoiceId, response.Data.TransactionNumber);
transaction.PaymentGateWayUrl = response.Data.PaymentGateWayUrl;
return(Ok(new { status = "PENDING", desc = "Transaction hash been created", transaction = transaction }));
}
else
{
_inv.SetCancel(newInvoice.InvoiceId);
return(BadRequest(new { status = "FAILURE", desc = response.Messages, transaction = transaction }));
}
}
var jsonString = JsonConvert.SerializeObject(response);
string ip = HttpContext.Connection.RemoteIpAddress.ToString();
_log.save("Online banking deposit", "post api/deposit/paywalo/online", jsonString, ip);
_inv.SetCancel(newInvoice.InvoiceId);
return(BadRequest(new { status = "FAILURE", desc = response.Messages, transaction = transaction }));
}
public async Task <OnlineDepositResponse> OnlineDepositAsync(OnlineDepositRequest request)
{
var result = await HttpClient.SecurePostAsJsonAsync(Token, "api/Payment/SubmitOnlineDeposit", request);
return(await EnsureApiResult <OnlineDepositResponse>(result));
}
