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;
}
}