public async Task <StudentsModel> CreateNewStudent(NewStudentModel request, byte[] imageBytes)
{
var student = new StudentsEntityModel
{
FirstName = request.FirstName,
SecondName = request.SecondName,
Patronymic = request.Patronymic,
InstitutionId = request.InstitutionId,
Status = Status.New,
FilingDate = DateTime.Now.Date,
Email = request.Email,
Phone = request.Phone,
PracticArea = request.PracticArea,
Speciality = request.Speciality,
PractiesBegining = request.PractiesBegining,
PractiesEnding = request.PractiesEnding
};
var result = _studRepository.CreateStudent(student, imageBytes);
if (result == null)
{
return(result);
}
var mailSubject = "Заявка на практику";
var mailBody = "Ваша заявка была успешно оформлена. Ожидайте ответа на указанный вами номер телефона, либо почту.";
var mailRequest = _requestClient.Create(new { To = request.Email, Body = mailBody, Subject = mailSubject });
var responce = await mailRequest.GetResponse <IEmailSent>();
_logger.LogInformation($"Email succefully sent! ID:{responce.Message.EventId} Time:{responce.Message.SentAtUtc}");
return(result);
}
public async Task <ActionResult> GetWithModel(CancellationToken cancellationToken, [FromQuery] BusMessageModelCommand model)
{
RequestHandle <IBusMessageCommand> request = _requestClient.Create(model, cancellationToken);
Response <IProcessDoneCommand> response = await request.GetResponse <IProcessDoneCommand>();
return(Ok(response.Message));
}
public IActionResult ClockIn(int id)
{
try
{
var request = _requestClient.Create(new { UserID = id, IsTimeIn = true });
var response = request.GetResponse <Message>();
response.Wait();
return(RedirectToAction("Index", "Employee"));
}
catch (RequestTimeoutException exception)
{
return(StatusCode((int)HttpStatusCode.RequestTimeout));
}
}
public async Task CreateDummyConsumptionViaServiceBus()
{
try
{
var dummyConsumption = new Consumption()
{
Data = "Dummy Consumption Creator Via ServiceBus",
Value = new Random().Next(1, 1000),
TenantId = 1
};
consumptionRequest = _consumptionRequestClient.Create(dummyConsumption);
var response = consumptionRequest.GetResponse <ConsumptionDone>().Result;
var result = response.Message;
var dbData = _mapper.Map <Consumption>(result);
var resultData = Task.FromResult <object>(consumptionRequest);
var repo = _uow.GetRepository <Consumption>();
await repo.AddAsync(dbData);
_uow.Commit();
}
catch (System.Exception ex)
{
_logger.LogError(ex, "Error occured in CreateDummyOfferViaServiceBus");
throw;
}
}
public async Task <IActionResult> BuyTickets([FromForm] BuyTicketCommand buyTicketCommand)
{
var request = _requestClientBuyTicketCommand.Create(buyTicketCommand);
await request.GetResponse <BuyTicketsEvent>();
return(RedirectToAction("Index"));
}
public async Task <GetAllTicketsQueryResponse> Handle(GetAllTicketsQueryRequest request, CancellationToken cancellationToken)
{
GetAllAdminUserQueryResponse p = null;
using (var clientRequest = _client.Create(new GetAllUserRequest()))
{
try
{
var response = await clientRequest.GetResponse <GetAllAdminUserQueryResponse>();
p = response.Message;
}
catch (MassTransitException e)
{
Console.WriteLine(e);
throw;
}
}
var tickets = await _ticketManagementDbContext.Tickets.Include(a => a.AnswerTickets).ToListAsync(cancellationToken: cancellationToken);
var ticketViewModel = tickets.Select(a => new TicketModel
{
Id = a.Id,
Title = a.Title,
AnswerTicketModels = a.AnswerTickets.Select(a => new AnswerTicketModel
{
Answer = a.Answer,
Id = a.Id
})
});
return(new GetAllTicketsQueryResponse(true, ticketViewModel));
}
public async Task <IActionResult> PostSendCheckingAccountTransaction(CancellationToken token, [FromBody] int Requests)
{
Random rnd = new Random();
try
{
AddCheckingAccountTransactionCommand AddCheckingAccountTransactionCommand = new AddCheckingAccountTransactionCommand()
{
CreditCheckingAccount = Guid.Parse("63F400DF-D01A-46E0-960A-5465A86C62BF"),
DebitCheckingAccount = Guid.Parse("22c3f8d0-5cb9-4d29-a300-52c0adc27704"),
CurrencyTypeID = Guid.Parse("6B577276-DDC9-4C8E-896A-EEE8396EFF82"),
Value = rnd.Next(1, 9999999)
};
var request = _requestClient.Create(AddCheckingAccountTransactionCommand, token, TimeSpan.FromMilliseconds(600));
var response = await request.GetResponse <TransportEntity>();
return(Ok(response));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public RequestHandle <T> CreateRequest <T>(T message, CancellationToken cancellationToken, RequestTimeout timeout)
where T : class
{
IRequestClient <T> client = CreateRequestClient <T>(timeout);
return(client.Create(message, cancellationToken));
}
public RequestHandle <T> CreateRequest <T>(ConsumeContext consumeContext, T message, CancellationToken cancellationToken, RequestTimeout timeout)
where T : class
{
IRequestClient <T> client = CreateRequestClient <T>(consumeContext, timeout);
return(client.Create(message, cancellationToken, timeout));
}
public async Task Should_find_and_invoke_the_service()
{
Task <ConsumeContext <Up <DeployPayload> > > upHandler = SubscribeHandler <Up <DeployPayload> >();
var clientId = NewId.NextGuid();
await Bus.Publish <Link <DeployPayload> >(new
{
__ResponseAddress = Bus.Address,
__TimeToLive = 10000,
ClientId = clientId
});
ConsumeContext <Up <DeployPayload> > upContext = await upHandler;
IRequestClient <DeployPayload> client = Bus.CreateRequestClient <DeployPayload>(upContext.Message.Service.ServiceAddress);
RequestHandle <DeployPayload> request = client.Create(new { Target = "Bogey" });
request.UseExecute(x => x.Headers.Set(MessageHeaders.ClientId, clientId));
Response <PayloadDeployed> response = await request.GetResponse <PayloadDeployed>();
Assert.That(response.Message.Target, Is.EqualTo("Bogey"));
}
public RequestHandle <T> CreateRequest <T>(Uri destinationAddress, object values, CancellationToken cancellationToken, RequestTimeout timeout)
where T : class
{
IRequestClient <T> client = CreateRequestClient <T>(destinationAddress, timeout);
return(client.Create(values, cancellationToken));
}
public async Task <IActionResult> Index()
{
var request = _requestClient.Create(new GetAllConcertsCommand());
var response = await request.GetResponse <GetAllConcertsEvent>();
return(View(response.Message.ConcertViewModel));
}
public RequestHandle <T> CreateRequest <T>(ConsumeContext consumeContext, object values, CancellationToken cancellationToken, RequestTimeout timeout)
where T : class
{
IRequestClient <T> client = CreateRequestClient <T>(consumeContext, timeout);
return(client.Create(values, cancellationToken));
}
public async Task <IActionResult> AddConcert(SaveConcertCommand concert, CancellationToken cancellationToken)
{
var request = _requestClientSave.Create(concert);
await request.GetResponse <SaveConcertEvent>();
TempData["Message"] = "New concert added";
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Post([FromBody] Vehicle vehicle, CancellationToken cancellationToken)
{
var request = _requestClient.Create(vehicle, cancellationToken);
var response = await request.GetResponse <Vehicle>();
return(CreatedAtAction(nameof(Get), new { id = response.Message.Id }, response.Message));
}
public async Task <ActionResult <PredictionResult> > Get
([FromServices] IRequestClient <PredictionRequest> client, string currency, int?limit, long?endDate, string tframe)
{
var payload = new PredictionRequest(currency, limit, endDate, tframe);
var request = client.Create(payload);
var response = await request.GetResponse <PredictionResult>();
return(Ok(response));
}
public async Task <IActionResult> Index()
{
var request = _requestClient.Create(new GetTicketByUserIdCommand()
{
UserId = 2
});
var response = await request.GetResponse <GetTicketByUserIdEvent>();
return(View(response.Message.TicketViewModel));
}
public async Task <BookModel> Update(BookViewModel model, string url)
{
BookModel book = model;
if (model.Cover != null)
{
book.Cover = _imageLogic.ToBytes(model.Cover);
}
else
{
book.Cover = null;
}
book.KeyWordsId = _keyWordService.CheckWord(model.KeyWordsName);
book.Categories = model.IdCategories;
book.Aviable += model.Count - model.PrevCount;
var result = await _bookService.Update(book);
if (model.Count > model.PrevCount)
{
var listNotification = _notificationService.GetList(model.Id);
var bookCardURL = url.Replace("UpdateBook", $"BookCard?bookId={book.Id}");
foreach (var notification in listNotification)
{
var user = _userService.GetUserById(notification.UserId);
await _requestClient.Create(new
{
MailTo = user.Email,
Subject = "Интересующая Вас книга появилась в наличии Библиотеки ММТР",
Body = $"Уважаемый(ая) {user.SecondName} {user.FirstName}, книга {book.Title} {book.Author} появилась в библиотеке ММТР. Вы можете взять её по ссылке {bookCardURL}"
}).GetResponse <IMailSent>();
await _notificationService.Delete(notification);
}
}
return(result);
}
public async Task <ServerResponse> CreateMhTaskAsync([FromBody] MhTaskRequest mhTaskRequest)
{
return(AOResultToServerResponse(await _mhTaskService.CreateMhTaskAsync(mhTaskRequest).ContinueWith(x =>
{
var request = _requestClient.Create(_mhTaskService.CreateMhTaskFeedMessage(mhTaskRequest, x.Result.Result));
request.GetResponse <FeedMessage>();
return x.Result;
})));
}
public async Task <ServerResponse <long> > CreateNoteAsync([FromBody] NoteRequest noteRequest)
{
return(AOResultToServerResponse(await _noteService.CreateNoteAsync(noteRequest).ContinueWith(x =>
{
var request = _requestClient.Create(_noteService.CreateNoteFeedMessage(noteRequest, x.Result.Result));
request.GetResponse <FeedMessage>();
return x.Result;
})));
}
public override async Task AddToGroupAsync(string connectionId, string groupName, CancellationToken cancellationToken = default)
{
if (connectionId == null)
{
throw new ArgumentNullException(nameof(connectionId));
}
if (groupName == null)
{
throw new ArgumentNullException(nameof(groupName));
}
var connection = Connections[connectionId];
if (connection != null)
{
// short circuit if connection is on this server
AddGroupAsyncCore(connection, groupName);
return;
}
// Publish to mass transit group management instead, but it waits for an ack...
try
{
_logger.Info("Publishing add GroupManagement<THub> message to MassTransit.");
RequestHandle <GroupManagement <THub> > request =
_groupManagementRequestClient.Create(new { ConnectionId = connectionId, GroupName = groupName, ServerName, Action = GroupAction.Add },
cancellationToken);
Response <Ack <THub> > ack = await request.GetResponse <Ack <THub> >().ConfigureAwait(false);
_logger.Info($"Request Received for add GroupManagement<THub> from {ack.Message.ServerName}.");
}
catch (RequestTimeoutException e)
{
// That's okay, just log and swallow
_logger.Warn("GroupManagement<THub> add ack timed out.", e);
}
}
public async Task <IActionResult> Submit(OrderModel model, CancellationToken cancellationToken)
{
try
{
var request = _requestClient.Create(new { OrderId = Guid.NewGuid(), SomeValue = model.SomeValue }, cancellationToken);
var response = await request.GetResponse <OrderAccepted>();
return(Content($"Order Accepted: {response.Message.SomeValue}"));
}
catch (RequestTimeoutException exception)
{
return(StatusCode((int)HttpStatusCode.RequestTimeout));
}
}
protected override void ConfigureRabbitMqReceiveEndpoint(IRabbitMqReceiveEndpointConfigurator configurator)
{
_ping = Handler <PingMessage>(configurator, async x =>
{
IRequestClient <A> client = _clientFactory.CreateRequestClient <A>(x, InputQueueAddress);
RequestHandle <A> request = client.Create(new A(), x.CancellationToken);
await request.GetResponse <B>();
x.Respond(new PongMessage(x.Message.CorrelationId));
});
_a = Handler <A>(configurator, x => x.RespondAsync(new B()));
}
public async Task <IActionResult> Post([FromBody] ContractDto contract, CancellationToken cancellationToken)
{
var request = _requestClient.Create(contract, cancellationToken);
var response = await request.GetResponse <IOperationResult <OperationStatus> >();
var result = response.Message.Data;
await _hubContext.Clients.All.SendAsync("ContractProcessed", result.Message);
if (result.Success)
{
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> Get(CancellationToken cancellationToken)
{
try
{
var request = _requestClient.Create(new { Value = "Hello, World." }, cancellationToken);
var response = await request.GetResponse <SomethingDone>();
return(Content($"{response.Message.Value}, MessageId: {response.MessageId:D}"));
}
catch (RequestTimeoutException exception)
{
return(StatusCode((int)HttpStatusCode.RequestTimeout));
}
}
public async Task <bool> SendRequest(SignupStudentMessage signupStudentMessage)
{
try
{
_requestClient.Create(new { SignupStudent = signupStudentMessage });
await Task.CompletedTask;
return(true);
}
catch (Exception e) // catch more general exception
{
await Task.FromException(e);
return(false);
}
}
public IActionResult EmailTest([FromForm] SendModel model)
{
try
{
var request = _requestClient.Create(new { To = model.MailTo, model.Body, model.Subject });
var responce = request.GetResponse <IEmailSent>();
return(Content($"Email succefully sent! ID:{responce.Result.Message.EventId} Time:{responce.Result.Message.SentAtUtc}"));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IActionResult> GetBySlug(string slug, int timeout)
{
Product p = null;
// request from the remote service
using (var request = _client.Create(new ProductInfoRequest {
Slug = slug, Delay = timeout
}))
{
var response = await request.GetResponse <ProductInfoResponse>();
p = response.Message.Product;
}
return(Ok(p));
}
/// <summary>
/// Send a request from the bus to the endpoint, and return a Task which can be awaited for the response.
/// </summary>
/// <param name="bus">A started bus instance</param>
/// <param name="destinationAddress">The service address</param>
/// <param name="message">The request message</param>
/// <param name="cancellationToken">An optional cancellationToken for this request</param>
/// <param name="timeout">An optional timeout for the request (defaults to 30 seconds)</param>
/// <param name="callback">A callback, which can modify the <see cref="SendContext" /> of the request</param>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <returns></returns>
public static async Task <Response <TResponse> > Request <TRequest, TResponse>(this IBus bus, Uri destinationAddress, TRequest message,
CancellationToken cancellationToken = default, RequestTimeout timeout = default, Action <SendContext <TRequest> > callback = null)
where TRequest : class
where TResponse : class
{
IRequestClient <TRequest> requestClient = bus.CreateRequestClient <TRequest>(destinationAddress, timeout);
using (RequestHandle <TRequest> requestHandle = requestClient.Create(message, cancellationToken))
{
if (callback != null)
{
requestHandle.UseExecute(callback);
}
return(await requestHandle.GetResponse <TResponse>().ConfigureAwait(false));
}
}
public async Task Should_be_awesome_with_a_side_of_sourdough_toast()
{
IRequestClient <GetValue> client = Bus.CreateRequestClient <GetValue>(InputQueueAddress);
Response <Value> response;
using (RequestHandle <GetValue> request = client.Create(new GetValue()))
{
request.UseExecute(context => context.Headers.Set("Frank", "Mary"));
response = await request.GetResponse <Value>();
}
Assert.That(response.RequestId.HasValue, Is.True);
Assert.That(response.Headers.TryGetHeader("Frank", out var value), Is.True);
Assert.That(value, Is.EqualTo("Mary"));
}
