public async Task HandleAsync(CreateUser command) { _logger.LogInformation("Create user: {User} with email {Email}", command.Name, command.Email); try { await _userService.RegisterAsync(command.Email, command.Password, command.Name); await _bus.PublishAsync(new UserCreated(command.Email, command.Name)); } catch (ActioException ex) { _logger.LogError(ex, ex.Message); await _bus.PublishAsync(new CreateUserRejected(command.Email, ex.Code, ex.Message)); } catch (Exception ex) { _logger.LogError(ex, ex.Message); await _bus.PublishAsync(new CreateUserRejected(command.Email, "error", ex.Message)); } }
public async Task HandleAsync(CreateActivity Command) { _logger.LogInformation($"Creating Activity: {Command.Name} !"); try { await _activityService.AddAsync(Command.Id, Command.UserId, Command.Category, Command.Name, Command.Description, Command.CreatedAt); await _busClient.PublishAsync(new ActivityCreated(Command.Id, Command.UserId, Command.Category, Command.Name, Command.Description, Command.CreatedAt)); } catch (ActioException ex) { await _busClient.PublishAsync(new CreateActivityRejected(Command.Id, ex.Message, ex.Code)); _logger.LogError(ex.Message); } catch (Exception ex) { await _busClient.PublishAsync(new CreateActivityRejected(Command.Id, ex.Message, "error")); _logger.LogError(ex.Message); } }
public async Task HandleAsync(CreateMovie command) { Console.WriteLine($"Creating movie {command.Title}"); try { await movieService.AddAsync(command.Url, command.Title, command.Duration, command.Description); } catch (Exception ex) { throw ex; } await busClient.PublishAsync(new MovieCreated(command.Id, command.Title)); }
public async Task <IActionResult> Post([FromBody] CreateMovie createMovie) { try { await busClient.PublishAsync(createMovie); return(Accepted($"api/movies/{createMovie.Id}")); } catch (Exception ex) { throw; } }
public async Task <IActionResult> Post(int number) { int?result = _repo.Get(number); if (!result.HasValue) { await _client.PublishAsync(new CalculateValueCommand() { Number = number }); } return(Accepted($"fib/{number}", null)); }
public async Task HandleAsync(RenewRemark command) { await _handler .Validate(async() => { var remark = await _remarkService.GetAsync(command.RemarkId); if (remark.Value.Group == null) { return; } await _groupService.ValidateIfRemarkCanBeRenewedOrFailAsync(remark.Value.Group.Id, command.UserId); }) .Run(async() => { Location location = null; if (command.Latitude != 0 && command.Longitude != 0) { location = Location.Create(command.Latitude, command.Longitude, command.Address); } await _remarkStateService.RenewAsync(command.RemarkId, command.UserId, command.Description, location); }) .OnSuccess(async() => { var remark = await _remarkService.GetAsync(command.RemarkId); var state = remark.Value.GetLatestStateOf(RemarkState.Names.Renewed).Value; var resource = _resourceFactory.Resolve <RemarkRenewed>(command.RemarkId); await _bus.PublishAsync(new RemarkRenewed(command.Request.Id, resource, command.UserId, command.RemarkId)); }) .OnCustomError(async ex => await _bus.PublishAsync(new RenewRemarkRejected(command.Request.Id, command.UserId, command.RemarkId, ex.Code, ex.Message))) .OnError(async(ex, logger) => { logger.Error(ex, "Error occured while renewing a remark."); await _bus.PublishAsync(new RenewRemarkRejected(command.Request.Id, command.UserId, command.RemarkId, OperationCodes.Error, ex.Message)); }) .ExecuteAsync(); }
public async Task HandleAsync(ActivateAccount command) { await _handler .Run(async() => await _userService .ActivateAsync(command.Email, command.Token)) .OnSuccess(async() => { var user = await _userService.GetByEmailAsync(command.Email, Providers.Collectively); await _bus .PublishAsync(new AccountActivated(command.Request.Id, command.Email, user.Value.UserId)); }) .OnCustomError(async ex => await _bus .PublishAsync(new ActivateAccountRejected(command.Request.Id, command.Email, ex.Code, ex.Message))) .OnError(async(ex, logger) => { logger.Error(ex, "Error when activating account."); await _bus.PublishAsync(new ActivateAccountRejected(command.Request.Id, command.Email, OperationCodes.Error, "Error when activating account")); }) .ExecuteAsync(); }
public async Task Handle(NotaFiscalCreatedDomainEvent notification, CancellationToken cancellationToken) { var message = new DespesaCreatedMessage { CPF = notification.NotaFiscal.Periodo.DeputadoFederal.CPF, TipoId = 1, Ano = notification.NotaFiscal.Periodo.Ano, Mes = notification.NotaFiscal.Periodo.Mes, Valor = notification.NotaFiscal.ValorDocumento }; await _busClient.PublishAsync(message); }
public async Task HandleAsync(CreateUser command) { _logger.LogInformation($"Create USer Handler called with params: User Email as {command.Email} and User Name as {command.Name}"); try { await _userService.RegisterAsync(command.Email, command.Password, command.Name); await _busClient.PublishAsync(new UserCreated(command.Email, command.Name)); _logger.LogInformation($"User created with Email {command.Email} and name {command.Name}"); } catch (LearnException learnEx) { _logger.LogError(learnEx, learnEx.Message); await _busClient.PublishAsync(new CreateUserRejected(learnEx.Message, learnEx.Code, command.Email)); } catch (Exception ex) { _logger.LogError(ex, ex.Message); await _busClient.PublishAsync(new CreateUserRejected(ex.Message, "error", command.Email)); } }
public async Task HandleAsync(ProcessWardenCheckResult command) { CheckResult checkResult = null; await _handler .Run(async() => { checkResult = _wardenCheckService.ValidateAndParseResult(command.UserId, command.OrganizationId, command.WardenId, command.Check); await _wardenCheckService.SaveAsync(checkResult); }) .OnSuccess(async() => await _bus.PublishAsync(new WardenCheckResultProcessed(command.Request.Id, command.UserId, command.OrganizationId, command.WardenId, _mapper.Map <CheckResult, CheckResultDto>(checkResult)))) .OnCustomError(async ex => await _bus.PublishAsync(new ProcessWardenCheckResultRejected(command.Request.Id, command.UserId, ex.Code, ex.Message))) .OnError(async(ex, logger) => { logger.Error("Error occured while processing Warden check result."); await _bus.PublishAsync(new ProcessWardenCheckResultRejected(command.Request.Id, command.UserId, OperationCodes.Error, ex.Message)); }) .ExecuteAsync(); }
private async Task DatabaseSpaceMetricCollect(DbWorkerOperationCompleted command) { var databaseSpaceMetrics = new DatabaseSpaceMetricsModel(); var flatResult = command.Result.SelectMany(x => x).Where(x => x.Key == "database_size" || x.Key == "unallocated space"); var databaseSize = flatResult.FirstOrDefault(x => x.Key == "database_size").Value.Split(); databaseSpaceMetrics.DatabaseId = command.DatabaseId; databaseSpaceMetrics.Space = Convert.ToDouble(flatResult.FirstOrDefault(x => x.Key == "database_size").Value.Split()[0]); databaseSpaceMetrics.UnallocatedSpace = Convert.ToDouble(flatResult.FirstOrDefault(x => x.Key == "unallocated space").Value.Split()[0]); databaseSpaceMetrics.Unit = "MB"; await _databaseSpaceMetricsService.CreateAsync(databaseSpaceMetrics); await _busClient.PublishAsync(new DatabaseSpaceUsageMetricsCompleted( command.Id, command.UserId, databaseSpaceMetrics.DatabaseId, databaseSpaceMetrics.Space, databaseSpaceMetrics.UnallocatedSpace, databaseSpaceMetrics.Unit )); }
public async Task HandleAsync(EditRemark command) => await _handler .Validate(async() => await _remarkService.ValidateEditorAccessOrFailAsync(command.RemarkId, command.UserId)) .Run(async() => { Location location = null; if (command.Latitude.HasValue && command.Latitude != 0 && command.Longitude.HasValue && command.Longitude != 0) { var locations = await _locationService.GetAsync(command.Latitude.Value, command.Longitude.Value); if (locations.HasNoValue || locations.Value.Results == null || !locations.Value.Results.Any()) { throw new ServiceException(OperationCodes.AddressNotFound, $"Address was not found for remark with id: '{command.RemarkId}' " + $"latitude: {command.Latitude}, longitude: {command.Longitude}."); } var address = locations.Value.Results.First().FormattedAddress; location = Domain.Location.Create(command.Latitude.Value, command.Longitude.Value, address); } await _remarkService.EditAsync(command.RemarkId, command.UserId, command.GroupId, command.Category, command.Description, location); }) .OnSuccess(async() => { var remark = await _remarkService.GetAsync(command.RemarkId); var resource = _resourceFactory.Resolve <RemarkEdited>(command.RemarkId); await _bus.PublishAsync(new RemarkEdited(command.Request.Id, resource, command.UserId, command.RemarkId)); }) .OnCustomError(async ex => await _bus.PublishAsync(new EditRemarkRejected(command.Request.Id, command.UserId, command.RemarkId, ex.Code, ex.Message))) .OnError(async(ex, logger) => { logger.Error(ex, "Error occured while editing a remark."); await _bus.PublishAsync(new EditRemarkRejected(command.Request.Id, command.UserId, command.RemarkId, OperationCodes.Error, ex.Message)); }) .ExecuteAsync();
public async Task <IActionResult> Post(int n) { ulong?result = _repository.Get(n); if (!result.HasValue) { await _client.PublishAsync(new CalculateFactorial { Number = n }); } return(Accepted($"factorial/{n}", null)); }
public async Task HandlerAsync(CreateActivity command) { Console.WriteLine($"Receive Create Activity command:{command.Name}"); try { await _activityService.AddAsync(command.Id, command.Name, command.Description, command.Category, command.UserId, command.CreatedAt); await _bus.PublishAsync(new ActivityCreated(command.Id, command.UserId, command.Category, command.Name, command.Description)); return; } catch (ActioException ex) { await _bus.PublishAsync(new CreateActivtyRejected(ex.Code, ex.Message)); } catch (Exception ex) { await _bus.PublishAsync(new CreateActivtyRejected("error", ex.Message)); } }
public async Task HandleAsync(UserCreated @event) { try { var merchant = new Merchant(); merchant.UserId = @event.UserId; merchant.Name = @event.Name; merchant.AcquiringBank = @event.AcquirerName; await _merchantRepository.AddAsync(merchant); var logCreated = new CreateLog(@event.UserId, Guid.Empty, LogLevel.Info, "Merchant_Created", "Created merchant " + @event.Name); await _busClient.PublishAsync(logCreated); } catch (Exception ex) { var logCreated = new CreateLog(@event.UserId, Guid.Empty, LogLevel.Error, "Merchant_Creation_Error", "Cannot save Merchant because :" + ex.Message); await _busClient.PublishAsync(logCreated); } }
public async Task HandleAsync(CreateUser command) { _logger.LogInformation($"Creating User: {command.Name}"); try { await _userService.RegisterAsync(command.Email, command.Password, command.Name); await _busClient.PublishAsync(new UserCreated(command.Email, command.Name)); } catch (JKTechException e) { await _busClient.PublishAsync(new CreateUserRejected(command.Email, e.Code, e.Message)); _logger.LogError(e.Message); } catch (Exception ex) { await _busClient.PublishAsync(new CreateUserRejected(command.Email, "error", ex.Message)); _logger.LogError(ex.Message); } }
public async Task DispatchAsync <T>(T command) where T : ICommand { if (command == null) { throw new ArgumentNullException(nameof(command), "Command can not be null"); } await _bus.PublishAsync(command, Guid.NewGuid(), cfg => cfg .WithRoutingKey("person.getname") .WithExchange(ex => ex.WithName("person_exchange").WithType(ExchangeType.Topic).WithAutoDelete()) ); }
public async Task HandleAsync(PaymentFailed @event) { try { await _historyService.SaveAsync(@event); var logCreated = new CreateLog(@event.UserId, @event.PaymentId, LogLevel.Info, "Process_Payment_6", "Saved Failed Payment"); await _busClient.PublishAsync(logCreated); var historyCreatedEvent = new PaymentHistoryCreated(); @event.CopyPayment(historyCreatedEvent); historyCreatedEvent.Processed = false; await _busClient.PublishAsync(historyCreatedEvent); } catch (Exception ex) { var logCreated = new CreateLog(@event.UserId, @event.PaymentId, LogLevel.Error, "Save_Payment_Failed", "Cannot save Failed payment because :" + ex.Message); await _busClient.PublishAsync(logCreated); } }
public async Task <object> PaymentGatewayCallback(Guid paymentId) { var paymentInfo = await _genericPaymentRepository.GetByIdAsync(paymentId); paymentInfo.PaymentStatus = PaymentStatus.Accepted; await _genericPaymentRepository.UpdateAsync(paymentInfo); var order = await _restClient.GetAsync <Order>("order_service", $"/api/orders/{paymentInfo.OrderId}"); await _messageBus.PublishAsync(new PaymentAcceptedEvent(order.SagaId.Value)); return(null); }
public async Task HandleAsync(CreateActivity command) { //Console.WriteLine($"Creating activity: {command.Category} {command.Name}"); _logger.LogInformation($"Creating activity: {command.Category} {command.Name}"); try { await _activityService.AddAsync(command.Id, command.UserId, command.Category, command.Name, command.Description, command.CreatedAt); await _busClient.PublishAsync(new ActivityCreated(command.Id, command.UserId, command.Category, command.Name, command.Description, command.CreatedAt)); return; } catch (ActioException ex) { await _busClient.PublishAsync(new CreateActivityRejected(command.Id, ex.Code, ex.Message)); _logger.LogError(ex.Message); } catch (Exception ex) { await _busClient.PublishAsync(new CreateActivityRejected(command.Id, "Error", ex.Message)); _logger.LogError(ex.Message); } }
public async Task PublishSaveEventAsync(Plant plant) { var e = new PlantSaved { Id = plant.Id, Name = plant.Name, GaiaCode = plant.GaiaCode, CountryId = plant.CountryId, SOAId = plant.SOAId, IsDeleted = plant.IsDeleted }; await _busClient.PublishAsync <PlantSaved>(e); }
public async Task HandleAsync(ChangePassword command) { _logger.LogInformation($"Processing: {command.Id}"); try { await _identityService.ChangePasswordAsync(command.UserId, command.CurrentPassword, command.NewPassword); await _busClient.PublishAsync(new OperationCompleted(command.Id, command.UserId, "password-changed", "identity service")); } catch (ToolBoxException ex) { await _busClient.PublishAsync(new OperationRejected(command.Id, command.UserId, "password-changed", "identity service", ex.Code, ex.Message)); _logger.LogError(command.Id.ToString(), ex.Message); } catch (Exception ex) { await _busClient.PublishAsync(new OperationRejected(command.Id, command.UserId, "password-changed", "identity service", "error", ex.Message)); _logger.LogError(command.Id.ToString(), ex.Message); } }
public async Task HandleAsync(TakeRemarkAction command) { Participant participant = null; await _handler .Run(async() => { await _remarkActionService.ParticipateAsync(command.RemarkId, command.UserId, command.Description); var maybeParticipant = await _remarkActionService.GetParticipantAsync(command.RemarkId, command.UserId); participant = maybeParticipant.Value; }) .OnSuccess(async() => await _bus.PublishAsync(new RemarkActionTaken(command.Request.Id, command.UserId, participant.User.Name, command.RemarkId, command.Description, participant.CreatedAt))) .OnCustomError(ex => _bus.PublishAsync(new TakeRemarkActionRejected(command.Request.Id, command.UserId, command.RemarkId, ex.Code, ex.Message))) .OnError(async(ex, logger) => { logger.Error(ex, $"Error occured while taking action for remark: '{command.RemarkId}' by user: '******'."); await _bus.PublishAsync(new TakeRemarkActionRejected(command.Request.Id, command.UserId, command.RemarkId, OperationCodes.Error, ex.Message)); }) .ExecuteAsync(); }
public void StartPublishing() { int n = 1; while (n > 0) { _client.PublishAsync(new HeartbeatMessage { serialNumber = n, timeSent = DateTime.Now }); n++; Thread.Sleep(_timeBetweenMsg * 1000); } }
public async Task HandleAsync(CreateUser command) { _logger.LogInformation($"Creating user: '******' with name: '{command.Name}'."); try { await _userService.RegisterAsync(command.Email, command.Password, command.Name); await _busClient.PublishAsync(new UserCreated(command.Email, command.Name)); _logger.LogInformation($"User: '******' was created with name: '{command.Name}'."); } catch (ActioException ex) { _logger.LogError(ex, ex.Message); await _busClient.PublishAsync(new CreateUserRejected(command.Email, ex.Message, ex.Code)); } catch (Exception ex) { _logger.LogError(ex, ex.Message); await _busClient.PublishAsync(new CreateUserRejected(command.Email, ex.Message, "error")); } }
public async Task HandleMessage(MessageWrapper message) { if (message.MessageBody != null) { if (message.MessageBody.Length > 0) { object testMsg = System.Text.Json.Serialization.JsonSerializer.Parse( message.MessageBody, Type.GetType(message.MessageType)); await _client.PublishAsync(testMsg); } } }
public async Task HandleAsync(CreateActivity command) { Console.WriteLine($"Creating activity:{command.Name}"); await _busClient.PublishAsync( new ActivityCreated( command.Id, command.UserId, command.Category, command.Name, command.Description, command.CreatedAt)); }
private async Task DbStoredProcedureInvoke(ServerModel server, SqlQueryModel sqlQuery) { foreach (var database in server.Databases) { await _busClient.PublishAsync(new SqlStoredProcedureQuery(Guid.NewGuid(), server.UserId, sqlQuery.Query, new Dictionary <string, string> { { "@oneresultset", "1" } }, server.Host, server.Port, server.Login, _protector.Unprotect(server.Password), database.Name, (int)sqlQuery.Name, server.Id, database.Id, "sqlmonitor-service" )); } }
public async Task <ActionResult> RegisterUser([FromBody] CreateUser createUser) { var emailTaken = await userService.EmailTakenAsync(createUser.Email); if (emailTaken) { return(BadRequest("Email already taken")); } await busClient.PublishAsync(createUser); return(Accepted($"RegisterUser/{createUser.Email}")); }
public async Task HandleAsync(xItem command) { try { var xitem = await _service.GetAsync(command.Item); if (xitem == null) { await InsertAsync(command); } else { await UpdateAsync(command, xitem); } return; } catch (OrderInException ex) { await _busClient.PublishAsync(new ItemRejected( command.Id, ex.Code, ex.Message )); _logger.LogError(ex.Message); } catch (Exception ex) { await _busClient.PublishAsync(new ItemRejected( command.Id, "error", ex.Message )); _logger.LogError(ex.Message); } }