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