Ejemplo n.º 1
0
        /// <summary>
        /// Moves the files.
        /// </summary>
        /// <param name="origin">The origin directory.</param>
        /// <param name="destination">The destination directory.</param>
        /// <param name="fileGroups">The file groups.</param>
        public static async Task MoveFiles(string origin, string destination, IEnumerable <FileGroup> fileGroups, CancellationToken cancellationToken = default)
        {
            var temp = TempFolderHelper.GetTempFolder();

            Directory.CreateDirectory(temp);
            try
            {
                foreach (var group in fileGroups)
                {
                    await ProcessGroup(origin, temp, group, cancellationToken).ConfigureAwait(false);
                }

                //Now Create all of the directories
                foreach (var dirPath in Directory.GetDirectories(temp, "*",
                                                                 SearchOption.AllDirectories))
                {
                    Directory.CreateDirectory(dirPath.Replace(temp, destination));
                }

                //Copy all the files & Replaces any files with the same name
                foreach (var newPath in Directory.GetFiles(temp, "*",
                                                           SearchOption.AllDirectories))
                {
                    File.Move(newPath, newPath.Replace(temp, destination));
                }
            }
            finally
            {
                Directory.Delete(temp, true);
            }
        }
Ejemplo n.º 2
0
        private static int Main(string[] args)
        {
            var app = new CommandLineApplication();

            app.HelpOption();

            var originPathOption      = app.Option("-p|--path <PATH>", "The origin path", CommandOptionType.SingleValue).IsRequired();
            var destinationPathOption = app.Option("-d|--destination <PATH>", "[optional] The destination path. Defaults to the current working directory", CommandOptionType.SingleValue);

            app.OnExecuteAsync(async(cancellationToken) =>
            {
                var originPath      = originPathOption.Value() ?? throw new InvalidOperationException();
                var destinationPath = destinationPathOption.Value() ?? Environment.CurrentDirectory;

                TempFolderHelper.CleanupAllTempFolders();

                try
                {
                    PrintOpener(originPath, destinationPath);

                    if (Path.GetExtension(originPath) == ".git")
                    {
                        originPath = GitHelper.GetFromUrl(originPath);
                    }

                    var promptResults = await GetPromptResults(originPath).ConfigureAwait(false);

                    var config = await ConfigReader
                                 .GetConfigFromFile(originPath, promptResults)
                                 .ConfigureAwait(false);

                    Console.WriteLine("Moving files...");
                    var filesResult = FileProcessor.GetFilesToMove(originPath, config, promptResults);
                    await FileProcessor
                    .MoveFiles(originPath, destinationPath, filesResult, cancellationToken)
                    .ConfigureAwait(false);

                    Console.WriteLine("All done!");
                }
                finally
                {
                    TempFolderHelper.CleanupAllTempFolders();
                }
                return(0);
            });

            return(app.Execute(args));
        }