C#

This walkthrough will show you how to build an app that listens for tweets from a certain twitter account, and then routes that tweet to a phone number, through Live Link 365's SMS API.

This is not a production-ready application. Please take your time to enhance it for production so that it meets your specific business requirements.

Steps

Before you can access the Twitter Streaming API, you will need to get the following information from Twitter:

  • API key
  • API secret
  • Access token
  • Access token secret
To get this information from Twitter, take the following steps:
  • Go to https://apps.twitter.com/ and log in with your twitter credentials.

    Note: If you do not already have a twitter account, you will need to create one

  • Click on "Create New App"
  • Complete the Create an application form, agree to the terms and conditions, and click Create your Twitter application
  • Once the new application is created, a new page for the app is displayed. Click the Keys and Access Tokens tab, and make a careful note of your "API key" and "API secret"
  • Scroll down to the Token Actions section and click Create my access token. Carefully note down your "Access token" and "Access token secret"
We will be using a Nugget package called Tweetinvi to connect to Twitter Streaming API and downloading the data.

Enter your credentials in the code into:

  • token
  • tokenSecret
  • consumerKey
  • consumerSecret

To get the user profile info we need to get the user id. You can fetch this ID from https://tweeterid.com/ by entering the twitter user name (@username):

  • userId=Long
  • var user=User.GetUserFromId(userId);

Using a properties or mapping json file makes it easier to send messages to only the users mentioned in the json file. This is done manually because it’s very difficult to do it directly via the API since not all the users keep their mobile numbers public.

Properties file is kept in the resources folder.

The information related to the user is stored as an object, containing the userId for the Twitter account we are going to listen to and an array of the phone numbers to which we want to send the notifications 
 user: {
    userId: userId 
    phoneNumbers: [phoneNumbers] 
}

Before you can use the API for sending SMS, we need to provide the basic configuration variables:

MessageHandler class works as a container for the functionalities required to send SMS through the API. For this step we have created two methods:

  • GetAccessToken(): This method will take the app Key and app Secret and combine them into a Base64 string, which will then be sent to the "/oauth/token" endpoint to generate and return the authentication token
  • sendMessage(): This method makes the POST request to the API to send the SMS; it receives the message to be sent, the number which we want to send the message, and optionally we can define from wich number we want to send the message

On this step we finally connect the twitter API to Live Link 365 , using all the data we collected before.

Create an user stream, this will allow us to start listening to the twitter account activity.

The stream allows us to listen to a variety of events, in this case, we listen to the TweetCreatedByMe; this event only triggers when the user tweets or retweets from its account.

For each new tweet posted on twitter from the account, a new SMS will be sent to the list of phone numbers defined on the properties.json file

Code

keyboard_arrow_down
zip tar 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
{
    // _Step_1
    "llkAppKey": "someHexKey",
    "llkAppSecret": "someHexSecret",
    "defaultOrigin": "someOrigin",
    "consumerKey": "someHexKey",
    "consumerSecret": "someHexSecret",
    "token": "someHexToken",
    "tokenSecret": "someHexTokenSecret",
    "user":  
        {
            "userId": "userId",
            "phoneNumber": []
        }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
using System;
using System.IO;
using System.Collections;

using Newtonsoft.Json.Linq;
using Tweetinvi;
using Tweetinvi.Credentials;
using Tweetinvi.Models;

using socialMedia.Class;

namespace socialMedia
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            // _Step_3
            JObject properties = JObject.Parse(File.ReadAllText(@"../../Resources/properties.json")); //Get the properties to be used in the project

            // _Step_4
            MessageHandler messageHandler = new MessageHandler(properties.GetValue("llkAppKey").ToString(), properties.GetValue("llkAppSecret").ToString(), properties.GetValue("defaultOrigin").ToString()); //Initialize the message handler
            var userToken = properties.GetValue("user");

            // _Step_2
            long userId = (long)userToken["userId"];//Get Twitter userId
            JArray phoneNumbers = (JArray)userToken["phoneNumbers"];//Get the array/list of phoneNumbers which are going to be notified.

            //Set the credentials from your Twitter app
            Auth.SetUserCredentials(properties.GetValue("consumerKey").ToString(), properties.GetValue("consumerSecret").ToString(), properties.GetValue("token").ToString(), properties.GetValue("tokenSecret").ToString());

            var user = User.GetUserFromId(userId);//Get the user using the userId provided

            // _Step_6
            var stream = Tweetinvi.Stream.CreateUserStream();//Create a stream to start listening the user's activity
            stream.TweetCreatedByMe += (object sender, Tweetinvi.Events.TweetReceivedEventArgs tweetArgs) => {
                String tweetMessage = tweetArgs.Tweet.FullText; //Get the tweet text
                for (Int32 i = 0; i < phoneNumbers.Count; i++) {
                    messageHandler.sendMessage(tweetMessage, phoneNumbers[i].ToString());//Sends a message with the tweet to the desired phoneNumbers
                }
                Console.WriteLine(user.Name + ": " + tweetMessage + " @ " + tweetArgs.Tweet.CreatedAt.ToString("f"));
            };
            stream.StartStream();//Start the stream so it will start monitoring the user's activity
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
using System;
using System.Net;
using System.Text;
using Newtonsoft.Json;
using RestSharp;

namespace socialMedia.Class
{

    public class MessageHandler
    {

        private String baseUrl = "https://livelink.sapdigitalinterconnect.com/api";
        private String appKey;
        private String appSecret;
        private String defaultOrigin;
        private WebProxy globalProxy;

        public MessageHandler()
        {
        }

        public MessageHandler(String appKey, String appSecret, String defaultOrigin = "", WebProxy proxy = null)
        {
            this.appKey = appKey;
            this.appSecret = appSecret;
            this.defaultOrigin = defaultOrigin;
            this.globalProxy = proxy;
        }

        // _Step_5
        public String GetAccessToken()
        {
            String oAuthUrl = this.baseUrl + "/oauth/token";
            String bearer = Convert.ToBase64String(Encoding.UTF8.GetBytes(this.appKey + ":" + this.appSecret));
            RestClient client = new RestClient(oAuthUrl);
            if (this.globalProxy != null) {
                client.Proxy = this.globalProxy;
                client.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
            }
            RestRequest request = new RestRequest(Method.POST);
            request.AddHeader("content-type", "application/x-www-form-urlencoded");
            request.AddHeader("authorization", "Basic " + bearer);
            request.AddParameter("application/x-www-form-urlencoded", "grant_type=client_credentials", ParameterType.RequestBody);

            IRestResponse<oAuthToken> response = client.Execute<oAuthToken>(request);

            if (response.StatusCode != HttpStatusCode.OK) {
                Console.WriteLine("..... Error: " + response.StatusDescription);
                return "";
            }

            String accessToken = response.Data.access_token;
            return accessToken;
        }

        public void sendMessage(String message, String destination, String origin = "")
        {
            String messageUrl = this.baseUrl + "/v2/sms";
            Object messagePayload = new {
                message = message,
                origin =  origin == "" ? this.defaultOrigin : origin,
                destination = destination //Phone numbers have to be in E.164 format.
            };
            String messageData = JsonConvert.SerializeObject(messagePayload);
            String bearer = GetAccessToken();
            if (String.IsNullOrEmpty(bearer)) {
                return;
            }
            RestClient client = new RestClient(messageUrl);
            if (this.globalProxy != null) {
                client.Proxy = this.globalProxy;
                client.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
            }

            RestRequest request = new RestRequest(Method.POST);
            request.AddHeader("authorization", "Bearer " + bearer);
            request.AddHeader("content-type", "application/json");
            request.AddParameter("application/json", messageData, ParameterType.RequestBody);

            IRestResponse response = client.Execute(request);

            if (response.StatusCode != HttpStatusCode.OK) {
                Console.WriteLine("..... failed to send message.");
                Console.WriteLine("..... Error: " + response.ErrorMessage);
            }
        }
    }
}