public async Task <IResult> CreateTask(CreateSubtaskForm form) { var jobExists = await _dbContext.Jobs.AnyAsync(x => x.JobId == form.JobId); if (!jobExists) { _logger.LogWarning("Job does not exist with ID = {JobId}", form.JobId); return(Result.NotFound($"Job does not exist with ID {form.JobId}")); } var taskExists = await _dbContext.Tasks.AnyAsync(x => x.Job.JobId == form.JobId && x.TaskId == form.TaskId); if (taskExists) { _logger.LogWarning("Sub-task already exists with ID = {TaskId}", form.TaskId); return(Result.Conflict($"Sub-task already exists with ID {form.TaskId}")); } await _sendEndpointProvider.Send <CreateSubtask>(new { JobId = form.JobId, TaskId = form.TaskId, Name = form.Name }); _logger.LogInformation("Sent <{MessageType}> command", nameof(CreateSubtask)); return(Result.Ok()); }
public async Task <ServerResponse <long> > CreateMhTaskAsync([FromBody] MhTaskRequest mhTaskRequest) { var serverResponse = await _mhTaskService.CreateMhTaskAsync(mhTaskRequest); mhTaskRequest.Id = serverResponse.Result; await _sendEndpointProvider.Send(_mhTaskService.CreateFeedMessage(mhTaskRequest, EFeedAction.Create)); return(serverResponse); }
public async Task <ServerResponse <long> > CreateNoteAsync([FromBody] NoteRequest noteRequest) { var serverResponse = await _noteService.CreateNoteAsync(noteRequest); noteRequest.Id = serverResponse.Result; await _sendEndpointProvider.Send(_noteService.CreateFeedMessage(noteRequest, EFeedAction.Create)); return(serverResponse); }
public async Task <Models.User> Add(RegistrationModel model) { var user = await _redisCache.GetRecordAsync <Models.User>(model.Alias); if (user != null) { return(user); } user = new Models.User { Alias = model.Alias, TestNumber = Models.User.GenerateNumber() }; await _redisCache.SetRecordAsync(user.Alias, user); await _sender.Send(new UserCreated { Alias = user.Alias, TestNumber = user.TestNumber, Timestamp = DateTime.UtcNow }); return(user); }
public async Task Send <TMessage>(object message) where TMessage : class { //Uri uri; //EndpointConvention.TryGetDestinationAddress<CreateAccount>(out Uri uri); await endpoint.Send <TMessage>(message); }
public async Task AddItem(string username, CartItem item) { var cart = await Cart(username); if (cart == null) { cart = new Cart { Id = Guid.NewGuid(), Username = username, Items = new List <CartItem>() }; if (ActiveCarts.TryAdd(username, cart)) { await sender.Send(new CartCreated { CartId = cart.Id, UserName = cart.Username, Timestamp = DateTime.UtcNow }); } else { ActiveCarts.TryGetValue(username, out cart); } } var exitingItem = cart.Items.FirstOrDefault(x => x.ProductSku == item.ProductSku); if (exitingItem != null) { exitingItem.Quantity += item.Quantity; } else { cart.Items.Add(item); } await sender.Send(new CartItemAdded { CartId = cart.Id, UserName = cart.Username, Timestamp = DateTime.UtcNow }); }
public async Task <IActionResult> ExecuteWithdrawal([FromBody] ExecuteWithdrawal request) { await _commandsSender.Send(new ExecuteWithdrawal { Id = request.Id }); return(Ok()); }
public Task Send([NotNull] object message, CancellationToken cancellationToken) { if (message == null) { throw new ArgumentNullException(nameof(message)); } return(_sendEndpointProvider.Send(message, cancellationToken)); }
private static async Task RunStripe(ISendEndpointProvider sendEndpointProvider, IEnumerable <object> messages) { await Task.Yield(); foreach (var message in messages) { await sendEndpointProvider.Send(message).ConfigureAwait(false); } }
public async Task <Unit> Handle(SubmitCaseCommand request, CancellationToken cancellationToken) { var mibToSubmit = new FacCaseSubmitted() { Action = "Save" }; await _serviceBus.Send(mibToSubmit); _logger.LogDebug("Case Submitted"); return(new Unit()); }
public async Task <Unit> Handle(SendDecisionCommand request, CancellationToken cancellationToken) { var caseToSubmit = new FacCaseDecision() { DecisionType = "New Case" }; await _serviceBus.Send(caseToSubmit); _logger.LogDebug("Case Submitted"); return(new Unit()); }
public async Task <Unit> Handle(SendMib request, CancellationToken cancellationToken) { var mibToSubmit = new MibSubmitted() { FirstName = "MyFirstName", LastName = "MyLastName", Dob = new DateTime(2000, 01, 15) }; await _serviceBus.Send(mibToSubmit); _logger.LogDebug("Mib Sent to service bus"); return(new Unit()); }
private async Task Run() { var id = (await _createClient.GetResponse <CreateEntityResponse>(new { TypeId = 1 })).Message.EntityId; _logger.LogInformation($"Test ID: {id:D}"); var s = Stopwatch.StartNew(); while (true) { var first = (await _getMetadataClient.GetResponse <GetEntityMetadataResponse>(new { EntityId = id, Index = 0, Type = 0 })).Message; var old = (int)_serializer.Deserialize(first.Type, first.Data); var firstTransform = (await _getTransformClient.GetResponse <GetEntityTransformResponse>(new { EntityId = id })).Message; _logger.LogInformation($"Old Value: {old} | {firstTransform.Position} | {firstTransform.Velocity}"); if (old >= 10000) { break; } await _sendEndpointProvider.Send <UpdateEntityMetadata>(new { EntityId = id, Index = 0, Type = 0, Data = _serializer.Serialize(0, old + 1) }); await _sendEndpointProvider.Send <UpdateTransform>(new { EntityId = id, Position = firstTransform.Position + Vector3.UnitX, Velocity = firstTransform.Velocity + Vector3.UnitZ }); var second = (await _getMetadataClient.GetResponse <GetEntityMetadataResponse>(new { EntityId = id, Index = 0, Type = 0 })).Message; var secondTransform = (await _getTransformClient.GetResponse <GetEntityTransformResponse>(new { EntityId = id })).Message; var @new = (int)_serializer.Deserialize(second.Type, second.Data); _logger.LogInformation($"New Value: {@new} | {secondTransform.Position} | {secondTransform.Velocity}"); } s.Stop(); _logger.LogInformation($"Took {s.Elapsed}"); }
public async Task <ActionResult> Post(string texto) { var endpoint = await _sendEndpointProvider.GetSendEndpoint(new Uri("rabbitmq://mq.acme.com/order/order_processing")); await _sendEndpointProvider.Send() Publish <Mensagem>(new Mensagem { Texto = texto }); return(Ok()); }
protected override async Task Handle(NewChatMessageDto request, CancellationToken cancellationToken) { var chatMessage = request.ChatMessage; var cmDto = mapper.Map <NewTwitchChannelMessage>(chatMessage); await sendEndpointProvider.Send(cmDto, cancellationToken : cancellationToken); foreach (var plugin in chatPlugins) { await plugin.ProcessMessage(chatMessage, twitchClient); } }
public async Task <IResult> CreateJob(CreateJobForm form) { var exists = await _dbContext.Jobs.AnyAsync(x => x.JobId == form.JobId); if (exists) { _logger.LogWarning("Job already exists with ID = {JobId}", form.JobId); return(Result.Conflict($"Job already exists with ID {form.JobId}")); } await _sendEndpointProvider.Send <CreateJob>(new { JobId = form.JobId, CorrelationId = form.CorrelationId, Type = form.Type, Namespace = form.Namespace, Meta = form.Meta }); _logger.LogInformation("Sent <{MessageType}> command", nameof(CreateJob)); return(Result.Ok()); }
public async Task SendEmail(EmailModel message) { var emails = EmailBuilder.Expand(message); var tasks = _Send(emails); await Task.WhenAll(tasks); IEnumerable <Task> _Send(IEnumerable <IEmail> emailsToSend) { foreach (var email in emailsToSend) { yield return(_sendEndpointProvider.Send <ScheduleEmail>(new { Email = email, ScheduleTime = message.ScheduleTime })); } } }
private async Task ProcessApproachAsync(ISendEndpointProvider sendEndpoint, MsgNotifyApproach approach) { if (approach == MsgNotifyApproach.APP) { var actors = await GetUserSessionActorsAsync(); var notify = CreateNotify(); var tasks = actors.Select(o => o.PushEventNotifyAsync(notify)); await Task.WhenAll(tasks); } else if (approach == MsgNotifyApproach.SMS) { throw new NotSupportedException("SMS notification coming soon"); string[] numbers = GetUserMobileNumbers(); var sms = CreateSms(); await sendEndpoint.Send(sms); } }
public async Task <IActionResult> GetAsync() { //await publishEndpoint.Publish<StartDataPreparationCommand>(new { MigrationId = Guid.NewGuid() }); tracer.ActiveSpan.SetOperationName("GetAsyncBaseApi"); await sendEndpointProvider.Send <StartDataPreparationCommand>(new { MigrationId = Guid.NewGuid() }); _logger.LogInformation("teste", "vai"); var rng = new Random(); var dados = Enumerable.Range(1, 5).Select(index => new WeatherForecast { Date = DateTime.Now.AddDays(index), TemperatureC = rng.Next(-20, 55), Summary = Summaries[rng.Next(Summaries.Length)] }) .ToArray(); return(new OkObjectResult(dados)); }
public async Task <bool> Handle(DeleteQuizCommand request, CancellationToken cancellationToken) { var quizSpecification = new QuizByIdSpecification(request.QuizId); if (!await _quizRepository.AnyAsync(quizSpecification)) { _logger.LogError($"Quiz with id {request.QuizId} not found"); throw new InvalidOperationException($"Chapter with id {request.QuizId} not found"); } if (!await _quizRepository.DeleteAsync(quizSpecification)) { _logger.LogError($"Delete chapter failed"); throw new InvalidOperationException($"Delete chapter failed"); } var message = _mapper.Map <DeleteQuizMessage>(request); await _sendEndpointProvider.Send(message, cancellationToken); return(true); }
public async Task <ActionResult> Create(UserRecord userRecord) { var user = new CompanyUser() { UserName = userRecord.Email, Email = userRecord.Email, EmailConfirmed = true, CompanyId = userRecord.CompanyId }; var dete = await _userManager.FindByEmailAsync(user.Email); await _userManager.DeleteAsync(dete); var result = await _userManager.CreateAsync(user, userRecord.Password); if (result.Succeeded) { var token = await _userManager.GenerateEmailConfirmationTokenAsync(user); var confirmationLink = Url.Action(nameof(ConfirmEmail), "Auth", new { token, email = user.Email }, Request.Scheme); var userRegistered = new CompanyUserRegisteredEvent(userRecord.CompanyId, userRecord.Email, userRecord.Password, userRecord.PasswordConfirmation, confirmationLink); await _bus.Send(userRegistered); return(ApiResponse()); } //await _mediatorHandler.PublishEvent( // new CompanyUserRegisteredEvent(userRecord.CompanyId, userRecord.Email, userRecord.Password, userRecord.PasswordConfirmation, confirmationLink)); //await _emailSender.SendEmailAsync(user.Email, "Email confirmation", confirmationLink); foreach (var error in result.Errors) { AddError("User", error.Description); } return(ApiResponse()); }
public async Task <Infrastructure.Database.Query.Model.Project.Project> Handle(AddProjectCommand request, CancellationToken cancellationToken) { var projectDomain = new Project(request.Name, request.Description, request.CategoryId, request.TypeId, request.ResponsibleDepartmentId, request.InitiatorId, request.CuratorId, request.ManagerId); var categoryDomain = _DictionaryValueRepository.GetById(request.CategoryId).Result .ToDomain <DictionaryValue>(_Mapper); projectDomain.Category = categoryDomain; var typeDomain = _DictionaryValueRepository.GetById(request.TypeId).Result .ToDomain <DictionaryValue>(_Mapper); projectDomain.Type = typeDomain; var projectDepartmentsDomain = request.DepartmentIds.Select(item => { var newItem = new ProjectDepartment(projectDomain.Id, item); newItem.Validate(); return(newItem); }); var projectContragentsDomain = request.ContragentIds.Select(item => { var newItem = new ProjectContragent(projectDomain.Id, item); newItem.Validate(); return(newItem); }); var projectproductsDomain = request.ProductIds.Select(item => { var newItem = new ProjectProduct(projectDomain.Id, item); newItem.Validate(); return(newItem); }); projectDepartmentsDomain.ForAll(item => projectDomain.AddDepartment(item)); projectContragentsDomain.ForAll(item => projectDomain.AddContragent(item)); projectproductsDomain.ForAll(item => projectDomain.AddProduct(item)); projectDomain.Validate(); #region Persistence var project = projectDomain.ToModel <Command.Project>(_Mapper); await _ProjectRepository.Add(project); await _UnitOfWork.Commit(); #endregion #region Bus var publishMessage = new Message(); publishMessage.MessageType = "AddProject"; var response = projectDomain.ToQueryModel <Query.Project>(_Mapper); publishMessage.SetData(response); //await _Bus.SendMessage(publishMessage); await _SendEndpointProvider.Send(publishMessage, cancellationToken); await _PublishEndpoint.Publish <ProjectCreated>(new { Id = project.Id, Name = project.Name }, cancellationToken); #endregion return(response); }
protected override async Task Handle(NewResubscriberDto request, CancellationToken cancellationToken) { var newSubscriber = mapper.Map <NewSubscriber>(request); await sendEndpointProvider.Send(newSubscriber, cancellationToken : cancellationToken); }
public Task Send(object command) { return(_sendEndpointProvider.Send(command)); }
public async Task <IActionResult> ExecuteSomething() { await _commandsSender.Send(new ExecuteSomething()); return(Ok()); }
public async Task Run() { await _sendEndpoint.Send <HelloWorld>(new { Name = "Ciccins " }); }
private async void _weChatEngine_OnMessage(object sender, MessageEventArgs e) { _logger.LogInformation("you got message: " + e.MessageResponse.Content); await _sendEndpointProvider.Send(e.MessageResponse); }
public async Task <ActionResult <string> > Get(int id) { await _sendEndpoint.Send <CreateReport>(new { ReportId = NewId.NextGuid(), RequestTime = DateTime.Now, EMail = "*****@*****.**" }); return("value"); }