private ListItem EnsureListFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
string serverRelativeUrl = string.Empty;
var list = folderModelHost.CurrentList;
var context = list.Context;
var currentFolder = GetListFolder(folderModelHost, folderModel, out serverRelativeUrl);
var currentFolderItem = folderModelHost.CurrentListItem;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentFolder,
ObjectType = typeof(Folder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
context.ExecuteQuery();
if (currentFolder == null)
{
currentFolderItem = list.AddItem(new ListItemCreationInformation
{
FolderUrl = serverRelativeUrl,
LeafName = folderModel.Name,
UnderlyingObjectType = FileSystemObjectType.Folder
});
currentFolderItem["Title"] = folderModel.Name;
currentFolderItem.Update();
context.ExecuteQuery();
}
else
{
context.Load(currentFolder, f => f.ListItemAllFields);
context.Load(currentFolder, f => f.Name);
context.ExecuteQuery();
currentFolderItem = currentFolder.ListItemAllFields;
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFolder,
ObjectType = typeof(Folder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
return(currentFolderItem);
}
public static void Create(SPList list, FolderDefinition definition)
{
var web = list.ParentWeb;
var existingFolder = web.GetFolder(list.Title + "/" + definition.Name);
if (existingFolder.Exists)
{
return;
}
var newFolder = list.Items.Add(string.Empty, SPFileSystemObjectType.Folder, definition.Name);
newFolder.Update();
if (definition.roleAssociations.Count <= 0)
{
return;
}
newFolder.BreakRoleInheritance(false);
foreach (var association in definition.roleAssociations)
{
newFolder.AddRole(association.RoleDefinitionName).For(association.PrincipalNames);
}
}
protected SPFolder GetListFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
var list = folderModelHost.CurrentList;
var currentFolderItem = folderModelHost.CurrentListItem;
var serverRelativeUrl = folderModelHost.CurrentListItem == null
? list.RootFolder.ServerRelativeUrl
: folderModelHost.CurrentListItem.Folder.ServerRelativeUrl;
var currentUrl = serverRelativeUrl + "/" + folderModel.Name;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Loading list folder with URL: [{0}]", currentUrl);
var folder = folderModelHost.CurrentList.ParentWeb.GetFolder(currentUrl);
if (folder != null && folder.Exists)
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "List folder with URL does exist: [{0}]", currentUrl);
}
else
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "List folder with URL does not exist: [{0}]", currentUrl);
}
return(folder);
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleFolders()
{
var activeDocsFolder = new FolderDefinition
{
Name = "Active documents"
};
var archiveFolder = new FolderDefinition
{
Name = "Archive"
};
var listWithFolders = new ListDefinition
{
Title = "List with folders",
Description = "Custom list with folders.",
TemplateType = BuiltInListTemplateTypeId.GenericList,
Url = "ListWithFolders"
};
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddList(listWithFolders, list =>
{
list
.AddFolder(activeDocsFolder)
.AddFolder(archiveFolder);
});
});
DeployModel(model);
}
private void ParseFolder(FolderDefinition folder)
{
foreach (var sourceItem in folder.Children)
{
ParseSourceItem(sourceItem);
}
}
protected Folder GetListFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
var tmp = string.Empty;
var result = GetListFolder(folderModelHost, folderModel, out tmp);
return(result);
}
protected Folder GetLibraryFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
var parentFolder = folderModelHost.CurrentLibraryFolder;
var context = parentFolder.Context;
context.Load(parentFolder, f => f.Folders);
context.ExecuteQueryWithTrace();
// dirty stuff, needs to be rewritten
var currentFolder = parentFolder
.Folders
.OfType <Folder>()
.FirstOrDefault(f => f.Name == folderModel.Name);
if (currentFolder != null)
{
context.Load(currentFolder, f => f.Name);
context.ExecuteQueryWithTrace();
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Library folder with name does exist: [{0}]", folderModel.Name);
}
else
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Library folder with name does not exist: [{0}]", folderModel.Name);
}
return(currentFolder);
}
/// <summary>
/// Reads the giving directory and populates the node with folders/files structure
/// </summary>
/// <param name="hostNode"></param>
/// <param name="folderPath"></param>
internal static void LoadModuleFilesFromLocalFolder(ModelNode hostNode, string folderPath)
{
var files = Directory.GetFiles(folderPath);
var folders = Directory.GetDirectories(folderPath);
foreach (var file in files)
{
hostNode.AddDefinitionNode(new ModuleFileDefinition
{
Content = File.ReadAllBytes(file),
FileName = Path.GetFileName(file),
Overwrite = true
});
}
foreach (var subFolder in folders)
{
var subFolderPath = subFolder;
var folderDef = new FolderDefinition
{
Name = Path.GetFileName(subFolderPath)
};
hostNode.AddDefinitionNode(folderDef, folderNode => LoadModuleFilesFromLocalFolder(folderNode, subFolderPath));
}
}
public FolderDefinition WithFolder(string folderName)
{
var definition = new FolderDefinition(this, folderName);
folderDefinitions.Add(definition);
return(definition);
}
private SPFolder FindCurrentLibraryFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
TraceService.Information((int)LogEventId.ModelProvisionCoreCall, "FindCurrentLibraryFolder()");
var currentFolder = GetLibraryFolder(folderModelHost, folderModel);
return(currentFolder);
}
private Folder GetListFolder(FolderModelHost folderModelHost, FolderDefinition folderModel,
out string serverRelativeUrl)
{
var list = folderModelHost.CurrentList;
var context = list.Context;
context.Load(list, l => l.RootFolder);
context.Load(list, l => l.ParentWeb);
#if NET35
throw new SPMeta2NotImplementedException("Not implemented for SP2010 - https://github.com/SubPointSolutions/spmeta2/issues/766");
#endif
#if !NET35
if (folderModelHost.CurrentListItem != null)
{
context.Load(folderModelHost.CurrentListItem, l => l.Folder);
}
context.ExecuteQueryWithTrace();
serverRelativeUrl = folderModelHost.CurrentListItem == null
? list.RootFolder.ServerRelativeUrl
: folderModelHost.CurrentListItem.Folder.ServerRelativeUrl;
var currentUrl = serverRelativeUrl + "/" + folderModel.Name;
var currentFolder = folderModelHost.CurrentList.ParentWeb.GetFolderByServerRelativeUrl(currentUrl);
var doesFolderExist = false;
try
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Loading list folder with URL: [{0}]", currentUrl);
context.Load(currentFolder, f => f.Name);
context.ExecuteQueryWithTrace();
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "List folder with URL does exist: [{0}]", currentUrl);
doesFolderExist = true;
}
catch (ServerException e)
{
if (e.ServerErrorTypeName == "System.IO.FileNotFoundException")
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "List folder with URL does not exist: [{0}]", currentUrl);
doesFolderExist = false;
}
}
if (doesFolderExist)
{
return(currentFolder);
}
#endif
return(null);
}
public void CanDeploy_WebpartTo_VideoContentType_VideoPlayerPage()
{
// aiming to deploy a web part to the following page with in a library
// forms/videocontenttype/videoplayerpage.aspx
var listDef = ModelGeneratorService.GetRandomDefinition <ListDefinition>(def =>
{
def.ContentTypesEnabled = true;
def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;
});
var contentTypeName = "Video";
var contentTypeLinkDef = new ContentTypeLinkDefinition
{
ContentTypeName = contentTypeName,
ContentTypeId = BuiltInSiteContentTypeId.Video
};
var formsFolder = new FolderDefinition
{
Name = "Forms"
};
var contentTypeFolder = new FolderDefinition
{
Name = contentTypeName
};
var pageDefinition = new WebPartPageDefinition
{
FileName = "videoplayerpage.aspx",
PageLayoutTemplate = BuiltInWebPartPageTemplates.spstd1,
NeedOverride = false
};
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddList(listDef, list =>
{
list.AddContentTypeLink(contentTypeLinkDef);
list.AddFolder(formsFolder, forms =>
{
forms.AddFolder(contentTypeFolder, folder =>
{
folder.AddHostWebPartPage(pageDefinition, page =>
{
page.AddRandomWebpart();
page.AddRandomWebpart();
page.AddRandomWebpart();
});
});
});
});
});
TestModel(model);
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeployUserCustomActionWithJquery()
{
var jQueryFile = new ModuleFileDefinition
{
FileName = "jquery-1.11.2.min.js",
Content = ModuleFileUtils.FromResource(GetType().Assembly, "SPMeta2.Docs.Modules.jquery-1.11.2.min.js"),
Overwrite = true
};
var appScriptsFolder = new FolderDefinition
{
Name = "M2 App Scripts"
};
var jQueryCustomAction = new UserCustomActionDefinition
{
Name = "m2jQuery",
Location = "ScriptLink",
ScriptSrc = UrlUtility.CombineUrl(new string[]
{
"~sitecollection",
BuiltInListDefinitions.StyleLibrary.GetListUrl(),
appScriptsFolder.Name,
jQueryFile.FileName
}),
Sequence = 1500
};
var jQuerySiteLogger = new UserCustomActionDefinition
{
Name = "m2jQuerySiteLogger",
Location = "ScriptLink",
ScriptBlock = "jQuery(document).ready( function() { console.log('jQuery site logger on site:' + _spPageContextInfo.siteAbsoluteUrl); } );",
Sequence = 1600
};
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site
.AddUserCustomAction(jQueryCustomAction)
.AddUserCustomAction(jQuerySiteLogger);
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddHostList(BuiltInListDefinitions.StyleLibrary, list =>
{
list.AddFolder(appScriptsFolder, folder =>
{
folder.AddModuleFile(jQueryFile);
});
});
});
DeployModel(siteModel);
DeployModel(webModel);
}
private SPFolder EnsureLibraryFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
TraceService.Information((int)LogEventId.ModelProvisionCoreCall, "EnsureLibraryFolder()");
var parentFolder = folderModelHost.CurrentLibraryFolder;
// dirty stuff, needs to be rewritten
var currentFolder = GetLibraryFolder(folderModelHost, folderModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentFolder == null || !currentFolder.Exists ? null : currentFolder,
ObjectType = typeof(SPFolder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
if (currentFolder == null || !currentFolder.Exists)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new library folder");
currentFolder = parentFolder.SubFolders.Add(folderModel.Name);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFolder,
ObjectType = typeof(SPFolder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing library folder");
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFolder,
ObjectType = typeof(SPFolder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
currentFolder.Update();
}
return(currentFolder);
}
private SPListItem FindCurrentListFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
TraceService.Information((int)LogEventId.ModelProvisionCoreCall, "FindCurrentListFolder()");
var list = folderModelHost.CurrentList;
var currentFolder = GetListFolder(folderModelHost, folderModel);
return(currentFolder.Item);
}
private SPFolder EnsureLibraryFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
var parentFolder = folderModelHost.CurrentLibraryFolder;
// dirty stuff, needs to be rewritten
var currentFolder = parentFolder
.SubFolders
.OfType <SPFolder>()
.FirstOrDefault(f => f.Name == folderModel.Name);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentFolder == null || !currentFolder.Exists ? null : currentFolder,
ObjectType = typeof(SPFolder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
if (currentFolder == null || !currentFolder.Exists)
{
currentFolder = parentFolder.SubFolders.Add(folderModel.Name);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFolder,
ObjectType = typeof(SPFolder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
}
else
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFolder,
ObjectType = typeof(SPFolder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
currentFolder.Update();
}
return(currentFolder);
}
private void ValidateFolderProps(Folder folder, FolderDefinition folderModel)
{
TraceUtils.WithScope(traceScope =>
{
var pair = new ComparePair <FolderDefinition, Folder>(folderModel, folder);
traceScope.WriteLine(string.Format("Validating model:[{0}] folder:[{1}]", folderModel, folder));
traceScope.WithTraceIndent(trace => pair
.ShouldBeEqual(trace, m => m.Name, o => o.Name));
});
}
private Folder GetListFolder(FolderModelHost folderModelHost, FolderDefinition folderModel,
out string serverRelativeUrl)
{
var list = folderModelHost.CurrentList;
var context = list.Context;
context.Load(list, l => l.RootFolder);
context.Load(list, l => l.ParentWeb);
if (folderModelHost.CurrentListItem != null)
{
context.Load(folderModelHost.CurrentListItem, l => l.Folder);
}
context.ExecuteQueryWithTrace();
serverRelativeUrl = folderModelHost.CurrentListItem == null
? list.RootFolder.ServerRelativeUrl
: folderModelHost.CurrentListItem.Folder.ServerRelativeUrl;
var currentUrl = serverRelativeUrl + "/" + folderModel.Name;
var currentFolder = folderModelHost.CurrentList.ParentWeb.GetFolderByServerRelativeUrl(currentUrl);
var doesFolderExist = false;
try
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Loading list folder with URL: [{0}]", currentUrl);
context.Load(currentFolder, f => f.Name);
context.ExecuteQueryWithTrace();
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "List folder with URL does exist: [{0}]", currentUrl);
doesFolderExist = true;
}
catch (ServerException e)
{
if (e.ServerErrorTypeName == "System.IO.FileNotFoundException")
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "List folder with URL does not exist: [{0}]", currentUrl);
doesFolderExist = false;
}
}
if (doesFolderExist)
{
return(currentFolder);
}
return(null);
}
private void MapProperties(ListItem currentItem, FolderDefinition definition)
{
if (!string.IsNullOrEmpty(definition.ContentTypeId))
{
currentItem[BuiltInInternalFieldNames.ContentTypeId] = definition.ContentTypeId;
}
else if (!string.IsNullOrEmpty(definition.ContentTypeName))
{
currentItem[BuiltInInternalFieldNames.ContentTypeId] = ContentTypeLookupService
.LookupContentTypeByName(currentItem.ParentList, definition.ContentTypeName)
.Id.ToString();
}
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var item = (reverseHost as FolderReverseHost).HostFolder;
var def = new FolderDefinition();
def.Name = item.Name;
return(new FolderModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeployPropertyBagUnderFolder()
{
var folderTag = new PropertyDefinition
{
Key = "m2_folder_tag",
Value = "m2_folder_tag_value",
};
var folderType = new PropertyDefinition
{
Key = "m2_folder_type",
Value = "m2_folder_type_value",
};
var listWithProperties = new ListDefinition
{
Title = "List with properties",
Description = "List with some properties.",
TemplateType = BuiltInListTemplateTypeId.GenericList,
Url = "ListWithProperties"
};
var fodlerWithProperties = new FolderDefinition
{
Name = "folder with properties"
};
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddList(listWithProperties, list =>
{
list.AddFolder(fodlerWithProperties, folder =>
{
// Syntax miss - folder should support adding props #669
// https://github.com/SubPointSolutions/spmeta2/issues/669
//folder
// .AddProperty(folderTag)
// .AddProperty(folderType);
folder
.AddDefinitionNode(folderTag)
.AddDefinitionNode(folderType);
});
});
});
DeployModel(model);
}
private void ReadSourceItems(XmlReader reader, SourceItemDefinition parent)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Folder":
case "Header":
{
SourceItemDefinition item;
var name = reader.GetAttribute("Name");
var isExcluded = "true".Equals(reader.GetAttribute("IsExcluded"));
if (reader.Name.Equals("Folder"))
{
item = new FolderDefinition(name);
}
else // if (reader.Name.Equals("Header"))
{
item = new HeaderDefinition(name);
}
parent.AddChild(item);
item.IsExcluded = isExcluded;
if (item.IsFolder)
{
ReadSourceItems(reader, item);
}
}
break;
case "IncludeFolder":
ReadIncludeFolder(reader, parent);
break;
default:
throw new NotImplementedException();
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
return;
}
}
}
private Folder EnsureLibraryFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
TraceService.Information((int)LogEventId.ModelProvisionCoreCall, "EnsureLibraryFolder()");
var parentFolder = folderModelHost.CurrentLibraryFolder;
var context = parentFolder.Context;
var currentFolder = GetLibraryFolder(folderModelHost, folderModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentFolder,
ObjectType = typeof(Folder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
if (currentFolder == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new library folder");
currentFolder = parentFolder.Folders.Add(folderModel.Name);
context.ExecuteQueryWithTrace();
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing library folder");
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFolder,
ObjectType = typeof(Folder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
currentFolder.Update();
context.ExecuteQueryWithTrace();
return(currentFolder);
}
private Folder GetListFolder(FolderModelHost folderModelHost, FolderDefinition folderModel,
out string serverRelativeUrl)
{
var list = folderModelHost.CurrentList;
var context = list.Context;
context.Load(list, l => l.RootFolder);
context.Load(list, l => l.ParentWeb);
if (folderModelHost.CurrentListItem != null)
{
context.Load(folderModelHost.CurrentListItem, l => l.Folder);
}
context.ExecuteQuery();
serverRelativeUrl = folderModelHost.CurrentListItem == null
? list.RootFolder.ServerRelativeUrl
: folderModelHost.CurrentListItem.Folder.ServerRelativeUrl;
var currentUrl = serverRelativeUrl + "/" + folderModel.Name;
var currentFolder = folderModelHost.CurrentList.ParentWeb.GetFolderByServerRelativeUrl(currentUrl);
var doesFolderExist = false;
try
{
context.Load(currentFolder, f => f.Name);
context.ExecuteQuery();
doesFolderExist = true;
}
catch (ServerException e)
{
if (e.ServerErrorTypeName == "System.IO.FileNotFoundException")
{
doesFolderExist = false;
}
}
if (doesFolderExist)
{
return(currentFolder);
}
return(null);
}
public void Deploy_ModuleFiles()
{
// Step 1, define security groups
var helloModuleFile = new ModuleFileDefinition
{
FileName = "hello-module.txt",
Content = Encoding.UTF8.GetBytes("A hello world module file provision.")
};
var angularFile = new ModuleFileDefinition
{
FileName = "angular.min.js",
Content = Encoding.UTF8.GetBytes(ResourceReader.ReadFromResourceName("Modules.js.angular.min.js"))
};
var jQueryFile = new ModuleFileDefinition
{
FileName = "jquery-1.11.1.min.js",
Content = Encoding.UTF8.GetBytes(ResourceReader.ReadFromResourceName("Modules.js.jquery-1.11.1.min.js"))
};
var jsFolder = new FolderDefinition {
Name = "spmeta2-custom-js"
};
// deploy web model - list and add content type links to list
var webModel = SPMeta2Model
.NewWebModel(web =>
{
web
.AddList(BuiltInListDefinitions.StyleLibrary, list =>
{
list
.AddModuleFile(helloModuleFile)
.AddFolder(jsFolder, folder =>
{
folder
.AddModuleFile(angularFile)
.AddModuleFile(jQueryFile);
});
});
});
DeployWebModel(webModel);
}
protected virtual void MapFolderProperties(SPListItem item, FolderDefinition definition)
{
if (!string.IsNullOrEmpty(definition.ContentTypeId) ||
!string.IsNullOrEmpty(definition.ContentTypeName))
{
var list = item.ParentList;
if (!string.IsNullOrEmpty(definition.ContentTypeId))
{
item["ContentTypeId"] = ContentTypeLookupService.LookupListContentTypeById(list, definition.ContentTypeId);
}
if (!string.IsNullOrEmpty(definition.ContentTypeName))
{
item["ContentTypeId"] = ContentTypeLookupService.LookupContentTypeByName(list, definition.ContentTypeName);
}
}
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeployModuleFilesToFolders()
{
var cssFile = new ModuleFileDefinition
{
FileName = "m2-red.css",
Overwrite = true,
Content = Encoding.UTF8.GetBytes(".m2-red { color:red; } ")
};
var jsFile = new ModuleFileDefinition
{
FileName = "m2-logger-module.js",
Overwrite = true,
Content = Encoding.UTF8.GetBytes(" function(msg) { console.log(msg); } ")
};
var cssFolder = new FolderDefinition
{
Name = "m2-css"
};
var jsFolder = new FolderDefinition
{
Name = "m2-js"
};
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddHostList(BuiltInListDefinitions.StyleLibrary, list =>
{
list
.AddFolder(cssFolder, folder =>
{
folder.AddModuleFile(cssFile);
})
.AddFolder(jsFolder, folder =>
{
folder.AddModuleFile(jsFile);
});
});
});
DeployModel(model);
}
/// <summary>
/// Reads the giving directory and populates the node with folders/files structure
/// </summary>
/// <param name="hostNode"></param>
/// <param name="folderPath"></param>
/// <param name="shouldIncludeFolderOrFile"></param>
internal static void LoadModuleFilesFromLocalFolder(ModelNode hostNode, string folderPath,
Func <string, bool> shouldIncludeFolderOrFile)
{
var files = Directory.GetFiles(folderPath);
var folders = Directory.GetDirectories(folderPath);
foreach (var file in files)
{
if (shouldIncludeFolderOrFile != null)
{
if (!shouldIncludeFolderOrFile(file))
{
continue;
}
}
hostNode.AddDefinitionNode(new ModuleFileDefinition
{
Content = File.ReadAllBytes(file),
FileName = Path.GetFileName(file),
Overwrite = true
});
}
foreach (var subFolder in folders)
{
var subFolderPath = subFolder;
if (shouldIncludeFolderOrFile != null)
{
if (!shouldIncludeFolderOrFile(subFolderPath))
{
continue;
}
}
var folderDef = new FolderDefinition
{
Name = Path.GetFileName(subFolderPath)
};
hostNode.AddDefinitionNode(folderDef, folderNode => LoadModuleFilesFromLocalFolder(folderNode, subFolderPath, shouldIncludeFolderOrFile));
}
}
private SourceItemDefinition CloneSourceItem(SourceItemDefinition item)
{
if (item == null)
{
return(null);
}
if (_oldToNewMapping.TryGetValue(item, out SourceItemDefinition clone))
{
return(clone);
}
if (item is HeaderDefinition)
{
clone = new HeaderDefinition(item.Name);
}
else if (item is FolderDefinition)
{
clone = new FolderDefinition(item.Name);
}
else if (item is RootFolderDefinition)
{
clone = new RootFolderDefinition(item.Name);
RootFolderClone = RootFolderClone ?? clone as RootFolderDefinition;
}
else
{
throw new NotSupportedException();
}
_oldToNewMapping[item] = clone;
clone.Parent = CloneSourceItem(item.Parent);
foreach (SourceItemDefinition child in item.Children.Where(c => !c.IsExcluded))
{
var childClone = CloneSourceItem(child);
clone.Children.Add(childClone);
}
return(clone);
}
private Folder EnsureLibraryFolder(FolderModelHost folderModelHost, FolderDefinition folderModel)
{
var parentFolder = folderModelHost.CurrentLibraryFolder;
var context = parentFolder.Context;
var currentFolder = GetLibraryFolder(folderModelHost, folderModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentFolder,
ObjectType = typeof(Folder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
if (currentFolder == null)
{
currentFolder = parentFolder.Folders.Add(folderModel.Name);
context.ExecuteQuery();
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFolder,
ObjectType = typeof(Folder),
ObjectDefinition = folderModel,
ModelHost = folderModelHost
});
currentFolder.Update();
context.ExecuteQuery();
return(currentFolder);
}
