public static TermStore LookupTermStore(SiteModelHost currentSiteModelHost,
TaxonomyFieldDefinition taxFieldModel, bool raiseNullRefException)
{
var termStore = TaxonomyTermStoreModelHandler.FindTermStore(currentSiteModelHost,
taxFieldModel.SspName,
taxFieldModel.SspId,
taxFieldModel.UseDefaultSiteCollectionTermStore);
if (termStore == null && raiseNullRefException)
{
throw new ArgumentNullException("termStore is NULL. Please define SspName, SspId or ensure there is a default term store for the giving site.");
}
if (termStore != null)
{
var storeContext = currentSiteModelHost.HostClientContext;
storeContext.Load(termStore, s => s.Id);
storeContext.ExecuteQueryWithTrace();
}
return(termStore);
}
/// <summary>
/// Deploys and validates target site model.
/// </summary>
/// <param name="model"></param>
public override void DeploySiteModel(ModelNode model)
{
foreach (var siteUrl in SiteUrls)
{
Trace.WriteLine(string.Format("[INF] Running on site: [{0}]", siteUrl));
for (var provisionGeneration = 0; provisionGeneration < ProvisionGenerationCount; provisionGeneration++)
{
WithCSOMContext(siteUrl, context =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(SiteModelHost.FromClientContext(context), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(SiteModelHost.FromClientContext(context), model);
}
});
}
}
}
private void DeployModel(ModelNode model)
{
WithCSOMContext(context =>
{
var provisionService = new StandardCSOMProvisionService();
if (model.Value.GetType() == typeof(FarmDefinition))
{
throw new SPMeta2NotImplementedException(
string.Format("Runner does not support model of type: [{0}]", model.Value.GetType()));
}
else if (model.Value.GetType() == typeof(WebApplicationDefinition))
{
throw new SPMeta2NotImplementedException(
string.Format("Runner does not support model of type: [{0}]", model.Value.GetType()));
}
else if (model.Value.GetType() == typeof(SiteDefinition))
{
provisionService.DeployModel(SiteModelHost.FromClientContext(context), model);
}
else if (model.Value.GetType() == typeof(WebDefinition))
{
provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
}
else if (model.Value.GetType() == typeof(ListDefinition))
{
throw new SPMeta2NotImplementedException(
string.Format("Runner does not support model of type: [{0}]", model.Value.GetType()));
}
else
{
throw new SPMeta2NotImplementedException(
string.Format("Runner does not support model of type: [{0}]", model.Value.GetType()));
}
});
}
public static Term LookupTerm(SiteModelHost currentSiteModelHost, TermStore termStore,
TermSet termSet,
TaxonomyFieldDefinition termModel)
{
return(LookupTerm(currentSiteModelHost.HostClientContext, termStore, termSet, termModel));
}
private void DeployArtifact(SiteModelHost modelHost, DesignPackageDefinition definition)
{
var site = modelHost.HostSite;
var context = site.Context;
//var existingSolutionFile = FindExistingSolutionFile(siteModelHost, definition);
var existingSolution = FindExistingSolutionById(modelHost, definition.SolutionId);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = existingSolution,
ObjectType = typeof(File),
ObjectDefinition = definition,
ModelHost = modelHost
});
// uninstalling existing one
if (existingSolution != null && definition.Install)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject,
"Processing existing sandbox solution");
var fileItem = existingSolution.ListItemAllFields;
context.Load(fileItem);
context.ExecuteQueryWithTrace();
var currentFileName = fileItem["FileLeafRef"].ToString();
//if (!currentFileName.Contains(definition.FileName))
// currentFileName = currentFileName.Replace(string.Format("-v{0}.{1}.wsp", 1, 0), string.Empty);
//else
// currentFileName = definition.FileName;
var packageFileName = Path.GetFileNameWithoutExtension(currentFileName);
var packageFileNameParts = packageFileName.Split('-');
var packageName = packageFileNameParts[0];
var versionParts = packageFileNameParts[1].Replace("v", string.Empty)
.Split('.');
var packageMajorVersion = int.Parse(versionParts[0]);
var packageMinorVersion = int.Parse(versionParts[1]);
var info = new DesignPackageInfo
{
PackageGuid = definition.SolutionId,
MajorVersion = packageMajorVersion,
MinorVersion = packageMinorVersion,
PackageName = packageName,
};
// cleaning up AppliedDesignGuid at root web to enable 'force' uninstall
var rootWeb = site.RootWeb;
rootWeb.AllProperties["AppliedDesignGuid"] = null;
rootWeb.Update();
context.ExecuteQueryWithTrace();
// deactivate and remove
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall,
"Deleting existing sandbox solution via DesignPackage.UnInstall()");
DesignPackage.UnInstall(context, site, info);
try
{
context.ExecuteQueryWithTrace();
}
catch (Exception uninstallException)
{
// pass this one
// bug in SharePoint's DesignPackage.UnInstall method
if (!uninstallException.ToString().Contains("33e33eca-7712-4f3d-ab83-6848789fc9b6"))
{
throw;
}
}
}
// installing new
if (definition.Install)
{
var folder = site.RootWeb.RootFolder;
context.Load(folder);
context.ExecuteQueryWithTrace();
var fileCreatingInfo = new FileCreationInformation
{
Url = definition.FileName,
Overwrite = true
};
if (definition.Content.Length < 1024 * 1024 * 1.5)
{
fileCreatingInfo.Content = definition.Content;
}
else
{
fileCreatingInfo.ContentStream = new MemoryStream(definition.Content);
}
var newFile = folder.Files.Add(fileCreatingInfo);
context.Load(newFile);
context.Load(newFile, f => f.ServerRelativeUrl);
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Uploading new sandbox solution to root site folder");
context.ExecuteQueryWithTrace();
var info = new DesignPackageInfo
{
PackageGuid = definition.SolutionId,
MajorVersion = definition.MajorVersion,
MinorVersion = definition.MinorVersion,
PackageName = Path.GetFileNameWithoutExtension(definition.FileName)
};
// activate and remove
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "DesignPackage.Install()");
DesignPackage.Install(context, site, info, newFile.ServerRelativeUrl);
context.ExecuteQueryWithTrace();
// clean up the file
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Deleting sandbox file from root site folder");
newFile.DeleteObject();
context.ExecuteQueryWithTrace();
existingSolution = FindExistingSolutionById(modelHost, definition.SolutionId);
}
if (definition.Apply)
{
var info = new DesignPackageInfo
{
PackageGuid = definition.SolutionId,
MajorVersion = definition.MajorVersion,
MinorVersion = definition.MinorVersion,
PackageName = Path.GetFileNameWithoutExtension(definition.FileName)
};
// apply
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "DesignPackage.Apply()");
DesignPackage.Apply(context, site, info);
context.ExecuteQueryWithTrace();
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = existingSolution,
ObjectType = typeof(File),
ObjectDefinition = definition,
ModelHost = modelHost
});
}
protected SPWeb GetCurrentObject(SiteModelHost siteModelHost, RootWebDefinition definition)
{
return(siteModelHost.HostSite.RootWeb);
}
private void DeploySiteEventReceiver(object modelHost, SiteModelHost siteModelHost, EventReceiverDefinition definition)
{
DeployEventReceiver(modelHost, siteModelHost.HostSite.EventReceivers, definition);
}
static void Main(string[] args)
{
try
{
ReadSettings();
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Configuring managed metadata");
var provisioningService = new StandardCSOMProvisionService();
var siteModel = SiteModel.BuildTaxonomyModel();
Console.WriteLine(siteModel.ToPrettyPrint());
provisioningService.RegisterModelHandlers(typeof(TaxonomyGroupModelHandler).Assembly);
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building site features");
var provisioningService = new CSOMProvisionService();
var siteModel = SiteModel.BuildSiteFeaturesModel();
Console.WriteLine(siteModel.ToPrettyPrint());
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building site fields");
var provisioningService = new StandardCSOMProvisionService();
var siteModel = SiteModel.BuildFieldsModel();
Console.WriteLine(siteModel.ToPrettyPrint());
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building site content types");
var provisioningService = new StandardCSOMProvisionService();
var siteModel = SiteModel.BuildContentTypesModel();
Console.WriteLine(siteModel.ToPrettyPrint());
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), siteModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building web root model ");
var provisioningService = new StandardCSOMProvisionService();
var webModel = SiteModel.BuildWebRootModel();
Console.WriteLine(webModel.ToPrettyPrint());
provisioningService.DeployModel(SiteModelHost.FromClientContext(ctx), webModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building web root files and modules");
var provisioningService = new StandardCSOMProvisionService();
var webModel = Model.FIles.BuildFilesModel();
Console.WriteLine(webModel.ToPrettyPrint());
provisioningService.DeployModel(WebModelHost.FromClientContext(ctx), webModel);
}
using (ClientContext ctx = GetAuthenticatedContext())
{
TraceHelper.TraceInformation("Building pages");
var provisioningService = new StandardCSOMProvisionService();
var webModel = Model.Pages.BuildPagesModel();
Console.WriteLine(webModel.ToPrettyPrint());
provisioningService.DeployModel(WebModelHost.FromClientContext(ctx), webModel);
}
}
catch (Exception ex)
{
TraceHelper.TraceError("an error has occured, message:{0}", ex);
}
}
protected File FindExistingSolutionFile(SiteModelHost siteModelHost,
SandboxSolutionDefinition sandboxSolutionDefinition)
{
return(FindExistingSolutionFileByName(siteModelHost, sandboxSolutionDefinition.FileName));
}
protected File FindExistingSolution(SiteModelHost siteModelHost,
SandboxSolutionDefinition sandboxSolutionDefinition)
{
return(FindExistingSolutionById(siteModelHost, sandboxSolutionDefinition.SolutionId));
}
private void DeployImageRenditionSettings(object modelHost, SiteModelHost siteModelHost,
ImageRenditionDefinition imageRenditionModel)
{
var context = siteModelHost.HostSite.Context;
var renditions = SiteImageRenditions.GetRenditions(siteModelHost.HostSite.Context);
context.ExecuteQueryWithTrace();
var currentRendition = GetCurrentImageRendition(renditions, imageRenditionModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentRendition,
ObjectType = typeof(ImageRendition),
ObjectDefinition = imageRenditionModel,
ModelHost = modelHost
});
if (currentRendition == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Image Rendition");
var newRendition = new ImageRendition
{
Name = imageRenditionModel.Name,
Width = imageRenditionModel.Width,
Height = imageRenditionModel.Height
};
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = newRendition,
ObjectType = typeof(ImageRendition),
ObjectDefinition = imageRenditionModel,
ModelHost = modelHost
});
renditions.Add(newRendition);
SiteImageRenditions.SetRenditions(context, renditions);
context.ExecuteQueryWithTrace();
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing existing Image Rendition");
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentRendition,
ObjectType = typeof(ImageRendition),
ObjectDefinition = imageRenditionModel,
ModelHost = modelHost
});
}
}
private void DeploySiteGroup(object modelHost, SiteModelHost siteModelHost, DefinitionBase model)
{
var site = siteModelHost.HostSite;
var securityGroupModel = model.WithAssertAndCast <SecurityGroupDefinition>("model",
value => value.RequireNotNull());
var web = site.RootWeb;
//var site = web.Site;
var currentGroup = (SPGroup)null;
var hasInitialGroup = false;
try
{
currentGroup = site.RootWeb.SiteGroups[securityGroupModel.Name];
hasInitialGroup = true;
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject,
"Processing existing security group");
}
catch (SPException)
{
var defaultUser = EnsureDefaultUser(web, securityGroupModel);
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject,
"Processing new security group");
// owner would be defaut site owner
web.SiteGroups.Add(securityGroupModel.Name, web.Site.Owner, defaultUser,
securityGroupModel.Description ?? string.Empty);
currentGroup = web.SiteGroups[securityGroupModel.Name];
// updating the owner or leave as default
// Enhance 'SecurityGroupDefinition' provision - add self-owner support #516
// https://github.com/SubPointSolutions/spmeta2/issues/516
var ownerUser = EnsureOwnerUser(web, securityGroupModel.Owner);
currentGroup.Owner = ownerUser;
currentGroup.Update();
}
if (hasInitialGroup)
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentGroup,
ObjectType = typeof(SPPrincipal),
ObjectDefinition = securityGroupModel,
ModelHost = modelHost
});
}
else
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = null,
ObjectType = typeof(SPPrincipal),
ObjectDefinition = securityGroupModel,
ModelHost = modelHost
});
}
currentGroup.OnlyAllowMembersViewMembership = securityGroupModel.OnlyAllowMembersViewMembership;
if (!string.IsNullOrEmpty(securityGroupModel.Owner))
{
currentGroup.Owner = EnsureOwnerUser(web, securityGroupModel.Owner);
}
currentGroup.Description = securityGroupModel.Description ?? string.Empty;
if (securityGroupModel.AllowMembersEditMembership.HasValue)
{
currentGroup.AllowMembersEditMembership = securityGroupModel.AllowMembersEditMembership.Value;
}
if (securityGroupModel.AllowRequestToJoinLeave.HasValue)
{
currentGroup.AllowRequestToJoinLeave = securityGroupModel.AllowRequestToJoinLeave.Value;
}
if (securityGroupModel.AutoAcceptRequestToJoinLeave.HasValue)
{
currentGroup.AutoAcceptRequestToJoinLeave = securityGroupModel.AutoAcceptRequestToJoinLeave.Value;
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentGroup,
ObjectType = typeof(SPPrincipal),
ObjectDefinition = securityGroupModel,
ModelHost = modelHost
});
currentGroup.Update();
}
internal static TermStore FindTermStore(SiteModelHost siteModelHost,
string termStoreName,
Guid?termStoreId,
bool?useDefaultSiteCollectionTermStore)
{
var site = siteModelHost.HostSite;
TermStore termStore = null;
lock (_storeCacheLock)
{
var key = string.Format("{0}-{1}-{2}",
siteModelHost.HostClientContext.GetHashCode(),
siteModelHost.HostClientContext.Site.GetHashCode(),
string.Format("{0}-{1}-{2}", termStoreName, termStoreId, useDefaultSiteCollectionTermStore))
.ToLower();
if (!_storeCache.ContainsKey(key))
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "First call to TermStore with cache key: [{0}]", key);
var session = TaxonomySession.GetTaxonomySession(siteModelHost.HostClientContext);
var client = siteModelHost.HostClientContext;
if (useDefaultSiteCollectionTermStore == true)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Resolving Term Store as useDefaultSiteCollectionTermStore");
termStore = session.GetDefaultSiteCollectionTermStore();
}
else
{
if (termStoreId.HasValue && termStoreId != default(Guid))
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Resolving Term Store by ID: [{0}]", termStoreId.Value);
termStore = session.TermStores.GetById(termStoreId.Value);
}
else if (!string.IsNullOrEmpty(termStoreName))
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Resolving Term Store by Name: [{0}]", termStoreName);
termStore = session.TermStores.GetByName(termStoreName);
}
}
if (termStore != null)
{
client.Load(termStore, s => s.Id);
client.Load(termStore, s => s.Name);
client.ExecuteQueryWithTrace();
}
_storeCache.Add(key, termStore);
}
else
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Resolving term store from internal cache with cache key: [{0}]", key);
}
return(_storeCache[key]);
}
return(termStore);
}
private void DeploySiteGroup(object modelHost, SiteModelHost siteModelHost, DefinitionBase model)
{
var webModelHost = modelHost.WithAssertAndCast <SiteModelHost>("modelHost", value => value.RequireNotNull());
var web = webModelHost.HostSite.RootWeb;
var securityGroupModel = model.WithAssertAndCast <SecurityGroupDefinition>("model", value => value.RequireNotNull());
var context = web.Context;
// well, this should be pulled up to the site handler and init Load/Exec query
context.Load(web, tmpWeb => tmpWeb.SiteGroups, g => g.Id, g => g.Title);
context.ExecuteQueryWithTrace();
Principal groupOwner = null;
if (!string.IsNullOrEmpty(securityGroupModel.Owner) &&
(securityGroupModel.Owner.ToUpper() != securityGroupModel.Name.ToUpper()))
{
groupOwner = ResolvePrincipal(context, web, securityGroupModel.Owner);
if (groupOwner == null)
{
throw new SPMeta2Exception(string.Format("Cannot resolve Principal by string value: [{0}]", securityGroupModel.Owner));
}
}
var currentGroup = FindSecurityGroupByTitle(web.SiteGroups, securityGroupModel.Name);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentGroup,
ObjectType = typeof(Principal),
ObjectDefinition = model,
ModelHost = modelHost
});
if (currentGroup == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new security group");
currentGroup = web.SiteGroups.Add(new GroupCreationInformation
{
Title = securityGroupModel.Name,
Description = securityGroupModel.Description ?? string.Empty,
});
currentGroup.Update();
context.ExecuteQueryWithTrace();
// updating the owner or leave as default
// Enhance 'SecurityGroupDefinition' provision - add self-owner support #516
// https://github.com/SubPointSolutions/spmeta2/issues/516
if (!string.IsNullOrEmpty(securityGroupModel.Owner))
{
groupOwner = ResolvePrincipal(context, web, securityGroupModel.Owner);
currentGroup.Owner = groupOwner;
currentGroup.Update();
context.ExecuteQueryWithTrace();
}
context.Load(currentGroup);
context.ExecuteQueryWithTrace();
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing security group");
}
currentGroup.Title = securityGroupModel.Name;
currentGroup.Description = securityGroupModel.Description ?? string.Empty;
currentGroup.OnlyAllowMembersViewMembership = securityGroupModel.OnlyAllowMembersViewMembership;
if (securityGroupModel.AllowMembersEditMembership.HasValue)
{
currentGroup.AllowMembersEditMembership = securityGroupModel.AllowMembersEditMembership.Value;
}
if (securityGroupModel.AllowRequestToJoinLeave.HasValue)
{
currentGroup.AllowRequestToJoinLeave = securityGroupModel.AllowRequestToJoinLeave.Value;
}
if (securityGroupModel.AutoAcceptRequestToJoinLeave.HasValue)
{
currentGroup.AutoAcceptRequestToJoinLeave = securityGroupModel.AutoAcceptRequestToJoinLeave.Value;
}
if (groupOwner != null)
{
currentGroup.Owner = groupOwner;
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentGroup,
ObjectType = typeof(Principal),
ObjectDefinition = model,
ModelHost = modelHost
});
currentGroup.Update();
context.ExecuteQueryWithTrace();
}
public override void DeployModel(object modelHost, DefinitionBase model)
{
if (!(modelHost is SiteModelHost || modelHost is ListModelHost))
{
throw new ArgumentException("modelHost needs to be SiteModelHost/ListModelHost instance.");
}
CurrentSiteModelHost = modelHost as SiteModelHost;
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Casting field model definition");
var fieldModel = model.WithAssertAndCast <FieldDefinition>("model", value => value.RequireNotNull());
Field currentField = null;
ClientRuntimeContext context = null;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = null,
ObjectType = GetTargetFieldType(fieldModel),
ObjectDefinition = model,
ModelHost = modelHost
});
InvokeOnModelEvent <FieldDefinition, Field>(currentField, ModelEventType.OnUpdating);
if (modelHost is SiteModelHost)
{
var siteHost = modelHost as SiteModelHost;
context = siteHost.HostSite.Context;
currentField = DeploySiteField(siteHost as SiteModelHost, fieldModel);
}
else if (modelHost is ListModelHost)
{
var listHost = modelHost as ListModelHost;
context = listHost.HostList.Context;
currentField = DeployListField(modelHost as ListModelHost, fieldModel);
}
object typedField = null;
// emulate context.CastTo<>() call for typed field type
if (GetTargetFieldType(fieldModel) != currentField.GetType())
{
var targetFieldType = GetTargetFieldType(fieldModel);
TraceService.InformationFormat((int)LogEventId.ModelProvisionCoreCall, "Calling context.CastTo() to field type: [{0}]", targetFieldType);
var method = context.GetType().GetMethod("CastTo");
var generic = method.MakeGenericMethod(targetFieldType);
typedField = generic.Invoke(context, new object[] { currentField });
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = typedField ?? currentField,
ObjectType = GetTargetFieldType(fieldModel),
ObjectDefinition = model,
ModelHost = modelHost
});
InvokeOnModelEvent <FieldDefinition, Field>(currentField, ModelEventType.OnUpdated);
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "UpdateAndPushChanges(true)");
currentField.UpdateAndPushChanges(true);
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "ExecuteQuery()");
context.ExecuteQueryWithTrace();
}
private void DeployDesignPackage(object modelHost, SiteModelHost siteModelHost, DesignPackageDefinition definition)
{
var site = siteModelHost.HostSite;
var sandboxSolution = FindExistingSolutionById(siteModelHost, definition.SolutionId);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = sandboxSolution,
ObjectType = typeof(SPUserSolution),
ObjectDefinition = definition,
ModelHost = modelHost
});
if (sandboxSolution != null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject,
"Processing existing design package");
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject,
"Processing new design package");
}
var designPackageInfo = new DesignPackageInfo(definition.FileName,
definition.SolutionId,
definition.MajorVersion,
definition.MinorVersion);
if (definition.Install)
{
// removing first
if (sandboxSolution != null)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Deleting existing sandbox solution");
siteModelHost.HostSite.Solutions.Remove(sandboxSolution);
var catalog = siteModelHost.HostSite.RootWeb.GetCatalog(SPListTemplateType.SolutionCatalog);
try
{
var solutionFile = catalog.RootFolder.Files[sandboxSolution.Name];
if (solutionFile.Exists)
{
solutionFile.Delete();
}
}
catch
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject,
"Error while deleting design package");
}
}
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Deploying design package file to the root folder of the root web");
var rootFolder = site.RootWeb.RootFolder;
var tmpDesignPackageFile = rootFolder.Files.Add(definition.FileName, definition.Content, true);
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall,
string.Format("Installing design package from URL:[{0}]", tmpDesignPackageFile.ServerRelativeUrl));
DesignPackage.Install(site, designPackageInfo, tmpDesignPackageFile.ServerRelativeUrl);
sandboxSolution = FindExistingSolutionById(siteModelHost, definition.SolutionId);
if (definition.Apply)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Applying design package");
DesignPackage.Apply(site, designPackageInfo);
}
else
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Apply == false. Skipping design package activation");
}
// cleanup
if (tmpDesignPackageFile.Exists)
{
tmpDesignPackageFile.Delete();
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = sandboxSolution,
ObjectType = typeof(SPUserSolution),
ObjectDefinition = definition,
ModelHost = modelHost
});
}
else
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Activate = false. Continue provision");
if (sandboxSolution != null)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Solution is NOT NULL. Checking Apply status");
if (definition.Apply)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Applying design package");
DesignPackage.Apply(site, designPackageInfo);
}
else
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall,
"Apply == false. Skipping design package activation");
}
}
else
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Solution is NULL. Skipping Apply status");
}
sandboxSolution = FindExistingSolutionById(siteModelHost, definition.SolutionId);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = sandboxSolution,
ObjectType = typeof(SPUserSolution),
ObjectDefinition = definition,
ModelHost = modelHost
});
}
}
protected TermStore FindTermStore(SiteModelHost siteModelHost, TaxonomyTermStoreDefinition termStoreModel)
{
return(FindTermStore(siteModelHost.HostSite,
termStoreModel.Name, termStoreModel.Id, termStoreModel.UseDefaultSiteCollectionTermStore));
}
private void DeploySiteDependentLookup(object modelHost, SiteModelHost siteModelHost, DependentLookupFieldDefinition definition)
{
DeployDependentLookupField(modelHost, siteModelHost.HostSite.RootWeb.Fields, definition);
}
private void DeploySiteManagedProperty(object modelHost, SiteModelHost siteModelHost, ManagedPropertyDefinition managedProperty)
{
throw new NotImplementedException();
}
public static void DeploySiteModel(this SSOMProvisionService modelHost, SPSite site, ModelNode model)
{
modelHost.DeployModel(SiteModelHost.FromSite(site), model);
}
private void DeploySiteManagedProperty(object modelHost, SiteModelHost siteModelHost, ManagedPropertyDefinition managedProperty)
{
throw new SPMeta2NotImplementedException("Managed property deployment under site is not implemented yet");
}
public static TermStore LookupTermStore(SiteModelHost currentSiteModelHost,
TaxonomyFieldDefinition taxFieldModel)
{
return(LookupTermStore(currentSiteModelHost, taxFieldModel, false));
}
public static Term LookupTerm(SiteModelHost currentSiteModelHost, TermStore termStore, TaxonomyFieldDefinition termModel)
{
var context = currentSiteModelHost.HostClientContext;
var site = currentSiteModelHost.HostSite;
Term result = null;
TermGroup currenGroup = null;
var termGroupName = termModel.TermGroupName;
var termGroupId = termModel.TermGroupId;
var isSiteCollectionGroup = termModel.IsSiteCollectionGroup;
if (!string.IsNullOrEmpty(termGroupName))
{
currenGroup = termStore.Groups.GetByName(termGroupName);
context.Load(currenGroup);
context.ExecuteQueryWithTrace();
}
else if (termGroupId != null && termGroupId.HasGuidValue())
{
currenGroup = termStore.Groups.GetById(termGroupId.Value);
context.Load(currenGroup);
context.ExecuteQueryWithTrace();
}
else if (isSiteCollectionGroup == true)
{
currenGroup = termStore.GetSiteCollectionGroup(site, false);
context.Load(currenGroup);
context.ExecuteQueryWithTrace();
}
if (currenGroup != null)
{
if (termModel.TermId.HasValue)
{
// by ID, the only one match
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = termStore.GetTerm(termModel.TermId.Value);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
context.ExecuteQueryWithTrace();
}
else if (!string.IsNullOrEmpty(termModel.TermName))
{
var terms = termStore.GetTerms(new LabelMatchInformation(context)
{
Lcid = termModel.TermLCID,
TermLabel = termModel.TermName,
TrimUnavailable = false
});
context.Load(terms, t => t.Include(
i => i.Id,
i => i.Name,
i => i.TermSet,
i => i.TermSet.Group,
i => i.TermSet.Group.Name
));
context.ExecuteQueryWithTrace();
result = terms.FirstOrDefault(t => t.TermSet.Group.Name == currenGroup.Name);
}
}
else
{
if (termModel.TermId.HasValue)
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = termStore.GetTerm(termModel.TermId.Value);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
context.ExecuteQueryWithTrace();
}
else if (!string.IsNullOrEmpty(termModel.TermName))
{
var terms = termStore.GetTerms(new LabelMatchInformation(context)
{
Lcid = termModel.TermLCID,
TermLabel = termModel.TermName,
TrimUnavailable = false
});
context.Load(terms);
context.ExecuteQueryWithTrace();
result = terms.FirstOrDefault();
}
}
if (result != null && result.ServerObjectIsNull == false)
{
context.Load(result);
context.ExecuteQueryWithTrace();
return(result);
}
return(null);
}
private void DeploySandboxSolution(object modelHost, SiteModelHost siteModelHost, SandboxSolutionDefinition sandboxSolutionDefinition)
{
var site = siteModelHost.HostSite;
var context = site.Context;
var existingSolutionFile = FindExistingSolutionFile(siteModelHost, sandboxSolutionDefinition);
var existingSolution = FindExistingSolution(siteModelHost, sandboxSolutionDefinition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = existingSolutionFile,
ObjectType = typeof(File),
ObjectDefinition = sandboxSolutionDefinition,
ModelHost = modelHost
});
if (existingSolution != null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing sandbox solution");
var fileItem = existingSolution.ListItemAllFields;
context.Load(fileItem);
context.ExecuteQueryWithTrace();
var currentFileName = fileItem["FileLeafRef"].ToString();
if (!currentFileName.Contains(sandboxSolutionDefinition.FileName))
{
currentFileName = currentFileName.Replace(string.Format("-v{0}.{1}.wsp", 1, 0), string.Empty);
}
else
{
currentFileName = sandboxSolutionDefinition.FileName;
}
var info = new DesignPackageInfo
{
PackageGuid = sandboxSolutionDefinition.SolutionId,
MajorVersion = 1,
MinorVersion = 0,
PackageName = Path.GetFileNameWithoutExtension(currentFileName)
};
// deactivate and remove
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Deleting existing sandbox solution via DesignPackage.UnInstall()");
DesignPackage.UnInstall(context, site, info);
context.ExecuteQueryWithTrace();
}
//var solutionGallery = site.RootWeb.Lists.GetByTitle("Site Assets");
//var folder = solutionGallery.RootFolder;
var folder = site.RootWeb.RootFolder;
context.Load(folder);
context.ExecuteQueryWithTrace();
var fileCreatingInfo = new FileCreationInformation
{
Url = sandboxSolutionDefinition.FileName,
Overwrite = true
};
if (sandboxSolutionDefinition.Content.Length < 1024 * 1024 * 1.5)
{
fileCreatingInfo.Content = sandboxSolutionDefinition.Content;
}
else
{
fileCreatingInfo.ContentStream = new System.IO.MemoryStream(sandboxSolutionDefinition.Content);
}
var newFile = folder.Files.Add(fileCreatingInfo);
context.Load(newFile);
context.Load(newFile, f => f.ServerRelativeUrl);
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Uploading new sandbox solution to root site folder");
context.ExecuteQueryWithTrace();
if (sandboxSolutionDefinition.Activate)
{
var info = new DesignPackageInfo
{
PackageGuid = sandboxSolutionDefinition.SolutionId,
MajorVersion = 1,
MinorVersion = 0,
PackageName = Path.GetFileNameWithoutExtension(sandboxSolutionDefinition.FileName)
};
// activate and remove
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Activating sandbox solution via DesignPackage.Install()");
DesignPackage.Install(context, site, info, newFile.ServerRelativeUrl);
context.ExecuteQueryWithTrace();
// clean up the file
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Deleting sandbox file from root site folder");
newFile.DeleteObject();
context.ExecuteQueryWithTrace();
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = newFile,
ObjectType = typeof(File),
ObjectDefinition = sandboxSolutionDefinition,
ModelHost = modelHost
});
}
private void DeploySandboxSolution(object modelHost, SiteModelHost siteModelHost, SandboxSolutionDefinition sandboxSolutionDefinition)
{
var existingSolutions = FindExistingSolutionFile(siteModelHost, sandboxSolutionDefinition);
var sandboxSolution = FindExistingSolution(siteModelHost, sandboxSolutionDefinition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = sandboxSolution,
ObjectType = typeof(SPUserSolution),
ObjectDefinition = sandboxSolutionDefinition,
ModelHost = modelHost
});
if (sandboxSolution != null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing sandbox solution");
}
if (sandboxSolution != null && sandboxSolution.Status == SPUserSolutionStatus.Activated)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Deleting existing sandbox solution");
siteModelHost.HostSite.Solutions.Remove(sandboxSolution);
}
var solutionGallery = (SPDocumentLibrary)siteModelHost.HostSite.GetCatalog(SPListTemplateType.SolutionCatalog);
var file = solutionGallery.RootFolder.Files.Add(sandboxSolutionDefinition.FileName, sandboxSolutionDefinition.Content, true);
if (sandboxSolutionDefinition.Activate)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Activating sandbox solution");
var userSolution = siteModelHost.HostSite.Solutions.Add(file.Item.ID);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = userSolution,
ObjectType = typeof(SPUserSolution),
ObjectDefinition = sandboxSolutionDefinition,
ModelHost = modelHost
});
}
else
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Activate = false. Continue provision");
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = sandboxSolution,
ObjectType = typeof(SPUserSolution),
ObjectDefinition = sandboxSolutionDefinition,
ModelHost = modelHost
});
}
}
