private static void ApplyProvisioningTemplateToSite(ClientContext context, String siteUrl, String folder, String fileName, Dictionary <String, String> parameters = null, Handlers handlers = Handlers.All)
{
// TODO: Move to Open XML
// Configure the XML file system provider
XMLTemplateProvider provider =
new XMLSharePointTemplateProvider(context, siteUrl,
PnPPartnerPackConstants.PnPProvisioningTemplates +
(!String.IsNullOrEmpty(folder) ? "/" + folder : String.Empty));
// Load the template from the XML stored copy
ProvisioningTemplate template = provider.GetTemplate(fileName);
template.Connector = provider.Connector;
ProvisioningTemplateApplyingInformation ptai =
new ProvisioningTemplateApplyingInformation();
// We exclude Term Groups because they are not supported in AppOnly
ptai.HandlersToProcess = handlers;
ptai.HandlersToProcess ^= Handlers.TermGroups;
// Handle any custom parameter
if (parameters != null)
{
foreach (var parameter in parameters)
{
template.Parameters.Add(parameter.Key, parameter.Value);
}
}
// Apply the template to the target site
context.Site.RootWeb.ApplyProvisioningTemplate(template, ptai);
}
private static void ApplyProvisioningTemplateToSite(ClientContext context, String siteUrl, String folder, String fileName, Dictionary <String, String> parameters = null)
{
// Configure the XML file system provider
XMLTemplateProvider provider =
new XMLSharePointTemplateProvider(context, siteUrl,
PnPPartnerPackConstants.PnPProvisioningTemplates +
(!String.IsNullOrEmpty(folder) ? "/" + folder : String.Empty));
// Load the template from the XML stored copy
ProvisioningTemplate template = provider.GetTemplate(fileName);
template.Connector = provider.Connector;
// Handle any custom parameter
if (parameters != null)
{
foreach (var parameter in parameters)
{
template.Parameters.Add(parameter.Key, parameter.Value);
}
}
// Apply the template to the target site
context.Site.RootWeb.ApplyProvisioningTemplate(template);
}
public static void CreateFieldsFromProvisioningXML(ClientContext ctx)
{
string folderPath = @"C:\Users\DavidOpdendries\source\SP2018\OfficeDev1\ProvisioningXMLExamples\";
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(folderPath, "");
XMLSharePointTemplateProvider spProvider = new XMLSharePointTemplateProvider(ctx, "https://folkis2018.sharepoint.com/sites/David/", "Shared%20Documents");
var provisioningTemplate = spProvider.GetTemplate("template.xml");
ctx.Web.ApplyProvisioningTemplate(provisioningTemplate);
}
public static ProvisioningTemplate GetProvisioningTemplate(ClientContext context, String siteUrl, String folder, String fileName)
{
// Configure the XML file system provider
XMLTemplateProvider provider =
new XMLSharePointTemplateProvider(context, siteUrl,
PnPPartnerPackConstants.PnPProvisioningTemplates +
(!String.IsNullOrEmpty(folder) ? "/" + folder : String.Empty));
// Load the template from the XML stored copy
ProvisioningTemplate template = provider.GetTemplate(fileName);
return(template);
}
private static void ApplyProvisioningTemplateToSite(ClientContext context, String siteUrl, String folder, String fileName)
{
// Configure the XML file system provider
XMLTemplateProvider provider =
new XMLSharePointTemplateProvider(context, siteUrl,
PnPPartnerPackConstants.PnPProvisioningTemplates +
(!String.IsNullOrEmpty(folder) ? "/" + folder : String.Empty));
// Load the template from the XML stored copy
ProvisioningTemplate template = provider.GetTemplate(fileName);
template.Connector = provider.Connector;
// Apply the template to the target site
context.Site.RootWeb.ApplyProvisioningTemplate(template);
}
/// <summary>
/// This method will retrieve the PnP provisioning template XML file from a SP Doc Library in the Infrastructure site and load it into a ProvisioningTemplate object
/// </summary>
/// <param name="defaultForeground"></param>
/// <param name="sitesToApply"></param>
/// <param name="infrastructureSite"></param>
/// <param name="userName"></param>
/// <param name="pwd"></param>
private static void RetrieveProvisioningTemplateFromSPO(ConsoleColor defaultForeground, List <GlobalNavSiteCollections> sitesToApply, string infrastructureSite, string userName, SecureString pwd)
{
ProvisioningTemplate template;
using (var context = new ClientContext(infrastructureSite))
{
context.Credentials = new SharePointOnlineCredentials(userName, pwd);
context.RequestTimeout = Timeout.Infinite;
Web web = context.Web;
// Get List of Template Files to store it
List list = web.Lists.GetByTitle("ProvisioningTemplates");
CamlQuery query = CamlQuery.CreateAllItemsQuery(100);
ListItemCollection items = list.GetItems(query);
context.Load(items,
includes => includes.Include(i => i.File
));
context.ExecuteQueryRetry();
web.EnsureProperty(w => w.Url);
// New version using SharePoint Connector
// Configure the SharePoint Connector
var sharepointConnector = new SharePointConnector(context, web.Url,
"ProvisioningTemplates");
foreach (ListItem item in items)
{
// Get the template file name and server relative URL
item.File.EnsureProperties(f => f.Name, f => f.ServerRelativeUrl);
XMLSharePointTemplateProvider provider = null;
// Otherwise use the .XML template provider for SharePoint
provider =
new XMLSharePointTemplateProvider(context, web.Url,
"ProvisioningTemplates");
// Get the template
template = provider.GetTemplate(item.File.Name);
ApplyPnPTemplate(sitesToApply, userName, pwd, template);
}
}
}
public void XMLSharePointGetTemplate1Test()
{
var _expectedID = "SPECIALTEAM";
var _expectedVersion = 1.0;
var context = TestCommon.CreatePnPClientContext();
XMLSharePointTemplateProvider provider =
new XMLSharePointTemplateProvider(context,
TestCommon.DevSiteUrl,
testTemplatesDocLib);
var result = provider.GetTemplate("ProvisioningTemplate-2016-05-Sample-02.xml");
Assert.AreEqual(_expectedID, result.Id);
Assert.AreEqual(_expectedVersion, result.Version);
Assert.IsTrue(result.Lists.Count == 2);
Assert.IsTrue(result.SiteFields.Count == 4);
}
private void CreateSiteCollection(SiteCollectionProvisioningJob job)
{
Console.WriteLine("Creating Site Collection \"{0}\".", job.RelativeUrl);
// Define the full Site Collection URL
String siteUrl = String.Format("{0}{1}",
PnPPartnerPackSettings.InfrastructureSiteUrl.Substring(0, PnPPartnerPackSettings.InfrastructureSiteUrl.IndexOf("sharepoint.com/") + 14),
job.RelativeUrl);
using (var adminContext = PnPPartnerPackContextProvider.GetAppOnlyTenantLevelClientContext())
{
adminContext.RequestTimeout = Timeout.Infinite;
// Configure the Site Collection properties
SiteEntity newSite = new SiteEntity();
newSite.Description = job.Description;
newSite.Lcid = (uint)job.Language;
newSite.Title = job.SiteTitle;
newSite.Url = siteUrl;
newSite.SiteOwnerLogin = job.PrimarySiteCollectionAdmin;
newSite.StorageMaximumLevel = job.StorageMaximumLevel;
newSite.StorageWarningLevel = job.StorageWarningLevel;
newSite.Template = PnPPartnerPackSettings.DefaultSiteTemplate;
newSite.TimeZoneId = job.TimeZone;
newSite.UserCodeMaximumLevel = job.UserCodeMaximumLevel;
newSite.UserCodeWarningLevel = job.UserCodeWarningLevel;
// Create the Site Collection and wait for its creation (we're asynchronous)
var tenant = new Tenant(adminContext);
tenant.CreateSiteCollection(newSite, true, true); // TODO: Do we want to empty Recycle Bin?
Site site = tenant.GetSiteByUrl(siteUrl);
Web web = site.RootWeb;
adminContext.Load(site, s => s.Url);
adminContext.Load(web, w => w.Url);
adminContext.ExecuteQueryRetry();
// Enable Secondary Site Collection Administrator
if (!String.IsNullOrEmpty(job.SecondarySiteCollectionAdmin))
{
Microsoft.SharePoint.Client.User secondaryOwner = web.EnsureUser(job.SecondarySiteCollectionAdmin);
secondaryOwner.IsSiteAdmin = true;
secondaryOwner.Update();
web.SiteUsers.AddUser(secondaryOwner);
adminContext.ExecuteQueryRetry();
}
Console.WriteLine("Site \"{0}\" created.", site.Url);
// Check if external sharing has to be enabled
if (job.ExternalSharingEnabled)
{
EnableExternalSharing(tenant, site);
// Enable External Sharing
Console.WriteLine("Enabled External Sharing for site \"{0}\".",
site.Url);
}
}
// Move to the context of the created Site Collection
using (ClientContext clientContext = PnPPartnerPackContextProvider.GetAppOnlyClientContext(siteUrl))
{
Site site = clientContext.Site;
Web web = site.RootWeb;
clientContext.Load(site, s => s.Url);
clientContext.Load(web, w => w.Url);
clientContext.ExecuteQueryRetry();
// Check if we need to enable PnP Partner Pack overrides
if (job.PartnerPackExtensionsEnabled)
{
// Enable Responsive Design
PnPPartnerPackUtilities.EnablePartnerPackOnSite(site.Url);
Console.WriteLine("Enabled PnP Partner Pack Overrides on site \"{0}\".",
site.Url);
}
// Check if the site has to be responsive
if (job.ResponsiveDesignEnabled)
{
// Enable Responsive Design
PnPPartnerPackUtilities.EnableResponsiveDesignOnSite(site.Url);
Console.WriteLine("Enabled Responsive Design Template to site \"{0}\".",
site.Url);
}
// Apply the Provisioning Template
Console.WriteLine("Applying Provisioning Template \"{0}\" to site.",
job.ProvisioningTemplateUrl);
// Determine the reference URLs and file names
String templatesSiteUrl = PnPPartnerPackUtilities.GetSiteCollectionRootUrl(job.ProvisioningTemplateUrl);
String templateFileName = job.ProvisioningTemplateUrl.Substring(job.ProvisioningTemplateUrl.LastIndexOf("/") + 1);
using (ClientContext repositoryContext = PnPPartnerPackContextProvider.GetAppOnlyClientContext(templatesSiteUrl))
{
// Configure the XML file system provider
XMLTemplateProvider provider =
new XMLSharePointTemplateProvider(
repositoryContext,
templatesSiteUrl,
PnPPartnerPackConstants.PnPProvisioningTemplates);
// Load the template from the XML stored copy
ProvisioningTemplate template = provider.GetTemplate(templateFileName);
template.Connector = provider.Connector;
// We do intentionally remove taxonomies, which are not supported
// in the AppOnly Authorization model
// For further details, see the PnP Partner Pack documentation
ProvisioningTemplateApplyingInformation ptai =
new ProvisioningTemplateApplyingInformation();
// Write provisioning steps on console log
ptai.MessagesDelegate += delegate(string message, ProvisioningMessageType messageType) {
Console.WriteLine("{0} - {1}", messageType, messageType);
};
ptai.ProgressDelegate += delegate(string message, int step, int total) {
Console.WriteLine("{0:00}/{1:00} - {2}", step, total, message);
};
ptai.HandlersToProcess ^=
OfficeDevPnP.Core.Framework.Provisioning.Model.Handlers.TermGroups;
// Configure template parameters
if (job.TemplateParameters != null)
{
foreach (var key in job.TemplateParameters.Keys)
{
if (job.TemplateParameters.ContainsKey(key))
{
template.Parameters[key] = job.TemplateParameters[key];
}
}
}
web.ApplyProvisioningTemplate(template, ptai);
}
Console.WriteLine("Applyed Provisioning Template \"{0}\" to site.",
job.ProvisioningTemplateUrl);
}
}
public ProvisioningTemplateInformation[] GetLocalProvisioningTemplates(string siteUrl, TemplateScope scope)
{
List <ProvisioningTemplateInformation> result =
new List <ProvisioningTemplateInformation>();
// Retrieve the Root Site Collection URL
siteUrl = PnPPartnerPackUtilities.GetSiteCollectionRootUrl(siteUrl);
// Connect to the Infrastructural Site Collection
using (var context = PnPPartnerPackContextProvider.GetAppOnlyClientContext(siteUrl))
{
// Get a reference to the target library
Web web = context.Web;
try
{
List list = web.Lists.GetByTitle(PnPPartnerPackConstants.PnPProvisioningTemplates);
// Get only Provisioning Templates documents with the specified Scope
CamlQuery query = new CamlQuery();
query.ViewXml =
@"<View>
<Query>
<Where>
<And>
<Eq>
<FieldRef Name='PnPProvisioningTemplateScope' />
<Value Type='Choice'>" + scope.ToString() + @"</Value>
</Eq>
<Eq>
<FieldRef Name='ContentType' />
<Value Type=''Computed''>PnPProvisioningTemplate</Value>
</Eq>
</And>
</Where>
</Query>
<ViewFields>
<FieldRef Name='Title' />
<FieldRef Name='PnPProvisioningTemplateScope' />
<FieldRef Name='PnPProvisioningTemplateSourceUrl' />
</ViewFields>
</View>";
ListItemCollection items = list.GetItems(query);
context.Load(items,
includes => includes.Include(i => i.File,
i => i[PnPPartnerPackConstants.PnPProvisioningTemplateScope],
i => i[PnPPartnerPackConstants.PnPProvisioningTemplateSourceUrl]));
context.ExecuteQueryRetry();
web.EnsureProperty(w => w.Url);
foreach (ListItem item in items)
{
// Configure the XML file system provider
XMLTemplateProvider provider =
new XMLSharePointTemplateProvider(context, web.Url,
PnPPartnerPackConstants.PnPProvisioningTemplates);
item.File.EnsureProperties(f => f.Name, f => f.ServerRelativeUrl);
ProvisioningTemplate template = provider.GetTemplate(item.File.Name);
result.Add(new ProvisioningTemplateInformation
{
Scope = (TemplateScope)Enum.Parse(typeof(TemplateScope), (String)item[PnPPartnerPackConstants.PnPProvisioningTemplateScope], true),
TemplateSourceUrl = item[PnPPartnerPackConstants.PnPProvisioningTemplateSourceUrl] != null ? ((FieldUrlValue)item[PnPPartnerPackConstants.PnPProvisioningTemplateSourceUrl]).Url : null,
TemplateFileUri = String.Format("{0}/{1}/{2}", web.Url, PnPPartnerPackConstants.PnPProvisioningTemplates, item.File.Name),
TemplateImageUrl = template.ImagePreviewUrl,
DisplayName = template.DisplayName,
Description = template.Description,
});
}
}
catch (ServerException ex)
{
// In case of any issue, ignore the local templates
}
}
return(result.ToArray());
}
private void CreateSubSite(SubSiteProvisioningJob job)
{
// Determine the reference URLs and relative paths
String subSiteUrl = job.RelativeUrl;
String siteCollectionUrl = PnPPartnerPackUtilities.GetSiteCollectionRootUrl(job.ParentSiteUrl);
String parentSiteUrl = job.ParentSiteUrl;
Console.WriteLine("Creating Site \"{0}\" as child Site of \"{1}\".", subSiteUrl, parentSiteUrl);
using (ClientContext context = PnPPartnerPackContextProvider.GetAppOnlyClientContext(parentSiteUrl))
{
// Get a reference to the parent Web
Web parentWeb = context.Web;
// Create the new sub site as a new child Web
WebCreationInformation newWeb = new WebCreationInformation();
newWeb.Description = job.Description;
newWeb.Language = job.Language;
newWeb.Title = job.SiteTitle;
newWeb.Url = subSiteUrl;
newWeb.UseSamePermissionsAsParentSite = job.InheritPermissions;
newWeb.WebTemplate = PnPPartnerPackSettings.DefaultSiteTemplate;
Web web = parentWeb.Webs.Add(newWeb);
context.ExecuteQueryRetry();
Console.WriteLine("Site \"{0}\" created.", subSiteUrl);
// Apply the Provisioning Template
Console.WriteLine("Applying Provisioning Template \"{0}\" to site.",
job.ProvisioningTemplateUrl);
// Determine the reference URLs and file names
String templatesSiteUrl = job.ProvisioningTemplateUrl.Substring(0,
job.ProvisioningTemplateUrl.IndexOf(PnPPartnerPackConstants.PnPProvisioningTemplates));
String templateFileName = job.ProvisioningTemplateUrl.Substring(job.ProvisioningTemplateUrl.LastIndexOf("/") + 1);
// Configure the XML file system provider
XMLTemplateProvider provider =
new XMLSharePointTemplateProvider(context, templatesSiteUrl,
PnPPartnerPackConstants.PnPProvisioningTemplates);
// Load the template from the XML stored copy
ProvisioningTemplate template = provider.GetTemplate(templateFileName);
template.Connector = provider.Connector;
// We do intentionally remove taxonomies, which are not supported in the AppOnly Authorization model
// For further details, see the PnP Partner Pack documentation
ProvisioningTemplateApplyingInformation ptai =
new ProvisioningTemplateApplyingInformation();
ptai.HandlersToProcess ^=
OfficeDevPnP.Core.Framework.Provisioning.Model.Handlers.TermGroups;
// Configure template parameters
foreach (var key in template.Parameters.Keys)
{
if (job.TemplateParameters.ContainsKey(key))
{
template.Parameters[key] = job.TemplateParameters[key];
}
}
// Apply the template to the target site
web.ApplyProvisioningTemplate(template, ptai);
Console.WriteLine("Applyed Provisioning Template \"{0}\" to site.",
job.ProvisioningTemplateUrl);
}
}