Skip navigation

We are using Microsoft technologies for a number of our services and products. Most recently our Windows Phone app for Jive.


Using the Jive REST API from a .Net/C# application is actually very straightforward, so I am going to outline a basic example in this post.


  • Jive system that supports the v3 api. I am using Jive Cloud in this example
  • .Net 4.5(.1) based project. I am using Visual Studio 2013 Update 2


In this example we are going to retrieve a person object from Jive (Jive REST Rest API v3.7 → Person entity)


The data model:

The person object

    public class Person
        public string displayName { get; set; }
        public int followerCount { get; set; }
        public int followingCount { get; set; }
        public int id { get; set; }
        public string location { get; set; }
        public string status { get; set; }
        public string thumbnailId { get; set; }
        public string thumbnailUrl { get; set; }
        public DateTime updated { get; set; }
        public List<ProfileEntry> emails { get; set; }
        public JivePerson jive { get; set; }
        public Name name { get; set; }
        public List<ProfileEntry> phoneNumbers { get; set; }
        public List<ProfileEntry> photos { get; set; }
        public DateTime published { get; set; }
        public List<string> tags { get; set; }
        public JiveResource resources { get; set; }


The JivePerson object that holds the Jive specific information about a person

    public class JivePerson
        public bool enabled { get; set; }
        public bool external { get; set; }
        public bool externalContributor { get; set; }
        public bool federated { get; set; }
        public DateTime lastProfileUpdate { get; set; }
        public Level level { get; set; }
        public string locale { get; set; }
        public List<ProfileEntry> profile { get; set; }
        public bool sendeable { get; set; }
        public bool termsAndConditionsRequired { get; set; }
        public string timeZone { get; set; }
        public string username { get; set;}
        public bool viewContent { get; set; }
        public bool visible { get; set; }


Additional objects for statuslevel, profile entries and names

    public class Level
        public string description { get; set; }
        public string imageURI { get; set; }
        public string name { get; set; }
        public int points { get; set; }

    public class ProfileEntry
        public string jive_label { get; set; }
        public string value { get; set; }
        public string type { get; set; }
        public bool primary { get; set; }
    public class Name
        public string familyName { get; set; }
        public string formatted { get; set; }
        public string givenName { get; set; }



Now that we have the datamodel for our person, let's retrieve a person via the rest api. In our example we are going to use the simplest call by getting the logged in user. I've hardcoded the necessary Urls in this example.


string jiveServer = "";
Person person = await JiveDataSource.GetPersonAsync(jiveServer + "/api/core/v3/people/@me");


The asynchronous method gets the Json describing the person using the ExecuteAbsolute method in the JiveRequest class.

Afterwards the JsonConvert.DeserializeObject method from the libary is used to create a person object from the Json.


   public static async Task<Person> GetPersonAsync(string url)
            JiveRequest myJiveRequest = new JiveRequest();

            string jiveCommunityJSON = await myJiveRequest.ExecuteAbsolute(url);
            Person myPerson = JsonConvert.DeserializeObject<Person>(jiveCommunityJSON);
            return myPerson;


Finally here is the JiveRequest.ExecuteAbsolute method. Again values are hardcoded in this example


        public async Task<string> ExecuteAbsolute(string url)
            string jiveCommunityUrl = "";
           //This example uses basic auth. OAuth based authentication is also possible

            string userName = "myuser";
            string password = "mypassword";

            System.Net.Http.HttpClientHandler jiveHandler = new System.Net.Http.HttpClientHandler();

          //Setting credentials for our request. This needs to be done for every request as there are no persistent sessions for the REST Api
            NetworkCredential myCredentials = new NetworkCredential(userName, password);
            myCredentials.Domain = jiveCommunityUrl + "/api/core/v3";
          //Getting our credentials in Base64 encoded format
            string cre = String.Format("{0}:{1}", userName, password);
              byte[] bytes = Encoding.UTF8.GetBytes(cre);
           string base64 = Convert.ToBase64String(bytes);
          //Set credentials and make sure we are pre-authenticating our request
            jiveHandler.Credentials = myCredentials;
            jiveHandler.PreAuthenticate = true;
            jiveHandler.UseDefaultCredentials = true;

           httpClient = new System.Net.Http.HttpClient(jiveHandler);
            httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", base64);

            HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, url);

            System.Net.Http.HttpResponseMessage activityResponse = await httpClient.SendAsync(requestMessage);
            String myActivityResponse = await activityResponse.Content.ReadAsStringAsync();
          //Remove the string Jive includes in every response from the REST API
            string cleanResponseActivities = myActivityResponse.Replace("throw 'allowIllegalResourceCall is false.';", "");

            return cleanResponseActivities;


What is GitHub4Jive


  • At it's core, GitHub4Jive is an integration that combines the collaboration strengths of Jive with the source control and issue tracking strengths of GitHub to fuel a collaboration driven approach to managing projects on GitHub.
  • For information on the specific user stories that we are trying to tackle, check out this document for insight:
    GitHub4Jive - Feature Document
  • From a training perspective, this add-on will demonstrate best practices for integrating multiple Jive disciplines, such as Tiles, Apps, Cartridges, REST/Webhooks and more.
  • It is our intent to make this add-on a reference example on how to build a fully-featured Jive add-on, similar to the Do you know Jive-Fu? for plugins (but better) =)
  • In addition to being a functioning Jive integration, the GitHub4Jive is the first of many projects that we will launch this year where we will look to engage the developer community for their expertise and get working examples out into open source.
  • As developers contribute back to these projects, they will earn credits in the 2014-15 Jive Developer Program in the Developer Community (details to come, but referenced here)
    Jive Developer Program - 2013-14 Recap, Achievements and Winners + 2014-15 Preview



Meet the Team


Aron RachoGlen NicolBrad ChesmanYuvi ZalkowRyan RutanAnd You!



Platform API - Engineer




Platform API - Intern




Sr. Professional Services Engineer




Sr. Documentation Engineer



Ryan Rutan

Developer Evangelist


Screen Shot 2014-07-20 at 11.30.34 PM.png



How Can You Contribute

      • Tip: GitHub makes it very easy to grab links to specific lines of code in the project, just right-click and select "Copy Link Address" on the line numbers on the left-hand side.

Note:  We've scaffolded out the add-on, so the need to due any major structure changes/innovations should be limited; however, if you feel you'd like to deviate from the structure, let's talk it out. 
Our goal was to reduce, not eliminate, the amount of "architecture" churn for this add-on.  When in doubt, please reference the files in your respective component(s).


We Can Do It

When it comes to contributing, do not feel obligated to have to deliver an entire component.  Even if you can help flesh out documentation, prettify user experiences, etc... these are all valuable contributions that benefit the project!


Our goal: to leverage the the above team and the developer community in a collaborative manner to complete something that is highly functional by JiveWorld that we can continue to developer (even in the Open Hackathon).


In addition, if we are successful, we will be able to leverage the add-on in the Jive Community to power future open-source projects on GitHub from our Developer Community!


If you have any questions, feel free to comment on this blog post or in the GitHub4Jive project!  Excited to get this started, and work with each of you!


From Producteev, to Jive

Our first collaboration with Jive Software was for Producteev, a task manager, that was just acquired by Jive at that time. We helped them create the new version of their OS X application. It was a great and successful collaboration.

When Producteev was finished, they were just releasing the first version of Jive Mobile on the iOS App Store. They also already had an Outlook and Office Jive plugins for those working on Windows systems. But nothing for Mac users…

And there are lots of Mac users at Jive Software, who wished to have a native Mac application to access their account, like their Windows colleagues already did with their Outlook plugin. Since they were all busy working on the next Jive version, they didn’t had the resources to create a Mac app. Fortunately, amongst those Mac users, a few had worked with us on Producteev and they knew the quality of our work.

They contacted us. We discussed. And that’s how we decided to team up with Jive as a Technology Partner to make the Mac application a reality!

Using Jive SDK

During the Jive Mobile conception, the Jive development team created an SDK, a set a tools for developers that provides easy access to the Jive platform. As iOS and OS X share the same programming language, it was a huge head start for us since it saved us the writing of hundreds of lines of code. But despite their similarities, these two platforms have some slight but important differences, which led us to our first mission: adapting the SDK to OS X!

We fought against name conflicts, function incompatibilities,… After a few back and forth with the Jive SDK team, we were on track to start developing the app.

Would it start to be easy at this point? Not at all! One of our biggest challenge awaited us in the corner.

On a desktop application, there are lots of informations displayed at the same time on the screen. It’s not like on mobile application where we display one or two informations at a time. When you show lots of informations, you wind up having duplicated data that needs to be synchronized.

Imagine a private conversation screen. We have a list of discussions, and the avatar of each users inside it. When a discussion is selected, the content of the discussion is retrieved from Jive servers using the SDK. If a user changes his avatar right before the content of the discussion is retrieved, it will show a different avatar between the discussions list and the discussion content. And you will say with good reason: “What a nasty bug!”

To solve this, we needed to uniquely identify each resource returned by the SDK.

When the SDK gives us a user, we search in the previously fetched users if we have one with the same identifier to update it. Thus if the avatar changes, each part of the application displaying it is notified of the change and updates automatically to keep all the interface consistent at any time.

Building interface

The Jive website offers tons of features. Implementing all of them on the application could have taken years, and wouldn’t have make sense since an app is typically focused on a subset of features. Also, a native application offers many ways to interact with the user: right click, application menu, shortcuts, multiple windows… All these reasons lead us to imagine a new interface, totally different from the Jive website.

The first step to build an efficient interface was to decide which features needed to be implemented in the application. Jive Software shared their experience with their platform to help us make the good choices. They told us what were the most useful features and what we should absolutely add to make the application a success.

After selecting those features, our next objective was to imagine a beautiful and clear interface to present them. We could have used a stock interface that looks like any other OS X application, mimicking the system controls. After all, OS X Mavericks is beautiful! But not beautiful enough for our ambitions of an outstanding app…

After days, trying different styles with our designers, discussing with our contacts at Jive Software, we ended up using iOS 7 to inspire us. Without knowing it, we created a flat design that had a lot of similarities with OS X Yosemite, which wasn’t announced yet at that time.

Thanks to that, we are now ready for the future and we hope that every Jivers using a Mac will enjoy as much as we are this great app we made!

2013-14 Jive Developer Program - Recap




JiveWorld14 - Jive Developer Conference

More Sessions, More Hacking, More Beer

When:  October 21-23, 2014

Where:  Cosmopolitan - Las Vegas, NV

  • NEW:  Developer Keynote by Matt McCullough, VP of Training @ GitHub
  • BETTER: Open Hackathon (conference attendees + remote developers are invited)
    • NEW: Developer challenges and drawings to win some special tech gadgets during the conference!  Your inner-nerd will be very happy!
  • MORE:  Unprecedented level of Developer Content and Access to Jive Engineers!
  • For more details, see:


Register Today to Get Your Early-Bird Discount

In these past 6 months we've made a lot of progress, but we can (and will) do even better
next year to make the Jive Developer Program more awesome for everyone!


2013-14 Jive Developer Program - Achievements



2014-15 Jive Developer Program - Preview

  • Jive Developer Expertise Gems (continue from 2013-14)
  • Jive Developer Community Participation (continue from 2013-14)
  • Jive Developer Project Contributions (new for 2014-15)
    • Chances to contribute small pieces of code to Developer Community open projects for hacking year-round on GitHub!
  • New Jive Developer Gamification Economy (new for 2014-15)


More information coming soon on this program, but to get started ... keep participating in the conversation in the Jive Developer Community and stock up on Jive Developer Expertise badges!


2013-14 Jive Developer Program - Rock Stars

The following developer community rockstars are being recognized for their accomplishments in the 2013-14 Jive Developer Program, but as well as their consistent level of participation in the Jive Developer community.  The Jive Developer community wouldn't be what it is today without you assistance, and for that we thank you. =)  To say thanks each of you will get first pass at the prizes (listed below) for this year's program.


Kevin BrownNils HeuerLG







2013-14 Jive Developer Program - Random Drawing Winners

The following developer community members have been selected at random based on entries into the lottery set forth by the Announcing the 2013-14 Jive Developer Program.  There participation in the Jive Developer Program has been much appreciated, and we will be reaching out to each of you once our Rockstars have picked their prizes!


Craig ReevesSnigdha ChallaPatrick CrownoverAaron WalkerCasey Gum






No Profile Photo =\













2013-14 Jive Developer Program - Prizes


3 x Philips Hue Starter Pack5 x Pebble Smart Watches

Filter Blog

By date: By tag: