public void Delete(DeleteItemCommand message) { var item = new T(); item.Id = message.Id; _repository.Save(item, -1); }
public ItemDetailVM() { DeleteItemCommand = new DeleteItemCommand(this); UpdateItemCommand = new UpdateItemCommand(this); ClosePopUpCommand = new ClosePopUpCommand(this); Item = new Item(); }
public async Task <IActionResult> DeleteItem([FromRoute(Name = "itemId")] int itemId) { var command = new DeleteItemCommand(new Domain.StoreItems.Models.ItemId(itemId)); await commandDispatcher.DispatchAsync(command, default); return(Ok()); }
public async Task <Unit> Handle(DeleteItemCommand request, CancellationToken cancellationToken) { _unitOfWork.ItemRepo.Delete(request.Id); await _unitOfWork.SaveAsync(); return(Unit.Value); }
private void InitializeCommands() { AddItemCommand = new DelegateCommand <ItemModel>((item) => { Items.Add(new ItemViewModel(item)); DeleteItemCommand.RaiseCanExecuteChanged(); }); DeleteItemCommand = new DelegateCommand <int>((int index) => { Items.RemoveAt(index); }, (int index) => { if (index == -1) { return(false); } return(Items.Count > 0); }); GoHomeCommand = new DelegateCommand(() => { NavigationService.Navigate(UniversalApp.Current.DefaultPage); }); }
private ICommand EnsureCommand(ECommandId idCommand) { NavigatorCommand command = null; lock (mSyncRoot) { command = mCachedCommands[(int)idCommand]; if (command == null) { switch (idCommand) { case ECommandId.NullRecord: break; case ECommandId.NextRecord: command = new NextItemCommand(mViewDataManipulator); break; case ECommandId.PreviousRecord: command = new PrevItemCommand(mViewDataManipulator); break; case ECommandId.FirstRecord: command = new FirstItemCommand(mViewDataManipulator); break; case ECommandId.LastRecord: command = new LastItemCommand(mViewDataManipulator); break; case ECommandId.GoToRecord: break; case ECommandId.AddRecord: command = new AddItemCommand(mViewDataManipulator); break; case ECommandId.Save: command = new SaveItemCommand(mViewDataManipulator); break; case ECommandId.DeleteRecord: command = new DeleteItemCommand(mViewDataManipulator); break; default: throw new ArgumentOutOfRangeException(nameof(idCommand), idCommand, null); } if (command != null) { mCachedCommands[(int)idCommand] = command; } } } return(command); }
public override void ReverseInit(object returnedData) { base.ReverseInit(returnedData); if (returnedData is ProductQuotationModel) { DeleteItemCommand.Execute(returnedData); } }
public async Task <IActionResult> DeleteItemAsync(int id) { var query = new DeleteItemCommand(id); var result = await _meadiator.Send(query); return(result == true ? (IActionResult)Ok(result) : BadRequest(result)); //var res = await _itemService.DeleteItemAysnc(id); //return res == true ? (IActionResult)Ok(res) : BadRequest(res); }
private async Task <bool> HandleAsync(DeleteItemCommand command) { var item = await this.context.Items.FindAsync(command.ItemId); this.context.Items.Remove(item); var count = await this.context.SaveChangesAsync(); return(count >= 0); }
public async Task <IActionResult> Delete(Guid id) { var request = new DeleteItemCommand { Id = id }; await _mediator.Send(request); return(NoContent()); }
public async Task <ActionResult> Delete(int id) { var deleteItemCommand = new DeleteItemCommand() { ItemId = id }; await _mediator.Send(deleteItemCommand); return(NoContent()); }
private bool CanDeleteItem(object parameter) { if (DeleteItemCommand != null) { return(CurrentItemIndex > 0 && DeleteItemCommand.CanExecute(parameter)); } return(CurrentItemIndex > 0 && IsCollection(ItemsSource)); }
public IHttpActionResult Delete(int id) { return(ExecuteCommand(() => { var command = new DeleteItemCommand() { Id = id }; _deleteCommandHandler.Handle(command); })); }
public DrugsManagementViewModel(AdminShellViewModel shellViewModel) { drugsManagementM = new DrugsManagementModel(); Items = new ObservableCollection <Drug>(drugsManagementM.Drugs); Items.CollectionChanged += DrugsChanged; this.containingShellVm = shellViewModel; EditCommand = new EditingItemCommand(this); DeleteCommand = new DeleteItemCommand(this); SearchCommand = new SearchItemCommand(this); ScreenReplacementCommand = new ScreenReplacementCommand(this); }
public void ShouldReturnFalseIfNoItemFound(DeleteItemCommand sut, Item item, ID parentId) { // arrange sut.Initialize(item, parentId); // act var result = (bool)ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().BeFalse(); }
public PhysiciansManagementViewModel(AdminShellViewModel shellViewModel) { physiciansManagementM = new PhysiciansManagementModel(); Items = new ObservableCollection <Physician>(physiciansManagementM.Physicians); Items.CollectionChanged += PhysiciansChanged; this.containingShellVm = shellViewModel; EditCommand = new EditingItemCommand(this); DeleteCommand = new DeleteItemCommand(this); SearchCommand = new SearchItemCommand(this); ScreenReplacementCommand = new ScreenReplacementCommand(this); }
public ConsumptionOfDrugsViewModel(PhysicianShellViewModel containingVm, string patientId) { medicalFileModel = new MedicalFileModel(patientId); this.containingVm = containingVm; DrugsPreviouslyTaken = new ObservableCollection <Recept>(medicalFileModel.AllRecepts.Where(x => x.TreatmentEndDate < DateTime.Now)); DrugsTake = new ObservableCollection <Recept>(medicalFileModel.AllRecepts.Where(x => x.TreatmentEndDate >= DateTime.Now)); ListDisplay = new ObservableCollection <Recept>(DrugsTake); BackCommand = new BackCommand(this); ChangeListDisplayCommand = new ChangeListDisplayCommand(this); RemoveFromDb = new DeleteItemCommand(this); }
public async Task <ActionResult> DeleteConfirmed([Bind("Id")] string id) { var command = new DeleteItemCommand { Id = new Guid(id) }; await _messaging.SendCommand(command); TempData["message"] = "Item deleted"; return(RedirectToRoute("ListItems", new { lastCommandId = command.CommandId })); }
public AddDrugViewModel(AdminShellViewModel containingVm) { addDrugM = new AddDrugModel(); this.containingVm = containingVm; UpdateDbCommand = new AddToDbCommand(this); IsNewDrug = true; BackCommand = new BackCommand(this); IngredientToAdd = new ActiveIngredient(); Ingredients = new ObservableCollection <ActiveIngredient>(); AddIngredientCommand = new AddIngredientToDrugCommand(this); DeleteIngredientCommand = new DeleteItemCommand(this); FileDialogCommand = new OpenFileDialogCommand(this); }
public void Execute_DeleteItemCommand_WithPosition_ShouldRemoveItemFromItemsList() { var documentItems = new List <DocumentItem> { new DocumentItem(new TestParagraph()), new DocumentItem(new TestParagraph()) }; var command = new DeleteItemCommand(documentItems, 1); command.Execute(); Assert.AreEqual(1, documentItems.Count); }
public DeleteItemCommandHandlerTest() { this.mockUnitOfWork = new Mock <IUnitOfWork>(MockBehavior.Strict); this.mockItemRepository = new Mock <IItemRepository>(MockBehavior.Strict); this.mockUserRepository = new Mock <IUserRepository>(MockBehavior.Strict); this.command = new DeleteItemCommand(5, 10); this.handler = new DeleteItemCommandHandler( mockUnitOfWork.Object, mockItemRepository.Object, mockUserRepository.Object); }
private void clearItems(UpdateOrderViewModel model, Order order) { var itemCmd = new DeleteItemCommand(_itemRepository, _itemValidator); foreach (var item in order.Items) { if (!model.Items.Any(i => i.Description == item.Description)) { itemCmd.Execute(item); AddNotifications(itemCmd); } } }
public void CanCreateCommandAndDeleteItemOnExecute() { var items = new List <DocumentItem> { new DocumentItem(new TestParagraph()), }; Assert.AreEqual(items.Count, 1); DeleteItemCommand c = new DeleteItemCommand(0, items); c.Execute(); Assert.AreEqual(items.Count, 0); }
public override void OnReceive(Context context, Intent intent) { if (intent != null) { var itemId = intent.GetStringExtra("itemId"); var deleteCommand = new DeleteItemCommand(PCLStorage.FileSystem.Current.LocalStorage); deleteCommand.Execute(itemId); var manager = NotificationManager.FromContext(context); manager.CancelAll(); } }
public async Task Handle_Given_ValidId_Should_Not_ThrowException_And_Should_DeleteItemFromDatabase() { var oldCount = await this.Context.Items.CountAsync(); var command = new DeleteItemCommand(DataConstants.SampleItemId); await this.handler.Handle(command, CancellationToken.None); var newCount = await this.Context.Items.CountAsync(); newCount .Should() .Be(oldCount - 1); }
public void ShouldDeleteItemFromDataStorageAndReturnTrue(DeleteItemCommand sut, DbItem item, ID parentId) { // arrange sut.DataStorage.GetFakeItem(item.ID).Returns(item); sut.DataStorage.RemoveFakeItem(item.ID).Returns(true); sut.Initialize(ItemHelper.CreateInstance(item.ID), parentId); // act var result = (bool)ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().BeTrue(); }
public void Execute_DeleteItemInvoked() { // Arrange bool isDeleteItemInvoked = false; _documentMock.Setup(d => d.DeleteItem(It.IsAny <int>())).Callback(() => isDeleteItemInvoked = true); ICommand command = new DeleteItemCommand(1, _documentMock.Object); // Act command.Execute(); // Assert Assert.True(isDeleteItemInvoked); }
public async Task <DeleteItemResponse> Handle(DeleteItemRequest request, CancellationToken cancellationToken) { var item = this.mapper.Map <Item>(request); var command = new DeleteItemCommand() { Parameter = item }; var itemFromDb = await this.commandExecutor.Execute(command); return(new DeleteItemResponse() { Data = this.mapper.Map <Domain.Models.Item>(itemFromDb) }); }
public UpdateDrugViewModel(AdminShellViewModel containingVm, Drug drugToUpdate) { updateDrugM = new UpdateDrugModel(drugToUpdate); this.containingVm = containingVm; UpdateDbCommand = new UpdateInDbCommand(this); IsNewDrug = false; BackCommand = new BackCommand(this); IngredientToAdd = new ActiveIngredient(); Ingredients = new ObservableCollection <ActiveIngredient>(updateDrugM.Ingredients); AddIngredientCommand = new AddIngredientToDrugCommand(this); DeleteIngredientCommand = new DeleteItemCommand(this); FileDialogCommand = new OpenFileDialogCommand(this); ImageUrl = Drug.ImageUrl; }
public async Task <IActionResult> DeleteItemAsync(Guid itemId) { try { var command = new DeleteItemCommand(itemId, User.Identity.Name); await commandHandler.HandleAsync(command); return(NoContent()); } catch (ItemNotFoundException) { return(this.NotFound()); } }