Reader Level:
ARTICLE

SMS Messaging Framework Using TWILIO API

Posted by Sachin Pachori Articles | WCF with C# February 14, 2013
The article is about creating the SMS messaging framework to allow users to send a SMS message to their application subscribers using the Twilio REST API.
  • 0
  • 0
  • 6378

Introduction

The article is about creating the SMS messaging framework to allow users to send a SMS message to their application subscribers using the Twilio REST API. It provides a lot of boilerplate code for someone to quickly get the task done.

Background
 
I was assigned a task to develop a SMS messaging framework using the TWILIO API. I decided to write this article to help others to use the code to save their time.

Prerequisites
 
This article requires knowledge of VS 2010, WCF REST Service template and MSMQ.

Let us start developing the SMS inbound and outbound messaging framework using the TWILIO API. First of all you need to buy an account with TWILIO or use a Trial account. They will give you a number that will be used for sending and receiving the messages. Also, you will receive the AccountId and Auth token to be used to access the TWILIO API.
 
OK, so now this framework contains the following components:

  1. Outbound Message queue to persist the messages sent from the application.
  2. Windows service to poll the message queue and send the SMS to the interested parties.
  3. REST API to collect the response received to the SMS sent from your application.
  4. Inbound Message queue to collect the response messages.
  5. Windows service to process the inbound messages.

Creating Queues

I am assuming you have the queues installed on your machine otherwise you can install it from Windows Components. Create a queue in the following manner (on Windows 7 OS):

Go to "Administrative Tools" -> "Computer Management" -> "Services and Applications" -> "Message Queuing" -> "Private Queues":

Creating-Queues.jpg


Creating-Queues1.jpg

Note: If we enabled Journaling then we can audit the messages later on.

Creating-Queues2.jpg


Creating-Queues3.jpg

In the same way you can create the "smsinq" for collecting the inbound SMS. Create a MessageDTO class with the desired properties and don't forget to mark it Serializable.

[Serializable]

public class MessageDTO

{

    public MessageDTO() { }

    public Guid MessageGUID { set; get; }

    public string To { set; get; } //Phone number to whom message need to send

    public string Subject { set; get; }

    public string Body { set; get; }

    public string From { set; get; } //Phone number from whom message need to send

    public DateTime CreatedOn { set; get; }

    public DateTime SentOn { set; get; }

}

Utility.cs

Now you need the function that will push the messages in the outbound SMS queue (smsoutq). This function can be put in the Utility class to be reusable and is quite easy and can be used for pushing both inbound and outbound messages in their respective queues as follows:

public class Utility

{

    private static string smsOutQueuePath = ".\private$\smsoutq";

    private static string smsInQueuePath = ".\private$\smsinq";

   

    private static Message SetMessageProperties(Message objMsg)

    {

           objMsg.Recoverable = true;

           objMsg.UseDeadLetterQueue = true;

           objMsg.UseJournalQueue = true;

           objMsg.Formatter = new BinaryMessageFormatter();

           return objMsg;

       }

      

       public static MessageQueue GetMessageQueue(string queuePath)

       {

           MessageQueue msgQ = null;

           try

           {

               if(!MessageQueue.Exists(queuePath))

               {

                    msgQ = MessageQueue.Create(queuePath);

               }               

               msgQ = new MessageQueue(queuePath, QueueAccessMode.SendAndReceive);

               msgQ.Formatter = new BinaryMessageFormatter();

               msgQ.DefaultPropertiesToSend.UseJournalQueue = true;

               msgQ.DefaultPropertiesToSend.Recoverable = true; //Messages remain if server goes down

               msgQ.DefaultPropertiesToSend.UseDeadLetterQueue = true;

               msgQ.MessageReadPropertyFilter.SetAll();

           }

           catch (Exception ex)

           {

                     //your exception logging code

           }

           return msgQ;

       }

 

       public static bool PostToSMSQueue(MessageDTO objMsg, string direction = Constants.MESSAGE_DIRECTION_OUT)

       {

           bool success = false;

           try

           {

               Message objMessage = new Message();

                  objMessage = SetMessageProperties(objMessage);

                  objMessage.Body = objMsg;

                  MessageQueue msgQ = null;

                 

                  if(direction == Constants.MESSAGE_DIRECTION_OUT)

                      msgQ = GetMessageQueue(smsOutQueuePath);

                  else

                      msgQ = GetMessageQueue(smsInQueuePath);

                  msgQ.Send(objMessage);

        success = true;

           }

           catch (Exception ex)

           {

              //your exception logging code

           }

 

           return success;

       }

      

       public static NameValueCollection ConvertUrlStringToNSCollection(string strUri)

       {

               NameValueCollection nsCol = new NameValueCollection();

               if(!String.IsNullOrEmpty(strUri))

               {

                   try

                   {

                       int endPos = 0;

                       string[] messageArray = null;

                       messageArray = strUri.Split('&');

                       for(int count = 0; count < messageArray.Length; count++)

                       {

                           endPos = messageArray[count].LastIndexOf('=');

                           nsCol.Add(messageArray[count].Substring(0, endPos),

                           messageArray[count].Substring(endPos + 1, messageArray[count].Length - (endPos + 1)));

                       }

                   }

                   catch(Exception ex)

                   {

                       throw ex;

                   }

               }

               return nsCol;

           }

}

Creating OutboundMsgPoller Service to Send Message to TWILIO

Now you must write the windows service (OutboundMsgPoller) that will read the messages to the desired parties at some defined time interval and seelct the messages and send them to TWILO using their API to be sent further. Note that the code will be the same for the ReponseProcessor (Windows service to process the received responses, read inline comments below), so you can reuse it.
 

public partial class OutboundMsgPoller : ServiceBase

{

    private static string smsOutQueuePath = ".\private$\smsoutq";

    private static string accountSID = string.Empty;

    private static string authToken = string.Empty;

    private static string callbackURL = string.Empty;

    private Thread m_oPollingThread = null;

    private bool shallRun = false

 

    protected override void OnStart(string[] args)

    {

        try

        {

            this.EventLog.WriteEntry("OutboundMessagePoller service started successfully", EventLogEntryType.Information);

            shallRun = true;

            if (m_oPollingThread == null)

                m_oPollingThread = new Thread(SendMessage);

        m_oPollingThread.IsBackground = false;

        m_oPollingThread.Start();

        }

        catch (Exception ex)

        {

            //your logging code

        }

    }

   

    protected override void OnStop()

    {

               this.EventLog.WriteEntry("OutboundMessagePoller service is OnStop.", EventLogEntryType.Information);

    }

 

    private void SendMessage()

    {

        IList lstMsg = new List();

        int pollInterval = 0;

        MessageQueue queue = new MessageQueue(smsOutQueuePath, QueueAccessMode.SendAndReceive);

        accountSID = "Your Account ID";

        authToken = "Your Auth Token";

        callbackURL = string.Empty;//in case you want to collect the message status then you can specify a url for your application where TWILIO can POST the status.

       

        do

        {

            try

            {

                using (MessageEnumerator messageEnumerator = queue.GetMessageEnumerator2())

                {

                    while (messageEnumerator.MoveNext(new TimeSpan(0, 0, 1)))

                    {

                        Message msg = queue.ReceiveById(messageEnumerator.Current.Id, new TimeSpan(0, 0, 1));

                        lstMsg.Add(msg);

                    }

                }

                queue.Close();

               

                if (lstMsg != null && lstMsg.Count > 0)

               {

                //for OutboundMsgPoller service

                this.SendMessageToTwilio(lstMsg, accountSID, authToken, callbackURL);

                //for ReponseProcessor service, you have to write your own method

                YourMethod(lstMsg);

            }

            lstMsg.Clear();

            //Wait...

            {

                pollInterval = 30000; //time in milliseconds, can be made configurable

            }

            Thread.Sleep(pollInterval);

        }

        catch (Exception ex)

        {

            shallRun = false;

            //your logging code

        }

        } while (shallRun);

    }

 

    private void SendMessageToTwilio(IList objMessage, string accountSID, string authToken, string callbackURL)

    {

        try

        {

            if (objMessage != null && objMessage.Count > 0)

            {

                // instantiate a new Twilio Rest Client

                var client = new TwilioRestClient(accountSID, authToken);

                // iterate over message

                foreach (Message ms in objMessage)

                {

                    ms.Formatter = new BinaryMessageFormatter();//this is important

                    if (ms.Body != null)

                    {

                        var objTw = client.SendSmsMessage(((MessageDTO)ms.Body).From, ((MessageDTO)ms.Body).To, ((MessageDTO)ms.Body).Body, callbackURL);

                            if (objTw.RestException != null)// this is important

                            {

                                throw new Exception("SendMessageToTwilio - Twilio Error Code - " + objTw.RestException.Code + "|| Error Message - " + objTw.RestException.Message);

                            }

                            else

                            {

                                //Update the SMSID received from TWILIO in your DB or other appropriate repository.

                            }

                        }

                    }

                }

        }

        catch (Exception ex)

        {

             //your logging code

        }

    }



Creating REST Service to Collect TWILIO Responses

In case you don't have it, please install the WCF REST template from the link: http://visualstudiogallery.msdn.microsoft.com/fbc7e5c1-a0d2-41bd-9d7b-e54c845394cd

Once you install it, create a new project using the following template:

Creating-Queues4.jpg

TWILIO Response Class

You will be need to create a Twilio Response class as follows:
 

[Serializable]// this is important

public class TwilioRespDTO

{

    public TwilioRespDTO() { }

    public string SmsSid { get; set; }

    public string AccountSid { get; set; }

    public string From { get; set; }

    public string To { get; set; }

    public string Body { get; set; }

}


Response Collection REST API

    [ServiceContract]

    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]

    // NOTE: If the service is renamed, remember to update the global.asax.cs file

    public class Responder

    {

        [WebInvoke(UriTemplate = "response/sms", Method = "POST")]

        //IMPORTANT: response/sms is the part of the uri you will register with Twilio account for getting responses.

        public void GetTwilioSMSResponse(Stream sr)

    {

        if (sr != null)

        {

            try

            {

                string postData = string.Empty;

                NameValueCollection nsCol = new NameValueCollection(); 

 

                using (StreamReader srt = new StreamReader(sr))

                {

                    postData = srt.ReadToEnd();

                }

 

                nsCol = Utility.ConvertUrlStringToNSCollection(postData);

 

                if (nsCol != null && nsCol.Count > 0)

                {

                    TwilioResponseDTO objTw = new TwilioResponseDTO();

                    objTw = CreateTwilioResponseObject(nsCol);

                    Utility.PostToSMSQueue(objResp, Constants.MESSAGE_DIRECTION_IN);

                }

            }

            catch (Exception ex)

            {

               //your error handling code here

            }

        }

    }

 

        private TwilioResponseDTO CreateTwilioResponseObject(NameValueCollection nsCol)

        {

            MethodInfo objMethod = (MethodInfo)MethodBase.GetCurrentMethod();

            TwilioResponseDTO objTw = new TwilioResponseDTO();

            objTw.SmsSid = nsCol.Get("SmsId");

            objTw.AccountSid = nsCol.Get("AccountId");

            objTw.From = HttpUtility.UrlDecode(nsCol.Get("From"));

            objTw.To = HttpUtility.UrlDecode(nsCol.Get("To"));

            objTw.Body = nsCol.Get("Body");

            return objTw;

        }

    }           


Conclusion

I hope you enjoyed reading this article as much as I enjoyed writing it. I also hope that it will relieve you from writing boilerplate code and allow you to concentrate on the task at hand instead. Feel free to borrow the code and use it for your needs.

 

COMMENT USING

Trending up