I have been asked a few times how to implement an auto-tagging solution using CSOM, how can I set Taxonomy fields programmatically?  This sample demonstrates how to auto-tag  a document that will populate meta-data at the time the document is upload to SharePoint. This solution will enable more refined search results and assist with classification of content. A Remote Event Receiver (ReR) will be used to retrieve the properties from the users profile and update the meta-data of the document at the time of document upload. The user will will have option of override those auto populated properties.

This samples demonstrates the following:

• Adding a Fields and Content Types to the host web
• Creation of Taxonomy Fields programmatically
• Creating Two Libraries with the associated content type that are deployed to the host web
• Register a ItemAdding & ItemAdded Remote Event Receiver in the host web
• Removal of the Remote Event Receiver
• Retrieval of User Profile Properties.
• Setting Taxonomy Fields programmatically

Permissions

AppOnly Permissions are used in this solution

• Tenant: FullControl
• Taxonomy: Read
• Social: Read

Adding Fields and Content Types

To create the fields and content types the below code leverages OfficeDevPnP.Core.  We chose to create the fields and content types programmatically and this is the preferred approach. This gives you greater control for future mainteanance, gives you away to  implement localized versions of your fields and content types.

        //Check the fields
        if (!ctx.Web.FieldExistsById(FLD_CLASSIFICATION_ID))
        {
                ctx.Web.CreateTaxonomyField(FLD_CLASSIFICATION_ID,
                                            FLD_CLASSIFICATION_INTERNAL_NAME,
                                            FLD_CLASSIFICATION_DISPLAY_NAME,
                                            FIELDS_GROUP_NAME,
                                            TAXONOMY_GROUP,
                                            TAXONOMY_TERMSET_CLASSIFICATION_NAME);
        }

        //check the content type
        if (!ctx.Web.ContentTypeExistsById(CONTOSODOCUMENT_CT_ID))
        {
                ctx.Web.CreateContentType(CONTOSODOCUMENT_CT_NAME,
                                          CT_DESC, CONTOSODOCUMENT_CT_ID,
                                          CT_GROUP);
        }

        //associate fields to content types
        if (!ctx.Web.FieldExistsByNameInContentType(CONTOSODOCUMENT_CT_NAME, FLD_CLASSIFICATION_INTERNAL_NAME))
        {
                ctx.Web.AddFieldToContentTypeById(CONTOSODOCUMENT_CT_ID,
                                                  FLD_CLASSIFICATION_ID.ToString(),
                                                  false);
        }

Create Document Library

To create a document library we use the following code. We are again, leveraging core to provide this functionality. The following code will create the library, enable versioning and remove the default Document content type. 

            if (!ctx.Web.ListExists(library.Title))
            {
                ctx.Web.AddList(ListTemplateType.DocumentLibrary, library.Title, false);
                List _list = ctx.Web.GetListByTitle(library.Title);
                if (!string.IsNullOrEmpty(library.Description))
                {
                    _list.Description = library.Description;
                }

                if (library.VerisioningEnabled)
                {
                    _list.EnableVersioning = true;
                }

                _list.ContentTypesEnabled = true;
                _list.RemoveContentTypeByName("Document");
                _list.Update();
                
                ctx.Web.AddContentTypeToListById(library.Title, associateContentTypeID, true);
                ctx.Web.Context.ExecuteQuery();
               
            }
            else
            {
                throw new Exception("A list, survey, discussion board, or document library with the specified title already exists in this Web site.  Please choose another title.");
            }

Registering the Remote Event Receiver in the host web

We will register two remote event receivers, which are ItemAdding and ItemAdded to two separate libraries. 

       public static void AddEventReceiver(ClientContext ctx, List list, EventReceiverDefinitionCreationInformation eventReceiverInfo)
        {
            if (!DoesEventReceiverExistByName(ctx, list, eventReceiverInfo.ReceiverName))
            {
                list.EventReceivers.Add(eventReceiverInfo);
                ctx.ExecuteQuery();
            }
        }

We want to make sure that when we add the event receiver that one doesn't already exist. The following code demonstrates how to check if the receiver exists by name.

       public static bool DoesEventReceiverExistByName(ClientContext ctx, List list, string eventReceiverName )
        {
            bool _doesExist = false;
            ctx.Load(list, lib => lib.EventReceivers);
            ctx.ExecuteQuery();

            var _rer = list.EventReceivers.Where(e => e.ReceiverName == eventReceiverName).FirstOrDefault();
            if (_rer != null) {
                _doesExist = true;
            }

            return _doesExist;
        }

The following code is used to help us create a new EventReceiverDefinitionCreationInformation object. Make sure you change your ReceiverUrl to match your environment.

       public static EventReceiverDefinitionCreationInformation CreateEventReciever(string receiverName, EventReceiverType type)
        {

            EventReceiverDefinitionCreationInformation _rer = new EventReceiverDefinitionCreationInformation();
            _rer.EventType = type;
            _rer.ReceiverName = receiverName;
            _rer.ReceiverClass = "ECM.AutoTaggingWeb.Services.AutoTaggingService";
            _rer.ReceiverUrl = "https://amsecm.azurewebsites.net/Services/AutoTaggingService.svc";
            _rer.Synchronization = EventReceiverSynchronization.Synchronous;
            return _rer;
        }

Removing the Remote Event Receiver in the host web

The following code is use to remove the event receiver from the list.

 public static void RemoveEventReceiver(ClientContext ctx, List list, string receiverName)
        {
            ctx.Load(list, lib => lib.EventReceivers);
            ctx.ExecuteQuery();

            var _rer = list.EventReceivers.Where(e => e.ReceiverName == receiverName).FirstOrDefault();
            if(_rer != null)
            {
                _rer.DeleteObject();
                ctx.ExecuteQuery();
            }
        }

ItemAdding Remote Event Receiver

Implementation class for ItemAdding. The ItemAdding member uses the result ChangeItemProperties to update the taxonomy field.  We need to check if the the document already contains the properties for the Taxonomy Field, in this scenario we don't want to update the field. When debugging the code you will notice that if the property is already supplied the format is 2;#MYTERNNAME|74972ac9-3183-4775-b232-cd6de3569c65 This is the WssID, the value of the term and the GUID. 

        public void HandleAutoTaggingItemAdding(SPRemoteEventProperties properties,SPRemoteEventResult result)
        {
            using (ClientContext ctx = TokenHelper.CreateRemoteEventReceiverClientContext(properties))
            {
                if (ctx != null)
                {
                    var itemProperties = properties.ItemEventProperties;
                    var _userLoginName = properties.ItemEventProperties.UserLoginName;
                    var _afterProperites = itemProperties.AfterProperties;
                    if(!_afterProperites.ContainsKey(ScenarioHandler.FLD_CLASSIFICATION_INTERNAL_NAME))
                    {
                        string _classficationToSet = ProfileHelper.GetProfilePropertyFor(ctx, _userLoginName, Constants.UPA_CLASSIFICATION_PROPERTY);
                        if(!string.IsNullOrEmpty(_classficationToSet))
                        { 
                            var _formatTaxonomy = AutoTaggingHelper.GetTaxonomyFormat(ctx, _classficationToSet);
                            result.ChangedItemProperties.Add(ScenarioHandler.FLD_CLASSIFICATION_INTERNAL_NAME, _formatTaxonomy);
                        }
                    }
                }
            }
        }

To get the term value in this format, we are going to use the below code that queries the TaxonomyHiddenList. Warning, DO NOT modify this list, you can read. Remember, you can look but don't touch.

        public static string GetTaxonomyFormat(ClientContext ctx, string term)
        { 
            if(string.IsNullOrEmpty(term))
            {
                throw new ArgumentException(string.Format(EXCEPTION_MSG_INVALID_ARG, "term"));
            }
            string _result = string.Empty;
            var _list = ctx.Web.Lists.GetByTitle(TAXONOMY_HIDDEN_LIST_NAME);
            CamlQuery _caml = new CamlQuery();

            _caml.ViewXml = string.Format(TAXONOMY_CAML_QRY, term);
            var _listItemCollection = _list.GetItems(_caml);

            ctx.Load(_listItemCollection,
                eachItem => eachItem.Include(
                    item => item,
                    item => item.Id,
                    item => item[TAXONOMY_FIELDS_IDFORTERM]));
            ctx.ExecuteQuery();

            if (_listItemCollection.Count > 0)
            {
                var _item = _listItemCollection.FirstOrDefault();
                var _wssId = _item.Id;
                var _termId = _item[TAXONOMY_FIELDS_IDFORTERM].ToString(); ;
                _result = string.Format(TAXONOMY_FORMATED_STRING, _wssId, term, _termId);
            }

            return _result;
        }

ItemAdded Remote Event Receiver

Implementation class for ItemAdded. The ItemAdded event receiver is implemented Synchronously. This implementation queries the list and updates the Taxonomy field in the list.

        public void HandleAutoTaggingItemAdded(SPRemoteEventProperties properties)
        {
            using (ClientContext ctx = TokenHelper.CreateRemoteEventReceiverClientContext(properties))
            {
                if (ctx != null)
                {
                    string _userLoginName = properties.ItemEventProperties.UserLoginName;
                    List _library = ctx.Web.Lists.GetById(properties.ItemEventProperties.ListId);
                    var _itemToUpdate = _library.GetItemById(properties.ItemEventProperties.ListItemId);
                    ctx.Load(_itemToUpdate);
                    ctx.ExecuteQuery();

                    Hashtable _model = new Hashtable();
                    string _classficationToSet = ProfileHelper.GetProfilePropertyFor(ctx, _userLoginName, Constants.UPA_CLASSIFICATION_PROPERTY);
                    if (!string.IsNullOrEmpty(_classficationToSet))
                    {
                        _model.Add(ScenarioHandler.FLD_CLASSIFICATION_INTERNAL_NAME, _classficationToSet);
                        AutoTaggingHelper.SetTaxonomyField(ctx, _itemToUpdate, _model);
                    }
                }
            }
        }

The AutoTagginghelper.SetTaxonomyField implementation uses the following code. The code is more expensive since we have to query the FieldCollection, get the Taxonomy Field that you want to update and then finally search for the Term by name to retrieve the Term Id.

public static void SetTaxonomyField(ClientContext ctx, ListItem listItem, Hashtable model)
        {
          
            FieldCollection _fields = listItem.ParentList.Fields;
            ctx.Load(_fields);
            ctx.ExecuteQuery();

            foreach(var _key in model.Keys)
            {
               var _termName = model[_key].ToString();
               TaxonomyField _field = ctx.CastTo<TaxonomyField>(_fields.GetByInternalNameOrTitle(_key.ToString()));
               ctx.Load(_field);
               ctx.ExecuteQuery();
               Guid _id = _field.TermSetId;
               string _termID = AutoTaggingHelper.GetTermIdByName(ctx, _termName, _id );
               var _termValue = new TaxonomyFieldValue()
               {
                   Label = _termName,
                   TermGuid = _termID,
                   WssId = -1
               };

               _field.SetFieldValueByValue(listItem, _termValue);
               listItem.Update();
               ctx.ExecuteQuery();
            }
        }

Recommendations

While your testing the two scenarios, you will noticed that the ItemAdding implementation is more responsive, this is due to how we are getting the term, the guid and its wssId, as well query int the list item. We have one call vs four in the ItemAdded implementation.  If your use case matches this scenario, then I would recommend that you use ItemAdding instead of ItemAdded (Synchronously).  You should also make sure you code is as efficient as possible. Another possible solution which is more efficient is to use ItemAdded asynchronously and queue the actions so that we are not blocking the user in the UI.

Dependencies

• Microsoft.SharePoint.Client
• Microsoft.SharePoint.Client.Runtime
• Microsoft.SharePoint.Client.Taxonomy
• Microsoft.SharePoint.Client.UserProfiles

References

• Setting up provider hosted app to Windows Azure for Office365 tenant
• Office 365 PnP
• The code sample used in this blog.
• Using App-Only Tokens
• FTC to CAM – Stop creating content types and site columns declaratively

In order to upload the wsp to the Solution Gallery, we are going to use  the FileCreationInformation class to upload the file to the gallery. Removing the solution is handled by finding the uploaded file and calling the DeleteObject member.

// get the file from the server path in the provider site

var filePath = Server.MapPath("~/PreventDeleteSites.wsp");

var file = new FileStream(filePath, FileMode.Open);

// create the FileCreationInformation object and prepare

// to upload it to the solution gallery

var fileCI = new FileCreationInformation() {

    ContentStream = file,

    Url = "PreventDeleteSites.wsp",

    Overwrite = true

};

// upload the solution to the gallery

var uploadedFile = solutionGallery.RootFolder.Files.Add(fileCI);

clientContext.Load(uploadedFile);

clientContext.ExecuteQuery();

Solution activation is done using the DesignPackage class in the Microsoft.SharePoint.Client.Publishing assembly.  We are going to use the DesignPackage.Install and DesignPackage.Uninstall members to activate and deactivate the solution for the site collection.

// get the DesignPackageInfo (which is the same name for a sandbox solution)

var wsp = new DesignPackageInfo(){

    // during deployment, the solution ID is not necessary but we need the Guid during removal

    PackageGuid = Guid.Empty, // 4c16c0b9-0162-43ad-a8e9-a4b810e58a56

    PackageName = "PreventDeleteSites"

};

// install the solution from the file url

var filerelativeurl = solutionGallery.RootFolder.ServerRelativeUrl + "/PreventDeleteSites.wsp";

DesignPackage.Install(clientContext, clientContext.Site, wsp, filerelativeurl);

clientContext.ExecuteQuery();

References

The Prevent Site Deletion sample that shows this code in action

Office 365 Patterns and Practices

Microsoft.SharePoint.Client.Publishing 

SharePoint Administrators can deploy apps to their tenancy basically two different ways. Deploy from the app catalog (“app stapling”) or via sideloading.

What is sideloading? App sideloading, from a SharePoint context, is the ability to install a SharePoint app directly into a site to explicitly bypass the regular governance controls of SharePoint. The main reason for blocking sideloading by default on non-developer sites is the risk that faulty apps pose to their host web/host site collection. Apps have the potential to destroy data and make sites or, given enough permissions, can even make site collections unusable. Therefore, apps should only be sideloaded in dev/test environments and in production only when deploying from the AppCatalog does not meet your needs. It is NOT recommended to sideload SharePoint Hosted-Applications, because of the risk of data loss.

Note:

• Enabling the app sideloading features requires tenant admin permissions (in a multi-tenant environment) or farm admin permissions (in a single tenant environment).
• You must have a user context when sideloading the application. App-only permission is not available.
• Sideloading does not suppress the security check or compensate existing security requirements. It does however enable the programmatic installation of an app
• You must still register and app principal for SharePoint Provider hosted applications
• You should deactivate the sideloading feature immediately once the app is in installed. Site Collections administrators can install apps using CSOM which could circumvent your governance practices.

This sample will use the ChangeInformation class to return all the changes in the source term store. 

First, create a TaxonomySession object. 

DateTime _startFrom = DateTime.Now.AddYears(-1);

Console.WriteLine("Opening the taxonomy session");
TaxonomySession _sourceTaxonomySession = TaxonomySession.GetTaxonomySession(sourceClientContext);
TermStore sourceTermStore = _sourceTaxonomySession.GetDefaultKeywordsTermStore();
sourceClientContext.Load(sourceTermStore);
sourceClientContext.ExecuteQuery();

Once you have created the TaxonomySession object we need to get the changes, we get the changes by creating a new Instance of ChangeInformation and set the start date. In this case, I’m getting all the changes from 1 year ago. 

Console.WriteLine("Reading the changes");
ChangeInformation _ci = new ChangeInformation(sourceClientContext);
_ci.StartTime = _startFrom;
ChangedItemCollection _cic = sourceTermStore.GetChanges(_ci);
sourceClientContext.Load(_cic);
sourceClientContext.ExecuteQuery();

Once we invoke the GetChanges member this will return a ChangeItemCollection that can be used to enumerate the changes that have occurred in term store. You can then perform an operation on the target term store like add, edit or delete like we do in the downloadable code sample.

foreach (ChangedItem _changeItem in _cic) {

///ENUMERATE YOU’RE CHANGES
if (_changeItem.ItemType == ChangedItemType.Group){
///PROCESS YOU’RE CHANGES
}
}

Running the code.

Ensure, that the user has the appropriate permissions to the term store in both the source and target term stores, or you will get an exception.

FAQ

Question - "Does this work with on-premises SharePoint implementations?" 

Sure does, in the code sample change SharePointOnlineCredentials to NetworkCredential

Question - "I need my Guid in the target Termstore, does this preserve the Guid?" 

Yes, the code sample will retain you Guid

Question - "Why should i use this pattern to sync my terms?"

This performs better  than just GetAllTerms and enumerating every time you want to sync. 

 Question - "Does this work with SharePoint 2010?"

In theory yes, however you should only use SharePoint 2010 as the source and not the target.  We are unable to set the TermId in CSOM for 2010.

References

Few useful links and resources related on this blog post

Code example from this blog post. - "Core.MMSSync.zip" 

Special thanks to Kimmo Forss 

First off, External sharing for OneDrive for Business is an all or nothing approach and is enabled by default. To disable External Sharing you would navigate to your SharePoint Admin Tenant URL, Site Collection view and choose Sharing from the ribbon. You will be presented with a similar view as depicted below where you can adjust your settings.

Once you disable sharing users will no longer be able to share outside your organization. Now you can disable Sharing at the tenant level but that will work but we still have that scenario that we want to allow Sharing for our collaboration sites.

Now, I'm a developer at heart and I cant have a blog post without sharing some code. So lets say for your team collaboration sites, you have a custom site provisioning solution like the one at https://officeams.codeplex.com/ and you wanted to enable External Sharing in these sites during the provisioning process and you don't want to have to navigate and enable Sharing for each one of your sites You can easy update the solution to include the below code. Now, don't try this one a OneDrive site you will receive an error.

/// <summary>
/// Sets the Site Collection External Sharing Setting using the SharePoint Tenant API
/// </summary>
/// <param name="adminCC"></param>
/// <param name="siteCollectionURl"></param>
/// <param name="shareSettings"></param>
public static void SetSiteSharing(ClientContext adminCC, string siteCollectionURl, SharingCapabilities shareSettings)
{
var _tenantAdmin = new Tenant(adminCC);
SiteProperties _siteprops = _tenantAdmin.GetSitePropertiesByUrl(siteCollectionURl, true);
adminCC.Load(_tenantAdmin);
adminCC.Load(_siteprops);
adminCC.ExecuteQuery();

SharingCapabilities _tenantSharing = _tenantAdmin.SharingCapability;
var _currentShareSettings = _siteprops.SharingCapability;
bool _isUpdatable = false;

if(_tenantSharing == SharingCapabilities.Disabled)
{
Console.WriteLine("Sharing is currently disabled in your tenant! I am unable to work on it.");
}
else
{
if(shareSettings == SharingCapabilities.Disabled)
{ _isUpdatable = true; }
else if(shareSettings == SharingCapabilities.ExternalUserSharingOnly)
{
_isUpdatable = true;
}
else if (shareSettings == SharingCapabilities.ExternalUserAndGuestSharing)
{
if (_tenantSharing == SharingCapabilities.ExternalUserAndGuestSharing)
{
_isUpdatable = true;
}
else
{
Console.WriteLine("ExternalUserAndGuestSharing is currently disabled in your tenant! I am unable to work on it.");
}
}
}
if (_currentShareSettings != shareSettings && _isUpdatable)
{
_siteprops.SharingCapability = shareSettings;
_siteprops.Update();
adminCC.ExecuteQuery();
Console.WriteLine("Set Sharing on site {0} to {1}.", siteCollectionURl, shareSettings);
}
}

You can get the sample solution here.

Sharing is caring!

As part of the new Client Side Object Model (CSOM) assemblies released in the SharePoint Online Client Components SDK, we now have many new capabilities and improvements. One specifically is the capability to programmatically provision One Drive for Business sites in Office 365

There is basically two ways to provision a users One Drive for Business site, the first way is user initiated that is when the user navigates to their newsfeed, site or One Drive links that are within the suite bar, the other is by pre-provisioning leveraging CSOM. In some cases it might not be feasible to have the user initiate the provision process. Say for example, you are migrating from an on-premises SharePoint farm or other repositories, and you don’t want to wait for the user to click a link before you start your migration. The AMS team is in the process of publishing this sample at https://officeams.codeplex.com/, but if you need it now and don’t want to wait here is a sample to get you going.

Use Cases

• You have an custom on-boarding process and you want to create One Drive Sites when you on-board new employees
• You are performing an on-premises migration to Office 365
• You are migrating from the G word or other repositories

Dependencies Components 

References

Requirements

• You must be a tenant administrator to provision One Drive for Business sites programmatically
• Your code must have a context to your tenant admin URL. For example https://microsoftacs-admin.sharepoint.com

Code Samples

Rest API Implementation

public void CreatePersonalSiteUsingRest(string tenantAdminUrl , string userName, string password , string emailIDs)
{
//Validate Arguments
Uri _uri = new Uri(tenantAdminUrl);
string _emailData = emailIDs;
if (_creds == null)
{
_creds = new SharePointOnlineCredentials(userName, Utilities.StringToSecure(password));
string authCookie = _creds.GetAuthenticationCookie(_uri);
_cookies = new CookieContainer();
_cookies.Add(new Cookie("FedAuth", authCookie.TrimStart("SPOIDCRL=".ToCharArray()), "", _uri.Authority));

Uri _apiContextInfo = new Uri(_uri, API_CONTEXTINFO);

HttpWebRequest _endpointRequest = (HttpWebRequest)HttpWebRequest.Create(_apiContextInfo.OriginalString);
_endpointRequest.Method = "POST";
_endpointRequest.Accept = "text/xml;charset=utf-8";
_endpointRequest.CookieContainer = _cookies;
_endpointRequest.ContentLength = 0;
_endpointRequest.Credentials = _creds;

//We need to get the form digest since we are submitting or writing data via rest.
//We need to make a call to _api/contextinnfo to retreive the digestvalue and attach the form digest value to all
//requests. https://msdn.microsoft.com/en-us/library/office/jj164022(v=office.15).aspx

HttpWebResponse _endpointResponse = (HttpWebResponse)_endpointRequest.GetResponse();
XmlNamespaceManager _xmlnspm = new XmlNamespaceManager(new NameTable());
_xmlnspm.AddNamespace("d", "https://schemas.microsoft.com/ado/2007/08/dataservices");
StreamReader _contextinfoReader = new StreamReader(_endpointResponse.GetResponseStream(), System.Text.Encoding.UTF8);
var _formDigestXML = new XmlDocument();
_formDigestXML.LoadXml(_contextinfoReader.ReadToEnd());
var _formDigestNode = _formDigestXML.SelectSingleNode("//d:FormDigestValue", _xmlnspm);
_formDigest = _formDigestNode.InnerXml;
}

Byte[] _payLoad = System.Text.Encoding.ASCII.GetBytes(_emailData);
HttpWebRequest _spoMySiteRequest = (HttpWebRequest)HttpWebRequest.Create(new Uri(_uri, API_CREATEPERSONALSITE));
_spoMySiteRequest.Method = "POST";
_spoMySiteRequest.ContentType = "application/json;odata=verbose";
_spoMySiteRequest.Accept = "application/json;odata=verbose";
_spoMySiteRequest.Headers.Add("X-FORMS_BASED_AUTH_ACCEPTED", "f");
_spoMySiteRequest.Headers.Add("X-RequestDigest", _formDigest);
_spoMySiteRequest.CookieContainer = _cookies;
_spoMySiteRequest.ContentLength = _emailData.Length;
_spoMySiteRequest.Credentials = _creds;

Stream _itemRequestStream = _spoMySiteRequest.GetRequestStream();
_itemRequestStream.Write(_payLoad, 0, _payLoad.Length);
_itemRequestStream.Close();

HttpWebResponse _mysiteCreateResponse = (HttpWebResponse)_spoMySiteRequest.GetResponse();

}

Invocation

PersonalSiteCreator _spoPersonalSiteCreator = new PersonalSiteCreator();
String _adminTenantUrl = "https://youradmin.sharepoint.com";
String _userName = "myAdmin@yourdomain.onmicrosoft.com";
String _passWord = "myAdminPassword";

//You dont want to provision more than 200 users personal sites during a single request. If you have a large amount of users consider
//waiting for the last users site to be provisioned. The reason behind this is not to bombard the service with requests.

// One Users
string _restPayload = "{'emailIDs':['user1@MicrosoftACS.onmicrosoft.com']}";

// Multiple Users
string _restPayload = "{'emailIDs':['user1@MicrosoftACS.onmicrosoft.com', 'user2@MicrosoftACS.onmicrosoft.com']}";
_spoPersonalSiteCreator.CreatePersonalSiteUsingRest(_adminTenantUrl, _userName, _passWord, _restPayload);

CSOM Implementation

/// <summary>
/// Sample Member that provisions personal sites leveraging CSOM
/// </summary>
/// <param name="tenantAdminUrl">The Tenanat Admin URL for your SharePoint Online Subscription</param>
/// <param name="userName">The User name, who has tenant admin permssions</param>
/// <param name="password">The password for the user who has tenant admin permissions</param>
/// <param name="emailIDs">The email ids for users who personal site you want to create</param>
public void CreatePersonalSiteUsingCSOM(string tenantAdminUrl, string userName, string password, string[] emailIDs)
{
using (ClientContext _context = new ClientContext(tenantAdminUrl))
{
try
{
SharePointOnlineCredentials _creds = new SharePointOnlineCredentials(userName, Utilities.StringToSecure(password));
_context.Credentials = _creds;
_context.ExecuteQuery();

ProfileLoader _profileLoader = ProfileLoader.GetProfileLoader(_context);
_profileLoader.CreatePersonalSiteEnqueueBulk(emailIDs);
_profileLoader.Context.ExecuteQuery();
}
catch(Exception _ex)
{
throw;
}
}
}

Invocation

PersonalSiteCreator _spoPersonalSiteCreator = new PersonalSiteCreator();
String _adminTenantUrl = "https://youradmin.sharepoint.com";
String _userName = "myAdmin@yourdomain.onmicrosoft.com";
String _passWord = "myAdminPassword";

//You dont want to provision more than 200 users personal sites during a single request. If you have a large amount of users consider
//waiting for the last users site to be provisioned. The reason behind this is not to bombard the service with requests.

//Create Personal Sites using CSOM
string[] _usersToCreate = { "User3@MicrosoftACS.onmicrosoft.com" , "User4@MicrosoftACS.onmicrosoft.com"};
_spoPersonalSiteCreator.CreatePersonalSiteUsingCSOM(_adminTenantUrl, _userName, _passWord, _usersToCreate);

During execution of the above code you might notice in the User Profiles a similar view, that the users personal site is displaying a SPSSITEERROR. This is expected during provisioning and will later be updated once the back-end processes have completed.

After this service has provisioned the site you will see a similar screen below which displays the users personal site.

FAQ

Q: Do we have an API to provision on-premises One Drive Sites?

I’m sorry at this time no.

Q: Should I use the Rest API or CSOM?

That depends, use what you are comfortable with however, our opinion is that CSOM is more intuitive in this scenario. 

Q: Can I batch more than 200 users at a time?

No, there is limit of 200 users per request.

Q: I have more than 200 users and I will need to submit multiple requests can I do that?

Sure you can, but you must batch the requests. Before you submit the next batch of users you should validate that the last user in your batch has had their One Drive site created. In the background all requests are queued up to the maximum 200.

Q: What happens, if we don’t listen to the above guidance?

You will receive an exception. We told you so.

Q: How long can does it take to provision a One Drive Site?

That depends we have seen it take up to 5 minutes per site during the day. During testing we provisioned 4,000 site collections and it took sometime to provision all the users. We are always improving the service.

Q - Can I use this code and material within any project I'm involved?

Feel free to use this on your engagements or solutions, but remember we told you no more than 200 users per requests

Q – Where can we provide feedback or we have other comments?

https://www.facebook.com/officeams or https://officeams.codeplex.com/

Q – These code snippets are nice, but can you point me to the Visual Studio Solution?

EDITED: The solution has been released and is available at https://officeams.codeplex.com/

Q – Do you have a PowerShell example?

Glad you asked. Here you go.

Open up SharePoint PowerShell console and run the following commands:

$webUrl = "https://yoursharepointadmin.SharePoint.com"
$ctx = New-Object Microsoft.SharePoint.Client.ClientContext($webUrl)

$web = $ctx.Web
$username = "admin@myadmin.sharepoint.com"
$password = read-host -AsSecureString

$ctx.Credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($username,$password )

$ctx.Load($web)
$ctx.ExecuteQuery()

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint.Client.UserProfiles")

$loader =[Microsoft.SharePoint.Client.UserProfiles.ProfileLoader]::GetProfileLoader($ctx)

#To Get Profile
$profile = $loader.GetUserProfile()
$ctx.Load($profile)
$ctx.ExecuteQuery()
$profile
#To enqueue Profile
$loader.CreatePersonalSiteEnqueueBulk(@("user1@domain.com"))
$loader.Context.ExecuteQuery()

Q – What if I submit a user who already has a One Drive Site?

We will process the request within the service and we will handle gracefully, however you should validate the user doesn’t have a site already to reduce the burden. See the AMS samples on how to determine if a user has One Drive site.

Q –   I want to add additional users or apply custom branding to the One Drive site how can I do that using this API?

The CreatePersonalSiteEnqueueBulk method only provisions the Site Collection, you can use the AMS sample Deploy branding to personal SkyDrive Pro sites automatically for possible options.

Special Thanks to

Kimmo Forss, Bob Fox, Vesa Juvonen, Rob Howard, Kirk Daues, Steve Walker, Ali Mazaheri, Bert Jansen, Jeremy Mazner, Phil Newman, Luca Bandinelli, Neil Hodgkinson, Bill Baer, Microsoft America Cloud Services & Office 365 CoE