public static void Apply(Web web, string templatePath, string templateFileName)
{
try
{
Handlers DefaultHandlers = Handlers.All;
// Get source template
var sourceCreationInformation = new ProvisioningTemplateCreationInformation(web)
{
HandlersToProcess = DefaultHandlers,
};
sourceCreationInformation.ProgressDelegate = (message, step, total) =>
{
LogWriter.Current.WriteLine(string.Format("{0}/{1} Extracting {2}", step, total, message));
};
// Get template from existing site
ProvisioningTemplate template = web.GetProvisioningTemplate(sourceCreationInformation);
// Save template using XML provider
templatePath = templatePath.ToLower();
XMLFileSystemTemplateProvider provider = new XMLFileSystemTemplateProvider(@"" + templatePath, "");
provider.SaveAs(template, templateFileName);
}
catch (Exception ex)
{
LogWriter.Current.WriteLine(string.Format("Error extracting template {0} : {1} - {2}", templateFileName, ex.Message, ex.StackTrace));
}
}
public void CanProvisionSite()
{
if (TestCommon.AppOnlyTesting())
{
Assert.Inconclusive("Template requires term store work, so this will not work in app-only");
}
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(
String.Format(@"{0}\..\..\Resources",
AppDomain.CurrentDomain.BaseDirectory),
"Templates");
var hierarchy = provider.GetHierarchy("ProvisioningSchema-2019-03-FullSample-01.xml");
CanProvisionResult result = null;
using (var pnpContext = new PnPProvisioningContext())
{
using (var context = TestCommon.CreateClientContext())
{
var applyingInformation = new ProvisioningTemplateApplyingInformation();
result = CanProvisionRulesManager.CanProvision(context.Web, hierarchy.Templates[0], applyingInformation);
}
}
Assert.IsNotNull(result);
#if ONPREMISES
// Because the "apps" rule is verified here
Assert.IsFalse(result.CanProvision);
#else
Assert.IsTrue(result.CanProvision);
#endif
}
public void XMLEncryptionTest()
{
X509Certificate2 certificate = RetrieveCertificateFromStore(new X509Store(StoreLocation.CurrentUser), "PnPTestCertificate");
if (certificate == null)
{
Assert.Inconclusive("Missing certificate with SN=PnPTestCertificate in CurrentUser Certificate Store, so can't test");
}
XMLEncryptionTemplateProviderExtension extension =
new XMLEncryptionTemplateProviderExtension();
extension.Initialize(certificate);
ITemplateProviderExtension[] extensions = new ITemplateProviderExtension[] { extension };
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(
String.Format(@"{0}\..\..\Resources",
AppDomain.CurrentDomain.BaseDirectory),
"Templates");
var template = provider.GetTemplate("ProvisioningTemplate-2016-05-Sample-01.xml");
template.DisplayName = "Ciphered template";
provider.SaveAs(template, "ProvisioningTemplate-2016-05-Ciphered.xml", extensions);
var result = provider.GetTemplate("ProvisioningTemplate-2016-05-Ciphered.xml", extensions);
provider.Delete("ProvisioningTemplate-2016-05-Ciphered.xml");
Assert.IsTrue(result.DisplayName == "Ciphered template");
}
public void ExportPagesTest()
{
using (var clientContext = TestCommon.CreateClientContext("https://bertonline.sharepoint.com/sites/TheLanding1"))
{
ProvisioningTemplateCreationInformation ptci = new ProvisioningTemplateCreationInformation(clientContext.Web)
{
// Limit the amount of handlers in this demo
HandlersToProcess = Handlers.PageContents,
// Create FileSystemConnector, so that we can store composed files temporarely somewhere
FileConnector = new FileSystemConnector(@"d:\temp\modernpages", ""),
PersistBrandingFiles = true,
IncludeAllClientSidePages = true,
ProgressDelegate = delegate(String message, Int32 progress, Int32 total)
{
// Only to output progress for console UI
Console.WriteLine("{0:00}/{1:00} - {2}", progress, total, message);
}
};
// Execute actual extraction of the tepmplate
ProvisioningTemplate template = clientContext.Web.GetProvisioningTemplate(ptci);
// Serialize to XML using the beta 201705 schema
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(@"d:\temp\modernpages", "");
var formatter = XMLPnPSchemaFormatter.GetSpecificFormatter(XMLConstants.PROVISIONING_SCHEMA_NAMESPACE_2021_03);
provider.SaveAs(template, "TheLandingMultiLingual.xml", formatter);
}
}
private void ExtractCompleteSPOWebElements(ClientContext ctx, Web extractionWeb, string templateName, string currentDirectory, ILogger logger)
{
try
{
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(Environment.CurrentDirectory, "");
var ptci = new ProvisioningTemplateCreationInformation(extractionWeb);
ctx.Load(extractionWeb.ParentWeb);
ctx.ExecuteQuery();
if (extractionWeb.ParentWeb.ServerObjectIsNull.Value)
{
ptci.IncludeSiteCollectionTermGroup = true;
ptci.IncludeAllTermGroups = true;
}
ProvisioningTemplate template = extractionWeb.GetProvisioningTemplate(ptci);
provider.SaveAs(template, templateName);
SplitTemplateFile(ctx, extractionWeb, string.Format("{0}\\{1}.--.complete-template.xml", Environment.CurrentDirectory, extractionWeb.Title), currentDirectory, logger);
logger.LogMessage(string.Format("Completed template file is extracted for '{0}'.", extractionWeb.Title), LogType.Info);
}
catch (Exception ex)
{
logger.LogMessage(string.Format(Constants.UnknownError, ex.Message), LogType.ErrorAndContinue);
}
}
public void CanProvisionHierarchy()
{
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(
String.Format(@"{0}\..\..\Resources",
AppDomain.CurrentDomain.BaseDirectory),
"Templates");
var hierarchy = provider.GetHierarchy("ProvisioningSchema-2019-03-FullSample-01.xml");
CanProvisionResult result = null;
using (var pnpContext = new PnPProvisioningContext())
{
using (var tenantContext = TestCommon.CreateTenantClientContext())
{
var applyingInformation = new ProvisioningTemplateApplyingInformation();
var tenant = new Tenant(tenantContext);
result = CanProvisionRulesManager.CanProvision(tenant, hierarchy, String.Empty, applyingInformation);
}
}
Assert.IsNotNull(result);
Assert.IsTrue(result.CanProvision);
}
internal static ProvisioningTemplate LoadProvisioningTemplateFromFile(string templatePath, ITemplateProviderExtension[] templateProviderExtensions)
{
// Prepare the File Connector
string templateFileName = System.IO.Path.GetFileName(templatePath);
// Prepare the template path
var fileInfo = new FileInfo(templatePath);
FileConnectorBase fileConnector = new FileSystemConnector(fileInfo.DirectoryName, "");
// Load the provisioning template file
Stream stream = fileConnector.GetFileStream(templateFileName);
var isOpenOfficeFile = ApplyProvisioningTemplate.IsOpenOfficeFile(stream);
XMLTemplateProvider provider;
if (isOpenOfficeFile)
{
provider = new XMLOpenXMLTemplateProvider(new OpenXMLConnector(templateFileName, fileConnector));
templateFileName = templateFileName.Substring(0, templateFileName.LastIndexOf(".", StringComparison.Ordinal)) + ".xml";
}
else
{
provider = new XMLFileSystemTemplateProvider(fileConnector.Parameters[FileConnectorBase.CONNECTIONSTRING] + "", "");
}
ProvisioningTemplate provisioningTemplate = provider.GetTemplate(templateFileName, templateProviderExtensions);
provisioningTemplate.Connector = provider.Connector;
// Return the result
return(provisioningTemplate);
}
protected override void ExecuteCmdlet()
{
ExtractConfiguration extractConfiguration = null;
if (ParameterSpecified(nameof(Configuration)))
{
extractConfiguration = Configuration.GetConfiguration(SessionState.Path.CurrentFileSystemLocation.Path);
if (!string.IsNullOrEmpty(SiteUrl))
{
if (extractConfiguration.Tenant.Sequence == null)
{
extractConfiguration.Tenant.Sequence = new OfficeDevPnP.Core.Framework.Provisioning.Model.Configuration.Tenant.Sequence.ExtractSequenceConfiguration();
}
extractConfiguration.Tenant.Sequence.SiteUrls.Add(SiteUrl);
}
}
if (ParameterSetName == PARAMETERSET_ASFILE)
{
ProvisioningHierarchy tenantTemplate = null;
if (!Path.IsPathRooted(Out))
{
Out = Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Out);
}
if (Out.ToLower().EndsWith(".pnp"))
{
WriteWarning("This cmdlet does not save a tenant template as a PnP file.");
}
var fileInfo = new FileInfo(Out);
var fileSystemConnector = new FileSystemConnector(fileInfo.DirectoryName, "");
extractConfiguration.FileConnector = fileSystemConnector;
var proceed = false;
if (File.Exists(Out))
{
if (Force || ShouldContinue(string.Format(Resources.File0ExistsOverwrite, Out), Resources.Confirm))
{
proceed = true;
}
}
else
{
proceed = true;
}
if (proceed)
{
tenantTemplate = ExtractTemplate(extractConfiguration);
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(fileInfo.DirectoryName, "");
provider.SaveAs(tenantTemplate, Out);
}
}
else
{
WriteObject(ExtractTemplate(extractConfiguration));
}
}
public static void ProvisionArtifactsByTemplate()
{
// Create a PnP AuthenticationManager object
AuthenticationManager am = new AuthenticationManager();
// Authenticate against SPO with an App-Only access token
using (ClientContext context = am.GetAzureADAppOnlyAuthenticatedContext(
O365ProjectsAppContext.CurrentSiteUrl, O365ProjectsAppSettings.ClientId,
O365ProjectsAppSettings.TenantId, O365ProjectsAppSettings.AppOnlyCertificate))
{
Web web = context.Web;
// Load the template from the file system
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(
String.Format(HttpContext.Current.Server.MapPath(".")),
"ProvisioningTemplates");
ProvisioningTemplate template = provider.GetTemplate("O365ProjectsAppSite.xml");
// Configure the AppSiteUrl parameter
template.Parameters["AppSiteUrl"] = O365ProjectsAppContext.CurrentAppSiteUrl;
// Apply the template to the target site
template.Connector = provider.Connector;
web.ApplyProvisioningTemplate(template);
}
}
protected override void ProcessRecord()
{
if (!System.IO.Path.IsPathRooted(Path))
{
Path = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Path);
}
// Load the template
var template = LoadProvisioningTemplate
.LoadProvisioningTemplateFromFile(Path,
TemplateProviderExtensions);
if (template == null)
{
throw new ApplicationException("Invalid template file!");
}
// Load the file and add it to the .PNP file
using (var fs = new FileStream(Source, FileMode.Open, FileAccess.Read, FileShare.Read))
{
Folder = Folder.Replace("\\", "/");
var fileName = Source.IndexOf("\\") > 0 ? Source.Substring(Source.LastIndexOf("\\") + 1) : Source;
var container = !string.IsNullOrEmpty(Container) ? Container : string.Empty;
var source = !string.IsNullOrEmpty(container) ? (container + "/" + fileName) : fileName;
template.Connector.SaveFileStream(fileName, container, fs);
if (template.Connector is ICommitableFileConnector)
{
((ICommitableFileConnector)template.Connector).Commit();
}
template.Files.Add(new OfficeDevPnP.Core.Framework.Provisioning.Model.File
{
Src = source,
Folder = Folder,
Overwrite = true,
});
// Determine the output file name and path
var outFileName = System.IO.Path.GetFileName(Path);
var outPath = new FileInfo(Path).DirectoryName;
var fileSystemConnector = new FileSystemConnector(outPath, "");
var formatter = XMLPnPSchemaFormatter.LatestFormatter;
var extension = new FileInfo(Path).Extension.ToLowerInvariant();
if (extension == ".pnp")
{
XMLTemplateProvider provider = new XMLOpenXMLTemplateProvider(new OpenXMLConnector(outPath, fileSystemConnector));
var templateFileName = outFileName.Substring(0, outFileName.LastIndexOf(".", StringComparison.Ordinal)) + ".xml";
provider.SaveAs(template, templateFileName, formatter, TemplateProviderExtensions);
}
else
{
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(Path, "");
provider.SaveAs(template, Path, formatter, TemplateProviderExtensions);
}
}
}
protected override void ProcessRecord()
{
// Determine the output file name and path
string outFileName = Path.GetFileName(Out);
if (!Path.IsPathRooted(Out))
{
Out = Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Out);
}
bool proceed = false;
if (System.IO.File.Exists(Out))
{
if (Force || ShouldContinue(string.Format(Properties.Resources.File0ExistsOverwrite, Out),
Properties.Resources.Confirm))
{
proceed = true;
}
}
else
{
proceed = true;
}
string outPath = new FileInfo(Out).DirectoryName;
// Determine if it is an .XML or a .PNP file
var extension = "";
if (proceed && outFileName != null)
{
if (outFileName.IndexOf(".", StringComparison.Ordinal) > -1)
{
extension = outFileName.Substring(outFileName.LastIndexOf(".", StringComparison.Ordinal)).ToLower();
}
else
{
extension = ".pnp";
}
}
var fileSystemConnector = new FileSystemConnector(outPath, "");
ITemplateFormatter formatter = XMLPnPSchemaFormatter.LatestFormatter;
if (extension == ".pnp")
{
XMLTemplateProvider provider = new XMLOpenXMLTemplateProvider(
Out, fileSystemConnector);
var templateFileName = outFileName.Substring(0, outFileName.LastIndexOf(".", StringComparison.Ordinal)) + ".xml";
provider.SaveAs(InputInstance, templateFileName, formatter, TemplateProviderExtensions);
}
else
{
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(outPath, "");
provider.SaveAs(InputInstance, Out, formatter, TemplateProviderExtensions);
}
}
public void CanSerializeDomainObjectWithJsonFormatter()
{
using (Stream _formattedTemplate = new FileStream(this._provisioningTemplatePath5, FileMode.Open, FileAccess.Read, FileShare.Read))
{
ITemplateFormatter formatter = XMLPnPSchemaFormatter.GetSpecificFormatter(this._provisioningTemplatePath5NamespaceURI);
XMLTemplateProvider xmlProvider =
new XMLFileSystemTemplateProvider(
String.Format(@"{0}\..\..\Resources",
AppDomain.CurrentDomain.BaseDirectory),
"Templates");
formatter.Initialize(xmlProvider);
var _pt = formatter.ToProvisioningTemplate(_formattedTemplate, "WORKFLOWSITE");
JsonTemplateProvider jsonProvider =
new JsonFileSystemTemplateProvider(
String.Format(@"{0}\..\..\Resources",
AppDomain.CurrentDomain.BaseDirectory),
"Templates");
jsonProvider.SaveAs(_pt, @"c:\temp\ProvisioningSchema-2015-05-ReferenceSample-01.json");
var _ptBack = jsonProvider.GetTemplate(@"c:\temp\ProvisioningSchema-2015-05-ReferenceSample-01.json");
Assert.IsTrue(_pt.Equals(_ptBack));
}
}
public static void Apply(Web web, string templatePath, string templateName)
{
try
{
LogWriter.Current.WriteLine("Applying " + templateName);
// Connector to file system. Use current .exe folder as root, don't specify a subfolder
var connector = new FileSystemConnector(LocalFilePaths.LocalPath, string.Empty);
// Provider to get template
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider();
provider.Connector = connector;
var result = provider.GetTemplate(templatePath + "\\" + templateName);
// Connector needs to be specified once more in ProvisioningTemplate because he is not copied from the provider on template creation
result.Connector = connector;
var applyingInformation = new ProvisioningTemplateApplyingInformation();
applyingInformation.ProgressDelegate = (message, step, total) =>
{
LogWriter.Current.WriteLine(string.Format("{0}/{1} Provisioning {2}", step, total, message));
};
web.ApplyProvisioningTemplate(result, applyingInformation);
}
catch (Exception ex)
{
LogWriter.Current.WriteLine(string.Format("Error applying template {0} : {1} - {2}", templateName, ex.Message, ex.StackTrace));
}
}
private static void GenerateProvisioningTemplate(LoadProvisioningInfo info, string appDirectory)
{
var context = Helper.GetADAppOnlyContext(info.WebUrl, appDirectory);
using (context)
{
Web web = context.Web;
context.Load(web, w => w.Title);
context.ExecuteQueryRetry();
ProvisioningTemplateCreationInformation ptci
= new ProvisioningTemplateCreationInformation(context.Web);
// Create FileSystemConnector to store a temporary copy of the template
ptci.FileConnector = new FileSystemConnector(Path.GetTempPath(), "");
ptci.PersistBrandingFiles = true;
ptci.HandlersToProcess = info.Handlers;
// Execute actual extraction of the template
ProvisioningTemplate template = context.Web.GetProvisioningTemplate(ptci);
// We can serialize this template to save and reuse it
// Optional step
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(Path.GetTempPath(), "");
provider.SaveAs(template, Configs.FileName);
}
}
/// <summary>
/// Load template file in fileSystem
/// dirPath: It be use to returned the final directory XML
/// </summary>
public static ProvisioningTemplate ReadTemplateFromUrl(string name, out string dirPath, string directory = "")
{
ProvisioningTemplate template = null;
try
{
string path = ""; // Check directory if not get current
if (string.IsNullOrEmpty(directory))
{
directory = System.Reflection.Assembly.GetExecutingAssembly().Location;
}
path = Path.GetDirectoryName(directory);
path = Path.Combine(path, mainFolder, string.Concat(name, mainExtension));
FileInfo fileInfo = new FileInfo(path);
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(fileInfo.DirectoryName, "");
template = provider.GetTemplate(fileInfo.Name); // Get XML file
dirPath = fileInfo.DirectoryName; // Use for upload files
} catch (Exception ex)
{
dirPath = "";
LogHelper.writeError(string.Concat("A problem happend when try to read the template from file system. ", ex.Message));
}
return(template);
}
public TestProvisioningTemplateResult TestProvisioningTemplate(ClientContext cc, string templateName, Handlers handlersToProcess = Handlers.All, ProvisioningTemplateApplyingInformation ptai = null, ProvisioningTemplateCreationInformation ptci = null)
{
try
{
// Read the template from XML and apply it
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(string.Format(@"{0}\..\..\Framework\Functional", AppDomain.CurrentDomain.BaseDirectory), "Templates");
ProvisioningTemplate sourceTemplate = provider.GetTemplate(templateName);
if (ptai == null)
{
ptai = new ProvisioningTemplateApplyingInformation();
ptai.HandlersToProcess = handlersToProcess;
}
if (ptai.ProgressDelegate == null)
{
ptai.ProgressDelegate = delegate(String message, Int32 progress, Int32 total)
{
Console.WriteLine("Applying template - {0}/{1} - {2}", progress, total, message);
};
}
sourceTemplate.Connector = provider.Connector;
TokenParser sourceTokenParser = new TokenParser(cc.Web, sourceTemplate);
cc.Web.ApplyProvisioningTemplate(sourceTemplate, ptai);
// Read the site we applied the template to
if (ptci == null)
{
ptci = new ProvisioningTemplateCreationInformation(cc.Web);
ptci.HandlersToProcess = handlersToProcess;
}
if (ptci.ProgressDelegate == null)
{
ptci.ProgressDelegate = delegate(String message, Int32 progress, Int32 total)
{
Console.WriteLine("Getting template - {0}/{1} - {2}", progress, total, message);
};
}
ProvisioningTemplate targetTemplate = cc.Web.GetProvisioningTemplate(ptci);
return(new TestProvisioningTemplateResult()
{
SourceTemplate = sourceTemplate,
SourceTokenParser = sourceTokenParser,
TargetTemplate = targetTemplate,
TargetTokenParser = new TokenParser(cc.Web, targetTemplate),
});
}
catch (Exception ex)
{
Console.WriteLine(ex.ToDetailedString());
throw;
}
}
internal static ProvisioningTemplate LoadProvisioningTemplateFromFile(string templatePath, ITemplateProviderExtension[] templateProviderExtensions, Action <Exception> exceptionHandler)
{
// Prepare the File Connector
string templateFileName = System.IO.Path.GetFileName(templatePath);
// Prepare the template path
var fileInfo = new FileInfo(templatePath);
FileConnectorBase fileConnector = new FileSystemConnector(fileInfo.DirectoryName, "");
// Load the provisioning template file
Stream stream = fileConnector.GetFileStream(templateFileName);
if (stream == null)
{
throw new FileNotFoundException($"File {templatePath} does not exist.", templatePath);
}
var isOpenOfficeFile = FileUtilities.IsOpenOfficeFile(stream);
XMLTemplateProvider provider;
if (isOpenOfficeFile)
{
var openXmlConnector = new OpenXMLConnector(templateFileName, fileConnector);
provider = new XMLOpenXMLTemplateProvider(openXmlConnector);
if (!String.IsNullOrEmpty(openXmlConnector.Info?.Properties?.TemplateFileName))
{
templateFileName = openXmlConnector.Info.Properties.TemplateFileName;
}
else
{
templateFileName = templateFileName.Substring(0, templateFileName.LastIndexOf(".", StringComparison.Ordinal)) + ".xml";
}
}
else
{
provider = new XMLFileSystemTemplateProvider(fileConnector.Parameters[FileConnectorBase.CONNECTIONSTRING] + "", "");
}
try
{
ProvisioningTemplate provisioningTemplate = provider.GetTemplate(templateFileName, templateProviderExtensions);
provisioningTemplate.Connector = provider.Connector;
return(provisioningTemplate);
}
catch (ApplicationException ex)
{
if (ex.InnerException is AggregateException)
{
if (exceptionHandler != null)
{
foreach (var exception in ((AggregateException)ex.InnerException).InnerExceptions)
{
exceptionHandler(exception);
}
}
}
}
return(null);
}
protected override void ExecuteCmdlet()
{
SelectedWeb.EnsureProperty(w => w.Url);
bool templateFromFileSystem = !Path.ToLower().StartsWith("http");
FileConnectorBase fileConnector;
string templateFileName = System.IO.Path.GetFileName(Path);
if (templateFromFileSystem)
{
if (!System.IO.Path.IsPathRooted(Path))
{
Path = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Path);
}
FileInfo fileInfo = new FileInfo(Path);
fileConnector = new FileSystemConnector(fileInfo.DirectoryName, "");
}
else
{
Uri fileUri = new Uri(Path);
var webUrl = Microsoft.SharePoint.Client.Web.WebUrlFromFolderUrlDirect(ClientContext, fileUri);
var templateContext = ClientContext.Clone(webUrl.ToString());
string library = Path.ToLower().Replace(templateContext.Url.ToLower(), "").TrimStart('/');
int idx = library.IndexOf("/");
library = library.Substring(0, idx);
fileConnector = new SharePointConnector(templateContext, templateContext.Url, library);
}
XMLTemplateProvider provider;
ProvisioningTemplate provisioningTemplate;
Stream stream = fileConnector.GetFileStream(templateFileName);
var isOpenOfficeFile = ApplyProvisioningTemplate.IsOpenOfficeFile(stream);
if (isOpenOfficeFile)
{
provider = new XMLOpenXMLTemplateProvider(new OpenXMLConnector(templateFileName, fileConnector));
templateFileName = templateFileName.Substring(0, templateFileName.LastIndexOf(".", StringComparison.Ordinal)) + ".xml";
}
else
{
if (templateFromFileSystem)
{
provider = new XMLFileSystemTemplateProvider(fileConnector.Parameters[FileConnectorBase.CONNECTIONSTRING] + "", "");
}
else
{
throw new NotSupportedException("Only .pnp package files are supported from a SharePoint library");
}
}
provisioningTemplate = provider.GetTemplate(templateFileName, TemplateProviderExtensions);
if (provisioningTemplate == null)
{
return;
}
GetProvisioningTemplate.SetTemplateMetadata(provisioningTemplate, TemplateDisplayName, TemplateImagePreviewUrl, TemplateProperties);
provider.SaveAs(provisioningTemplate, templateFileName, TemplateProviderExtensions);
}
public static ProvisioningTemplate GenerateProvisioningTemplate(ConsoleColor defaultForeground, ClientContext ctx, string filePath, string fileName)
{
//using (var ctx = new ClientContext(webUrl))
{
// ctx.Credentials = new NetworkCredentials(userName, pwd);
//ctx.Credentials = new SharePointOnlineCredentials(userName, pwd);
ctx.RequestTimeout = Timeout.Infinite;
// Just to output the site details
Web web = ctx.Web;
ctx.Load(web, w => w.Title);
ctx.ExecuteQueryRetry();
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Your site title is:" + ctx.Web.Title);
Console.ForegroundColor = defaultForeground;
var ptci = new ProvisioningTemplateCreationInformation(ctx.Web);
// Create FileSystemConnector to store a temporary copy of the template
ptci.FileConnector = new FileSystemConnector(filePath, "");
ptci.PersistComposedLookFiles = true;
ptci.ProgressDelegate = delegate(String message, Int32 progress, Int32 total)
{
// Only to output progress for console UI
Console.WriteLine("{0:00}/{1:00} - {2}", progress, total, message);
};
//ptci.IncludeAllTermGroups = true;
ptci.IncludeAllTermGroups = false;
ptci.IncludeNativePublishingFiles = false;
ptci.IncludeSearchConfiguration = false;
ptci.IncludeSiteCollectionTermGroup = false;
ptci.IncludeSiteGroups = false;
ptci.IncludeTermGroupsSecurity = false;
//ptci.HandlersToProcess = Handlers.All;
//ALL
ptci.HandlersToProcess = Handlers.AuditSettings | Handlers.ComposedLook | Handlers.ContentTypes | Handlers.CustomActions | Handlers.ExtensibilityProviders | Handlers.Features | Handlers.Fields | Handlers.Files | Handlers.Lists | Handlers.Navigation | Handlers.PageContents | Handlers.Pages | Handlers.PropertyBagEntries | Handlers.Publishing | Handlers.RegionalSettings | Handlers.SearchSettings;// | Handlers.WebSettings;
//PART 1
//ptci.HandlersToProcess = Handlers.ContentTypes | Handlers.Fields | Handlers.Files | Handlers.Lists;
//PART 2
//ptci.HandlersToProcess = Handlers.Files | Handlers.Pages;
//ptci.HandlersToProcess = Handlers.PageContents | Handlers.Pages | Handlers.PropertyBagEntries | Handlers.Publishing | Handlers.RegionalSettings | Handlers.SearchSettings | Handlers.WebSettings;
// Execute actual extraction of the template
ProvisioningTemplate template = ctx.Web.GetProvisioningTemplate(ptci);
// We can serialize this template to save and reuse it
// Optional step
var provider = new XMLFileSystemTemplateProvider(filePath, "");
provider.SaveAs(template, fileName);
return(template);
}
}
private static void GetProvisioningTemplate(ClientContext clientContext, string path = @"c:\temp\pnpprovisioningdemo")
{
var webTemplateCreationInformation = new ProvisioningTemplateCreationInformation(clientContext.Web);
var template = clientContext.Web.GetProvisioningTemplate(webTemplateCreationInformation);
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(@"c:\temp\pnpprovisioningdemo", "");
provider.SaveAs(template, "PnPProvisioning.xml");
}
private static ProvisioningTemplate GetTemplateFromXmlFile(string filePath)
{
var path = System.IO.Path.GetDirectoryName(filePath);
var fileName = System.IO.Path.GetFileName(filePath);
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(path, "");
return(provider.GetTemplate(fileName));
}
public void CanProvisionHierarchy()
{
if (TestCommon.AppOnlyTesting())
{
Assert.Inconclusive("Template requires term store work, so this will not work in app-only");
}
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(
String.Format(@"{0}\..\..\..\Resources",
AppDomain.CurrentDomain.BaseDirectory),
"Templates");
var hierarchy = provider.GetHierarchy("ProvisioningSchema-2019-03-FullSample-01.xml");
var applyingInformation = new ProvisioningTemplateApplyingInformation();
if (TestCommon.AppOnlyTesting())
{
bool templateSupportsAppOnly = true;
if (applyingInformation.HandlersToProcess.Has(PnP.Framework.Provisioning.Model.Handlers.TermGroups) ||
applyingInformation.HandlersToProcess.Has(PnP.Framework.Provisioning.Model.Handlers.SearchSettings))
{
if (hierarchy.Templates.Count > 0)
{
foreach (var template in hierarchy.Templates)
{
templateSupportsAppOnly = this.IsTemplateSupportedForAppOnly(template);
if (!templateSupportsAppOnly)
{
break;
}
}
}
}
if (!templateSupportsAppOnly)
{
Assert.Inconclusive("Taxonomy and SearchSettings tests are not supported when testing using app-only context.");
}
}
CanProvisionResult result = null;
using (var pnpContext = new PnPProvisioningContext())
{
using (var tenantContext = TestCommon.CreateTenantClientContext())
{
var tenant = new Tenant(tenantContext);
result = CanProvisionRulesManager.CanProvision(tenant, hierarchy, String.Empty, applyingInformation);
}
}
Assert.IsNotNull(result);
Assert.IsTrue(result.CanProvision);
Assert.IsTrue(result.CanProvision);
}
/// <summary>
/// Save export template to file in fileSystem
/// </summary>
public static void SaveTemplateFromUrl(ProvisioningTemplate template, string directory, string fileName)
{
string templateName = !string.IsNullOrEmpty(fileName) ? fileName : "template";
// We can serialize this template to save and reuse it
// Optional step
XMLTemplateProvider provider = new XMLFileSystemTemplateProvider(directory, "");
provider.SaveAs(template, string.Concat(templateName, ".xml"));
}
public static void RunXmlFiles(ClientContext ctx)
{
//To run XML files change the template name and the path of the file.
XMLFileSystemTemplateProvider provider = new XMLFileSystemTemplateProvider(@"C:\Users\lucho\source\repos\OfficeDev1\FinalAssignment\Common\XML", "");
string templateName = "assignment.xml";
ProvisioningTemplate template = provider.GetTemplate(templateName);
ctx.Web.ApplyProvisioningTemplate(template);
}
private static bool Auto_ProcessSubsites(ListItemCollection subsiterequests, ClientContext ctx)
{
bool processed = false;
ConsoleColor defaultForeground = Console.ForegroundColor;
foreach (ListItem ssite in subsiterequests)
{
if (ssite != null)
{
Web newlycreatedWeb;
bool proceedwithProvisioning = false;
ProvisioningTemplate subsitetemplate;
string siteUrl = Convert.ToString(ssite["SiteUrl"]);
string fullsubsiteurl = Convert.ToString(ssite["SiteBaseUrl"]) + siteUrl;
string subsite_TemplateFileName = Convert.ToString(ssite["TemplateFileName"]);
string subsiteTemplateID = Convert.ToString(ssite["TemplateID"]);
bool result = Auto_WebExists(Convert.ToString(ssite["SiteBaseUrl"]), fullsubsiteurl, subsitecheck);
if (!result)
{
newlycreatedWeb = Auto_CreateSubSite(Convert.ToString(ssite["SiteBaseUrl"]), Convert.ToString(ssite["SiteName"]), Convert.ToString(ssite["Description"]), subsiteTemplateID, siteUrl);
if (newlycreatedWeb != null)
{
UpdateStatusToList(ssite.Id, SubSite_Created, "Created at " + DateTime.Now.ToString());
proceedwithProvisioning = true;
}
else
{
UpdateStatusToList(ssite.Id, SubSite_Creation_Failed, "Failed at " + DateTime.Now.ToString());
Console.WriteLine("Skipped provisioning of site {0}.Problem while creating subsite.", Convert.ToString(ssite["SiteUrl"]));
}
}
else
{
UpdateStatusToList(ssite.Id, Failure_SubSite_Exists, string.Format("Subsite with url already exist{0} at {1}", fullsubsiteurl, DateTime.Now.ToString()));
proceedwithProvisioning = false;
}
if (proceedwithProvisioning)
{
var subsiteConfigPath = string.Format("{0}\\{1}\\{2}", System.IO.Directory.GetCurrentDirectory(), ConfigurationManager.AppSettings["XMLConfigRootPath"], subsite_TemplateFileName);
XMLTemplateProvider subsiteprovider = new XMLFileSystemTemplateProvider(ConfigurationManager.AppSettings["XMLConfigRootPath"], "");
subsitetemplate = subsiteprovider.GetTemplate(subsiteConfigPath);
string errorOccuredMessage = Auto_ApplyProvisioningTemplate(defaultForeground, fullsubsiteurl, subsitetemplate);
if (string.IsNullOrEmpty(errorOccuredMessage))
{
UpdateStatusToList(ssite.Id, Completed_Template_Provisioning, "Provisioned successfully at " + DateTime.Now.ToString());
}
else
{
UpdateStatusToList(ssite.Id, Failed_Template_Provisioning, string.Format("Subsite Provisioning failed.{0}", errorOccuredMessage));
}
}
}
}
processed = true;
return(processed);
}
static void Main(string[] args)
{
try
{
ConsoleColor defaultForeground = Console.ForegroundColor;
// Collect information
// string templateWebUrl = GetInput("Enter the URL of the template site: ", false, defaultForeground);
string targetWebUrl = GetInput("Enter the URL of the target site: ", false, defaultForeground);
string userName = GetInput("Enter your user name:", false, defaultForeground);
string pwdS = GetInput("Enter your password:"******"Get XMl Path:", false, defaultForeground);
string filename = GetInput("Get XMl filename:", false, defaultForeground);
SecureString pwd = new SecureString();
foreach (char c in pwdS.ToCharArray())
{
pwd.AppendChar(c);
}
using (var context = new ClientContext(targetWebUrl))
{
context.Credentials = new SharePointOnlineCredentials(userName, pwd);
Web web = context.Web;
context.Load(web, w => w.Title);
context.ExecuteQueryRetry();
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(filepath, "");
ProvisioningTemplate template = provider.GetTemplate(filename);
ProvisioningTemplateApplyingInformation ptai =
new ProvisioningTemplateApplyingInformation();
ptai.ProgressDelegate = delegate(String message, Int32 progress, Int32 total)
{
Console.WriteLine("{0:00}/{1:00} - {2}", progress, total, message);
};
template.Connector = provider.Connector;
web.ApplyProvisioningTemplate(template, ptai);
}
// Get the template from existing site and serialize that (not really needed)
// Just to pause and indicate that it's all done
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("We are all done. Press enter to continue.");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
Console.WriteLine("Document id activation started...");
// Grab site from arguments
var siteUrl = args[0];
var adminSiteUrl = new Uri(siteUrl.Replace(".sharepoint.com", "-admin.sharepoint.com")).GetLeftPart(UriPartial.Authority);
Console.WriteLine($"Site url is \"{siteUrl}\"");
// Grab client credentials from configuration
var appId = AppSettings["AppId"];
var appSecret = AppSettings["AppSecret"];
// Load the provisioning template
Console.WriteLine("Loading template...");
TemplateProviderBase templateProvider = new XMLFileSystemTemplateProvider(".\\", string.Empty);
var template = templateProvider.GetTemplate("OpportunitySite.xml");
Console.WriteLine("Template successfully parsed.");
// Authenticate using the client credentials flow
Console.WriteLine("Attempting OAuth authentication...");
// Prepare site
var retries = 0;
do
{
try
{
var adminAuthenticationManager = new AuthenticationManager();
using (var adminContext = adminAuthenticationManager.GetAppOnlyAuthenticatedContext(adminSiteUrl, appId, appSecret))
{
var tenant = new Tenant(adminContext);
tenant.SetSiteProperties(siteUrl, noScriptSite: false);
adminContext.ExecuteQuery();
var authenticationManager = new AuthenticationManager();
using (var context = authenticationManager.GetAppOnlyAuthenticatedContext(siteUrl, appId, appSecret))
{
Console.WriteLine("Succesfully authenticated. Provisioning...");
// Apply the provisioning template
context.Web.ApplyProvisioningTemplate(template);
Console.WriteLine("Provisioning was successful.");
}
}
return;
}
catch (Exception ex)
{
var errorMessage = $"Provisioning failed: {ex.Message}. Retry #{retries}.";
Console.WriteLine(errorMessage);
retries++;
Thread.Sleep(5000);
}
} while (retries < 10);
throw new Exception($"Document Id Activation failed after {retries}. Please activate it manually");
}
public static ProvisioningTemplate GetProvisioningTemplateFromResourcePath(string templateName, string resourcesPath, string folderName, string provisionResourceFolderPath)
{
// Template to be applied to site
ProvisioningTemplate template = null;
XMLFileSystemTemplateProvider provider = new XMLFileSystemTemplateProvider(resourcesPath, folderName);
template = provider.GetTemplate(templateName);
template.Connector = new FileSystemConnector(provisionResourceFolderPath, "");
return(template);
}
private void DumpTemplate(ClientContext ctx, string template, string subSiteTemplate = "", string saveAsTemplate = "")
{
Uri devSiteUrl = new Uri(ConfigurationManager.AppSettings["SPODevSiteUrl"]);
string baseUrl = String.Format("{0}://{1}", devSiteUrl.Scheme, devSiteUrl.DnsSafeHost);
string siteUrl = "";
if (subSiteTemplate.Length > 0)
{
siteUrl = (String.Format("{1}/sites/template{0}/template{2}", template, baseUrl, subSiteTemplate));
}
else
{
siteUrl = (String.Format("{1}/sites/template{0}", template, baseUrl));
}
using (ClientContext cc = ctx.Clone(siteUrl))
{
// Specify null as base template since we do want "everything" in this case
ProvisioningTemplateCreationInformation creationInfo = new ProvisioningTemplateCreationInformation(cc.Web);
creationInfo.BaseTemplate = null;
// Override the save name. Case is online site collection provisioned using blankinternetcontainer#0 which returns
// blankinternet#0 as web template using CSOM/SSOM API
if (saveAsTemplate.Length > 0)
{
template = saveAsTemplate;
}
ProvisioningTemplate p = cc.Web.GetProvisioningTemplate(creationInfo);
if (subSiteTemplate.Length > 0)
{
p.Id = String.Format("{0}template", subSiteTemplate);
}
else
{
p.Id = String.Format("{0}template", template);
}
// Cleanup before saving
p.Security.AdditionalAdministrators.Clear();
XMLFileSystemTemplateProvider provider = new XMLFileSystemTemplateProvider(".", "");
if (subSiteTemplate.Length > 0)
{
provider.SaveAs(p, String.Format("{0}Template.xml", subSiteTemplate));
}
else
{
provider.SaveAs(p, String.Format("{0}Template.xml", 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 void XMLFileSystemGetTemplatesTest()
{
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(
String.Format(@"{0}\..\..\Resources",
AppDomain.CurrentDomain.BaseDirectory),
"Templates");
var result = provider.GetTemplates();
Assert.IsTrue(result.Count == 2);
Assert.IsTrue(result[0].Files.Count == 1);
Assert.IsTrue(result[1].Files.Count == 5);
}
public void XMLFileSystemGetTemplate2Test()
{
var _expectedID = "SPECIALTEAM";
var _expectedVersion = 1.0;
XMLTemplateProvider provider =
new XMLFileSystemTemplateProvider(
String.Format(@"{0}\..\..\Resources",
AppDomain.CurrentDomain.BaseDirectory),
"Templates");
var result = provider.GetTemplate("ProvisioningTemplate-2015-03-Sample-02.xml");
Assert.AreEqual(_expectedID, result.ID);
Assert.AreEqual(_expectedVersion, result.Version);
Assert.IsTrue(result.Lists.Count == 2);
Assert.IsTrue(result.Files.Count == 5);
Assert.IsTrue(result.SiteFields.Count == 4);
}
