public async Task Status_InCache_is_returned_if_item_is_in_cache()
{
// Arrange
assetManager.Setup(e => e.CheckPreparationStatus("1111"))
.Returns(Task.FromResult(new PreparationStatus {
PackageIsInPreparationQueue = false
}));
doesExistInCacheConsumer.DoesExistFunc = context => new Tuple <bool, long>(true, 99999);
// Act
response = requestClient.GetResponse <GetAssetStatusResult>(new GetAssetStatusRequest
{
ArchiveRecordId = "1111",
AssetType = AssetType.Gebrauchskopie,
CallerId = "2"
});
// Wait for the results
var message = (await response).Message;
await getAssetStatusTask;
// Assert
message.Status.Should().Be(AssetDownloadStatus.InCache);
message.InQueueSince.Should().Be(DateTime.MinValue);
}
public async Task Should_work()
{
var instanceA = await CreateInstance();
try
{
IRequestClient <DeployPayload> requestClient = Bus.CreateRequestClient <DeployPayload>();
Response <PayloadDeployed> response = await requestClient.GetResponse <PayloadDeployed>(new { Target = "A" });
Assert.That(response.Message.Target, Is.EqualTo("A"));
var instanceB = await CreateInstance();
try
{
await instanceA.StopAsync();
response = await requestClient.GetResponse <PayloadDeployed>(new { Target = "B" });
Assert.That(response.Message.Target, Is.EqualTo("B"));
}
finally
{
await instanceB.StopAsync();
}
}
finally
{
await instanceA.StopAsync();
}
}
public async Task <IActionResult> Login(User user)
{
var userMessage = new List <User>()
{
new User
{
Login = user.Login,
Password = user.Password
}
};
try
{
var response = await _userClient.GetResponse <Message <User> >(
new
{
Action = Variables.ActionLogin,
MessageContent = userMessage
});
if (response.Message.StatusCode == 200)
{
HttpContext.Session.SetString(SessionName, response.Message.MessageContent.FirstOrDefault().FullName);
HttpContext.Session.SetString(SessionUserEmail, response.Message.MessageContent.FirstOrDefault().Email);
HttpContext.Session.SetString(SessionUserId, response.Message.MessageContent.FirstOrDefault().Id);
if (response.Message.MessageContent.FirstOrDefault().Login == StaticVariables.AdminId)
{
HttpContext.Session.SetInt32(SessionStatus, 2);
}
else
{
HttpContext.Session.SetInt32(SessionStatus, 1);
}
return(RedirectToAction("Rented", "Books"));
}
else if (response.Message.StatusCode == 400)
{
ViewBag.ErrorMsg = "Incorrect card id or password.";
}
return(View());
}
catch (RequestTimeoutException timeException)
{
HttpContext.Session.Clear();
Debug.WriteLine(timeException.Message);
ViewBag.ErrorMsg = "Your request timed out.";
return(View());
}
catch (Exception e)
{
HttpContext.Session.Clear();
Debug.WriteLine(e.Message);
ViewBag.ErrorMsg = "Unknown error occured.";
return(View());
}
}
public async Task <IActionResult> Rent(string id, Book book)
{
var today = DateTime.Today;
book.Renter = HttpContext.Session.GetString(SessionUserId);
book.RentDate = today.ToString("yyyy MMMM dd");
book.ReturnDate = today.AddDays(21).ToString("yyyy MMMM dd");
var bookMessage = new List <Book>()
{
new Book()
{
Id = id,
Renter = book.Renter,
RentDate = book.RentDate,
ReturnDate = book.ReturnDate
}
};
try
{
var response = await _bookResponseClient.GetResponse <MessageResponse <Book> >(
new
{
Action = Variables.ActionRent,
UserId = book.Renter,
MessageContent = bookMessage
});
if (response.Message.StatusCode == 200)
{
return(RedirectToAction("Rented", new { id = book.Renter }));
}
else
{
Debug.WriteLine("There was a problem renting the book.");
}
return(RedirectToAction("ListAvailable"));
}
catch (RequestTimeoutException timeException)
{
HttpContext.Session.Clear();
Debug.WriteLine(timeException.Message);
ViewBag.ErrorMsg = "Your request timed out.";
return(RedirectToAction("ListAvailable"));
}
catch (Exception e)
{
HttpContext.Session.Clear();
Debug.WriteLine(e.Message);
ViewBag.ErrorMsg = "Unknown error occured.";
return(RedirectToAction("ListAvailable"));
}
}
public async Task <IActionResult> UpdatePassword(UserUpdate userUpdate)
{
var userId = HttpContext.Session.GetString(SessionUserId);
if (userId == "")
{
return(RedirectToAction("Login", "Users"));
}
var userMessage = new List <UserUpdate>()
{
new UserUpdate
{
OldPassword = userUpdate.OldPassword,
NewPassword = userUpdate.NewPassword,
RepeatNewPassword = userUpdate.RepeatNewPassword
}
};
try
{
var response = await _userUpdateResponseClient.GetResponse <MessageResponse <UserUpdate> >(
new
{
Action = Variables.ActionUpdatePassword,
UserId = userId,
MessageContent = userMessage
});
if (response.Message.StatusCode == 200)
{
ViewBag.ErrorMsg = "Password changed.";
HttpContext.Session.SetInt32(SessionStatus, 0);
HttpContext.Session.SetString(SessionName, "");
HttpContext.Session.SetString(SessionUserId, "");
return(View("Login"));
}
else if (response.Message.StatusCode == 400)
{
ViewBag.ErrorMsg = "Password update error.";
ViewBag.fullName = HttpContext.Session.GetString(SessionName);
ViewBag.Email = HttpContext.Session.GetString(SessionUserEmail);
ViewBag.status = HttpContext.Session.GetInt32(SessionStatus);
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(View("Update", userUpdate));
}
static async Task WaitForCompletion(IRequestClient <BatchStatusRequested> batchStatusClient, Task <Response <BatchSubmitted> > acceptedTask)
{
Response <BatchSubmitted> acceptedResult = await acceptedTask;
Guid id = acceptedResult.Message.BatchId;
while (true)
{
var(status, notFound) = await batchStatusClient.GetResponse <BatchStatus, BatchNotFound>(new
{
BatchId = id,
InVar.Timestamp,
});
if (IsCompletedSuccessfully(notFound))
{
continue;
}
Response <BatchStatus> response = await status;
if (response.Message.ProcessingJobCount == 0 &&
response.Message.UnprocessedJobCount == 0 &&
response.Message.State == "Finished")
{
Console.WriteLine($"Batch {id} completed");
return;
}
}
}
public async Task Should_allow_reconfiguration_of_prefetch_count()
{
IRequestClient <SetPrefetchCount> client = Bus.CreateRequestClient <SetPrefetchCount>(TestTimeout);
for (var i = 0; i < 50; i++)
{
await Bus.Publish(new A());
await Task.Delay(20);
}
await client.GetResponse <PrefetchCountUpdated>(new
{
PrefetchCount = (ushort)32,
Timestamp = DateTime.UtcNow,
QueueName = "input_queue"
}, TestCancellationToken);
for (var i = 0; i < 50; i++)
{
await Bus.Publish(new A());
await Task.Delay(20);
}
Assert.IsTrue(_consumerA.Consumed.Select <A>().Any());
}
public async Task <IActionResult> BookingRequestResponse(BookingRequestResponseModel model)
{
model.BookingId = NewId.NextGuid();
var response = await _bookingModelRequestClient.GetResponse <BookingRequestResponseModel>(model);
return(Accepted(response.Message.BookingId));
}
public async Task <ExecutionResult> Execute(ExecuteContext <IReserveProducts> context)
{
_logger.LogInformation($"Reserve Products called for order {context.Arguments.OrderId}");
var orderItems = await _orderService.GetCartItemsAsync(context.Arguments.OrderId);
IList <ICartItem> items = orderItems
.Select(i => (ICartItem) new CartItemDto {
ProductId = i.ProductId, Quantity = i.Quantity
})
.ToList();
var response = await _reserveProductsClient.GetResponse <IReserveProductsResult>(new
{
CorrelationId = context.Arguments.CorrelationId,
OrderId = context.Arguments.OrderId,
Items = items
});
if (!response.Message.Success)
{
throw new InvalidOperationException();
}
return(context.Completed(new { context.Arguments.CorrelationId, context.Arguments.OrderId, response.Message.ReserveId }));
}
public async Task <CreateActiveDeliveryCommandResult> Handle(CreateActiveDeliveryCommand request, CancellationToken cancellationToken)
{
var resultExistance = await _client.GetResponse <BooksExitanceResult>(
new { BooksIdsWithEans = request.ItemsInfo
.ToDictionary(key => key.BookId, value => value.BookEan) });
if (!resultExistance.Message.IsAllExists)
{
return(new CreateActiveDeliveryCommandResult(false,
new [] { "Some of requested books not exists or they Ids do not match with corresponding Eans" }));
}
var delivery = new ActiveDelivery(request.Name);
AddDeliveryItems(delivery, request);
var deliveryResult = _activeDeliveryRepository.Add(delivery);
if (await _activeDeliveryRepository.UnitOfWork.SaveChangesAsync(cancellationToken) < 1)
{
return(new CreateActiveDeliveryCommandResult(false, new [] { "Something went wrong during saving Active Delivery to Db" }));
}
var result = _mapper.Map <CommandActiveDeliveryDto>(deliveryResult);
return(new CreateActiveDeliveryCommandResult(true, result));
}
private async Task <List <ImageData> > GetUsersAvatarsAsync(List <Guid> imagesIds, List <string> errors)
{
if (imagesIds == null || !imagesIds.Any())
{
return(null);
}
try
{
Response <IOperationResult <IGetImagesResponse> > response =
await _rcGetImages.GetResponse <IOperationResult <IGetImagesResponse> >(
IGetImagesRequest.CreateObj(imagesIds, ImageSource.News));
if (response.Message.IsSuccess)
{
return(response.Message.Body.ImagesData);
}
_logger.LogWarning(
"Error while getting images by ids: {ImagesIds}. Reason:{Errors}",
string.Join(", ", imagesIds),
string.Join('\n', response.Message.Errors));
}
catch (Exception exc)
{
_logger.LogError("Can not get images by ids: {ImagesIds}. {ErrorsMessage}", imagesIds, exc.Message);
}
errors.Add("Can not get images. Please try again later.");
return(null);
}
public async Task Should_capture_the_bus_instance_metric()
{
IRequestClient <SubmitJob <TheJob> > requestClient = Bus.CreateRequestClient <SubmitJob <TheJob> >();
var jobId = NewId.NextGuid();
Response <JobSubmissionAccepted> response = await requestClient.GetResponse <JobSubmissionAccepted>(new
{
JobId = jobId,
Job = new { Duration = TimeSpan.FromSeconds(30) }
});
await _activityMonitor.AwaitBusInactivity(TestCancellationToken);
using var stream = new MemoryStream();
await Metrics.DefaultRegistry.CollectAndExportAsTextAsync(stream);
var text = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(text);
Assert.That(text.Contains("mt_send_total{service_name=\"unit_test\",message_type=\"AllocateJobSlot\"} 1"), "send");
Assert.That(text.Contains("mt_send_total{service_name=\"unit_test\",message_type=\"JobSlotAllocated\"} 1"), "send");
Assert.That(text.Contains("mt_send_total{service_name=\"unit_test\",message_type=\"JobSlotReleased\"} 1"), "send");
Assert.That(text.Contains("mt_send_total{service_name=\"unit_test\",message_type=\"JobAttemptCreated\"} 1"), "send");
Assert.That(text.Contains("mt_send_total{service_name=\"unit_test\",message_type=\"StartJobAttempt\"} 1"), "send");
Assert.That(text.Contains("mt_send_total{service_name=\"unit_test\",message_type=\"StartJob\"} 1"), "send");
Assert.That(text.Contains("mt_send_total{service_name=\"unit_test\",message_type=\"JobSubmissionAccepted\"} 1"), "send");
Assert.That(text.Contains("mt_send_total{service_name=\"unit_test\",message_type=\"SubmitJob_TheJob\"} 1"), "send");
Assert.That(
text.Contains("mt_consume_total{service_name=\"unit_test\",message_type=\"SubmitJob_TheJob\",consumer_type=\"SubmitJobConsumer_TheJob\"} 1"),
"submit job");
Assert.That(
text.Contains("mt_consume_total{service_name=\"unit_test\",message_type=\"TheJob\",consumer_type=\"TestJobConsumer\"} 1"),
"submit job");
}
async public Task <OperationResult <List <TemplateModel> > > GetAll()
{
var productRepository = _sqlUnitOfWork.GetRepository <ITempateSQLServerRepository>();
List <TestMessageResponse> list = new List <TestMessageResponse>();
for (var index = 0; index <= 10; index++)
{
await _publishEndpoint.Publish(new TestMessagePublish
{
Id = Guid.NewGuid(),
Text = "TestText",
Value = 5
});
}
for (var index = 0; index <= 10; index++)
{
var result = await _client.GetResponse <OperationResult <TestMessageResponse> >(new TestMessageRequest { Text = index.ToString() });
list.Add(result.Message.Data);
}
return(productRepository.Get());
}
public async Task <IHttpActionResult> GetOneTimeToken(int orderItemId)
{
var access = this.GetManagementAccess();
var userId = access.UserId;
if (!access.HasFeature(ApplicationFeature.AuftragsuebersichtAuftraegeKannDownloadGebrauchskopieAusfuehren))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
var orderItem = (await orderManagerClient.FindOrderItems(new[] { orderItemId })).FirstOrDefault();
if (orderItem == null)
{
return(BadRequest("OrderItem does not exist in DB"));
}
var doesExistInCacheResponse = (await doesExistInCacheClient.GetResponse <DoesExistInCacheResponse>(new DoesExistInCacheRequest
{
Id = orderItemId.ToString(),
RetentionCategory = CacheRetentionCategory.UsageCopyBenutzungskopie
})).Message;
if (!doesExistInCacheResponse.Exists)
{
return(StatusCode(HttpStatusCode.Gone));
}
var ipAddress = downloadHelper.GetClientIp(Request);
var expires = DateTime.Now.AddMinutes(downloadHelper.GetConfigValueTokenValidTime());
var token = downloadHelper.CreateDownloadToken();
downloadTokenDataAccess.CreateToken(token, orderItemId, DownloadTokenType.OrderItem, expires, ipAddress, userId);
return(Content(HttpStatusCode.OK, token));
}
private async Task <IGetUserCredentialsResponse> GetUserCredentials(string loginData)
{
IGetUserCredentialsResponse result = null;
try
{
var brokerResponse = await _requestClient.GetResponse <IOperationResult <IGetUserCredentialsResponse> >(
IGetUserCredentialsRequest.CreateObj(loginData));
if (!brokerResponse.Message.IsSuccess)
{
_logger.LogWarning("Can't get user credentials for LoginData: '{loginData}'", loginData);
}
else
{
result = brokerResponse.Message.Body;
}
}
catch (Exception exc)
{
_logger.LogError(
exc,
"Exception was caught while receiving user credentials for LoginData: {loginData}",
loginData);
}
return(result);
}
private async Task <List <UserData> > GetUsersThroughBrokerAsync(List <Guid> usersIds, List <string> errors)
{
if (usersIds is null || !usersIds.Any())
{
return(null);
}
try
{
Response <IOperationResult <IGetUsersDataResponse> > response =
await _rcGetUsers.GetResponse <IOperationResult <IGetUsersDataResponse> >(
IGetUsersDataRequest.CreateObj(usersIds));
if (response.Message.IsSuccess && response.Message.Body.UsersData.Any())
{
return(response.Message.Body.UsersData);
}
_logger.LogWarning(
"Error while getting users data with users ids: {UsersIds}.\nErrors: {Errors}",
string.Join(", ", usersIds),
string.Join('\n', response.Message.Errors));
}
catch (Exception exc)
{
_logger.LogError(
exc,
"Cannot get users data with users ids: {UsersIds}.",
string.Join(", ", usersIds));
}
errors.Add("Cannot get users data. Please try again later.");
return(null);
}
private async Task <List <DepartmentData> > GetDepartmentAsync(Guid newsId, List <string> errors)
{
try
{
Response <IOperationResult <IGetDepartmentsResponse> > response =
await _rcGetDepartments.GetResponse <IOperationResult <IGetDepartmentsResponse> >(
IGetDepartmentsRequest.CreateObj(newsIds: new List <Guid> {
newsId
}));
if (response.Message.IsSuccess)
{
return(response.Message.Body.Departments);
}
_logger.LogWarning(
"Error while getting department by news id {NewsId}. Reason:{Errors}",
newsId,
string.Join('\n', response.Message.Errors));
}
catch (Exception exc)
{
_logger.LogError("Can not get department by news id {NewsId}. {ErrorsMessage}", exc.Message);
}
errors.Add("Can not get department info. Please try again later.");
return(null);
}
private async Task <List <UserData> > GetUsersDataAsync(List <Guid> usersIds, List <string> errors)
{
if (usersIds == null || !usersIds.Any())
{
return(null);
}
try
{
Response <IOperationResult <IGetUsersDataResponse> > response =
await _rcGetUsers.GetResponse <IOperationResult <IGetUsersDataResponse> >(
IGetUsersDataRequest.CreateObj(usersIds.Distinct().ToList()));
if (response.Message.IsSuccess)
{
return(response.Message.Body.UsersData);
}
_logger.LogWarning(
"Error while geting users data by ids: {UsersIds}. Reason:{Errors}",
string.Join(", ", usersIds),
string.Join('\n', response.Message.Errors));
}
catch (Exception exc)
{
_logger.LogError(
"Can not get users data by ids: {UsersIds}. {ErrorsMessage}",
string.Join(", ", usersIds),
exc.Message);
}
errors.Add("Can not get users data. Please try again later.");
return(null);
}
public async Task Should_support_the_test_harness()
{
var provider = new ServiceCollection()
.AddMassTransitInMemoryTestHarness(cfg =>
{
cfg.AddConsumer <PingRequestConsumer>();
})
.BuildServiceProvider(true);
var harness = provider.GetRequiredService <InMemoryTestHarness>();
await harness.Start();
try
{
var bus = provider.GetRequiredService <IBus>();
IRequestClient <PingMessage> client = bus.CreateRequestClient <PingMessage>();
await client.GetResponse <PongMessage>(new PingMessage());
Assert.That(await harness.Consumed.Any <PingMessage>());
}
finally
{
await harness.Stop();
await provider.DisposeAsync();
}
}
public async Task Should_respond_with_rejected_if_customer_is_test()
{
var harness = new InMemoryTestHarness();
ConsumerTestHarness <SubmitOrderConsumer> consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
Guid orderId = NewId.NextGuid();
IRequestClient <SubmitOrder> requestClient = await harness.ConnectRequestClient <SubmitOrder>();
Response <OrderSubmissionRejected> response = await requestClient.GetResponse <OrderSubmissionRejected>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "TEST12345"
});
// assert
response.Message.OrderId.Should().Be(orderId);
consumer.Consumed.Select <SubmitOrder>().Should().NotBeNullOrEmpty();
harness.Sent.Select <OrderSubmissionRejected>().Should().NotBeNullOrEmpty();
}
finally
{
await harness.Stop();
}
}
public async Task Should_support_the_test_harness()
{
var container = new WindsorContainer()
.AddMassTransitInMemoryTestHarness(cfg =>
{
cfg.AddConsumer <PingRequestConsumer>();
});
var harness = container.Resolve <InMemoryTestHarness>();
await harness.Start();
try
{
var bus = container.Resolve <IBus>();
IRequestClient <PingMessage> client = bus.CreateRequestClient <PingMessage>();
await client.GetResponse <PongMessage>(new PingMessage());
Assert.That(await harness.Consumed.Any <PingMessage>());
}
finally
{
await harness.Stop();
container.Dispose();
}
}
private async Task <List <UserData> > GetUsersAsync(List <Guid> usersIds, List <string> errors)
{
if (usersIds == null || !usersIds.Any())
{
return(null);
}
try
{
var usersDataResponse = await _usersDataRequestClient.GetResponse <IOperationResult <IGetUsersDataResponse> >(
IGetUsersDataRequest.CreateObj(usersIds));
if (usersDataResponse.Message.IsSuccess)
{
return(usersDataResponse.Message.Body.UsersData);
}
_logger.LogWarning(
$"Can not get users. Reason:{Environment.NewLine}{string.Join('\n', usersDataResponse.Message.Errors)}.");
}
catch (Exception exc)
{
_logger.LogError(exc, "Exception on get users information.");
}
errors.Add("Can not get users info. Please try again later.");
return(null);
}
public async Task <ActionResult <List <Message> > > GetAsync()
{
//Func<Message, bool> expression = p => p.Text.EndsWith("1");
var response = await _client.GetResponse <MessagesResult>(new { EndWithFilter = "1" });
return(response.Message.Messages);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Starting client setup");
SetupTwitchClient();
_logger.LogInformation("Finished client setup");
_logger.LogInformation("Starting client connection");
client.Connect();
_logger.LogInformation("Finished client connection");
_logger.LogInformation("Starting monitoring channels request");
//Get list of channels for us to monitor
var channels = await _channelsClient.GetResponse <ResponseChannelsToMonitor>(new { }, stoppingToken);
_logger.LogInformation("Finished monitoring channels request, received {ChannelCount} channels", channels.Message.Channels.Length);
foreach (var channel in channels.Message.Channels)
{
_logger.LogInformation("Connecting to channel {ChannelName}", channel);
client.JoinChannel(channel);
}
while (!stoppingToken.IsCancellationRequested)
{
//_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
await Task.Delay(1000, stoppingToken);
}
}
private async void cmdGetDigitizationData_Click(object sender, EventArgs e)
{
try
{
Cursor = Cursors.WaitCursor;
var text = txtArchiveRecordId.Text;
var archiveRecordId = Convert.ToInt32(text.Contains("(") ? text.Substring(0, text.IndexOf("(", StringComparison.Ordinal)) : text);
var result = (await orderClient.GetResponse <GetDigitizationOrderDataResponse>(new GetDigitizationOrderData {
ArchiveRecordId = archiveRecordId.ToString()
})).Message;
if (result.Result.Success)
{
txtResult.Text = JsonConvert.SerializeObject(result.Result.DigitizationOrder, Formatting.Indented);
}
else
{
txtResult.Text = "FEHLER" + Environment.NewLine +
"======" + Environment.NewLine + Environment.NewLine + result.Result.ErrorMessage;
}
}
catch (Exception ex)
{
Cursor = Cursors.Default;
txtResult.Text = ex.Message;
}
Cursor = Cursors.Default;
}
public async Task Should_get_the_job_accepted()
{
var serviceClient = Bus.CreateServiceClient();
IRequestClient <SubmitJob <GrindTheGears> > requestClient = serviceClient.CreateRequestClient <SubmitJob <GrindTheGears> >();
Response <JobSubmissionAccepted> response = await requestClient.GetResponse <JobSubmissionAccepted>(new
{
JobId = _jobId,
Job = new { Duration = TimeSpan.FromSeconds(30) }
});
Assert.That(response.Message.JobId, Is.EqualTo(_jobId));
ConsumeContext <JobStarted> started = await _started;
await Bus.Publish <CancelJob>(new
{
JobId = _jobId,
Reason = "I give up",
InVar.Timestamp
});
// just to capture all the test output in a single window
ConsumeContext <JobCanceled> cancelled = await _cancelled;
}
public async Task Should_accept_that_faults_happen()
{
IRequestClient <CreateShortLink> client = Bus.CreateRequestClient <CreateShortLink>(RequestTimeout.After(s: 30));
Assert.That(async() =>
await client.GetResponse <ShortLinkCreated>(new { Link = new Uri("http://www.google.com") }), Throws.TypeOf <RequestFaultException>());
}
public async Task <IActionResult> Validate([FromQuery] TokenSubmissionViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var(accepted, rejected) = await _submitTokenRequestClient.GetResponse <TokenAccepted, TokenRejected>(new
{
EventId = NewId.NextGuid(),
InVar.Timestamp,
model.Token
});
if (accepted.IsCompletedSuccessfully)
{
var response = await accepted;
return(Accepted(response));
}
if (accepted.IsCompleted)
{
await accepted;
return(Problem("Token was not accepted"));
}
else
{
var response = await rejected;
return(BadRequest(response.Message));
}
}
public async Task <ExecutionResult> Execute(ExecuteContext <AllocateInventoryArguments> context)
{
var oderId = context.Arguments.OrderId;
string itemNumber = context.Arguments.ItemNumber ??
throw new ArgumentNullException(nameof(itemNumber));
var quantity = context.Arguments.Quantity;
if (quantity <= 0.0m)
{
throw new ArgumentNullException(nameof(quantity));
}
var allocationId = NewId.NextGuid();
Console.WriteLine("here");
var response = await _client.GetResponse <InventoryAllocated>(new
{
AllocationId = allocationId,
ItemNumber = itemNumber,
Quantity = quantity
});
return(context.Completed(new
{
AllocationId = allocationId,
}));
}
public async Task <IActionResult> Post(OrderViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var(accepted, rejected) = await _submitOrderRequestClient
.GetResponse <OrderSubmissionAccepted, OrderSubmissionRejected>(new
{
OrderId = model.Id,
InVar.Timestamp,
});
if (accepted.IsCompletedSuccessfully)
{
var response = await accepted;
return(Accepted(response));
}
if (accepted.IsCompleted)
{
await accepted;
return(Problem("Order was not accepted"));
}
else
{
var response = await rejected;
return(BadRequest(response.Message));
}
}
