protected string ResolveContentTypeId(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
var context = folderHost.CurrentLibraryFolder.Context;
var list = folderHost.CurrentList;
var stringCustomContentType = string.Empty;
// preload custm content type
if (!string.IsNullOrEmpty(moduleFile.ContentTypeName))
{
var listContentTypes = list.ContentTypes;
context.Load(listContentTypes);
context.ExecuteQueryWithTrace();
var listContentType = listContentTypes.ToList()
.FirstOrDefault(c => c.Name.ToUpper() == moduleFile.ContentTypeName.ToUpper());
if (listContentType == null)
{
throw new ArgumentNullException(
string.Format("Cannot find content type with Name:[{0}] in List:[{1}]",
new string[]
{
moduleFile.ContentTypeName,
list.Title
}));
}
stringCustomContentType = listContentType.Id.ToString();
}
return(stringCustomContentType);
}
protected File GetFile(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
Folder folder = null;
if (folderHost.CurrentList != null)
{
folder = folderHost.CurrentListFolder;
}
else if (folderHost.CurrentContentType != null)
{
folder = folderHost.CurrentContentTypeFolder;
}
else if (folderHost.CurrentWebFolder != null)
{
folder = folderHost.CurrentWebFolder;
}
var web = folderHost.HostWeb;
var context = web.Context;
var file = web.GetFileByServerRelativeUrl(GetSafeFileUrl(folder, moduleFile));
context.Load(file, f => f.Exists);
context.ExecuteQueryWithTrace();
return(file);
}
private string GetSafeFileUrl(SPFolder folder, ModuleFileDefinition moduleFile)
{
if (folder.ServerRelativeUrl != "/")
return folder.ServerRelativeUrl + "/" + moduleFile.FileName;
return moduleFile.FileName;
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeployModuleFilesToStyleLibrary()
{
var cssFile = new ModuleFileDefinition
{
FileName = "m2-styles.css",
Overwrite = true,
Content = Encoding.UTF8.GetBytes(".m2-content { padding:10px; border:1px red solid; } ")
};
var jsFile = new ModuleFileDefinition
{
FileName = "m2-app.js",
Overwrite = true,
Content = Encoding.UTF8.GetBytes(" alert('hello, m2!'); ")
};
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddHostList(BuiltInListDefinitions.StyleLibrary, list =>
{
list
.AddModuleFile(cssFile)
.AddModuleFile(jsFile);
});
});
DeployModel(model);
}
private void EnsureDefaultValues(SPListItem newFileItem, ModuleFileDefinition definition)
{
foreach (var defaultValue in definition.DefaultValues)
{
if (!string.IsNullOrEmpty(defaultValue.FieldName))
{
if (newFileItem.Fields.ContainsFieldWithStaticName(defaultValue.FieldName))
{
if (newFileItem[defaultValue.FieldName] == null)
{
newFileItem[defaultValue.FieldName] = defaultValue.Value;
}
}
}
else if (defaultValue.FieldId.HasValue && defaultValue.FieldId != default(Guid))
{
if (newFileItem.Fields.OfType <SPField>().Any(f => f.Id == defaultValue.FieldId.Value))
{
if (newFileItem[defaultValue.FieldId.Value] == null)
{
newFileItem[defaultValue.FieldId.Value] = defaultValue.Value;
}
}
}
}
}
//[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 string GetSafeFileUrl(SPFolder folder, ModuleFileDefinition moduleFile)
{
var result = moduleFile.FileName;
if (folder.ServerRelativeUrl != "/")
{
result = UrlUtility.CombineUrl(folder.ServerRelativeUrl, moduleFile.FileName);
}
result = result.Replace("//", "/");
return(result);
}
protected SPFile GetFile(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
if (folderHost.CurrentWebFolder != null)
return folderHost.CurrentWebFolder.ParentWeb.GetFile(GetSafeFileUrl(folderHost.CurrentWebFolder, moduleFile));
if (folderHost.CurrentContentType != null)
return folderHost.CurrentContentTypeFolder.ParentWeb.GetFile(GetSafeFileUrl(folderHost.CurrentContentTypeFolder, moduleFile));
if (folderHost.CurrentLibraryFolder != null)
return folderHost.CurrentLibraryFolder.ParentWeb.GetFile(GetSafeFileUrl(folderHost.CurrentLibraryFolder, moduleFile));
throw new ArgumentException("CurrentWebFolder/CurrentContentType/CurrentLibraryFolder should not be null");
}
private void ProcessContentTypeModuleFile(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
var folder = folderHost.CurrentContentTypeFolder;
var currentFile = folder.ParentWeb.GetFile(GetSafeFileUrl(folder, moduleFile));
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentFile.Exists ? currentFile : null,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = folderHost
});
if (moduleFile.Overwrite)
{
var file = folder.Files.Add(moduleFile.FileName, moduleFile.Content, moduleFile.Overwrite);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = file,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = folderHost
});
}
else
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFile.Exists ? currentFile : null,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = folderHost
});
}
folder.Update();
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploContentEditorWebpartWithUrlLink()
{
var htmlContent = new ModuleFileDefinition
{
FileName = "m2-cewp-content.html",
Content = Encoding.UTF8.GetBytes("M2 is everything you need to deploy stuff to Sharepoint"),
Overwrite = true,
};
var cewp = new ContentEditorWebPartDefinition
{
Title = "Content Editor Webpart with URL link",
Id = "m2ContentLinkCEWP",
ZoneIndex = 20,
ZoneId = "Main",
ContentLink = UrlUtility.CombineUrl(new string[] {
"~sitecollection",
BuiltInListDefinitions.StyleLibrary.GetListUrl(),
htmlContent.FileName
})
};
var webPartPage = new WebPartPageDefinition
{
Title = "M2 CEWP provision",
FileName = "cewp-provision.aspx",
PageLayoutTemplate = BuiltInWebPartPageTemplates.spstd1
};
var model = SPMeta2Model.NewWebModel(web =>
{
web
.AddHostList(BuiltInListDefinitions.StyleLibrary, list =>
{
list.AddModuleFile(htmlContent);
})
.AddHostList(BuiltInListDefinitions.SitePages, list =>
{
list.AddWebPartPage(webPartPage, page =>
{
page.AddContentEditorWebPart(cewp);
});
});
});
DeployModel(model);
}
protected string ResolveContentTypeId(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
var context = folderHost.CurrentListFolder.Context;
var list = folderHost.CurrentList;
var stringCustomContentType = string.Empty;
if (!string.IsNullOrEmpty(moduleFile.ContentTypeId))
{
stringCustomContentType = moduleFile.ContentTypeId;
}
else if (!string.IsNullOrEmpty(moduleFile.ContentTypeName))
{
stringCustomContentType = ContentTypeLookupService.LookupContentTypeByName(list, moduleFile.ContentTypeName).Id.ToString();
}
return(stringCustomContentType);
}
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);
}
//[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);
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var item = (reverseHost as ModuleFileReverseHost).HostFile;
var context = (reverseHost as ModuleFileReverseHost).HostClientContext;
var def = new ModuleFileDefinition();
def.FileName = item.Name;
using (var stream = File.OpenBinaryDirect(
context,
item.ServerRelativeUrl).Stream)
{
def.Content = ModuleFileUtils.ReadFully(stream);
}
return(new ModuleFileModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
private void ProcessFile(
object modelHost,
SPFolder folder, ModuleFileDefinition moduleFile)
{
DeployModuleFile(
folder,
GetSafeFileUrl(folder, moduleFile),
moduleFile.FileName,
moduleFile.Content,
moduleFile.Overwrite,
before =>
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = before.Exists ? before : null,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = modelHost
});
},
after =>
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = after,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = modelHost
});
});
}
private static void EnsureDefaultValues(ListItem newFileItem, ModuleFileDefinition publishingPageModel)
{
foreach (var defaultValue in publishingPageModel.DefaultValues)
{
if (!string.IsNullOrEmpty(defaultValue.FieldName))
{
if (newFileItem.FieldValues.ContainsKey(defaultValue.FieldName))
{
if (newFileItem[defaultValue.FieldName] == null)
{
newFileItem[defaultValue.FieldName] = defaultValue.Value;
}
}
else
{
newFileItem[defaultValue.FieldName] = defaultValue.Value;
}
}
else if (defaultValue.FieldId.HasValue && defaultValue.FieldId != default(Guid))
{
// unsupported by CSOM API yet
}
}
}
public static TModelNode AddModuleFile <TModelNode>(this TModelNode model, ModuleFileDefinition definition,
Action <ModuleFileModelNode> action)
where TModelNode : ModelNode, IModuleFileHostModelNode, new()
{
return(model.AddTypedDefinitionNode(definition, action));
}
private void ProcessFile(
object modelHost,
SPFolder folder,
ModuleFileDefinition moduleFile)
{
DeployModuleFile(
folder,
GetSafeFileUrl(folder, moduleFile),
moduleFile.FileName,
moduleFile.Content,
moduleFile.Overwrite,
before =>
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = before.Exists ? before : null,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = modelHost
});
},
after =>
{
if (!string.IsNullOrEmpty(moduleFile.ContentTypeId) ||
!string.IsNullOrEmpty(moduleFile.ContentTypeName))
{
var list = folder.ParentWeb.Lists[folder.ParentListId];
if (!string.IsNullOrEmpty(moduleFile.ContentTypeId))
{
after.ListItemAllFields["ContentTypeId"] = LookupListContentTypeById(list, moduleFile.ContentTypeId);
}
if (!string.IsNullOrEmpty(moduleFile.ContentTypeName))
{
after.ListItemAllFields["ContentTypeId"] = LookupListContentTypeByName(list, moduleFile.ContentTypeName);
}
after.ListItemAllFields.Update();
}
if (moduleFile.DefaultValues.Count > 0)
{
EnsureDefaultValues(after.ListItemAllFields, moduleFile);
after.ListItemAllFields.Update();
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = after,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = modelHost
});
});
}
private string GetSafeFileUrl(SPFolder folder, ModuleFileDefinition moduleFile)
{
return(folder.ServerRelativeUrl + "/" + moduleFile.FileName);
}
private void ProcessWebModuleFile(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
throw new SPMeta2NotImplementedException("Module provision under web folders is not implemented yet.");
}
private void ProcessFile(
object modelHost,
SPFolder folder, ModuleFileDefinition moduleFile)
{
var web = folder.ParentWeb;
var list = folder.DocumentLibrary;
var file = web.GetFile(GetSafeFileUrl(folder, moduleFile));
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = file.Exists ? file : null,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = modelHost
});
var fileName = moduleFile.FileName;
var fileContent = moduleFile.Content;
// for file deployment to the folder, root web folder or under _cts or other spccial folders
// list == null
// big todo with correct update and punblishing
// get prev SPMeta2 impl for publishing pages
if (list != null && (file.Exists && file.CheckOutType != SPFile.SPCheckOutType.None))
{
file.UndoCheckOut();
}
if (list != null && (list.EnableMinorVersions && file.Exists && file.Level == SPFileLevel.Published))
{
file.UnPublish("Provision");
}
if (list != null && (file.Exists && file.CheckOutType == SPFile.SPCheckOutType.None))
{
file.CheckOut();
}
var spFile = folder.Files.Add(fileName, fileContent, file.Exists);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = spFile,
ObjectType = typeof(SPFile),
ObjectDefinition = moduleFile,
ModelHost = modelHost
});
spFile.Update();
if (list != null && (file.Exists && file.CheckOutType != SPFile.SPCheckOutType.None))
{
spFile.CheckIn("Provision");
}
if (list != null && (list.EnableMinorVersions || list.EnableVersioning))
{
spFile.Publish("Provision");
}
if (list != null && list.EnableModeration)
{
spFile.Approve("Provision");
}
}
public static TModelNode AddHostModuleFile <TModelNode>(this TModelNode model, ModuleFileDefinition definition,
Action <ModuleFileModelNode> action)
where TModelNode : ModelNode, IModuleFileHostModelNode, new()
{
return(model.AddTypedDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing()));
}
private void ProcessContentTypeFolder(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
var web = folderHost.HostWeb;
var folder = folderHost.CurrentContentTypeFolder;
var context = web.Context;
if (!folder.IsPropertyAvailable("ServerRelativeUrl"))
{
context.Load(folder, f => f.ServerRelativeUrl);
context.ExecuteQueryWithTrace();
}
var currentFile = web.GetFileByServerRelativeUrl(GetSafeFileUrl(folder, moduleFile));
context.Load(currentFile, f => f.Exists);
context.ExecuteQuery();
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentFile.Exists ? currentFile : null,
ObjectType = typeof(File),
ObjectDefinition = moduleFile,
ModelHost = folderHost
});
if (moduleFile.Overwrite)
{
var fileCreatingInfo = new FileCreationInformation
{
Url = moduleFile.FileName,
Overwrite = true
};
if (moduleFile.Content.Length < ContentStreamFileSize)
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Using fileCreatingInfo.Content for small file less than: [{0}]", ContentStreamFileSize);
fileCreatingInfo.Content = moduleFile.Content;
}
else
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Using fileCreatingInfo.ContentStream for big file more than: [{0}]", ContentStreamFileSize);
fileCreatingInfo.ContentStream = new System.IO.MemoryStream(moduleFile.Content);
}
var file = folder.Files.Add(fileCreatingInfo);
folder.Context.ExecuteQuery();
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = file,
ObjectType = typeof(File),
ObjectDefinition = moduleFile,
ModelHost = folderHost
});
}
else
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentFile.Exists ? currentFile : null,
ObjectType = typeof(File),
ObjectDefinition = moduleFile,
ModelHost = folderHost
});
}
folder.Update();
folder.Context.ExecuteQueryWithTrace();
}
private void ProcessWebFolder(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
throw new NotImplementedException();
}
private File ProcessFile(FolderModelHost folderHost, ModuleFileDefinition moduleFile)
{
var context = folderHost.CurrentLibraryFolder.Context;
var web = folderHost.CurrentWeb;
var list = folderHost.CurrentList;
var folder = folderHost.CurrentLibraryFolder;
context.Load(folder, f => f.ServerRelativeUrl);
context.ExecuteQueryWithTrace();
var stringCustomContentType = ResolveContentTypeId(folderHost, moduleFile);
if (list != null)
{
context.Load(list, l => l.EnableMinorVersions);
context.Load(list, l => l.EnableVersioning);
context.Load(list, l => l.EnableModeration);
context.ExecuteQueryWithTrace();
}
var file = web.GetFileByServerRelativeUrl(GetSafeFileUrl(folder, moduleFile));
context.Load(file, f => f.Exists);
context.ExecuteQueryWithTrace();
InvokeOnModelEvent <ModuleFileDefinition, File>(file, ModelEventType.OnUpdating);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = file.Exists ? file : null,
ObjectType = typeof(File),
ObjectDefinition = moduleFile,
ModelHost = folderHost
});
WithSafeFileOperation(list, file, f =>
{
var fileName = moduleFile.FileName;
var fileContent = moduleFile.Content;
var fileCreatingInfo = new FileCreationInformation
{
Url = fileName,
Overwrite = file.Exists
};
if (fileContent.Length < ContentStreamFileSize)
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Using fileCreatingInfo.Content for small file less than: [{0}]", ContentStreamFileSize);
fileCreatingInfo.Content = fileContent;
}
else
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Using fileCreatingInfo.ContentStream for big file more than: [{0}]", ContentStreamFileSize);
fileCreatingInfo.ContentStream = new System.IO.MemoryStream(fileContent);
}
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Overwriting file");
var updatedFile = folder.Files.Add(fileCreatingInfo);
var newFileItem = updatedFile.ListItemAllFields;
//context.Load(newFileItem);
//context.ExecuteQueryWithTrace();
if (!string.IsNullOrEmpty(stringCustomContentType))
{
newFileItem[BuiltInInternalFieldNames.ContentTypeId] = stringCustomContentType;
}
if (moduleFile.DefaultValues.Count > 0)
{
EnsureDefaultValues(newFileItem, moduleFile);
}
if (!string.IsNullOrEmpty(stringCustomContentType) || moduleFile.DefaultValues.Count > 0)
{
newFileItem.Update();
}
return(updatedFile);
});
var resultFile = web.GetFileByServerRelativeUrl(GetSafeFileUrl(folder, moduleFile));
context.Load(resultFile, f => f.Exists);
context.ExecuteQueryWithTrace();
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = resultFile,
ObjectType = typeof(File),
ObjectDefinition = moduleFile,
ModelHost = folderHost
});
InvokeOnModelEvent <ModuleFileDefinition, File>(resultFile, ModelEventType.OnUpdated);
return(resultFile);
}
private File ProcessFile(FolderModelHost folderHost, ModuleFileDefinition definition)
{
var context = folderHost.CurrentListFolder.Context;
var web = folderHost.CurrentWeb;
var list = folderHost.CurrentList;
var folder = folderHost.CurrentListFolder;
context.Load(folder, f => f.ServerRelativeUrl);
#if !NET35
context.Load(folder, f => f.Properties);
#endif
context.ExecuteQueryWithTrace();
var stringCustomContentType = ResolveContentTypeId(folderHost, definition);
if (list != null)
{
context.Load(list, l => l.EnableMinorVersions);
context.Load(list, l => l.EnableVersioning);
context.Load(list, l => l.EnableModeration);
context.ExecuteQueryWithTrace();
}
var file = web.GetFileByServerRelativeUrl(GetSafeFileUrl(folder, definition));
context.Load(file, f => f.Exists);
context.ExecuteQueryWithTrace();
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = file.Exists ? file : null,
ObjectType = typeof(File),
ObjectDefinition = definition,
ModelHost = folderHost
});
#if !NET35
var doesFileHasListItem =
//Forms folders
!(folder != null
&&
(folder.Properties.FieldValues.ContainsKey("vti_winfileattribs") &&
folder.Properties.FieldValues["vti_winfileattribs"].ToString() == "00000012"));
#endif
#if NET35
var doesFileHasListItem = true;
#endif
WithSafeFileOperation(list, file, f =>
{
var fileName = definition.FileName;
var fileContent = definition.Content;
var fileCreatingInfo = new FileCreationInformation
{
Url = fileName,
Overwrite = file.Exists
};
if (fileContent.Length < ContentStreamFileSize)
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Using fileCreatingInfo.Content for small file less than: [{0}]", ContentStreamFileSize);
fileCreatingInfo.Content = fileContent;
}
else
{
#if NET35
throw new SPMeta2Exception(string.Format("SP2010 CSOM implementation does no support file more than {0}. Checkout FileCreationInformation and avialabe Content size.", ContentStreamFileSize));
#endif
#if !NET35
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Using fileCreatingInfo.ContentStream for big file more than: [{0}]", ContentStreamFileSize);
fileCreatingInfo.ContentStream = new System.IO.MemoryStream(fileContent);
#endif
}
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Overwriting file");
var updatedFile = folder.Files.Add(fileCreatingInfo);
FieldLookupService.EnsureDefaultValues(updatedFile.ListItemAllFields, definition.DefaultValues);
if (!string.IsNullOrEmpty(stringCustomContentType))
{
updatedFile.ListItemAllFields[BuiltInInternalFieldNames.ContentTypeId] = stringCustomContentType;
}
if (!string.IsNullOrEmpty(definition.Title))
{
updatedFile.ListItemAllFields[BuiltInInternalFieldNames.Title] = definition.Title;
}
FieldLookupService.EnsureValues(updatedFile.ListItemAllFields, definition.Values, true);
if (!string.IsNullOrEmpty(stringCustomContentType) ||
definition.DefaultValues.Count > 0 ||
definition.Values.Count > 0 ||
!string.IsNullOrEmpty(definition.Title))
{
updatedFile.ListItemAllFields.Update();
}
return(updatedFile);
}, doesFileHasListItem);
var resultFile = web.GetFileByServerRelativeUrl(GetSafeFileUrl(folder, definition));
context.Load(resultFile, f => f.Exists);
context.ExecuteQueryWithTrace();
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = resultFile,
ObjectType = typeof(File),
ObjectDefinition = definition,
ModelHost = folderHost
});
return(resultFile);
}
private string GetSafeFileUrl(Folder folder, ModuleFileDefinition moduleFile)
{
return(UrlUtility.CombineUrl(folder.ServerRelativeUrl, moduleFile.FileName));
}
public static ModelNode AddHostModuleFile(this ModelNode model, ModuleFileDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing()));
}
public static ModelNode AddHostModuleFile(this ModelNode model, ModuleFileDefinition definition)
{
return(AddHostModuleFile(model, definition, null));
}
public static TModelNode AddModuleFile <TModelNode>(this TModelNode model, ModuleFileDefinition definition)
where TModelNode : ModelNode, IModuleFileHostModelNode, new()
{
return(AddModuleFile(model, definition, null));
}
