public async Task WhenConvertSourceToVhdDestinationThenReadDataIsIdentical() { // arrange var sourcePath = $"{Guid.NewGuid()}.img"; var destinationPath = $"{Guid.NewGuid()}.vhd"; var fakeCommandHelper = new FakeCommandHelper(new [] { sourcePath }, new [] { destinationPath }); var cancellationTokenSource = new CancellationTokenSource(); // act - read source img to destination vhd var convertCommand = new ConvertCommand(new NullLogger <ConvertCommand>(), fakeCommandHelper, sourcePath, destinationPath); var result = await convertCommand.Execute(cancellationTokenSource.Token); Assert.True(result.IsSuccess); // get source bytes var sourceBytes = fakeCommandHelper.GetMedia(sourcePath).GetBytes(); // get destination bytes from vhd var destinationBytes = await ReadMediaBytes(fakeCommandHelper, destinationPath, sourceBytes.Length); var destinationPathSize = new FileInfo(destinationPath).Length; // assert length is not the same (vhd file format different than img) and bytes are the same Assert.NotEqual(sourceBytes.Length, destinationPathSize); Assert.Equal(sourceBytes, destinationBytes); // delete destination path vhd File.Delete(destinationPath); }
public async Task <ActionResult <BalanceDto> > Convert( [FromBody] ConvertCommand command, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); return(Ok(await _mediator.Send(command, cancellationToken))); }
public async Task WhenConvertSourceToImgDestinationThenReadDataIsIdentical() { // arrange var sourcePath = $"{Guid.NewGuid()}.img"; var destinationPath = $"{Guid.NewGuid()}.img"; var fakeCommandHelper = new FakeCommandHelper(new [] { sourcePath }, new [] { destinationPath }); var cancellationTokenSource = new CancellationTokenSource(); // act - convert source img to destination img var convertCommand = new ConvertCommand(new NullLogger <ConvertCommand>(), fakeCommandHelper, sourcePath, destinationPath); DataProcessedEventArgs dataProcessedEventArgs = null; convertCommand.DataProcessed += (_, args) => { dataProcessedEventArgs = args; }; var result = await convertCommand.Execute(cancellationTokenSource.Token); Assert.True(result.IsSuccess); Assert.NotNull(dataProcessedEventArgs); Assert.NotEqual(0, dataProcessedEventArgs.PercentComplete); Assert.NotEqual(0, dataProcessedEventArgs.BytesProcessed); Assert.Equal(0, dataProcessedEventArgs.BytesRemaining); Assert.NotEqual(0, dataProcessedEventArgs.BytesTotal); // assert data is identical var sourceBytes = fakeCommandHelper.GetMedia(sourcePath).GetBytes(); var destinationBytes = fakeCommandHelper.GetMedia(destinationPath).GetBytes(); Assert.Equal(sourceBytes, destinationBytes); }
public JsonView() { InitializeComponent(); addCommand = Resources["ConvertCommand"] as ConvertCommand; model = Resources["JsonViewModel"] as JsonViewModel; addCommand.ConvertAction = model.ConvertAction; }
public CurrencyVM() { Currencies = new ObservableCollection <string>(); FullCurrency = new ObservableCollection <string>(); Transaction = new Transaction(); ConvertCommand = new ConvertCommand(this); getCurrencies(); }
public VidConverterViewModel() { ConvertCommand = new ConvertCommand(this); BrowseFilesCommand = new BrowseFilesCommand(this); BrowseDirectoriesCommand = new BrowseDirectoriesCommand(this); CurrVidPath = "Select a video file you'd like to convert..."; CurrOutputDir = "Select output folder (will be same as video file's if unselected)"; VidConverter = new VidConverter(); VidConverter.PropertyChanged += VidConverter_PropertyChanged; }
public async ValueTask Handle(IBackgroundTaskContext context) { if (context.BackgroundTask is not ConvertBackgroundTask convertBackgroundTask) { return; } try { var commandHelper = new CommandHelper(); var convertCommand = new ConvertCommand(loggerFactory.CreateLogger <ConvertCommand>(), commandHelper, convertBackgroundTask.SourcePath, convertBackgroundTask.DestinationPath); convertCommand.DataProcessed += async(_, args) => { await progressHubContext.SendProgress(new Progress { Title = convertBackgroundTask.Title, IsComplete = false, PercentComplete = args.PercentComplete, BytesProcessed = args.BytesProcessed, BytesRemaining = args.BytesRemaining, BytesTotal = args.BytesTotal, MillisecondsElapsed = args.PercentComplete > 0 ? (long)args.TimeElapsed.TotalMilliseconds : new long?(), MillisecondsRemaining = args.PercentComplete > 0 ? (long)args.TimeRemaining.TotalMilliseconds : new long?(), MillisecondsTotal = args.PercentComplete > 0 ? (long)args.TimeTotal.TotalMilliseconds : new long?() }, context.Token); }; var result = await convertCommand.Execute(context.Token); await progressHubContext.SendProgress(new Progress { Title = convertBackgroundTask.Title, IsComplete = true, HasError = result.IsFaulted, ErrorMessage = result.IsFaulted ? result.Error.Message : null, PercentComplete = 100 }, context.Token); } catch (Exception e) { await progressHubContext.SendProgress(new Progress { Title = convertBackgroundTask.Title, IsComplete = true, HasError = true, ErrorMessage = e.Message, PercentComplete = 100 }, context.Token); } }
private static bool Convert(ConvertCommand command) { try { ExecuteConvert(command.DocxPath, command.PdfOutputPath); Console.WriteLine("Done..."); } catch (Exception ex) { Console.WriteLine("Convert failed"); Console.WriteLine(ex); } return(!command.Continue); }
public void UseOptionsFromConfigurationFile() { Prepare(nameof(UseOptionsFromConfigurationFile)); Directory.SetCurrentDirectory(nameof(UseOptionsFromConfigurationFile)); try { var codeConverterMock = new Mock <ICodeConverter>(); codeConverterMock .Setup(c => c.ConvertToTypeScript(It.IsAny <string>(), It.IsAny <CodeConversionOptions>())) .Returns("interface Item16 { }"); var fileNameConverterMock = new Mock <IFileNameConverter>(); fileNameConverterMock .Setup(f => f.ConvertToTypeScript(It.IsAny <string>(), It.IsAny <ModuleNameConversionOptions>())) .Returns("item.ts"); File.WriteAllText(ConfigurationFile.FileName, "{ \"preserveCasing\": true }"); File.WriteAllText("Item.cs", "class Item16 { }"); var command = new ConvertCommand(codeConverterMock.Object, fileNameConverterMock.Object); command.OnExecute(); Assert.True(command.PreserveCasing); codeConverterMock.Verify(c => c.ConvertToTypeScript( It.IsAny <string>(), It.Is <CodeConversionOptions>(o => !o.ToCamelCase)), Times.Once); } finally { Directory.SetCurrentDirectory(".."); } }
public async Task WhenConvertSourceToImgDestinationWithSizeThenReadDataIsIdentical() { // arrange var sourcePath = $"{Guid.NewGuid()}.img"; var destinationPath = $"{Guid.NewGuid()}.img"; var size = 16 * 512; var fakeCommandHelper = new FakeCommandHelper(new [] { sourcePath }, new [] { destinationPath }); var cancellationTokenSource = new CancellationTokenSource(); // act - convert source img to destination img var convertCommand = new ConvertCommand(new NullLogger <ConvertCommand>(), fakeCommandHelper, sourcePath, destinationPath, size); var result = await convertCommand.Execute(cancellationTokenSource.Token); Assert.True(result.IsSuccess); // assert data is identical within defined size var sourceBytes = fakeCommandHelper.GetMedia(sourcePath).GetBytes(size); Assert.Equal(size, sourceBytes.Length); var destinationBytes = fakeCommandHelper.GetMedia(destinationPath).GetBytes(); Assert.Equal(sourceBytes, destinationBytes); }
public ConverterViewModel() { _input = ""; _currencyInWords = "no input"; ConvertCommand = new ConvertCommand(this); }
public ConvertCommandShould(CLIFixture fixture) { _convertCommand = fixture.ConvertCommand; }
public static int Main(string[] args) { CommandLine.Initialize(); var options = new CommandLineParser(args); options.AddOptions(null, OPTIONS_GENERAL); options.AddOptions("help", OPTIONS_HELP); options.AddOptions("version", OPTIONS_VERSION); options.AddOptions("convert", OPTIONS_CONVERT); options.AddOptions("list", OPTIONS_LIST); options.AddOptions("register", OPTIONS_REGISTER); // save the error state bool invalidArguments = !options.Parse("convert"); // get the Quiet option first, before we emit anything Quiet = options.GetOptionSwitch("quiet"); if (Quiet) { Console.SetOut(new StreamWriter(Stream.Null)); Console.SetError(Console.Out); } NoLog = options.GetOptionSwitch("nolog"); if (!NoLog) { Process running_proc = Process.GetCurrentProcess(); Process[] mbinc_procs = Process.GetProcessesByName(running_proc.ProcessName); // If we only have one instance of MBINCompiler running create the usual log. // If a process starts and there is already a running MBINCompiler process, then // add the PID to the log file name so that there is no issue with two processes // attempting to write to the same log file. if (mbinc_procs.Length == 1) { Logger.Open(Path.ChangeExtension(Utils.GetExecutablePath(), ".log")); } else { Logger.Open(Path.ChangeExtension(Utils.GetExecutablePath(), $".{running_proc.Id}.log")); } Logger.EnableTraceLogging = true; Logger.LogMessage("VERSION", $"MBINCompiler v{Version.GetVersionStringCompact()}"); Logger.LogMessage("ARGS", $"\"{string.Join("\" \"", args)}\"\n"); using (var indent = new Logger.IndentScope()) { Logger.LogMessage("If you encounter any errors, please submit a bug report and include this log file.\n" + "Please check that there isn't already a similar issue open before creating a new one.\n" + "https://github.com/monkeyman192/MBINCompiler/issues\n"); } } // now we can emit an error if we need to if (invalidArguments) { return(CommandLine.ShowInvalidCommandLineArg(options)); } // initialize remaining global options DebugMode = options.GetOptionSwitch("debug"); // execute the appropriate mode try { switch (options.Verb) { case "help": return(HelpCommand.Execute(options)); case "version": return(VersionCommand.Execute(options)); case "list": return(ListCommand.Execute(options)); case "register": return(RegisterCommand.Execute(options)); default: return(ConvertCommand.Execute(options)); } } catch (System.Exception e) { return(CommandLine.ShowException(e)); } }
protected override void IsValidChanged() { ConvertCommand.RaiseCanExecuteChanged(); }
static async Task Run(Arguments arguments) { Log.Logger = new LoggerConfiguration() .Enrich.FromLogContext() .WriteTo.Console() .CreateLogger(); var serviceProvider = new ServiceCollection() .AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true)) .BuildServiceProvider(); var loggerFactory = serviceProvider.GetService <ILoggerFactory>(); var isAdministrator = OperatingSystem.IsAdministrator(); if (!isAdministrator) { Console.WriteLine("Requires administrator rights!"); } var commandHelper = new CommandHelper(); var physicalDrives = (await GetPhysicalDrives(arguments)).ToList(); var cancellationTokenSource = new CancellationTokenSource(); switch (arguments.Command) { case Arguments.CommandEnum.List: var listCommand = new ListCommand(loggerFactory.CreateLogger <ListCommand>(), commandHelper, physicalDrives); listCommand.ListRead += (_, args) => { // // await Task.Run(() => // { // Console.WriteLine(JsonSerializer.Serialize(physicalDrivesList, JsonSerializerOptions)); // }); InfoPresenter.PresentInfo(args.MediaInfos); }; var listResult = await listCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(listResult.IsSuccess ? "Done" : $"ERROR: Read failed, {listResult.Error}"); break; case Arguments.CommandEnum.Info: var infoCommand = new InfoCommand(loggerFactory.CreateLogger <InfoCommand>(), commandHelper, physicalDrives, arguments.SourcePath); infoCommand.DiskInfoRead += (_, args) => { InfoPresenter.PresentInfo(args.MediaInfo); }; var infoResult = await infoCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(infoResult.IsSuccess ? "Done" : $"ERROR: Read failed, {infoResult.Error}"); break; case Arguments.CommandEnum.Read: Console.WriteLine("Reading physical drive to image file"); GenericPresenter.PresentPaths(arguments); var readCommand = new ReadCommand(loggerFactory.CreateLogger <ReadCommand>(), commandHelper, physicalDrives, arguments.SourcePath, arguments.DestinationPath, arguments.Size); readCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); }; var readResult = await readCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(readResult.IsSuccess ? "Done" : $"ERROR: Read failed, {readResult.Error}"); break; case Arguments.CommandEnum.Convert: Console.WriteLine("Converting source image to destination image file"); GenericPresenter.PresentPaths(arguments); var convertCommand = new ConvertCommand(loggerFactory.CreateLogger <ConvertCommand>(), commandHelper, arguments.SourcePath, arguments.DestinationPath, arguments.Size); convertCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); }; var convertResult = await convertCommand.Execute(cancellationTokenSource.Token); Console.WriteLine( convertResult.IsSuccess ? "Done" : $"ERROR: Convert failed, {convertResult.Error}"); break; case Arguments.CommandEnum.Write: Console.WriteLine("Writing source image file to physical drive"); GenericPresenter.PresentPaths(arguments); var writeCommand = new WriteCommand(loggerFactory.CreateLogger <WriteCommand>(), commandHelper, physicalDrives, arguments.SourcePath, arguments.DestinationPath, arguments.Size); writeCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); }; var writeResult = await writeCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(writeResult.IsSuccess ? "Done" : $"ERROR: Write failed, {writeResult.Error}"); break; case Arguments.CommandEnum.Verify: Console.WriteLine("Verifying source image to destination"); GenericPresenter.PresentPaths(arguments); var verifyCommand = new VerifyCommand(loggerFactory.CreateLogger <VerifyCommand>(), commandHelper, physicalDrives, arguments.SourcePath, arguments.DestinationPath, arguments.Size); verifyCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); }; var verifyResult = await verifyCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(verifyResult.IsSuccess ? "Done" : $"ERROR: Verify failed, {verifyResult.Error}"); break; case Arguments.CommandEnum.Blank: Console.WriteLine("Creating blank image"); Console.WriteLine($"Path: {arguments.SourcePath}"); var blankCommand = new BlankCommand(loggerFactory.CreateLogger <BlankCommand>(), commandHelper, arguments.SourcePath, arguments.Size); var blankResult = await blankCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(blankResult.IsSuccess ? "Done" : $"ERROR: Blank failed, {blankResult.Error}"); break; case Arguments.CommandEnum.Optimize: Console.WriteLine("Optimizing image file"); Console.WriteLine($"Path: {arguments.SourcePath}"); var optimizeCommand = new OptimizeCommand(loggerFactory.CreateLogger <OptimizeCommand>(), commandHelper, arguments.SourcePath); var optimizeResult = await optimizeCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(optimizeResult.IsSuccess ? "Done" : $"ERROR: Optimize failed, {optimizeResult.Error}"); break; } }