public T ProcessRecurring <T>(RecurringBuilder <T> builder) where T : class
{
return(new RecurringRequest <T>(Credentials, ServiceUrl, Timeout)
.WithRequestLogger(RequestLogger)
.WithWebProxy(WebProxy)
.Execute(builder));
}
public T ProcessRecurring <T>(RecurringBuilder <T> builder) where T : class
{
var request = new JsonDoc();
if (builder.TransactionType == TransactionType.Create || builder.TransactionType == TransactionType.Edit)
{
if (builder.Entity is Customer)
{
BuildCustomer(request, builder.Entity as Customer);
}
else if (builder.Entity is RecurringPaymentMethod)
{
BuildPaymentMethod(request, builder.Entity as RecurringPaymentMethod, builder.TransactionType);
}
else if (builder.Entity is Schedule)
{
BuildSchedule(request, builder.Entity as Schedule, builder.TransactionType);
}
}
else if (builder.TransactionType == TransactionType.Search)
{
foreach (var entry in builder.SearchCriteria)
{
request.Set(entry.Key, entry.Value);
}
}
var response = DoTransaction(MapMethod(builder.TransactionType), MapUrl(builder), request.ToString());
return(MapResponse <T>(response));
}
private TResult MapRecurringResponse <TResult>(string rawResponse, RecurringBuilder <TResult> builder) where TResult : class
{
var root = new ElementTree(rawResponse).Get("response");
// check response
CheckResponse(root);
return(builder.Entity as TResult);
}
public static T Get <T>(string key, string configName = "default") where T : class, IRecurringEntity
{
var entity = Activator.CreateInstance <T>() as IRecurringEntity;
entity.Key = key;
var response = new RecurringBuilder <T>(TransactionType.Fetch, entity).Execute(configName);
return(response as T);
}
internal T Execute(RecurringBuilder <T> builder)
{
if (builder.Entity is Customer customer)
{
return(CustomerRequest(customer, builder.TransactionType));
}
else if (builder.Entity is RecurringPaymentMethod recurringPaymentMethod)
{
return(CustomerAccountRequest(recurringPaymentMethod, builder.TransactionType));
}
else
{
throw new UnsupportedTransactionException();
}
}
private string MapRecurringRequestType <T>(RecurringBuilder <T> builder) where T : class
{
var entity = builder.Entity;
switch (builder.TransactionType)
{
case TransactionType.Create:
if (entity is Customer)
{
return("payer-new");
}
else if (entity is IPaymentMethod)
{
return("card-new");
}
throw new UnsupportedTransactionException();
case TransactionType.Edit:
if (entity is Customer)
{
return("payer-edit");
}
else if (entity is IPaymentMethod)
{
return("card-update-card");
}
throw new UnsupportedTransactionException();
case TransactionType.Delete:
if (entity is RecurringPaymentMethod)
{
return("card-cancel-card");
}
throw new UnsupportedTransactionException();
default:
throw new UnsupportedTransactionException();
}
}
private string MapUrl <T>(RecurringBuilder <T> builder) where T : class
{
var suffix = string.Empty;
if (builder.TransactionType == TransactionType.Fetch ||
builder.TransactionType == TransactionType.Delete ||
builder.TransactionType == TransactionType.Edit)
{
suffix = "/" + builder.Entity.Key;
}
var type = Activator.CreateInstance <T>();
if (type is Customer || type is IEnumerable <Customer> )
{
return(string.Format("{0}{1}", (builder.TransactionType == TransactionType.Search) ? "searchCustomers" : "customers", suffix));
}
else if (type is RecurringPaymentMethod || type is IEnumerable <RecurringPaymentMethod> )
{
string paymentMethod = string.Empty;
if (builder.TransactionType == TransactionType.Create)
{
paymentMethod = ((builder.Entity as RecurringPaymentMethod).PaymentMethod is Credit) ? "CreditCard" : "ACH";
}
else if (builder.TransactionType == TransactionType.Edit)
{
paymentMethod = (builder.Entity as RecurringPaymentMethod).PaymentType.Replace(" ", "");
}
return(string.Format("{0}{1}{2}", (builder.TransactionType == TransactionType.Search) ? "searchPaymentMethods" : "paymentMethods", paymentMethod, suffix));
}
else if (type is Schedule || type is IEnumerable <Schedule> )
{
return(string.Format("{0}{1}", (builder.TransactionType == TransactionType.Search) ? "searchSchedules" : "schedules", suffix));
}
throw new UnsupportedTransactionException();
}
public static T Create <T>(T entity, string configName = "default") where T : class, IRecurringEntity
{
var response = new RecurringBuilder <T>(TransactionType.Create, entity).Execute(configName);
return(response as T);
}
public TResult ProcessRecurring <TResult>(RecurringBuilder <TResult> builder) where TResult : class
{
var et = new ElementTree();
string timestamp = GenerationUtils.GenerateTimestamp();
string orderId = builder.OrderId ?? GenerationUtils.GenerateOrderId();
// Build Request
var request = et.Element("request")
.Set("type", MapRecurringRequestType(builder))
.Set("timestamp", timestamp);
et.SubElement(request, "merchantid").Text(MerchantId);
et.SubElement(request, "account", AccountId);
et.SubElement(request, "orderid", orderId);
if (builder.TransactionType == TransactionType.Create || builder.TransactionType == TransactionType.Edit)
{
if (builder.Entity is Customer)
{
var customer = builder.Entity as Customer;
request.Append(BuildCustomer(et, customer));
et.SubElement(request, "sha1hash").Text(GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, null, null, customer.Key));
}
else if (builder.Entity is RecurringPaymentMethod)
{
var payment = builder.Entity as RecurringPaymentMethod;
var cardElement = et.SubElement(request, "card");
et.SubElement(cardElement, "ref").Text(payment.Key ?? payment.Id);
et.SubElement(cardElement, "payerref").Text(payment.CustomerKey);
if (payment.PaymentMethod != null)
{
var card = payment.PaymentMethod as CreditCardData;
string expiry = card.ShortExpiry;
et.SubElement(cardElement, "number").Text(card.Number);
et.SubElement(cardElement, "expdate").Text(expiry);
et.SubElement(cardElement, "chname").Text(card.CardHolderName);
et.SubElement(cardElement, "type").Text(card.CardType);
string sha1hash = string.Empty;
if (builder.TransactionType == TransactionType.Create)
{
sha1hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, null, null, payment.CustomerKey, card.CardHolderName, card.Number);
}
else
{
sha1hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, payment.CustomerKey, payment.Key ?? payment.Id, expiry, card.Number);
}
et.SubElement(request, "sha1hash").Text(sha1hash);
}
}
}
else if (builder.TransactionType == TransactionType.Delete)
{
if (builder.Entity is RecurringPaymentMethod)
{
var payment = builder.Entity as RecurringPaymentMethod;
var cardElement = et.SubElement(request, "card");
et.SubElement(cardElement, "ref").Text(payment.Key ?? payment.Id);
et.SubElement(cardElement, "payerref").Text(payment.CustomerKey);
string sha1hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, payment.CustomerKey, payment.Key ?? payment.Id);
et.SubElement(request, "sha1hash").Text(sha1hash);
}
}
var response = DoTransaction(et.ToString(request));
return(MapRecurringResponse <TResult>(response, builder));
}
public static T Create <T>(T entity) where T : class, IRecurringEntity
{
var response = new RecurringBuilder <T>(TransactionType.Create, entity).Execute();
return(response as T);
}
public static T Delete <T>(T entity, bool force = false) where T : class, IRecurringEntity
{
var response = new RecurringBuilder <T>(TransactionType.Delete, entity).Execute();
return(response as T);
}
