/// <summary>
        /// Moves item on local filesystem and remote if it exists.
        /// </summary>
        /// <param name="item">The item to move.</param>
        /// <param name="destinationFolder"> The destination folder.</param>
        /// <param name="name">New item's name.</param>
        /// <exception cref="ArgumentNullException">
        /// Throw when <paramref name="item"/> is null or <paramref name="destinationFolder"/> is null.
        /// </exception>
        public void MoveItem(ItemMetadata item, FolderMetadata destinationFolder, string name)
        {
            if (item == null)
            {
                throw new ArgumentNullException(nameof(item));
            }
            if (destinationFolder == null)
            {
                throw new ArgumentNullException(nameof(destinationFolder));
            }
            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            if (item.ExistsOnServer)
            {
                this.MoveItemOnServer(item, destinationFolder, name);
            }

            if (item.ExistsLocal)
            {
                this.LocalStorage.Move(item.LocalItem, destinationFolder.LocalFolder, name);
            }
        }
        /// <summary>Creates folder on server only.</summary>
        /// <param name="folderMetadata">The folder metadata.</param>
        /// <param name="folderName">The directory name.</param>
        /// <returns>The <see cref="FolderMetadata"/>.</returns>
        public FolderMetadata CreateFolderOnServer(FolderMetadata folderMetadata, string folderName)
        {
            IFolderAsync newFolder = folderMetadata.ServerFolder.CreateFolderAsync(folderName).GetAwaiter().GetResult();

            string      id        = this.LocationMapper.GetIdentifierFromServerUri(newFolder.Href);
            string      localPath = this.LocationMapper.GetLocalUrlFromIdentifier(id);
            LocalFolder localItem = this.LocalStorage.GetFolder(localPath);

            return(this.CreateFolderMetadata(id, localItem, newFolder));
        }
        /// <summary>Creates file on server.</summary>
        /// <param name="parentMetadata">The parent metadata.</param>
        /// <param name="fileName">The file name.</param>
        /// <returns>The <see cref="FileMetadata"/>.</returns>
        public FileMetadata CreateFileOnServer(FolderMetadata parentMetadata, string fileName)
        {
            IFileAsync newFile    = parentMetadata.ServerFolder.CreateFileAsync(fileName, null).GetAwaiter().GetResult();
            string     identifier = this.LocationMapper.GetIdentifierFromServerUri(newFile.Href);
            string     localPath  = this.LocationMapper.GetLocalUrlFromIdentifier(identifier);
            LocalFile  localItem  = this.LocalStorage.GetFile(localPath);
            string     name       = this.GetItemDisplayName(identifier, newFile);

            return(new FileMetadata(identifier, parentMetadata.Identifier, name, localItem, newFile));
        }
        /// <summary>Returns folder's remote content or empty if not exists.</summary>
        /// <param name="folderMetadata">The folder metadata.</param>
        /// <returns>The <see cref="IHierarchyItemAsync"/> array.</returns>
        private static IHierarchyItemAsync[] GetRemoteFolderContentOrEmpty(FolderMetadata folderMetadata)
        {
            if (!folderMetadata.ExistsOnServer)
            {
                return(new IHierarchyItemAsync[0]);
            }

            try
            {
                return(folderMetadata.ServerFolder.GetChildrenAsync(false).GetAwaiter().GetResult());
            }
            catch (NotFoundException)
            {
                return(new IHierarchyItemAsync[0]);
            }
        }
        /// <summary>Creates folder on server without local copy.</summary>
        /// <param name="item">The item.</param>
        /// <returns>The <see cref="FolderMetadata"/>.</returns>
        private FolderMetadata CreateOnServer(FolderMetadata item)
        {
            FolderMetadata parent = this.GetFolderMetadata(item.ParentIdentifier);

            return(this.CreateFolderOnServer(parent, item.Name));
        }
 /// <summary>Moves item on server only.</summary>
 /// <param name="item">The item.</param>
 /// <param name="destinationFolder">The destination folder.</param>
 /// <param name="name">The name.</param>
 public void MoveItemOnServer(ItemMetadata item, FolderMetadata destinationFolder, string name)
 {
     item.ServerItem.MoveToAsync(destinationFolder.ServerFolder, name, false, null).GetAwaiter().GetResult();
 }
 /// <summary>Retrieves folder's local and remote content.</summary>
 /// <param name="folderMetadata">The folder metadata.</param>
 /// <returns>The <see cref="ItemMetadata"/> array.</returns>
 public ItemMetadata[] GetFolderChildrenMetadatas(FolderMetadata folderMetadata)
 {
     IHierarchyItemAsync[] serverItems = GetRemoteFolderContentOrEmpty(folderMetadata);
     LocalItem[]           localItems  = this.LocalStorage.GetFolderContentOrEmpty(folderMetadata.LocalFolder);
     return(this.CreateItemMetadatas(folderMetadata.Identifier, localItems, serverItems));
 }