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");
}
