/// <inheritdoc />
/// <summary>
/// Gets the transactions view model.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <returns></returns>
public IEnumerable <BraintreeTransactionViewModel> GetTransactionsViewModel(UmbracoContext umbracoContext)
{
loggingService.Info(GetType());
List <BraintreeTransactionViewModel> viewModels = new List <BraintreeTransactionViewModel>();
PaymentSettingsModel model = paymentProvider.GetPaymentSettingsModel(umbracoContext);
if (model.PaymentsEnabled)
{
transactionsRepository.SetKey(umbracoContext);
bool exists = transactionsRepository.Exists();
if (exists)
{
return(transactionsRepository.Get <IEnumerable <BraintreeTransactionViewModel> >());
}
ResourceCollection <Transaction> transactions = paymentProvider.GetBraintreeTransactions(model);
viewModels = (from Transaction transaction
in transactions
select transactionTranslator.Translate(transaction))
.ToList();
transactionsRepository.Add(viewModels);
}
return(viewModels);
}
private void AddNewPaymentRecord()
{
PaymentMethod = new PaymentSettingsModel {
GpPaymentId = -1
};
ShowPopup = true;
}
/// <inheritdoc />
public bool SavePaymentDetails(PaymentSettingsModel paymentMethod)
{
using (var connection = new SqlConnection(Constants.ConnectorDatabase))
{
var cmd = new SqlCommand
{
CommandType = System.Data.CommandType.Text,
CommandText = @"IF(@Id>0)
Update PaymentMethod SET EcommercePaymentMethod=@MagentoPaymentMethod,ERPPaymentMethod=@ERPPaymentMethod,ERPPaymentType=@ERPPaymentType,IsEcommerceDefault=@IsEcommerceDefault,IsErpDefault=@IsErpDefault where PaymentMethodId=@Id
else
Insert into PaymentMethod (EcommercePaymentMethod,ERPPaymentMethod,ERPPaymentType,IsEcommerceDefault,IsErpDefault) values(@MagentoPaymentMethod,@ERPPaymentMethod,@ERPPaymentType,@IsEcommerceDefault,@IsErpDefault);"
};
cmd.Parameters.AddWithValue("@MagentoPaymentMethod", paymentMethod.MagentoPaymentName);
cmd.Parameters.AddWithValue("@ERPPaymentMethod", paymentMethod.GpPaymentName);
cmd.Parameters.AddWithValue("@ERPPaymentType", paymentMethod.GpPaymentId);
cmd.Parameters.AddWithValue("@Id", paymentMethod.Id);
cmd.Parameters.AddWithValue("@IsEcommerceDefault", paymentMethod.IsEcommerceDefault);
cmd.Parameters.AddWithValue("@IsErpDefault", paymentMethod.IsErpDefault);
cmd.Connection = connection;
connection.Open();
int i = cmd.ExecuteNonQuery();
if (i <= 0)
{
return(false);
}
UpdateDefaultValues(paymentMethod, connection);
return(true);
}
}
/// <inheritdoc />
/// <summary>
/// Gets the transaction.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <param name="transactionId">The transaction identifier.</param>
/// <returns></returns>
public BraintreeTransactionViewModel GetTransactionViewModel(
UmbracoContext umbracoContext,
string transactionId)
{
loggingService.Info(GetType(), "EncryptedTransactionId=" + transactionId);
PaymentSettingsModel model = paymentProvider.GetPaymentSettingsModel(umbracoContext);
transactionsRepository.SetKey(umbracoContext);
bool exists = transactionsRepository.Exists();
if (exists)
{
IEnumerable <BraintreeTransactionViewModel> viewModels = transactionsRepository.Get <IEnumerable <BraintreeTransactionViewModel> >();
BraintreeTransactionViewModel viewModel = viewModels.FirstOrDefault(x => x.Id == transactionId);
if (viewModel != null)
{
return(viewModel);
}
}
Transaction transaction = paymentProvider.GetTransaction(model, transactionId);
return(transactionTranslator.Translate(transaction));
}
/// <inheritdoc />
/// <summary>
/// Gets the transactions view model.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <returns></returns>
public IEnumerable <TransactionViewModel> GetTransactionsViewModel(UmbracoContext umbracoContext)
{
loggingService.Info(GetType());
List <TransactionViewModel> viewModels = new List <TransactionViewModel>();
PaymentSettingsModel model = paymentProvider.GetPaymentSettingsModel(umbracoContext);
if (model.PaymentsEnabled)
{
CustomerModel customerModel = customerProvider.GetCustomerModel(umbracoContext);
//// TODO : change at some point!
DateTime startDate = DateTime.MinValue;
DateTime endDate = DateTime.MaxValue;
IEnumerable <TransactionModel> transactions = databaseProvider.GetTransactions(
startDate,
endDate,
customerModel.Id);
viewModels = (from TransactionModel transaction
in transactions
select transactionTranslator.Translate(transaction))
.ToList();
}
return(viewModels);
}
/// <inheritdoc />
/// <summary>
/// Sets the key.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
public void SetKey(UmbracoContext umbracoContext)
{
IPublishedContent customerNode = settingsService.GetCustomerNode();
if (customerNode != null)
{
CustomerModel customerModel = new CustomerModel(customerNode);
IPublishedContent paymentsNode = settingsService.GetPaymentsNode();
if (paymentsNode != null)
{
PaymentSettingsModel paymentSettingsModel = new PaymentSettingsModel(paymentsNode);
Key = "Tranactions" +
customerModel.Id +
paymentSettingsModel.Environment +
paymentSettingsModel.MerchantId +
paymentSettingsModel.PublicKey;
return;
}
}
throw new ApplicationException("Unable to set Transactions Cache Key.");
}
/// <inheritdoc />
/// <summary>
/// Gets the gateway.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public IBraintreeGateway GetGateway(PaymentSettingsModel model)
{
return(new BraintreeGateway(
model.Environment,
model.MerchantId,
model.PublicKey,
model.PrivateKey));
}
private static void UpdateEcommerceDefaultValues(PaymentSettingsModel paymentMethod, SqlConnection connection)
{
const string commandText = "update PaymentMethod SET IsEcommerceDefault=0 where EcommercePaymentMethod<>@EcommercePaymentMethod AND ERPPaymentMethod=@ERPPaymentMethod";
using (var command = new SqlCommand(commandText, connection))
{
command.Parameters.AddWithValue("@ERPPaymentMethod", paymentMethod.GpPaymentName);
command.Parameters.AddWithValue("@EcommercePaymentMethod", paymentMethod.MagentoPaymentName);
command.ExecuteNonQuery();
}
}
private static void UpdateDefaultValues(PaymentSettingsModel paymentMethod, SqlConnection connection)
{
if (paymentMethod.IsErpDefault)
{
UpdateErpDefaultValues(paymentMethod, connection);
}
if (paymentMethod.IsEcommerceDefault)
{
UpdateEcommerceDefaultValues(paymentMethod, connection);
}
}
public async Task <IActionResult> Settings(PaymentSettingsModel model,
[FromServices] ICustomerActivityService customerActivityService)
{
var paymentSettings = _settingService.LoadSetting <PaymentSettings>();
paymentSettings = model.ToEntity(paymentSettings);
await _settingService.SaveSetting(paymentSettings);
//activity log
await customerActivityService.InsertActivity("EditSettings", "", _translationService.GetResource("ActivityLog.EditSettings"));
Success(_translationService.GetResource("Admin.Configuration.Updated"));
return(RedirectToAction("Settings"));
}
public static PaymentSettingsModel ToModel(this PaymentSettings paymentSettings)
{
var model = new PaymentSettingsModel()
{
CreditExchangeRate = paymentSettings.CreditExchangeRate,
IsPromotionalCreditUsageLimitPercentage = paymentSettings.IsPromotionalCreditUsageLimitPercentage,
MacroPaymentsFixedPaymentProcessingFee = paymentSettings.MacroPaymentsFixedPaymentProcessingFee,
MacroPaymentsPaymentProcessingPercentage = paymentSettings.MacroPaymentsPaymentProcessingPercentage,
MicroPaymentsFixedPaymentProcessingFee = paymentSettings.MicroPaymentsFixedPaymentProcessingFee,
MicroPaymentsPaymentProcessingPercentage = paymentSettings.MicroPaymentsPaymentProcessingPercentage,
PaymentMethodSelectionType = paymentSettings.PaymentMethodSelectionType,
PromotionalCreditUsageLimitPerTransaction = paymentSettings.PromotionalCreditUsageLimitPerTransaction
};
return(model);
}
/// <summary>
/// Gets the payment partial view.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <returns></returns>
/// <exception cref="ApplicationException">Payment Provider not setup.</exception>
/// <inheritdoc />
public string GetPaymentPartialView(
UmbracoContext umbracoContext)
{
PaymentSettingsModel model = GetPaymentSettingsModel(umbracoContext);
switch (model.Provider)
{
case Constants.PaymentProviders.Braintree:
return(BraintreeDirectory + PaymentPage);
case Constants.PaymentProviders.PayPal:
return(PayPalDirectory + PaymentPage);
default:
throw new ApplicationException("Payment Provider not setup.");
}
}
public IHttpActionResult Post(PaymentSettingsModel entityModel)
{
var paymentSettings = new PaymentSettings()
{
CreditExchangeRate = entityModel.CreditExchangeRate,
IsPromotionalCreditUsageLimitPercentage = entityModel.IsPromotionalCreditUsageLimitPercentage,
MacroPaymentsFixedPaymentProcessingFee = entityModel.MacroPaymentsFixedPaymentProcessingFee,
MacroPaymentsPaymentProcessingPercentage = entityModel.MacroPaymentsPaymentProcessingPercentage,
MicroPaymentsFixedPaymentProcessingFee = entityModel.MicroPaymentsFixedPaymentProcessingFee,
MicroPaymentsPaymentProcessingPercentage = entityModel.MicroPaymentsPaymentProcessingPercentage,
PaymentMethodSelectionType = entityModel.PaymentMethodSelectionType,
PromotionalCreditUsageLimitPerTransaction = entityModel.PromotionalCreditUsageLimitPerTransaction
};
_settingService.Save(paymentSettings);
VerboseReporter.ReportSuccess("Settings saved successfully", "post_setting");
return(RespondSuccess(new { PaymentSettings = paymentSettings.ToModel() }));
}
/// <summary>
/// Gets the transaction view model.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <param name="encryptedId">The encrypted identifier.</param>
/// <returns></returns>
/// <inheritdoc />
public TransactionViewModel GetTransactionViewModel(
UmbracoContext umbracoContext,
string encryptedId)
{
PaymentSettingsModel settingsModel = paymentProvider.GetPaymentSettingsModel(umbracoContext);
if (settingsModel.PaymentsEnabled)
{
string paymentId = encryptionService.DecryptString(encryptedId);
CustomerModel customerModel = customerProvider.GetCustomerModel(umbracoContext);
TransactionModel model = databaseProvider.GetTransaction(Convert.ToInt32(paymentId), customerModel.Id);
return(transactionTranslator.Translate(model));
}
return(new TransactionViewModel());
}
public PartialViewResult GetCreateInvoice()
{
LoggingService.Info(GetType());
if (rulesEngineService.IsCustomerInvoicesEnabled())
{
CreateInvoiceViewModel viewModel = new CreateInvoiceViewModel();
IPublishedContent paymentsNode = settingsService.GetPaymentsNode();
PaymentSettingsModel settingsModel = new PaymentSettingsModel(paymentsNode);
viewModel.ShowIncludePaymentLink = settingsModel.CustomerPaymentsEnabled;
return(PartialView("Partials/Spectrum/Invoices/CreateInvoice", viewModel));
}
return(default(PartialViewResult));
}
/// <inheritdoc />
public bool CheckPaymentCombination(PaymentSettingsModel paymentMethod)
{
bool result;
using (var connection = new SqlConnection(Constants.ConnectorDatabase))
{
const string commandText = @"Select PaymentMethodId from PaymentMethod where EcommercePaymentMethod=@MagentoPaymentMethod AND ERPPaymentType=@ERPPaymentType AND PaymentMethodId<>@Id";
using (var command = new SqlCommand(commandText, connection))
{
connection.Open();
command.Parameters.AddWithValue("@MagentoPaymentMethod", paymentMethod.MagentoPaymentName);
command.Parameters.AddWithValue("@ERPPaymentType", paymentMethod.GpPaymentId);
command.Parameters.AddWithValue("@Id", paymentMethod.Id);
using (SqlDataReader dataReader = command.ExecuteReader())
{
result = dataReader.Read();
}
connection.Close();
}
}
return(result);
}
/// <inheritdoc />
/// <summary>
/// Makes the payment.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="viewModel">The view model.</param>
/// <returns>Payment Id</returns>
public Result <Transaction> MakePayment(
PaymentSettingsModel model,
MakePaymentViewModel viewModel)
{
TransactionRequest request = new TransactionRequest
{
Amount = viewModel.Amount,
PaymentMethodNonce = viewModel.Nonce,
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true
}
};
Result <Transaction> result = GetGateway(model).Transaction.Sale(request);
if (result.IsSuccess() &&
result.Target != null)
{
return(result);
}
return(null);
}
/// <inheritdoc />
/// <summary>
/// Gets the authentication token.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public string GetAuthToken(PaymentSettingsModel model)
{
return(braintreeService.GetAuthToken(model));
}
/// <inheritdoc />
/// <summary>
/// Gets the transactions.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public ResourceCollection <Transaction> GetBraintreeTransactions(PaymentSettingsModel model)
{
return(braintreeService.GetTransactions(model));
}
/// <inheritdoc />
/// <summary>
/// Gets the transaction.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="transactionId">The transaction identifier.</param>
/// <returns></returns>
public Transaction GetTransaction(
PaymentSettingsModel model,
string transactionId)
{
return(braintreeService.GetTransaction(model, transactionId));
}
/// <inheritdoc />
/// <summary>
/// Gets the token.
/// </summary>
/// <param name="model">The model.</param>
/// <returns>
/// The token.
/// </returns>
public string GetAuthToken(PaymentSettingsModel model)
{
return(GetGateway(model).ClientToken.generate());
}
private static bool IsDataValid(PaymentSettingsModel paymentSettingsModel)
{
//TODO Need to valid data with Magento & GP
return(true);
}
/// <inheritdoc />
/// <summary>
/// Gets the transactions.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public ResourceCollection <Transaction> GetTransactions(PaymentSettingsModel model)
{
TransactionSearchRequest request = new TransactionSearchRequest();
return(GetGateway(model).Transaction.Search(request));
}
public static PaymentSettings ToEntity(this PaymentSettingsModel model, PaymentSettings destination)
{
return(model.MapTo(destination));
}
/// <inheritdoc />
/// <summary>
/// Gets the transaction.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="transactionId">The transaction identifier.</param>
/// <returns></returns>
public Transaction GetTransaction(
PaymentSettingsModel model,
string transactionId)
{
return(GetGateway(model).Transaction.Find(transactionId));
}
/// <inheritdoc />
/// <summary>
/// Determines whether [is customer payments enabled].
/// </summary>
public bool IsCustomerPaymentsEnabled()
{
PaymentSettingsModel model = GetPaymentsSettingsModel();
return(model != null && model.PaymentsEnabled);
}
/// <summary>
/// Handles the payment.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <param name="publishedContent">Content of the published.</param>
/// <param name="viewModel">The view model.</param>
/// <param name="currentUser">The current user.</param>
/// <returns></returns>
/// <inheritdoc />
public string MakePayment(
UmbracoContext umbracoContext,
IPublishedContent publishedContent,
MakePaymentViewModel viewModel,
string currentUser)
{
loggingService.Info(GetType());
PageModel pageModel = new PageModel(publishedContent);
if (string.IsNullOrEmpty(pageModel.NextPageUrl))
{
throw new ApplicationException("Next Page Url Not Set");
}
if (string.IsNullOrEmpty(pageModel.ErrorPageUrl))
{
throw new ApplicationException("Error Page Url Not Set");
}
PaymentSettingsModel paymentSettingsModel = paymentProvider.GetPaymentSettingsModel(umbracoContext);
if (paymentSettingsModel.Provider != Constants.PaymentProviders.Braintree)
{
//// we currently only support Braintree
throw new ApplicationException("Unsupported Payment Provider");
}
Result <Transaction> transaction = paymentProvider.MakePayment(paymentSettingsModel, viewModel);
if (transaction != null)
{
//// at this point the payment has worked
//// so need to be careful from here as to what we raise as errors etc.
//// make sure we clear the cache!
transactionsRepository.SetKey(umbracoContext);
transactionsRepository.Clear();
string paymentId = transaction.Target.Id;
loggingService.Info(GetType(), "Payment Succesful Id=" + paymentId);
try
{
eventPublisher.Publish(new TransactionMadeMessage(
umbracoContext,
transaction.Target,
viewModel,
currentUser,
pageModel.EmailTemplateName,
paymentSettingsModel.Provider,
paymentSettingsModel.Environment));
}
catch (Exception exception)
{
loggingService.Error(GetType(), "Publish of payment Failed", exception);
}
return(pageModel.NextPageUrl);
}
loggingService.Info(GetType(), "Payment Failed");
return(pageModel.ErrorPageUrl);
}
/// <inheritdoc />
/// <summary>
/// Gets the authentication token.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <returns></returns>
public string GetAuthToken(UmbracoContext umbracoContext)
{
PaymentSettingsModel model = paymentProvider.GetPaymentSettingsModel(umbracoContext);
return(model != null?paymentProvider.GetAuthToken(model) : string.Empty);
}
/// <inheritdoc />
/// <summary>
/// Makes the payment.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="viewModel">The view model.</param>
/// <returns>Payment Id</returns>
public Result <Transaction> MakePayment(
PaymentSettingsModel model,
MakePaymentViewModel viewModel)
{
return(braintreeService.MakePayment(model, viewModel));
}
/// <inheritdoc />
/// <summary>
/// Gets the environment.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <returns></returns>
public string GetEnvironment(UmbracoContext umbracoContext)
{
PaymentSettingsModel model = paymentProvider.GetPaymentSettingsModel(umbracoContext);
return(model?.Environment);
}
