The IoT Gateway

 https://{serviceNamespace}.servicebus.windows.net/{eventHubPath}/publishers/{deviceName}/messages  

 https://ioteh-ns.servicebus.windows.net/ioteh/publishers/dhtxx/messages   

• Timeout : This can be set to 2 sec or 3 sec -  depending on what works best for you 
• Content-Type : application/json
• Authorization : The generated SharedAccessSignature token value. 

Generating Event Hubs SharedAccessSignature 

 

The Implementation 

// main method 
int send_event () { 
SERVICE_NAMESPACE = 'ioteh-ns'
EVENT_HUB_NAME = 'ioteh'
PUBLISHER_NAME = 'dhtxx' 
EVENT_HUB_SIGNATURE = 'change_me'
API_ENDPOINT = "https://#{SERVICE_NAMESPACE}.servicebus.windows.net/#{EVENT_HUB_NAME}/publishers/#{PUBLISHER_NAME}/messages"

// define headers 
HTTP.Headers.ConnectionTimeout = 60
HTTP.Headers.Content-Type =  'application/json'
HTTP.Headers.Authorization = #{EVENT_HUB_SIGNATURE}

//body of message 
HTTP.body = telemetry_data 
//Send it 
HTTP.POST (API_ENDPOINT) 

If HTTP.RESPONSE.StatusCode == 201
// successfully sent event to Azure Event Hubs 
Else 
// print HTTP.RESPONSE.StatusCode  
// print HTTP.RESPONSE.Body 
return HTTP.RESPONSE.StatusCode 
} 

// method  
String telemetry_data() {
//this method receives telemetry  data from IOT
// you will need to convert telemetry to json if you're not sending it in json format from IoT 
// sample data: https://gist.github.com/iogbole/8af14091e801d6352cf2

return telemetry_json_format 
} 

Deploying the IoT Gateway

Analytics!

 

SELECT
    DateAdd(second,-15,System.TimeStamp) as startTime,
    system.TimeStamp as endTime,
    chipid,
    Avg(heat_index) as avgHeatIndex,
    Avg(temperature) as avgTemperature,
    Avg(humidity) as avgHumidity,
    Count(*) as totalCount
 INTO dhtanalyticsdboutput
FROM DHTStreamAnalytics
GROUP BY TumblingWindow(hour, 1), chipid

SELECT
    DateAdd(second,-15,System.TimeStamp) as startTime,
    system.TimeStamp as endTime,
    chipid,
    Avg(heat_index) as avgHeatIndex,
    Avg(temperature) as avgTemperature,
    Avg(humidity) as avgHumidity,
    Count(*) as totalCount
INTO dhtpowerbioutput
FROM DHTStreamAnalytics
GROUP BY TumblingWindow(hour, 1), chipid

The Result 

select * from DHTAnalytics order by endTime DESC ;
select * from DHTReadings order by created_at DESC;

 

 

• https://msdn.microsoft.com/en-us/library/azure/dn790664.aspx  
• https://azure.microsoft.com/en-gb/documentation/articles/virtual-machines-set-up-endpoints/
• https://azure.microsoft.com/en-us/documentation/articles/stream-analytics-define-outputs/
• https://msdn.microsoft.com/en-us/library/azure/dn949330.aspx

Tweet to @israel_ogbole

Event Hubs and Stream Analytics

Create an Azure Database 

CREATE TABLE DHTAnalytics (chipid INT NOT NULL, startTime DATETIME, endTime DATETIME,
 avgTemperature FLOAT(53), avgHumidity FLOAT(53), avgHeatIndex FLOAT(53), totalCount BIGINT);
 
CREATE CLUSTERED INDEX chipid ON DHTAnalytics (chipid); 

CREATE TABLE DHTReadings (chipid INT NOT NULL, location VARCHAR(50), description VARCHAR(MAX),temperature FLOAT(53) NOT NULL,
humidity FLOAT(53) NOT NULL, heat_index FLOAT(53), created_at DATETIME DEFAULT getdate() NOT NULL);

CREATE CLUSTERED INDEX chipid ON DHTReadings (chipid); 

Navigate to OUTPUTS - > Add Output -> SQL Database - > 

References: 

• https://azure.microsoft.com/en-gb/documentation/articles/event-hubs-csharp-ephcs-getstarted/ 
• https://azure.microsoft.com/en-us/documentation/articles/stream-analytics-get-started/

Tweet to @israel_ogbole

• The project schematic and Arduino sketch  
• Setting up Azure Event Hub to process telemetry  
• Developing/Coding the IoT Gateway & Result Analysis with PowerBI

The Schematic

• Breadboard and jumper cables
• 3.3V and 5V breadboard power supply unit

• 10KΩ resistor
• 100µF capacitor
• ESP8266 Wifi Module

• Arduino Uno Micro controller

• DHT22 Sensor 

Connecting the DOTS!

The Arduino Sketch 

#include <SoftwareSerial.h>

SoftwareSerial wifiPort(2, 3);  //Connect ESP Tx to Uno Pin 2, ESP Rx to Uno Pin 3

void setup()  
{
  Serial.begin(9600);
  while (!Serial) {
  }
  wifiPort.begin(9600); // Most modern ESP-01 communicate at 9600 bps, change it if needed

void loop() 
{

  wifiPort.listen();
  if (wifiPort.available() ) {
    Serial.write(wifiPort.read());
  }
  if (Serial.available() ){
    wifiPort.write(Serial.read());
  }
  delay(10);
}

#include <SoftwareSerial.h>
#define SSID "changeme"
#define PASS "changeme"
#define IP "184.106.153.149" // thingspeak.com
String GET = "GET /update?key=paste_channel_key_here&field1=";

SoftwareSerial wifiPort(2, 3); 

void setup()  
{
  Serial.begin(9600);
  while (!Serial) {
  }
  
  wifiPort.begin(9600);
   connectToWiFi();
}

boolean connectToWiFi(){
  Serial.println("AT+CWMODE=3");
  delay(2000);
  String cmd="AT+CWJAP=\"";
  cmd+=SSID;
  cmd+="\",\"";
  cmd+=PASS;
  cmd+="\"";
  wifiPort.println(cmd);  
  delay(5000);
  if(wifiPort.find("OK")){
    Serial.print("Connected, IP address:  ");
    delay(2000);
    wifiPort.println("AT+CIFSR");
  delay(2000);
   Serial.println("All good!");
  wifiPort.println("AT+CIPMUX=1");
    return true;
  }else{
    Serial.println("Not good!");
    return false;
  }
}

void sendTelemetry(float tempF, float humP){
  String cmd = "AT+CIPSTART=4,\"TCP\",\"";
  //AT+CIPSTART=4,"TCP","bing.com",80 
  cmd += IP;
  cmd += "\",80";
  Serial.println(cmd);
  wifiPort.println(cmd);
  delay(2000);
  if(wifiPort.find("Error")){
    Serial.println("Not good!");
    return;
  }
  cmd = GET;
  cmd += tempF;
  cmd += "&field2=";
  cmd += humP;
  cmd += "\r\n";
  wifiPort.print("AT+CIPSEND=4,");
  wifiPort.println(cmd.length());
  delay(3000);
  if(wifiPort.find(">")){
      Serial.println("sending command... ");
    wifiPort.print(cmd);
  }else{
   Serial.println("closing");
    wifiPort.println("AT+CIPCLOSE");
  }
}

void loop() 
{

  wifiPort.listen();
  if (wifiPort.available() ) {
    Serial.write(wifiPort.read());
  }
  if (Serial.available() ){
    wifiPort.write(Serial.read());
  }
  delay(10);

   sendTelemetry(28.7,13.8);
}

#include "DHT.h"
#include <SoftwareSerial.h>
#define SSID "change_me"
#define PASS "change_me"
#define GATEWAY_ADDRESS "icent.nut.cc" // iotGateway address https://icent.nut.cc:3000. Locked down to specific IP range
#define GATEWAY_PORT 3000
#define chipId "101"
#define initReqData "POST /dhts.json HTTP/1.1\r\nHost:"
#define DHTPIN 4 // the uno digital pin I'm connected to
#define DHTTYPE DHT22 // DHT 22  

unsigned long previousMillis = 0; // will store last time DHT was acccessed 
const long readInterval = 600000;   // read temperature,humidity and send readings to iotgateway every 10 minutes 

SoftwareSerial wifiPort(2, 3); //Connect ESP Tx to Uno Pin 2, ESP Rx to Uno Pin 3
// Initialize DHT sensor.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
    Serial.begin(9600);
    wifiPort.begin(9600); //  ESP baudrate
   
    //initalize the wifi module 
    prepareWifiModule();

    //Connect ESP module to home/office wifi 
    connectToWiFi();
}

void prepareWifiModule() {
    sendCommand("AT\r\n");
    sendCommand("AT+RST\r\n");
    sendCommand("AT+CWMODE=3\r\n");
    sendCommand("AT+CIPMUX=1\r\n");
    delay(2000);
}

void connectToWiFi() {
    // Serial.println("Connecting to the internet...");
    String cmd = "AT+CWJAP=\"";
    cmd += SSID;
    cmd += "\",\"";
    cmd += PASS;
    cmd += "\"";
    cmd += "\r\n";
    sendCommand(cmd);
    delay(2000);
}

void loop() {
    unsigned long currentMillis = millis();
    
    if(currentMillis - previousMillis > readInterval) {
    //save the next readInterval.
    previousMillis = currentMillis;
    
    // Read temperature as Celsius (the default)
    float hum = dht.readHumidity();
    
    // Read temperature as Celsius
    float tem = dht.readTemperature();
    
    // Read temperature as Fahrenheit (isFahrenheit = true)
    //float temF = dht.readTemperature(true);
    
    // Check if any reads failed and exit early (to try again).
    if (isnan(hum) || isnan(tem)) {
        Serial.println("Failed to read from DHT sensor!");
        return;
    }
    
    float hic = dht.computeHeatIndex(tem, hum, false);
    
    Serial.print("Humidity: ");
    Serial.print(hum);
    Serial.print(" %\t");
    Serial.print("Temperature: ");
    Serial.print(tem);
    Serial.print(" *C\t ");
    Serial.print("Heat index: ");
    Serial.print(hic);
    Serial.print(" *C ");
    Serial.print('\n');
    
    sendTelemetry(tem, hum, hic);
    
    } 
}

void sendTelemetry(float t, float h, float hi) {
    char buff[10];
    String temperature_string;
    String humidity_string;
    String heatIndex_string;
    
    //convert floats to strings
    temperature_string = dtostrf(t, 2, 2, buff);
    humidity_string = dtostrf(h, 2, 2, buff);
    heatIndex_string = dtostrf(hi, 2, 2, buff);

   //Generate telemetry in json format 
    String telemetry = "{";
    telemetry += "\"chipid\":\"";
    telemetry += chipId;
    telemetry +=  "\",\"location\":\"GBRG6\",\"description\":\"B4Z1\",\"temperature\":";
    telemetry += temperature_string;
    telemetry += "\",\"humidity\":\"";
    telemetry += humidity_string;
    telemetry += "\",\"heat_index\":\"";
    telemetry += heatIndex_string;
    telemetry += "\"}";

    // Or parameterize telemetery in post request..
    //Note that the dht[...] is a ruby on rails thing.
    
//    String telemetry = "dht[chipid]=";
//    telemetry += chipId;
//    telemetry += "&dht[location]=GBRG6&dht[description]=B4Z1&dht[temperature]=";
//    telemetry += temperature_string;
//    telemetry += "&dht[humidity]=";
//    telemetry += humidity_string;
//    telemetry += "&dht[heat_index]=";
//    telemetry += heatIndex_string;

    telemetry.trim(); //remove trailing whitespaces.. 

    delay(1000); //let the buffer load 

    String requestHeader = GATEWAY_ADDRESS;
    requestHeader += "\r\n";
  //requestHeader += "Content-Type:application/x-www-form-urlencoded\r\nContent-Length:";  //if using post forms instead of JSON. 
    requestHeader += "Content-Type:application/json\r\nContent-Length:";
    requestHeader += telemetry.length();
    requestHeader += " \r\n\r\n";

    delay(1000); //let the buffer load 

    String http_request = initReqData;
    http_request += requestHeader;
    http_request += telemetry;
    http_request += "\r\n\r\n";

    delay(1000);
   
    //connect to gateway
    String cipStart = "AT+CIPSTART=4,\"TCP\",\"";
    cipStart += GATEWAY_ADDRESS;
    cipStart += "\",";
    cipStart += GATEWAY_PORT;
    cipStart += "\r\n";
    sendCommand(cipStart);
    
    delay(1000);
    
    //Serial.println(wifiPort.readString());
    if (Serial.find("ERROR") || Serial.find("Error")  || Serial.find("Unlink") || Serial.find("link is not")) {
        Serial.println("Could not connect to IOTgateway, retrying module initialization...");
        prepareWifiModule();
    }

    String cipSend = "AT+CIPSEND=4";
    cipSend += ",";
    cipSend += http_request.length();
    cipSend += "\r\n";
    
    sendCommand(cipSend);
    delay(1000);
    
    sendCommand(http_request);
    delay(3000);

    //close the TCP connection 
    sendCommand("AT+CIPCLOSE=4\r\n");
}

String sendCommand(String command) {
    String response = "";
    const int timeout = 1000;
    boolean debug = true;

    wifiPort.print(command); // send the read character to the esp8266

    long int time = millis();

    while ((time + timeout) > millis()) {
        while (wifiPort.available()) {
            // The esp has data so display its output to the serial window 
            char c = wifiPort.read(); // read the next character.
            response += c;
        }
    }

    if (debug) {
        Serial.print(response);
    }

    return response;
}

• https://www.electrodragon.com/w/ESP8266_firmware_flasher 
• https://learn.adafruit.com/dht
• https://github.com/adafruit/DHT-sensor-library 
• https://allaboutee.com

Tweet to @israel_ogbole

This question comes up quite often partly because there is no yammer documented/supported api on how to add members to a group in bulk. Most users, out of desperation end up hacking endpoints and and their respective parameters by capturing fiddler trace, inspecting browser elements, etc, but these get them into an unsupported state as undocumented APIs could change and/or break at any time without prior notice.

In this blog post, I will share my experience on how I worked with some clients to bulk add users to yammer group programatically - using yammer supported/documented API endpoints.

Prerequisites

• Register an app in Yammer as discussed in "Yammer REST API for Dummies" 
• Note the client ID and secret of the created app 
• Create a service account in Yammer and grant verified admin privilege to the service account. 
• Obtain OAuth token of the service account as discussed in "Consuming Yammer RESTful API with AngularJS for Dummies" 
• Obtain User IDs of the users you'd like to add to a group. These User IDs can be obtained by performing user data export

The Pseudo-code 

This implementation is represented in pseudo-code so as to make it easier for you or your developers to translate this information into any programming language of choice. 

 #Declare variables and constants  
 Array temp = Read userIDs from csv  
 constant group_id = 123  
 constant client_id = c456 
 var userid = 0;  
 ImpersonationURL = https://api.yammer.com/api/v1/oauth/tokens.json?user_id=$userid&consumer_key=$client_id
 GroupURL = https://api.yammer.com/api/v1/group_memberships.json?group_id=$group_id  
 while temp contains value {  
 userid = temp  
 #Impersonate the user with the VA's OAuth token   
 json_response = HTTP.GET (ImpersonationURL, userid).Authorization.Header(Bearer verified_admin_token)  
 #Consume the impersonated user's token from the JSON response  
 if json_response == null   
   exit and/or catch NullPointerException
 else  
#Parse the response to type json and read the token value  
user_token = JSON.Parse(json_response).token  
#Now, add the impersonated user to the group  
response = HTTP.POST (GroupURL, group_id).Authorization.Header(Bearer user_token)  
 if (response.status == 201) {  
   render SUCCESS or write userid into success.log  
 } else {  
   Read JSON response and render appropriate message OR write userid with the corresponding http response into failed.log  
 }  
 #Do not exceed yammer api rate limit - https: //developer.yammer.com/docs/rest-api-rate-limits. So sleep 
 sleep(2 sec)  
 increment++  
 }  

In plain English, what we have done so far are:

• Read userIDs from the csv that was obtained from data export 
• Iterate through the user list 
• Impersonate each user so as to get a pre-authorized token 
• Make the user add him/herself to the group. Yah!

I think this is needless to mention, but due to some questions that came up recently, I would like to note that it is not possible to impersonate a pending user. Impersonation only applies to active yammer accounts. 

References 

• https://developer.yammer.com/v1.0/docs/impersonation
• https://developer.yammer.com/v1.0/docs/group_membershipsjsongroup_idid
• https://developer.yammer.com/docs/rest-api-rate-limits

Was this information helpful? Please leave a feedback. 

Tweet to @israel_ogbole

Creating an AD Security Group 

• Click Start, point to, point to Programs, Administrative Tools, and then click Active Directory Users and Computers
• In Active Directory Users and Computers window, expand <domain name>.com
• In the console tree, right-click the folder in which you want to add a new group.
• Click New and then click Group.

• Type the name of the new group. You may want to use a name that you can easily associate with the role you are creating.

• In the New Object - Group dialogue box, do the following:

  • In Group scope, select Global scope.
  • In Group type, select Security

• Click OK
• Now double click on the group you just created and follow the direction of the arrows to add a member to the group: 

Get SID of the Security Group

 $name = “GROUP-NAME-GOES-HERE”  
 (New-Object System.Security.Principal.NTAccount($name)).Translate([System.Security.Principal.SecurityIdentifier]).value  

Update the Yammer Relying Party Trust 

• Open ADFS Management Snap-in and navigate to Relying Party Trust
• Right click the already existing Yammer Trust and click Edit Claim Rules
• Go to the "Issuance Authorization Rules" tab at the top
• Click Add Rule and select "Send Claims Using A Custom Rule" from the drop down.

• Copy/Paste this rule into the Custom rule text box:

 NOT exists([Type == "https://schemas.microsoft.com/ws/2008/06/identity/claims/groupsid", Value =~ "\bSID-GOES-HERE\b"])  
  => issue(Type = "https://schemas.microsoft.com/authorization/claims/deny", Value = "true");  

• Replace SID-GOES-HERE with the ObjectSID value of the security Group: 

Testing Yammer SSO with Custom Claim Rule 

 Set-AdfsRelyingPartyWebContent -Name fedpassive -ErrorPageAuthorizationErrorMessage "<br><p> You need to be a member of the Yammer Users Security group to access this Yammer network. Click <A href='https://requestyammeraccess/'>here</a> for more information or contact jetlee@contoso.com</p>“  

Tweet to @israel_ogbole

The AngularJS client will be accessed by opening the users.html file in your browser, and will consume the Yammer api service accepting requests at:

 https://api.yammer.com/api/v1/users.json  

Note that the Yammer REST API documentation uses https://www.yammer.com as the API endpoint host; you should always remember to change it to https://api.yammer.com.

The users.json API endpoint will respond with a JSON representation of all the users in the Yammer network.

Create an AngularJS Controller

First, let's create a very simple AngularJS controller that will consume the REST service. This can be done with and without user authentication prompt.  

Yammer support often get advisory questions from customers wanting to pull generic non-user specific yammer feeds into their (intranet) websites without authentication. Now, yammer does not support anonymity or public data so a user must be authenticated in one way or the other to be able to get and/or post yammer contents. To achieve this goal, you'd need to create a service account and obtain an access token using the instructions in this documentation.

Considering this is a newbie guide and if the documented process of obtaining yammer token is too complicated for you, you may try the following steps: 

• Login to Yammer using the service account
• Inspect the elements on the page
• Navigate to the network tab
• Reload the page if necessary
• Locate any line containing .json originating from www.yammer.com. See screenshot below
• Click the Request Header section
• Look out for the line starting with "Authorization: Bearer "
• Copy the token into a secure place

The above process is an alternative way of obtaining a user access token and it should look like this in Firefox:

The caveat is, tokens that are generated (or copied from browser elements) this way may be short lived or rendered invalid when the user logs out of the browser session. So I'd recommend you generate a token from a registered app for production purpose as they are long lived.  

Next, create a controller.js file then copy and paste this code into it: 

 function YammerGetUserCtrl($scope, $http ) {  
 $http.get('https://api.yammer.com/api/v1/users.json', {headers: {'Authorization': 'Bearer TOKEN_VALUE'}}).  
      success(function(data) {  
       $scope.users = data;  
      console.log($scope.users)  
     });  
 }  

Once that's done, replace TOKEN_VALUE with the access token you obtained.  

This controller module is represented as a simple JavaScript function that is given AngularJS’s $scope and $http components. It uses the $http component to consume the REST service at "/api/v1/users.json". The $http component sends a GET request to the API endpoint with a pre-defined Authorization header; this is one way of consuming Yammer feeds without prompting for authentication. 

If the GET request is successful, it will assign the JSON returned back from the service to $scope.users, effectively setting a model object named "users". By setting that model object, AngularJS can bind it to the application page’s DOM, rendering it for the end user to see. Bear in mind that this could be a lot better but slightly more complex, and I am seriously trying to keep the above implementation as simple as it possibly can because this tutorial is meant for you - newbie.  

Create the HTML Page

Now that you have an AngularJS controller, let's create the HTML page that will load the controller into the user’s web browser. Let's give it users.html as the file name. 

 <!DOCTYPE HTML>  
 <html ng-app>  
   <head>  
    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.23/angular.min.js"></script>  
    <script src="controller.js"></script>  
   </head>  
   <body>  
    <hr>  
    <p></p>  
    <h3> Yammer Users</h3>  
    <div ng-controller="YammerGetUserCtrl">  
      <div align="left"> Filter users : <input type="text" ng-model="yamUser"> &nbsp;&nbsp; <br><br> </div>  
      <p ng-show='yamUser.length>0'> ({{yamUser.length}}) </p>  
       <table>  
         <thead valign="top">  
          <tr>  
            <th>userID</th>  
            <th>Full Name</th>  
            <th>NetworkID</th>  
            <th>Activation Date</th>  
            <th>Face</th>  
          </tr>  
         </thead>  
         <tbody>  
          <tr ng-repeat ="user in users | filter:yamUser" ng-class-even="'alt'">  
            <td> {{ user.id}}</td>  
            <td> {{ user.full_name }}</td>  
            <td> {{ user.network_id }}</td>  
            <td> {{ user.activated_at}}</td>  
            <td> <img src= "{{ user.mugshot_url}}"/></td>  
          </tr>  
          <tr ng-if"users.length==0" colspan="4"> No matching results for {{yamUser}} {{user.length}} </tr>  
         </tbody>  
       </table>  
    </div>  
   </body>  
 </html>  

Note the following two script tags within the head section.

 <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.23/angular.min.js"></script>   
 <script src="controller.js"></script>   

The first script tag loads the minified AngularJS library (angular.min.js) from a content delivery network (CDN) so that you don’t have to download AngularJS and place it in your project. It also loads the controller code (controller.js) from the application’s path.

The AngularJS library enables several custom attributes for use with standard HTML tags. In users.html, four such attributes are in play:

• The <html> tag has the ng-app attribute to indicate that this page is an AngularJS application.
• The <div> tag has the ng-controller attribute set to reference YammerGetUserCtrl, the controller module. 
• The <tr> tag has the ng-repeat directive and it is used to iterate over each element in the users' collection.
• The same <tr> tag also contains the filter directive and it used to search/filter by the properties of the users.

Also note the five <td> tags which use placeholders (identified by double-curly-braces).

 <td> {{ user.id}}</td>  
 <td> {{ user.full_name }}</td>  
 <td> {{ user.network_id }}</td>  
 <td> {{ user.activated_at}}</td>  
 <td> <img src= "{{ user.mugshot_url}}"/></td>  

The placeholders reference the properties of the JSON objects which will be set upon successfully consuming the REST service. You can easily identify the property names by copying the returned JSON into a JSON viewer - https://jsonviewer.stack.hu/

Running your code

Update the Javascript origin with the host name of your application if you haven't done so to avoid CORS error, something like:

 XMLHttpRequest cannot load https://api.yammer.com/api/v1/users.json. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin....  

Lunch your app and navigate to the users.html page. This is how mine looks like - I added some css styles.

Summary

Congratulations! You’ve just developed an AngularJS client that consumes a Yammer RESTful web service.

One important security advice is to never use the access token the way it was described above in a public website. Anyone could impersonate the service-account user if the access token is compromised. You may explore other ideas of storing the access token in a database, or at least try to scramble it using any javascript obfuscation tool. A typical example is javascriptobfuscator.com. 

Lastly, you'd need to take each user through the authentication flow if you require user specific feed and if the yammer embed feed feature does not meet your requirement. See a sample implementation here. 

Feel free to download and re-use the source of the implementation that is described in this blog from GitHub. 

Tweet to @israel_ogbole

The first thing you want to do is to register an app in your Yammer network. Note down your Client ID (a.k.a App ID) and Client Secret values because you're going to need them. 

Post message to a yammer group

Next, you'd need to create a basic HTML page and include the JS SDK resource with the data-app-id definition as shown below:

   <script type="text/javascript" data-app-id="PASTE_YOUR_CLIENT_ID_HERE" src="https://c64.assets-yammer.com/assets/platform_js_sdk.js"></script>  
 

Once that's done, write the PostMessage function:   

 function postMessage() {  
     yam.getLoginStatus( function(response) {  
       if (response.authResponse) {  
        //call the yamPostRequest function if the user is logged in
       yamPostRequest(this);  
       } else {  
        //redirect the user to log in
        alert("not logged in")  
         yam.login( function (response) {  
        //re-check if the user is now logged in, then call the yamPostRequest function
          if (!response.authResponse) {  
           yamPostRequest(this);  
          }  
         });  
       }  
     });  
   }  

The postMessage function checks if there is a valid yammer oauth token in the user's browser and if the app is verified by the user. If the user is not logged in, "yam.login" is used to pop up the yammer login screen. You'd need to enable popups from *yammer.com in your browser for this work. Once the code verifies that the user is logged in, it will then invoke the yamPostRequest function shown below: 

 function yamPostRequest(val) {  
   var msg_value = document.getElementById('msg_body').value;  
   var groupID = document.getElementById('group_id').value;  
    if(msg_value ==""){  
     alert ("Message body cannot be empty!");  
     return false;  
    }  
    if(groupID==""){  
    var conf = confirm("Group ID is empty, message will be posted to All Company") ;
    if(conf==false){return false;}
    }  
 yam.platform.request(  
   {   
    url: "https://api.yammer.com/api/v1/messages.json"  
    , method: "POST"  
    , data: {  
     "body" : msg_value,  
     "group_id" : groupID  
    }  
    , success: function (msg) { alert("Post was Successful!"); }  
    , error: function (msg) { alert("Post was Unsuccessful"); }  
    }  
    )  
 }  

The yamPostRequest function accept message body and group ID as form inputs, validate the inputs and POST the request to Yammer's messages REST endpoint. 

Next, create the HTML form:

  <form name="myForm" method="get" action="">  
  <table cellspacing="2" cellpadding="2" border="0">  
   <tr>  
   <td align="right">GroupID</td>  
   <td>  
   <input type="text" name="group_id" id="group_id" />   
  </td>  
  </tr>  
  <tr>  
   <td align="right">Body</td>  
   <td>  
   <textarea rows="4" cols="50" name="msg_body" id="msg_body"></textarea>  
  </td>  
  </tr>  
 <tr>  
  <td align="right"></td>  
  <td><input type="button" value="Post Message" onclick ="postMessage();" /></td>  
  </tr>  
  </table>  
 </form>  

In all, your project layout should look like this - https://codio.com/iogbole/yam-jssdk-101

That's all about the coding aspect, but an attempt to run your code will result to Cross Origin Resource Sharing (CORS) error; so the next and final step is to open the registered app in Yammer and add the host name of your web server to the app's Javascript Origins: 

Feel free to download the code from github, change the data-app-id value in script.js and Yammer-ON. 

The next part of this blog will demonstrate how to GET contents from yammer using the Javascript SDK and AngularJS

Next -> Consuming Yammer RESTful APIs using AngularJS 

Tweet to @israel_ogbole

Yammer supports any SAML 2.0 compliant Identity Provider (IdP). These include ADF 2.0 & 3.0,  Windows Azure AD, Shibboleth, OneLogin, PingFed, Okta etc. The first step to implementing Single Sign-On (SSO) with Yammer is to open a yammer SSO service request. You will be asked to provide your IdP metadata and token signing certificate so you may want to speed up the data collection phase by providing the required files as soon as you open the service request. In the case of ADFS IdP, the metadata can be downloaded from -  https://your-server-URL/FederationMetadata/2007-06/FederationMetadata.xml and you may use this instruction to extract the token signing certificate. You should zip the token signing certificate before sending it to the Yammer support rep. because .cer files are quarantined by Microsoft IT.

Once you’ve provided the required files, Yammer support will create the connection and respond back with the Yammer Service Provider (SP) metadata. At this point, the connection is inactive and there will be no impact on users' experience. Download the metadata file and start the process of creating the relying party trust and claims rule as described below.

Add Relying Party Trust

• In ADFS Management Console, navigate to Trust Relationships ->Replying Party Trusts
  

• Right Click Relying Party Trusts and click Add Relying Party Trust

• Click Start

• Select "Import data about the relying party from a file", browse to the metadata file that was provided by Yammer Support and click Next.

• Add a Display name (and Notes if necessary) and click Next

• Multi-factor authentication is not required, click Next 

• Permit all users to access this relying party, Next.

• Check the Edit Claim Rules box
  

Edit Claim Rules for Relying Party Trust

• In the Issuance Transform Rules tab, click Add Rule

• In the Select Rule Template, leave "Send LDAP Attributes as Claims" selected

• In the Configure Claim Rule page, enter Get attributes in the Claim rule name box

• In the Attribute store list, select Active Directory

• In the Mapping of LDAP attributes create the following mappings: E-mail-Addresses - SAML_SUBJECT
  

• Click Finish
  

Testing your Single Sign-On Connection

Lastly, if you want to restrict yammer access to a subset of users, which is the main reason most customers use Yammer SSO instead of Office 365 sign-in for Yammer, please refer to this blog. 

Tweet to @israel_ogbole