public async Task <IActionResult> BookingWithSaga(BookingAccepted model)
{
model.BookingId = NewId.NextGuid();
await _publishEndpoint.Publish(model);
return(Accepted());
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
await Task.Delay(100);
foreach (var i in Enumerable.Range(1, 11))
{
Console.Write($"Messages Published count: {i}");
//RabbitMQ publish with routing key information
//await _publish.Publish(new SomeValue($"{i}.Dark.Red"), ctx => ctx.SetRoutingKey("dark.red"));
//Azure Service Bus with header information
await _publish.Publish(new SomeValue { Payload = $"{i}.Dark.Red" }, x => x.Headers.Set("RoutingKey", "dark.red"));
await _publish.Publish(new SomeValue { Payload = $"{i}.Light.Red" }, x => x.Headers.Set("RoutingKey", "light.red"));
await _publish.Publish(new SomeValue { Payload = $"{i}.Dark.Blue" }, x => x.Headers.Set("RoutingKey", "dark.blue"));
//await _publish.Publish(new SomeValue { Payload = $"{i}.Light.Blue" });
//await _publish.Publish(new SomeValue { Payload = $"{i}.Dark.Red" });
//await _publish.Publish(new SomeValue { Payload = $"{i}.Light.Red" });
//await _publish.Publish(new SomeValue { Payload = $"{i}.Dark.Blue" });
}
;
}
public async Task <IAccountModel?> EvaluateAccountPendingAsync(IAccountModel accountCheckCommand)
{
if (
string.IsNullOrEmpty(accountCheckCommand.ProfileId) ||
string.IsNullOrEmpty(accountCheckCommand.Id)
)
{
return(null);
}
var isCreationAllowed = await _licenseManager.EvaluateNewEntityAsync(accountCheckCommand);
if (isCreationAllowed)
{
accountCheckCommand.SetApproval();
}
else
{
accountCheckCommand.SetDenial();
}
var approvedEntity = await _approvalsService.CreateApprovalAsync(
accountCheckCommand.ToApprovalEntity()
);
if (approvedEntity != null)
{
var accountIsCheckedEvent = approvedEntity.ToAccountModel <AccountIsCheckedEvent>(accountCheckCommand);
await _publishEndpoint.Publish(accountIsCheckedEvent);
return(accountIsCheckedEvent);
}
return(null);
}
public async Task <ActionResult> Create(CreateUserViewModel model)
{
if (ModelState.IsValid)
{
var userEvent = new CreateUserEvent
{
Name = model.Name,
Username = model.Username,
Password = model.Password
};
try
{
await _publishEndpoint.Publish <CreateUserEvent>(userEvent);
return(RedirectToAction(nameof(Index), new { success = true }));
}
catch
{
ModelState.AddModelError(string.Empty, "Error - Create User Event Publish");
}
}
return(View(model));
}
public async Task <ActionResult> Create(CreateOrderViewModel model)
{
if (ModelState.IsValid)
{
var filteredProducts = model.Products.Where(p => p.Amount > 0).ToList();
var orderEvent = new CreateOrderEvent
{
UserId = model.UserId,
Products = filteredProducts.Select(p => new CreateOrderEvent.CreateOrderEventProductDto(p.Id, p.Amount)).ToList()
};
try
{
await _publishEndpoint.Publish <CreateOrderEvent>(orderEvent);
return(RedirectToAction(nameof(Index), new { success = true }));
}
catch
{
ModelState.AddModelError(string.Empty, "Error - Create Order Event Publish");
}
}
model.SetUserList(await _orderService.GetUsersAsync());
model.SetProductList(await _orderService.GetProductsAsync());
return(View(model));
}
public async Task <ActionResult> Create(CreateProductViewModel model)
{
if (ModelState.IsValid)
{
var productEvent = new CreateProductEvent
{
Name = model.Name,
Amount = model.Amount,
Price = model.Price
};
try
{
await _publishEndpoint.Publish <CreateProductEvent>(productEvent);
return(RedirectToAction(nameof(Index), new { success = true }));
}
catch
{
ModelState.AddModelError(string.Empty, "Error - Create Product Event Publish");
}
}
return(View(model));
}
public async Task <IActionResult> TriggerFirstMessage()
{
var message = new FirstMessage();
await _publishEndpoint.Publish(message);
return(Ok());
}
public async Task <TransactionDto?> CreateNewTransactionAsync(ITransactionModel transactionModel)
{
if (
string.IsNullOrEmpty(transactionModel.ProfileId) ||
transactionModel.AccountId == Guid.Empty.ToString() ||
!await _licenseManager.EvaluateNewEntityAsync(transactionModel)
)
{
return(null);
}
// Optimistic Concurrency Control: set the sequential number
var sequencedTransaction = await _concurrencyManager.SetNextSequentialNumber(transactionModel);
var newTransaction = await _transactionsService.CreateTransactionAsync(
sequencedTransaction.ToTransactionEntity()
);
if (newTransaction != null)
{
await _publishEndpoint.Publish(newTransaction.ToTransactionModel <TransactionCreatedEvent>());
await _publishEndpoint.Publish(newTransaction.ToTransactionModel <TransactionCheckCommand>());
return(newTransaction.ToTransactionModel <TransactionDto>());
}
return(null);
}
public async void Created(Booking booking)
{
var contract = _mapper.Map <BookingCreatedContract>(booking);
contract.ItemNo = booking.Id;
await _publishEndpoint.Publish <IBookingCreated>(contract);
_logger.Information("Event: Created published, with name: {ItemName} and id: {Id}", contract.ItemName, contract.Id);
}
public async Task <IActionResult> AddManyAsync([FromBody, Required] IEnumerable <StudentOpticalForm> forms)
{
await _opticalFormRepository.DeleteManyAsync(forms);
await _opticalFormRepository.AddManyAsync(forms);
await _publishEndpoint.Publish(new EvaluateExam(forms.First().ExamId));
return(Ok());
}
private async Task Publish <TEvent>(TEvent evt, Type type) where TEvent : Event
{
if (type == null)
{
await _publishEndpoint.Publish(evt);
}
else
{
await _publishEndpoint.Publish(evt, type);
}
}
public async void Deleted(int Id, string ItemNo)
{
var contract = new ItemEntityDeleted {
Id = Id, ItemNo = ItemNo
};
//await _bus.Publish<ItemEntityDeleted>(contract);
await _publishEndpoint.Publish <IItemEntityDeleted>(contract);
_logger.Information("ItemManagerService - Publishing ItemEntityDeleted events with Id: {Id}, ItemNo: {ItemNo}",
Id, ItemNo);
}
public async Task <HttpResponseMessage> Register(HttpRequestMessage request, UserInput userInput)
{
return(await _apiHelper.CreateHttpResponse <string>(request, async() =>
{
var Id = await _userAppService.Register(userInput);
if (!string.IsNullOrWhiteSpace(Id))
{
await _publishEndpoint.Publish <UserRegisted>(new { Id = Id, UserName = userInput.UserName });
}
return Id;
}));
}
public async Task <DefaultResponse> Handle(StartSagaSampleCommand request, CancellationToken cancellationToken)
{
var @event = new SagaStartedEvent()
{
ItemId = request.ItemId,
Timestamp = DateTime.Now,
Text = request.TextRequest
};
await _publishEndpoint.Publish(@event);
return(DefaultResponse.Success());
}
public async Task Execute(BehaviorContext <OrderState> context, Behavior <OrderState> next)
{
await Console.Out.WriteLineAsync(
$"Publishing Order Event Created: {context.Instance.CorrelationId} ({context.GetPayload<ConsumeContext>().ConversationId})");
await _publishEndpoint.Publish <OrderStateCreated>(new
{
OrderId = context.Instance.CorrelationId,
Timestamp = DateTime.UtcNow
}, sendContext => sendContext.CorrelationId = NewId.NextGuid());
await next.Execute(context);
}
private void PublishItemCreatedEvent(SaveParticipantLibraryItemCommand saveParticipantLibraryItemCommand)
{
_publishEndpoint.Publish <IParticipantLibraryItemCreated>(new ParticipantLibraryItemCreated
{
NexusKey = saveParticipantLibraryItemCommand.NexusKey,
DisplayCode = saveParticipantLibraryItemCommand.DisplayCode,
Iso2Code = saveParticipantLibraryItemCommand.Iso2Code,
Iso3Code = saveParticipantLibraryItemCommand.Iso3Code,
Name = saveParticipantLibraryItemCommand.Name,
DisplayName = saveParticipantLibraryItemCommand.DisplayName,
TypeKey = saveParticipantLibraryItemCommand.TypeKey,
});
}
public Task Publish <T>(object values, CancellationToken cancellationToken = default) where T : class
{
if (Transaction.Current == null)
{
return(_publishEndpoint.Publish(values, cancellationToken));
}
var pendingActions = _pendingActions.GetOrAdd(Transaction.Current, new TransactionOutboxEnlistment(_loggerFactory));
pendingActions.Add(() => _publishEndpoint.Publish(values, cancellationToken));
return(Task.CompletedTask);
}
public async Task<IActionResult> CrearProceso([FromBody] Proceso proceso)
{
var procesoProgreso = new
{
IdEmpresa = proceso.IdEmpresa,
IdNomina = proceso.IdNomina,
IdProceso = proceso.Tipo,
TotalRegistros = proceso.Cantidad
};
await _publicador.Publish<ICrearProcesoProgreso>(procesoProgreso);
CrearNotificacionesProgreso(procesoProgreso);
return Ok(procesoProgreso);
}
public async Task Publish(IPublishEndpoint endpoint, TInput input, IPipe <PublishContext> pipe, CancellationToken cancellationToken)
{
InitializeMessageContext <TMessage, TInput> messageContext = await InitializeMessage(input, cancellationToken).ConfigureAwait(false);
if (_headerInitializers.Length > 0)
{
await endpoint.Publish(messageContext.Message, new InitializerPublishContextPipe(_headerInitializers, messageContext, pipe), cancellationToken)
.ConfigureAwait(false);
}
else
{
await endpoint.Publish(messageContext.Message, pipe, cancellationToken).ConfigureAwait(false);
}
}
public async Task <ActionResult <ItemDTO> > PostAsync([FromBody] CreateItemContract createItemContract)
{
var item = new Item
{
Name = createItemContract.Name,
Description = createItemContract.Description,
Price = createItemContract.Price,
CreatedDate = DateTimeOffset.UtcNow
};
await _itemsRepository.CreateAsync(item);
await _publishEndpoint.Publish(new CatalogItemCreatedContract(item.Id, item.Name, item.Description));
return(CreatedAtAction(nameof(GetByIdAsync), new { id = item.Id }, item));
}
public async Task <ActionResult <ItemDto> > PostAsync(CreateItemDto createItemDto)
{
var item = new Item
{
Name = createItemDto.Name,
Description = createItemDto.Description,
Price = createItemDto.Price,
CreatedDate = DateTimeOffset.UtcNow
};
await itemsRepository.CreateAsync(item);
await publishEndpoint.Publish(new CatalogItemCreated(item.Id, item.Name, item.Description));
return(CreatedAtAction(nameof(GetByIdAsync), new { id = item.Id }, item));
}
public async Task Consume(ConsumeContext <SubmitOrderRequest> context)
{
_logger.LogInformation("Received Order {OrderId} at {OrderDate}", context.Message.OrderId, context.Message.OrderDate);
// await generate/submit order
//publish/broadcast an event that order submitted successfully
await _publishEndpoint.Publish <OrderSubmittedEvent>(new
{
context.Message.OrderId,
context.Message.OrderDate,
context.Message.CustomerNumber,
context.Message.OrderTotal,
OrderStatus = "Submitted"
});
//caller expects a response
//mass transit can do both patterns i.e fire and forget and respond, however it is generally not recommended to do both in a consumer
if (context.RequestId != null)
{
await context.RespondAsync <SubmitOrderResponse>(new
{
Ack = true,
OrderStatus = "Submitted"
});
}
}
protected async Task <Guid> LoadBlob(IPublishEndpoint endpoint, Guid userId, string bucket, string fileName, string contentType = "application/octet-stream", IDictionary <string, object> metadata = null)
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "Resources", fileName);
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
var blobId = await _blobStorage.AddFileAsync(fileName, File.OpenRead(path), contentType, bucket, metadata);
var blobInfo = await _blobStorage.GetFileInfo(blobId, bucket);
await endpoint.Publish <BlobLoaded>(new
{
//CorrelationId = blobInfo.Metadata != null ? blobInfo.Metadata.ContainsKey("correlationId") ? new Guid(blobInfo.Metadata["correlationId"].ToString()) : Guid.Empty,
BlobInfo = new LoadedBlobInfo(blobId, fileName, blobInfo.Length, userId, blobInfo.UploadDateTime, blobInfo.MD5, bucket, blobInfo.Metadata),
TimeStamp = DateTimeOffset.UtcNow
});
//Thread.Sleep(100);
Log.Debug($"BlobLoaded: {fileName}; BlobId: {blobId}");
return(blobId);
}
public async Task Consume(ConsumeContext <EditProductEvent> context)
{
_logger.LogInformation($"Processing msg: '{context.MessageId}' with topic: '{context.ConversationId}'.");
try
{
var product = context.Message;
var dbProduct = await _applicationDbContext.Products.FirstOrDefaultAsync(x => x.Id == product.Id);
if (dbProduct == null)
{
throw new ApplicationException("Product not found");
}
dbProduct.Name = product.Name;
dbProduct.Price = product.Price;
dbProduct.Amount = product.Amount;
await _applicationDbContext.SaveChangesAsync();
_logger.LogInformation($"Edited product with ID {dbProduct.Id} and name {dbProduct.Name}");
await _publishEndpoint.Publish(new ProductEditedEvent
{
Id = dbProduct.Id,
Name = dbProduct.Name,
Amount = dbProduct.Amount,
Price = dbProduct.Price
});
}
catch (Exception ex)
{
_logger.LogError(default, ex, ex.Message);
async public Task <OperationResult <List <TemplateModel> > > GetAll()
{
var productRepository = _sqlUnitOfWork.GetRepository <ITempateSQLServerRepository>();
List <TestMessageResponse> list = new List <TestMessageResponse>();
for (var index = 0; index <= 10; index++)
{
await _publishEndpoint.Publish(new TestMessagePublish
{
Id = Guid.NewGuid(),
Text = "TestText",
Value = 5
});
}
for (var index = 0; index <= 10; index++)
{
var result = await _client.GetResponse <OperationResult <TestMessageResponse> >(new TestMessageRequest { Text = index.ToString() });
list.Add(result.Message.Data);
}
return(productRepository.Get());
}
public async Task Consume(ConsumeContext <UserCheckoutAcceptedIntegrationEvent> context)
{
IExecutionResult result = ExecutionResult.Failed();
var orderId = OrderId.New;
// Send Integration event to clean basket once basket is converted to Order and before starting with the order creation process
var orderItems = from orderItem in context.Message.Basket.Items
select new OrderStockItem(int.Parse(orderItem.ProductId), orderItem.Quantity);
if (context.Message.RequestId != Guid.Empty)
{
var createOrderCommand = new CreateOrderCommand(orderId, new SourceId(context.Message.RequestId.ToString()), context.Message.Basket.Items, context.Message.UserId, context.Message.UserName, context.Message.City, context.Message.Street,
context.Message.State, context.Message.Country, context.Message.ZipCode,
context.Message.CardNumber, context.Message.CardHolderName, context.Message.CardExpiration,
context.Message.CardSecurityNumber, context.Message.CardTypeId);
result = await _commandBus.PublishAsync(createOrderCommand, CancellationToken.None).ConfigureAwait(false);
if (result.IsSuccess)
{
var orderStartedIntegrationEvent = new OrderStartedIntegrationEvent(context.Message.UserId, orderId.Value, orderItems.ToList(), context.Message.RequestId);
await _endpoint.Publish(orderStartedIntegrationEvent);
}
}
}
public async Task <ActionResult <Purchase> > Add(PurchaseRequest request)
{
try
{
int userId = int.Parse(User.Claims.FirstOrDefault(x => x.Type == "id")?.Value ?? "-1");
var purchase = await _service.AddAsync(userId, request);
var storePurchase = new StorePurchase
{
Date = purchase.TimeOfPurchase,
UserId = userId,
PurchaseProducts = purchase.ReceiptPositions.Select(x => new PurchaseProduct
{
Count = x.Count,
Name = x.Product.ProductName,
Price = x.Product.Price
}).ToList()
};
await _endpoint.Publish(storePurchase);
return(Ok(purchase));
}
catch (ApiException e)
{
return(BadRequest(new ProblemDetails {
Detail = e.Message
}));
}
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
// get existing basket with total price
// Set TotalPrice on basketCheckout eventMessage
// send checkout event to rabbitmq
// remove the basket
// get existing basket with total price
var basket = await _repository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
// send checkout event to rabbitmq
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.TotalPrice = basket.TotalPrice;
await _publishEndpoint.Publish <BasketCheckoutEvent>(eventMessage);
// remove the basket
await _repository.DeleteBasket(basket.UserName);
return(Accepted());
}
public async Task <IActionResult> CreateOrder([FromBody] Order order)
{
order.OrderStatus = OrderStatus.Preparing;
order.OrderDate = DateTime.UtcNow;
_logger.LogInformation(" testing ");
_logger.LogInformation(" In Create Order");
_logger.LogInformation(" Order" + order.UserName);
_ordersContext.Orders.Add(order);
_ordersContext.OrderItems.AddRange(order.OrderItems);
_logger.LogInformation(" Order added to context");
_logger.LogInformation(" Saving........");
try
{
await _ordersContext.SaveChangesAsync();
_logger.LogWarning("BuyerId is: " + order.BuyerId);
_bus.Publish(new OrderCompletedEvent(order.BuyerId)).Wait();
return(Ok(new { order.OrderId }));
}
catch (DbUpdateException ex)
{
_logger.LogError("An error occored during Order saving .." + ex.Message);
return(BadRequest());
}
}
public async Task <ActionResult <ItemDTO> > Post(CreateItemDTO createItemDTO)
{
var item = new Items
{
Name = createItemDTO.Name,
Description = createItemDTO.Description,
Price = createItemDTO.Price,
CreatedDate = DateTimeOffset.UtcNow
};
await _itemsRepository.Create(item);
await _publishEndpoint.Publish(new CatalogItemCreated(item.Id, item.Name, item.Description));
return(CreatedAtAction(nameof(GetById), new { id = item.Id }, item));
}
