protected override void ProcessRecord()
{
switch (ParameterSetName)
{
case ParameterSet_PATH:
{
if (!System.IO.Path.IsPathRooted(Path))
{
Path = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Path);
}
WriteObject(ProvisioningHelper.LoadSiteTemplateFromFile(Path, TemplateProviderExtensions, (e) =>
{
WriteError(new ErrorRecord(e, "TEMPLATENOTVALID", ErrorCategory.SyntaxError, null));
}));
break;
}
case ParameterSet_XML:
{
WriteObject(ProvisioningHelper.LoadSiteTemplateFromString(Xml, TemplateProviderExtensions, (e) =>
{
WriteError(new ErrorRecord(e, "TEMPLATENOTVALID", ErrorCategory.SyntaxError, null));
}));
break;
}
}
}
private void ProcessFiles(ProvisioningTemplate template, string templateFileName, FileConnectorBase fileSystemConnector)
{
var templateFile = ProvisioningHelper.LoadSiteTemplateFromFile(templateFileName, null, (e) =>
{
WriteError(new ErrorRecord(e, "TEMPLATENOTVALID", ErrorCategory.SyntaxError, null));
});
if (template.Tenant?.AppCatalog != null)
{
foreach (var app in template.Tenant.AppCatalog.Packages)
{
WriteObject($"Processing {app.Src}");
AddFile(app.Src, templateFile, fileSystemConnector);
}
}
if (template.Tenant?.SiteScripts != null)
{
foreach (var siteScript in template.Tenant.SiteScripts)
{
WriteObject($"Processing {siteScript.JsonFilePath}");
AddFile(siteScript.JsonFilePath, templateFile, fileSystemConnector);
}
}
if (template.Localizations != null && template.Localizations.Any())
{
foreach (var location in template.Localizations)
{
WriteObject($"Processing {location.ResourceFile}");
AddFile(location.ResourceFile, templateFile, fileSystemConnector);
}
}
if (template.WebSettings != null && !String.IsNullOrEmpty(template.WebSettings.SiteLogo))
{
// is it a file?
var isFile = false;
using (var fileStream = fileSystemConnector.GetFileStream(template.WebSettings.SiteLogo))
{
isFile = fileStream != null;
}
if (isFile)
{
WriteObject($"Processing {template.WebSettings.SiteLogo}");
AddFile(template.WebSettings.SiteLogo, templateFile, fileSystemConnector);
}
}
if (template.Files.Any())
{
foreach (var file in template.Files)
{
WriteObject($"Processing {file.Src}");
AddFile(file.Src, templateFile, fileSystemConnector);
}
}
if (templateFile.Connector is ICommitableFileConnector)
{
((ICommitableFileConnector)templateFile.Connector).Commit();
}
}
protected override void ProcessRecord()
{
if (!System.IO.Path.IsPathRooted(Path))
{
Path = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Path);
}
// Load the template
ProvisioningTemplate template = ProvisioningHelper.LoadSiteTemplateFromFile(Path, TemplateProviderExtensions, (e) =>
{
WriteError(new ErrorRecord(e, "TEMPLATENOTVALID", ErrorCategory.SyntaxError, null));
});
if (template == null)
{
throw new ApplicationException("Invalid template file!");
}
var fileToRemove = template.Files.FirstOrDefault(f => f.Src == FilePath);
if (fileToRemove != null)
{
template.Files.Remove(fileToRemove);
template.Connector.DeleteFile(FilePath);
if (template.Connector is ICommitableFileConnector)
{
((ICommitableFileConnector)template.Connector).Commit();
}
// 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 ExecuteCmdlet()
{
if (!System.IO.Path.IsPathRooted(Path))
{
Path = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Path);
}
var template = ProvisioningHelper.LoadSiteTemplateFromFile(Path, TemplateProviderExtensions, (e) =>
{
WriteError(new ErrorRecord(e, "TEMPLATENOTVALID", ErrorCategory.SyntaxError, null));
});
if (template == null)
{
throw new ApplicationException("Invalid template file!");
}
// We will remove a list if it's found so we can get the list
List spList = List.GetListOrThrow(nameof(List), CurrentWeb,
l => l.RootFolder, l => l.HasUniqueRoleAssignments);
ListInstance listInstance = template.Lists.Find(l => l.Title == spList.Title);
if (listInstance == null)
{
throw new ApplicationException("List does not exist in the template file!");
}
ClientContext.Load(ClientContext.Web, w => w.Url, w => w.ServerRelativeUrl, w => w.Id);
ClientContext.Load(ClientContext.Site, s => s.Url, s => s.ServerRelativeUrl, s => s.Id);
CamlQuery query = new CamlQuery();
var viewFieldsStringBuilder = new StringBuilder();
if (Fields != null)
{
viewFieldsStringBuilder.Append("<ViewFields>");
foreach (var field in Fields)
{
viewFieldsStringBuilder.AppendFormat("<FieldRef Name='{0}'/>", field);
}
viewFieldsStringBuilder.Append("</ViewFields>");
}
query.ViewXml = string.Format("<View>{0}{1}</View>", Query, viewFieldsStringBuilder);
var listItems = spList.GetItems(query);
ClientContext.Load(listItems, lI => lI.Include(l => l.HasUniqueRoleAssignments, l => l.ContentType.StringId));
ClientContext.ExecuteQueryRetry();
Microsoft.SharePoint.Client.FieldCollection fieldCollection = spList.Fields;
ClientContext.Load(fieldCollection, fs => fs.Include(f => f.InternalName, f => f.FieldTypeKind, f => f.ReadOnlyField));
ClientContext.ExecuteQueryRetry();
var rows = new DataRowCollection(template);
foreach (var listItem in listItems)
{
// Make sure we don't pull Folders.. Of course this won't work
if (listItem.ServerObjectIsNull == false)
{
ClientContext.Load(listItem);
ClientContext.ExecuteQueryRetry();
if (!(listItem.FileSystemObjectType == FileSystemObjectType.Folder))
{
DataRow row = new DataRow();
if (IncludeSecurity && listItem.HasUniqueRoleAssignments)
{
row.Security.ClearSubscopes = true;
row.Security.CopyRoleAssignments = false;
var roleAssignments = listItem.RoleAssignments;
ClientContext.Load(roleAssignments);
ClientContext.ExecuteQueryRetry();
ClientContext.Load(roleAssignments, r => r.Include(a => a.Member.LoginName, a => a.Member, a => a.RoleDefinitionBindings));
ClientContext.ExecuteQueryRetry();
foreach (var roleAssignment in roleAssignments)
{
var principalName = roleAssignment.Member.LoginName;
var roleBindings = roleAssignment.RoleDefinitionBindings;
foreach (var roleBinding in roleBindings)
{
row.Security.RoleAssignments.Add(new PnP.Framework.Provisioning.Model.RoleAssignment()
{
Principal = principalName, RoleDefinition = roleBinding.Name
});
}
}
}
if (Fields != null)
{
foreach (var fieldName in Fields)
{
Microsoft.SharePoint.Client.Field dataField = fieldCollection.FirstOrDefault(f => f.InternalName == fieldName);
if (dataField != null)
{
var defaultFieldValue = GetFieldValueAsText(ClientContext.Web, listItem, dataField);
if (TokenizeUrls.IsPresent)
{
defaultFieldValue = Tokenize(defaultFieldValue, ClientContext.Web, ClientContext.Site);
}
row.Values.Add(fieldName, defaultFieldValue);
}
}
}
else
{
// All fields are added except readonly fields and unsupported field type
var fieldsToExport = fieldCollection.AsEnumerable()
.Where(f => !f.ReadOnlyField && !_unsupportedFieldTypes.Contains(f.FieldTypeKind));
foreach (var field in fieldsToExport)
{
var fldKey = (from f in listItem.FieldValues.Keys where f == field.InternalName select f).FirstOrDefault();
if (!string.IsNullOrEmpty(fldKey))
{
var fieldValue = GetFieldValueAsText(ClientContext.Web, listItem, field);
if (TokenizeUrls.IsPresent)
{
fieldValue = Tokenize(fieldValue, ClientContext.Web, ClientContext.Site);
}
row.Values.Add(field.InternalName, fieldValue);
}
}
}
rows.Add(row);
}
}
}
template.Lists.Remove(listInstance);
listInstance.DataRows.AddRange(rows);
template.Lists.Add(listInstance);
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(Path, 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 ExecuteCmdlet()
{
if (!System.IO.Path.IsPathRooted(Path))
{
Path = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Path);
}
// Load the template
var template = ProvisioningHelper.LoadSiteTemplateFromFile(Path, TemplateProviderExtensions, (e) =>
{
WriteError(new ErrorRecord(e, "TEMPLATENOTVALID", ErrorCategory.SyntaxError, null));
});
if (template == null)
{
throw new ApplicationException("Invalid template file.");
}
List spList = List.GetList(CurrentWeb);
ClientContext.Load(spList, l => l.RootFolder, l => l.HasUniqueRoleAssignments);
ClientContext.ExecuteQueryRetry();
//We will remove a list if it's found so we can get the list
ListInstance listInstance = template.Lists.Find(l => l.Title == spList.Title);
if (listInstance == null)
{
throw new ApplicationException("List does not exist in the template file.");
}
Microsoft.SharePoint.Client.Folder listFolder = spList.RootFolder;
ClientContext.Load(listFolder);
ClientContext.ExecuteQueryRetry();
IList <PnP.Framework.Provisioning.Model.Folder> folders = GetChildFolders(listFolder);
template.Lists.Remove(listInstance);
listInstance.Folders.AddRange(folders);
template.Lists.Add(listInstance);
// 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(Path, 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()
{
if (!System.IO.Path.IsPathRooted(Path))
{
Path = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Path);
}
// Load the template
var template = ProvisioningHelper.LoadSiteTemplateFromFile(Path, TemplateProviderExtensions, (e) =>
{
WriteError(new ErrorRecord(e, "TEMPLATENOTVALID", ErrorCategory.SyntaxError, null));
});
if (template == null)
{
throw new ApplicationException("Invalid template file!");
}
if (this.ParameterSetName == parameterSet_REMOTEFILE)
{
CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
var sourceUri = new Uri(SourceUrl, UriKind.RelativeOrAbsolute);
var serverRelativeUrl =
sourceUri.IsAbsoluteUri ? sourceUri.AbsolutePath :
SourceUrl.StartsWith("/", StringComparison.Ordinal) ? SourceUrl :
CurrentWeb.ServerRelativeUrl.TrimEnd('/') + "/" + SourceUrl;
var file = CurrentWeb.GetFileByServerRelativeUrl(serverRelativeUrl);
var fileName = file.EnsureProperty(f => f.Name);
var folderRelativeUrl = serverRelativeUrl.Substring(0, serverRelativeUrl.Length - fileName.Length - 1);
var folderWebRelativeUrl = System.Net.WebUtility.UrlDecode(folderRelativeUrl.Substring(CurrentWeb.ServerRelativeUrl.TrimEnd('/').Length + 1));
if (ClientContext.HasPendingRequest)
{
ClientContext.ExecuteQueryRetry();
}
try
{
var fi = CurrentWeb.GetFileByServerRelativeUrl(serverRelativeUrl);
var fileStream = fi.OpenBinaryStream();
ClientContext.ExecuteQueryRetry();
using (var ms = fileStream.Value)
{
AddFileToTemplate(template, ms, folderWebRelativeUrl, fileName, folderWebRelativeUrl);
}
}
catch (WebException exc)
{
WriteWarning($"Can't add file from url {serverRelativeUrl} : {exc}");
}
}
else
{
if (!System.IO.Path.IsPathRooted(Source))
{
Source = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Source);
}
// Load the file and add it to the .PNP file
using (var fs = System.IO.File.OpenRead(Source))
{
Folder = Folder.Replace("\\", "/");
var fileName = Source.IndexOf("\\", StringComparison.Ordinal) > 0 ? Source.Substring(Source.LastIndexOf("\\") + 1) : Source;
var container = !string.IsNullOrEmpty(Container) ? Container : string.Empty;
AddFileToTemplate(template, fs, Folder, fileName, container);
}
}
}
protected override void ExecuteCmdlet()
{
WriteWarning("This cmdlet is work in progress, the markdown report will improve/grow with later releases.");
if (!Path.IsPathRooted(TemplatePath))
{
TemplatePath = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, TemplatePath);
}
if (!File.Exists(TemplatePath))
{
throw new PSArgumentException("File does not exist", nameof(TemplatePath));
}
if (ShouldProcess($"Converts a PnP Site Template to markdown format"))
{
var process = false;
var template = ProvisioningHelper.LoadSiteTemplateFromFile(TemplatePath, null, (exception) =>
{
throw new PSInvalidOperationException("Invalid template", exception);
});
ITemplateFormatter mdFormatter = new MarkdownPnPFormatter();
if (ParameterSpecified(nameof(Out)))
{
if (!Path.IsPathRooted(Out))
{
Out = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, Out);
}
if (File.Exists(Out))
{
if (Force || ShouldContinue(string.Format(Resources.File0ExistsOverwrite, Out), Resources.Confirm))
{
process = true;
}
}
else
{
process = true;
}
if (process)
{
using (var outputStream = mdFormatter.ToFormattedTemplate(template))
{
using (var fileStream = File.Create(Out))
{
outputStream.Seek(0, SeekOrigin.Begin);
outputStream.CopyTo(fileStream);
fileStream.Close();
}
}
}
}
else
{
using (var outputStream = mdFormatter.ToFormattedTemplate(template))
{
using (var reader = new StreamReader(outputStream))
{
WriteObject(reader.ReadToEnd());
}
}
}
}
}
