/// <summary>
/// This is the constructor for the Load page
/// </summary>
/// <param name="data">A DataProvider object to store the data in</param>
/// <param name="main">An instance of the MainWindowViewModel</param>
public Load(DataProvider data, MainWindowViewModel main)
{
InitializeComponent();
_dataProvider = data;
LoadViewModel loadView = new LoadViewModel(_dataProvider, new CIDER.LoadIO.FolderChecker(), new CIDER.LoadIO.FolderSelector(), new CIDER.LoadIO.FileIO(), main);
this.DataContext = loadView;
}
private void LoadColumnsList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
LoadViewModel viewModel = (LoadViewModel)DataContext;
List <ColumnViewModel>?columns = columnsListNew.SelectedItems.Cast <ColumnViewModel>().ToList();
viewModel.SelectedColumns = columns;
viewModel.SelectedColumn = columns.FirstOrDefault();
}
public ActionResult Load(LoadViewModel capsule)
{
if (!ModelState.IsValid)
{
return(View(capsule));
}
var capsuleDB = Database.Capsules.SingleOrDefault(p => p.CapsuleId == capsule.CapsuleId && p.UserId == Username);
if (capsuleDB == null)
{
return(new HttpNotFoundResult());
}
if (capsule.Items != null)
{
if (capsule.Items.Any(p => p.LoadQuantity > p.ItemQuantity))
{
return(View(capsule));
}
foreach (var item in capsule.Items.Where(p => p.LoadQuantity > 0))
{
CapsulesItems capsuleItem = Database.CapsulesItems.SingleOrDefault(p => p.CapsuleId == capsule.CapsuleId && p.ItemId == item.CurrentItem.ItemId);
if (capsuleItem != null)
{
capsuleItem.Quantity += item.LoadQuantity;
}
else
{
Database.CapsulesItems.Add(new CapsulesItems {
CapsuleId = capsule.CapsuleId, ItemId = item.CurrentItem.ItemId, Quantity = item.LoadQuantity
});
}
InventoriesItems invItem = Database.InventoriesItems.SingleOrDefault(p => p.Inventories.UserId == Username && p.ItemId == item.CurrentItem.ItemId);
if (invItem != null)
{
if (invItem.Quantity == item.LoadQuantity)
{
Database.InventoriesItems.Remove(invItem);
}
else
{
invItem.Quantity -= item.LoadQuantity;
}
}
}
Database.SaveChanges();
}
return(RedirectToAction("List", new { id = capsule.CapsuleId }));
}
public IActionResult Load()
{
var viewModel = new LoadViewModel()
{
IsLoad = logService.IsLoading,
FileName = logService.IsLoading ? logService.FileInProcess : string.Empty,
};
return(View(viewModel));
}
public IActionResult Load(IFormFile file)
{
if (file == null)
{
var viewModel = new LoadViewModel()
{
IsLoad = logService.IsLoading,
FileName = logService.IsLoading ? logService.FileInProcess : string.Empty,
};
return(View(viewModel));
}
if (!logService.IsLoading)
{
using (var stream = new FileStream(this.pathToSave + file.FileName, FileMode.Create))
{
file.CopyTo(stream);
}
try
{
logService.LoadLogFile(this.pathToSave + file.FileName);
}
catch
{
var exceptionViewModel = new LoadViewModel()
{
IsLoad = false,
FileName = file.FileName,
Message = ErrorMessages.FileWithoutLogs
};
return(View(exceptionViewModel));
}
var viewModel = new LoadViewModel()
{
IsLoad = true,
FileName = file.FileName,
};
return(View(viewModel));
}
else
{
var viewModel = new LoadViewModel()
{
IsLoad = logService.IsLoading,
FileName = logService.IsLoading ? logService.FileInProcess : string.Empty,
};
return(View(viewModel));
}
}
public void LoadViewModel_OnSelectClickekWrongFolder_SetsBlocked()
{
FolderManager manager = Substitute.For <FolderManager>();
DataProvider dataProvider = Substitute.For <DataProvider>();
Checker folderChecker = Substitute.For <Checker>();
FileIO fileIO = Substitute.For <FileIO>();
LoadViewModel viewModel = new LoadViewModel(dataProvider, folderChecker, manager, fileIO, Factories.GetMainWindowViewModelStub());
folderChecker.ReturnTrue = false;
viewModel.SelectClickCommand.Execute(this);
Assert.AreEqual(@"..\Icons\001-error.png", viewModel.CheckImage);
}
public void LoadViewModel_OnSelectClickekCorrectFolder_SetsCheckmark()
{
//Arrange
FolderManager manager = Substitute.For <FolderManager>();
DataProvider dataProvider = Substitute.For <DataProvider>();
Checker folderChecker = Substitute.For <Checker>();
FileIO fileIO = Substitute.For <FileIO>();
LoadViewModel viewModel = new LoadViewModel(dataProvider, folderChecker, manager, fileIO, Factories.GetMainWindowViewModelStub());
//Act
viewModel.SelectClickCommand.Execute(this);
//Assert
Assert.AreEqual(@"..\Icons\002-success.png", viewModel.CheckImage);
}
public void LoadViewModel_OnSelectClicked_CallsFolderChecker()
{
//Arrange
FolderManager manager = Substitute.For <FolderManager>();
DataProvider dataProvider = Substitute.For <DataProvider>();
Checker folderChecker = Substitute.For <Checker>();
FileIO fileIO = Substitute.For <FileIO>();
LoadViewModel viewModel = new LoadViewModel(dataProvider, folderChecker, manager, fileIO, Factories.GetMainWindowViewModelStub());
//Act
viewModel.SelectClickCommand.Execute(this);
//Assert
folderChecker.Received().IsCorrectFolder("return");
}
public void LoadViewModel_OnSelectClicked_ReceivesStringOfSelectedFile()
{
//Arrange
FolderManager manager = Substitute.For <FolderManager>();
DataProvider dataProvider = Substitute.For <DataProvider>();
FolderChecker folderChecker = Substitute.For <FolderChecker>();
FileIO fileIO = Substitute.For <FileIO>();
LoadViewModel viewModel = new LoadViewModel(dataProvider, folderChecker, manager, fileIO, Factories.GetMainWindowViewModelStub());
//Act
viewModel.SelectClickCommand.Execute(this);
//Assert
Assert.AreEqual("return", manager.LastSelected);
}
public async Task <IActionResult> Load(LoadViewModel loadViewModel, CancellationToken cancellationToken)
{
var progressReporter = _progressReporterFactory.GetLoadingBarReporter(loadViewModel.ConnectionId);
for (int i = 0; i < loadViewModel.Seconds; i++)
{
if (cancellationToken.IsCancellationRequested)
{
return(NoContent());
}
progressReporter.Report(1 / (double)loadViewModel.Seconds);
await Task.Delay(1000);
}
return(Content("Completed"));
}
private LoadViewModel RecuperarItemsLoad(int id)
{
var capsuleDB = Database.Capsules.SingleOrDefault(p => p.CapsuleId == id && p.UserId == Username);
if (capsuleDB == null)
{
return(null);
}
LoadViewModel model = new LoadViewModel();
LoadCapsule(capsuleDB, model);
model.Items = capsuleDB.CapsulesItems.Select(p => new ItemLoadViewModel {
CurrentItem = ItemBase.Create(ItemsXml, p.ItemId),
CapsuleQuantity = p.Quantity,
ItemQuantity = 0,
LoadQuantity = 0
}).OrderBy(x => x.CurrentItem.Order).ToList();
var isCapsule = ItemsCapsule.Select(s => s.ItemId);
var isKey = ItemsXml.Where(p => p.IsKey).Select(s => s.ItemId);
var inventoryDB = Database.InventoriesItems.Where(p => p.Inventories.UserId == Username && !isCapsule.Contains(p.ItemId) && (!model.Properties.IsKeyLocker || isKey.Contains(p.ItemId))).ToList();
var inventories = inventoryDB.Select(q => new ItemLoadViewModel {
CurrentItem = ItemBase.Create(ItemsXml, q.ItemId),
CapsuleQuantity = 0,
ItemQuantity = q.Quantity,
LoadQuantity = 0
}).OrderBy(p => p.CurrentItem.Order).ToList();
foreach (var item in model.Items)
{
ItemLoadViewModel inv = inventories.SingleOrDefault(p => p.CurrentItem == item.CurrentItem);
if (inv != null)
{
item.ItemQuantity = inv.ItemQuantity;
inventories.Remove(inv);
}
}
model.Items.AddRange(inventories);
return(model);
}
public void LoadViewModel_OnSelectClickedError_ReceivesSelectorError()
{
//Arrange
FolderManager manager = Substitute.For <FolderManager>();
DataProvider dataProvider = Substitute.For <DataProvider>();
FolderChecker folderChecker = Substitute.For <FolderChecker>();
FileIO fileIO = Substitute.For <FileIO>();
LoadViewModel viewModel = new LoadViewModel(dataProvider, folderChecker, manager, fileIO, Factories.GetMainWindowViewModelStub());
//Act
viewModel.SelectClickCommand.Execute(this);
manager.ThrowError = true;
viewModel.SelectClickCommand.Execute(this);
//Assert
Assert.AreEqual("", viewModel.PathText);
}
private void TextBox_PreviewKeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter)
{
btnSubmitLoad.IsDefault = false;
LoadViewModel model = (LoadViewModel)this.DataContext;
model.SerialNumberToAdd = tbSerialNumber.Text;
model.AddSerialNumberCommand.Execute(this);
Task.Run(() =>
{
System.Threading.Thread.Sleep(250);
System.Windows.Application.Current.Dispatcher.Invoke((Action)(() =>
{
btnSubmitLoad.IsDefault = true;
}));
});
}
}
public void LoadEntityViewModel <TViewModel>(LoadViewModel vmInfo) where TViewModel : IViewModel
{
try
{
var concreteVM = BootStrapper.BootStrapper.Container.GetExportedTypes <TViewModel>().FirstOrDefault() ?? BootStrapper.BootStrapper.Container.GetExportedType(vmInfo.ViewModelInfo.ViewModelType);
var vm = (TViewModel)Activator.CreateInstance(concreteVM, new object[] { vmInfo.Process, vmInfo.ViewModelInfo.ViewInfo, vmInfo.ViewModelInfo.Subscriptions, vmInfo.ViewModelInfo.Publications, vmInfo.ViewModelInfo.Commands, vmInfo.ViewModelInfo.Orientation, vmInfo.ViewModelInfo.Priority });
EventMessageBus.Current.Publish(new ViewModelCreated <TViewModel>(vm, new StateEventInfo(vmInfo.Process.Id, RevolutionData.Context.ViewModel.Events.ViewModelCreated), vmInfo.Process, Source), Source);
EventMessageBus.Current.Publish(new ViewModelCreated <IViewModel>(vm, new StateEventInfo(vmInfo.Process.Id, RevolutionData.Context.ViewModel.Events.ViewModelCreated), vmInfo.Process, Source), Source);
//dynamic dvm = new DynamicViewModel<TViewModel>(vm);
// EventMessageBus.Current.Publish(new ViewModelCreated<DynamicViewModel<TViewModel>>(dvm,vmInfo.Process, source), source);
}
catch (Exception ex)
{
Debugger.Break();
EventMessageBus.Current.Publish(new ProcessEventFailure(failedEventType: typeof(ILoadViewModel),
failedEventMessage: vmInfo,
expectedEventType: typeof(IViewModelCreated <IDynamicViewModel <TViewModel> >),
exception: ex,
source: Source, processInfo: new StateEventInfo(vmInfo.Process.Id, RevolutionData.Context.Process.Events.Error)), Source);
}
}
public async Task <IActionResult> Load(string name, int level, CancellationToken cancellationToken)
{
var id = UserHelper.GetUserId(User.Claims);
var model = new LoadViewModel
{
Theme = "",
Option = _mapper.Map <DungeonOptionViewModel>(await _dungeonService.GetDungeonOptionByNameAsync(name, id, cancellationToken)),
Themes = (await _optionService.ListOptionsAsync(cancellationToken, OptionKey.Theme)).Select(om => new SelectListItem {
Text = om.Name, Value = om.Value, Selected = true
}).ToList()
};
var dungeons = await _dungeonService.ListUserDungeonsByNameAsync(model.Option.DungeonName, id, cancellationToken);
if (level != 0)
{
dungeons = dungeons.Where(dm => dm.Level == level).ToList();
}
model.Option.Dungeons = dungeons.Select(dm => _mapper.Map <DungeonViewModel>(dm)).ToList();
ViewData["ReturnUrl"] = Url.Action("Index", "Dungeon");
return(View(model));
}
private void HandleProcessViews(IProcessSystemMessage pe)
{
try
{
Parallel.ForEach(ProcessViewModelInfos.Where(x => x.ProcessId == pe.Process.Id), new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount
},
(v) =>
{
var msg = new LoadViewModel(v,
new StateCommandInfo(pe.Process.Id, RevolutionData.Context.ViewModel.Commands.LoadViewModel),
pe.Process, Source);
EventMessageBus.Current.Publish(msg, Source);
});
}
catch (Exception ex)
{
//todo: need to fix this
PublishProcesError(pe, ex, pe.GetType());
}
}
public LoadWindow()
{
InitializeComponent();
DataContext = new LoadViewModel();
}
/// <summary>
/// the constractur of the LoadDLLWindow
/// </summary>
public LoadDLLWindow()
{
InitializeComponent();
vm = new LoadViewModel(new LoadModel());
DataContext = vm;
}
