User profile | Second Life of a Hungarian SharePoint Geek

November 17, 2010

Creating a timer job for Active Directory – SharePoint profile user image synchronization

Filed under: Active Directory, Reflection, SP 2010, Timer jobs, User profile — Tags: Active Directory, Reflection, SP 2010, Timer jobs, User profile — Peter Holpar @ 02:40

In my former post I’ve illustrated how to synchronize user images between AD and SharePoint using a custom web part in a self-service way. If you need to synchronize user images automatically you need a more advanced technique.

The user profile synchronization service in SharePoint provides a built-in solution for you, but only if you need one-way (SharePoint to AD) synchronization of images, as described in this article:

Replicating user pictures from Sharepoint 2010 to Exchange 2010 and Communications Server 14

If you would like the user images to be updated automatically in AD and SharePoint when it is changed on either end of the connection you need to apply some tricks.

(REMARK: Most of the codes for this solution are borrowed from my former post, hence I’ve include only the most relevant new snippets in the current post. The entire solution can be downloaded from here, use it at your own risk. Any feedback is welcome.)

To fulfill the requirement I’ve created a custom timer job that runs periodically and checks the images for all users in both AD and SharePoint, and if these images are different (missing on either sides or has different hash value) then the the more recent image is copied over the older one into the other system.

(REMARK: In this post I do not concentrate on the custom timer job development, just on the actual synchronization task. If you are new to timer jobs, you can find several excellent posts about this topic on the web, like this one from Andrew Connell:

Creating Custom SharePoint Timer Jobs)

But the question is: how to get the date when the image is modified in the AD and in the SharePoint profile?

It was lot easier (at least, for me) to answer the second one: the images stored in a dedicated list in the SharePoint My Site Host, so we can read the last modified date using standard SharePoint API.

After some investigation in AD and on the web I’ve found the answer to the first part as well. The LastOriginatingChangeTime property of the AttributeMetadata class (that can be accesses through the ActiveDirectoryReplicationMetadata object) gives you information about when a specific AD property was changed.

The following code snippet from the helper class ADUtils illustrates the concept:

/// <summary>
/// Gets the time of last user photo change in AD
/// </summary>
public DateTime UserPhotoLastModified
{
    get
    {
        // if we do not find info about the property change we consider it is changed "never"
        DateTime lastModified = DateTime.MinValue;
        ActiveDirectoryReplicationMetadata rm = _domainController.GetReplicationMetadata(_userPath);
        AttributeMetadata am = rm["thumbnailPhoto"];
        if (am != null)
        {
             lastModified = am.LastOriginatingChangeTime;
        }
        return lastModified;
    }
}

The ADUtils class is initialized like this:

String _defaultPartition;
DirectoryContext _directoryContext;
DomainController _domainController;
DirectoryEntry _user;
String _userPath;
 
public ADUtils(String userName)
{
    String[] splittedName = userName.Split(new char[] { '\\' }, StringSplitOptions.RemoveEmptyEntries);
    String domainShortName = splittedName[0];
    String accountName = splittedName[1];
    _directoryContext = new DirectoryContext(DirectoryContextType.Domain, domainShortName);
    _domainController  = DomainController.FindOne(_directoryContext);
    _defaultPartition = GetDomainRoot(domainShortName);
    _user = FindUserByAccountName(accountName);
    _userPath = _user.Path.Remove(0, 7); //remove the LDAP prefix
}

If you read my former post in the topic you might remember that there was a web part property that stored the AD root partition. In the meantime I found a direct way to get this AD path from the short domain name:

/// <summary>
/// Retrieves the path of root AD partition
/// </summary>
/// <param name="domainShortName"></param>
/// <returns></returns>
private String GetDomainRoot(String domainShortName)
{
    Domain domain = Domain.GetDomain(_directoryContext);
    String domainName = domain.Name;
    String domainComponent = "DC=" + domainName.Replace(".", ",DC=");
 
    return domainComponent;
}

We can access the AD photo via the ThumbnailPhoto property of the ADUtils class:

/// <summary>
/// Gets / sets the thumbnail photo for the user
/// </summary>
public byte[] ThumbnailPhoto
{
    get
    {
        // if we do not find info about the thumbnailPhoto property we consider it is "empty"
        byte[] thumbnailPhotoBytes = null;
        if (_user.Properties.Contains("thumbnailPhoto"))
        {
            thumbnailPhotoBytes = (byte[])_user.Properties["thumbnailPhoto"].Value;
        }
        return  thumbnailPhotoBytes;
    }
    set
    {
        _user.Properties["thumbnailPhoto"].Clear();
        if (value != null)
        {
            _user.Properties["thumbnailPhoto"].Add(value);
        }
        _user.CommitChanges();
    }
}

I’ve created a static helper method to access profile properties easier:

public static class Extensions
{      
    public static String GetProfileValue(this UserProfile profile, String propertyName)
    {
        String propertyValue = String.Empty;
        ProfileValueCollectionBase propertyValues = profile.GetProfileValueCollection(propertyName);
        if ((propertyValues != null) && (propertyValues.Count != 0))
        {
            propertyValue = (String)propertyValues[0];
        }
        return propertyValue;
    }
}

After this short introduction to the code environment, let’s see the code that is responsible for the synchronization logic. In the SynchronizePhotos method we iterate through all users in the profile manager, check the user images both in AD and in the SharePoint profile, and act if the images are different:

public void SynchronizePhotos()
{
    using (SPSite site = new SPSite(_mySiteHostUrl))
    {
        using (SPWeb web = site.OpenWeb())
        {
            foreach (UserProfile userProfile in _profileManager)
            {
                // using our custom extension method
                String accountName = userProfile.GetProfileValue("AccountName");
                Trace.TraceInformation("SynchronizePhotos: Processing user: '{0}'", accountName);
 
                ADUtils au = new ADUtils(accountName);
 
                DateTime adPhotoLastModified = au.UserPhotoLastModified;
                // assigning a dummy value just to initialize the variable, will be updated later
                DateTime spPhotoLastModified = DateTime.MinValue;
 
                byte[] sharePointImageContent = null;
                byte[] activeDirectoryImageContent = au.ThumbnailPhoto;
 
                String pictureUrl =  userProfile.GetProfileValue("PictureUrl");
                // the picture URL must refer to the image stored on My Site Host
                if (!String.IsNullOrEmpty(pictureUrl))
                {
                    SPFile file = web.GetFile(pictureUrl);
                    if (file.Exists)
                    {
                        Trace.TraceInformation("SP profile photo found");
                        SPListItem listItem = file.GetListItem(new String[] { "Modified" });
                        spPhotoLastModified = (DateTime)listItem["Modified"];
                        sharePointImageContent = file.OpenBinary();
                    }
                }
 
                bool hasADPhoto = (activeDirectoryImageContent != null);
                bool hasSPProfilePhoto = (sharePointImageContent != null);
 
                if ((hasSPProfilePhoto) && (hasADPhoto))
                {
                    Trace.TraceInformation("Both AD and SP profile photos are specified, checking rules for update");
 
                    byte[] spHash = new MD5CryptoServiceProvider().ComputeHash(sharePointImageContent);
                    byte[] adHash = new MD5CryptoServiceProvider().ComputeHash(activeDirectoryImageContent);
 
                    bool sameImage = (Convert.ToBase64String(spHash) == Convert.ToBase64String(adHash));
 
                    // if different, try to synchronize based on last modified date in AD vs. SP
                    if (sameImage)
                    {
                        Trace.TraceInformation("AD and SP profile photos are the same, no further synchronization action required");
                    }
                    else
                    {
                        Trace.TraceInformation("AD photo last set: '{0}', SP profile photo last set: '{1}'", adPhotoLastModified, spPhotoLastModified);
                        if (spPhotoLastModified < adPhotoLastModified)
                        {
                            UpdatePhotoInSharePoint(activeDirectoryImageContent, accountName, web);
                        }
                        else
                        {
                            UpdatePhotoInActiveDirectory(sharePointImageContent, au);
                        }
                    }
                }
                else if (hasSPProfilePhoto) 
                {
                    Trace.TraceInformation("User has SP profile photo but no AD photo");
                    if (spPhotoLastModified < adPhotoLastModified)
                    {
                        Trace.TraceInformation("SP photo is older than AD last modified (deleted), delete SP photo");
                        DeletePhotoInSharePoint(accountName, web);
                    }
                    else
                    {
                        Trace.TraceInformation("SP photo is newer than AD last modified, copy SP photo to AD");
                        UpdatePhotoInActiveDirectory(sharePointImageContent, au);
                    }                            
                }
                else if (hasADPhoto)
                {
                    UpdatePhotoInSharePoint(activeDirectoryImageContent, accountName, web);
                }
                else
                {
                    Trace.TraceInformation("There is no AD or SP profile photo for user");
                }
 
                Trace.TraceInformation("SynchronizePhotos processing user: '{0}' finished", accountName);
            }
        }
    }
}

Important notes:

Before trying out the job, be sure that the SharePoint 2010 Timer service (SPTimerV4, OWSTIMER.EXE) is running, and the service account has write rights to alter Active Directory properties. For the sake of simplicity my service account has domain admin rights, but if you would like to set the permissions as recommended I suggest you to read this post, especially the section Nice, so what about actually writing back to AD (Sync)?:

Rational Guide to implementing SharePoint Server 2010 User Profile Synchronization

If you change the code it is important to restart the SharePoint 2010 Timer otherwise the new assembly won’t be loaded by the service.

The next image shows the timer job after deployment on the list of scheduled jobs:

If you click on the name of the job, the details are displayed. If you don’t want to wait for the job to be started automatically, you can click Run Now.

By clicking Run Now you will be navigated back to the list of scheduled jobs. If you would like to run the job once more but would not like to look up the job in the long list, simply click Back in Internet Explorer or use the Alt + Left Arrow key combination. After you re-deploy the solution you need to refresh the page in IE (use F5).

The code that reads and writes (copies to be exact) user images in SharePoint and AD are the same (or at least, very similar) to the previous version you can find in my former post.

As you can see, I’ve included plenty of trace commands to make it easier to track what happens during timer job installation and execution, for example by using DebugView. If you would like to follow the execution step-by-step, you can debug the timer job. Don’t forget to attach the debugger to OWSTIMER.EXE. You may find my Visual Studio extensions useful in this case.

You can test the results and modify the image for a user in SharePoint using the Manage User Profiles admin page on the Central Administration site.

If you do any changes in the profile, do not forget to click Save and Close on the top of the page to persist your changes.

To do the same in Active Directory I suggest you to install this extension that enables Active Directory Users and Computers to manage the thumbnailPhoto property a user friendly way:

Again, if you change the thumbnail, press Apply or OK.

Known issues, limitations:

If you have read the code thoughtfully, you might have already noticed that it does handle a special case the wrong way. If the same image exists both is SharePoint and AD, but deleted later in SharePoint, one can expect that the corresponding image will be deleted in the AD as well. Instead of this, the image from the AD will be copied back to SharePoint again.

The reason of this behavior is that there is no information in SharePoint (unless one would like to include audit data into the game) about when the images were deleted or when the PictureUrl property was set last time in the profile. In lack of this information we can not decide which of the systems is the current one, and we choose the action that does not cause data lost, copy the AD image to SharePoint, instead of deleting the AD image as well.

If we really need this functionality, we can replace the timer job with an event receiver that synchronize (update or delete) the corresponding AD image immediately when the SharePoint image has been changed or deleted.

This type of working would be complete by using AD change notification mechanism on the other side, something that described here:

Change Notifications in Active Directory Domain Services

Since these methods do not fit well into the timer job that is the topic of the current post, I ignore them for now. Maybe in a later post…

Comments (2)

August 10, 2010

Synchronizing user image between Active Directory and SharePoint profile

Filed under: Active Directory, Reflection, SP 2010, User profile — Tags: Active Directory, Reflection, SP 2010, User profile — Peter Holpar @ 01:30

As you may know Exchange 2010 and Outlook 2010 use the Picture attribute (better known as thumbnailPhoto based on its LDAP name) to store user and contact photos in Active Directory. You can learn more about that from this post in the Microsoft Exchange Team Blog.

Since I found no way in Outlook 2010 to set the photo, and found only (for an end user) cumbersome admin tools, like PowerShell and VBScript to upload the image. On the other side, SharePoint makes it possible for a user to upload her / his photo to the profile from the web UI easily.

Before trying to reinvent the wheel, I looked around on the web for similar solutions, but found only implementations (like this one) where an extension attribute of AD (like extensionAttribute3) was mapped to the ProfileURL SharePoint profile property.

My goal was a bit more: to synchronize the image binary as well, not only URLs. As I’ve already created tools to upload user photos from file system to SharePoint profile programmatically I thought it would be nice to reuse that knowledge on this task.

Although an ideal solution might be some kind of server process (for example a timer job), for the sake of simplicity and visibility I chose a Visual Web Part-based “self-service” implementation.

Let’s see the results first. You can find the code and the binaries as a single file download here.

When deploy the solution, you have to add the Profile Photo Sync WebPart to a page…

…and set its Root application partition property to the root of your AD.

Assuming there is no user photo in the profile nor in the AD, you should see something similar first:

Let’s upload our photo quickly to our SharePoint profile. It is done, the image is shown on the profile page. Let’s back to the web part. But wait a minute! The photo is still not visible there! What happened? I told you: wait a minute. SharePoint requires about one minute to push the profile property changes to the site. After it is done, the image is visible in the web part as expected:

If you press the >> button, the image is transferred to AD.

Now delete the image from the profile and refresh the page. The image can be found in the AD, but not in the SharePoint profile.

Try to load it back to SharePoint by pressing the << button. It seems to have no effect, but again you should wait a minute to see the result:

If you delete the image from the SharePoint profile again, refresh the page and now click on the >> button, you find that the photo is deleted from the AD as well and we are back to our starting point. Synchronizing an empty thumbnailPhoto property from AD to SharePoint profile deletes the image from the profile as well.

After this short demo let’s see some code blocks.

Since our control has to know where to look for AD properties we have to provide this iannformation for it. The web part has a property called DefaultPartition. The value of this property is forwarded to the user control in the CreateChildControls method.

[Personalizable(),
WebBrowsable(),
WebDisplayName("Root application partition")]
public string DefaultPartition
{
    get;
    set;
}
#endregion
 
protected override void CreateChildControls()
{
    ProfilePhotoSyncWebPartUserControl control = (ProfilePhotoSyncWebPartUserControl)Page.LoadControl(_ascxPath);
    control.DefaultPartition = DefaultPartition;
    Controls.Add(control);
}

The RefreshControls method is responsible for rendering the content of the UI. Since there is no built-in way to refer the thumbnailPhoto property in the AD via a URL, I made a quick and dirty hack there. If the request URL contains the UserName query string parameter, we clears the response, get the binary content from the thumbnailPhoto property and push that content to the response.

If the UserName query string parameter is not found in the request URL and the thumbnailPhoto property is not empty, I set the image URL of the AD image to the URL of the current page appending the current user name in the UserName query string parameter.

Similarly, if the PictureUrl user profile property is not empty in SharePoint I set the image URL for the SharePoint image to the value stored in the PictureUrl property.

If one or both of the properties would be empty then the corresponding image is hidden and a No photo label is shown as you can see on the images above.

private void RefreshControls()
        {
            String userName = Request.QueryString["UserName"];
 
            // hack: render response as image for AD "thumbnailPhoto" image
            if (!String.IsNullOrEmpty(userName))
            {
                Response.Clear();
                ADUtils adUtils = new ADUtils(DefaultPartition);
                using (DirectoryEntry root = adUtils.GetDefaultPartition())
                using (DirectoryEntry user = adUtils.FindUserByAccountName(userName))
                {
                    byte[] thumbnailPhotoBytes = (byte[])user.Properties["thumbnailPhoto"].Value;
                    if (thumbnailPhotoBytes != null)
                    {
                        Response.BinaryWrite(thumbnailPhotoBytes);
                    }
 
                }
                Response.End();
            }
            else
            {
                try
                {
                    ADUtils adUtils = new ADUtils(DefaultPartition);
                    using (DirectoryEntry root = adUtils.GetDefaultPartition())
                    using (DirectoryEntry user = adUtils.FindUserByAccountName(_shortName))
                    {
                        byte[] thumbnailPhotoBytes = (byte[])user.Properties["thumbnailPhoto"].Value;
                        bool hasThumbnailPhoto = (thumbnailPhotoBytes != null);
                        ADImage.Visible = hasThumbnailPhoto;
                        ADImageLabel.Visible = !hasThumbnailPhoto;
 
                        if (hasThumbnailPhoto)
                        {
                            ADImage.ImageUrl = String.Format("{0}?UserName={1}", Request.Url.GetLeftPart(UriPartial.Path), _shortName);
                        }
 
                    }
                }
                catch (Exception ex)
                {
                    Warning.Visible = true;
                }
 
                UserProfileManager userProfileManager = new UserProfileManager(SPServiceContext.Current);
                UserProfile userProfile = userProfileManager.GetUserProfile(_accountName);
 
                String pictureUrl = (String)userProfile["PictureUrl"].Value;
 
                bool hasProfilelPhoto = (!String.IsNullOrEmpty(pictureUrl));
 
                // double check to be sure the file is there to avoid "missing" images on the page
                // when removing the profile image on the UI it takes some time the change get reflected
                // in the profile property, but image is deleted immediately
                if (hasProfilelPhoto)
                {
                    using (SPSite site = new SPSite(pictureUrl))
                    {
                        using (SPWeb web = site.OpenWeb())
                        {
                            SPFile file = web.GetFile(pictureUrl);
                            hasProfilelPhoto = file.Exists;
                        }
                    }
                }
 
                SPImage.Visible = hasProfilelPhoto;
                SPImageLabel.Visible = !hasProfilelPhoto;
 
                if (hasProfilelPhoto != null)
                {
                    SPImage.ImageUrl = pictureUrl;
                }
 
            }
        }

When you click on the >> button to copy SharePoint profile image to AD the following code is called:

protected void SP2AD_Click(object sender, EventArgs e)
        {
 
            UserProfileManager userProfileManager = new UserProfileManager(SPServiceContext.Current);
            UserProfile userProfile = userProfileManager.GetUserProfile(_accountName);
 
            String pictureUrl = (String)userProfile["PictureUrl"].Value;
 
            bool hasProfilelPhoto = (!String.IsNullOrEmpty(pictureUrl));
 
            byte[] imageContent = null;
 
            // double check to be sure the file is there to avoid "missing" images on the page
            // when removing the profile image on the UI it takes some time the change get reflected
            // in the profile property, but image is deleted immediately
            if (hasProfilelPhoto)
            {
                using (SPSite site = new SPSite(pictureUrl))
                {
                    using (SPWeb web = site.OpenWeb())
                    {
                        SPFile file = web.GetFile(pictureUrl);
                        if (file.Exists)
                        {
                            imageContent = file.OpenBinary();
                        }
                    }
                }
            }
 
            ADUtils adUtils = new ADUtils(DefaultPartition);
            using (DirectoryEntry root = adUtils.GetDefaultPartition())
            using (DirectoryEntry user = adUtils.FindUserByAccountName(_shortName))
            {
                user.Properties["thumbnailPhoto"].Clear();
                if (imageContent != null)
                {
                    user.Properties["thumbnailPhoto"].Add(imageContent);
                }
                user.CommitChanges();
 
            }
 
            RefreshControls();
 
        }

Similarly, when you click << to copy image from AD to the SharePoint profile, the following code gets executed:

protected void AD2SP_Click(object sender, EventArgs e)
      {
          try
          {
              ADUtils adUtils = new ADUtils(DefaultPartition);
              using (DirectoryEntry root = adUtils.GetDefaultPartition())
              using (DirectoryEntry user = adUtils.FindUserByAccountName(_shortName))
              {
                  byte[] thumbnailPhotoBytes = (byte[])user.Properties["thumbnailPhoto"].Value;
                  bool hasThumbnailPhoto = (thumbnailPhotoBytes != null);
                  ADImage.Visible = hasThumbnailPhoto;
                  ADImageLabel.Visible = !hasThumbnailPhoto;
 
                  if (hasThumbnailPhoto)
                  {
                      using (SPSite site = new SPSite(GetMySiteHostUrl(SPContext.Current.Site)))
                      {
                          site.AllowUnsafeUpdates = true;
                          using (SPWeb web = site.OpenWeb())
                          {
                              web.AllowUnsafeUpdates = true;
                              ProfileImagePicker profileImagePicker = new ProfileImagePicker();
                              InitializeProfileImagePicker(profileImagePicker, web);
                              SPFolder subfolderForPictures = GetSubfolderForPictures(profileImagePicker);
 
                              UploadPhoto(_accountName, thumbnailPhotoBytes, subfolderForPictures);
                              SetPictureUrl(_accountName, subfolderForPictures);
                          }
                      }
                  }
              }
          }
          catch (Exception ex)
          {
              Warning.Visible = true;
          }
 
          RefreshControls();
 
      }

Helper methods in the AD2SP_Click method (UploadPhoto, SetPictureUrl, GetMySiteHostUrl etc.) are similar to the ones used in my former solutions here and here.

Active Directory related code is included in the ADUtils class (see credits later):

public class ADUtils
    {
 
        public ADUtils(String defaultPartition)
        {
            DefaultPartition = defaultPartition;
        }
 
        private String DefaultPartition
        {
            get;
            set;
        }
 
        /// <summary>
        /// Retrieves a DirectoryEntry using configuration data
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public DirectoryEntry CreateDirectoryEntry(string path)
        {
            return new DirectoryEntry(String.Format("LDAP://{0}", path));
        }
 
        /// <summary>
        /// Creates a DirectoryEntry from the DefaultPartition defined in config
        /// </summary>
        /// <returns></returns>
        public DirectoryEntry GetDefaultPartition()
        {
            return CreateDirectoryEntry(DefaultPartition);
        }
 
        /// <summary>
        /// Simple method to find and return a user using the CN name and searching the
        /// defaultNamingContext defined in config.
        /// </summary>
        /// <param name="userRDN"></param>
        /// <returns></returns>
        public DirectoryEntry FindUserByCN(string userRDN)
        {
            using (DirectoryEntry searchRoot = GetDefaultPartition())
            {
                DirectorySearcher ds = new DirectorySearcher(
                    searchRoot,
                    String.Format("(cn={0})", userRDN),
                    new string[] { "cn" },
                    SearchScope.Subtree
                    );
 
                SearchResult sr = ds.FindOne();
 
                return (sr != null) ? sr.GetDirectoryEntry() : null;
            }
        }
 
        /// <summary>
        /// Simple method to find and return a user using the sAMAccountName name and searching the
        /// defaultNamingContext defined in config.
        /// </summary>
        /// <param name="userRDN"></param>
        /// <returns></returns>
        public  DirectoryEntry FindUserByAccountName(string accountName)
        {
            Trace.TraceInformation("FindUserByAccountName method called. Account name: '{0}'", accountName);
            using (DirectoryEntry searchRoot = GetDefaultPartition())
            {
                DirectorySearcher ds = new DirectorySearcher(
                    searchRoot,
                    String.Format("(sAMAccountName={0})", accountName),
                    new string[] { "sAMAccountName" },
                    SearchScope.Subtree
                    );
 
                SearchResult sr = ds.FindOne();
                Trace.TraceInformation("FindUserByAccountName user found. Path: '{0}'", sr.Path);
                return (sr != null) ? sr.GetDirectoryEntry() : null;
            }
        }
 
    }

Note: The sample web part provided “as is”, and is intended to be used only as a proof of concept.

Important point on security: The sample should work only when at least two of the followings are located on the same computer: browser, SharePoint 2010 front end, Active Directory domain controller. If all of these three are located on a different computer and there is no Kerberos implemented then you should be prepared for the so-called double hops issue.

My general recommendation for that problem is accessing the resource (in this case the AD) using a service user account that has access to all the requested information. One can store the service account credentials for example in SSO or in an encrypted configuration parameter.

Implementing this features require some modifications in the current code. For example, you have to use a DirectoryEntry constructor in the CreateDirectoryEntry method of ADUtils class that has user name and password parameters.

You will not have such issues if you alter the solution to a server process, like timer job that runs as a dedicated user account.

Credits: I would like to say thanks to Joe Kaplan and Ryan Dunn for their book The .NET Developer’s Guide to Directory Services Programming. The book and the code samples are definitely a must for every .NET programmer who wants (or has) to dive into the beauty of Active Directory programming. The ADUtils class in my sample is based on a solution found in the book.

Comments (9)

April 16, 2010

Getting the My Site host URL from code

Filed under: Reflection, SP 2010, User profile — Tags: Reflection, SP 2010, User profile — Peter Holpar @ 15:59

I had to determine the URL of the My Site host that belongs to a given site.

One of the possible solution might have been to iterate through the web applications and site collections, looking for a site that is based on the SPSMSITEHOST, but since I felt this solution not enough scientific I decided to look up how the built-in PersonalSites.aspx page work. You can access the page through Central Administration / Application Management / Manage service applications / Manage Profile Service: User Profile Service / My Site Settings / Setup My Sites, where User Profile Service is the name of the User Profile Service instance on the SP 2010.

This page is inherited from Microsoft.SharePoint.Portal.UserProfiles.AdminUI.PersonalSites (Microsoft.SharePoint.Portal).

The OnLoad method of the page looks like this:

SPSite site = SPContext.Current.Site;
UserProfileApplication currentApplication = ProfileAdminPage.CurrentApplication;
Guid currentPartitionId = ProfileAdminPage.CurrentPartitionId;
string mySitePortalUrl = currentApplication.GetMySitePortalUrl(site.Zone, currentPartitionId);

Unfortunately, the ProfileAdminPage.CurrentApplication property gets the current application ID from a query string parameter, and the ProfileAdminPage.CurrentPartitionId property also contains references to the current SPServiceContext and SPContext objects, so I can not set this values from my code, for example from a console application.

Creating a UserProfileApplication using the constructor and calling the internal

GetMySitePortalUrl(SPUrlZone zone, SPServiceContext serviceContext) method also don’t work because of a NullReferenceException. I had to get the UserProfileApplication instance using an algorithm similar to the one implemented in the

CurrentUserProfileServiceApplication method of the Microsoft.SharePoint.Portal.UserProfiles.AdminUI.NewProfileServiceSettingsPage (Microsoft.SharePoint.Portal) class.

The final code includes a lot of Reflection calls, but seems to work.

You should add reference to the Microsoft.Office.Server.UserProfiles assembly (and to Microsoft.SharePoint as always), and add the following using directives to the code:

using System.Reflection;
using System.Collections;
using Microsoft.Office.Server.UserProfiles;
using Microsoft.SharePoint.Administration;

Here comes the code itself. At the second part of the code we iterate through the user profile applications. Since there is usually a single application instance, I commented out this section, feel free to comment that back and pass an additional application ID parameter to the method if you need that feature.

private string GetMySiteHostUrl(SPSite site)
{
 
    String result = String.Empty;
           
    // hack to get the Microsoft.Office.Server.UserProfiles assembly
    Assembly userProfilesAssembly = typeof(UserProfile).Assembly;
    // UserProfileApplication and UserProfileService are internal classes, 
    // so you cannot get them directly from Visual Studio 
    // like I do with the SPServiceCollection type
    Type userProfileApplicationType = userProfilesAssembly.GetType("Microsoft.Office.Server.Administration.UserProfileApplication");
    Type userProfileServiceType = userProfilesAssembly.GetType("Microsoft.Office.Server.Administration.UserProfileService");
    Type spServiceCollectionType = typeof(SPServiceCollection);
            
    // first we call
    // SPFarm.Local.Services.GetValue<UserProfileService>()
 
    MethodInfo mi_GetValue = spServiceCollectionType.GetMethod("GetValue",
            BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null
            );
    if (mi_GetValue != null)
    {
        // get the generic version of GetValue method
        MethodInfo mi_GetValueGeneric = mi_GetValue.MakeGenericMethod(userProfileServiceType);
        if (mi_GetValueGeneric != null)
        {
            Object userProfileService = mi_GetValueGeneric.Invoke(SPFarm.Local.Services, null);
 
            System.Reflection.PropertyInfo pi_Applications = userProfileServiceType.GetProperty("Applications", BindingFlags.NonPublic | BindingFlags.Instance);
            if ((pi_Applications != null) && (userProfileService != null))
            {
                // Microsoft.Office.Server.Administration.UserProfileApplicationCollection 
                Object userProfileApplicationCollection = pi_Applications.GetValue(userProfileService, null);
                if (userProfileApplicationCollection != null)
                {
                    foreach (Object userProfileApplication in (IEnumerable)userProfileApplicationCollection)
                    {
                        // you could compare the id for the service application id
                        // it is useful if there are multiple user profile service application instances
                        // since it is not common I ignore the condition now and exit after the first item
                                
                        //System.Reflection.PropertyInfo pi_Id = userProfileApplicationType.GetProperty("Id", BindingFlags.Public | BindingFlags.Instance);
                        //if (pi_Id != null)
                        //{
                        //    Guid id = (Guid)pi_Id.GetValue(userProfileApplication, null);                                    
                            //if (appId == id)
                            //{
 
                                Type[] parameterTypes = new Type[2] { typeof(SPUrlZone), typeof(SPServiceContext) };
                                MethodInfo mi_GetMySitePortalUrl = userProfileApplicationType.GetMethod("GetMySitePortalUrl",
                                    BindingFlags.NonPublic | BindingFlags.Instance, null, parameterTypes, null
                                    );
                                if (mi_GetMySitePortalUrl != null)
                                {
                                    result = (String)mi_GetMySitePortalUrl.Invoke(userProfileApplication, new object[] { site.Zone, SPServiceContext.GetContext(site) });
                                }
 
                                break;
                            //}
 
                        //}
                    }
                }
            }
        }
    }
 
    return result;
 
}

Comments (14)

March 17, 2010

Creating profile properties and sections the SharePoint 2010 way – part 2, The code

Filed under: SP 2010, User profile — Tags: SP 2010, User profile — Peter Holpar @ 02:53

After the theory of properties in the first part now let’s see the code itself.

Create a new console application and add references to Microsoft.Office.Server, Microsoft.Office.Server.UserProfiles, Microsoft.SharePoint, Microsoft.SharePoint.Taxonomy and System.Web assemblies.

For the sake of simplicity we store manager classes as instance variables.

using System;
using Microsoft.SharePoint;
using Microsoft.Office.Server.UserProfiles;
using Microsoft.SharePoint.Taxonomy;
using Microsoft.Office.Server;
using Microsoft.SharePoint.Administration;
namespace CreateUserProfileProps
{
class Program
{
private SPSite _site;
private SPServiceContext _serviceContext;
private UserProfileManager _profileManager;
private ProfileSubtypePropertyManager _profileSubtypePropertyManager;
private UserProfileConfigManager _userProfileConfigManager;
private ProfilePropertyManager _profilePropertyManager;
private CorePropertyManager _corePropertyManager;
private ProfileTypePropertyManager _profileTypePropertyManager;
static void Main(string[] args)
{
String siteUrl = "http://sp2010";
using (SPSite site = new SPSite(siteUrl))
{
Program prog = new Program(site);
prog.ProcessProps();
prog = null;
}
}

In the constructor we initialize the instance variables we defined above.

public Program(SPSite site)
{
_site = site;
_serviceContext = SPServiceContext.GetContext(_site);
_userProfileConfigManager = new UserProfileConfigManager(_serviceContext);
_profilePropertyManager = _userProfileConfigManager.ProfilePropertyManager;
_profileManager = new UserProfileManager(_serviceContext);
_profileSubtypePropertyManager = _profileManager.DefaultProfileSubtypeProperties;
// if you need another profile subtype
//_profileSubtypePropertyManager = _profilePropertyManager.GetProfileSubtypeProperties("ProfileSubtypeName");
_corePropertyManager = _profilePropertyManager.GetCoreProperties();
_profileTypePropertyManager = _profilePropertyManager.GetProfileTypeProperties(ProfileType.User);
}

This helper method is useful to enumerate different type of properties when working with the application.

private void EnumerateProperties()
{
Console.WriteLine("ProfileSubtypeProperty list");
foreach (ProfileSubtypeProperty profileSubtypeProperty in _profileSubtypePropertyManager.PropertiesWithSection)
{
Console.WriteLine("{0} name: {1}, display name: {2}, type property name: {3}, core property name: {4}, display order: {5}",
profileSubtypeProperty.IsSection ? "Section" : "Property",
profileSubtypeProperty.Name,
profileSubtypeProperty.DisplayName,
profileSubtypeProperty.TypeProperty.Name,
profileSubtypeProperty.CoreProperty.Name,
profileSubtypeProperty.DisplayOrder);
}
Console.WriteLine("ProfileTypeProperty list");
foreach (ProfileTypeProperty profileTypeProperty in _profileTypePropertyManager.PropertiesWithSection)
{
Console.WriteLine("{0} name: {1}, core property name: {2}",
profileTypeProperty.IsSection ? "Section" : "Property",
profileTypeProperty.Name,
profileTypeProperty.CoreProperty.Name);
}
Console.WriteLine("CoreProperty list");
foreach (CoreProperty coreProperty in _corePropertyManager.PropertiesWithSection)
{
Console.WriteLine("{0} name: {1} display name: {2}, type: {3}, use count: {4}",
coreProperty.IsSection ? "Section" : "Property",
coreProperty.Name,
coreProperty.DisplayName,
coreProperty.Type,
//coreProperty.UseCount
"BUG!"
);
}
}

Next, we define some helper methods that we use to determine the display order of the properties we create.

The first one is the GetDisplayOrderForLastSection method that returns the DisplayOrder property of the last section. We use the value later in the CreateOrUpdateSection method to get the DisplayOrder of a new section.

private int GetDisplayOrderForLastSection()
{
int displayOrder = 0;
foreach (ProfileSubtypeProperty profileSubtypeProperty in _profileSubtypePropertyManager.PropertiesWithSection)
{
if (profileSubtypeProperty.IsSection)
{
if (profileSubtypeProperty.DisplayOrder > displayOrder)
{
displayOrder = profileSubtypeProperty.DisplayOrder;
}
}
}
return displayOrder;
}

The GetLastDisplayOrderForSection method makes it easy to get the DisplayOrder property of the last property within the specified section.

private int GetLastDisplayOrderForSection(ProfileSubtypeProperty section)
{
int displayOrder = 0;
foreach (ProfileSubtypeProperty profileSubtypeProperty in _profileSubtypePropertyManager.PropertiesWithSection)
{
if ((section.DisplayOrder < displayOrder) && (profileSubtypeProperty.IsSection))
{
break;
}
displayOrder = profileSubtypeProperty.DisplayOrder;
}
return displayOrder;
}
private int GetLastDisplayOrderForSection(string sectionName)
{
ProfileSubtypeProperty section = _profileSubtypePropertyManager.GetSectionByName(sectionName);
return GetLastDisplayOrderForSection(section.Name);
}

The GetSectionForProperty method returns the section the specified property belongs to.

private ProfileSubtypeProperty GetSectionForProperty(ProfileSubtypeProperty property)
{
ProfileSubtypeProperty section = null;
foreach (ProfileSubtypeProperty profileSubtypeProperty in _profileSubtypePropertyManager.PropertiesWithSection)
{
if (profileSubtypeProperty.IsSection)
{
section = profileSubtypeProperty;
}
if (profileSubtypeProperty.Name == property.Name)
{
break;
}
}
return section;
}
private ProfileSubtypeProperty GetSectionForProperty(string propertyName)
{
ProfileSubtypeProperty property = _profileSubtypePropertyManager.GetPropertyByName(propertyName);
return GetSectionForProperty(property.Name);
}

The CreateOrUpdateSection method creates a section based on the specified name and display name.

private ProfileSubtypeProperty CreateOrUpdateSection(string name, string displayName)
{
if ((_corePropertyManager.GetPropertyByName(name) != null)
|| (_profileTypePropertyManager.GetPropertyByName(name) != null)
|| (_profileSubtypePropertyManager.GetPropertyByName(name) != null))
{
throw new Exception(String.Format("WARNING! Property with the same name ‘{0}’ exists.", name));
}
CoreProperty coreProperty = _corePropertyManager.GetSectionByName(name);
bool exist = (coreProperty != null);
if (!exist)
{
coreProperty = _corePropertyManager.Create(true);
coreProperty.Name = name;
}
coreProperty.DisplayName = displayName;
if (exist)
{
coreProperty.Commit();
}
else
{
_corePropertyManager.Add(coreProperty);
}
ProfileTypeProperty profileTypeProperty = _profileTypePropertyManager.GetSectionByName(name);
if (profileTypeProperty == null)
{
profileTypeProperty = _profileTypePropertyManager.Create(coreProperty);
_profileTypePropertyManager.Add(profileTypeProperty);
}
ProfileSubtypeProperty profileSubTypeProperty = _profileSubtypePropertyManager.GetSectionByName(coreProperty.Name);
if (profileSubTypeProperty == null)
{
// we should get the display order before creating our new section
// otherwise its display order will be returned when trying to get
// the display order of the last section
int lastSectionDisplayOrder = GetDisplayOrderForLastSection();
profileSubTypeProperty = _profileSubtypePropertyManager.Create(profileTypeProperty);
_profileSubtypePropertyManager.Add(profileSubTypeProperty);
// set the position for new section by adding 100 to the last section
_profileSubtypePropertyManager.SetDisplayOrderBySectionName(name, lastSectionDisplayOrder + 100);
_profileSubtypePropertyManager.CommitDisplayOrder();
}
return profileSubTypeProperty;
}

The CreateOrUpdateProfileTypeProperty method creates or gets the specified type property and sets the type property level settings: the IsVisibleOnViewer and the IsVisibleOnEditor. We could set CoreProperty type specific values here as well, like the MaximumShown property for mulivalue string profile properties, but I wouldn’t like to make the example more complex than necessary.

private ProfileTypeProperty CreateOrUpdateProfileTypeProperty(CoreProperty coreProperty, bool isVisibleOnEditor, bool isVisibleOnViewer)
{
ProfileTypeProperty profileTypeProperty =
_profileTypePropertyManager.GetPropertyByName(coreProperty.Name);
if (profileTypeProperty == null)
{
profileTypeProperty = _profileTypePropertyManager.Create(coreProperty);
_profileTypePropertyManager.Add(profileTypeProperty);
}
profileTypeProperty.IsVisibleOnViewer = isVisibleOnViewer;
profileTypeProperty.IsVisibleOnEditor = isVisibleOnEditor;
profileTypeProperty.Commit();
return profileTypeProperty;
}

The CreateOrUpdateSubtypeProperty method gets the type property first by calling the CreateOrUpdateProfileTypeProperty method, then sets subtype property level settings like IsUserEditable, DefaultPrivacy, and PrivacyPolicy. If a section is specified and it is not the actual section of the subtype property, then the new DisplayOrder value is set either.

private ProfileSubtypeProperty CreateOrUpdateSubtypeProperty(CoreProperty coreProperty,
bool required, Privacy privacy, bool isVisibleOnEditor, bool isVisibleOnViewer,
bool isUserEditable, ProfileSubtypeProperty section)
{
ProfileTypeProperty profileTypeProperty = CreateOrUpdateProfileTypeProperty(coreProperty,
isVisibleOnEditor, isVisibleOnViewer);
ProfileSubtypeProperty profileSubTypeProperty =
_profileSubtypePropertyManager.GetPropertyByName(coreProperty.Name);
if (profileSubTypeProperty == null)
{
profileSubTypeProperty = _profileSubtypePropertyManager.Create(profileTypeProperty);
_profileSubtypePropertyManager.Add(profileSubTypeProperty);
// set the section if specified and differs from the current one
if ((section != null)
&& (section.Name != GetSectionForProperty(profileSubTypeProperty).Name))
{
int displayOrder = GetLastDisplayOrderForSection(section);
_profileSubtypePropertyManager.SetDisplayOrderByPropertyName(coreProperty.Name,
displayOrder + 1);
_profileSubtypePropertyManager.CommitDisplayOrder();
}
}
profileSubTypeProperty.IsUserEditable = isUserEditable;
profileSubTypeProperty.DefaultPrivacy = privacy;
profileSubTypeProperty.PrivacyPolicy = (required ? PrivacyPolicy.Mandatory :
PrivacyPolicy.OptIn);
profileSubTypeProperty.Commit();
return profileSubTypeProperty;
}

The CreateOrUpdateDateProperty and the CreateOrUpdateIntProperty methods simply calls forward to the CreateOrUpdateProperty method specifying the requested property type date and integer.

private ProfileSubtypeProperty CreateOrUpdateDateProperty(string name, string displayName,
string description, bool required, Privacy privacy, bool isVisibleOnViewer,
bool isVisibleOnEditor, bool isUserEditable, ProfileSubtypeProperty section)
{
return CreateOrUpdateProperty(name, "date", displayName,
description, required, privacy, isVisibleOnViewer,
isVisibleOnEditor, isUserEditable, section, null, null);
}
private ProfileSubtypeProperty CreateOrUpdateIntProperty(string name, string displayName,
string description, bool required, Privacy privacy, bool isVisibleOnViewer,
bool isVisibleOnEditor, bool isUserEditable, ProfileSubtypeProperty section)
{
return CreateOrUpdateProperty(name, "integer", displayName,
description, required, privacy, isVisibleOnViewer,
isVisibleOnEditor, isUserEditable, section, null, null);
}

The CreateOrUpdateStringProperty method is a bit more complex. It contains an extra Action for the CustomProperty that is run when the property is created and sets some string property type specific values like Length, IsMultivalued and TermSet. TermSet can be set on an existing CoreProperty instance, so we set it in the Action that is defined for the update either. The Length, IsMultivalued properties cannot set on an existing instance.

private ProfileSubtypeProperty CreateOrUpdateStringProperty(string name, string displayName,
string description, int length, bool isMultiValued, string separator, string termStoreName,
string groupName, string termSetName, bool required, Privacy privacy, bool isVisibleOnViewer,
bool isVisibleOnEditor, bool isUserEditable, ProfileSubtypeProperty section)
{
TermSet termSet = null;
if ((!String.IsNullOrEmpty(termStoreName))
&& (!String.IsNullOrEmpty(groupName))
&& (!String.IsNullOrEmpty(termSetName)))
{
TaxonomySession session = new TaxonomySession(_site);
TermStore termStore = session.TermStores[termStoreName];
Group group = termStore.Groups[groupName];
termSet = group.TermSets[termSetName];
}
Action<CoreProperty> customSettingsOnCreate =
coreProperty =>
{
// for multivalue and taxonomic properties the length
// will be set to 3600 chars by default
if ((!isMultiValued) && (termSet == null))
{
coreProperty.Length = length;
}
coreProperty.IsMultivalued = isMultiValued;
if ((isMultiValued) && (!String.IsNullOrEmpty(separator)))
{
coreProperty.Separator = (MultiValueSeparator)Enum.Parse(typeof(MultiValueSeparator), separator);
}
if (termSet != null)
{
coreProperty.TermSet = termSet;
}
};
Action<CoreProperty> customSettingsOnUpdate =
coreProperty =>
{
if (termSet != null)
{
coreProperty.TermSet = termSet;
}
};
return CreateOrUpdateProperty(name, String.Format("string ({0} Value)",
isMultiValued ? "Multi" : "Single"),
displayName, description, required, privacy, isVisibleOnViewer,
isVisibleOnEditor, isUserEditable, section, customSettingsOnCreate, customSettingsOnUpdate);
}

The CreateOrUpdateCoreProperty method creates the requested CoreProperty or returns an existing instance and sets the properties that are common for each property type, like Name, Type and DisplayName. Property type specific settings can be injected using the Action instances that are run after property creation or update.

private CoreProperty CreateOrUpdateCoreProperty(string name, string propertyType,
string displayName, string description, Action<CoreProperty> customSettingsOnCreate, Action<CoreProperty> customSettingsOnUpdate)
{
if ((_corePropertyManager.GetSectionByName(name) != null)
|| (_profileTypePropertyManager.GetSectionByName(name) != null)
|| (_profileSubtypePropertyManager.GetSectionByName(name) != null))
{
throw new Exception(String.Format("WARNING! Section with the same name ‘{0}’ exists.",
name));
}
CoreProperty coreProperty = _corePropertyManager.GetPropertyByName(name);
bool exist = (coreProperty != null);
if (!exist)
{
coreProperty = _corePropertyManager.Create(false);
coreProperty.Name = name;
coreProperty.Type = propertyType;
}
if (coreProperty.Type.ToLower() == propertyType.ToLower())
{
coreProperty.DisplayName = displayName;
coreProperty.Description = description;
if (exist)
{
// call custom settings method if specified
if (customSettingsOnUpdate != null)
{
customSettingsOnUpdate.Invoke(coreProperty);
}
coreProperty.Commit();
}
else
{
// call custom settings method if specified
if (customSettingsOnCreate != null)
{
customSettingsOnCreate.Invoke(coreProperty);
}
_corePropertyManager.Add(coreProperty);
}
}
else
{
throw new Exception(String.Format("The CoreProperty with the specified name ‘{0}’ exists, but is a type of ‘{1}’ not ‘{2}’ ",
name, coreProperty.Type, propertyType));
}
return coreProperty;
}

The CreateOrUpdateProperty method is a wrapper over the CreateOrUpdateCoreProperty and the CreateOrUpdateSubtypeProperty methods and serves as a helper method for the property type specific methods we saw above (CreateOrUpdateDateProperty, CreateOrUpdateIntProperty, CreateOrUpdateStringProperty).

private ProfileSubtypeProperty CreateOrUpdateProperty(string name, string propertyType, string displayName,
string description, bool required, Privacy privacy, bool isVisibleOnViewer,
bool isVisibleOnEditor, bool isUserEditable, ProfileSubtypeProperty section,
Action<CoreProperty> customSettingsOnCreate, Action<CoreProperty> customSettingsOnUpdate)
{
CoreProperty coreProperty = CreateOrUpdateCoreProperty(name, propertyType,
displayName, description, customSettingsOnCreate, customSettingsOnUpdate);
ProfileSubtypeProperty profileSubTypeProperty = CreateOrUpdateSubtypeProperty(
coreProperty, required, privacy, isVisibleOnEditor, isVisibleOnViewer,
isUserEditable, section);
return profileSubTypeProperty;
}

The following code block shows some examples of these methods. It creates a new section and adds a few profile properties to the new section. Of course, you should change the taxonomy related values, the term store, the group and the term set name to something existing one in your environment.

The code finally starts the profile information synchronization process that is the UserProfile – Profile Synchronization Job of the User Profile Service. See this post for details and code of the StartServiceJob method. It makes the time the new section and properties appear on the Edit User Profile Property management user interface shorter, although not immediate, so you have to wait a few seconds for the results.

private void ProcessProps()
{
try
{
ProfileSubtypeProperty mySection = CreateOrUpdateSection("MySection", "My section");
ProfileSubtypeProperty profileSubtypeProperty1 = CreateOrUpdateStringProperty("TaxonomyProperty", "Taxonomy property",
"It is a taxonomy property. Created from code.", 100, false, null, "Metadata", "Test", "Languages",
true, Privacy.Public, true, true, true, mySection);
ProfileSubtypeProperty profileSubtypeProperty2 = CreateOrUpdateStringProperty("MultivalueProperty", "Multivalue property",
"It is a multivalue property. Created from code.", 50, true, null, null, null, null,
false, Privacy.Manager, true, true, true, mySection);
ProfileSubtypeProperty profileSubtypeProperty3 = CreateOrUpdateIntProperty("IntegerProperty", "Integer property",
"It is an integer property. Created from code.",
false, Privacy.Manager, true, true, true, mySection);
ProfileSubtypeProperty profileTypeProperty4 = CreateOrUpdateDateProperty(
"MyDateProp", "My date property", "This is my date property. Created from code.",
false, Privacy.Private, true, true, true, mySection);
// start UserProfile – Profile Synchronization Job
StartServiceJob("User Profile Service", "UserProfile_ProfileSynchronizationJob");
}
catch (Exception ex)
{
Console.WriteLine("ERROR: {0}", ex.Message);
}
}

Comments (7)

Creating profile properties and sections the SharePoint 2010 way – part 1, The theory

Filed under: SP 2010, User profile — Tags: SP 2010, User profile — Peter Holpar @ 02:50

Although the code samples for SharePoint 2010 use the UserProfileManager class to create profile properties, you receive the following warning message when trying to build the code:

Warning 1 ‘Microsoft.Office.Server.UserProfiles.ProfileManagerBase.Properties’ is obsolete: ‘"PropertyCollection is replaced by ProfileSubtypePropertyManager. Use ProfilePropertyManager to retrieve proper ProfileSubtypePropertyManager."’

In this post I show you how to create profile properties in SharePoint 2010 that leverage the full power of the new features like taxonomic properties bound to term sets. In the first part I introduce you the basics of the profile property handling in SharePoint 2010. The next part contains the code to create the properties.

In SharePoint 2010 there are three levels of properties each of these has its specific purpose and the set of behavior to configure.

The core property (CoreProperty class) is the most “physical” of the three. It contains information about the data type (Type property), display name (DisplayName property), description (Description property), length (Length property), multivalue (IsMultivalued property), separator for the multiple value (Separator property), term set (TermSet property), etc.

The CoreProperty contains the search related settings, like the IsAlias and IsSearchable properties and the information about the property usage in the UseCount property.

The next level is the type property (ProfileTypeProperty class). It contains information about how the property is rendered on the user interface. For example, whether it is included in the property view and edit forms (IsVisibleOnViewer and IsVisibleOnEditor properties), the maximum number of values to show before displaying ellipsis on the edit form for multivalue string profile properties (MaximumShown property) or whether the system should track updates to the property in the User Profile Change Log (IsEventLog property).

The IsReplicable property determines whether the property is replicable or not.

The uppermost level is the subtype property (ProfileSubtypeProperty class). It is basically some kind of mapping between the property and the profile subtype. A given profile property may have different settings for different profile subtypes.

The profile subtype property specifies the policy setting (PrivacyPolicy property), the default privacy setting (DefaultPrivacy property) if the users can override the default privacy setting (UserOverridePrivacy property) and if the users are allowed to edit values for the property (IsUserEditable property). The display order within the profile subtype (DisplayOrder property) can be also set for the specific subtype property.

All of these property classes are subclasses of the PropertyBase class. The property classes can be accessed through manager classes (CorePopertyManager, ProfileTypePropertyManager and ProfileSubtypePropertyManger classes) that are subclasses of the PropertyBaseManager class.

There are a special type of properties, that is section. The section is nothing more than a placeholder property that has a display order to separate group of properties. The IsSection property specifies if the actual property is a section.

The DisplayOrder of the neighbor sections has a difference of 100 by default, so there is space for adding new properties for existing sections.

After this quick start on properties I show you how to create properties using code in the next part.

Comments (3)

Working with profile subtypes from code

Filed under: SP 2010, User profile — Tags: SP 2010, User profile — Peter Holpar @ 00:36

Profile properties are organized into profile subtypes in SharePoint 2010.

Profile subtypes can be created for different profile types. The ProfileType enumeration has three values: User, Group and Organization.

The following code snippet shows how to create a new profile subtype, how to enumerate existing profile subtypes, how to get reference for existing profile subtypes and how to delete existing profile subtypes.

String siteUrl = "http://sp2010&quot;;
using (SPSite site = new SPSite(siteUrl))
{
    SPServiceContext serviceContext = SPServiceContext.GetContext(site);
    ProfileSubtypeManager profileSubtypeManager = ProfileSubtypeManager.Get(serviceContext);
    ProfileSubtype myProfileSubtype = profileSubtypeManager.CreateSubtype("MyProfiletype", "My new profile subtype", ProfileType.User);
    foreach (ProfileSubtype profileSubtype in profileSubtypeManager.GetSubtypesForProfileType(ProfileType.User))
    {
        Console.WriteLine("Profile subtype ID: '{0}', name: '{1}', display name: '{2}'",
            profileSubtype.SubtypeID, profileSubtype.Name, profileSubtype.DisplayName);
    }
 
    // getting references for the same profile subtype
    ProfileSubtype myProfileSubtype2 = profileSubtypeManager.GetProfileSubtype(myProfileSubtype.SubtypeID);
    ProfileSubtype myProfileSubtype3 = profileSubtypeManager.GetProfileSubtype(myProfileSubtype.Name);
 
    // deleting the profile subtype
    myProfileSubtype.Delete();
    // or the same using the subtype manager
    //profileSubtypeManager.DeleteSubtype(myProfileSubtype.Name);
}

If you step through the code above line by line, you may notice that although the code is run successfully and the new profile subtype is created and showed when enumerating the existing ones, the new subtype is not shown on the user interface, for example, when you would like to create a new property.

It is due to the fact, that profile information is synchronized by the UserProfile – Profile Synchronization Job of the User Profile Service. This service runs every minutes by default. See this post if you want to run the synchronization process immediately after the change.

March 13, 2010

Orphaned type property and core property items

Filed under: Bugs, SP 2010, User profile — Tags: Bugs, SP, User profile — Peter Holpar @ 00:56

There is a serious design issue with user and organization profile properties in the beta 2 version of SharePoint 2010.

I found that if you create a property you may forget to check the Sub-type of Profile. There is no default Sub-type, and selecting one is not mandatory as shown below:

In this case, the type and core properties are created, but the sub-type property is not created. It means that the new property will not part of any of the profile sub-types, and will be inaccessible from the Manage Profile Service web user interface. It has the side-effect, that you can’t create a new property having the same name as the former one, since you get a warning like this: The property you tried to add is a duplicate of another property in the profile.

The same is true when you delete a property using the web admin UI, or delete the sub-type on the Manage Sub-types page.

The profile properties specifically associated with this sub-type will be deleted. Profile properties shared by this sub-type will continue to be used by other sub-types. Do you want to continue?

In the latter case, the not shared sub-types are really deleted, but type and core properties are not, and will prohibit re-creating properties with the same name.

As a workaround we should clean these properties from code. (Or please, let me know how can I do that through the UI!)

Create a new console application and add references to Microsoft.Office.Server, Microsoft.Office.Server.UserProfiles, Microsoft.SharePoint and System.Web assemblies.

using System;
using Microsoft.SharePoint;
using Microsoft.Office.Server.UserProfiles;
using Microsoft.SharePoint.Taxonomy;
using Microsoft.Office.Server;
 
namespace CreateUserProfileProps
{
    class Program
    {
        private static SPServiceContext _serviceContext;
        private static UserProfileManager _profileManager;
        private static ProfileSubtypePropertyManager _profileSubtypePropertyManager;
        private static UserProfileConfigManager _userProfileConfigManager;
        private static ProfilePropertyManager _profilePropertyManager;
        private static CorePropertyManager _corePropertyManager;
        private static ProfileTypePropertyManager _profileTypePropertyManager;
 
        static void Main(string[] args)
        {
            String siteUrl = "http://sp2010&quot;;
 
            using (SPSite site = new SPSite(siteUrl))
            {
 
                _serviceContext = SPServiceContext.GetContext(site);
                _userProfileConfigManager = new UserProfileConfigManager(_serviceContext);
                _profilePropertyManager = _userProfileConfigManager.ProfilePropertyManager;
 
                _profileManager = new UserProfileManager(_serviceContext);
                _profileSubtypePropertyManager = _profileManager.DefaultProfileSubtypeProperties;
                // if you need another profile subtype
                //_profileSubtypePropertyManager = _profilePropertyManager.GetProfileSubtypeProperties("ProfileSubtypeName");
 
                _corePropertyManager = _profilePropertyManager.GetCoreProperties();
                _profileTypePropertyManager = _profilePropertyManager.GetProfileTypeProperties(ProfileType.User);

I’ve created a few helper method to check if the specified sub-type property, type property or core property exists in a specific type of profile sub-type (sorry for the lot of properties and types, but it seems we have to get used to them).

private static bool FoundInProfileType(ProfileSubtypeProperty profileSubtypeProperty, ProfileType profileType)
{
 
    ProfileSubtypeManager profileSubtypeManager = ProfileSubtypeManager.Get(_serviceContext);
 
    foreach (ProfileSubtype profileSubtype in profileSubtypeManager.GetSubtypesForProfileType(profileType))
    {
        ProfileSubtypePropertyManager profileSubtypePropertyManager = profileSubtype.Properties;
        if (profileSubtypePropertyManager != null)
        {
            ProfileSubtypeProperty profileSubtypePropertyRef = profileSubtypePropertyManager.GetPropertyByName(profileSubtypeProperty.CoreProperty.Name);
            if (profileSubtypePropertyRef != null)
            {
                return true;
            }
        }
    }
 
    return false;
}
 
private static bool FoundInProfileType(ProfileTypeProperty profileTypeProperty, ProfileType profileType)
{
 
    ProfileSubtypeManager profileSubtypeManager = ProfileSubtypeManager.Get(_serviceContext);
 
    foreach (ProfileSubtype profileSubtype in profileSubtypeManager.GetSubtypesForProfileType(profileType))
    {
        ProfileSubtypePropertyManager profileSubtypePropertyManager = profileSubtype.Properties;
        if (profileSubtypePropertyManager != null)
        {
            ProfileSubtypeProperty profileSubtypeProperty = profileSubtypePropertyManager.GetPropertyByName(profileTypeProperty.CoreProperty.Name);
            if (profileSubtypeProperty != null)
            {
                return true;
            }
        }
    }
 
    return false;
}
 
private static bool FoundInProfileType(CoreProperty coreProperty, ProfileType profileType)
{
    ProfileSubtypeManager profileSubtypeManager = ProfileSubtypeManager.Get(_serviceContext);
 
    foreach (ProfileSubtype profileSubtype in profileSubtypeManager.GetSubtypesForProfileType(profileType))
    {
        ProfileSubtypePropertyManager profileSubtypePropertyManager = profileSubtype.Properties;
        if (profileSubtypePropertyManager != null)
        {
            ProfileSubtypeProperty profileSubtypeProperty = profileSubtypePropertyManager.GetPropertyByName(coreProperty.Name);
            if (profileSubtypeProperty != null)
            {
                return true;
            }
        }
    }
 
    return false;
}

The following code block shows an example of their usage.

Console.WriteLine("Orphaned sub-type properties");
foreach (ProfileSubtypeProperty profileSubtypeProperty in _profileSubtypePropertyManager.PropertiesWithSection)
{
    // sections are not bound to subtypes
    if (!profileSubtypeProperty.IsSection
        && !FoundInProfileType(profileSubtypeProperty, ProfileType.User)
        && !FoundInProfileType(profileSubtypeProperty, ProfileType.Group)
        && !FoundInProfileType(profileSubtypeProperty, ProfileType.Organization))
    {
       Console.WriteLine("{0} name: {1}, display name: {2}, type property name: {3}, core property name: {4}",
        profileSubtypeProperty.IsSection ? "Section" : "Property",
        profileSubtypeProperty.Name,
        profileSubtypeProperty.DisplayName,
        profileSubtypeProperty.TypeProperty.Name,
        profileSubtypeProperty.CoreProperty.Name);
        Console.WriteLine("Press 'Y' for delete (including type and core property if no more references)!");
        ConsoleKeyInfo key = Console.ReadKey();
        if (key.KeyChar.ToString().ToUpper() == "Y")
        {
            ProfileTypeProperty profileTypeProperty = profileSubtypeProperty.TypeProperty;
            CoreProperty coreProperty = profileSubtypeProperty.CoreProperty;
            Console.WriteLine();
            _profileSubtypePropertyManager.RemoveByName(profileSubtypeProperty.Name, false);
            Console.WriteLine("Sub-type property is deleted.");
            if (!profileTypeProperty.IsSection
                && !FoundInProfileType(profileTypeProperty, ProfileType.User)
                && !FoundInProfileType(profileTypeProperty, ProfileType.Group)
                && !FoundInProfileType(profileTypeProperty, ProfileType.Organization))
            {
                _profileTypePropertyManager.RemoveByName(profileTypeProperty.Name, false);
                Console.WriteLine("Type property is deleted.");
 
                if (!coreProperty.IsSection
                    && !FoundInProfileType(coreProperty, ProfileType.User)
                    && !FoundInProfileType(coreProperty, ProfileType.Group)
                    && !FoundInProfileType(coreProperty, ProfileType.Organization))
                {
                    _corePropertyManager.RemoveByName(profileTypeProperty.CoreProperty.Name, false);
                    Console.Write("Core property is deleted.");
                }
                else
                {
                    Console.Write("Core property is not deleted.");
                }
            }
            else
            {
                Console.WriteLine("Type property is not deleted. Core property is not deleted.");
            }
 
        }
        Console.WriteLine();
    }
}
 
 
Console.WriteLine("Orphaned type properties");
foreach (ProfileTypeProperty profileTypeProperty in _profileTypePropertyManager.PropertiesWithSection)
{
    // sections are not bound to subtypes
    if (!profileTypeProperty.IsSection
        && !FoundInProfileType(profileTypeProperty, ProfileType.User)
        && !FoundInProfileType(profileTypeProperty, ProfileType.Group)
        && !FoundInProfileType(profileTypeProperty, ProfileType.Organization))
    {
        Console.WriteLine("{0} name: '{1}' core property name: '{2}'",
        profileTypeProperty.IsSection ? "Section" : "Property",
        profileTypeProperty.Name,
        profileTypeProperty.CoreProperty.Name);
        Console.WriteLine("Press 'Y' for delete (including core property if no more references)!");
        ConsoleKeyInfo key = Console.ReadKey();
        if (key.KeyChar.ToString().ToUpper() == "Y")
        {
            CoreProperty coreProperty = profileTypeProperty.CoreProperty;
            Console.WriteLine();
            _profileTypePropertyManager.RemoveByName(profileTypeProperty.Name, false);
            Console.WriteLine("Type property is deleted.");
            if (!coreProperty.IsSection
                && !FoundInProfileType(coreProperty, ProfileType.User)
                && !FoundInProfileType(coreProperty, ProfileType.Group)
                && !FoundInProfileType(coreProperty, ProfileType.Organization))
            {
                _corePropertyManager.RemoveByName(profileTypeProperty.CoreProperty.Name, false);
                Console.Write("Core property is deleted.");
            }
            else
            {
                Console.Write("Core property is not deleted.");
            }
 
        }
        Console.WriteLine();
    }
}
 
Console.WriteLine("Orphaned core properties");
foreach (CoreProperty coreProperty in _corePropertyManager.PropertiesWithSection)
{
    // sections are not bound to subtypes
    if (!coreProperty.IsSection
        && !FoundInProfileType(coreProperty, ProfileType.User)
        && !FoundInProfileType(coreProperty, ProfileType.Group)
        && !FoundInProfileType(coreProperty, ProfileType.Organization))
    {
        Console.WriteLine("{0} name: '{1}' display name: '{2}'",
        coreProperty.IsSection ? "Section" : "Property",
        coreProperty.Name,
        coreProperty.DisplayName);
        Console.WriteLine("Press 'Y' for delete!");
        ConsoleKeyInfo key = Console.ReadKey();
        if (key.KeyChar.ToString().ToUpper() == "Y")
        {
            _corePropertyManager.RemoveByName(coreProperty.Name, false);
            Console.WriteLine();
            Console.Write("Core property is deleted.");
        }
        Console.WriteLine();
    }
}

The most important one for us is the code block that checks for orphaned type properties. You should use that for clean-up after user actions mentioned above if you would like to re-use orphaned property names.

The code block that checks for orphaned sub-type properties has not much sense. Since we start from a specific ProfileSubtypePropertyManager we iterate through ProfileSubtypeProperty items belong to this sub-type, so probably we will never found orphaned items.

In these two cases we delete the related type and core properties as well if no more references found for that property.

The code block that checks for orphaned core properties may be useful when the sub-type and type properties were deleted using custom code but the core property remained there orphaned.

Empty display name on the Manage Sub-types page

Filed under: Bugs, SP 2010, User profile — Tags: Bugs, SP 2010, User profile — Peter Holpar @ 00:32

There is a minor bug that allows you to create a new profile sub-type without specifying its display name. It have the result shown below:

When creating a new property after this, it’s rather hard to decide which sub-type it order to:

Also, empty sub-types are not displayed in the Select a sub-type to filter the list of properties drop-down:

March 12, 2010

Bug in the UseCount property of the CoreProperty class

Filed under: Bugs, SP 2010, User profile — Tags: Bugs, SP 2010, User profile — Peter Holpar @ 23:15

The UseCount property would be very useful, by definition it “gets the number of times this property is used in the user profile database.” It would help you to decide whether you can delete the property without data loss or there are profiles already that utilize the property.

When you try to use this property you get an “UserProfileException was unhandled” warning in Visual Studio that means the following:
A failure was encountered while retrieving the profile count. SQL error occurred.
Microsoft.Office.Server.UserProfiles.UserProfileException
at Microsoft.Office.Server.UserProfiles.CoreProperty.get_UseCount()

The getter of the property calls the profile_GetProfileCountWithProperty in the Profile DB database (the database you configured for the User Profile Service Application) stored procedure. When the stored procedure does not find the specified profile property by its name, it returns the Error output parameter having value 1. In this case a PropertyNotDefinedException is thrown in the try/catch block of the UseCount property getter and the exception is re-thrown as UserProfileException.

My first idea was that I might try to get the UseCount for a CoreProperty that is section type, but I was wrong.

Creating a quick SQL trace and checking the SharePoint log both showed, that the code of the UseCount getter does not provide the mandatory partitionID parameter for the stored procedure.

Here is the summary of the exception from the log file:

System.Data.SqlClient.SqlException: Procedure or function ‘profile_GetProfileCountWithProperty’ expects parameter ‘@partitionID’, which was not supplied.     at System.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean breakConnection)     at System.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject stateObj)     at System.Data.SqlClient.TdsParser.Run(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj)     at System.Data.SqlClient.SqlDataReader.ConsumeMetaData()     at System.Data.SqlClient.SqlDataReader.get_MetaData()     at System.Data.SqlClient.SqlCommand.FinishExecuteReader(SqlDataReader ds, RunBehavior runBehavior, String resetOptionsString)     at System…
….Data.SqlClient.SqlCommand.RunExecuteReaderTds(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, Boolean async)     at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method, DbAsyncResult result)     at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method)     at System.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior, String method)     at System.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior)     at Microsoft.Office.Server.Data.SqlSession.ExecuteReader(SqlCommand command, CommandBehavior behavior, SqlQueryData monitoringData, Boolean retryForDeadLock)
at Microsoft.Office.Server.Data.SqlSession.ExecuteReader(SqlCommand command, Boolean retryForDeadLock)     at Microsoft.Office.Server.UserProfiles.CoreProperty.get_UseCount()

As a dirty workaround I modified the stored procedure (of course, I’ve created a backup of the original version first) to have the default value for the mandatory partitionID parameter. It is not very hard, since there is only a single GUID value in the PartitionID field of the PropertyList table of the profile database.

…
ALTER PROCEDURE [dbo].[profile_GetProfileCountWithProperty]
@partitionID uniqueidentifier = ’0C37852B-34D0-418E-91C6-2AC25AF4BE5B’,
@PropertyName nvarchar(50),
…

Be sure to use the correct value for your system:

SELECT DISTINCT [PartitionID]
FROM [Profile DB].[dbo].[PropertyList]

After this hack the UseCount property works like a charm, but I hope this bug will be fixed in the final version.

Comments (2)

March 10, 2010

How to upload a user profile photo programmatically

Filed under: Reflection, SP 2010, User profile — Tags: Reflection, SP 2010, User profile — Peter Holpar @ 17:30

Updated No. 1: Changes required by SP 2010 RTM.

Updated No. 2: Method added to set the picture URL property for the user profile.

On the MSDN forum I’ve met a question that ask about how can one upload and set user profile pictures programmatically. I did a little research on the area and found another thread with the same question but I think the accepted answer of Chakkaradeep Chandran really does not answer the question, as it simply sets the image in the profile through the PictureUrl profile property, but does nothing related to upload and image resizing.

I admit the later tasks are not trivial although definitely not impossible through some hacking with Reflection. It is required since the methods we need (LoadPictureLibraryInternal, CreateThumbnail, GetSubfolderForPictures) are internal and private members of the ProfileImagePicker and UserProfilePhotos classes (later class is internal itself as well). So if you don’t mind this kind of dirty code, here is the solution for the question.

You should create a console application and add references to System.Drawing, System.Web, Microsoft.SharePoint, Microsoft.SharePoint.Portal, Microsoft.Office.Server and Microsoft.Office.Server.UserProfiles assemblies.

Next, use the code below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Reflection;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Portal.WebControls;
using System.IO;
using Microsoft.Office.Server.UserProfiles;
 
namespace UploadProfileImage
{
    class Program
    {
        static void Main(string[] args)
        {
            Program prog = new Program();
            prog.UploadProfileImages();
        }
 
        private void UploadProfileImages()
        {
 
            // my site host url
            String url = "http://sp2010/profiles/host&quot;;
            using (SPSite site = new SPSite(url))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    ProfileImagePicker profileImagePicker = new ProfileImagePicker();
                    InitializeProfileImagePicker(profileImagePicker, web);
                    SPFolder subfolderForPictures = GetSubfolderForPictures(profileImagePicker);
 
                    // repeat this block if you have more images and users
                    // your account name
                    String accountName = @"domain\administrator";
                    // path to image file
                    String imageFilePath = @"C:\Temp\AdminAvatar.jpg";
                    UploadPhoto(accountName, imageFilePath, subfolderForPictures, profileImagePicker);
                    SetPictureUrl(accountName, subfolderForPictures);
                    // repeat block finished
 
                }
            }
        }
 
 
        private void SetPictureUrl(string accountName, SPFolder subfolderForPictures)
        {
            Console.WriteLine("Setting profile image for user '{0}'", accountName);
 
            SPSite site = subfolderForPictures.ParentWeb.Site;
            UserProfileManager userProfileManager = new UserProfileManager(SPServiceContext.GetContext(site));
            UserProfile userProfile = userProfileManager.GetUserProfile(accountName);
 
            string fileNameWithoutExtension = GetFileNameFromAccountName(accountName);
 
            string pictureUrl = String.Format("{0}/{1}/{2}_MThumb.jpg", site.Url, subfolderForPictures.Url, fileNameWithoutExtension);
 
            userProfile["PictureUrl"].Value = pictureUrl;
            userProfile.Commit();
        }
 
 
        private void UploadPhoto(string accountName, string imageFilePath, SPFolder subfolderForPictures, ProfileImagePicker profileImagePicker)
        {
            Console.WriteLine("Uploading image '{0}' for user '{1}'", imageFilePath, accountName);
 
            if (!File.Exists(imageFilePath) || Path.GetExtension(imageFilePath).Equals(".gif"))
            {
                Console.WriteLine("File '{0}' does not exist or has invalid extension", imageFilePath);
            }
            else
            {
                string fileNameWithoutExtension = GetFileNameFromAccountName(accountName);
 
                FileStream file = File.Open(imageFilePath, FileMode.Open);
                BinaryReader reader = new BinaryReader(file);
 
                if (subfolderForPictures != null)
                {
                    // try casting length (long) to int
                    byte[] buffer = reader.ReadBytes((int)file.Length);
 
                    int largeThumbnailSize = 0×90;
                    int mediumThumbnailSize = 0×60;
                    int smallThumbnailSize = 0×20;
 
                    using (MemoryStream stream = new MemoryStream(buffer))
                    {
                        using (Bitmap bitmap = new Bitmap(stream, true))
                        {
                            CreateThumbnail(bitmap, largeThumbnailSize, largeThumbnailSize, subfolderForPictures, fileNameWithoutExtension + "_LThumb.jpg");
                            CreateThumbnail(bitmap, mediumThumbnailSize, mediumThumbnailSize, subfolderForPictures, fileNameWithoutExtension + "_MThumb.jpg");
                            CreateThumbnail(bitmap, smallThumbnailSize, smallThumbnailSize, subfolderForPictures, fileNameWithoutExtension + "_SThumb.jpg");
                        }
                    }
 
                }
            }
        }
 
 
        private void InitializeProfileImagePicker(ProfileImagePicker profileImagePicker, SPWeb web)
        {
            Type profileImagePickerType = typeof(ProfileImagePicker);
 
            FieldInfo fi_m_objWeb = profileImagePickerType.GetField("m_objWeb", BindingFlags.NonPublic | BindingFlags.Instance);
            fi_m_objWeb.SetValue(profileImagePicker, web);
 
            MethodInfo mi_LoadPictureLibraryInternal = profileImagePickerType.GetMethod("LoadPictureLibraryInternal", BindingFlags.NonPublic | BindingFlags.Instance);
            if (mi_LoadPictureLibraryInternal != null)
            {
                mi_LoadPictureLibraryInternal.Invoke(profileImagePicker, new object[] { });
            }
        }
 
        public SPFile CreateThumbnail(Bitmap original, int idealWidth, int idealHeight, SPFolder folder, string fileName)
        {
            SPFile file = null;
 
            // hack to get the Microsoft.Office.Server.UserProfiles assembly
            Assembly userProfilesAssembly = typeof(UserProfile).Assembly;
            // or assuming you know all the details of the assembly
            // Assembly userProfilesAssembly = Assembly.Load(“Microsoft.Office.Server.UserProfiles, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c”);
 
            // UserProfilePhotos is internal class, 
            // so you cannot get it directly from Visual Studio             
            Type userProfilePhotosType = userProfilesAssembly.GetType("Microsoft.Office.Server.UserProfiles.UserProfilePhotos");
 
            MethodInfo mi_CreateThumbnail = userProfilePhotosType.GetMethod("CreateThumbnail", BindingFlags.NonPublic | BindingFlags.Static);
            if (mi_CreateThumbnail != null)
            {
                file = (SPFile)mi_CreateThumbnail.Invoke(null, new object[] { original, idealWidth, idealHeight, folder, fileName });
            }
 
            return file;
        }
 
        private SPFolder GetSubfolderForPictures(ProfileImagePicker profileImagePicker)
        {
            SPFolder folder = null;
 
            Type profileImagePickerType = typeof(ProfileImagePicker);
 
            MethodInfo mi_GetSubfolderForPictures = profileImagePickerType.GetMethod("GetSubfolderForPictures", BindingFlags.NonPublic | BindingFlags.Instance);
            if (mi_GetSubfolderForPictures != null)
            {
                folder = (SPFolder)mi_GetSubfolderForPictures.Invoke(profileImagePicker, new object[] { });
            }
 
            return folder;
        }
 
        private string GetFileNameFromAccountName(string accountName)
        {
            string result = accountName;
            string charsToReplace = @"\/:*?""<>|";
            Array.ForEach(charsToReplace.ToCharArray(), charToReplace => result = result.Replace(charToReplace, '_'));
            return result;
        }
    }
}

Happy profile image uploading!

You should know that user profile photos are stored in three different resolutions in a folder called Profile Pictures in the User Photos image library on the My Site Host site.

Note, that I found a bit strange dependency of behavior on the size of the photo you set in the PictureUrl profile property when it is about removing the profile image. It seems to be a minor issue, but might have significant impact on your solution.

When you upload the profile photo via the Edit User Profile user interface and then removes that also via the UI, then all of the image versions (I mean the three different resolution) are deleted. and using code. I consider this to be the standard behavior as it is not desired to leave orphaned files in the User Photos image library.

First I’ve tried to set the large image (_LThumb.jpg) from code in the PictureUrl profile property, but when I was to remove the image from the UI then only the large image was deleted, medium and small images remained in the image library. After checking the effect of setting the image from the UI I found, that it sets the PictureUrl property to the medium image (_MThumb.jpg), so I modified the code accordingly. Now all of the images were removed as expected.

Comments (94)