public static void DeployModuleFile(SPFolder folder,
string fileUrl,
string fileName,
byte[] fileContent,
bool overwrite,
Action<SPFile> beforeProvision,
Action<SPFile> afterProvision)
{
// doc libs
SPList list = folder.DocumentLibrary;
// fallback for the lists assuming deployment to Forms or other places
if (list == null)
{
list = folder.ParentWeb.Lists[folder.ParentListId];
}
WithSafeFileOperation(list, folder, fileUrl, fileName, fileContent,
overwrite,
onBeforeFile =>
{
if (beforeProvision != null)
beforeProvision(onBeforeFile);
},
onActionFile =>
{
if (afterProvision != null)
afterProvision(onActionFile);
});
}
private static bool ProcessAllSubFolders(SPFolder Folder, bool recursive, Func<SPFolder, bool> methodToCall)
{
IList<SPFolder> subFolders = Folder.SubFolders.Cast<SPFolder>().ToList<SPFolder>();
foreach (SPFolder subFolder in subFolders)
{
//Loop through all sub webs recursively
bool bContinue;
bContinue = methodToCall.Invoke(subFolder);
if (!bContinue)
return false;
if (recursive && subFolder.Exists)
{
bContinue = ProcessAllSubFolders(subFolder, recursive, methodToCall);
if (!bContinue)
return false;
}
}
return true;
}
public CopyFolderCommand(SPFolder sourceFolder, string newUrl, string contentTypeId, SPWeb web)
: base(web)
{
_NewUrl = newUrl;
_SourceFolder = sourceFolder;
_ContentTypeId = contentTypeId;
}
private void DeployWelcomePage(object modelHost, DefinitionBase model, SPFolder folder, WelcomePageDefinition welcomePgaeModel)
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = folder,
ObjectType = typeof(SPFolder),
ObjectDefinition = welcomePgaeModel,
ModelHost = modelHost
});
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Changing welcome page to: [{0}]", welcomePgaeModel.Url);
// https://github.com/SubPointSolutions/spmeta2/issues/431
folder.WelcomePage = UrlUtility.RemoveStartingSlash(welcomePgaeModel.Url);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = folder,
ObjectType = typeof(SPFolder),
ObjectDefinition = welcomePgaeModel,
ModelHost = modelHost
});
folder.Update();
}
protected void LoadFolderNodes(SPFolder folder, TreeNode folderNode)
{
foreach (SPFolder childFolder in folder.SubFolders)
{
TreeNode childFolderNode = new TreeNode(childFolder.Name, childFolder.Name, FOLDER_IMG);
childFolderNode.NavigateUrl = SPContext.Current.Site.MakeFullUrl(childFolder.Url);
LoadFolderNodes(childFolder, childFolderNode);
folderNode.ChildNodes.Add(childFolderNode);
}
foreach (SPFile file in folder.Files)
{
TreeNode fileNode;
if (file.CustomizedPageStatus == SPCustomizedPageStatus.Uncustomized)
{
fileNode = new TreeNode(file.Name, file.Name, GHOSTED_FILE_IMG);
}
else
{
fileNode = new TreeNode(file.Name, file.Name, UNGHOSTED_FILE_IMG);
}
fileNode.NavigateUrl = SPContext.Current.Site.MakeFullUrl(file.Url);
folderNode.ChildNodes.Add(fileNode);
}
}
/// <summary>
/// Checks the folders for unghosted files.
/// </summary>
/// <param name="folder">The folder.</param>
/// <param name="unghostedFiles">The unghosted files.</param>
internal static void CheckFoldersForUnghostedFiles(SPFolder folder, ref List<object> unghostedFiles, bool asString)
{
foreach (SPFolder sub in folder.SubFolders)
{
CheckFoldersForUnghostedFiles(sub, ref unghostedFiles, asString);
}
foreach (SPFile file in folder.Files)
{
if (file.CustomizedPageStatus == SPCustomizedPageStatus.Customized)
{
if (asString)
{
string url = file.Web.Site.MakeFullUrl(file.ServerRelativeUrl);
if (!unghostedFiles.Contains(url))
unghostedFiles.Add(url);
}
else
{
if (!unghostedFiles.Contains(file))
unghostedFiles.Add(file);
}
}
}
}
public void GetPendingFiles()
{
SPListItemCollection items = null;
using (SPSite site = new SPSite("http://kamlesh-lt:2013"))
{
using (SPWeb web = site.OpenWeb())
{
try
{
SPList list = web.Lists["BulkUpload"];
fldErrorLogs = web.Folders["ErrorLogs"];
SPQuery query = new SPQuery();
query.Query = "<Where><Eq><FieldRef Name=\"Status\" /><Value Type=\"Choice\">Pending</Value></Eq></Where>";
query.ViewAttributes = "Scope='Recursive'";
items = list.GetItems(query);
for (int i = 0; i < items.Count; i++)
{
this.ProcessFile(items[i]);
}
}
catch (Exception ex)
{
throw ex;
}
}
}
}
public static SPFile GetFile(SPFolder folder, string relativeFilePath)
{
var currentFolder = folder;
var parts = relativeFilePath.Split('/');
var pathFolders = parts.Take(parts.Length - 1);
var fileName = parts.Last();
try
{
foreach (var folderName in pathFolders)
{
if (folderName == "..")
currentFolder = currentFolder.ParentFolder;
else
currentFolder = currentFolder.SubFolders.OfType<SPFolder>().FirstOrDefault(f => f.Name == folderName);
if (currentFolder == null || !currentFolder.Exists)
return null;
}
}
catch (Exception exception)
{
var message = String.Format("Error on FileUtilities#GetFile for parameters \"{0}\", \"{1}\"\n{2}",
folder.ServerRelativeUrl, relativeFilePath, exception);
SPMinLoggingService.LogError(message, TraceSeverity.Unexpected);
return null;
}
return currentFolder.Files.OfType<SPFile>().FirstOrDefault(f => f.Name == fileName);
}
private static string CheckPathAndCreate(string strExportPath, SPFolder folder)
{
string strPath;
strPath = string.Format("{0}\\{1}", strExportPath, folder.Url.Replace("/", "\\"));
//strPath = "d:\\Export\\IT\\IT\\Project\\Phase 2 - Rel 1 Implementation\\90-Team Folder\\Difei\\ARS\\ARS global documents\\FY06 ARS Process Model\\6 - Enterprise Management\\6.01 - Master Data Maintenance - Retail Organization\\6.1.03 CMD Company Code and Purchase Organiz\\test";
if (!Directory.Exists(strPath))
{
try
{
//if (strPath.ToCharArray().Length < 248)
//{
Directory.CreateDirectory(strPath);
//}
}
catch (PathTooLongException pathTooLongException) {
LogInfoToRecordFile(InfoLogUNCPath, string.Format("The specific folder <{0}> path {1} is too long!",
folder.Url,
strPath));
strPath = null;
}
}
return strPath;
}
protected void update_folder_time(SPFolder current_folder)
{
if (current_folder == null || !current_folder.Url.Contains("/")) return;
current_folder.SetProperty("Name", current_folder.Name);
current_folder.Update();
update_folder_time(current_folder.ParentFolder);
}
public FileContentParser(SPFile file)
{
this.mainFile = file;
this.parentFolder = file.ParentFolder;
this.mainContent = GetContent(mainFile);
IncludedFiles = FileInclusionParser.GetIncludedFiles(mainContent);
}
private void DeployContentTypeOrder(object modelHost, SPList list, SPFolder folder, UniqueContentTypeOrderDefinition contentTypeOrderDefinition)
{
var oldContentTypeOrder = folder.ContentTypeOrder;
var newContentTypeOrder = new List<SPContentType>();
var listContentTypes = list.ContentTypes.OfType<SPContentType>().ToList();
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = folder,
ObjectType = typeof(SPFolder),
ObjectDefinition = contentTypeOrderDefinition,
ModelHost = modelHost
});
// re-order
foreach (var srcContentTypeDef in contentTypeOrderDefinition.ContentTypes)
{
SPContentType listContentType = null;
if (!string.IsNullOrEmpty(srcContentTypeDef.ContentTypeName))
listContentType = listContentTypes.FirstOrDefault(c => c.Name == srcContentTypeDef.ContentTypeName);
if (listContentType == null && !string.IsNullOrEmpty(srcContentTypeDef.ContentTypeId))
listContentType = listContentTypes.FirstOrDefault(c => c.Id.ToString().ToUpper().StartsWith(srcContentTypeDef.ContentTypeId.ToUpper()));
if (listContentType != null && !newContentTypeOrder.Contains(listContentType))
newContentTypeOrder.Add(listContentType);
}
// filling up gapes
foreach (var oldCt in oldContentTypeOrder)
{
if (newContentTypeOrder.Count(c =>
c.Name == oldCt.Name ||
c.Id.ToString().ToUpper().StartsWith(oldCt.Id.ToString().ToUpper())) == 0)
newContentTypeOrder.Add(oldCt);
}
if (newContentTypeOrder.Count() > 0)
folder.UniqueContentTypeOrder = newContentTypeOrder;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = folder,
ObjectType = typeof(SPFolder),
ObjectDefinition = contentTypeOrderDefinition,
ModelHost = modelHost
});
folder.Update();
}
public MoveFolderCommand(SPFolder folder, string newUrl, string contentTypeId, SPWeb web)
: base(web)
{
_NewUrl = newUrl;
_Folder = folder;
_Item = _Folder.Item;
_OldUrl = string.Format("{0}/{1}", _SPWeb.Url, _Folder.Url);
_ContentTypeId = contentTypeId;
}
public SPListItem CopyItem(SPListItem sourceItem, SPFolder destinationFolder)
{
SPListItem copiedItem = null;
try
{
var destinationList = destinationFolder.ParentWeb.Lists[destinationFolder.ParentListId];
if (destinationFolder.Item == null)
{
copiedItem = destinationList.Items.Add();
}
else
{
copiedItem = destinationFolder.Item.ListItems.Add(
destinationFolder.ServerRelativeUrl,
sourceItem.FileSystemObjectType);
}
foreach (string fileName in sourceItem.Attachments)
{
SPFile file = sourceItem.ParentList.ParentWeb.GetFile(sourceItem.Attachments.UrlPrefix + fileName);
byte[] data = file.OpenBinary();
copiedItem.Attachments.Add(fileName, data);
}
for (int i = sourceItem.Versions.Count - 1; i >= 0; i--)
{
foreach (SPField destinationField in destinationList.Fields)
{
SPListItemVersion version = sourceItem.Versions[i];
if (!version.Fields.ContainsField(destinationField.InternalName))
continue;
if ((!destinationField.ReadOnlyField) && (destinationField.Type != SPFieldType.Attachments) && !destinationField.Hidden
|| destinationField.Id == SPBuiltInFieldId.Author || destinationField.Id == SPBuiltInFieldId.Created
|| destinationField.Id == SPBuiltInFieldId.Editor || destinationField.Id == SPBuiltInFieldId.Modified)
{
if (destinationField.Type == SPFieldType.DateTime)
{
var dtObj = version[destinationField.InternalName];
copiedItem[destinationField.InternalName] = dtObj != null ?
(object)destinationList.ParentWeb.RegionalSettings.TimeZone.UTCToLocalTime((DateTime)dtObj) : null;
}
else copiedItem[destinationField.Id] = version[destinationField.InternalName];
}
}
copiedItem.Update();
}
copiedItem[SPBuiltInFieldId.ContentTypeId] = sourceItem[SPBuiltInFieldId.ContentTypeId];
copiedItem.SystemUpdate(false);
}
catch (Exception e)
{}
return copiedItem;
}
private void DeployPublishingPage(object modelHost, SPList list, SPFolder folder, PublishingPageLayoutDefinition definition)
{
var web = list.ParentWeb;
var targetPage = GetCurrentObject(folder, definition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = targetPage == null ? null : targetPage.File,
ObjectType = typeof(SPFile),
ObjectDefinition = definition,
ModelHost = modelHost
});
if (targetPage == null)
targetPage = CreateObject(modelHost, folder, definition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = targetPage.File,
ObjectType = typeof(SPFile),
ObjectDefinition = definition,
ModelHost = modelHost
});
ModuleFileModelHandler.WithSafeFileOperation(list, folder,
targetPage.Url,
GetSafePageFileName(definition),
Encoding.UTF8.GetBytes(definition.Content),
definition.NeedOverride,
null,
afterFile =>
{
var pageItem = afterFile.Properties;
pageItem["vti_title"] = definition.Title;
pageItem["MasterPageDescription"] = definition.Description;
pageItem[BuiltInInternalFieldNames.ContentTypeId] = BuiltInPublishingContentTypeId.PageLayout;
if (!string.IsNullOrEmpty(definition.AssociatedContentTypeId))
{
var siteContentType = web.AvailableContentTypes[new SPContentTypeId(definition.AssociatedContentTypeId)];
pageItem["PublishingAssociatedContentType"] = String.Format(";#{0};#{1};#",
siteContentType.Name,
siteContentType.Id.ToString());
}
});
}
private void DeployHideContentTypeLinks(object modelHost, SPList list, SPFolder folder, HideContentTypeLinksDefinition contentTypeOrderDefinition)
{
var oldContentTypeOrder = folder.ContentTypeOrder;
var newContentTypeOrder = oldContentTypeOrder;
var listContentTypes = list.ContentTypes.OfType<SPContentType>().ToList();
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = folder,
ObjectType = typeof(SPFolder),
ObjectDefinition = contentTypeOrderDefinition,
ModelHost = modelHost
});
// re-order
foreach (var srcContentTypeDef in contentTypeOrderDefinition.ContentTypes)
{
SPContentType listContentType = null;
if (!string.IsNullOrEmpty(srcContentTypeDef.ContentTypeName))
listContentType = listContentTypes.FirstOrDefault(c => c.Name == srcContentTypeDef.ContentTypeName);
if (listContentType == null && !string.IsNullOrEmpty(srcContentTypeDef.ContentTypeId))
listContentType = listContentTypes.FirstOrDefault(c => c.Id.ToString().ToUpper().StartsWith(srcContentTypeDef.ContentTypeId.ToUpper()));
if (listContentType != null)
{
var existingCt = newContentTypeOrder.FirstOrDefault(ct => ct.Name == listContentType.Name || ct.Id == listContentType.Id);
if (existingCt != null && newContentTypeOrder.Contains(existingCt))
newContentTypeOrder.Remove(existingCt);
}
}
if (newContentTypeOrder.Count() > 0)
folder.UniqueContentTypeOrder = newContentTypeOrder;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = folder,
ObjectType = typeof(SPFolder),
ObjectDefinition = contentTypeOrderDefinition,
ModelHost = modelHost
});
folder.Update();
}
private void DeployInternall(SPList list, SPFolder folder, ListItemDefinition listItemModel)
{
if (IsDocumentLibray(list))
{
TraceService.Error((int)LogEventId.ModelProvisionCoreCall, "Please use ModuleFileDefinition to deploy files to the document libraries. Throwing SPMeta2NotImplementedException");
throw new SPMeta2NotImplementedException("Please use ModuleFileDefinition to deploy files to the document libraries");
}
EnsureListItem(list, folder, listItemModel);
}
public static void WithSafeFileOperation(
SPList list,
SPFolder folder,
string fileUrl,
string fileName,
byte[] fileContent,
bool overide,
Action<SPFile> onBeforeAction,
Action<SPFile> onAction)
{
var file = list.ParentWeb.GetFile(fileUrl);
if (onBeforeAction != null)
onBeforeAction(file);
// are we inside ocument libary, so that check in stuff is needed?
var isDocumentLibrary = list != null && list.BaseType == SPBaseType.DocumentLibrary;
if (isDocumentLibrary)
{
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();
}
SPFile newFile;
if (overide)
newFile = folder.Files.Add(fileName, fileContent, file.Exists);
else
newFile = file;
if (onAction != null)
onAction(newFile);
newFile.Update();
if (isDocumentLibrary)
{
if (list != null && (file.Exists && file.CheckOutType != SPFile.SPCheckOutType.None))
newFile.CheckIn("Provision");
if (list != null && (list.EnableMinorVersions))
newFile.Publish("Provision");
if (list != null && list.EnableModeration)
newFile.Approve("Provision");
}
}
private bool DoesFolderExist(SPFolder parentFolder, string folderName)
{
if(string.IsNullOrEmpty(folderName))
{
throw new ArgumentException("folderName");
}
var folderCollection = parentFolder.SubFolders;
var exists = FolderExistsImplementation(folderCollection, folderName);
return exists;
}
public SPFile AddDocumentLink(SPWeb web, SPFolder targetFolder, string documentPath, string documentName, string documentUrl)
{
web.RequireNotNull("web");
targetFolder.RequireNotNull("targetFolder");
documentPath.RequireNotNullOrEmpty("documentPath");
documentName.RequireNotNullOrEmpty("documentName");
documentUrl.RequireNotNullOrEmpty("documentUrl");
IServiceLocator serviceLocator = SharePointServiceLocator.GetCurrent();
IContentTypeOperations contentTypeOps = serviceLocator.GetInstance<IContentTypeOperations>();
string contentTypeName = "Link to a Document";
var contentType = web.AvailableContentTypes[contentTypeName];
SPDocumentLibrary DocLibrary = targetFolder.DocumentLibrary;
if (null != DocLibrary)
{
bool LinkToDocumentApplied = false;
foreach (SPContentType cType in DocLibrary.ContentTypes)
{
if (cType.Name == contentTypeName)
{
LinkToDocumentApplied = true;
break;
}
}
if (!LinkToDocumentApplied)
{
contentTypeOps.AddContentTypeToList(contentType, DocLibrary);
}
}
var filePath = targetFolder.ServerRelativeUrl;
if (!string.IsNullOrEmpty(documentPath))
{
filePath += "/" + documentPath;
}
var currentFolder = web.GetFolder(filePath);
var files = currentFolder.Files;
var urlOfFile = currentFolder.Url + "/" + documentName + ".aspx";
var builder = new StringBuilder(aspxPageFormat.Length + 400);
builder.AppendFormat(aspxPageFormat, typeof(SPDocumentLibrary).Assembly.FullName);
var properties = new Hashtable();
properties["ContentTypeId"] = contentType.Id.ToString();
var file = files.Add(urlOfFile, new MemoryStream(new UTF8Encoding().GetBytes(builder.ToString())), properties, false, false);
var item = file.Item;
item["URL"] = documentUrl + ", ";
item.UpdateOverwriteVersion();
return file;
}
public FolderNode(SPFolder folder)
{
this.Tag = folder;
if (folder.ParentListId != Guid.Empty)
{
this.SPParent = folder.ParentWeb.Lists[folder.ParentListId];
}
this.Setup();
this.Nodes.Add(new ExplorerNodeBase("Dummy"));
}
/// <summary>
/// Sets a default for a field at a location.
/// </summary>
/// <param name="metadata">Provides the method to set the default value for the field</param>
/// <param name="folder"><see cref="SPFolder"/> location at which to set the default value</param>
/// <param name="list">List of the TaxonomyField containing the validatedString corresponding to the default value.</param>
public void ApplyFieldOnMetadata(MetadataDefaults metadata, SPFolder folder, SPList list)
{
var term = this.Term;
var labelGuidPair = term.GetDefaultLabel((int)list.ParentWeb.Language) + "|" + term.Id;
var taxonomyField = list.Fields.GetField(this.FieldName) as TaxonomyField;
var newTaxonomyFieldValue = new TaxonomyFieldValue(taxonomyField);
// PopulateFromLabelGuidPair takes care of looking up the WssId value and creating a new item in the TaxonomyHiddenList if needed.
// Reference: http://msdn.microsoft.com/en-us/library/ee567833.aspx
newTaxonomyFieldValue.PopulateFromLabelGuidPair(labelGuidPair);
metadata.SetFieldDefault(folder, this.FieldName, newTaxonomyFieldValue.ValidatedString);
}
protected SPListItem FindWebPartPage(SPFolder folder, WebPartPageDefinition webpartPageModel)
{
var webPartPageName = GetSafeWebPartPageFileName(webpartPageModel);
if (!webPartPageName.EndsWith(".aspx"))
webPartPageName += ".aspx";
foreach (SPFile file in folder.Files)
if (file.Name.ToUpper() == webPartPageName.ToUpper())
return file.Item;
return null;
}
private void AddFolder(ZipFileBuilder builder, SPFolder folder, string parentFolder)
{
string folderPath = parentFolder == string.Empty ? folder.Name : parentFolder + "\\" + folder.Name;
builder.AddDirectory(folderPath);
foreach (SPFile file in folder.Files)
{
AddFile(builder, file, folderPath);
}
foreach (SPFolder subFolder in folder.SubFolders)
{
AddFolder(builder, subFolder, folderPath);
}
}
/// <summary>
/// Applies the field on metadata.
/// </summary>
/// <param name="metadata">The metadata.</param>
/// <param name="folder">The folder.</param>
public virtual void ApplyFieldOnMetadata(MetadataDefaults metadata, SPFolder folder)
{
var defaultValue = string.Empty;
if (this.Value != null)
{
defaultValue = this.Value.ToString();
}
metadata.SetFieldDefault(
folder,
this.FieldName,
defaultValue);
metadata.Update();
}
public string GetDefaultContentTypeId(SPFolder folder)
{
var contentTypeId = string.Empty;
if (folder.Item != null)
{
var metadata = new MetadataDefaults(folder.Item.ParentList);
while (string.IsNullOrEmpty(contentTypeId) && folder != null)
{
contentTypeId = metadata.GetFieldDefault(folder, BuiltInFields.ContentTypeId.InternalName);
folder = folder.ParentFolder;
}
}
return contentTypeId;
}
private void DeployPage(object modelHost, SPList list, SPFolder folder, ContentPageDefinitionBase definition)
{
var web = list.ParentWeb;
var targetPage = GetCurrentObject(folder, definition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = targetPage == null ? null : targetPage.File,
ObjectType = typeof(SPFile),
ObjectDefinition = definition,
ModelHost = modelHost
});
if (targetPage == null)
targetPage = CreateObject(modelHost, folder, definition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = targetPage.File,
ObjectType = typeof(SPFile),
ObjectDefinition = definition,
ModelHost = modelHost
});
ModuleFileModelHandler.WithSafeFileOperation(list, folder,
targetPage.Url,
GetSafePageFileName(definition),
definition.Content,
definition.NeedOverride,
null,
afterFile =>
{
var pageItem = afterFile.Properties;
pageItem["vti_title"] = definition.Title;
MapProperties(modelHost, pageItem, definition);
//pageItem.SystemUpdate();
});
}
protected virtual SPListItem FindListItem(SPList list, SPFolder folder, ListItemDefinition listItemModel)
{
var items = list.GetItems(new SPQuery
{
Folder = folder,
Query = string.Format(@"<Where>
<Eq>
<FieldRef Name='Title'/>
<Value Type='Text'>{0}</Value>
</Eq>
</Where>", listItemModel.Title)
});
if (items.Count > 0)
return items[0];
return null;
}
public void EnsureVariationsSettings(SPSite site, VariationSettingsInfo variationSettings)
{
var rootWeb = site.RootWeb;
Guid varRelationshipsListId = new Guid(rootWeb.AllProperties["_VarRelationshipsListId"] as string);
SPList varRelationshipsList = rootWeb.Lists[varRelationshipsListId];
SPFolder rootFolder = varRelationshipsList.RootFolder;
// Automatic creation
rootFolder.Properties["EnableAutoSpawnPropertyName"] = variationSettings.IsAutomaticTargetPageCreation.ToString();
// Recreate Deleted Target Page; set to false to enable recreation
rootFolder.Properties["AutoSpawnStopAfterDeletePropertyName"] = (!variationSettings.IsRecreateDeletedTargetPage).ToString();
// Update Target Page Web Parts
rootFolder.Properties["UpdateWebPartsPropertyName"] = variationSettings.IsUpdateTargetPageWebParts.ToString();
// Resources
rootFolder.Properties["CopyResourcesPropertyName"] = variationSettings.IsCopyResourcesToTarget.ToString();
// Notification
rootFolder.Properties["SendNotificationEmailPropertyName"] = variationSettings.IsSendNotificationEmail.ToString();
rootFolder.Properties["SourceVarRootWebTemplatePropertyName"] = variationSettings.SourceVariationTopLevelWebTemplate;
rootFolder.Update();
SPListItem item = null;
if (varRelationshipsList.Items.Count > 0)
{
item = varRelationshipsList.Items[0];
}
else
{
item = varRelationshipsList.Items.Add();
item["GroupGuid"] = new Guid("F68A02C8-2DCC-4894-B67D-BBAED5A066F9");
}
item["Deleted"] = false;
item["ObjectID"] = rootWeb.ServerRelativeUrl;
item["ParentAreaID"] = string.Empty;
item.Update();
}
private static bool ListContainsAttachments(SPWeb web, ListInfo listInfo)
{
SPFolder listFolder = null;
// Get the list folder in the web
var folders = listInfo.WebRelativeUrl.ToString().Split('/');
for (var i = 0; i < folders.Count(); i++)
{
// If the first list folder segment, get it in the web folders collection.
// Else, get the folder in the subfolders collection.
if (i == 0)
{
listFolder = web.Folders[folders[i]];
}
else if (listFolder != null)
{
listFolder = listFolder.SubFolders[folders[i]];
}
}
// If the list folder exists
if (listFolder != null)
{
try
{
// If the attachments folder exists
var attachmentsFolder = listFolder.SubFolders["Attachments"];
if (attachmentsFolder != null)
{
// Return true if any attachments folder contains a subfolder with files.
return(attachmentsFolder.SubFolders.Cast <SPFolder>().Any(folder => folder.Files.Count > 0));
}
}
catch (ArgumentException)
{
return(false);
}
}
return(false);
}
public static SPFile SaveFilePowerLibrary(string fileName, byte[] bin)
{
string powerLibraryPath = PowerWebPartStore.Current.PowerLibraryUrl;
if (String.IsNullOrEmpty(powerLibraryPath))
{
throw new FileNotFoundException("PowerLibrary in not configured!");
}
using (SPSite site = new SPSite(powerLibraryPath))
{
using (SPWeb web = site.OpenWeb())
{
SPFolder folder = web.GetFolder(powerLibraryPath);
SPFile file = folder.Files.Add(fileName, bin);
return(file);
}
}
}
private void WriteFiles(string targetFolder, SPFolder folder)
{
if (!Directory.Exists(targetFolder))
{
WriteVerbose(string.Format("Creating folder {0}...", targetFolder));
Directory.CreateDirectory(targetFolder);
}
foreach (SPFile file in folder.Files)
{
WriteFile(targetFolder, file);
}
if (Recursive)
{
foreach (SPFolder childFolder in folder.SubFolders)
{
WriteFiles(Path.Combine(targetFolder, childFolder.Name), childFolder);
}
}
}
public override void DeployModel(object modelHost, DefinitionBase model)
{
var folderModelHost = modelHost.WithAssertAndCast <FolderModelHost>("modelHost", value => value.RequireNotNull());
var definition = model.WithAssertAndCast <FolderDefinition>("model", value => value.RequireNotNull());
SPFolder spObject = null;
if (folderModelHost.CurrentLibrary != null)
{
spObject = GetLibraryFolder(folderModelHost, definition);
}
else if (folderModelHost.CurrentList != null)
{
spObject = GetListFolder(folderModelHost, definition);
}
var assert = ServiceFactory.AssertService
.NewAssert(definition, spObject)
.ShouldBeEqual(m => m.Name, o => o.Name);
}
protected virtual SPListItem FindListItem(SPList list, SPFolder folder, ListItemDefinition listItemModel)
{
var items = list.GetItems(new SPQuery
{
Folder = folder,
Query = string.Format(@"<Where>
<Eq>
<FieldRef Name='Title'/>
<Value Type='Text'>{0}</Value>
</Eq>
</Where>", listItemModel.Title)
});
if (items.Count > 0)
{
return(items[0]);
}
return(null);
}
private static SPFolder GetOASLibrary(SPWeb web)
{
SPListTemplateType genericList = new SPListTemplateType();
genericList = SPListTemplateType.DocumentLibrary;
SPFolder res = (SPFolder)web.GetFolder(OAS_LIBRARY);
if (!res.Exists)
{
web.AllowUnsafeUpdates = true;
Guid listGuid = web.Lists.Add(OAS_LIBRARY, "", genericList);
SPDocumentLibrary oaslist = (SPDocumentLibrary)web.Lists[listGuid];
oaslist.Hidden = true;
oaslist.Update();
}
return((SPFolder)web.Folders[OAS_LIBRARY]);
}
private void DeleteExistingPicturesForUser(SPFolder pictureDocumentLibrary)
{
string userName = GetCleanUserName(SPContext.Current.Web.CurrentUser.LoginName);
var picturesToDelete = new List <SPFile>();
foreach (SPFile file in pictureDocumentLibrary.Files)
{
if (Path.GetFileNameWithoutExtension(file.Name) == userName)
{
picturesToDelete.Add(file);
}
}
foreach (SPFile file in picturesToDelete)
{
file.Delete();
}
pictureDocumentLibrary.Update();
}
private void addSubFolder(StringBuilder dynamicMenuXml, SPFolder subFolder)
{
dynamicMenuXml.Append("<FlyoutAnchor ");
dynamicMenuXml.Append(" Id=\"Ribbon.Flyoutanchor\" ");
dynamicMenuXml.Append(" LabelText=\"").Append(subFolder.Name).Append("\" ");
dynamicMenuXml.Append(" Command=\"DoNothingCommand\" ");
dynamicMenuXml.Append(" CommandType=\"IgnoredByMenu\" ");
dynamicMenuXml.Append(" Image16by16=\"/_layouts/images/folder.gif\" ");
dynamicMenuXml.Append(" > ");
dynamicMenuXml.Append(" <Menu Id=\"Ribbon.Flyoutanchor.Menu\"> ");
dynamicMenuXml.Append(" <MenuSection Id=\"Ribbon.Flyoutanchor.Menu.MenuSection DisplayMode='Menu16'\"> ");
dynamicMenuXml.Append(" <Controls Id=\"Ribbon.Flyoutanchor.Menu.MenuSection.Controls\"> ");
addFolderContents(dynamicMenuXml, subFolder, false);
dynamicMenuXml.Append(" </Controls> ");
dynamicMenuXml.Append(" </MenuSection> ");
dynamicMenuXml.Append(" </Menu> ");
dynamicMenuXml.Append(" </FlyoutAnchor> ");
}
private static void RemoveConversionFiles(SPWeb web, string JobId)
{
SPList list = GetOASList(web);
SPListItemCollection listItems = list.Items;
int itemCount = listItems.Count;
web.AllowUnsafeUpdates = true;
for (int k = 0; k < itemCount; k++)
{
SPListItem item = listItems[k];
if (JobId == item["JobId"].ToString())
{
//source file
string fileid = item["FileId"].ToString();
//conveted file
string source = Path.GetFileNameWithoutExtension(fileid);
SPFolder lib = GetOASLibrary(web);
//delete result file
SPFile res = GetFile(lib, fileid);
if (res != null)
{
res.Delete();
lib.Update();
}
//delete source file
res = GetFile(lib, source);
if (res != null)
{
res.Delete();
lib.Update();
}
listItems.Delete(k);
break;
}
}
web.AllowUnsafeUpdates = false;
}
public static SPMObjectType IdentifyObject(object obj)
{
if (obj is SPFolder)
{
SPFolder folder = (SPFolder)obj;
if (folder.UniqueId.Equals(folder.ParentWeb.RootFolder.UniqueId))
{
return(SPMObjectType.SPWeb);
}
else
{
SPList list = folder.ParentWeb.Lists[folder.ParentListId];
if (folder.UniqueId.Equals(list.RootFolder.UniqueId))
{
if (list is SPDocumentLibrary)
{
return(SPMObjectType.SPDocumentLibrary);
}
else
{
return(SPMObjectType.SPList);
}
}
else
{
return(SPMObjectType.SPFolder);
}
}
}
else if (obj is SPListItem)
{
return(SPMObjectType.SPListItem);
}
else if (obj is SPFile)
{
return(SPMObjectType.SPFile);
}
return(SPMObjectType.Unknown);
}
private static void copyTemplates(SPFolder template, SPFolder dest, bool isProtected)
{
foreach (SPFile f in template.Files)
{
Hashtable fileProperties = new Hashtable();
fileProperties["vti_Title"] = Regex.Replace(f.Name, "[0-9]+\\s", "");
int intOutNr;
string strNumber = f.Name.Substring(0, 2);
if (int.TryParse(strNumber, out intOutNr))
{
fileProperties["DocumentNumber"] = strNumber;
}
var templatefile = f.OpenBinaryStream(SPOpenBinaryOptions.SkipVirusScan);
var file = dest.Files.Add(SPUrlUtility.CombineUrl(dest.ServerRelativeUrl, f.Name), templatefile, fileProperties, true);
if (isProtected)
{
file.Item[BriefingFields.DocumentIsProtectedName] = isProtected;
file.Item.UpdateOverwriteVersion();
SPUtil.SecureBriefing(file.Item);
}
if (file.CheckOutType != SPFile.SPCheckOutType.None)
{
file.CheckIn("");
}
}
foreach (SPFolder folder in template.SubFolders)
{
if (folder.Item != null && folder.Name != "Forms")
{
SPFolder fld = dest.SubFolders.Add(folder.Name);
SPListItem folderItem = fld.Item;
folderItem["ExemptPublishAll"] = folder.Item["ExemptPublishAll"];
folderItem.Update();
copyTemplates(folder, fld, isProtected);
}
}
}
void ddl_Controls_SelectedIndexChanged(object sender, EventArgs e)
{
string control = ddl_Controls.SelectedValue;
SPList stylelib = SPContext.Current.Site.RootWeb.Lists.TryGetList("Style Library");
if (!string.IsNullOrEmpty(control))
{
SPFolder controlFolder = stylelib.RootFolder.SubFolders[control];
SPFolderCollection styleFolders = controlFolder.SubFolders;
List <SPFolder> empty = new List <SPFolder>();
foreach (SPFolder folder in controlFolder.SubFolders)
{
bool found = false;
foreach (SPFile file in folder.Files)
{
if (string.Compare("definition.xml", file.Name, true) == 0)
{
found = true;
break;
}
}
if (!found)
{
empty.Add(folder);
}
}
ddl_Style.DataSource = styleFolders;
ddl_Style.DataBind();
foreach (SPFolder folder in empty)
{
ddl_Style.Items.Remove(folder.Name);
}
if (ddl_Style.Items.Count == 0)
{
ddl_Controls.Items.Remove(controlFolder.Name);
}
}
}
protected void btnUpload_Click(object sender, EventArgs args)
{
//Find out about the file we want to archive
SPWeb webSite = SPContext.Current.Web;
string filePath = webSite.Url.ToString() + Request.QueryString["ItemUrl"].ToString();
//This is work around for the webSite.GetFile() method.
//I found this didn't let me get the binary bite array
SPListItem item = webSite.GetListItem(filePath);
SPFolder itemfolder = webSite.Folders[item.ParentList.Title].SubFolders[item.Name];
SPFile fileToArchive = itemfolder.Files[0];
//SPFile fileToArchive = webSite.GetFile(filePath);
//Save the binary version to upload to Azure
byte[] fileBinaryArray = fileToArchive.OpenBinary();
//Make sure the archived file name is unique
string fileNameGuid = Guid.NewGuid().ToString();
string newBlobName = string.Format(fileNameGuid + "_" + fileToArchive.Name.ToString());
//Get or create the container
blobContainer = cloudBlobClient.GetContainerReference(defaultContainerName);
blobContainer.CreateIfNotExist();
//Make sure the container is public
var perms = blobContainer.GetPermissions();
perms.PublicAccess = BlobContainerPublicAccessType.Container;
blobContainer.SetPermissions(perms);
//Create the blob
cloudBlob = blobContainer.GetBlockBlobReference(newBlobName);
try
{
//Upload the binary
cloudBlob.UploadByteArray(fileBinaryArray);
//Display the path to the blob
resultsLabel.Text = "Blob Location: " + cloudBlob.Uri.ToString();
resultsLabel.Text += "<br />Try pasting the above URL into the IE address bar to download the file from Azure";
}
catch (Exception ex)
{
resultsLabel.Text = "There was an exception uploading the file: " + ex.Message;
}
}
protected override void CreateChildControls()
{
try
{
SPWeb site = SPContext.Current.Web;
SPFolder rootFolder = site.RootFolder;
TreeNode rootNode = new TreeNode(site.Url, site.Url, SITE_IMG);
LoadFolderNodes(rootFolder, rootNode);
treeSitesFiles = new SPTreeView();
treeSitesFiles.Nodes.Add(rootNode);
treeSitesFiles.ExpandDepth = 1;
Controls.Add(treeSitesFiles);
base.CreateChildControls();
}
catch (Exception e)
{
string exp = "e.ToString";
}
}
SPFolder CreateFolder(SPFolder folder, string name)
{
SPFolder newFolder = null;
try
{
newFolder = folder.SubFolders[name];
}
catch (ArgumentException)
{
}
if (newFolder == null)
{
newFolder = folder.SubFolders.Add(name);
newFolder.Update();
folder.Update();
}
return(newFolder);
}
/// <summary>
/// Provisions the welcome page.
/// </summary>
/// <param name="contentType">The content type.</param>
/// <returns>The welcome page.</returns>
private SPFile ProvisionWelcomePage(SPContentType contentType)
{
// Guard
if (contentType == null)
{
throw new ArgumentNullException("contentType");
}
SPFile file = this.GetWelcomePage(contentType);
if (file != null)
{
return(file);
}
byte[] buffer =
File.ReadAllBytes(SPUtility.GetVersionedGenericSetupPath(@"Template\Features\DocumentSet\docsethomepage.aspx", 0));
SPFolder resourceFolder = contentType.ResourceFolder;
return(resourceFolder.Files.Add(this.DocumentSetWelcomePage, buffer, true));
}
internal static void RemovePages(EntitiesDataContext _edc, SPWeb _root)
{
Anons.WriteEntry(_edc, m_SourceClass + m_SourceRemovePages, "Remove Pages starting");
try
{
SPFolder WebPartPagesFolder = _root.GetFolder(ProjectElementManagement.WebPartPagesFolder);
if (WebPartPagesFolder.Exists)
{
WebPartPagesFolder.Delete();
}
else
{
Anons.WriteEntry(_edc, m_SourceClass + m_SourceRemovePages, "Failed, the folder " + WebPartPagesFolder + "dies not exist.");
}
}
catch (Exception ex)
{
Anons.WriteEntry(_edc, m_SourceClass + m_SourceRemovePages, "Remove pages failed with exception: " + ex.Message);
}
Anons.WriteEntry(_edc, m_SourceClass + m_SourceRemovePages, "Remove Pages finished");
}
/// <summary>
/// Writes a field value as an SPFolder's default column value
/// </summary>
/// <param name="folder">The folder for which we wish to update a field's default value</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (TaxonomyValueCollection)fieldValueInfo.Value;
var list = folder.ParentWeb.Lists[folder.ParentListId];
var taxonomyField = (TaxonomyField)list.Fields[fieldValueInfo.FieldInfo.Id];
MetadataDefaults listMetadataDefaults = new MetadataDefaults(list);
if (defaultValue != null)
{
var taxonomyFieldValueCollection = CreateSharePointTaxonomyFieldValue(taxonomyField, defaultValue, null);
string collectionValidatedString = taxonomyField.GetValidatedString(taxonomyFieldValueCollection);
listMetadataDefaults.SetFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName, collectionValidatedString);
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
/// <summary>
/// Gets the name of the folder.
/// </summary>
/// <param name="list">The list.</param>
/// <param name="folder">The folder.</param>
/// <returns>The Folder name</returns>
private string GetFolderName(SPList list, SPFolder folder)
{
string value;
if (_filter.IncludeNumberOfFiles)
{
if (list.BaseType == SPBaseType.DocumentLibrary)
{
value = folder.Name + " (" + folder.Files.Count + ")";
}
else
{
value = folder.Name + " (" + CountFolderItems(list, folder) + ")";
}
}
else
{
value = folder.Name;
}
return(value);
}
public List <IItem> GetListItems(ISiteSetting siteSetting, Folder folder, IView view, string sortField, bool isAsc, int currentPageIndex, string currentListItemCollectionPositionNext, CamlFilters filters, bool isRecursive, out string listItemCollectionPositionNext, out int itemCount)
{
SPFolder _folder = folder as SPFolder;
if (_folder == null)
{
listItemCollectionPositionNext = string.Empty;
itemCount = 0;
return(new List <IItem>());
}
ISharePointService spService = new SharePointService();
string folderPath = string.Empty;
if (folder as SPList == null)
{
folderPath = _folder.GetPath();
}
return(spService.GetListItems(siteSetting, view, sortField, isAsc, _folder.IsDocumentLibrary, _folder.WebUrl, _folder.ListName, folderPath, currentListItemCollectionPositionNext, filters, isRecursive, out listItemCollectionPositionNext, out itemCount));
}
private SPFolder CreateFolderPathRecursive(SPFolder folder, IList <string> pathComponents)
{
if (pathComponents.Count == 0)
{
return(folder);
}
SPFolder newFolder;
try
{
newFolder = folder.SubFolders[pathComponents.First()];
}
catch (ArgumentException)
{
newFolder = folder.SubFolders.Add(pathComponents.First());
}
pathComponents.RemoveAt(0);
return(CreateFolderPathRecursive(newFolder, pathComponents));
}
private static bool DoesPrincipalHasPermissions(SPFolder folder, SPPrincipal principal,
SPBasePermissions permissions)
{
var user = principal as SPUser;
if (user != null)
{
return(folder.Item.DoesUserHavePermissions(user, permissions));
}
SPRoleAssignment assignmentByPrincipal = null;
try
{
assignmentByPrincipal = folder.Item.RoleAssignments.GetAssignmentByPrincipal(principal);
}
catch
{
return(false);
}
return(assignmentByPrincipal.RoleDefinitionBindings.Cast <SPRoleDefinition>().Any(definition => (definition.BasePermissions & permissions) == permissions));
}
public void DeleteUnregisterDataBaseCache()
{
StatusValuePair <List <ArchiveEntities> > allRecords = _archiveEntityCrud.GetListArchiveElements();
if (!allRecords.HasValue || allRecords.Value == null)
{
return;
}
foreach (ArchiveEntities archiveEntity in allRecords.Value)
{
SPFolder folder = SpList.ParentWeb.GetFolder(archiveEntity.Url);
if (folder != null && folder.Item != null)
{
continue;
}
_manyToManyEntityCrud.Delete(archiveEntity.Id);
_archiveEntityCrud.Delete(archiveEntity);
}
}
/// <summary>
/// Reflection crawl process of webpart properties and xml files
/// </summary>
/// <param name="folder"></param>
protected void Crawl(SPFolder folder)
{
SPFile MyFile = null;
if (folder != null)
{
foreach (SPFile CurrentFile in folder.Files)
{
MyFile = CurrentFile;
try
{
string FileExtension = Path.GetExtension(CurrentFile.Url);
if (CurrentFile.InDocumentLibrary &&
CurrentFile.Item != null &&
m_Parameters.IncludeXmlFilesLibraries &&
XmlFileLibraryInFilteredList(CurrentFile.Item.ParentList as SPDocumentLibrary) &&
XmlFileLibraryInFilteredList(CurrentFile))
{
ReadXmlFile(CurrentFile);
continue;
}
else if (FileExtension.ToLower() == ".aspx" && m_Parameters.IncludeWebParts)
{
CrawlWebPartPage(CurrentFile);
}
}
catch (Exception ex)
{
OnError(ex, "ERROR: Cannot process file " + MyFile.Name);
}
}
foreach (SPFolder SubFolder in folder.SubFolders)
{
Crawl(SubFolder);
}
}
}
protected override void CreateChildControls()
{
string s = "";
if (string.IsNullOrEmpty(DocLibUrl))
{
s = string.Format(@"
Html Parametric by
<a href=""{0}"" target=""_blank"">{1}</a>
<br />
<a id=""HtmlParametricWebPart_OpenToolPane_{2}"" href=""#"" onclick=""javascript:MSOTlPn_ShowToolPane2('Edit','{3}');"">Open the tool pane</a>
to configure this Web Part."
, Helper.SGART_URL, Helper.SGART_TITLE
, this.ClientID, this.ID);
}
else
{
try
{
web = SPContext.Current.Web;
SPList list = web.GetList(docLibUrl);
editUrl = list.Forms[PAGETYPE.PAGE_EDITFORM].ServerRelativeUrl;
SPFolder folder = list.RootFolder;
STreeItem root = GetNode(folder, null);
LoadTree(folder, root);
s = ShowTree(root);
}
catch (Exception ex)
{
s = string.Format("### Error: {0}", ex);
}
}
lc = new LiteralControl(s);
this.Controls.Add(lc);
base.CreateChildControls();
}
protected static void download(SPFolder folder, string targetf)
{
foreach (SPFile file in folder.Files)
{
string message = "";
string fileName = file.Name;
byte[] binfile = file.OpenBinary();
string completePath = file.ParentFolder.ToString();
string folderPath = System.IO.Path.Combine(targetf, getSafeFileName(completePath));
System.IO.Directory.CreateDirectory(folderPath);
string filePath = System.IO.Path.Combine(folderPath, fileName);
bool response = false;
try
{
FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite);
BinaryWriter bw = new BinaryWriter(fs);
bw.Write(binfile);
bw.Close();
response = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
if (response == true)
{
message = "Copie ok: " + fileName;// +" dans " + filePath;
}
else
{
message = "Erreur: " + fileName;
}
EcrireLog(message);
}
}
protected override SPListItem FindListItem(SPList list, SPFolder folder, ListItemDefinition listItemModel)
{
var definition = listItemModel.WithAssertAndCast <ComposedLookItemDefinition>("model", value => value.RequireNotNull());
// first by Name
var items = list.GetItems(new SPQuery
{
Folder = folder,
Query = string.Format(@"<Where>
<Eq>
<FieldRef Name='Name'/>
<Value Type='Text'>{0}</Value>
</Eq>
</Where>", definition.Name)
});
if (items.Count > 0)
{
return(items[0]);
}
// by Title?
items = list.GetItems(new SPQuery
{
Folder = folder,
Query = string.Format(@"<Where>
<Eq>
<FieldRef Name='Title'/>
<Value Type='Text'>{0}</Value>
</Eq>
</Where>", definition.Title)
});
if (items.Count > 0)
{
return(items[0]);
}
return(null);
}
public ArchiveEntities CreateArchiveElement(SPFolder folder, string documentType = null, string description = null, string status = null)
{
if (folder == null || folder.Item == null || folder.Item[SPBuiltInFieldId.Author] == null)
{
return(null);
}
SPFieldUserValue author = new SPFieldUserValue(folder.Item.Web, folder.Item[SPBuiltInFieldId.Author].ToString());
int userId = author.User.ID;
DateTime created = DateTime.Now;
// создаём новую запись в БД, генерируем название папки из Id новой записи
string editUrl = folder.Item.ParentList.DefaultEditFormUrl + "?ID=" + folder.Item.ID + "&RootFolder=/" + (folder.Item.Folder == null ? string.Empty : folder.Item.Folder.Url);
long barcode = 0;
if (folder.Item[Constants.BarCodeFieldName] != null)
{
var barcodeValue = folder.Item[Constants.BarCodeFieldName].ToString();
BarcodeFabric.TryParse(barcodeValue, out barcode);
}
StatusValuePair <ArchiveEntities> archiveElement = _archiveEntityCrud.Create(folder.Url, editUrl, userId, folder.Item.ParentList.ID.ToString(), folder.Item.ID.ToString("D"), created, true, documentType, description, status, barcode > 0 ? barcode.ToString() : null);
if (!archiveElement.HasValue)
{
return(null);
}
using (DisabledItemEventsScope scope = new DisabledItemEventsScope())
{
folder.Item[Constants.BarCodeFieldName] = archiveElement.Value.Barcode;
folder.Item.Update();
}
List <Permissions> permissions = PermissionsHelper.GetPermissions(archiveElement.Value.Barcode, folder.Item);
CreateOrUpdatePermissions(permissions);
return(archiveElement);
}
private static void ReOrderSetItemID(SPItemEventProperties properties, bool isSource)
{
string urlString = null;
SPFolder spFolder = null;
//This is intentionally started at 1 as we do not want a document with an ID of 0.
int i = 1;
//are we dealing with a source or destination library?
if (isSource)
{
urlString = properties.BeforeUrl.Substring(0, properties.BeforeUrl.LastIndexOf("/"));
spFolder = properties.Web.GetFolder(urlString);
}
else
{
urlString = properties.AfterUrl.Substring(0, properties.AfterUrl.LastIndexOf("/"));
spFolder = properties.Web.GetFolder(urlString);
}
// reorder our SetItemID values in the source folder
SPList docSetList = properties.List;
SPQuery query = new SPQuery();
query.Folder = spFolder;
query.Query = "<OrderBy><FieldRef Name='SetItemID' Ascending='FALSE' /></OrderBy>";
SPListItemCollection items = docSetList.GetItems(query);
if (items.Count > 0)
{
foreach (SPListItem item in items)
{
if (item.ID != properties.ListItem.ID)
{
item["SetItemID"] = i;
item.Update();
i++;
}
}
}
}
private static void PublishAssetInternal(string assetUrl, SPListItem sourceItem)
{
if (!CommonHelper.IsNullOrWhiteSpace(assetUrl))
{
object fileSystemObj;
try {
int pathEndPos = assetUrl.IndexOfAny(new[] { '?', '#' });
if (pathEndPos >= 0)
{
assetUrl = assetUrl.Substring(0, pathEndPos);
}
fileSystemObj = sourceItem.Web.Site.GetFileOrFolder(assetUrl);
} catch {
return;
}
try {
if (fileSystemObj is SPFolder)
{
SPFolder folder = (SPFolder)fileSystemObj;
if (folder.ParentListId != Guid.Empty)
{
folder.EnsureApproved();
}
}
else if (fileSystemObj is SPFile)
{
SPFile file = (SPFile)fileSystemObj;
if (file.ParentFolder.ParentListId != Guid.Empty)
{
if (file.Item != null && file.Item.ContentTypeId.IsChildOf(SPBuiltInContentTypeId.Document) && !file.Item.ContentTypeId.IsChildOf(ContentTypeId.MasterPage.Parent) && !file.Item.ContentTypeId.IsChildOf(ContentTypeId.Page.Parent))
{
file.EnsurePublished(String.Concat("Publish linked asset from ", SPUrlUtility.CombineUrl(sourceItem.Web.ServerRelativeUrl, sourceItem.Url)));
}
}
}
} catch (Exception ex) {
throw new Exception(String.Concat("Cannot approve or publish content at ", assetUrl), ex);
}
}
}
/// <summary>
/// Sets a default for a field at a location.
/// </summary>
/// <param name="metadata">Provides the method to set the default value for the field</param>
/// <param name="folder"><see cref="SPFolder"/> location at which to set the default value</param>
/// <param name="list">List of the TaxonomyField containing the validatedString corresponding to the default value.</param>
public void ApplyFieldOnMetadata(MetadataDefaults metadata, SPFolder folder, SPList list)
{
var taxonomyField = list.Fields.GetField(this.FieldName) as TaxonomyField;
if (taxonomyField != null)
{
var newTaxonomyFieldValueCollection = this.GetTaxonomyFieldValueCollection(taxonomyField);
List<string> wssIdAndLabelStrings = new List<string>();
foreach (TaxonomyFieldValue fieldValue in newTaxonomyFieldValueCollection)
{
var wssId = fieldValue.WssId;
var label = fieldValue.Label;
wssIdAndLabelStrings.Add(wssId + ";#" + label);
}
// Tax field value collection looks like this: "97;#Human resources;#96;#IT Services Portal" where "WSSidTerm1;#Term1Label;#WssidTerm2;#Term2Label"
string taxFieldValueCollectionAsString = string.Join(";#", wssIdAndLabelStrings.ToArray());
metadata.SetFieldDefault(folder, this.FieldName, taxFieldValueCollectionAsString);
}
}
