Synchronize Active Directory Information with Sharepoint Foundation 2013 User Profiles

You might be wondering why should I do this when Sharepoint can do this already though User Profile Synchronization, well that is partly true because in Sharepoint Foundation 2013 and even on 2010 it is not available.  Having said that there will always be a way and that’s what are trying to achieve on this article, to synchronize Active Directory Information with Sharepoint User Profile by doing some coding.  This can be achieved in multiple ways, you can do Powershell, you can create a Sharepoint feature or develop a standalone application, we will do the latter as for me its more flexible and manageable.

Now lets start but before doing so lets lay out some ground work and give some explanation on how to we go about on this one.

Did you know that Sharpoint stores user profiles in a list as well?  It’s sort of hidden but in case you did not know you can locate it at:

http://{YourSharepointUrl}/_catalogs/users/simple.aspx

And it will look like this

But something is different, unlike normal lists it does not give you the tabs to manipulate the list or its view but that does not stop us in doing so as it is just a web part in a page, having said that you can still edit the page.

and edit the web part

then edit the current view

and there you are

free to change how your view looks like.

That does not end there, you can also edit the list by adding column of your choice.  It’s not straightforward though as you need to know your List Id by checking it in the URL while you in the view property page.

Now copy that and combine it with the URL below to view your List Properties

http://{YourSharepointURL}/_layouts/listedit.aspx?List={YourListIdHere}

And whoalla! you can now edit your list.

So now lets say we add Description, Office and Company which is not there by default.

Once saved you can now see it on the view

Now that you know that the user profiles are saved on a list and you can modify the structure of it let’s do some coding and map our Active Directory with Sharepoint User Data.  For this example we will map the common and the most logical fields we usually use.

Although it shows the proper name on the view the field names might not be the same, so if you run the codes below and investigate what the field names are it would look like this.

So make sure you map it to the correct Sharepoint and Active Directory fields/columns, for our example it will be like this.

Now lets start coding.  What we will do first is a simple listing of all Site Users, to do that copy and paste the codes below.

private static void GetAllSiteUsers()
{
    // Starting with ClientContext, the constructor requires a URL to the server running SharePoint. 
    var sharepointContext = new ClientContext("http://yoursharepointurl/");
 
    //Get Web Context
    var sharepointList = sharepointContext.Web.SiteUserInfoList;
 
    var camlQuery = new CamlQuery();
 
    var userList = sharepointList.GetItems(camlQuery);
    sharepointContext.Load(userList);
    sharepointContext.ExecuteQuery();
 
    foreach (ListItem user in userList)
    {
               
    }
}

Run it and lets see your first data, the first user that will appear is the one who set up your Sharepoint Instance, which means you are safe to assume that it is a real user.

Place a breakpoint and investigate your results.  If you notice when you run the code it will give you all the List Items and in our example we have 2399 items, we need to filter it further because the whole list contains Users, Active Directory Groups and Sharepoint Groups.  What we need to sync only are the Users so we need to identify which are the users somehow.

After looking at my example I have two Field values that I can use, first is the ContentTypeId which if you further investigate is common for all Users other entities have a different ContentTypeId.  Another is the Name where all users will have a Claims Authentication Code and Domain Prefix ie i:0#.w|YourDomainUserName other entities such as group is prefixed as c:0+.w|  followed by and SID.

Now we know how to filter lets apply that to the CAML Query and further filter our results.

private static void GetAllSiteUsersFilteredByType()
{
    // Starting with ClientContext, the constructor requires a URL to the server running SharePoint. 
    var sharepointContext = new ClientContext("http://yoursharepointurl/");
 
    //Get Web Context
    var sharepointList = sharepointContext.Web.SiteUserInfoList;
 
    //Prefix for all users
    string userType = "i:0#.w|";
 
    var camlQuery = new CamlQuery();
    camlQuery.ViewXml = @"<FieldRef Name='Name' />" + userType + "</Value></Contains></Where></Query></View>";
 
    var userList = sharepointList.GetItems(camlQuery);
    sharepointContext.Load(userList);
    sharepointContext.ExecuteQuery();
 
    foreach (ListItem user in userList)
    {
 
    }
}

Now you will see we have lesser result count as we only get the real users.

Let’s do the synchronization Part!

By now you know how to get all that users now we need to search for the same user in Active Directory get its information and overwrite the ones in Sharepoint.  The codes below is complete but I just created them in one class as a console application, it’s up to you how you want to use them.

The codes also takes into consideration that service user you will be using have full rights on Active Directory and is in the Site Collection Administrators Group on Sharepoint.

using Microsoft.SharePoint.Client;
using System.DirectoryServices;
using System.DirectoryServices.AccountManagement;
 
namespace Sharepoint_User_and_Active_Directory_Sync
{
    static class Program
    {
        //If you're using claims authentication, this defines a user on a domain
        const string userType = "i:0#.w|";
        //If you're not using claims authentication, this defines a user on a domain
        //const string userType = @"YourDomain"; 
 
        const string domain = "your.sharepoint.com";
        const string rooOrganizationalUnit = "DC=your,DC=sharepoint,DC=com";
        const string adDomain = "YOURDOMAIN";
        const string adUserName = "YourServiceUser";
        const string adPassword ="YourServiceUserPassword";
 
        static void Main(string[] args)
        {
 
            // Starting with ClientContext, the constructor requires a URL to the server running SharePoint. 
            var sharepointContext = new ClientContext("http://yoursharepointurl/");
            sharepointContext.Credentials = new System.Net.NetworkCredential(adUserName, adPassword, adDomain);
 
            //Get Site Users Lists
            var sharepointList = sharepointContext.Web.SiteUserInfoList;
            
            //Filter User List by CAML Query
            var camlQuery = new CamlQuery();
            camlQuery.ViewXml = @"<FieldRef Name='Name' />" + userType + "</Value></Contains></Where></Query></View>";
            var userList = sharepointList.GetItems(camlQuery);
            sharepointContext.Load(userList);
            sharepointContext.ExecuteQuery();
 
            //Loop Through Each User
            foreach (ListItem user in userList)
            {
                //Lets remove the Claims Authentication Prefix
                var userName = user["Name"].ToString().Replace(userType, "");
 
                //Get the User Details from Active Directory
                UserPrincipal userPrincipal = GetUser(userName);
 
                //if User Principal Exists
                if (userPrincipal != null)
                {
                    user["Title"] = userPrincipal.DisplayName;
                    user["EMail"] = userPrincipal.EmailAddress;
                    user["Description"] = userPrincipal.Description;
                    user["DDI"] = userPrincipal.VoiceTelephoneNumber;
 
                    //Unrepresented AD Attributes in User Principal, we have to use 
                    //our own extension method called GetProperty to retrieve AD Value
                    user["JobTitle"] = userPrincipal.GetProperty("title");
                    user["Department"] = userPrincipal.GetProperty("department");
                    user["MobilePhone"] = userPrincipal.GetProperty("mobile");
                    user["SipAddress"] = userPrincipal.GetProperty("ipPhone");
                    user["Office"] = userPrincipal.GetProperty("physicalDeliveryOfficeName");
                    user["Company"] = userPrincipal.GetProperty("company");
 
                    //Update User
                    user.Update();
 
                    //Commit Changes
                    sharepointContext.ExecuteQuery();
                }
            }
        }
 
        /// <summary>
        /// Gets the base principal context
        /// </summary>
        /// <returns>Retruns the PrincipalContext object</returns>
        private static PrincipalContext GetPrincipalContext()
        {
            PrincipalContext principalContext;
 
            principalContext = new PrincipalContext(ContextType.Domain, domain, rooOrganizationalUnit, ContextOptions.Negotiate, adDomain + @"" + adUserName, adPassword);
 
            return principalContext;
        }
 
        /// <summary>
        /// Gets a certain user on Active Directory
        /// </summary>
        /// <param name="userName">The username to get</param>
        /// <returns>Returns the UserPrincipal Object</returns>
        private static UserPrincipal GetUser(string userName)
        {
            try
            {
                var principalContext = GetPrincipalContext();
 
                var userPrincipal = UserPrincipal.FindByIdentity(principalContext, userName);
                return userPrincipal;
            }
            catch
            {
                return null;
            }
        }
 
        /// <summary>
        /// Gets the AD Attributes not represented in UserPrincipal
        /// </summary>
        /// <param name="principal">The User Principal Object</param>
        /// <param name="property">The property name you want to retrieve</param>
        /// <returns></returns>
        private static string GetProperty(this UserPrincipal principal, string property)
        {
            var directoryEntry = principal.GetUnderlyingObject() as DirectoryEntry;
 
            if (directoryEntry.Properties.Contains(property))
            {
                return directoryEntry.Properties[property].Value.ToString();
            }
            else
            {
                //Property not exisiting return empty strung
                return string.Empty;
            }
        }
    }
}

That’s it, now you can sync your Active Directory User Information to your Sharepoint Foundation 2013 regularly.