public WhenAddItemCommandIsHandled()
{
command = new AddItemCommand(Guid.NewGuid(), Guid.NewGuid());
var commandHandler = new AddItemCommandHandler();
cart = commandHandler.Handle(command);
}
private void AutoCompleteBox_OnPreviewKeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter)
{
AddItemCommand.Execute(null);
}
}
private void Button_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
var item = (sender as Button).DataContext;
LV_MinecraftItems.SelectedItem = item;
AddItemCommand.Execute(item);
}
public ucCraftingTree()
{
SortingTypes = new ObservableCollection <string> {
"----------", "Name", "Category", "Required (High to Low)", "Required (Low to High)"
};
SortType = "----------";
Categories = new ObservableCollection <string>
{
"All",
"Building Blocks",
"Decorations",
"Redstone",
"Transportation",
"Miscellaneous",
"Foodstuffs",
"Brewing",
"Combat"
};
CategoryIndex = 0;
AddItemCommand = new AddItemCommand(this);
RemoveItemCommand = new RemoveItemCommand(this);
InitializeComponent();
LayoutRoot.DataContext = this;
}
protected override void Initialize()
{
AddItemCommand.Initialize(this);
ExtendElementsCommand.Initialize(this);
NewFolder1.Command1.Initialize(this);
base.Initialize();
}
public async Task Execute_AddItemNoOtherItems()
{
// SETUP
var item = new Item()
{
CategoryId = "catid",
Name = "Name1",
Id = Guid.NewGuid().ToString()
};
var fileStub = new FileStub(string.Empty);
var rootFolderMock = new Mock <IFolder> ();
var itemsFolderMock = new Mock <IFolder> ();
itemsFolderMock.Setup(ifm => ifm.GetFileAsync("items.data", default(CancellationToken))).ReturnsAsync(fileStub);
rootFolderMock.Setup(rf => rf.CreateFolderAsync("items", CreationCollisionOption.OpenIfExists, default(CancellationToken))).ReturnsAsync(itemsFolderMock.Object);
// ACTION
var called = false;
var command = new AddItemCommand(rootFolderMock.Object);
command.Added += (sender, e) => {
called = true;
};
command.Execute(item);
// ASSERT
Assert.IsTrue(called);
Assert.AreEqual(JsonConvert.SerializeObject(new List <Item> ()
{
item
}), fileStub.WrittenContent);
}
public IActionResult AddItemFile(AddItemCommand cmd)
{
int a = 5;
int b = a + 5;
return(TryPush(cmd));
}
private void Handle(AddItemCommand command)
{
var actor = GetCart(command.CartId);
actor.Tell(command);
pendingOperations.Add(command.Id, Sender);
}
public async Task <ActionResult <int> > AddItem(int uId, int gId, int sId, AddItemCommand addItemCommand)
{
addItemCommand.Finalize(uId, gId, sId);
var shoppingTripItemId = await _mediator.Send(addItemCommand);
return(shoppingTripItemId);
}
public AdditionalDepositsPageViewModel(AccountModel accountModel, Mediator mediator)
{
GoToNextPage = new RelayCommand <object>(arg => mediator.Invoke("OnGoToNextPage"));
GoToPreviousPage = new RelayCommand <object>(arg => mediator.Invoke("OnGoToPreviousPage"));
OnRemoveDeposit = new RemoveItemCommand(accountModel.RemoveDeposit);
OnAddDeposit = new AddItemCommand(accountModel.AddDeposit);
AccountModel = accountModel;
}
public WithdrawalsPageViewModel(AccountModel accountModel, Mediator mediator)
{
GoToNextPage = new RelayCommand <object>(arg => mediator.Invoke("OnGoToNextPage"));
GoToPreviousPage = new RelayCommand <object>(arg => mediator.Invoke("OnGoToPreviousPage"));
OnRemoveWithdrawal = new RemoveItemCommand(accountModel.RemoveWithdrawal);
OnAddWithdrawal = new AddItemCommand(accountModel.AddWithdrawal);
AccountModel = accountModel;
}
public void should_have_error_when_GenreId_is_null()
{
var addItemCommand = new AddItemCommand {
Price = new Money()
};
_validator.ShouldHaveValidationErrorFor(x => x.GenreId, addItemCommand);
}
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 async Task <IActionResult> AddItem(string id, [FromBody] AddItemCommand command, CancellationToken cancellationToken)
{
var basketAggregate = await _repository.Load(id, cancellationToken);
basketAggregate.Apply(command);
await _repository.Save(basketAggregate, cancellationToken);
return(Ok());
}
protected override void Initialize()
{
AddItemCommand.Initialize(this);
AddPackageReferenceCommand.Initialize(this);
BuildCurrentModelCommand.Initialize(this);
ExtendElementsCommand.Initialize(this);
NewFolder1.Command1.Initialize(this);
base.Initialize();
}
public void AddItem(AddItemCommand cmd)
{
ShoppingCartItem existingItem = items.Where(item => item.CreateSnapshot().ItemId == cmd.ItemId).FirstOrDefault();
if (existingItem != null)
items.Remove(existingItem);
items.Add(ShoppingCartItem.Create(cmd.ItemId, cmd.Qty, cmd.Price, cmd.ItemCode, cmd.ItemName, cmd.UnitCode));
this.totalAmountAfterDiscount = items.Sum(item => item.CreateSnapshot().AmountAfterDiscount);
}
public async Task <IActionResult> AddItemAsync([FromBody] ItemDTO itemDTO)
{
var query = new AddItemCommand(itemDTO);
var result = await _meadiator.Send(query);
return(result == true ? (IActionResult)Ok(result) : BadRequest(result));
//var item = _mapper.Map<Item>(itemDTO);
//var res = await _itemService.AddItemAysnc(item);
//return res == true ? (IActionResult)Ok(res) : BadRequest(res);
}
public ItemViewModel()
{
items = new ObservableCollection <ItemModel>();
recommand_four = new ObservableCollection <ItemModel>();
recommandsList = new ObservableCollection <ItemModel>();
OpenItemCommandProperty = new OpenItemCommand();
OpenSearchItemCommandProperty = new OpenSearchItemCommand();
AddItemCommandProperty = new AddItemCommand();
IsItemPopup = false;
}
public void should_have_error_when_GenreId_doesnt_exist()
{
_mediatorMock
.Setup(x => x.Send(It.IsAny <GetGenreCommand>(), CancellationToken.None))
.ReturnsAsync(() => null);
var addItemCommand = new AddItemCommand {
Price = new Money(), GenreId = Guid.NewGuid()
};
_validator.ShouldHaveValidationErrorFor(x => x.GenreId, addItemCommand);
}
private async Task <int> HandleAsync(AddItemCommand command)
{
var item = new Item {
Title = command.Title, IsDone = false, ListId = command.ListId
};
await this.context.Items.AddAsync(item);
await this.context.SaveChangesAsync();
return(item.Id);
}
public async Task <IActionResult> AddItemInOrderItemList([FromBody] AddItemCommand command)
{
if (command == null)
{
return(await Respond(null, new List <Notification> {
new Notification("Order", "Parameters is invalid.")
}));
}
var result = _orderCommandHandler.Handle(command);
return(await Respond(result, _orderCommandHandler.Notifications));
}
public void Handle(AddItemCommand command)
{
try
{
Thread.Sleep(new Random().Next(500, 4000));
if (command.Id == Guid.Empty)
{
throw new ArgumentNullException("command.Id");
}
if (string.IsNullOrEmpty(command.Name))
{
throw new ArgumentNullException("command.Name");
}
Console.WriteLine("Got command: {0}, Id: {1}, Name: {2}", command.GetType().Name, command.Id, command.Name);
using (var db = new MyReadStore())
{
if (db.SomeItems.Where(x => x.Id == command.Id).Any())
{
throw new Exception("Item does already exists");
}
db.SomeItems.Add(new SomeItem()
{
Id = command.Id, Name = command.Name, IsActive = false
});
db.SaveChanges();
}
_publisher.Publish(new ItemAddedEvent()
{
Id = command.Id, Name = command.Name
});
_publisher.Publish(new ClientNotification()
{
Success = true,
Message = string.Format("The item '{0}' was added", command.Name),
ClientId = command.ClientId
});
}
catch (Exception ex)
{
Console.WriteLine("Failed to execute command: {0}, Message: {1}", command.GetType().Name, ex.Message);
_publisher.Publish(new ClientNotification()
{
Success = false,
Message = string.Format("Could not add the item. Errormessage: ", ex.Message),
ClientId = command.ClientId
});
}
}
public async Task <AddItemResponse> Handle(AddItemRequest request, CancellationToken cancellationToken)
{
var item = this.mapper.Map <Item>(request);
var command = new AddItemCommand()
{
Parameter = item
};
var itemFromDb = await this.commandExecutor.Execute(command);
return(new AddItemResponse()
{
Data = this.mapper.Map <Domain.Models.Item>(itemFromDb)
});
}
public BasketAggregateShould()
{
_addItemCommand = new AddItemCommand
{
Sku = "12345",
Description = "Product Description"
};
_updateItemCommand = new UpdateItemCommand
{
Sku = _addItemCommand.Sku,
Quantity = 2
};
}
private void Handle(AddItemCommand command)
{
if (!isInitialized)
{
Sender.Tell(new CommandFailed(command.Id, "Cart is not initialized!"));
return;
}
if (!items.ContainsKey(command.ItemId))
{
items.Add(command.ItemId, 0);
}
items[command.ItemId] += command.Quantity;
Sender.Tell(new ItemAddedEvent(command.Id, command.CartId, command.ItemId, command.Quantity));
}
public void Apply(AddItemCommand command)
{
if (Items.Any(item => item.Sku == command.Sku))
{
return;
}
Items.Add(new ProductItem
{
Sku = command.Sku,
Description = command.Description
});
HasBeenUpdated = true;
}
public ActionResult Create(ItemViewModel itemViewModel)
{
if (ModelState.IsValid)
{
var addItemCommand = new AddItemCommand();
Mapper.CreateMap<ItemViewModel, AddItemCommand>();
Mapper.Map(itemViewModel, addItemCommand);
CommandProcessor.Process<AddItemCommand, CommandResult>(addItemCommand, ModelState);
if (!ModelState.IsValid)
return View();
return this.RedirectToAction(c => c.Index(null, null));
}
return View();
}
private void DeleteItemCommandExecute()
{
DeleteItemRequest request = new DeleteItemRequest {
Item = SelectedItem
};
DeleteItemRequest.Raise(request, returned =>
{
if (!request.Confirmed)
{
return;
}
Items.Remove(SelectedItem);
});
AddItemCommand.RaiseCanExecuteChanged();
}
public MainWindowViewModel()
{
this.WhenAnyValue(x => x.ItemCount).Subscribe(ResizeItems);
RecreateCommand = ReactiveCommand.Create();
RecreateCommand.Subscribe(_ => Recreate());
AddItemCommand = ReactiveCommand.Create();
AddItemCommand.Subscribe(_ => AddItem());
RemoveItemCommand = ReactiveCommand.Create();
RemoveItemCommand.Subscribe(_ => Remove());
SelectFirstCommand = ReactiveCommand.Create();
SelectFirstCommand.Subscribe(_ => SelectItem(0));
SelectLastCommand = ReactiveCommand.Create();
SelectLastCommand.Subscribe(_ => SelectItem(Items.Count - 1));
}
private IEnumerable <Item> ParseAddItemCommand(AddItemCommand commandXml)
{
List <Item> objList = new List <Item>();
string str1 = commandXml.AddedItemData.DatabaseName;
string str2 = commandXml.AddedItemData.Name;
string str3 = commandXml.AddedItemData.ID;
string str4 = commandXml.AddedItemData.BranchId;
string str5 = commandXml.AddedItemData.ParentId;
string str6 = commandXml.AddedItemData.TemplateId;
IEnumerable <Field> first = this.ParseFields(commandXml.AddedItemData.SharedFields)
.Select <KeyValuePair <string, string>, Field>((Func <KeyValuePair <string, string>, Field>)(f => new Field()
{
FieldType = FieldType.Shared,
Id = f.Key,
Value = f.Value
}));
foreach (var xpathSelectElement in commandXml.AddedItemData.Versions)
{
string str7 = xpathSelectElement.Version;
string str8 = xpathSelectElement.Language;
IEnumerable <Field> second = this.ParseFields(xpathSelectElement.Fields)
.Select <KeyValuePair <string, string>, Field>((Func <KeyValuePair <string, string>, Field>)(f => new Field()
{
FieldType = FieldType.Unknown,
Id = f.Key,
Value = f.Value
}));
objList.Add(new Item()
{
Database = str1,
Name = str2,
Id = str3,
MasterId = str4,
ParentId = str5,
TemplateId = str6,
Language = str8,
Version = str7,
Fields = first.Union <Field>(second)
});
}
return((IEnumerable <Item>)objList);
}
public Infrastructure Create(ModelEntities entity, string function)
{
if (function == "item")
{
ItemViews _view = new ItemViews();
SelectionCommand selectionCommand = new SelectionCommand(_view);
UpdateItemCommand updateItemCommand = new UpdateItemCommand(_view);
AddItemCommand addItemCommand = new AddItemCommand(_view);
ViewModel _viewModel = new ViewModel(entity, selectionCommand.Command, updateItemCommand.Command, addItemCommand.Command);
selectionCommand.ViewModel = _viewModel;
updateItemCommand.ViewModel = _viewModel;
addItemCommand.ViewModel = _viewModel;
return(new Infrastructure(_view, _viewModel, entity));
}
else
{
return(null);
}
}
private void almImportClick(object sender, RoutedEventArgs e)
{
var innovator = getInnovator();
if (_openAmlDialog.ShowDialog() == true && innovator != null)
{
var dom = new XmlDocument();
dom.Load(_openAmlDialog.FileName);
var item = innovator.newItem();
item.loadAML(dom.OuterXml);
string importError = EnsureSingleItem(null, "add", ref item);
if (string.IsNullOrEmpty(importError))
{
string itemTypeName = item.getType();
var itemType = _project.ItemTypes.FirstOrDefault(it => it.Name == itemTypeName);
if (itemType != null)
{
var addItemCommand = new AddItemCommand(_project, itemType, 0, 0);
_project.PerformCommand(addItemCommand);
Item importedItem = addItemCommand.NewItem;
foreach (var property in importedItem.Properties)
{
property.Value = item.getProperty(property.Name);
}
_allItemControls[importedItem].Item = importedItem; // update after properties are refreshed
}
else
{
MessageBox.Show($"There are no \"{itemTypeName}\" type found.", "Impossible to import", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
else
{
MessageBox.Show(importError, "Impossible to import", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
}
