private void When(ProductCreated e)
{
Products.Add(new ProductDTO()
{
Name = e.Name, Id = e.Id
});
}
public async Task <ActionResult <Product> > Create([FromBody] ProductCreated model)
{
if (!ModelState.IsValid)
{
return(BadRequest(
new
{
Error = new { Message = "Invalid product created." },
ModelState.Values
}
));
}
var prod = new Product
{
Nombre = model.Nombre,
Presentacion = model.Presentacion,
Descripcion = model.Descripcion,
Precio = model.Precio,
FechaCreacion = model.FechaCreacion,
ImageUrl = model.ImageUrl,
Id = ""
};
await _productService.CreateAsync(prod);
return(CreatedAtRoute("GetProductById", new { id = prod.Id.ToString() }, prod));
}
/// <summary>
///Proceso de creación de un producto, asíncrono.
/// </summary>
/// <param name="model">Objeto de tipo producto.</param>
/// <returns>Retorna el nevo objeto creado con su id</returns>
public async Task <ProductApiModel> CreateProductAsync([FromBody] ProductCreated model)
{
ProductApiModel pro = null;
response = await client.PostAsJsonAsync($"{_HostProduct}v1/api/product", model);
var jsonSerialize = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
string mensaje = JsonConvert.SerializeObject(jsonSerialize);
throw new HttpException(new List <string> {
mensaje
}, response.StatusCode);
}
// return URI of the created resource.
pro = JsonConvert
.DeserializeObject <ProductApiModel>(jsonSerialize.ToString()
, new JsonSerializerSettings()
{
MissingMemberHandling =
MissingMemberHandling.Ignore
});
pro.CheckIsNotNull();
return(pro);
}
void Apply(ProductCreated e)
{
Id = e.Id.ToString();
_price = e.Price;
_quantity = e.Quantity;
_productCode = e.ProductCode;
}
private void Apply(ProductCreated e)
{
Id = e.Id;
Name = e.Name;
Description = e.Description;
Price = e.Price;
}
private void Apply(ProductCreated e)
{
Id = e.Id;
Code = e.Code;
Name = e.Name;
Description = e.Description;
}
private void HandleProductCreated(ProductCreated ev)
{
var product = new Product(ev.Name);
products.Add(product);
ev.EntityId = product.Id;
}
private void Apply(ProductCreated @event)
{
Id = @event.ProductId;
Brand = new BrandRef(@event.BrandId, "");
Category = new CategoryRef(@event.CategoryId, "");
Code = @event.ProductCode;
}
static void Main(string[] args)
{
var productService = new ProductService(new ProductRepository());
var productEvent = new ProductCreated
{
Message = "Some message",
MessageAttributes = new Dictionary <string, MessageAttribute>()
{
{ "ID", new MessageAttribute {
DataType = "number", StringValue = "3"
} },
{ "Name", new MessageAttribute {
DataType = "string", StringValue = "Polestar 3"
} }
}
};
productService.HandleSaveProductEvent(productEvent);
var products = productService.GetAllProducts();
foreach (var p in products)
{
Console.WriteLine(p.Id);
Console.WriteLine(p.Name);
}
}
private void OnProductCreated(ProductCreated @event)
{
if (@event == null)
{
throw new ArgumentNullException(nameof(@event));
}
Title = @event.Title;
}
private void Apply(ProductCreated @event)
{
Id = @event.AggregateRootId;
Name = @event.Name;
Description = @event.Description;
Price = @event.Price;
Status = @event.Status;
}
public void CreateProduct(CreateProductCommand cmd)
{
if (!_products.Any(x => x.Id == cmd.Id || x.Name.Equals(cmd.Name)))
{
var @event = new ProductCreated(cmd.Id, cmd.Name, cmd.Description);
Apply(@event);
Dispatch(@event);
}
}
public ActionResult SendObj()
{
var @event = new ProductCreated {
Guid = Guid.NewGuid(), Id = 5, Name = "Twarożek"
};
_eventBusPublisher.Publish(@event, "ProductCreated");
return(Ok());
}
private void When(ProductCreated @event)
{
this.Id = @event.AggregateId;
this.Name = @event.Name;
this.Description = @event.Description;
this.Qty = @event.TotalSalesQty;
this.CategoryId = @event.CategoryId;
this.ThumbnailPath = @event.ThumbnailPath;
this.SlidingImgPath = @event.SlidingImgPath?.ToList() ?? new List <ImageInfo>();
}
public void Handle(ProductCreated @event)
{
_auditRepository.Add(new Audit()
{
Id = @event.EventId.ToString(),
Name = @event.GetType().ToString(),
Details = @event.Name,
CreatedTime = @event.EventPublished.UtcDateTime
});
}
public XNodeEventService(ILogger <SystemService> logger,
string agentId,
XNodeConfiguration nodeConfig,
DataStorageConfiguration dataStorageConfig,
AgentConfiguration agentConfiguration,
IXNodeConnectionRepository xNodeConnectionRepository,
TenantIOService tenantIOService,
ProducerIOService producerIOService,
ConsumerIOService consumerIOService,
MessageIOService messageIOService)
{
this.logger = logger;
this.xNodeConnectionRepository = xNodeConnectionRepository;
this.tenantIOService = tenantIOService;
this.producerIOService = producerIOService;
this.consumerIOService = consumerIOService;
this.messageIOService = messageIOService;
this.agentId = agentId;
this.nodeConfig = nodeConfig;
var provider = new XNodeConnectionProvider(nodeConfig, dataStorageConfig, agentConfiguration, agentId);
_connection = provider.GetHubConnection();
_connection.On <AgentConnectedArgs>("StorageConnected", connectedArgs => StorageConnected?.Invoke(connectedArgs));
_connection.On <AgentDisconnectedArgs>("StorageDisconnected", disconnectedArgs => StorageDisconnected?.Invoke(disconnectedArgs));
_connection.On <TenantCreatedArgs>("TenantCreated", tenantCreated => TenantCreated?.Invoke(tenantCreated));
_connection.On <TenantUpdatedArgs>("TenantUpdated", tenantUpdated => TenantUpdated?.Invoke(tenantUpdated));
_connection.On <ProductCreatedArgs>("ProductCreated", productCreated => ProductCreated?.Invoke(productCreated));
_connection.On <ProductUpdatedArgs>("ProductUpdated", productUpdated => ProductUpdated?.Invoke(productUpdated));
_connection.On <ComponentCreatedArgs>("ComponentCreated", componentCreated => ComponentCreated?.Invoke(componentCreated));
_connection.On <ComponentUpdatedArgs>("ComponentUpdated", componentUpdated => ComponentUpdated?.Invoke(componentUpdated));
_connection.On <TopicCreatedArgs>("TopicCreated", topicCreated => TopicCreated?.Invoke(topicCreated));
_connection.On <TopicUpdatedArgs>("TopicUpdated", topicUpdated => TopicUpdated?.Invoke(topicUpdated));
_connection.On <ProducerConnectedArgs>("ProducerConnected", producerConnected => ProducerConnected?.Invoke(producerConnected));
_connection.On <ProducerDisconnectedArgs>("ProducerDisconnected", producerDisconnected => ProducerDisconnected?.Invoke(producerDisconnected));
_connection.On <ConsumerConnectedArgs>("ConsumerConnected", consumerConnected => ConsumerConnected?.Invoke(consumerConnected));
_connection.On <ConsumerDisconnectedArgs>("ConsumerDisconnected", consumerDisconnected => ConsumerDisconnected?.Invoke(consumerDisconnected));
_connection.On <ConsumerConnectedArgs>("ConsumerUnacknowledgedMessagesRequested", consumerConnected => ConsumerUnacknowledgedMessagesRequested?.Invoke(consumerConnected));
_connection.On <MessageAcknowledgedArgs>("MessageAcknowledged", messageAcked => MessageAcknowledged?.Invoke(messageAcked));
_connection.On <MessageStoredArgs>("MessageStored", msgStored => MessageStored?.Invoke(msgStored));
InitializeEventHandlers();
ConnectAsync();
xNodeConnectionRepository.AddService(nodeConfig.ServiceUrl, agentId, this);
}
void OnProductCreated(ProductCreated productCreated)
{
lock (lock_)
{
if (CheckMessageSanity(productCreated))
{
var product = productCreated.Product;
data[product.Id] = product;
}
}
}
static void proccessProductCreated(ProductCreated newProduct)
{
var pli = MapProductLineItem(newProduct);
pli.CategoryName = newProduct.CategoryName;
using (var redisClient = new RedisClient())
using (var cacheProduct = redisClient.As <ProductLineItem>())
{
cacheProduct.Store(pli);
}
}
public void Handle(ProductCreated @event)
{
Product product = new Product()
{
Id = @event.Id,
Name = @event.Name,
Price = @event.Price
};
_orderRepository.SaveProduct(product);
}
private void Handle(ProductCreated evt)
{
var product = new Product()
{
Id = evt.Id,
Name = evt.Name,
Price = evt.Price
};
_indexer.Index(product);
_graphIndexer.AddProduct(product);
}
private void OnProductCreated(ProductCreated evt)
{
_ctx.Products.Add(new Product
{
Id = evt.AggregateId,
Name = evt.Name,
Price = evt.Price,
Quantity = 0,
Reserved = 0,
LastEventNumber = evt.Metadata.EventNumber
});
_ctx.SaveChanges();
}
public async Task <IActionResult> CreateProduct([FromBody] ProductCreated request)
{
var jsonRequest = JsonSerializer.Serialize(request, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
this._logger.LogInformation($"[{nameof(PublisherController)}] - Send to [{nameof(DaprPublisher)}]: {jsonRequest}");
await this._daprPublisher.Publish(request);
return(Ok());
}
public void Product_Should_Be_Created()
{
var productId = Guid.NewGuid();
var name = Random <string>();
var @event = new ProductCreated(productId, name);
new ScenarioFor <Product>(
() => Product.Create(productId, name)
)
.When(product => { })
.ThenAssert(@event);
}
public async Task <IActionResult> CreateProduct([FromBody] CreateProductRequest request)
{
var productCreated = new ProductCreated
{
Id = Guid.NewGuid(),
Name = request.Name,
price = request.price
};
await _messagePublisher.Publish(productCreated);
return(Ok());
}
/*private void Handle(OrderCreated evt)
* {
* var existinBasket = _indexer.Get<Basket>(evt.BasketId);
* existinBasket.BasketState = BasketState.Paid;
* _indexer.Index(existinBasket);
*
* _graphClient.Cypher
* .Match("(customer:Customer)-[:HAS_BASKET]->(basket:Basket)-[]->(product:Product)")
* .Where((Basket basket) => basket.Id == evt.BasketId)
* .Create("customer-[:BOUGHT]->product")
* .ExecuteWithoutResults();
* }
*
* private void Handle(BasketCheckedOut evt)
* {
* var basket = _indexer.Get<Basket>(evt.Id);
* basket.BasketState = BasketState.CheckedOut;
* _indexer.Index(basket);
* }
*
* private void Handle(CustomerIsCheckingOutBasket evt)
* {
* var basket = _indexer.Get<Basket>(evt.Id);
* basket.BasketState = BasketState.CheckingOut;
* _indexer.Index(basket);
* }*/
/*private void Handle(ItemAdded evt)
* {
* var existingBasket = _indexer.Get<Basket>(evt.Id);
* var orderLines = existingBasket.OrderLines;
* if (orderLines == null || orderLines.Length == 0)
* {
* existingBasket.OrderLines = new[] { evt.OrderLine };
* }
* else
* {
* var orderLineList = orderLines.ToList();
* orderLineList.Add(evt.OrderLine);
* existingBasket.OrderLines = orderLineList.ToArray();
* }
*
* _indexer.Index(existingBasket);
*
* _graphClient.Cypher
* .Match("(basket:Basket)", "(product:Product)")
* .Where((Basket basket) => basket.Id == evt.Id)
* .AndWhere((Product product) => product.Id == evt.OrderLine.ProductId)
* .Create("basket-[:HAS_ORDERLINE {orderLine}]->product")
* .WithParam("orderLine", evt.OrderLine)
* .ExecuteWithoutResults();
* }*/
/*private void Handle(BasketCreated evt)
* {
* var newBasket = new Basket()
* {
* Id = evt.Id,
* OrderLines = null,
* BasketState = BasketState.Shopping
* };
* _indexer.Index(newBasket);
* _graphClient.Cypher
* .Create("(basket:Basket {newBasket})")
* .WithParam("newBasket", newBasket)
* .ExecuteWithoutResults();
*
* _graphClient.Cypher
* .Match("(customer:Customer)", "(basket:Basket)")
* .Where((Customer customer) => customer.Id == evt.CustomerId)
* .AndWhere((Basket basket) => basket.Id == evt.Id)
* .Create("customer-[:HAS_BASKET]->basket")
* .ExecuteWithoutResults();
* }*/
private void Handle(ProductCreated evt)
{
var product = new Product()
{
Id = evt.Id,
Name = evt.Name
};
_indexer.Index(product);
_graphClient.Cypher
.Create("(product:Product {newProduct})")
.WithParam("newProduct", product)
.ExecuteWithoutResults();
}
public async Task <ProductVM> Handle(AddProductCmd request, CancellationToken cancellationToken)
{
ProductId productId = this.repository.GenerateProductId();
CategoryId categoryId = this.categoryIdTranslator.Translate(request.CategoryId);
Product product = Product.CreateProduct(productId, request.Name,
request.Description, request.TotalSalesQty, categoryId,
request.ThumbnailPath, request.SlidingImgPath);
ProductCreated @event = product.DomainEvents.First(evt => evt is ProductCreated) as ProductCreated;
this.repository.Save(product, @event);
ProductVM rm = this.productRMTranslator.Translate(product);
return(await Task.FromResult(rm));
}
public async Task <string> Create(string title, int amount)
{
var product = new Product
{
Id = Guid.NewGuid().ToString(),
Title = title,
Amount = amount,
};
var @event = await CreateEvent(
product.Id, EventTypes.ProductCreated, product);
var productCreated = ProductCreated.Create(@event, product);
messageQueue.Publish(productCreated);
return(product.Id);
}
public void When_CreateProduct_ProductCreated()
{
var command = new CreateProduct(id, "Test Product", 2);
command.Metadata.CausationId = command.Metadata.CommandId;
command.Metadata.CorrelationId = causationAndCorrelationId;
When(command);
var expectedEvent = new ProductCreated(id, "Test Product", 2);
expectedEvent.Metadata.CausationId = command.Metadata.CommandId;
expectedEvent.Metadata.CorrelationId = causationAndCorrelationId;
expectedEvent.Metadata.ProcessId = command.Metadata.ProcessId;
Then(expectedEvent);
}
public async Task Publish(ProductCreated request)
{
var jsonRequest = JsonSerializer.Serialize(request, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
var requestStringContent = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
this._logger.LogInformation($"[{nameof(DaprPublisher)}] - Preparing publish: {jsonRequest}");
this._logger.LogInformation($"[{nameof(DaprPublisher)}] - Publish Address: {this._httpClient.BaseAddress}");
var response = await this._httpClient.PostAsync("/v1.0/publish/ProductCreated", requestStringContent);
response.EnsureSuccessStatusCode();
}
public void Aggregate_Should_Be_Created_And_Publish_ProductCreated_Event()
{
var productId = Random <Guid>();
var brandId = Random <int>();
var productCode = Random <string>();
var categoryId = Random <int>();
var productCreated = new ProductCreated(
productId,
productCode,
brandId, categoryId);
ScenarioFor(
() => Product.Create(productId, categoryId, brandId, productCode)
)
.When(product => { })
.Then(productCreated);
}
private void Handle(ProductCreated evt)
{
var product = new Product()
{
Id = evt.Id,
Name = evt.Name,
Price = evt.Price
};
_indexer.Index(product);
_graphClient.Cypher
.Create("(product:Product {newProduct})")
.WithParam("newProduct", product)
.ExecuteWithoutResults();
}
private void Apply(ProductCreated obj)
{
Id = obj.Id;
Name = obj.Name;
Price = obj.Price;
}
public void Handle(ProductCreated evnt)
{
_connection.Insert(evnt, "eventsourcing_sample_product", _transaction);
}
protected virtual void Handle(ProductCreated evnt)
{
_entityManager.BuildAndSave<ProductEntity>(evnt);
}