public void given_a_product_when_persisting_then_successfully_persisted() { //given string name = "test_product_01"; var client = new RestClient(this.uri); var request = new RestRequest("products", Method.POST); AddNewProductCommand command = new AddNewProductCommand { Name = name }; request.AddJsonBody(command); //when IRestResponse response = client.Execute(request); //then response.StatusCode.Should().Be(HttpStatusCode.OK, response.Content); List <Product> item = DBOperation.ReadAllProducts(); item.Count.Should().Be(1, "item count !!!"); item[0].Name.Should().Be(name, "product name !!!"); item[0].Id.Should().Be(1, "product id !!!"); }
public void given_a_product_when_persisting_to_both_with_exception_at_the_end_then_successfully_rollback() { //given string name = "test_product_01"; var client = new RestClient(this.uri); var request = new RestRequest("products/bothexception", Method.POST); AddNewProductCommand command = new AddNewProductCommand { Name = name }; request.AddJsonBody(command); //when IRestResponse response = client.Execute(request); //then response.StatusCode.Should().Be(HttpStatusCode.InternalServerError, response.ErrorMessage); List <Product> products = DBOperation.ReadAllProducts(); List <Inventory> inventories = DBOperation.ReadAllInventories(); products.Count.Should().Be(0, "products count !!!"); inventories.Count.Should().Be(0, "inventories count !!!"); }
private void AddNewProduct(AddNewProductCommand c) { var product = new Product { Id = c.Id, Name = c.Name, Price = c.Price, Stock = c.Stock }; try { _inventory.AddNewProduct(product); } catch (Exception e) { var result = CommandResult.Error(e.Message); Sender.Tell(result); return; } var ev = new NewProductAddedToInventory(c.Id, c.Name, c.Price, c.Stock); PersistEventAndSnapshot(ev); Sender.Tell(CommandResult.Success()); }
public Task <AddNewProductResponse> addNewProduct(AddNewProductRequest request) { AddNewProductCommand command = new AddNewProductCommand ( request.Product.Name, request.Product.Note, request.Product.Code, request.Product.OtherUnitOfProduct, request.Product.UnitId, request.Product.WeightPerUnit, request.Product.Preservation.ID ); Task <object> product = (Task <object>)Bus.SendCommand(command); //RabbitMQBus.Publish(command); AddNewProductResponse response = new AddNewProductResponse(); response = Common <AddNewProductResponse> .checkHasNotification(_notifications, response); if (response.Success) { ProductModel ProductModel = (ProductModel)product.Result; response.Data = ProductModel.Id; } return(Task.FromResult(response)); }
public async Task <IActionResult> Post([FromBody] Product product) { try { //Log Information - Request _logger.LogInformation($"Received Request : HTTPPOST api/products"); //Create command from Input AddNewProductCommand addCmd = new AddNewProductCommand { Name = product.Name, Description = product.Description, UnitPrice = product.UnitPrice, UnitsInStock = product.UnitsInStock }; //Send Command AddNewProductResult result = await _mediator.Send(addCmd); //Return result return(CreatedAtRoute("", new { id = result.ProductId })); } catch (Exception ex) { // Log the failure and return HTTP 500 _logger.LogError($"Error at HTTPPOST api/products :{ex}"); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public void given_a_product_when_persisting_to_both_then_successfully_persisted() { //given string name = "test_product_01"; var client = new RestClient(this.uri); var request = new RestRequest("products/both", Method.POST); AddNewProductCommand command = new AddNewProductCommand() { Name = name }; request.AddJsonBody(command); //when IRestResponse response = client.Execute(request); //then response.StatusCode.Should().Be(HttpStatusCode.OK); List <Product> products = DBOperation.ReadAllProducts(); List <Inventory> inventories = DBOperation.ReadAllInventories(); products.Count.Should().Be(1, "products count !!!"); products[0].Name.Should().Be(name, "product name !!!"); products[0].Id.Should().Be(1, "product id !!!"); inventories.Count.Should().Be(1, "inventories count !!!"); inventories[0].Name.Should().Be(name, "inventory name !!!"); inventories[0].Id.Should().Be(1, "inventory id !!!"); }
public async void Test_AddProductTo_ProductAPI_And_QueryProductPriceFrom_PricingAPI() { //Arrange //Both below servers and clients DO NOT talk to each other directly or via REST. //All communication is via EventBus - RabbitMQ over AMQP protocol using (var productClient = _servers.ProductCatalogAPIServer.CreateClient()) { using (var priceClient = _servers.PricingAPIServer.CreateClient()) { //Act var addNewProductCommand = new AddNewProductCommand(10, "Addedproduct", "", "", 100, new decimal(12.25), ""); var content = new StringContent(JsonConvert.SerializeObject(addNewProductCommand), Encoding.UTF8, "application/json"); //1. Add a new product to product catalog microservice var productResponse = await productClient.PostAsync("api/v1/ProductCatalogue/new", content); //2. Query for price from pricing microservice for added product var priceResponse = await priceClient.GetAsync("api/v1/ProductPrice/" + addNewProductCommand.ProductId.ToString("D")); //Assert Assert.True(productResponse.StatusCode == System.Net.HttpStatusCode.OK); var items = await priceResponse.Content.ReadAsStringAsync(); var price = JsonConvert.DeserializeObject <ProductPrice>(items); //ProductId is equal, which shows that after adding to ProductCatalog microservice, //this product is also avaliable within Pricing microservices over integration events via RabbitMQ Event Bus Assert.True(price.ProductId == addNewProductCommand.ProductId); Assert.True((price.Price - addNewProductCommand.UnitPrice) < new decimal(0.0000000000001)); //Prices are equal } } }
//public AddProductViewModel(IDataRepository dataRepository, IDialogCoordinator dialogCoordinator) public AddProductViewModel(ProductsViewModel productsViewModel, IDataRepository dataRepository, IDialogCoordinator dialogCoordinator) { _dataRepository = dataRepository; _dialogCoordinator = dialogCoordinator; _productsViewModel = productsViewModel; AddNewProductCommand = new AddNewProductCommand(this); }
public async Task <IActionResult> AddNewProduct([FromBody] NewProductDTO dto) { var command = new AddNewProductCommand(dto.Name, dto.Price, dto.Stock); var result = await CartSystem.AddNewProduct(command); if (result.IsSuccessful) { return(Ok()); } return(BadRequest(result.Message)); }
static void RunCQRS() { var serviceProvider = BuildServiceProvider(); try { var commandDispatcher = new CommandDispatcher(serviceProvider); var queryDispatcher = new QueryDispatcher(serviceProvider); //Add new Product var product = new AddNewProductCommand { Id = Guid.NewGuid(), Name = "iPhone 11", Description = "Apple iphone 11" }; commandDispatcher.Send(product); //Update Product Unit Price commandDispatcher.Send(new UpdateProductUnitPriceCommand { Id = product.Id, UnitPrice = 800 }); //Update Product Current Stock commandDispatcher.Send(new UpdateProductCurrentStockCommand { Id = product.Id, CurrentStock = 500 }); //Fine Products By Name var productsByName = queryDispatcher.Send(new GetProductsByNameQuery { Name = "iPhone" }); foreach (var item in productsByName) { Console.WriteLine(item.ToString()); } //Fine Products By Name var outOfStockProducts = queryDispatcher.Send(new FindOutOfStockProductsQuery()); foreach (var item in outOfStockProducts) { Console.WriteLine(item.ToString()); } //Delete Product commandDispatcher.Send(new DeleteProductCommand { Id = product.Id }); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public async Task<IActionResult> AddNewProductAsync([FromBody]AddNewProductCommand command) { if(command == null) { return BadRequest(); } _logger.LogInformation($"Sending command for adding product with name {command.Name}"); var commandResult = await _mediator.Send(command); _logger.LogInformation($"Command handled successfuly for adding product with name {command.Name}"); return Ok(commandResult); }
public async void Test_API_AddNewProduct() { //Arrange var catalogController = CreateController(); var newProductCommand = new AddNewProductCommand(10, "Something", string.Empty, string.Empty, 10, 100, string.Empty); //Act var result = await catalogController.AddNewProductAsync(newProductCommand); //Assert var expectedResult = Assert.IsType <OkObjectResult>(result); Assert.True((bool)expectedResult.Value); Mock.VerifyAll(); }
public Task <bool> Handle(AddNewProductCommand message, CancellationToken cancellationToken) { if (!message.IsValid()) { NotifyValidationErrors(message); return(Task.FromResult(false)); } #region Get Category Category existingcategory = _categoryRepository.GetById(message.Id); if (existingcategory == null) { Bus.RaiseEvent(new DomainNotification(message.MessageType, "The Category does not exist.")); return(Task.FromResult(false)); } #endregion Get Category #region Add Product to Category Product product = new Product(Guid.NewGuid(), message.Name); if (existingcategory.Products != null && existingcategory.Products.Any(p => p.Name == product.Name)) { Bus.RaiseEvent(new DomainNotification(message.MessageType, "The Product Name has already been taken.")); return(Task.FromResult(false)); } existingcategory.AddProduct(product); #endregion Add Product to Category _categoryRepository.Update(existingcategory); if (Commit()) { Bus.RaiseEvent(new NewProductAddedEvent(existingcategory.Id, existingcategory.Name)); } return(Task.FromResult(true)); }
public IActionResult Post(AddNewProductCommand command) { _commandDispatcher.Send(command); return(NoContent()); }
public async Task <int> Add(AddNewProductCommand command) { return(await Mediator.Send(command)); }
public async Task <CommandResult> AddNewProduct(AddNewProductCommand command) { return(await _commandActor.Ask <CommandResult>(command)); }
public void AddNewProduct(ProductViewModel productViewModel) { AddNewProductCommand addNewProductCommand = _mapper.Map <AddNewProductCommand>(productViewModel); _bus.SendCommand(addNewProductCommand); }
public void Create([FromBody] AddNewProductCommand command) { _addNewProductCommandHandler.Execute(command); }
public async Task <IActionResult> AddNewProduct([FromBody] AddNewProductCommand request) => Ok(await Mediator.Send(request));