Ejemplo n.º 1
0
        private static async Task<StorageFile> SaveFileFromUriAsync(Uri fileUri, string localFileName, string localPath = "Images", NameCollisionOption collisionOption = NameCollisionOption.ReplaceExisting)
        {
            if (localFileName.StartsWith("/"))
                localFileName = localFileName.Substring(1);

            localFileName = Path.GetFileName(localFileName);
            
            var destinationFolder = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync(localPath, CreationCollisionOption.OpenIfExists);

            var outFile = await destinationFolder.CreateFileAsync(localFileName, CreationCollisionOption.OpenIfExists);
            if((await outFile.GetBasicPropertiesAsync()).Size == 0)
            {
                BackgroundDownloader backgroundDownloader = new BackgroundDownloader();
                var download = backgroundDownloader.CreateDownload(fileUri, outFile);
                try
                {
                    download.CostPolicy = BackgroundTransferCostPolicy.Always;
                    var downloadTask = download.StartAsync();
                    await downloadTask;
                }
                catch
                {
                }

            }
            return outFile;
        }
Ejemplo n.º 2
0
 private static async Task<StorageFile> SaveFileFromUriAsync(Uri fileUri, string localFileName, string localPath = "Images", NameCollisionOption collisionOption = NameCollisionOption.ReplaceExisting)
 {
     if (localFileName.StartsWith("/"))
         localFileName = localFileName.Substring(1);
     var file = await StorageFile.CreateStreamedFileFromUriAsync(localFileName, fileUri, Windows.Storage.Streams.RandomAccessStreamReference.CreateFromUri(fileUri));
     var destinationFolder = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync(localPath, CreationCollisionOption.OpenIfExists);
     var outFile = await file.CopyAsync(destinationFolder, file.Name, collisionOption);
     return outFile;
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Downloads a file from the specified address and returns the file.
        /// </summary>
        /// <param name="fileUri">The URI of the file.</param>
        /// <param name="folder">The folder to save the file to.</param>
        /// <param name="fileName">The file name to save the file as.</param>
        /// <param name="option">
        /// A value that indicates what to do
        /// if the filename already exists in the current folder.
        /// </param>
        /// <remarks>
        /// If no file name is given - the method will try to find
        /// the suggested file name in the HTTP response
        /// based on the Content-Disposition HTTP header.
        /// </remarks>
        /// <returns></returns>
        public async static Task<StorageFile> SaveAsync(
            Uri fileUri,
            StorageFolder folder = null,
            string fileName = null,
            NameCollisionOption option = NameCollisionOption.GenerateUniqueName)
        {
            if (folder == null)
            {
                folder = ApplicationData.Current.LocalFolder;
            }

            var file = await folder.CreateTempFileAsync();
            var downloader = new BackgroundDownloader();
            var download = downloader.CreateDownload(
                fileUri,
                file);

            var res = await download.StartAsync();

            if (string.IsNullOrEmpty(fileName))
            {
                // Use temp file name by default
                fileName = file.Name;

                // Try to find a suggested file name in the http response headers
                // and rename the temp file before returning if the name is found.
                var info = res.GetResponseInformation();

                if (info.Headers.ContainsKey("Content-Disposition"))
                {
                    var cd = info.Headers["Content-Disposition"];
                    var regEx = new Regex("filename=\"(?<fileNameGroup>.+?)\"");
                    var match = regEx.Match(cd);

                    if (match.Success)
                    {
                        fileName = match.Groups["fileNameGroup"].Value;
                        await file.RenameAsync(fileName, option);
                        return file;
                    }
                }
            }

            await file.RenameAsync(fileName, option);
            return file;
        }
Ejemplo n.º 4
0
        public override async Task <StorageFolder> CopyAsync(
            StoragePath destinationPath,
            NameCollisionOption options,
            CancellationToken cancellationToken = default
            )
        {
            _ = destinationPath ?? throw new ArgumentNullException(nameof(destinationPath));
            if (!EnumInfo.IsDefined(options))
            {
                throw new ArgumentException(ExceptionStrings.Enum.UndefinedValue(options), nameof(options));
            }

            if (!(destinationPath is PhysicalStoragePath))
            {
                throw new ArgumentException(
                          ExceptionStrings.FsCompatibility.StoragePathTypeNotSupported(),
                          nameof(destinationPath)
                          );
            }

            if (destinationPath.FullPath.Parent is null)
            {
                throw new IOException(ExceptionStrings.StorageFolder.CannotMoveToRootLocation());
            }

            if (destinationPath.FullPath == _fullPath)
            {
                throw new IOException(ExceptionStrings.StorageFolder.CannotCopyToSameLocation());
            }

            var destinationParentFolder = await FsHelper
                                          .GetFolderAsync(destinationPath.FullPath.Parent, cancellationToken)
                                          .ConfigureAwait(false);

            var sourceFolder = await FsHelper.GetFolderAsync(_fullPath, cancellationToken).ConfigureAwait(false);

            await Impl(sourceFolder, destinationParentFolder, destinationPath.FullPath.Name).ConfigureAwait(false);

            return(FileSystem.GetFolder(destinationPath.FullPath));

            async Task Impl(WinStorageFolder src, WinStorageFolder dstFolderParent, string dstFolderName)
            {
                var dstFolder = await dstFolderParent
                                .CreateFolderAsync(dstFolderName, ((CreationCollisionOption)options).ToWinOptions())
                                .AsTask(cancellationToken)
                                .WithConvertedException()
                                .ConfigureAwait(false);

                foreach (var file in await src.GetFilesAsync().AsAwaitable(cancellationToken))
                {
                    await file
                    .CopyAsync(dstFolder, file.Name)
                    .AsTask(cancellationToken)
                    .WithConvertedException()
                    .ConfigureAwait(false);
                }

                foreach (var folder in await src.GetFoldersAsync().AsAwaitable(cancellationToken))
                {
                    await Impl(folder, dstFolder, folder.Name).ConfigureAwait(false);
                }
            }
        }
Ejemplo n.º 5
0
        private async void PlaylistList_ItemClick(object sender, ItemClickEventArgs e)
        {
            PlaylistSongs.Items.Clear();
            const ThumbnailMode thumbnailMode = ThumbnailMode.MusicView;

            Model.Playlist playlistToShow = (Model.Playlist)e.ClickedItem;
            var            fileToShow     = fileList.Where(f => f.Name == playlistToShow.Name).FirstOrDefault();
            Playlist       playlist       = await Playlist.LoadAsync(fileToShow);

            foreach (var s in playlist.Files)
            {
                const uint size = 100;
                using (StorageItemThumbnail thumbnail = await s.GetThumbnailAsync(thumbnailMode, size))
                {
                    // Also verify the type is ThumbnailType.Image (album art) instead of ThumbnailType.Icon
                    // (which may be returned as a fallback if the file does not provide album art)
                    if (thumbnail != null && thumbnail.Type == ThumbnailType.Image)
                    {
                        BitmapImage bitmapImage = new BitmapImage();
                        bitmapImage.SetSource(thumbnail);
                        Model.MediaFile o1 = new Model.AudioFile();
                        Image           i  = new Image();
                        MusicProperties musicProperties = await s.Properties.GetMusicPropertiesAsync();

                        i.Source = bitmapImage;
                        o1.Thumb = i;
                        o1.Title = s.Name;
                        if (musicProperties.Title != "")
                        {
                            o1.Title = musicProperties.Title;
                        }
                        o1.Name = s.Name;
                        o1.Path = "MusicLibrary";
                        PlaylistSongs.Items.Add(o1);
                    }
                }
            }
            PlaylistView.Title = fileToShow.Name.Replace(".wpl", "");
            ContentDialogResult contentDialogResult = await PlaylistView.ShowAsync();

            if (contentDialogResult == ContentDialogResult.Primary)
            {
                playlist.Files.Clear();
                StorageFolder       sf = KnownFolders.MusicLibrary;
                NameCollisionOption collisionOption = NameCollisionOption.ReplaceExisting;
                PlaylistFormat      format          = PlaylistFormat.WindowsMedia;
                foreach (Model.MediaFile item in PlaylistSongs.Items)
                {
                    StorageFile storageFile = await sf.GetFileAsync(item.Name);

                    playlist.Files.Add(storageFile);
                    Debug.WriteLine(item.Name);
                }
                StorageFile savedFile = await playlist.SaveAsAsync(sf, fileToShow.Name.Replace(".wpl", ""), collisionOption, format);
            }
            else if (contentDialogResult == ContentDialogResult.Secondary)
            {
                if (fileToShow != null)
                {
                    Playlist playlistToPlay = await Playlist.LoadAsync(fileToShow);

                    MediaPlaybackList mediaPlaybackList = new MediaPlaybackList();
                    foreach (var f in playlist.Files)
                    {
                        mediaPlaybackList.Items.Add(new MediaPlaybackItem(MediaSource.CreateFromStorageFile(f)));
                    }
                    if (mediaPlaybackList.Items.Count != 0)
                    {
                        mediaElement.Source = mediaPlaybackList;
                        mediaElement.MediaPlayer.Play();
                    }
                }
            }
        }
Ejemplo n.º 6
0
 internal Task Rename(CancellationToken ct, string desiredName, NameCollisionOption option)
 => Implementation.RenameAsync(ct, desiredName, option);
Ejemplo n.º 7
0
 public IAsyncAction RenameAsync(string desiredName, NameCollisionOption option)
 {
     return null;
 }
Ejemplo n.º 8
0
        /// <summary>
        /// Changes folder to new name by adding "_" to its name.
        /// </summary>
        /// <param name="fromName">Path to folder.</param>
        /// <param name="toName"> </param>
        /// <param name="rootFolder"> </param>
        /// <param name="option"> </param>
        /// <returns>Name-changed folder.</returns>
        public async Task<StorageFolder> ChangeFolderName(string fromName,
                                                          string toName,
                                                          StorageFolder rootFolder = null,
                                                          NameCollisionOption option = NameCollisionOption.ReplaceExisting)
        {
            if (string.IsNullOrEmpty(fromName))
            {
                return null;
            }

            fromName = NormalizePath(fromName);

            var changeFolder = rootFolder ?? ApplicationData.Current.LocalFolder;
            try
            {
                changeFolder = await changeFolder.GetFolderAsync(fromName);
            }
            catch (Exception)
            {
                changeFolder = null;
            }

            if (changeFolder != null)
            {
                try
                {
                    if (string.IsNullOrEmpty(toName) || fromName.ToLowerInvariant().EndsWith(toName.ToLowerInvariant()))
                    {
                        return changeFolder;
                    }

                    await changeFolder.RenameAsync(toName, option);
                }
                catch (Exception ex)
                {
                    LogManager.Instance.LogInfo("Cannot change folder name " + fromName + "!" + ex);
                    changeFolder = null;
                }
            }

            return changeFolder;
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Extract a zip file.
        /// </summary>
        /// <param name="desinationFolder">The destination folder for zip file extraction</param>
        /// <param name="collisionOption">How to deal with collisions with existing files.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>A task with a List of strings containing the names of extracted files from the zip archive.</returns>
        public static async Task <List <string> > ExtractZipAsync(IFile zipFile, IFolder desinationFolder, NameCollisionOption collisionOption = NameCollisionOption.ReplaceExisting, CancellationToken cancellationToken = default(CancellationToken))
        {
            var    zipFiles      = new List <string>();
            Stream zipDataStream = await zipFile.OpenAsync(FileAccess.Read, cancellationToken);

            if (zipDataStream == null)
            {
                return(null);
            }
            try
            {
                ZipArchive zipArchive = new ZipArchive(zipDataStream);
                foreach (var zipArchiveEntry in zipArchive.Entries)
                {
                    var zipData = zipArchiveEntry.Open();
                    if (zipData == null)
                    {
                    }
                    else
                    {
                        if (zipArchiveEntry.Name == null || zipArchiveEntry.Name.Length == 0)
                        {
                        }
                        else
                        {
                            IFile file = await desinationFolder.CreateFileAsync(zipArchiveEntry.Name, CreationCollisionOption.ReplaceExisting);
                            await WriteStreamAsync(file, zipData, cancellationToken);

                            zipFiles.Add(zipArchiveEntry.Name);
                        }
                    }
                }
            }
            catch (Exception e)
            {
            }
            return(zipFiles);
        }
Ejemplo n.º 10
0
 public IStorageItem Copy(IFolder destinationFolder, string desiredNewName,
                          NameCollisionOption option = NameCollisionOption.FailIfExists)
 => Copy(destinationFolder.Path, desiredNewName, option);
Ejemplo n.º 11
0
 public IStorageItem Copy(string destinationFolderPath, string desiredNewName,
                          NameCollisionOption option = NameCollisionOption.FailIfExists)
 => Copy(Combine(destinationFolderPath, desiredNewName), option);
Ejemplo n.º 12
0
 public async Task <IStorageHistory> CopyAsync(IStorageItemWithPath source, string destination, NameCollisionOption collision, IProgress <float> progress, IProgress <FileSystemStatusCode> errorCode, CancellationToken cancellationToken)
 {
     return(await CopyItemsAsync(source.CreateEnumerable(), destination.CreateEnumerable(), collision.ConvertBack().CreateEnumerable(), progress, errorCode, cancellationToken));
 }
Ejemplo n.º 13
0
        /// <summary>
        /// Renames a file without changing its location.
        /// </summary>
        /// <param name="newName">The new leaf name of the file.</param>
        /// <param name="collisionOption">How to deal with collisions with existing files.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A task which will complete after the file is renamed.
        /// </returns>
        public async Task RenameAsync(string newName, NameCollisionOption collisionOption, CancellationToken cancellationToken)
        {
            Requires.NotNullOrEmpty(newName, "newName");

            await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
            string newPath = PortablePath.Combine(System.IO.Path.GetDirectoryName(_path), newName);
            await MoveAsync(newPath, collisionOption, cancellationToken);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Renames the current file.
        /// This method also specifies what to do if an existing item in the current file's location has the same name.
        /// </summary>
        /// <param name="desiredName">The desired, new name of the current file.
        /// <para>If there is an existing item in the current file's location that already has the specified desiredName, the specified <see cref="NameCollisionOption"/>  determines how the system responds to the conflict.</para></param>
        /// <param name="option">The enum value that determines how the system responds if the desiredName is the same as the name of an existing item in the current file's location.</param>
        /// <returns>No object or value is returned by this method when it completes.</returns>
        public Task RenameAsync(string desiredName, NameCollisionOption option)
        {
            if(string.IsNullOrEmpty(desiredName))
            {
                throw new ArgumentNullException("desiredName");
            }

#if WINDOWS_UWP || WINDOWS_APP || WINDOWS_PHONE_APP || WINDOWS_PHONE
            return _file.RenameAsync(desiredName, (Windows.Storage.NameCollisionOption)((int)option)).AsTask();
#elif __ANDROID__ || __UNIFIED__ || WIN32 || TIZEN
            return Task.Run(() =>
            {
                string folder = global::System.IO.Path.GetDirectoryName(Path);
                string newPath = global::System.IO.Path.Combine(folder, desiredName);
                switch(option)
                {

                    case NameCollisionOption.GenerateUniqueName:
                        string generatedPath = newPath;
                        int num = 2;
                        while(File.Exists(generatedPath))
                        {
                            generatedPath = global::System.IO.Path.Combine(folder, global::System.IO.Path.GetFileNameWithoutExtension(desiredName), string.Format("({0})", num), global::System.IO.Path.GetExtension(desiredName));
                            num++;
                        }
                        newPath = generatedPath;
                        break;

                    case NameCollisionOption.ReplaceExisting:

                        if(File.Exists(newPath))
                        {
                            File.Delete(newPath);
                        }
                        break;

                    default:
                        break;
                }

                File.Move(Path, global::System.IO.Path.Combine(global::System.IO.Path.GetDirectoryName(Path), desiredName));
                _path = newPath;
            });
#else
            throw new PlatformNotSupportedException();
#endif
        }
Ejemplo n.º 15
0
 public IStorageItem Copy(IFolder destinationFolder,
                          NameCollisionOption option = NameCollisionOption.FailIfExists)
 => Copy(destinationFolder, Name, option);
Ejemplo n.º 16
0
        public async Task <IStorageHistory> RenameAsync(IStorageItemWithPath source,
                                                        string newName,
                                                        NameCollisionOption collision,
                                                        IProgress <FileSystemStatusCode> errorCode,
                                                        CancellationToken cancellationToken)
        {
            if (Path.GetFileName(source.Path) == newName && collision == NameCollisionOption.FailIfExists)
            {
                errorCode?.Report(FileSystemStatusCode.AlreadyExists);
                return(null);
            }

            if (!string.IsNullOrWhiteSpace(newName) &&
                !FilesystemHelpers.ContainsRestrictedCharacters(newName) &&
                !FilesystemHelpers.ContainsRestrictedFileName(newName))
            {
                var renamed = await source.ToStorageItemResult(associatedInstance)
                              .OnSuccess(async(t) =>
                {
                    if (t.Name.Equals(newName, StringComparison.CurrentCultureIgnoreCase))
                    {
                        await t.RenameAsync(newName, NameCollisionOption.ReplaceExisting);
                    }
                    else
                    {
                        await t.RenameAsync(newName, collision);
                    }
                    return(t);
                });

                if (renamed)
                {
                    errorCode?.Report(FileSystemStatusCode.Success);
                    return(new StorageHistory(FileOperationType.Rename, source, renamed.Result.FromStorageItem()));
                }
                else if (renamed == FileSystemStatusCode.Unauthorized)
                {
                    // Try again with MoveFileFromApp
                    var destination = Path.Combine(Path.GetDirectoryName(source.Path), newName);
                    if (NativeFileOperationsHelper.MoveFileFromApp(source.Path, destination))
                    {
                        errorCode?.Report(FileSystemStatusCode.Success);
                        return(new StorageHistory(FileOperationType.Rename, source, StorageItemHelpers.FromPathAndType(destination, source.ItemType)));
                    }
                    else
                    {
                        Debug.WriteLine(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
                    }
                }
                else if (renamed == FileSystemStatusCode.NotAFile || renamed == FileSystemStatusCode.NotAFolder)
                {
                    await DialogDisplayHelper.ShowDialogAsync("RenameError/NameInvalid/Title".GetLocalized(), "RenameError/NameInvalid/Text".GetLocalized());
                }
                else if (renamed == FileSystemStatusCode.NameTooLong)
                {
                    await DialogDisplayHelper.ShowDialogAsync("RenameError/TooLong/Title".GetLocalized(), "RenameError/TooLong/Text".GetLocalized());
                }
                else if (renamed == FileSystemStatusCode.InUse)
                {
                    // TODO: proper dialog, retry
                    await DialogDisplayHelper.ShowDialogAsync("FileInUseDeleteDialog/Title".GetLocalized(), "");
                }
                else if (renamed == FileSystemStatusCode.NotFound)
                {
                    await DialogDisplayHelper.ShowDialogAsync("RenameError/ItemDeleted/Title".GetLocalized(), "RenameError/ItemDeleted/Text".GetLocalized());
                }
                else if (renamed == FileSystemStatusCode.AlreadyExists)
                {
                    var ItemAlreadyExistsDialog = new ContentDialog()
                    {
                        Title               = "ItemAlreadyExistsDialogTitle".GetLocalized(),
                        Content             = "ItemAlreadyExistsDialogContent".GetLocalized(),
                        PrimaryButtonText   = "ItemAlreadyExistsDialogPrimaryButtonText".GetLocalized(),
                        SecondaryButtonText = "ItemAlreadyExistsDialogSecondaryButtonText".GetLocalized(),
                        CloseButtonText     = "ItemAlreadyExistsDialogCloseButtonText".GetLocalized()
                    };

                    if (UIHelpers.IsAnyContentDialogOpen())
                    {
                        // Only a single ContentDialog can be open at any time.
                        return(null);
                    }
                    ContentDialogResult result = await ItemAlreadyExistsDialog.ShowAsync();

                    if (result == ContentDialogResult.Primary)
                    {
                        return(await RenameAsync(source, newName, NameCollisionOption.GenerateUniqueName, errorCode, cancellationToken));
                    }
                    else if (result == ContentDialogResult.Secondary)
                    {
                        return(await RenameAsync(source, newName, NameCollisionOption.ReplaceExisting, errorCode, cancellationToken));
                    }
                }
                errorCode?.Report(renamed);
            }

            return(null);
        }
Ejemplo n.º 17
0
 public abstract void Move(string destinationFullPath,
                           NameCollisionOption option = NameCollisionOption.FailIfExists);
Ejemplo n.º 18
0
        public static async Task <SafeWrapperResult> RenameItem(IStorageItem item, string newName, NameCollisionOption collision = NameCollisionOption.GenerateUniqueName)
        {
            SafeWrapperResult result = await SafeWrapperRoutines.SafeWrapAsync(async() => await item.RenameAsync(newName, collision).AsTask());

            return(result);
        }
Ejemplo n.º 19
0
 public abstract void Move(string destinationFolderPath, string desiredNewName,
                           NameCollisionOption option = NameCollisionOption.FailIfExists);
Ejemplo n.º 20
0
        /// <summary>
        /// Renames a file without changing its location.
        /// </summary>
        /// <param name="newName">The new leaf name of the file.</param>
        /// <param name="collisionOption">How to deal with collisions with existing files.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A task which will complete after the file is renamed.
        /// </returns>
        public async Task RenameAsync(string newName, NameCollisionOption collisionOption, CancellationToken cancellationToken)
        {
            Requires.NotNullOrEmpty(newName, "newName");

            try
            {
                await _wrappedFile.RenameAsync(newName, (Windows.Storage.NameCollisionOption)collisionOption).AsTask(cancellationToken).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                if (ex.HResult == FILE_ALREADY_EXISTS)
                {
                    throw new IOException("File already exists.", ex);
                }

                throw;
            }
        }
Ejemplo n.º 21
0
 public abstract void Move(IFolder destinationFolder,
                           NameCollisionOption option = NameCollisionOption.FailIfExists);
Ejemplo n.º 22
0
 public Windows.Foundation.IAsyncAction RenameAsync(string desiredName, NameCollisionOption option)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 23
0
 /// <summary>
 /// Renames the current item. This method also specifies what to do if an existing
 ///     item in the current item's location has the same name.
 /// </summary>
 /// <param name="desiredName">The desired, new name of the current item.</param>
 /// <param name="option">
 /// The <see cref="Enum"/> value that determines how responds if the <see cref="desiredName"/> is the
 ///     same as the name of an existing item in the current item's location.
 ///     Default value is "<see cref="NameCollisionOption.FailIfExists"/>".
 /// </param>
 public abstract void Rename(string desiredName,
                             NameCollisionOption option = NameCollisionOption.FailIfExists);
 public IAsyncAction MoveAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 {
     throw new System.NotImplementedException();
 }
Ejemplo n.º 25
0
        public async Task <IStorageFile> CopyTo(IStorageFolder folderdestination, string filenamewithextension, NameCollisionOption option)
        {
            var status = await new PermissionRequest().Request();

            if (!status)
            {
                return(null);
            }
            if (await Exists())
            {
                string outfilepath = Path.Combine(folderdestination.FullPath, filenamewithextension);
                if (option == NameCollisionOption.FailIfExists)
                {
                    if (File.Exists(outfilepath))
                    {
                        throw new Exception("El archivo que tratas de copiar ya existe");
                    }
                }
                else
                {
                    if (option == NameCollisionOption.GenerateUniqueName)
                    {
                        outfilepath = Path.Combine(folderdestination.FullPath, UniqueString() + filenamewithextension);
                    }
                    else
                    {
                        File.Delete(outfilepath);
                    }
                }
                File.Copy(FullPath, outfilepath);
                if (File.Exists(outfilepath))
                {
                    return(await GetFileFromPath(outfilepath));
                }
                else
                {
                    throw new FileNotFoundException("No fue posible copiar el archivo");
                }
            }
            return(null);
        }
Ejemplo n.º 26
0
 internal Task Move(CancellationToken ct, IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 => Implementation.MoveAsync(ct, destinationFolder, desiredNewName, option);
Ejemplo n.º 27
0
 public async Task RenameAsync(string newName, NameCollisionOption collisionOption = NameCollisionOption.FailIfExists,
                               CancellationToken cancellationToken = new CancellationToken())
 {
     throw new NotImplementedException();
 }
        /// <summary>
        /// Renames a file without changing its location.
        /// </summary>
        /// <param name="newName">The new leaf name of the file.</param>
        /// <param name="collisionOption">How to deal with collisions with existing files.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A task which will complete after the file is renamed.
        /// </returns>
        public async Task RenameAsync(string newName, NameCollisionOption collisionOption, CancellationToken cancellationToken)
        {
            Requires.NotNullOrEmpty(newName, "newName");

            await MoveAsync(PortablePath.Combine(System.IO.Path.GetDirectoryName(_path), newName), collisionOption, cancellationToken);
        }
Ejemplo n.º 29
0
 public async Task MoveAsync(string newPath, NameCollisionOption collisionOption = NameCollisionOption.ReplaceExisting,
                             CancellationToken cancellationToken = new CancellationToken())
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 30
0
        public override async Task <StorageFolder> RenameAsync(
            string newName,
            NameCollisionOption options,
            CancellationToken cancellationToken = default
            )
        {
            _ = newName ?? throw new ArgumentNullException(nameof(newName));
            if (newName.Length == 0)
            {
                throw new ArgumentException(ExceptionStrings.String.CannotBeEmpty(), nameof(newName));
            }

            if (newName.Contains(PhysicalPathHelper.InvalidNewNameCharacters))
            {
                throw new ArgumentException(
                          ExceptionStrings.StorageFolder.NewNameContainsInvalidChar(FileSystem.PathInformation),
                          nameof(newName)
                          );
            }

            if (!EnumInfo.IsDefined(options))
            {
                throw new ArgumentException(ExceptionStrings.Enum.UndefinedValue(options), nameof(options));
            }

            var srcFolder = await FsHelper.GetFolderAsync(_fullPath, cancellationToken).ConfigureAwait(false);

            var fullDestinationPath = _fullParentPath is null
                ? FileSystem.GetPath(newName).FullPath
                : _fullParentPath.Join(newName).FullPath;

            // The Windows Storage API doesn't do a hard replace with the ReplaceExisting option.
            // For example, if we had this structure:
            // |_ src
            // |  |_ foo.ext
            // |_ dst
            //    |_ bar.ext
            //
            // and renamed `src` to `dst`, we'd get this result:
            // |_ dst
            //    |_ foo.ext
            //    |_ bar.ext
            //
            // What we (and the spec) want is this:
            // |_ dst
            //    |_ foo.ext
            //
            // We can manually delete the dst folder if it exists to fulfill the specification.
            // We're *only* doing it if we can be sure that we're not doing an in-place rename though,
            // i.e. rename `src` to `src`.
            // Otherwise we'd run into the problem that `src` is deleted and that the rename operation
            // will fail (DirectoryNotFound). Afterwards the entire folder is gone permanently.
            // That must be avoided at all cost.
            if (options == NameCollisionOption.ReplaceExisting &&
                !fullDestinationPath.Name.Equals(_fullPath.Name, FileSystem.PathInformation.DefaultStringComparison))
            {
                try
                {
                    var dstFolder = await FsHelper.GetFolderAsync(fullDestinationPath, cancellationToken).ConfigureAwait(false);

                    await dstFolder.DeleteAsync(StorageDeleteOption.PermanentDelete).AsAwaitable(cancellationToken);
                }
                catch
                {
                    // If deleting the conflicting folder fails, it's okay, since the whole process
                    // is just there for fulfilling the specification.
                    // The Windows Storage API will still replace conflicting elements.
                    // It's just that certain files may be left over (as described above).
                    // Not fulfilling the spec is the best thing we can do without taking higher risks
                    // of lost data.
                }
            }

            await srcFolder
            .RenameAsync(newName, options.ToWinOptions())
            .AsTask(cancellationToken)
            .WithConvertedException()
            .ConfigureAwait(false);

            return(FileSystem.GetFolder(fullDestinationPath));
        }
Ejemplo n.º 31
0
        /// <summary>
        /// Moves a file.
        /// </summary>
        /// <param name="newPath">The new full path of the file.</param>
        /// <param name="collisionOption">How to deal with collisions with existing files.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A task which will complete after the file is moved.
        /// </returns>
        public async Task MoveAsync(string newPath, NameCollisionOption collisionOption, CancellationToken cancellationToken)
        {
            Requires.NotNullOrEmpty(newPath, "newPath");

            await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);

            string newDirectory = System.IO.Path.GetDirectoryName(newPath);
            string newName = System.IO.Path.GetFileName(newPath);

            for (int counter = 1; ; counter++)
            {
                cancellationToken.ThrowIfCancellationRequested();
                string candidateName = newName;
                if (counter > 1)
                {
                    candidateName = String.Format(
                        CultureInfo.InvariantCulture,
                        "{0} ({1}){2}",
                        System.IO.Path.GetFileNameWithoutExtension(newName),
                        counter,
                        System.IO.Path.GetExtension(newName));
                }

                string candidatePath = PortablePath.Combine(newDirectory, candidateName);

                if (File.Exists(candidatePath))
                {
                    switch (collisionOption)
                    {
                        case NameCollisionOption.FailIfExists:
                            throw new IOException("File already exists.");
                        case NameCollisionOption.GenerateUniqueName:
                            continue; // try again with a new name.
                        case NameCollisionOption.ReplaceExisting:
                            File.Delete(candidatePath);
                            break;
                    }
                }

                File.Move(_path, candidatePath);
                _path = candidatePath;
                _name = candidateName;
                return;
            }
        }
Ejemplo n.º 32
0
 /// <summary>
 /// Extract a zip file.
 /// </summary>
 /// <param name="desinationFolder">The destination folder for zip file extraction</param>
 /// <param name="collisionOption">How to deal with collisions with existing files.</param>
 /// <param name="cancellationToken">The cancellation token.</param>
 /// <returns>A task with a List of strings containing the names of extracted files from the zip archive.</returns>
 public async Task <List <string> > ExtractZipAsync(IFolder desinationFolder, NameCollisionOption collisionOption = NameCollisionOption.ReplaceExisting, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(await TargetPlatformFileSystem.ExtractZipAsync(this, desinationFolder, collisionOption, cancellationToken));
 }
Ejemplo n.º 33
0
        /// <summary>
        /// Renames a file without changing its location.
        /// </summary>
        /// <param name="newName">The new leaf name of the file.</param>
        /// <param name="collisionOption">How to deal with collisions with existing files.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A task which will complete after the file is renamed.
        /// </returns>
        public async Task RenameAsync(string newName, NameCollisionOption collisionOption, CancellationToken cancellationToken)
        {
            Requires.NotNullOrEmpty(newName, "newName");

            await MoveAsync(PortablePath.Combine(System.IO.Path.GetDirectoryName(_path), newName), collisionOption, cancellationToken);
        }
Ejemplo n.º 34
0
        public async Task <IStorageHistory> CopyAsync(IStorageItemWithPath source,
                                                      string destination,
                                                      NameCollisionOption collision,
                                                      IProgress <float> progress,
                                                      IProgress <FileSystemStatusCode> errorCode,
                                                      CancellationToken cancellationToken)
        {
            if (associatedInstance.FilesystemViewModel.WorkingDirectory.StartsWith(App.AppSettings.RecycleBinPath))
            {
                errorCode?.Report(FileSystemStatusCode.Unauthorized);
                progress?.Report(100.0f);

                // Do not paste files and folders inside the recycle bin
                await DialogDisplayHelper.ShowDialogAsync(
                    "ErrorDialogThisActionCannotBeDone".GetLocalized(),
                    "ErrorDialogUnsupportedOperation".GetLocalized());

                return(null);
            }

            IStorageItem copiedItem = null;

            //long itemSize = await FilesystemHelpers.GetItemSize(await source.ToStorageItem(associatedInstance));

            if (source.ItemType == FilesystemItemType.Directory)
            {
                if (!string.IsNullOrWhiteSpace(source.Path) &&
                    Path.GetDirectoryName(destination).IsSubPathOf(source.Path)) // We check if user tried to copy anything above the source.ItemPath
                {
                    var           destinationName = destination.Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries).Last();
                    var           sourceName      = source.Path.Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries).Last();
                    ContentDialog dialog          = new ContentDialog()
                    {
                        Title   = "ErrorDialogThisActionCannotBeDone".GetLocalized(),
                        Content = $"{"ErrorDialogTheDestinationFolder".GetLocalized()} ({destinationName}) {"ErrorDialogIsASubfolder".GetLocalized()} (sourceName)",
                        //PrimaryButtonText = "ErrorDialogSkip".GetLocalized(),
                        CloseButtonText = "ErrorDialogCancel".GetLocalized()
                    };

                    ContentDialogResult result = await dialog.ShowAsync();

                    if (result == ContentDialogResult.Primary)
                    {
                        progress?.Report(100.0f);
                        errorCode?.Report(FileSystemStatusCode.InProgress | FileSystemStatusCode.Success);
                    }
                    else
                    {
                        progress?.Report(100.0f);
                        errorCode?.Report(FileSystemStatusCode.InProgress | FileSystemStatusCode.Generic);
                    }
                    return(null);
                }
                else
                {
                    // CopyFileFromApp only works on file not directories
                    var fsSourceFolder = await source.ToStorageItemResult(associatedInstance);

                    var fsDestinationFolder = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(Path.GetDirectoryName(destination));

                    var fsResult = (FilesystemResult)(fsSourceFolder.ErrorCode | fsDestinationFolder.ErrorCode);

                    if (fsResult)
                    {
                        var fsCopyResult = await FilesystemTasks.Wrap(() => CloneDirectoryAsync((StorageFolder)fsSourceFolder, (StorageFolder)fsDestinationFolder, fsSourceFolder.Result.Name, collision.Convert()));

                        if (fsCopyResult == FileSystemStatusCode.AlreadyExists)
                        {
                            errorCode?.Report(FileSystemStatusCode.AlreadyExists);
                            progress?.Report(100.0f);
                            return(null);
                        }

                        if (fsCopyResult)
                        {
                            if (FolderHelpers.CheckFolderForHiddenAttribute(source.Path))
                            {
                                // The source folder was hidden, apply hidden attribute to destination
                                NativeFileOperationsHelper.SetFileAttribute(fsCopyResult.Result.Path, FileAttributes.Hidden);
                            }
                            copiedItem = (StorageFolder)fsCopyResult;
                        }
                        fsResult = fsCopyResult;
                    }
                    errorCode?.Report(fsResult.ErrorCode);
                    if (!fsResult)
                    {
                        return(null);
                    }
                }
            }
            else if (source.ItemType == FilesystemItemType.File)
            {
                var fsResult = (FilesystemResult)await Task.Run(() => NativeFileOperationsHelper.CopyFileFromApp(source.Path, destination, true));

                if (!fsResult)
                {
                    Debug.WriteLine(System.Runtime.InteropServices.Marshal.GetLastWin32Error());

                    FilesystemResult <StorageFolder> destinationResult = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(Path.GetDirectoryName(destination));

                    var sourceResult = await source.ToStorageItemResult(associatedInstance);

                    fsResult = sourceResult.ErrorCode | destinationResult.ErrorCode;

                    if (fsResult)
                    {
                        var file         = (StorageFile)sourceResult;
                        var fsResultCopy = await FilesystemTasks.Wrap(() => file.CopyAsync(destinationResult.Result, Path.GetFileName(file.Name), collision).AsTask());

                        if (fsResultCopy == FileSystemStatusCode.AlreadyExists)
                        {
                            errorCode?.Report(FileSystemStatusCode.AlreadyExists);
                            progress?.Report(100.0f);
                            return(null);
                        }

                        if (fsResultCopy)
                        {
                            copiedItem = fsResultCopy.Result;
                        }
                        fsResult = fsResultCopy;
                    }
                }
                errorCode?.Report(fsResult.ErrorCode);
                if (!fsResult)
                {
                    return(null);
                }
            }

            if (Path.GetDirectoryName(destination) == associatedInstance.FilesystemViewModel.WorkingDirectory)
            {
                await Windows.ApplicationModel.Core.CoreApplication.MainView.DispatcherQueue.EnqueueAsync(async() =>
                {
                    await Task.Delay(50); // Small delay for the item to appear in the file list
                    List <ListedItem> copiedListedItems = associatedInstance.FilesystemViewModel.FilesAndFolders
                                                          .Where(listedItem => destination.Contains(listedItem.ItemPath)).ToList();

                    if (copiedListedItems.Count > 0)
                    {
                        itemManipulationModel.AddSelectedItems(copiedListedItems);
                        itemManipulationModel.FocusSelectedItems();
                    }
                }, Windows.System.DispatcherQueuePriority.Low);
            }

            progress?.Report(100.0f);

            if (collision == NameCollisionOption.ReplaceExisting)
            {
                errorCode?.Report(FileSystemStatusCode.Success);

                return(null); // Cannot undo overwrite operation
            }

            var pathWithType = copiedItem.FromStorageItem(destination, source.ItemType);

            return(new StorageHistory(FileOperationType.Copy, source, pathWithType));
        }
Ejemplo n.º 35
0
        public override IAsyncOperation <BaseStorageFile> CopyAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
        {
            return(AsyncInfo.Run(async(cancellationToken) =>
            {
                using var ftpClient = new FtpClient();
                ftpClient.Host = FtpHelpers.GetFtpHost(Path);
                ftpClient.Port = FtpHelpers.GetFtpPort(Path);
                ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);

                if (!await ftpClient.EnsureConnectedAsync())
                {
                    return null;
                }

                BaseStorageFolder destFolder = destinationFolder.AsBaseStorageFolder();
                BaseStorageFile file = await destFolder.CreateFileAsync(desiredNewName, option.Convert());
                var stream = await file.OpenStreamForWriteAsync();

                if (await ftpClient.DownloadAsync(stream, FtpPath, token: cancellationToken))
                {
                    return file;
                }

                return null;
            }));
        }
Ejemplo n.º 36
0
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // METHODS //////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public async Task RenameFileAsync(string newName, NameCollisionOption collisionOption)
        {
            await ScanFile.RenameAsync(newName, collisionOption);

            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ScanFile)));
        }
Ejemplo n.º 37
0
 public override IAsyncAction MoveAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option) => throw new NotSupportedException();
Ejemplo n.º 38
0
 public IAsyncOperation<StorageFile> CopyAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 39
0
            public virtual async Task RenameAsync(CancellationToken ct, string desiredName, NameCollisionOption option)
            {
                var parent = await GetParentAsync(ct);

                if (parent == null)
                {
                    throw new InvalidOperationException("The file's parent is not accessible, so we cannot move the file to rename it.");
                }

                await MoveAsync(ct, parent, desiredName, option);
            }
Ejemplo n.º 40
0
        /// <summary>
        /// Moves a file.
        /// </summary>
        /// <param name="newPath">The new full path of the file.</param>
        /// <param name="collisionOption">How to deal with collisions with existing files.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A task which will complete after the file is moved.
        /// </returns>
        public async Task MoveAsync(string newPath, NameCollisionOption collisionOption, CancellationToken cancellationToken)
        {
            Requires.NotNullOrEmpty(newPath, "newPath");

            var newFolder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(newPath)).AsTask(cancellationToken).ConfigureAwait(false);
            string newName = System.IO.Path.GetFileName(newPath);

            try
            {
                await _wrappedFile.MoveAsync(newFolder, newName, (Windows.Storage.NameCollisionOption)collisionOption).AsTask(cancellationToken).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                if (ex.HResult == FILE_ALREADY_EXISTS)
                {
                    throw new IOException("File already exists.", ex);
                }

                throw;
            }
        }
Ejemplo n.º 41
0
            public virtual async Task MoveAsync(CancellationToken ct, IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
            {
                var dst = await CreateDestination(ct, destinationFolder, desiredNewName, option);

                await MoveAndReplaceAsync(ct, dst);
            }
Ejemplo n.º 42
0
 public IAsyncAction MoveAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 {
     return null;
 }
Ejemplo n.º 43
0
 public IAsyncOperation <StorageFile> CopyAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 => AsyncOperation <StorageFile> .FromTask((ct, _) => Implementation.CopyAsync(ct, destinationFolder, desiredNewName, option));
Ejemplo n.º 44
0
 public IAsyncOperation<StorageFile> CopyAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 {
     return null;
 }
Ejemplo n.º 45
0
 public IAsyncAction RenameAsync(string desiredName, NameCollisionOption option)
 => AsyncAction.FromTask(ct => Implementation.RenameAsync(ct, desiredName, option));
Ejemplo n.º 46
0
 public Windows.Foundation.IAsyncAction MoveAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 47
0
 public IAsyncAction MoveAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 => AsyncAction.FromTask(ct => Implementation.MoveAsync(ct, destinationFolder, desiredNewName, option));
Ejemplo n.º 48
0
        private static async Task<StorageFile> GenerateResizedImageAsync(StorageFile inputFile, uint width, uint height, uint edgePadding = 5, uint bottomPadding = 20, NameCollisionOption collisionOption = NameCollisionOption.ReplaceExisting)
        {
            try
            {
                string fileName = inputFile.DisplayName + width + "x" + height;
                string extension = inputFile.Name.Substring(inputFile.Name.LastIndexOf('.'));

                string folder = inputFile.Path.Substring(0, inputFile.Path.LastIndexOf('\\'));
                var outputFolder = await StorageFolder.GetFolderFromPathAsync(folder);
                var newFile = await outputFolder.CreateFileAsync(fileName + extension, CreationCollisionOption.ReplaceExisting);

                var inputStream = await inputFile.OpenAsync(Windows.Storage.FileAccessMode.Read);
                var outputStream = await newFile.OpenTransactedWriteAsync();

                var inMemStream = new InMemoryRandomAccessStream();
                var decoder = await BitmapDecoder.CreateAsync(inputStream);
                var encoder = await BitmapEncoder.CreateForTranscodingAsync(inMemStream, decoder);

                // Find aspect ratio for resize
                float nPercentW = (((float)width - (edgePadding * 2)) / (float)decoder.PixelWidth);
                float nPercentH = (((float)height - (edgePadding * 2)) / (float)decoder.PixelHeight);
                float nPercent = nPercentH < nPercentW ? nPercentH : nPercentW;

                // Scale height and width
                if (nPercent < 1)
                {
                    encoder.BitmapTransform.ScaledHeight = (uint)(decoder.PixelHeight * nPercent);
                    encoder.BitmapTransform.ScaledWidth = (uint)(decoder.PixelWidth * nPercent);
                }

                // Image may still exceed intended bounds, resize as appropriate
                if (encoder.BitmapTransform.ScaledWidth > width || encoder.BitmapTransform.ScaledHeight > height)
                {
                    BitmapBounds bounds = new BitmapBounds();
                    if (encoder.BitmapTransform.ScaledWidth > width)
                    {
                        bounds.Width = width;
                        bounds.X = (encoder.BitmapTransform.ScaledWidth - width) / 2;
                    }
                    else
                        bounds.Width = encoder.BitmapTransform.ScaledWidth;
                    if (encoder.BitmapTransform.ScaledHeight > height)
                    {
                        bounds.Height = height;
                        bounds.Y = (encoder.BitmapTransform.ScaledHeight - height) / 2;
                    }
                    else
                        bounds.Height = encoder.BitmapTransform.ScaledHeight;
                    encoder.BitmapTransform.Bounds = bounds;
                }
                await encoder.FlushAsync();

                var outDecoder = await BitmapDecoder.CreateAsync(inMemStream);
                var outEncoder = await BitmapEncoder.CreateForTranscodingAsync(outputStream.Stream, outDecoder);

                var transparentBytes = GenerateTransparentBitmap(width, height);

                PixelDataProvider data = await outDecoder.GetPixelDataAsync();
                uint heightOffset = (height - outDecoder.PixelHeight) / 2 - bottomPadding;
                uint widthOffset = (width - outDecoder.PixelWidth) / 2;
                byte[] bytes = MergePixelArrays(transparentBytes, width, height, data.DetachPixelData(), outDecoder.PixelWidth, outDecoder.PixelHeight, widthOffset, heightOffset);
                outEncoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, width, height, 72.0, 72.0, bytes);

                await outEncoder.FlushAsync();
                return newFile;
            }
            catch (Exception)
            {

            }

            return null;
        }
 public IAsyncAction RenameAsync(string desiredName, NameCollisionOption option)
 {
     throw new System.NotImplementedException();
 }