private TransactionResponseModel Deposit(DepositViewModel model, IUnitOfWork unit)
{
var failureResponse = new TransactionResponseModel
{
IsSuccessful = false
};
var account = unit.Repository <Account>().Get().SingleOrDefault(a => a.AccountNumber == model.AccountNumber);
if (account != null)
{
if (model.Amount < decimal.MaxValue - account.Balance)
{
account.Balance += model.Amount;
var entity = unit.Repository <Account>().Attach(account);
return(new TransactionResponseModel
{
IsSuccessful = true,
CurrentBalance = entity.Balance,
Message = Message.SuccessfulTracsaction
});
}
failureResponse.Message = Message.SystemError;
return(failureResponse);
}
failureResponse.Message = Message.AccountIsInvalid;
return(failureResponse);
}
private IActionResult GetResponse(TransactionResponseModel responseModel)
{
switch (responseModel.StatusCode)
{
case StatusCodes.Status415UnsupportedMediaType:
{
return(View("Error"));
}
case StatusCodes.Status400BadRequest:
{
return(BadRequest(responseModel));
}
case StatusCodes.Status200OK:
{
return(Ok());
}
case StatusCodes.Status500InternalServerError:
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
return(View("Index"));
}
private TransactionResponseModel HandleSaving(SaveResultModel saveResult, TransactionResponseModel result, IUnitOfWork unit, string accountNumber)
{
if (saveResult.IsSuccessful)
{
var account = unit.Repository <Account>().Get().SingleOrDefault(a => a.AccountNumber == accountNumber);
if (account != null)
{
return(new TransactionResponseModel
{
IsSuccessful = saveResult.IsSuccessful,
Message = saveResult.Message,
CurrentBalance = result.CurrentBalance,
RowVersion = Convert.ToBase64String(account.RowVersion)
});
}
return(new TransactionResponseModel
{
IsSuccessful = false,
Message = Message.AccountNotFound
});
}
return(new TransactionResponseModel
{
IsSuccessful = saveResult.IsSuccessful,
Message = saveResult.Message,
RowVersion = result.RowVersion
});
}
private TransactionResponseModel Withdraw(WithdrawViewModel model, IUnitOfWork unit)
{
var failureResponse = new TransactionResponseModel
{
IsSuccessful = false
};
var account = unit.Repository <Account>().Get().FirstOrDefault(a => a.AccountNumber == model.AccountNumber);
if (account != null)
{
if (account.Balance >= model.Amount)
{
account.Balance -= model.Amount;
var entity = unit.Repository <Account>().Attach(account);
return(new TransactionResponseModel
{
IsSuccessful = true,
CurrentBalance = entity.Balance,
Message = Message.SuccessfulTracsaction
});
}
failureResponse.Message = Message.BalanceIsNotEnough;
return(failureResponse);
}
failureResponse.Message = Message.AccountIsInvalid;
return(failureResponse);
}
public async Task <IActionResult> MultisigTransactionAsync(DestinationChain destinationChain, int transactionId, bool raw)
{
try
{
if (!this.ethCompatibleClientProvider.IsChainSupportedAndEnabled(destinationChain))
{
return(this.Json($"{destinationChain} not enabled or supported!"));
}
IETHClient client = this.ethCompatibleClientProvider.GetClientForChain(destinationChain);
if (raw)
{
return(this.Json(await client.GetRawMultisigTransactionAsync(transactionId).ConfigureAwait(false)));
}
TransactionDTO transaction = await client.GetMultisigTransactionAsync(transactionId).ConfigureAwait(false);
var response = new TransactionResponseModel()
{
Destination = transaction.Destination,
Value = transaction.Value.ToString(),
Data = Encoders.Hex.EncodeData(transaction.Data),
Executed = transaction.Executed
};
return(this.Json(response));
}
catch (Exception e)
{
this.logger.LogError("Exception occurred: {0}", e.ToString());
return(ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest, e.Message, e.ToString()));
}
}
private void LoadMoreTransactionsCompleted(TransactionResponseModel transactionResponse)
{
TableView.ReloadData();
cnsTableViewHeight.Constant = TableView.ContentSize.Height;
ScrollView.ContentSize = new CGSize(ScrollView.Frame.Width, TableView.Frame.Y + TableView.ContentSize.Height);
didRefreshTransactions = true;
RefreshComplete();
}
public ActionResult HostedCheckoutReceipt(string orderId, string result, string sessionId)
{
// Logger.LogInformation($"PaymentApiController HostedCheckoutReceipt action orderId {orderId} result {result} sessionId {sessionId}");
if (result == "SUCCESS")
{
GatewayApiRequest gatewayApiRequest = new GatewayApiRequest(GatewayApiConfig)
{
ApiOperation = "RETRIEVE_ORDER",
OrderId = orderId,
ApiMethod = GatewayApiClient.GET
};
gatewayApiRequest.buildOrderUrl();
string response = GatewayApiClient.SendTransaction(gatewayApiRequest);
// Logger.LogInformation($"Hosted checkout retrieve order response {response}");
//parse response
TransactionResponseModel transactionResponseModel = null;
try
{
transactionResponseModel = TransactionResponseModel.toTransactionResponseModel(response);
}
catch (Exception e)
{
// Logger.LogError($"Hosted Checkout Receipt error : {JsonConvert.SerializeObject(e)}");
return(View("Error", new ErrorViewModel
{
RequestId = getRequestId(),
Cause = e.InnerException != null ? e.InnerException.StackTrace : e.StackTrace,
Message = e.Message
}));
}
return(View(ViewList["Receipt"], transactionResponseModel));
}
else
{
// Logger.LogError($"The payment was unsuccessful {result}");
return(View("Error", new ErrorViewModel
{
RequestId = getRequestId(),
Cause = "Payment was unsuccessful",
Message = "There was a problem completing your transaction."
}));
}
}
void RefreshTransactionComplete(TransactionResponseModel response)
{
try
{
TableView.ReloadData();
cnsTableViewHeight.Constant = TableView.ContentSize.Height;
ScrollView.ContentSize = new CGSize(ScrollView.Frame.Width, TableView.Frame.Y + TableView.ContentSize.Height);
}
catch (Exception)
{
}
didRefreshTransactions = true;
RefreshComplete();
}
public ActionResult browserPaymentReceipt(String transactionId, String orderId)
{
//get order id from page parameter
//create a gateway parameters request to retrieve the transaction result
GatewayApiRequest gatewayApiRequest = new GatewayApiRequest();
gatewayApiRequest.GatewayApiConfig = GatewayApiConfig;
gatewayApiRequest.ApiMethod = GatewayApiClient.GET;
gatewayApiRequest.ApiOperation = "RETRIEVE_TRANSACTION";
gatewayApiRequest.OrderId = orderId;
gatewayApiRequest.buildOrderUrl();
gatewayApiRequest.buildPayload();
string response = GatewayApiClient.SendTransaction(gatewayApiRequest);
//validate transaction response
if (JsonHelper.isErrorMessage(response))
{
return(View("Error", ErrorViewModel.toErrorViewModel(getRequestId(), response)));
}
//parse response to model
TransactionResponseModel model = null;
try
{
model = TransactionResponseModel.toTransactionResponseModel(response);
}
catch (Exception e)
{
// Logger.LogError($"browserPaymentReceipt error : {JsonConvert.SerializeObject(e)}");
return(View("Error", new ErrorViewModel
{
RequestId = getRequestId(),
Cause = e.InnerException != null ? e.InnerException.StackTrace : e.StackTrace,
Message = e.Message
}));
}
return(View(ViewList["Receipt"], model));
}
public TransactionRetrieveResponseOperation GetPaymentTransaction(string receiptResponse)
{
TransactionResponseModel transactionResponseModel = null;
try
{
transactionResponseModel = TransactionResponseModel.toPaywithTokenTransactionResponseModel(receiptResponse);
}
catch (Exception ex)
{
LogInfo.Error($" : { EnumExtensions.GetDescription(MPGSAPIResponse.HostedCheckoutReceiptError) + " " + JsonConvert.SerializeObject(ex)}");
throw ex;
}
return(new TransactionRetrieveResponseOperation {
TrasactionResponse = transactionResponseModel
});
}
//TODO: Change to private when done unit test
public async Task <TransactionResponseModel> DepositAsync(DepositViewModel model, IUnitOfWork unit)
{
var account = await unit.Repository <Account>().Get().SingleOrDefaultAsync(a => a.AccountNumber == model.AccountNumber);
var currentRowVerStr = Convert.ToBase64String(account.RowVersion);
var failureResponse = new TransactionResponseModel
{
IsSuccessful = false,
RowVersion = currentRowVerStr
};
var passRowVer = Convert.FromBase64String(model.RowVersion);
var prop = unit.GetContext().Entry(account).Property(a => a.RowVersion);
prop.CurrentValue = passRowVer;
prop.OriginalValue = passRowVer;
if (account != null)
{
if (model.Amount < decimal.MaxValue - account.Balance)
{
account.Balance += model.Amount;
var entity = unit.Repository <Account>().Attach(account);
unit.GetContext().Entry(account).State = EntityState.Modified;
return(new TransactionResponseModel
{
IsSuccessful = true,
CurrentBalance = entity.Balance,
Message = Message.SuccessfulTracsaction,
RowVersion = currentRowVerStr
});
}
failureResponse.Message = Message.SystemError;
return(failureResponse);
}
failureResponse.Message = Message.AccountIsInvalid;
return(failureResponse);
}
public async Task <IViewComponentResult> InvokeAsync()
{
PaystackTransaction transactionResponse = null;
TransactionResponseModel transactionResponseModel = null;
PaystackSetting paystackSetting = null;
try
{
string tranxid = _httpContext.Request.Query["reference"].ToString();
if (!tranxid.IsEmpty())
{
paystackSetting = await _settingService.GetSetting <PaystackSetting>();
transactionResponse = await _gatewayLuncher.VerifyTransaction(paystackSetting, tranxid);
await _httpContext.Session.SetComplexData(_gatewayLuncher.GatewayResponse, transactionResponse);
if (transactionResponse != null && transactionResponse.Data != null && transactionResponse.Data.customer != null)
{
transactionResponse.status = false;
transactionResponseModel = new TransactionResponseModel()
{
ResponseData = transactionResponse.Data
};
transactionResponseModel.HomePageUrl = _gatewayLuncher.GetRedirectUrl(_httpContext.Request, "Index", "Home");
if (transactionResponse.status)
{
_gatewayLuncher.IsSuccessful = true;
transactionResponseModel.AlertType = "primary";
transactionResponseModel.BorderColor = "blue";
transactionResponseModel.ThankYou = "Your transaction was successful";
transactionResponseModel.PaymentSuccessful = true;
}
else
{
_gatewayLuncher.IsSuccessful = false;
transactionResponseModel.BorderColor = "red";
transactionResponseModel.AlertType = "danger";
transactionResponseModel.ThankYou = "Your transaction failed!";
transactionResponseModel.ErrorMessage = transactionResponse.Data.gateway_response;
transactionResponseModel.PaymentSuccessful = false;
//transactionResponseModel.ErrorMessage = transactionResponse.Data.gateway_response;
//_httpContext.Session.SetString(_gatewayLuncher.ErrorMessage, transactionResponseModel.TransactionSummary);
}
transactionResponseModel.Currency = transactionResponse.Data.currency;
transactionResponseModel.GatewayResponse = transactionResponse.Data.gateway_response;
transactionResponseModel.TransactionReference = transactionResponse.Data.reference;
transactionResponseModel.TransactionStatus = transactionResponse.Data.status;
}
else
{
transactionResponseModel.ErrorMessage = "Gateway response is empty! Please click on the 'Continue button' below to initiate another transaction.";
//_httpContext.Session.SetString(_gatewayLuncher.ErrorMessage, "Gateway response is empty! Please click on the 'Continue button' below to initiate another transaction."); // "Transction response is empty";
}
}
else
{
transactionResponseModel.ErrorMessage = "No Transction Reference returned!";
//_httpContext.Session.SetString(_gatewayLuncher.ErrorMessage, "No Transction Reference returned!"); // "No Transction Reference returned!";
}
}
catch (Exception ex)
{
transactionResponseModel.ErrorMessage = ex.Message;
////_logger.Error(ex);
//_httpContext.Session.SetString(_gatewayLuncher.ErrorMessage, ex.Message);
}
try
{
await _gatewayLuncher.LogTransaction(transactionResponse);
//Order order = _orderService.GetOrderById(GatewayLuncher.RegistrationId);
//SetOrderStatus(order, transactionResponse.status);
//bool sendMail = paystackSetting.SendMailOnFailedTransaction == true || _gatewayLuncher.IsSuccessful == true;
//SendEmail(order, sendMail);
}
catch (Exception ex)
{
transactionResponseModel.ErrorMessage = ex.Message;
//_logger.Error(ex);
//_httpContext.Session.SetString(_gatewayLuncher.ErrorMessage, ex.Message);
}
//ViewViewComponentResult viewComponent = null;
//bool isRegistered = _widgetProvider.IsRegistered(WidgetZone.PaymentGatewayHappyResponse);
//if (isRegistered && _gatewayLuncher.IsSuccessful)
//{
// viewComponent = await Task.FromResult(View(transactionResponseModel));
//}
//else
//{
// viewComponent = await Task.FromResult(View(new TransactionResponseModel()));
//}
ViewViewComponentResult viewComponent = null;
bool isRegistered = _widgetProvider.IsRegistered(WidgetZone.PaymentGatewayResponse);
if (isRegistered)
{
viewComponent = await Task.FromResult(View(transactionResponseModel));
}
return(viewComponent);
}
public ActionResult masterpassResponse(String oauth_token, String oauth_verifier, String checkoutId,
String checkout_resource_url, String mpstatus)
{
String UPDATE_SESSION_FROM_WALLET = "UPDATE_SESSION_FROM_WALLET";
String WALLET_PROVIDER = "MASTERPASS_ONLINE";
//get session values
String sessionId = getSessionValueAsString("sessionId");
String amount = getSessionValueAsString("amount");
String currency = getSessionValueAsString("currency");
String orderId = getSessionValueAsString("orderId");
//remove session values
removeSessionValue("sessionId");
removeSessionValue("amount");
removeSessionValue("currency");
removeSessionValue("orderId");
// UPDATE_SESSION_FROM_WALLET - Retrieve payment details from wallet using session ID
GatewayApiRequest gatewayApiRequest = new GatewayApiRequest(GatewayApiConfig);
gatewayApiRequest.ApiMethod = GatewayApiClient.POST;
gatewayApiRequest.ApiOperation = UPDATE_SESSION_FROM_WALLET;
gatewayApiRequest.MasterpassOnline = WALLET_PROVIDER;
gatewayApiRequest.MasterpassOauthToken = oauth_token;
gatewayApiRequest.MasterpassOauthVerifier = oauth_verifier;
gatewayApiRequest.MasterpassCheckoutUrl = checkout_resource_url;
gatewayApiRequest.buildSessionRequestUrl(sessionId);
//build json
gatewayApiRequest.buildPayload();
string response = GatewayApiClient.SendTransaction(gatewayApiRequest);
// Logger.LogInformation($"Masterpass update session : {response}");
//validate transaction response
if (JsonHelper.isErrorMessage(response))
{
return(View("Error", ErrorViewModel.toErrorViewModel(getRequestId(), response)));
}
// Make a payment using the session
// Construct API request
GatewayApiRequest gatewayPayApiRequest = new GatewayApiRequest(GatewayApiConfig);
gatewayPayApiRequest.ApiMethod = GatewayApiClient.PUT;
gatewayPayApiRequest.ApiOperation = "PAY";
gatewayPayApiRequest.SessionId = sessionId;
//order info
gatewayPayApiRequest.OrderAmount = amount;
gatewayPayApiRequest.OrderId = orderId;
gatewayPayApiRequest.OrderCurrency = currency;
gatewayPayApiRequest.TransactionId = IdUtils.generateSampleId();
//build payload
gatewayPayApiRequest.buildPayload();
gatewayPayApiRequest.buildRequestUrl();
response = GatewayApiClient.SendTransaction(gatewayPayApiRequest);
// Logger.LogInformation($"Masterpass PAY operation : {response}");
//validate transaction response
if (JsonHelper.isErrorMessage(response))
{
return(View("Error", ErrorViewModel.toErrorViewModel(getRequestId(), response)));
}
//parse response to default transaction response model
TransactionResponseModel model = null;
try
{
model = TransactionResponseModel.fromMasterpassResponseToTransactionResponseModel(response);
}
catch (Exception e)
{
// Logger.LogError($"MasterpassResponse error : {JsonConvert.SerializeObject(e)}");
return(View("Error", new ErrorViewModel
{
RequestId = getRequestId(),
Cause = e.InnerException != null ? e.InnerException.StackTrace : e.StackTrace,
Message = e.Message
}));
}
return(View(ViewList["Receipt"], model));
}
public async Task <ActionResult> CreateTransaction(User user, ClaimsPrincipal currentUser, decimal amount, Transaction transaction, string reason)
{
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
List <Transaction> transactions = new List <Transaction>();
TransactionResponseModel sender = new TransactionResponseModel();
TransactionResponseModel reciever = new TransactionResponseModel();
if (transaction.SenderAccountInfo.Contains("BG18VITB") && transaction.SenderAccountInfo.Length == 23)
{
sender.IsIBAN = true;
sender.SenderInfo = transaction.SenderAccountInfo;
reciever.RecieverInfo = transaction.RecieverAccountInfo;
if (transaction.RecieverAccountInfo.Contains("BG18VITB") && transaction.RecieverAccountInfo.Length == 23)
{
reciever.IsIBAN = true;
reciever.RecieverInfo = transaction.RecieverAccountInfo;
}
}
else if (transaction.RecieverAccountInfo.Contains("BG18VITB") && transaction.RecieverAccountInfo.Length == 23)
{
reciever.IsIBAN = true;
sender.SenderInfo = transaction.SenderAccountInfo;
reciever.RecieverInfo = transaction.RecieverAccountInfo;
}
else
{
_messageModel.Message = "Invalid arguments!";
return(StatusCode(400, _messageModel));
}
//bad request
if (sender.IsIBAN && reciever.IsIBAN)
{
transaction.Reason = reason;
transaction.Date = DateTime.Now;
transaction.TransactionAmount = amount;
_context.Add(transaction);
await _context.SaveChangesAsync();
transactions = _context.Transactions.ToList();
user.LastTransactionId = transactions.Last().Id;
await _context.SaveChangesAsync();
_messageModel.Message = "Money send successfully!";
return(StatusCode(200, _messageModel));
}
else if (sender.IsIBAN && !reciever.IsIBAN)
{
transaction.Reason = reason;
transaction.Date = DateTime.Now;
transaction.TransactionAmount = amount;
_context.Add(transaction);
await _context.SaveChangesAsync();
transactions = _context.Transactions.ToList();
user.LastTransactionId = transactions.Last().Id;
await _context.SaveChangesAsync();
_messageModel.Message = "Purchase successfull!";
return(StatusCode(200, _messageModel));
}
else if (!sender.IsIBAN && reciever.IsIBAN)
{
transaction.Reason = reason;
transaction.Date = DateTime.Now;
transaction.TransactionAmount = amount;
_context.Add(transaction);
await _context.SaveChangesAsync();
transactions = _context.Transactions.ToList();
user.LastTransactionId = transactions.Last().Id;
await _context.SaveChangesAsync();
_messageModel.Message = "Money recieved successfully!";
return(StatusCode(200, _messageModel));
}
}
_messageModel.Message = "You are not autorized to do such actions!";
return(StatusCode(403, _messageModel));
}
