public FlashUploadCommandVM(IRUSDevice device, IFlashDumpDataParserFactory parserFactory, IFlashDumpSaver flashDumpSaver, IFlashDumpLoader dumpLoader, BusyObject busy)
{
_device = device ?? throw new ArgumentNullException(nameof(device));
_parserFactory = parserFactory;
_flashDumpSaver = flashDumpSaver;
IsBusy = busy ?? throw new ArgumentNullException(nameof(busy));
SaveDump = new ActionCommand(saveDumpAsync, () => _dump != null && IsBusy.IsNotBusy, IsBusy);
async Task saveDumpAsync()
{
try
{
var path = IOUtils.RequestFileSavingPath("BIN(*.bin)|*.bin");
if (path != null)
{
using (var targetDumpFile = File.Create(path))
{
await _dump.SaveDumpAsync(targetDumpFile, _flashDumpSaver, new AsyncOperationInfo());
}
await dumpLoader.LoadAsync(path, new AsyncOperationInfo());
UserInteracting.ReportSuccess("Сохранение дампа Flash-памяти", "Файл успешно сохранен");
}
}
catch (Exception ex)
{
Logger.LogErrorEverywhere("Ошибка сохранения дампа Flash-памяти", ex);
}
}
}
public async void OptionCheckedAsync(BoolOption newOption)
{
using (_isBusy.BusyMode)
{
// Because i dont want user to shift between two options till 'Yes' will be pressed...
if (newOption != _lastFallbackedOption)
{
var doChange = await UserInteracting.RequestAcknowledgementAsync("Смена длительности импульса", "Данные предыдущих замеров будут стерты.-NL-NLПродолжить?");
if (doChange)
{
_calibrator.DiscardShockCalibration();
_lastFallbackedOption = null;
}
else
{
newOption.IsChecked = false;
_lastFallbackedOption = _previousCheckedOption;
_previousCheckedOption.IsChecked = true; // this line triggers method to run again, so it should be the last
}
_previousCheckedOption = ImpulseDurations.Single(o => o.IsChecked);
}
}
}
protected virtual async Task discardAsync()
{
if (UserInteracting.RequestAcknowledgement("Отмена калибровки", "Данные проведенных замеров будут стерты. -NL-NLПродолжить?"))
{
onDiscard();
await cancelMeasureAnywayAsync();
_calibrator.DiscardCalibration();
}
}
async Task cancelMeasureAsync()
{
using (IsBusy.BusyMode)
{
if (!_preferences.RequestCancellationAcknowledgement ||
UserInteracting.RequestAcknowledgement("Прервать замер", "Данные текущего замера будут потеряны.-NL-NLПродолжить?"))
{
await cancelMeasureAnywayAsync();
}
}
}
public WriteFilesByDefaultVM(IRUSDevice device, BusyObject isBusy)
{
IsBusy = isBusy;
WriteAllFilesByDefault = new ActionCommand(writeDefaultFiles, isBusy);
SerialNumber.ModelValue = 1;
Modification.ModelValue = "??";
async Task writeDefaultFiles()
{
using (isBusy.BusyMode)
{
SerialNumber.AssertValue();
Modification.AssertValue();
if (!UserInteracting.RequestAcknowledgement("Запись файлов по умолчанию", "Данная операция перезапишет все файлы файлами по умолчанию-NL-NLПродолжить?"))
{
return;
}
var hadError = false;
var date = DateTime.UtcNow;
foreach (var file in Files.Descriptors.Where(d => d.Key.TargetDeviceId == device.Id))
{
var entities = file.Value.Descriptors.Select(d => d.FileDefaultDataEntity);
entities = Files.SetBurnDate(entities, date);
entities = Files.SetSerialNumber(entities, SerialNumber.ModelValue.ToInt32());
entities = Files.SetFileEntity(entities, FileEntityType.MODIFICATION, Modification.ModelValue);
var request = file.Key.FileType.GetRequestAddress();
var result = await device.BurnAsync(request, entities, DeviceOperationScope.DEFAULT, CancellationToken.None);
if (result.Status != BurnStatus.OK)
{
Logger.LogErrorEverywhere("Ошибка операции");
hadError = true;
break;
}
}
if (!hadError)
{
SuccessfullyWritten?.Invoke(this);
}
}
}
}
public App()
{
const string appId = "96f478cb-c39d-4d1f-a630-a8ae4f9fe760";
_mutex = new Mutex(true, appId, out bool createdNew);
if (!createdNew)
{
UserInteracting.ReportError("Запуск программы", "Приложение уже запущено");
Current.Shutdown();
}
var version = Assembly.GetEntryAssembly().GetName().Version;
var versionString = $"{version.Major}.{version.Minor}.{version.Build}:{version.Revision}";
Logger.LogInfo(null, $"Программа запущена. V{versionString}");
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
}
protected override void OnClosing(CancelEventArgs e)
{
e.Cancel = !UserInteracting.RequestAcknowledgement("Закрытие программы", $"Несохраненные данные будут потеряны.-NL-NLВсе равно закрыть?");
base.OnClosing(e);
}
public LasExportMainVM(IList <IPointsRow> rows, IEnumerable <ICurveInfo> curveInfos)
{
_rows = rows ?? throw new ArgumentNullException(nameof(rows));
CurveInfos = curveInfos?.Select(ci => new CurveInfo(ci.Title, ci.IsShown)).ToArray() ?? throw new ArgumentNullException(nameof(curveInfos));
SelectAll = new ActionCommand(selectAll, () => !_cancellationManager.HasTasks, _cancellationManager);
UnselectAll = new ActionCommand(unselectAll, () => !_cancellationManager.HasTasks, _cancellationManager);
Export = new ActionCommand(exportAsync, () => !_cancellationManager.HasTasks, _cancellationManager);
Cancel = new ActionCommand(TryCancelExportAsync, () => _cancellationManager.HasTasks, _cancellationManager);
void selectAll()
{
foreach (var ci in CurveInfos)
{
ci.IsShown = true;
}
}
void unselectAll()
{
foreach (var ci in CurveInfos)
{
ci.IsShown = false;
}
}
async Task exportAsync()
{
var file = tryRequestFile();
if (file.Stream != null)
{
using (file.Stream)
{
try
{
ExportProgress.Reset();
var exportingCurvesIndexes = CurveInfos.FindAllIndexes(ci => ci.IsShown).ToArray();
var curvesNames = CurveInfos.Get(exportingCurvesIndexes).Select(ci => ci.Title).ToArray();
var filteredRows = _rows.GetRange(0, _rows.Count)
.Select(r => r.Points.Get(exportingCurvesIndexes).ToArray());
var task = new LasExporter()
.SaveToAsync(file.Stream, curvesNames, filteredRows, _rows.Count, new AsyncOperationInfo(ExportProgress, _cancellationManager.Token));
await _cancellationManager.RegisterAndReturn(task);
UserInteracting.ReportSuccess("Экспорт в Las", "Экспорт успешно завершен");
}
catch (OperationCanceledException)
{
file.Stream.Dispose();
CommonUtils.Try(() => File.Delete(file.Path));
ExportProgress.Stage = "Операция прервана";
ExportProgress.OperationStatus = OperationStatus.ABORTED;
}
catch (Exception ex)
{
Logger.LogErrorEverywhere("Ошибка экспорта в Las", ex);
Reporter.ReportError("Не удалось произвести экспорт в Las", ex);
ExportProgress.Stage = "Ошибка экспорта";
ExportProgress.OperationStatus = OperationStatus.FAILED;
UserInteracting.ReportError("Экспорт в Las", "Неизвестная ошибка экспорта");
await TryCancelExportAsync();
}
finally
{
_cancellationManager.Reset();
}
}
}
(Stream Stream, string Path) tryRequestFile()
{
var filePath = IOUtils.RequestFileSavingPath("LAS (*las)|*las");
return(CommonUtils.TryOrDefault(() =>
{
if (!Path.HasExtension(filePath))
{
filePath += ".las";
}
File.Delete(filePath);
return File.OpenWrite(filePath);
}), filePath);
}
}
}
public async Task OnReadAsync(AsyncOperationInfo operationInfo)
{
if (_dump != null && !await UserInteracting.RequestAcknowledgementAsync("Начать загрузку дампа Flash-памяти", "Предыдущий дамп будет стерт из памяти программы-NL-NLПродолжить?"))
{
return;
}
operationInfo.Progress.Report(0);
var formats = new Dictionary <RUSDeviceId, IEnumerable <IDataEntity> >();
switch (formatSource)
{
case FormatSource.MODULE:
{
var format = await _device.ReadAsync(Command.DATA_PACKET_CONFIGURATION_FILE, DeviceOperationScope.DEFAULT, operationInfo);
if (format.Status != ReadStatus.OK)
{
Logger.LogErrorEverywhere("Не удалось получить формат данных");
return;
}
formats.Add(_device.Id, format.Entities);
}
break;
case FormatSource.DEVICES:
{
foreach (var device in _device.Children.Concat(_device))
{
var format = await device.ReadAsync(Command.FLASH_DATA_PACKET_CONFIGURATION, DeviceOperationScope.DEFAULT, operationInfo);
if (format.Status == ReadStatus.OK)
{
formats.Add(device.Id, format.Entities);
}
else
{
Logger.LogWarningEverywhere($"Не удалось получить формат данных для устройства: {device.Id}");
}
}
}
break;
default:
throw new NotSupportedException();
}
if (formats.Count == 0)
{
Logger.LogErrorEverywhere($"Ни один из требуемых форматов не был получен");
return;
}
var reader = await FlashStreamReader.CreateAsync(_device.Id, formats, _parserFactory, operationInfo);
var result = await _device.ReadAsync(Command.DOWNLOAD_FLASH, reader.FlashReadOperationScope, operationInfo);
if (result.Status == ReadStatus.OK)
{
await reader.FinishAsync(operationInfo);
_dump = reader;
}
}
