protected override void ExecuteCmdlet()
{
if (string.IsNullOrEmpty(Folder))
{
if (CurrentWeb.PropertyBagContainsKey(Key))
{
if (Force || ShouldContinue(string.Format(Properties.Resources.Delete0, Key), Properties.Resources.Confirm))
{
CurrentWeb.RemovePropertyBagValue(Key);
}
}
}
else
{
CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
var folderUrl = UrlUtility.Combine(CurrentWeb.ServerRelativeUrl, Folder);
var folder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(folderUrl));
folder.EnsureProperty(f => f.Properties);
if (folder.Properties.FieldValues.ContainsKey(Key))
{
if (Force || ShouldContinue(string.Format(Properties.Resources.Delete0, Key), Properties.Resources.Confirm))
{
folder.Properties[Key] = null;
folder.Properties.FieldValues.Remove(Key);
folder.Update();
ClientContext.ExecuteQueryRetry();
}
}
}
}
protected override void ExecuteCmdlet()
{
var webServerRelativeUrl = CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
if (!SourceUrl.StartsWith("/"))
{
SourceUrl = UrlUtility.Combine(webServerRelativeUrl, SourceUrl);
}
if (!TargetUrl.StartsWith("/"))
{
TargetUrl = UrlUtility.Combine(webServerRelativeUrl, TargetUrl);
}
string sourceFolder = SourceUrl.Substring(0, SourceUrl.LastIndexOf('/'));
string targetFolder = TargetUrl;
if (System.IO.Path.HasExtension(TargetUrl))
{
targetFolder = TargetUrl.Substring(0, TargetUrl.LastIndexOf('/'));
}
Uri currentContextUri = new Uri(ClientContext.Url);
Uri sourceUri = new Uri(currentContextUri, EncodePath(sourceFolder));
Uri sourceWebUri = Microsoft.SharePoint.Client.Web.WebUrlFromFolderUrlDirect(ClientContext, sourceUri);
Uri targetUri = new Uri(currentContextUri, EncodePath(targetFolder));
Uri targetWebUri = Microsoft.SharePoint.Client.Web.WebUrlFromFolderUrlDirect(ClientContext, targetUri);
if (Force || ShouldContinue(string.Format(Resources.MoveFile0To1, SourceUrl, TargetUrl), Resources.Confirm))
{
if (sourceWebUri != targetWebUri)
{
Move(currentContextUri, sourceUri, targetUri, SourceUrl, TargetUrl, false);
}
else
{
var isFolder = false;
try
{
var folder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(TargetUrl));
var folderServerRelativePath = folder.EnsureProperty(f => f.ServerRelativePath);
isFolder = folderServerRelativePath.DecodedUrl == ResourcePath.FromDecodedUrl(TargetUrl).DecodedUrl;
}
catch
{
}
if (isFolder)
{
Move(currentContextUri, sourceUri, targetUri, SourceUrl, TargetUrl, true);
}
else
{
var file = CurrentWeb.GetFileByServerRelativePath(ResourcePath.FromDecodedUrl(SourceUrl));
file.MoveToUsingPath(ResourcePath.FromDecodedUrl(TargetUrl), Overwrite ? MoveOperations.Overwrite : MoveOperations.None);
ClientContext.ExecuteQueryRetry();
}
}
}
}
protected override void ExecuteCmdlet()
{
try
{
if (!ParameterSpecified(nameof(Folder)))
{
if (!Indexed)
{
// If it is already an indexed property we still have to add it back to the indexed properties
Indexed = !string.IsNullOrEmpty(CurrentWeb.GetIndexedPropertyBagKeys().FirstOrDefault(k => k == Key));
}
CurrentWeb.SetPropertyBagValue(Key, Value);
if (Indexed)
{
CurrentWeb.AddIndexedPropertyBagKey(Key);
}
else
{
CurrentWeb.RemoveIndexedPropertyBagKey(Key);
}
}
else
{
CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
var folderUrl = UrlUtility.Combine(CurrentWeb.ServerRelativeUrl, Folder);
var folder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(folderUrl));
folder.EnsureProperty(f => f.Properties);
folder.Properties[Key] = Value;
folder.Update();
ClientContext.ExecuteQueryRetry();
}
}
catch (Exception ex)
{
if (ex is ServerUnauthorizedAccessException)
{
if (CurrentWeb.IsNoScriptSite())
{
ThrowTerminatingError(new ErrorRecord(new Exception($"{ex.Message} Site might have NoScript enabled, this prevents setting some property bag values.", ex), "NoScriptEnabled", ErrorCategory.InvalidOperation, this));
return;
}
throw;
}
else
{
throw;
}
}
}
protected override void ExecuteCmdlet()
{
CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
var sourceFolderUrl = UrlUtility.Combine(CurrentWeb.ServerRelativeUrl, Folder);
Folder sourceFolder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(sourceFolderUrl));
ClientContext.Load(sourceFolder, f => f.Name, f => f.ServerRelativePath);
ClientContext.ExecuteQueryRetry();
var targetPath = string.Concat(sourceFolder.ServerRelativePath.DecodedUrl.Remove(sourceFolder.ServerRelativePath.DecodedUrl.Length - sourceFolder.Name.Length), TargetFolderName);
sourceFolder.MoveToUsingPath(ResourcePath.FromDecodedUrl(targetPath));
ClientContext.ExecuteQueryRetry();
}
protected override void ExecuteCmdlet()
{
if (string.IsNullOrEmpty(Folder))
{
if (!string.IsNullOrEmpty(Key))
{
WriteObject(CurrentWeb.GetPropertyBagValueString(Key, string.Empty));
}
else
{
CurrentWeb.EnsureProperty(w => w.AllProperties);
var values = CurrentWeb.AllProperties.FieldValues.Select(x => new PropertyBagValue()
{
Key = x.Key, Value = x.Value
});
WriteObject(values, true);
}
}
else
{
// Folder Property Bag
CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
var folderUrl = UrlUtility.Combine(CurrentWeb.ServerRelativeUrl, Folder);
var folder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(folderUrl));
folder.EnsureProperty(f => f.Properties);
if (!string.IsNullOrEmpty(Key))
{
var value = folder.Properties.FieldValues.FirstOrDefault(x => x.Key == Key);
WriteObject(value.Value, true);
}
else
{
var values = folder.Properties.FieldValues.Select(x => new PropertyBagValue()
{
Key = x.Key, Value = x.Value
});
WriteObject(values, true);
}
}
}
protected override void ExecuteCmdlet()
{
DefaultRetrievalExpressions = new Expression <Func <Folder, object> >[] { f => f.ServerRelativeUrl, f => f.Name, f => f.TimeLastModified, f => f.ItemCount };
if (List != null)
{
// Gets the provided list
var list = List.GetList(CurrentWeb);
// Query for all folders in the list
CamlQuery query = CamlQuery.CreateAllFoldersQuery();
do
{
// Execute the query. It will retrieve all properties of the folders. Refraining to using the RetrievalExpressions would cause a tremendous increased load on SharePoint as it would have to execute a query per list item which would be less efficient, especially on lists with many folders, than just getting all properties directly
ListItemCollection listItems = list.GetItems(query);
ClientContext.Load(listItems, item => item.Include(t => t.Folder), item => item.ListItemCollectionPosition);
ClientContext.ExecuteQueryRetry();
// Take all the folders from the resulting list items and put them in a list to return
var folders = new List <Folder>(listItems.Count);
foreach (ListItem listItem in listItems)
{
var folder = listItem.Folder;
folders.Add(folder);
}
WriteObject(folders, true);
query.ListItemCollectionPosition = listItems.ListItemCollectionPosition;
} while (query.ListItemCollectionPosition != null);
}
else
{
var webServerRelativeUrl = CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
if (!Url.StartsWith(webServerRelativeUrl, StringComparison.OrdinalIgnoreCase))
{
Url = UrlUtility.Combine(webServerRelativeUrl, Url);
}
var folder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(Url));
folder.EnsureProperties(RetrievalExpressions);
WriteObject(folder);
}
}
protected override void ExecuteCmdlet()
{
CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
var sourceFolderUrl = UrlUtility.Combine(CurrentWeb.ServerRelativeUrl, Folder);
Folder sourceFolder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(sourceFolderUrl));
ClientContext.Load(sourceFolder, f => f.Name, f => f.ServerRelativeUrl);
ClientContext.ExecuteQueryRetry();
var targetPath = string.Concat(TargetFolder, "/", sourceFolder.Name);
sourceFolder.MoveToUsingPath(ResourcePath.FromDecodedUrl(targetPath));
ClientContext.ExecuteQueryRetry();
var folder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(targetPath));
ClientContext.Load(folder, f => f.Name, f => f.ItemCount, f => f.TimeLastModified, f => f.ListItemAllFields);
ClientContext.ExecuteQueryRetry();
WriteObject(folder);
}
protected override void ExecuteCmdlet()
{
CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
var folderUrl = UrlUtility.Combine(CurrentWeb.ServerRelativeUrl, Folder, Name);
Folder folder = CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(folderUrl));
folder.EnsureProperty(f => f.Name);
if (Force || ShouldContinue(string.Format(Resources.Delete0, folder.Name), Resources.Confirm))
{
if (Recycle)
{
folder.Recycle();
}
else
{
folder.DeleteObject();
}
ClientContext.ExecuteQueryRetry();
}
}
private IEnumerable <object> GetContents(string FolderSiteRelativeUrl)
{
Folder targetFolder = null;
if (ParameterSetName == ParameterSet_FOLDERSBYPIPE && Identity != null)
{
targetFolder = Identity.GetFolder(CurrentWeb);
}
else
{
string serverRelativeUrl = null;
if (!string.IsNullOrEmpty(FolderSiteRelativeUrl))
{
var webUrl = CurrentWeb.EnsureProperty(w => w.ServerRelativeUrl);
serverRelativeUrl = UrlUtility.Combine(webUrl, FolderSiteRelativeUrl);
}
targetFolder = (string.IsNullOrEmpty(FolderSiteRelativeUrl)) ? CurrentWeb.RootFolder : CurrentWeb.GetFolderByServerRelativePath(ResourcePath.FromDecodedUrl(serverRelativeUrl));
}
IEnumerable <File> files = null;
IEnumerable <Folder> folders = null;
if (ItemType == "File" || ItemType == "All")
{
files = ClientContext.LoadQuery(targetFolder.Files).OrderBy(f => f.Name);
if (!string.IsNullOrEmpty(ItemName))
{
files = files.Where(f => f.Name.Equals(ItemName, StringComparison.InvariantCultureIgnoreCase));
}
}
if (ItemType == "Folder" || ItemType == "All" || Recursive)
{
folders = ClientContext.LoadQuery(targetFolder.Folders).OrderBy(f => f.Name);
if (!string.IsNullOrEmpty(ItemName))
{
folders = folders.Where(f => f.Name.Equals(ItemName, StringComparison.InvariantCultureIgnoreCase));
}
}
ClientContext.ExecuteQueryRetry();
IEnumerable <object> folderContent = null;
switch (ItemType)
{
case "All":
folderContent = folders.Concat <object>(files);
break;
case "Folder":
folderContent = folders;
break;
default:
folderContent = files;
break;
}
if (Recursive && folders.Count() > 0)
{
foreach (var folder in folders)
{
var relativeUrl = folder.ServerRelativeUrl.Replace(CurrentWeb.ServerRelativeUrl, "");
var subFolderContents = GetContents(relativeUrl);
folderContent = folderContent.Concat <object>(subFolderContents);
}
}
return(folderContent);
}