Liam Cavanagh's Blog

I talked previously about why I chose to use Stripe with Cotega to allow me to accept credit card payments. In it I talked about how excellent their support was and how easy it was to take their samples and implement it into my service. I am still extremely pleased with my choice of using Stripe and I have no intention of moving away from it. I have however always wanted to investigate using PayPal as an alternative payment option because occasionally International customers will have credit cards that are not acceptable by Stripe or they just plain prefer to use PayPal. For this reason, I decided to take some time and understand what it would take to implement PayPal into my MVC based service.
Unfortunately, I did not find this to be quite as simple to implement as it was with Stripe. Although PayPal has a number of examples, none of the ones I could find were targeted for MVC and there did not seem to be any good tutorials on this subject to get me started. I hope this blog post will help anyone thinking to implement PayPal with MVC. I do want to caveat this with the fact that I am far from a PayPal expert and I do not claim that this is the “PayPal preferred” way to implement this other than to say that I have tried to convert other examples as best I can and it has worked well for me so far. If you have any comments or suggestions, I am very interested to hear your feedback.

Step 1 – Choosing PayPal IPN vs. PDT vs. Express

One of the first things I needed to decide on was the appropriate “PayPal Responder” to use. A responder is like a callback that PayPal does when the transaction is complete (successful, unsuccessful, invalid, etc.). It can also return custom variables that you set when the user first clicks the “Pay Now” button.
Since we are using MVC, we first need to create a View that initiates the transaction to PayPal. This is where the user clicks the “Pay Now” button and is re-directed to PayPal where they enter their credit card or PayPal account information. After this is complete, PayPal can initiate a responder which calls your service with the results of the transaction. The flow of the process looks something like this:

You really only need to use a responder in the cases where you need to continue with some process after that transaction completes. For example, in my case I want to be able to enable a user subscription once the transaction completes. If you are simply accepting payments, there may be no need to go to the complexity of using responders.
There is lots of information on responders but I found that Instant Payment Notifications (IPN) was the best choice for me, and probably yourself as well if you simply want a callback from PayPal to your MVC controllers.

Step 2 – Implementing the View and Form

The next step is to create a payment page using a View where the user can choose to start the PayPal process. Here is an example of a HTML form that I used.

@*
*@



User ID

        Pay with PayPal
 

There are a couple of things you should notice in this form:
• The commented out section allows me to either submit the payment request to the PayPal sandbox (test) environment or to the actual live PayPal url.
• Notice all the input type=”text” types. These are values that are returned to my controller after the transaction is complete. When I load the page, I set the “device-id” input type to a custom value that I want PayPal to return when the transaction completes. I can use this value to update the user’s status in my SQL database (assuming the transaction is successful).
• The “return” input type URL defines where the user will be redirected to after the transaction is complete. It is important that you don’t rely on this as a method for completing a transaction because most users will never click on this link. Don’t forget to create this page.
• The notify_url input is the IPN URL that PayPal will call after the transaction completes.
• Remember to associate the business input type email address with the PayPal address you used for your sandbox or live account
• There are a lot more custom values you can use and learn more about here.

Step 3 – Creating an IPN Controller in MVC

Next we will want to create a new ActionResult controller that will receive the responder request from PayPal after the transaction completes. I want to give credit to this page where I was able to leverage a lot of code for this controller. You should also remember to actually create an IPN view (IPN.cshtml) page because PayPal will continue to call this controller until it gets a successful page returned.

public ActionResult IPN()
{
// Receive IPN request from PayPal and parse all the variables returned
var formVals = new Dictionary();
formVals.Add("cmd", "_notify-validate");

// if you want to use the PayPal sandbox change this from false to true
string response = GetPayPalResponse(formVals, false);

if (response == "VERIFIED")
{
string transactionID = Request["txn_id"];
string sAmountPaid = Request["mc_gross"];
string deviceID = Request["custom"];

//validate the order
Decimal amountPaid = 0;
Decimal.TryParse(sAmountPaid, out amountPaid);

if (sAmountPaid == "2.95")
{
// take the information returned and store this into a subscription table
// this is where you would update your database with the details of the tran

return View();

}
else
{
// let fail - this is the IPN so there is no viewer
// you may want to log something here
}
}

return View();
}

string GetPayPalResponse(DictionaryformVals, bool useSandbox)
{

// Parse the variables
// Choose whether to use sandbox or live environment
string paypalUrl = useSandbox ? "https://www.sandbox.paypal.com/cgi-bin/webscr"
: "https://www.paypal.com/cgi-bin/webscr";

HttpWebRequest req = (HttpWebRequest)WebRequest.Create(paypalUrl);

// Set values for the request back
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";

byte[] param = Request.BinaryRead(Request.ContentLength);
string strRequest = Encoding.ASCII.GetString(param);

StringBuilder sb = new StringBuilder();
sb.Append(strRequest);

foreach (string key in formVals.Keys)
{
sb.AppendFormat("&{0}={1}", key, formVals[key]);
}
strRequest += sb.ToString();
req.ContentLength = strRequest.Length;

//for proxy
//WebProxy proxy = new WebProxy(new Uri("http://urlort#");
//req.Proxy = proxy;
//Send the request to PayPal and get the response
string response = "";
using (StreamWriter streamOut = new StreamWriter(req.GetRequestStream(), System.Text.Encoding.ASCII))
{

streamOut.Write(strRequest);
streamOut.Close();
using (StreamReader streamIn = new StreamReader(req.GetResponse().GetResponseStream()))
{
response = streamIn.ReadToEnd();
}
}

return response;
}

Step 4 – Enabling Sandbox and IPN

I highly recommend that you first test this with the PayPal sandbox. You need to sign up separately for a sandbox account from your live PayPal account from the developer page here.
For sandbox accounts, you do not need to enable IPN, but for live accounts you do. Once you are ready to switch to live, log in to your PayPal account and go to Profile | More Options | My Selling Tools | Choose Update for “Instant Payment Notifications” and then enable IPN and set the URL that you wish PayPal to call (which is the IPN controller we created above).

Summary

At this point you should be ready to go. One of the real pains of this system is that there is no easy way to debug your IPN controller if you are running the MVC app on a remote machine that does not have Visual Studio installed. For this reason, I chose to log each of the steps to a “Log” table that I created in my database. That way I could log all the variables that PayPal returned and still get an idea of what was happening or determine if there were any issues.
I am still testing this and have not yet implemented this into my Cotega service for monitoring SQL Azure databases. For now, if you would like to see this working I am using it in a Windows Phone Baby Monitor app that I wrote.
If you have any suggestions or problems I look forward to hearing from you.

I am the founder of a startup called Cotega and also a Microsoft employee within the SQL Azure group where I work as a Program Manager. This is a series of posts where I talk about my experience building a startup outside of Microsoft. I do my best to take my Microsoft hat off and tell both the good parts and the bad parts I experienced using Azure.

A key feature of the Cotega monitoring service is the ability to send email notifications when there are issues with a user’s database. The Windows Azure worker role executes a specified set of jobs against a users database and if there are issues such as connection drops or query performance degradation, then the service will send a notification to the administrator.

Currently there are no SMTP servers available within Windows Azure to allow me to send email notifications. Luckily, there are a huge number of third party email services that work really well with Windows Azure and are extremely cheap.

Sending Email Using Free Email Services

To get started, I first built a prototype that would send notifications from my worker roles. To do this I started with Hotmail as the SMTP server. The code to do this is pretty simple and there are a number of good examples on how to do this, such as here and here. These services worked pretty well.  Ultimately I decided not to move forward with them given the sending restrictions that free email services like Hotmail, Office365, GMail, Yahoo mail have. For example, many of them limit the number of senders you can send to within an hour or limit the total number of emails you could send over a specified period of time. I suspected it would be a long time before the Cotega service reached these limits but I preferred to avoid them if possible.

3rd Party Paid Email Services

I really did not want to host my own SMTP service in Windows Azure.  In fact, I have heard (but not confirmed) that sending emails using your own SMTP servers can have issues where emails will frequently be bounced back or will be tagged inaccurately as spam.  Many third party email services have techniques to minimize this which was very attractive to me.  So for these reasons, I started researching other third party email services. Some of the most promising ones that I found were Elastic Email, SendGrid and Amazon SES (Simple Email Service). Each of these are paid services.  I ended up using Amazon SES primarily because I wanted to get an opportunity to learn more about Amazon’s services and their cost was attractive at $0.10 per thousand email messages. The other interesting thing about Amazon SES is that they start you out at a limited number of outbound emails. This limit is quite high at 10,000 over 24 hours and increases as Amazon learns to trust that you are not sending spam. Plus you can request an increase if needed. The dashboard for monitoring your email traffic is pretty nice and allows you to visually see the number of delivered, rejected, bounced and complaints emails.

After setting up my Amazon SES account, I needed to install the Amazon SDK and include the Amazon.SimpleEmail.Model namespace which would be deployed a a reference to the worker role. Here is a snippet of code that I used which is based on a sample Amazon provides. If you use it, remember to update the [CODE] sections with your SES keys:

public static Boolean SendEmailSES(String From, String To, String Subject, String Text = null, String HTML = null, String emailReplyTo = null, String returnPath = null)
{
    if (Text != null && HTML != null)
    {
        String from = From;

        List to
            = To
            .Replace(", ", ",")
            .Split(',')
            .ToList();

        Destination destination = new Destination();
        destination.WithToAddresses(to);
        //destination.WithCcAddresses(cc);
        //destination.WithBccAddresses(bcc);

        Content subject = new Content();
        subject.WithCharset("UTF-8");
        subject.WithData(Subject);

        Content html = new Content();
        html.WithCharset("UTF-8");
        html.WithData(HTML);

        Content text = new Content();
        text.WithCharset("UTF-8");
        text.WithData(Text);

        Body body = new Body();
        body.WithHtml(html);
        body.WithText(text);

        Message message = new Message();
        message.WithBody(body);
        message.WithSubject(subject);

        AmazonSimpleEmailService ses = AWSClientFactory.CreateAmazonSimpleEmailServiceClient("[CODE]", "[CODE]");

        SendEmailRequest request = new SendEmailRequest();
        request.WithDestination(destination);
        request.WithMessage(message);
        request.WithSource(from);

        if (emailReplyTo != null)
        {
            List replyto
                = emailReplyTo
                .Replace(", ", ",")
                .Split(',')
                .ToList();

            request.WithReplyToAddresses(replyto);
        }

        if (returnPath != null)
        {
            request.WithReturnPath(returnPath);
        }

        try
        {
            SendEmailResponse response = ses.SendEmail(request);
            SendEmailResult result = response.SendEmailResult;

            Console.WriteLine("Email sent.");
            Console.WriteLine(String.Format("Message ID: {0}",
                result.MessageId));

            return true;
        }
        catch (Exception ex)
        {
            Helper.LogException("Worker - SendEmailSES", ex.Message.ToString());
            return false;
        }
    }

    Console.WriteLine("Specify Text and/or HTML for the email body!");

    return false;
}