public static TokenParser ProcessApps(Tenant tenant, ProvisioningTenant provisioningTenant, FileConnectorBase connector, TokenParser parser, PnPMonitoredScope scope, ProvisioningTemplateApplyingInformation applyingInformation, ProvisioningMessagesDelegate messagesDelegate)
{
if (provisioningTenant.AppCatalog != null && provisioningTenant.AppCatalog.Packages.Count > 0)
{
var rootSiteUrl = tenant.GetRootSiteUrl();
tenant.Context.ExecuteQueryRetry();
using (var context = ((ClientContext)tenant.Context).Clone(rootSiteUrl.Value, applyingInformation.AccessTokens))
{
var web = context.Web;
Uri appCatalogUri = null;
try
{
appCatalogUri = web.GetAppCatalog();
}
catch (System.Net.WebException ex)
{
if (ex.Response != null)
{
var httpResponse = ex.Response as System.Net.HttpWebResponse;
if (httpResponse != null && httpResponse.StatusCode == HttpStatusCode.Unauthorized)
{
// Ignore any security exception and simply keep
// the AppCatalog URI null
}
else
{
throw ex;
}
}
else
{
throw ex;
}
}
if (appCatalogUri != null)
{
var manager = new AppManager(context);
foreach (var app in provisioningTenant.AppCatalog.Packages)
{
AppMetadata appMetadata = null;
if (app.Action == PackageAction.Upload || app.Action == PackageAction.UploadAndPublish)
{
var appSrc = parser.ParseString(app.Src);
var appBytes = ConnectorFileHelper.GetFileBytes(connector, appSrc);
var hash = string.Empty;
using (var memoryStream = new MemoryStream(appBytes))
{
hash = CalculateHash(memoryStream);
}
var exists = false;
var appId = Guid.Empty;
using (var appCatalogContext = ((ClientContext)tenant.Context).Clone(appCatalogUri, applyingInformation.AccessTokens))
{
// check if the app already is present
var appList = appCatalogContext.Web.GetListByUrl("AppCatalog");
var camlQuery = new CamlQuery
{
ViewXml = string.Format(appExistsQuery, hash)
};
var items = appList.GetItems(camlQuery);
appCatalogContext.Load(items, i => i.IncludeWithDefaultProperties());
appCatalogContext.ExecuteQueryRetry();
if (items.Count > 0)
{
exists = true;
appId = Guid.Parse(items[0].FieldValues["UniqueId"].ToString());
}
}
var appFilename = appSrc.Substring(appSrc.LastIndexOf('\\') + 1);
if (!exists)
{
messagesDelegate?.Invoke($"Processing solution {app.Src}", ProvisioningMessageType.Progress);
appMetadata = manager.Add(appBytes, appFilename, app.Overwrite, timeoutSeconds: 300);
}
else
{
messagesDelegate?.Invoke($"Skipping existing solution {app.Src}", ProvisioningMessageType.Progress);
appMetadata = manager.GetAvailable().FirstOrDefault(a => a.Id == appId);
}
parser.AddToken(new AppPackageIdToken(web, appFilename, appMetadata.Id));
parser.AddToken(new AppPackageIdToken(web, appMetadata.Title, appMetadata.Id));
}
if (app.Action == PackageAction.Publish || app.Action == PackageAction.UploadAndPublish)
{
if (appMetadata == null)
{
appMetadata = manager.GetAvailable()
.FirstOrDefault(a => a.Id == Guid.Parse(parser.ParseString(app.PackageId)));
}
if (appMetadata != null)
{
if (appMetadata.Deployed == false)
{
manager.Deploy(appMetadata, app.SkipFeatureDeployment);
}
}
else
{
scope.LogError("Referenced App Package {0} not available", app.PackageId);
throw new Exception($"Referenced App Package {app.PackageId} not available");
}
}
if (app.Action == PackageAction.Remove)
{
var appId = Guid.Parse(parser.ParseString(app.PackageId));
// Get the apps already installed in the site
var appExists = manager.GetAvailable()?.Any(a => a.Id == appId);
if (appExists.HasValue && appExists.Value)
{
manager.Remove(appId);
}
else
{
messagesDelegate?.Invoke($"App Package with ID {appId} does not exist in the AppCatalog and cannot be removed!", ProvisioningMessageType.Warning);
}
}
}
}
else
{
messagesDelegate?.Invoke($"Tenant app catalog doesn't exist. ALM step will be skipped!", ProvisioningMessageType.Warning);
}
}
}
return(parser);
}
internal static List <ReusedTerm> ProcessGroup(ClientContext context, TaxonomySession session, TermStore termStore, Model.TermGroup modelTermGroup, TermGroup siteCollectionTermGroup, TokenParser parser, PnPMonitoredScope scope)
{
List <ReusedTerm> reusedTerms = new List <ReusedTerm>();
SiteCollectionTermGroupNameToken siteCollectionTermGroupNameToken =
new SiteCollectionTermGroupNameToken(context.Web);
#region Group
var newGroup = false;
var modelGroupName = parser.ParseString(modelTermGroup.Name);
var normalizedGroupName = TaxonomyItem.NormalizeName(context, modelGroupName);
context.ExecuteQueryRetry();
TermGroup group = termStore.Groups.FirstOrDefault(
g => g.Id == modelTermGroup.Id || g.Name == normalizedGroupName.Value);
if (group == null)
{
var parsedDescription = parser.ParseString(modelTermGroup.Description);
if (modelTermGroup.Name == "Site Collection" ||
modelGroupName == siteCollectionTermGroupNameToken.GetReplaceValue() ||
modelTermGroup.SiteCollectionTermGroup)
{
var site = (context as ClientContext).Site;
group = termStore.GetSiteCollectionGroup(site, true);
context.Load(group, g => g.Name, g => g.Id, g => g.TermSets.Include(
tset => tset.Name,
tset => tset.Id));
context.ExecuteQueryRetry();
}
else
{
group = termStore.Groups.FirstOrDefault(g => g.Name == normalizedGroupName.Value);
if (group == null)
{
if (modelTermGroup.Id == Guid.Empty)
{
modelTermGroup.Id = Guid.NewGuid();
}
group = termStore.CreateGroup(modelGroupName, modelTermGroup.Id);
group.Description = parsedDescription;
// Handle TermGroup Contributors, if any
if (modelTermGroup.Contributors != null && modelTermGroup.Contributors.Count > 0)
{
foreach (var c in modelTermGroup.Contributors)
{
group.AddContributor(c.Name);
}
}
// Handle TermGroup Managers, if any
if (modelTermGroup.Managers != null && modelTermGroup.Managers.Count > 0)
{
foreach (var m in modelTermGroup.Managers)
{
group.AddGroupManager(m.Name);
}
}
termStore.CommitAll();
context.Load(group);
context.Load(termStore);
context.ExecuteQueryRetry();
newGroup = true;
}
}
}
#endregion
session.UpdateCache();
session.Context.ExecuteQueryRetry();
#region TermSets
foreach (var modelTermSet in modelTermGroup.TermSets)
{
TermSet set = null;
var newTermSet = false;
var normalizedTermSetName = TaxonomyItem.NormalizeName(context, parser.ParseString(modelTermSet.Name));
context.ExecuteQueryRetry();
if (!newGroup)
{
set =
group.TermSets.FirstOrDefault(
ts => ts.Id == modelTermSet.Id || ts.Name == normalizedTermSetName.Value);
}
if (set == null)
{
if (modelTermSet.Id == Guid.Empty)
{
modelTermSet.Id = Guid.NewGuid();
}
else
{
if (CheckIfTermSetIdIsUnique(termStore, modelTermSet.Id) == false)
{
throw new Exception($"Termset ID {modelTermSet.Id} is already present in termstore");
}
}
var termSetLanguage = modelTermSet.Language.HasValue ? modelTermSet.Language.Value : termStore.DefaultLanguage;
set = group.CreateTermSet(normalizedTermSetName.Value, modelTermSet.Id, termSetLanguage);
parser.AddToken(new TermSetIdToken(context.Web, group.Name, normalizedTermSetName.Value, modelTermSet.Id));
if (siteCollectionTermGroup != null && !siteCollectionTermGroup.ServerObjectIsNull.Value)
{
if (group.Name == siteCollectionTermGroup.Name)
{
parser.AddToken((new SiteCollectionTermSetIdToken(context.Web, normalizedTermSetName.Value, modelTermSet.Id)));
}
}
newTermSet = true;
if (!string.IsNullOrEmpty(modelTermSet.Description))
{
set.Description = parser.ParseString(modelTermSet.Description);
}
set.IsOpenForTermCreation = modelTermSet.IsOpenForTermCreation;
set.IsAvailableForTagging = modelTermSet.IsAvailableForTagging;
foreach (var property in modelTermSet.Properties)
{
set.SetCustomProperty(property.Key, parser.ParseString(property.Value));
}
if (modelTermSet.Owner != null)
{
set.Owner = parser.ParseString(modelTermSet.Owner);
}
termStore.CommitAll();
context.Load(set);
context.ExecuteQueryRetry();
}
context.Load(set, s => s.Terms.Include(t => t.Id, t => t.Name));
context.ExecuteQueryRetry();
var terms = set.Terms;
foreach (var modelTerm in modelTermSet.Terms)
{
if (!newTermSet)
{
if (terms.Any())
{
var term = terms.FirstOrDefault(t => t.Id == modelTerm.Id);
if (term == null)
{
var normalizedTermName = TaxonomyItem.NormalizeName(context, modelTerm.Name);
context.ExecuteQueryRetry();
term = terms.FirstOrDefault(t => t.Name == normalizedTermName.Value);
if (term == null)
{
var returnTuple = CreateTerm <TermSet>(context, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
reusedTerms.AddRange(returnTuple.Item3);
}
else
{
// todo: add handling for reused term?
modelTerm.Id = term.Id;
}
}
else
{
// todo: add handling for reused term?
modelTerm.Id = term.Id;
}
if (term != null)
{
CheckChildTerms(context, modelTerm, term, termStore, parser, scope);
}
}
else
{
var returnTuple = CreateTerm <TermSet>(context, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
reusedTerms.AddRange(returnTuple.Item3);
}
}
else
{
var returnTuple = CreateTerm <TermSet>(context, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
reusedTerms.AddRange(returnTuple.Item3);
}
}
// do we need custom sorting?
if (modelTermSet.Terms.Any(t => t.CustomSortOrder > 0))
{
var sortedTerms = modelTermSet.Terms.OrderBy(t => t.CustomSortOrder);
var customSortString = sortedTerms.Aggregate(string.Empty,
(a, i) => a + i.Id.ToString() + ":");
customSortString = customSortString.TrimEnd(new[] { ':' });
set.CustomSortOrder = customSortString;
termStore.CommitAll();
context.ExecuteQueryRetry();
}
}
#endregion
return(reusedTerms);
}
public static TokenParser ProcessSiteDesigns(Tenant tenant, ProvisioningTenant provisioningTenant, TokenParser parser, PnPMonitoredScope scope, ProvisioningMessagesDelegate messagesDelegate)
{
if (provisioningTenant.SiteDesigns != null && provisioningTenant.SiteDesigns.Any())
{
var existingDesigns = tenant.GetSiteDesigns();
tenant.Context.Load(existingDesigns);
tenant.Context.ExecuteQueryRetry();
foreach (var siteDesign in provisioningTenant.SiteDesigns)
{
var parsedTitle = parser.ParseString(siteDesign.Title);
var parsedDescription = parser.ParseString(siteDesign.Description);
var parsedPreviewImageUrl = parser.ParseString(siteDesign.PreviewImageUrl);
var parsedPreviewImageAltText = parser.ParseString(siteDesign.PreviewImageAltText);
messagesDelegate?.Invoke($"Processing site design {parsedTitle}", ProvisioningMessageType.Progress);
var existingSiteDesign = existingDesigns.FirstOrDefault(d => d.Title == parsedTitle);
if (existingSiteDesign == null)
{
TenantSiteDesignCreationInfo siteDesignCreationInfo = new TenantSiteDesignCreationInfo()
{
Title = parsedTitle,
Description = parsedDescription,
PreviewImageUrl = parsedPreviewImageUrl,
PreviewImageAltText = parsedPreviewImageAltText,
IsDefault = siteDesign.IsDefault,
};
switch ((int)siteDesign.WebTemplate)
{
case 0:
{
siteDesignCreationInfo.WebTemplate = "64";
break;
}
case 1:
{
siteDesignCreationInfo.WebTemplate = "68";
break;
}
}
if (siteDesign.SiteScripts != null && siteDesign.SiteScripts.Any())
{
List <Guid> ids = new List <Guid>();
foreach (var siteScriptRef in siteDesign.SiteScripts)
{
ids.Add(Guid.Parse(parser.ParseString(siteScriptRef)));
}
siteDesignCreationInfo.SiteScriptIds = ids.ToArray();
}
var design = tenant.CreateSiteDesign(siteDesignCreationInfo);
tenant.Context.Load(design);
tenant.Context.ExecuteQueryRetry();
if (siteDesign.Grants != null && siteDesign.Grants.Any())
{
foreach (var grant in siteDesign.Grants)
{
var rights = (TenantSiteDesignPrincipalRights)Enum.Parse(typeof(TenantSiteDesignPrincipalRights), grant.Right.ToString());
tenant.GrantSiteDesignRights(design.Id, new[] { grant.Principal }, rights);
}
tenant.Context.ExecuteQueryRetry();
}
parser.AddToken(new SiteDesignIdToken(null, design.Title, design.Id));
}
else
{
if (siteDesign.Overwrite)
{
var existingId = existingSiteDesign.Id;
existingSiteDesign = Tenant.GetSiteDesign(tenant.Context, existingId);
tenant.Context.ExecuteQueryRetry();
existingSiteDesign.Title = parsedTitle;
existingSiteDesign.Description = parsedDescription;
existingSiteDesign.PreviewImageUrl = parsedPreviewImageUrl;
existingSiteDesign.PreviewImageAltText = parsedPreviewImageAltText;
existingSiteDesign.IsDefault = siteDesign.IsDefault;
switch ((int)siteDesign.WebTemplate)
{
case 0:
{
existingSiteDesign.WebTemplate = "64";
break;
}
case 1:
{
existingSiteDesign.WebTemplate = "68";
break;
}
}
tenant.UpdateSiteDesign(existingSiteDesign);
tenant.Context.ExecuteQueryRetry();
var existingToken = parser.Tokens.OfType <SiteDesignIdToken>().FirstOrDefault(t => t.GetReplaceValue() == existingId.ToString());
if (existingToken != null)
{
parser.Tokens.Remove(existingToken);
}
parser.AddToken(new SiteScriptIdToken(null, parsedTitle, existingId));
if (siteDesign.Grants != null && siteDesign.Grants.Any())
{
var existingRights = Tenant.GetSiteDesignRights(tenant.Context, existingId);
tenant.Context.Load(existingRights);
tenant.Context.ExecuteQueryRetry();
foreach (var existingRight in existingRights)
{
Tenant.RevokeSiteDesignRights(tenant.Context, existingId, new[] { existingRight.PrincipalName });
}
foreach (var grant in siteDesign.Grants)
{
var rights = (TenantSiteDesignPrincipalRights)Enum.Parse(typeof(TenantSiteDesignPrincipalRights), grant.Right.ToString());
tenant.GrantSiteDesignRights(existingId, new[] { parser.ParseString(grant.Principal) }, rights);
}
tenant.Context.ExecuteQueryRetry();
}
}
}
}
}
return(parser);
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
// Check if this is not a noscript site as we're not allowed to write to the web property bag is that one
bool isNoScriptSite = web.IsNoScriptSite();
web.EnsureProperties(w => w.ServerRelativeUrl, w => w.Url);
// Build on the fly the list of additional files coming from the Directories
var directoryFiles = new List <Model.File>();
foreach (var directory in template.Directories)
{
var metadataProperties = directory.GetMetadataProperties();
directoryFiles.AddRange(directory.GetDirectoryFiles(metadataProperties));
}
var filesToProcess = template.Files.Union(directoryFiles).ToArray();
var siteAssetsFiles = filesToProcess.Where(f => f.Folder.ToLower().Contains("siteassets")).FirstOrDefault();
if (siteAssetsFiles != null)
{
// Need this so that we dont have access denied error during the first time upload, especially for modern sites
web.Lists.EnsureSiteAssetsLibrary();
web.Context.ExecuteQueryRetry();
}
var currentFileIndex = 0;
var originalWeb = web; // Used to store and re-store context in case files are deployed to masterpage gallery
foreach (var file in filesToProcess)
{
file.Src = parser.ParseString(file.Src);
var targetFileName = parser.ParseString(
!String.IsNullOrEmpty(file.TargetFileName) ? file.TargetFileName : template.Connector.GetFilenamePart(file.Src)
);
currentFileIndex++;
WriteSubProgress("File", targetFileName, currentFileIndex, filesToProcess.Length);
var folderName = parser.ParseString(file.Folder);
if (folderName.ToLower().Contains("/_catalogs/"))
{
// Edge case where you have files in the template which should be provisioned to the site collection
// master page gallery and not to a connected subsite
web = web.Context.GetSiteCollectionContext().Web;
web.EnsureProperties(w => w.ServerRelativeUrl, w => w.Url);
}
if (folderName.ToLower().StartsWith((web.ServerRelativeUrl.ToLower())))
{
folderName = folderName.Substring(web.ServerRelativeUrl.Length);
}
if (SkipFile(isNoScriptSite, targetFileName, folderName))
{
// add log message
scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_Files_SkipFileUpload, targetFileName, folderName);
continue;
}
var folder = web.EnsureFolderPath(folderName);
folder.EnsureProperties(p => p.UniqueId, p => p.ServerRelativeUrl);
parser.AddToken(new FileUniqueIdToken(web, folder.ServerRelativeUrl.Substring(web.ServerRelativeUrl.Length).TrimStart("/".ToCharArray()), folder.UniqueId));
parser.AddToken(new FileUniqueIdEncodedToken(web, folder.ServerRelativeUrl.Substring(web.ServerRelativeUrl.Length).TrimStart("/".ToCharArray()), folder.UniqueId));
var checkedOut = false;
var targetFile = folder.GetFile(template.Connector.GetFilenamePart(targetFileName));
if (targetFile != null)
{
if (file.Overwrite)
{
scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Files_Uploading_and_overwriting_existing_file__0_, targetFileName);
checkedOut = CheckOutIfNeeded(web, targetFile);
using (var stream = FileUtilities.GetFileStream(template, file))
{
targetFile = UploadFile(folder, stream, targetFileName, file.Overwrite);
}
}
else
{
checkedOut = CheckOutIfNeeded(web, targetFile);
}
}
else
{
using (var stream = FileUtilities.GetFileStream(template, file))
{
if (stream == null)
{
throw new FileNotFoundException($"File {file.Src} does not exist");
}
else
{
scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Files_Uploading_file__0_, targetFileName);
targetFile = UploadFile(folder, stream, targetFileName, file.Overwrite);
}
}
checkedOut = CheckOutIfNeeded(web, targetFile);
}
if (targetFile != null)
{
// Add the fileuniqueid tokens
targetFile.EnsureProperties(p => p.UniqueId, p => p.ServerRelativePath);
parser.AddToken(new FileUniqueIdToken(web, targetFile.ServerRelativePath.DecodedUrl.Substring(web.ServerRelativeUrl.Length).TrimStart("/".ToCharArray()), targetFile.UniqueId));
parser.AddToken(new FileUniqueIdEncodedToken(web, targetFile.ServerRelativePath.DecodedUrl.Substring(web.ServerRelativeUrl.Length).TrimStart("/".ToCharArray()), targetFile.UniqueId));
bool webPartsNeedLocalization = false;
if (file.WebParts != null && file.WebParts.Any())
{
targetFile.EnsureProperties(f => f.ServerRelativePath);
var existingWebParts = web.GetWebParts(targetFile.ServerRelativePath.DecodedUrl).ToList();
foreach (var webPart in file.WebParts)
{
// check if the webpart is already set on the page
if (existingWebParts.FirstOrDefault(w => w.WebPart.Title == parser.ParseString(webPart.Title)) == null)
{
scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Files_Adding_webpart___0___to_page, webPart.Title);
var wpEntity = new WebPartEntity
{
WebPartTitle = parser.ParseString(webPart.Title),
WebPartXml = parser.ParseXmlString(webPart.Contents).Trim(new[] { '\n', ' ' }),
WebPartZone = webPart.Zone,
WebPartIndex = (int)webPart.Order
};
var wpd = web.AddWebPartToWebPartPage(targetFile.ServerRelativePath.DecodedUrl, wpEntity);
if (webPart.Title.ContainsResourceToken())
{
// update data based on where it was added - needed in order to localize wp title
wpd.EnsureProperties(w => w.ZoneId, w => w.WebPart, w => w.WebPart.Properties);
webPart.Zone = wpd.ZoneId;
webPart.Order = (uint)wpd.WebPart.ZoneIndex;
webPartsNeedLocalization = true;
}
}
}
}
if (webPartsNeedLocalization)
{
file.LocalizeWebParts(web, parser, targetFile, scope);
}
//Set Properties before Checkin
if (file.Properties != null && file.Properties.Any())
{
Dictionary <string, string> transformedProperties = file.Properties.ToDictionary(property => property.Key, property => parser.ParseString(property.Value));
SetFileProperties(targetFile, transformedProperties, parser, false);
}
switch (file.Level)
{
case Model.FileLevel.Published:
{
targetFile.PublishFileToLevel(Microsoft.SharePoint.Client.FileLevel.Published);
break;
}
case Model.FileLevel.Draft:
{
targetFile.PublishFileToLevel(Microsoft.SharePoint.Client.FileLevel.Draft);
break;
}
default:
{
if (checkedOut)
{
targetFile.CheckIn("", CheckinType.MajorCheckIn);
web.Context.ExecuteQueryRetry();
}
break;
}
}
// Don't set security when nothing is defined. This otherwise breaks on files set outside of a list
if (file.Security != null &&
(file.Security.ClearSubscopes == true || file.Security.CopyRoleAssignments == true || file.Security.RoleAssignments.Count > 0))
{
targetFile.ListItemAllFields.SetSecurity(parser, file.Security, WriteMessage);
}
}
web = originalWeb; // restore context in case files are provisioned to the master page gallery #1059
}
}
WriteMessage("Done processing files", ProvisioningMessageType.Completed);
return(parser);
}
public void ParseTests()
{
using (var ctx = TestCommon.CreateClientContext())
{
ctx.Load(ctx.Web,
w => w.Id,
w => w.ServerRelativeUrl,
w => w.Title,
w => w.AssociatedOwnerGroup.Title,
w => w.AssociatedMemberGroup.Title,
w => w.AssociatedVisitorGroup.Title,
w => w.AssociatedOwnerGroup.Id,
w => w.AssociatedMemberGroup.Id,
w => w.AssociatedVisitorGroup.Id);
ctx.Load(ctx.Site, s => s.ServerRelativeUrl, s => s.Owner);
var masterCatalog = ctx.Web.GetCatalog((int)ListTemplateType.MasterPageCatalog);
ctx.Load(masterCatalog, m => m.RootFolder.ServerRelativeUrl);
var themesCatalog = ctx.Web.GetCatalog((int)ListTemplateType.ThemeCatalog);
ctx.Load(themesCatalog, t => t.RootFolder.ServerRelativeUrl);
var expectedRoleDefinitionId = 1073741826;
var roleDefinition = ctx.Web.RoleDefinitions.GetById(expectedRoleDefinitionId);
ctx.Load(roleDefinition);
ctx.ExecuteQueryRetry();
var currentUser = ctx.Web.EnsureProperty(w => w.CurrentUser);
var ownerGroupName = ctx.Web.AssociatedOwnerGroup.Title;
ProvisioningTemplate template = new ProvisioningTemplate();
template.Parameters.Add("test", "test");
var parser = new TokenParser(ctx.Web, template);
parser.AddToken(new FieldIdToken(ctx.Web, "DemoField", new Guid("7E5E53E4-86C2-4A64-9F2E-FDFECE6219E0")));
var siteName = parser.ParseString("{sitename}");
var siteId = parser.ParseString("{siteid}");
var site = parser.ParseString("{site}/test");
var sitecol = parser.ParseString("{sitecollection}/test");
var masterUrl = parser.ParseString("{masterpagecatalog}/test");
var themeUrl = parser.ParseString("{themecatalog}/test");
var parameterTest = parser.ParseString("abc{parameter:TEST}/test");
var associatedOwnerGroup = parser.ParseString("{associatedownergroup}");
var associatedVisitorGroup = parser.ParseString("{associatedvisitorgroup}");
var associatedMemberGroup = parser.ParseString("{associatedmembergroup}");
var currentUserId = parser.ParseString("{currentuserid}");
var currentUserLoginName = parser.ParseString("{currentuserloginname}");
var currentUserFullName = parser.ParseString("{currentuserfullname}");
var guid = parser.ParseString("{guid}");
var associatedOwnerGroupId = parser.ParseString("{groupid:associatedownergroup}");
var associatedMemberGroupId = parser.ParseString("{groupid:associatedmembergroup}");
var associatedVisitorGroupId = parser.ParseString("{groupid:associatedvisitorgroup}");
var groupId = parser.ParseString($"{{groupid:{ownerGroupName}}}");
var siteOwner = parser.ParseString("{siteowner}");
var roleDefinitionId = parser.ParseString($"{{roledefinitionid:{roleDefinition.Name}}}");
var xamlEscapeString = "{}{0}Id";
var parsedXamlEscapeString = parser.ParseString(xamlEscapeString);
const string fieldRef = @"<FieldRefs><FieldRef Name=""DemoField"" ID=""{7E5E53E4-86C2-4A64-9F2E-FDFECE6219E0}"" /></FieldRefs></Field>";
var parsedFieldRef = parser.ParseString(@"<FieldRefs><FieldRef Name=""DemoField"" ID=""{{fieldid:DemoField}}"" /></FieldRefs></Field>");
Assert.IsTrue(site == $"{ctx.Web.ServerRelativeUrl}/test");
Assert.IsTrue(sitecol == $"{ctx.Site.ServerRelativeUrl}/test");
Assert.IsTrue(masterUrl == $"{masterCatalog.RootFolder.ServerRelativeUrl}/test");
Assert.IsTrue(themeUrl == $"{themesCatalog.RootFolder.ServerRelativeUrl}/test");
Assert.IsTrue(parameterTest == "abctest/test");
Assert.IsTrue(associatedOwnerGroup == ctx.Web.AssociatedOwnerGroup.Title);
Assert.IsTrue(associatedVisitorGroup == ctx.Web.AssociatedVisitorGroup.Title);
Assert.IsTrue(associatedMemberGroup == ctx.Web.AssociatedMemberGroup.Title);
Assert.IsTrue(siteName == ctx.Web.Title);
Assert.IsTrue(siteId == ctx.Web.Id.ToString());
Assert.IsTrue(currentUserId == currentUser.Id.ToString());
Assert.IsTrue(currentUserFullName == currentUser.Title);
Assert.IsTrue(currentUserLoginName.Equals(currentUser.LoginName, StringComparison.OrdinalIgnoreCase));
Guid outGuid;
Assert.IsTrue(Guid.TryParse(guid, out outGuid));
Assert.IsTrue(int.Parse(associatedOwnerGroupId) == ctx.Web.AssociatedOwnerGroup.Id);
Assert.IsTrue(int.Parse(associatedMemberGroupId) == ctx.Web.AssociatedMemberGroup.Id);
Assert.IsTrue(int.Parse(associatedVisitorGroupId) == ctx.Web.AssociatedVisitorGroup.Id);
Assert.IsTrue(associatedOwnerGroupId == groupId);
Assert.IsTrue(siteOwner == ctx.Site.Owner.LoginName);
Assert.IsTrue(roleDefinitionId == expectedRoleDefinitionId.ToString(), $"Role Definition Id was not parsed correctly (expected:{expectedRoleDefinitionId};returned:{roleDefinitionId})");
Assert.IsTrue(parsedXamlEscapeString == xamlEscapeString);
Assert.IsTrue(parsedFieldRef.ToUpperInvariant() == fieldRef.ToUpperInvariant());
}
}
public void RegexSpecialCharactersTests()
{
using (var ctx = TestCommon.CreateClientContext())
{
ctx.Load(ctx.Web, w => w.Id, w => w.ServerRelativeUrl, w => w.Title, w => w.AssociatedOwnerGroup.Title, w => w.AssociatedMemberGroup.Title, w => w.AssociatedVisitorGroup.Title);
ctx.Load(ctx.Site, s => s.ServerRelativeUrl);
ctx.ExecuteQueryRetry();
var currentUser = ctx.Web.EnsureProperty(w => w.CurrentUser);
ProvisioningTemplate template = new ProvisioningTemplate();
template.Parameters.Add("test(T)", "test");
template.Parameters.Add("a{b", "test");
var parser = new TokenParser(ctx.Web, template);
var web = ctx.Web;
var contentTypeName = "Test CT (TC) [TC].$";
var contentTypeId = "0x010801006439AECCDEAE4db2A422A3A04C79CC83";
var listGuid = Guid.NewGuid();
var listTitle = @"List (\,*+?|{[()^$.#";
var listUrl = "Lists/TestList";
var webPartTitle = @"Webpart (\*+?|{[()^$.#";
var webPartId = Guid.NewGuid();
var termSetName = @"Test TermSet (\*+?{[()^$.#";
var termGroupName = @"Group Name (\*+?{[()^$.#";
var termStoreName = @"Test TermStore (\*+?{[()^$.#";
var termSetId = Guid.NewGuid();
var termStoreId = Guid.NewGuid();
var resolvedTermGroupName = parser.ParseString("{sitecollectiontermgroupname}");
// Use fake data
parser.AddToken(new ContentTypeIdToken(web, contentTypeName, contentTypeId));
parser.AddToken(new ListIdToken(web, listTitle, listGuid));
parser.AddToken(new ListUrlToken(web, listTitle, listUrl));
parser.AddToken(new WebPartIdToken(web, webPartTitle, webPartId));
parser.AddToken(new TermSetIdToken(web, termGroupName, termSetName, termSetId));
parser.AddToken(new TermSetIdToken(web, resolvedTermGroupName, termSetName, termSetId));
parser.AddToken(new TermStoreIdToken(web, termStoreName, termStoreId));
var resolvedContentTypeId = parser.ParseString($"{{contenttypeid:{contentTypeName}}}");
var resolvedListId = parser.ParseString($"{{listid:{listTitle}}}");
var resolvedListUrl = parser.ParseString($"{{listurl:{listTitle}}}");
var parameterExpectedResult = $"abc{"test"}/test";
var parameterTest1 = parser.ParseString("abc{parameter:TEST(T)}/test");
var parameterTest2 = parser.ParseString("abc{parameter:a{b}/test");
var resolvedWebpartId = parser.ParseString($"{{webpartid:{webPartTitle}}}");
var resolvedTermSetId = parser.ParseString($"{{termsetid:{termGroupName}:{termSetName}}}");
var resolvedTermSetId2 = parser.ParseString($"{{termsetid:{{sitecollectiontermgroupname}}:{termSetName}}}");
var resolvedTermStoreId = parser.ParseString($"{{termstoreid:{termStoreName}}}");
Assert.IsTrue(contentTypeId == resolvedContentTypeId);
Assert.IsTrue(listUrl == resolvedListUrl);
Guid outGuid;
Assert.IsTrue(Guid.TryParse(resolvedListId, out outGuid));
Assert.IsTrue(parameterTest1 == parameterExpectedResult);
Assert.IsTrue(parameterTest2 == parameterExpectedResult);
Assert.IsTrue(Guid.TryParse(resolvedWebpartId, out outGuid));
Assert.IsTrue(Guid.TryParse(resolvedTermSetId, out outGuid));
Assert.IsTrue(Guid.TryParse(resolvedTermSetId2, out outGuid));
Assert.IsTrue(Guid.TryParse(resolvedTermStoreId, out outGuid));
}
}
private static void Execute(String siteUrl, ClientContext clientContext, Mode mode)
{
var lastTimeRun = DateTime.MinValue;
if (mode == Mode.debug || mode == Mode.activateIncremental)
{
lastTimeRun = GetLastRun();
}
clientContext.Load(clientContext.Web);
clientContext.ExecuteQueryRetry();
var doc = XDocument.Load("settings.xml");
if (!doc.Root.HasAttributes || !doc.Root.FirstAttribute.IsNamespaceDeclaration)
{
Console.WriteLine("PNP namespace missing from the root element.");
return;
}
_NameSpace = (XNamespace)doc.Root.FirstAttribute.Value;
_Branding = doc.Element("branding");
//Create token parser and add custom tokens
_TokenParser = new TokenParser(clientContext.Web, new ProvisioningTemplate());
_TokenParser.AddToken(new SiteCollectionUrlToken(clientContext.Web));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "Main Search"));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "Local People Results", new Guid("b09a7990-05ea-4af9-81ef-edfab16c4e31")));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "SPFarmId"));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "SPSiteId"));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "SPSiteSubscriptionId"));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "SPWebId"));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "DatabaseId"));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "Local SharePoint", new Guid("fa947043-6046-4f97-9714-40d4c113963d")));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "OpenSearch", new Guid("3a17e140-1574-4093-bad6-e19cdf1c0121")));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "People Search Results", new Guid("e4bcc058-f133-4425-8ffc-1d70596ffd33")));
_TokenParser.AddToken(new CustomGuidTokenDefinition(clientContext.Web, "Blank", new Guid("00000000-0000-0000-0000-000000000000")));
foreach (var template in Enum.GetValues(typeof(ListTemplateType)).Cast <ListTemplateType>())
{
_TokenParser.AddToken(new ListTypeTokenDefinition(clientContext.Web, template.ToString(), (int)template));
}
switch (mode)
{
case Mode.export:
ExportSearch(clientContext);
break;
case Mode.activate:
case Mode.activateIncremental:
case Mode.debug:
// create managed metadata here
// string termGroupName = GetConfigurationValue("termGroupName");
// TermSets.CreateTermSets( _TokenParser, _Branding, clientContext, termGroupName);
// CreateSiteColumns(clientContext);
CreateContentTypes(clientContext);
// UploadFiles(clientContext, lastTimeRun);
// SetSearchConfiguration(clientContext);
// UploadMasterPages(clientContext, lastTimeRun);
// UploadPageLayouts(clientContext, lastTimeRun);
// SitePermissions.CreatePermissions(clientContext);
// SubSites.CreateSubSites(_NameSpace, _TokenParser, _Branding, siteUrl, clientContext.Credentials);
// CreatePages(clientContext);
// AddNavigationNodes(clientContext);
// UpdateDeviceChannels(clientContext);
// CreateImageRenditions(clientContext);
// SaveTimeStamp();
break;
case Mode.deactivate:
RemoveFiles(clientContext);
RemoveMasterPages(clientContext);
RemovePageLayouts(clientContext);
RemoveLists(clientContext);
break;
}
}
