public void ProcessResponseSuccessful()
{
var random = new Random();
var payment = new PayPalPaymentConfirmation()
{
Application = new Application()
{
Identifier = Guid.NewGuid(),
},
User = new User()
{
Identifier = Guid.NewGuid(),
},
TransactionId = random.Next().ToString(),
Response = PayPalResponseValue,
};
payment = PaymentCore.ProcessResponse(payment);
var table = new AzureTable <PayPalPaymentConfirmationRow>(ServerConfiguration.Default);
var row = table.QueryByPartition(payment.Application.Identifier.ToString()).First();
Assert.AreEqual <string>(payment.FirstName, row.FirstName);
Assert.AreEqual <string>(payment.LastName, row.LastName);
Assert.AreEqual <string>(payment.PaymentStatusFromPayPal, row.PaymentStatusFromPayPal);
Assert.AreEqual <string>(payment.Email, row.Email);
Assert.AreEqual <string>(payment.Gross, row.Gross);
Assert.AreEqual <string>(payment.CurrencyCode, row.CurrencyCode);
Assert.AreEqual <string>(payment.Custom, row.Custom);
Assert.IsTrue(payment.Successful);
Assert.IsTrue(row.Successful);
}
public bool ValidatePurchase(PayPalPaymentConfirmation payment)
{
Contract.Requires <ArgumentNullException>(null != payment);
Contract.Requires <ArgumentException>(!string.IsNullOrWhiteSpace(payment.TransactionId));
payment.Successful = false;
var url = ServerConfiguration.PayPalPaymentDataTransferUrl;
var query = "cmd=_notify-synch&tx={0}&at={1}".FormatWithCulture(payment.TransactionId, ServerConfiguration.PayPalPaymentDataTransfer);
var req = (HttpWebRequest)WebRequest.Create(url);
// Set values for the request back
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";
req.ContentLength = query.Length;
// Write the request back IPN strings
using (var output = new StreamWriter(req.GetRequestStream(), System.Text.Encoding.ASCII))
{
output.Write(query);
// Do the request to PayPal and get the response
var input = new StreamReader(req.GetResponse().GetResponseStream());
payment.Response = input.ReadToEnd();
payment = PaymentCore.ProcessResponse(payment);
}
return(payment.Successful);
}
public static PayPalPaymentConfirmation ProcessResponse(PayPalPaymentConfirmation payment)
{
Contract.Requires <ArgumentNullException>(null != payment);
if (string.IsNullOrWhiteSpace(payment.Response))
{
log.Log("Empty response returned from PayPal.");
}
else if (payment.Response.StartsWith("SUCCESS", StringComparison.InvariantCultureIgnoreCase))
{
payment.Successful = true;
payment = PaymentCore.ProcessSuccessfulResponse(payment);
var preferenceTable = new AzureTable <UserPreferenceRow>(ServerConfiguration.Default);
var preference = preferenceTable.QueryBy(payment.Application.Identifier.ToString(), payment.User.Identifier.ToString());
preference = preference ?? new UserPreferenceRow(payment.Application.Identifier, payment.User.Identifier);
preference.MaxiumAllowedApplications = preference.MaxiumAllowedApplications.HasValue ? preference.MaxiumAllowedApplications + 1 : 1;
preferenceTable.AddOrUpdateEntity(preference);
}
else
{
payment.Successful = false;
log.Log("Error Accepting payment response.");
}
var table = new AzureTable <PayPalPaymentConfirmationRow>(ServerConfiguration.Default);
table.AddEntity(payment.Convert());
return(payment);
}
public void ProcessResponseInvalid()
{
var random = new Random();
var payment = new PayPalPaymentConfirmation()
{
Application = new Application()
{
Identifier = Guid.NewGuid(),
},
User = new User()
{
Identifier = Guid.NewGuid(),
},
TransactionId = random.Next().ToString(),
Response = StringHelper.ValidString(),
};
payment = PaymentCore.ProcessResponse(payment);
var table = new AzureTable <PayPalPaymentConfirmationRow>(ServerConfiguration.Default);
var row = table.QueryByPartition(payment.Application.Identifier.ToString()).First();
Assert.IsFalse(payment.Successful);
Assert.IsFalse(row.Successful);
}
public void App()
{
var payment = new PayPalPaymentConfirmation();
var data = Application.Current;
payment.Application = data;
Assert.AreEqual <Application>(data, payment.Application);
}
public void ResidenceCountry()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.ResidenceCountry = data;
Assert.AreEqual <string>(data, payment.ResidenceCountry);
}
public void ItemNumber()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.ItemNumber = data;
Assert.AreEqual <string>(data, payment.ItemNumber);
}
public void Successful()
{
var payment = new PayPalPaymentConfirmation();
Assert.IsFalse(payment.Successful);
payment.Successful = true;
Assert.IsTrue(payment.Successful);
}
public void AddressState()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.AddressState = data;
Assert.AreEqual <string>(data, payment.AddressState);
}
public void ReceiverEmail()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.ReceiverEmail = data;
Assert.AreEqual <string>(data, payment.ReceiverEmail);
}
public void Quantity()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.Quantity = data;
Assert.AreEqual <string>(data, payment.Quantity);
}
public void TransactionId()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.TransactionId = data;
Assert.AreEqual <string>(data, payment.TransactionId);
}
public void ShippingMethod()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.ShippingMethod = data;
Assert.AreEqual <string>(data, payment.ShippingMethod);
}
public void User()
{
var payment = new PayPalPaymentConfirmation();
var data = new User();
payment.User = data;
Assert.AreEqual <User>(data, payment.User);
}
public void CurrencyCode()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.CurrencyCode = data;
Assert.AreEqual <string>(data, payment.CurrencyCode);
}
public void Response()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.Response = data;
Assert.AreEqual <string>(data, payment.Response);
}
public void Amount()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.Amount = data;
Assert.AreEqual <string>(data, payment.Amount);
}
public void PaymentStatus()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.PaymentStatus = data;
Assert.AreEqual <string>(data, payment.PaymentStatus);
}
public void ProtectionEligibility()
{
var payment = new PayPalPaymentConfirmation();
var data = StringHelper.ValidString();
payment.ProtectionEligibility = data;
Assert.AreEqual <string>(data, payment.ProtectionEligibility);
}
public void ProcessSuccessfulResponseInvalid()
{
var payment = new PayPalPaymentConfirmation()
{
Response = StringHelper.NullEmptyWhiteSpace(),
};
PaymentCore.ProcessSuccessfulResponse(payment);
}
public void Valid()
{
var payment = new PayPalPaymentConfirmation()
{
TransactionId = StringHelper.ValidString(),
};
var validator = new Validator <PayPalPaymentConfirmation>();
Assert.IsTrue(validator.IsValid(payment));
}
public void InvalidTransactionIdInvalid()
{
var payment = new PayPalPaymentConfirmation()
{
TransactionId = StringHelper.NullEmptyWhiteSpace(),
};
var validator = new Validator <PayPalPaymentConfirmation>();
Assert.IsFalse(validator.IsValid(payment));
}
public void ValidatePurchaseTransactionIdInvalid()
{
var payment = new PayPalPaymentConfirmation()
{
TransactionId = StringHelper.NullEmptyWhiteSpace(),
};
var core = new PaymentCore();
core.ValidatePurchase(payment);
}
public void ProcessSuccessfulResponseFull()
{
var payment = new PayPalPaymentConfirmation()
{
Response = PayPalResponseFull,
};
payment = PaymentCore.ProcessSuccessfulResponse(payment);
Assert.AreEqual <string>("0.01", payment.MCGross);
Assert.AreEqual <string>("Eligible", payment.ProtectionEligibility);
Assert.AreEqual <string>("confirmed", payment.AddressStatus);
Assert.AreEqual <string>("LHXGFUDRHPPEL", payment.PayerId);
Assert.AreEqual <string>("0.00", payment.Tax);
Assert.AreEqual <string>("546+beatty%0D%0A309", payment.AddressStreet);
Assert.AreEqual <string>("18%3A49%3A02+Jan+30%2C+2012+PST", payment.PaymentDate);
Assert.AreEqual <string>("Completed", payment.PaymentStatus);
Assert.AreEqual <string>("windows-1252", payment.Charset);
Assert.AreEqual <string>("v6b2l3", payment.AddressZip);
Assert.AreEqual <string>("Jeffrey", payment.FirstName);
Assert.AreEqual <string>("0.01", payment.MCFee);
Assert.AreEqual <string>("CA", payment.AddressCountryCode);
Assert.AreEqual <string>("Jeffrey+King", payment.AddressName);
Assert.AreEqual <string>(null, payment.PaymentFee);
Assert.AreEqual <string>(null, payment.Custom);
Assert.AreEqual <string>(null, payment.Gross);
Assert.AreEqual <string>("unverified", payment.PayerStatus);
Assert.AreEqual <string>("1", payment.Quantity);
Assert.AreEqual <string>("jef%40agilebusinesscloud.com", payment.Business);
Assert.AreEqual <string>("Canada", payment.AddressCountry);
Assert.AreEqual <string>("vancouver", payment.AddressCity);
Assert.AreEqual <string>("jamieking80%40gmail.com", payment.Email);
Assert.AreEqual <string>("5JW20211VT0352427", payment.TXNId);
Assert.AreEqual <string>("instant", payment.PaymentType);
Assert.AreEqual <string>("41305525", payment.BTNId);
Assert.AreEqual <string>("King", payment.LastName);
Assert.AreEqual <string>("British+Columbia", payment.AddressState);
Assert.AreEqual <string>("jef%40agilebusinesscloud.com", payment.ReceiverEmail);
Assert.AreEqual <string>("0.00", payment.ShippingDiscount);
Assert.AreEqual <string>("0.00", payment.InsuranceAmount);
Assert.AreEqual <string>("6ZLN7RZS446C2", payment.ReceiverId);
Assert.AreEqual <string>("web_accept", payment.TXNType);
Assert.AreEqual <string>("One+Cent", payment.ItemName);
Assert.AreEqual <string>("0.00", payment.Discount);
Assert.AreEqual <string>("CAD", payment.CurrencyCode);
Assert.AreEqual <string>("0002", payment.ItemNumber);
Assert.AreEqual <string>("CA", payment.ResidenceCountry);
Assert.AreEqual <string>("Default", payment.ShippingMethod);
Assert.AreEqual <string>("0.00", payment.HandlingAmount);
Assert.AreEqual <string>("One+Cent", payment.TransactionSubject);
Assert.AreEqual <string>("0.00", payment.Shipping);
}
public ActionResult PurchaseComplete(string tx, string st, string amt, string cc)
{
using (new PerformanceMonitor())
{
if (string.IsNullOrWhiteSpace(tx))
{
return(this.RedirectToAction("Index", "Home"));
}
else
{
var payment = new PayPalPaymentConfirmation()
{
TransactionId = tx,
PaymentStatus = st,
Amount = amt,
CurrencyCode = cc,
Application = Abc.Services.Contracts.Application.Current,
User = this.User.Identity.Data(),
};
try
{
ViewBag.CanCreateAnApplication = this.CanCreateAnApplication();
var validator = new Validator <PayPalPaymentConfirmation>();
if (!validator.IsValid(payment))
{
var messages = validator.AllMessages(payment);
log.Log(messages);
return(this.View(messages));
}
else
{
paymentCore.ValidatePurchase(payment);
ViewBag.CanCreateAnApplication = this.CanCreateAnApplication();
return(View(payment));
}
}
catch (Exception ex)
{
log.Log(ex, EventTypes.Error, (int)Fault.Unknown);
return(this.View(ex.Message));
}
}
}
}
public void ProcessSuccessfulResponse()
{
var payment = new PayPalPaymentConfirmation()
{
Response = PayPalResponseValue,
};
payment = PaymentCore.ProcessSuccessfulResponse(payment);
Assert.AreEqual <string>("Jane+Doe", payment.FirstName);
Assert.AreEqual <string>("Smith", payment.LastName);
Assert.AreEqual <string>("Completed", payment.PaymentStatus);
Assert.AreEqual <string>("*****@*****.**", payment.Email);
Assert.AreEqual <string>("3.99", payment.Gross);
Assert.AreEqual <string>("USD", payment.CurrencyCode);
Assert.AreEqual <string>("For+the+purchase+of+the+rare+book+Green+Eggs+%26+Ham", payment.Custom);
}
public void ProcessResponseSuccessfulApplicationAdded()
{
var random = new Random();
var payment = new PayPalPaymentConfirmation()
{
Application = new Application()
{
Identifier = Guid.NewGuid(),
},
User = new User()
{
Identifier = Guid.NewGuid(),
},
TransactionId = random.Next().ToString(),
Response = PayPalResponseValue,
};
payment = PaymentCore.ProcessResponse(payment);
var table = new AzureTable <UserPreferenceRow>(ServerConfiguration.Default);
var row = table.QueryBy(payment.Application.Identifier.ToString(), payment.User.Identifier.ToString());
Assert.AreEqual <int>(1, row.MaxiumAllowedApplications.Value);
}
public static PayPalPaymentConfirmation ProcessSuccessfulResponse(PayPalPaymentConfirmation payment)
{
Contract.Requires <ArgumentNullException>(null != payment);
Contract.Requires <ArgumentException>(!string.IsNullOrWhiteSpace(payment.Response));
foreach (Match match in RegexStatement.PayPalResponse.Matches(payment.Response))
{
var value = match.Groups["value"].Value;
switch (match.Groups["key"].Value)
{
case "first_name":
payment.FirstName = value;
continue;
case "last_name":
payment.LastName = value;
continue;
case "payment_status":
payment.PaymentStatus = value;
continue;
case "payer_email":
payment.Email = value;
continue;
case "payment_gross":
payment.Gross = value;
continue;
case "mc_currency":
payment.CurrencyCode = value;
continue;
case "custom":
payment.Custom = value;
continue;
case "mc_gross":
payment.MCGross = value;
continue;
case "protection_eligibility":
payment.ProtectionEligibility = value;
continue;
case "address_status":
payment.AddressStatus = value;
continue;
case "payer_id":
payment.PayerId = value;
continue;
case "tax":
payment.Tax = value;
continue;
case "address_street":
payment.AddressStreet = value;
continue;
case "payment_date":
payment.PaymentDate = value;
continue;
case "charset":
payment.Charset = value;
continue;
case "address_zip":
payment.AddressZip = value;
continue;
case "mc_fee":
payment.MCFee = value;
continue;
case "address_country_code":
payment.AddressCountryCode = value;
continue;
case "address_name":
payment.AddressName = value;
continue;
case "payer_status":
payment.PayerStatus = value;
continue;
case "business":
payment.Business = value;
continue;
case "address_country":
payment.AddressCountry = value;
continue;
case "address_city":
payment.AddressCity = value;
continue;
case "quantity":
payment.Quantity = value;
continue;
case "txn_id":
payment.TXNId = value;
continue;
case "payment_type":
payment.PaymentType = value;
continue;
case "btn_id":
payment.BTNId = value;
continue;
case "address_state":
payment.AddressState = value;
continue;
case "receiver_email":
payment.ReceiverEmail = value;
continue;
case "payment_fee":
payment.PaymentFee = value;
continue;
case "shipping_discount":
payment.ShippingDiscount = value;
continue;
case "insurance_amount":
payment.InsuranceAmount = value;
continue;
case "receiver_id":
payment.ReceiverId = value;
continue;
case "txn_type":
payment.TXNType = value;
continue;
case "item_name":
payment.ItemName = value;
continue;
case "discount":
payment.Discount = value;
continue;
case "item_number":
payment.ItemNumber = value;
continue;
case "residence_country":
payment.ResidenceCountry = value;
continue;
case "shipping_method":
payment.ShippingMethod = value;
continue;
case "handling_amount":
payment.HandlingAmount = value;
continue;
case "transaction_subject":
payment.TransactionSubject = value;
continue;
case "shipping":
payment.Shipping = value;
continue;
default:
log.Log("Unknown response from PayPal: '{0}'; '{1}'.".FormatWithCulture(match.Groups["key"].Value, value));
continue;
}
}
return(payment);
}
public void Convert()
{
var payment = new PayPalPaymentConfirmation()
{
Amount = StringHelper.ValidString(),
Application = Abc.Services.Contracts.Application.Current,
Currency = StringHelper.ValidString(),
CurrencyCode = StringHelper.ValidString(),
Custom = StringHelper.ValidString(),
Email = StringHelper.ValidString(),
FirstName = StringHelper.ValidString(),
Gross = StringHelper.ValidString(),
LastName = StringHelper.ValidString(),
PaymentStatus = StringHelper.ValidString(),
PaymentStatusFromPayPal = StringHelper.ValidString(),
Successful = false,
TransactionId = StringHelper.ValidString(),
Response = StringHelper.ValidString(),
MCGross = StringHelper.ValidString(),
ProtectionEligibility = StringHelper.ValidString(),
AddressStatus = StringHelper.ValidString(),
PayerId = StringHelper.ValidString(),
Tax = StringHelper.ValidString(),
AddressStreet = StringHelper.ValidString(),
PaymentDate = StringHelper.ValidString(),
Charset = StringHelper.ValidString(),
AddressZip = StringHelper.ValidString(),
MCFee = StringHelper.ValidString(),
AddressCountryCode = StringHelper.ValidString(),
AddressName = StringHelper.ValidString(),
PayerStatus = StringHelper.ValidString(),
Business = StringHelper.ValidString(),
AddressCountry = StringHelper.ValidString(),
Quantity = StringHelper.ValidString(),
TXNId = StringHelper.ValidString(),
PaymentType = StringHelper.ValidString(),
BTNId = StringHelper.ValidString(),
AddressState = StringHelper.ValidString(),
ReceiverEmail = StringHelper.ValidString(),
Shipping = StringHelper.ValidString(),
PaymentFee = StringHelper.ValidString(),
ShippingDiscount = StringHelper.ValidString(),
InsuranceAmount = StringHelper.ValidString(),
ReceiverId = StringHelper.ValidString(),
TXNType = StringHelper.ValidString(),
ItemName = StringHelper.ValidString(),
Discount = StringHelper.ValidString(),
ItemNumber = StringHelper.ValidString(),
ResidenceCountry = StringHelper.ValidString(),
ShippingMethod = StringHelper.ValidString(),
HandlingAmount = StringHelper.ValidString(),
TransactionSubject = StringHelper.ValidString(),
User = new User()
{
Identifier = Guid.NewGuid(),
},
};
var row = payment.Convert();
Assert.AreEqual <string>(payment.Amount, row.Amount);
Assert.AreEqual <string>(payment.Currency, row.Currency);
Assert.AreEqual <string>(payment.CurrencyCode, row.CurrencyCode);
Assert.AreEqual <string>(payment.Custom, row.Custom);
Assert.AreEqual <string>(payment.Email, row.Email);
Assert.AreEqual <string>(payment.FirstName, row.FirstName);
Assert.AreEqual <string>(payment.Gross, row.Gross);
Assert.AreEqual <string>(payment.LastName, row.LastName);
Assert.AreEqual <string>(payment.PaymentStatus, row.PaymentStatus);
Assert.AreEqual <string>(payment.PaymentStatusFromPayPal, row.PaymentStatusFromPayPal);
Assert.AreEqual <string>(payment.TransactionId, row.TransactionId);
Assert.AreEqual <string>(payment.Response, row.Response);
Assert.AreEqual <string>(payment.MCGross, row.MCGross);
Assert.AreEqual <string>(payment.ProtectionEligibility, row.ProtectionEligibility);
Assert.AreEqual <string>(payment.AddressStatus, row.AddressStatus);
Assert.AreEqual <string>(payment.PayerId, row.PayerId);
Assert.AreEqual <string>(payment.Tax, row.Tax);
Assert.AreEqual <string>(payment.AddressStreet, row.AddressStreet);
Assert.AreEqual <string>(payment.PaymentDate, row.PaymentDate);
Assert.AreEqual <string>(payment.Charset, row.Charset);
Assert.AreEqual <string>(payment.AddressZip, row.AddressZip);
Assert.AreEqual <string>(payment.MCFee, row.MCFee);
Assert.AreEqual <string>(payment.AddressCountryCode, row.AddressCountryCode);
Assert.AreEqual <string>(payment.AddressName, row.AddressName);
Assert.AreEqual <string>(payment.PayerStatus, row.PayerStatus);
Assert.AreEqual <string>(payment.Business, row.Business);
Assert.AreEqual <string>(payment.AddressCountry, row.AddressCountry);
Assert.AreEqual <string>(payment.Quantity, row.Quantity);
Assert.AreEqual <string>(payment.TXNId, row.TXNId);
Assert.AreEqual <string>(payment.PaymentType, row.PaymentType);
Assert.AreEqual <string>(payment.BTNId, row.BTNId);
Assert.AreEqual <string>(payment.AddressState, row.AddressState);
Assert.AreEqual <string>(payment.ReceiverEmail, row.ReceiverEmail);
Assert.AreEqual <string>(payment.Shipping, row.Shipping);
Assert.AreEqual <string>(payment.PaymentFee, row.PaymentFee);
Assert.AreEqual <string>(payment.ShippingDiscount, row.ShippingDiscount);
Assert.AreEqual <string>(payment.InsuranceAmount, row.InsuranceAmount);
Assert.AreEqual <string>(payment.ReceiverId, row.ReceiverId);
Assert.AreEqual <string>(payment.TXNType, row.TXNType);
Assert.AreEqual <string>(payment.ItemName, row.ItemName);
Assert.AreEqual <string>(payment.Discount, row.Discount);
Assert.AreEqual <string>(payment.ItemNumber, row.ItemNumber);
Assert.AreEqual <string>(payment.ResidenceCountry, row.ResidenceCountry);
Assert.AreEqual <string>(payment.ShippingMethod, row.ShippingMethod);
Assert.AreEqual <string>(payment.HandlingAmount, row.HandlingAmount);
Assert.AreEqual <string>(payment.TransactionSubject, row.TransactionSubject);
Assert.AreEqual <bool>(payment.Successful, row.Successful);
Assert.AreEqual <Guid>(payment.User.Identifier, row.UserId);
Assert.AreEqual <Guid>(payment.Application.Identifier, row.ApplicationId);
}
