public void ListenOnUpdateAddressAndCallSendOdrer() { var fakeMessageToSend = new CreateOrderMessage { Id = Guid.NewGuid(), IsTest = true, OrderId = 53462, OrderName = "Test order", }; var startup = new TestStartup(Ofs.Processor.ApplicationMode.UPDATE_ADDRESS); startup.Start(); startup.SendFakeMessage(fakeMessageToSend); //Wait 3 second. Task.Delay(3000); //Assert: CheckIn after processing should send IMessage to update address queue. Assert.IsType(fakeMessageToSend.GetType(), startup.Message); var receivedMessage = (CreateOrderMessage)startup.Message; Assert.NotNull(receivedMessage); Assert.Equal(fakeMessageToSend.Id, receivedMessage.Id); Assert.Equal(fakeMessageToSend.IsTest, receivedMessage.IsTest); Assert.Equal(fakeMessageToSend.OrderId, receivedMessage.OrderId); Assert.Equal(fakeMessageToSend.OrderName, receivedMessage.OrderName); Assert.Equal("sendorder", startup.Topic); }
/// <summary> /// Saves an order that as completed submission. /// </summary> /// /// <param name="order">The order to save.</param> /// /// <returns>The key for the order in storage.</returns> /// public async Task <string> SaveCompletedOrderAsync(CreateOrderMessage order) { if (order == null) { throw new ArgumentNullException(nameof(order)); } var identity = order.Identity; if (String.IsNullOrEmpty(identity?.PartnerCode)) { throw new ArgumentException("The order partner code is required", nameof(order.Identity.PartnerCode)); } if (String.IsNullOrEmpty(identity?.PartnerOrderId)) { throw new ArgumentException("The order identifier is required", nameof(order.Identity.PartnerOrderId)); } var blobName = this.FormatCompletedOrderBlobName(identity.PartnerCode, identity.PartnerOrderId); await this.UploadTextAsBlobAsync(this.configuration.StorageConnectionString, this.configuration.CompletedContainer, blobName, JsonConvert.SerializeObject(order, this.serializerSettings)); return(blobName); }
public async Task SaveCompletedOrderAsyncAttemptsToUploadTheBlob() { var config = new OrderSubmissionBlobStorageConfiguration { StorageConnectionString = "hey, connect to storage!", CompletedContainer = "the place where stuff lives" }; var mockStorage = new Mock <OrderSubmissionBlobStorage>(config, null) { CallBase = true }; var partner = "Henry"; var orderId = "ABD123"; var order = new CreateOrderMessage { Identity = new OrderIdentity { PartnerCode = partner, PartnerOrderId = orderId } }; var serialized = JsonConvert.SerializeObject(order); mockStorage .Protected() .Setup <Task>("UploadTextAsBlobAsync", ItExpr.Is <string>(connection => connection == config.StorageConnectionString), ItExpr.Is <string>(container => container == config.CompletedContainer), ItExpr.Is <string>(blob => ((blob.Contains(partner)) && (blob.Contains(orderId)))), ItExpr.Is <string>(content => content == serialized)) .Returns(Task.CompletedTask) .Verifiable("The blob upload should have been requested"); await mockStorage.Object.SaveCompletedOrderAsync(order); mockStorage.VerifyAll(); }
public async Task Run([ServiceBusTrigger(QueueName.CreateOrder, Connection = "ServiceBusConnection")] CreateOrderMessage createOrderMessage, ILogger log) { log.LogInformation($"Start process for order: {createOrderMessage.OrderId}"); await useCase.ProcessAsync(createOrderMessage); log.LogInformation($"End process for order: {createOrderMessage.OrderId}"); }
public async Task TryRetrievePendingOrderAsyncReturnsBlobContentWhenFound() { var config = new OrderSubmissionBlobStorageConfiguration { StorageConnectionString = "hey, connect to storage!", PendingContainer = "the place where stuff lives" }; var mockStorage = new Mock <OrderSubmissionBlobStorage>(config, null) { CallBase = true }; var partner = "Henry"; var orderId = "ABD123"; var content = new CreateOrderMessage(); mockStorage .Protected() .Setup <Task <(bool, string)> >("RetrieveBlobAsTextAsync", ItExpr.Is <string>(connection => connection == config.StorageConnectionString), ItExpr.Is <string>(container => container == config.PendingContainer), ItExpr.Is <string>(blob => ((blob.Contains(partner)) && (blob.Contains(orderId))))) .Returns(Task.FromResult((true, JsonConvert.SerializeObject(content)))) .Verifiable("The blob text should have been requested"); var result = await mockStorage.Object.TryRetrievePendingOrderAsync(partner, orderId); result.Found.Should().BeTrue("because the content was returned"); result.Order.ShouldBeEquivalentTo(content, "because the content should have been retrieved"); mockStorage.VerifyAll(); }
public async Task SubmitOrderForProductionProvidesTheCorrectPayload() { using (var response = new HttpResponseMessage()) { var config = new OrderProductionClientConfiguration { RequestProtocol = "https", ServiceHostAddress = "google.com", CreateOrderUrlTemplate = "/partners/{partner}/orders", RequestTimeoutSeconds = 60, ConnectionLeaseTimeoutSeconds = 300 }; var partner = "ABC"; var order = new CreateOrderMessage { Identity = new OrderIdentity { PartnerCode = partner }, TransactionId = "1234" }; var client = new TestOrderProductionClient(config, response); await client.SubmitOrderForProductionAsync(order, null); client.Request.Content.Headers.ContentType.MediaType.Should().Be(MimeTypes.Json, "becuse the order should have been sent in the correct format"); client.RequestContent.Should().Be(JsonConvert.SerializeObject(order), "because the correct order should have been sent"); } }
/// <summary> /// Submits an order to the order production service, signaling a request that it be produced. /// </summary> /// /// <param name="log">The logging instance to use for emitting information.</param> /// <param name="client">The client to use for interacting with the order production service.</param> /// <param name="createOrderMessage">The CreateOrderMessage representing the order to be produced.</param> /// <param name="correlationId">An optional identifier used to correlate activities across the disparate parts of processing, including external interations.</param> /// <param name="emulatedResult">An optional emulated result to use in place of querying the eCommerce service.</param> /// /// <returns>The result of the operation.</returns> /// /// <remarks> /// This method owns responsibility for logging the results of the operation and how /// it was produced. /// </remarks> /// protected virtual async Task <OperationResult> SendOrderToProductionAsync(ILogger log, IOrderProductionClient client, CreateOrderMessage order, string correlationId = null, OperationResult emulatedResult = null) { OperationResult result; try { result = emulatedResult ?? (await client.SubmitOrderForProductionAsync(order, correlationId)); log.Information("The order {Partner}//{Order} has been submitted for production. Emulated: {Emulated}. Result: {Result}", order?.Identity?.PartnerCode, order?.Identity?.PartnerOrderId, (emulatedResult != null), result); } catch (Exception ex) { log.Error(ex, "An error occured while submitting the order {Partner}//{Order}", order?.Identity?.PartnerCode, order?.Identity?.PartnerOrderId); return(OperationResult.ExceptionResult); } return(result); }
public async Task SaveCompletedOrderAsyncReturnsARepresentativeBlobPath() { var config = new OrderSubmissionBlobStorageConfiguration { StorageConnectionString = "hey, connect to storage!", CompletedContainer = "the place where stuff lives" }; var mockStorage = new Mock <OrderSubmissionBlobStorage>(config, null) { CallBase = true }; var partner = "Henry"; var orderId = "ABD123"; var order = new CreateOrderMessage { Identity = new OrderIdentity { PartnerCode = partner, PartnerOrderId = orderId } }; var serialized = JsonConvert.SerializeObject(order); mockStorage .Protected() .Setup <Task>("UploadTextAsBlobAsync", ItExpr.Is <string>(connection => connection == config.StorageConnectionString), ItExpr.Is <string>(container => container == config.CompletedContainer), ItExpr.Is <string>(blob => ((blob.Contains(partner)) && (blob.Contains(orderId)))), ItExpr.Is <string>(content => content == serialized)) .Returns(Task.CompletedTask); var result = await mockStorage.Object.SaveCompletedOrderAsync(order); result.Should().Contain(partner, "because the partner should be part of the blob key"); result.Should().Contain(orderId, "because the order id should be part of the blob key"); }
/// <summary> /// Queries the details of an order from the eCommerce system. /// </summary> /// /// <param name="orderId">The unique identifier of the order to query for.</param> /// <param name="correlationId">The correlation identifier to associate with the request. If <c>null</c>, no correlation will be sent.</param> /// /// <returns>The result of the operation.</returns> /// public async Task <OperationResult> SubmitOrderForProductionAsync(CreateOrderMessage order, string correlationId) { var identity = order.Identity; var timeout = TimeSpan.FromSeconds(this.configuration.RequestTimeoutSeconds); var requestUrl = this.configuration.CreateOrderUrlTemplate.Replace("{partner}", identity?.PartnerCode); using (var request = new HttpRequestMessage(HttpMethod.Post, requestUrl)) { if (correlationId != null) { request.Headers.TryAddWithoutValidation(HttpHeaders.CorrelationId, correlationId); request.Headers.TryAddWithoutValidation(HttpHeaders.DefaultApplicationInsightsOperationId, correlationId); } foreach (var pair in this.staticHeaders.Value) { request.Headers.TryAddWithoutValidation(pair.Key, pair.Value); } request.Content = new StringContent(JsonConvert.SerializeObject(order, this.serializerSettings), Encoding.UTF8, MimeTypes.Json); using (var response = await this.SendRequestAsync(request, timeout)) { return(new OperationResult { Outcome = (response.IsSuccessStatusCode) ? Outcome.Success : Outcome.Failure, Reason = response.StatusCode.ToString(), Recoverable = response.StatusCode.IsRetryEncouraged(), Payload = (response.Content == null) ? null : (await response.Content.ReadAsStringAsync()) }); } } }
public async Task SaveAsync(CreateOrderMessage order) { using (var redis = await ConnectAsync()) { var database = redis.GetDatabase(); await database.StringSetAsync(order.Id, JsonConvert.SerializeObject(order)); } }
static async Task Main(string[] args) { var configuration = BuildConfiguration(); var busControl = CreateBusControl(configuration); Task.Factory.StartNew(async() => await busControl.StartAsync()); var sendEndpoint = await busControl.GetSendEndpoint(new Uri(configuration.QueueUrl)); Console.WriteLine("Press a key:"); Console.WriteLine(" 1 to send a CreateOrder message"); Console.WriteLine(" 2 to send a CancelOrder message"); Console.WriteLine(" q to stop the application"); ConsoleKeyInfo key; int orderId = 0; do { key = Console.ReadKey(); Console.WriteLine(); if (key.Key == ConsoleKey.NumPad1) { var message = new CreateOrderMessage() { Id = ++orderId, OrderDate = DateTime.Now }; await sendEndpoint.Send(message); Console.WriteLine($"Order with Id {message.Id} has been sent."); } else if (key.Key == ConsoleKey.NumPad2) { Console.WriteLine("Enter the Id of the order that you want to cancel: "); string cancelOrderId = Console.ReadLine(); var m2 = new CancelOrderMessage() { OrderId = Int32.Parse(cancelOrderId) }; await sendEndpoint.Send(m2); } } while (key.Key != ConsoleKey.Q); Console.WriteLine("Stopping..."); await Task.Delay(2000); await busControl.StopAsync(); Console.WriteLine("MassTransit Queue demo stopped."); }
static void Main(string[] args) { var message = new CreateOrderMessage { CustomerName = "ACME" }; // This code throws InvalidCastException var handler2 = (ICommandMessageHandler2 <CreateOrderMessage>) new CreateOrderHandler2(); handler2.Execute(message); }
public async Task CreateOrder(string product, int amount) { var message = new CreateOrderMessage { Product = product, Amount = amount }; // Publish the message to the rabbitmq or in-memory queue await _messageSender.SendMessageAsync(message, CancellationToken.None); }
public AcknowledgedOrderMessage GetAckFromOrderRequest(CreateOrderMessage msg) { var returnMsg = new AcknowledgedOrderMessage { ControlNumber = msg.ControlNumber, CustomerPO = msg.CustomerPO, BusinessPartnerCode = msg.BusinessPartnerCode, AckType = "AD" }; msg.LineItems.ToList().ForEach(i => returnMsg.Add(get_new_line(i))); return returnMsg; }
public Task SaveAsync(CreateOrderMessage order) { lock (_lock) { if (_list.All(o => o.Id != order.Id)) { _list.Add(order); } } return(Task.CompletedTask); }
private static CreateOrderMessage get_message() { var line = new CreateOrderMessage() { ControlNumber = "23432", CustomerPO = "23432" }; line.Add(new CustomerOrderLine() { LineNumber = 1 }); return(line); }
public AcknowledgedOrderMessage GetAckFromOrderRequest(CreateOrderMessage msg) { var returnMsg = new AcknowledgedOrderMessage { ControlNumber = msg.ControlNumber, CustomerPO = msg.CustomerPO, BusinessPartnerCode = msg.BusinessPartnerCode, AckType = "AD" }; msg.LineItems.ToList().ForEach(i => returnMsg.Add(get_new_line(i))); return(returnMsg); }
public void SaveCompletedOrderAsyncFailsWhenTheOrderIdentityIsNull() { var config = new OrderSubmissionBlobStorageConfiguration { StorageConnectionString = "hey, connect to storage!", CompletedContainer = "the place where stuff lives" }; var order = new CreateOrderMessage(); var storage = new OrderSubmissionBlobStorage(config, null); Action actionUnderTest = () => storage.SaveCompletedOrderAsync(order).GetAwaiter().GetResult(); actionUnderTest.ShouldThrow <ArgumentException>("because the order is required"); }
public void SavePendingOrderAsyncValidatesTheOrderId() { var config = new OrderSubmissionBlobStorageConfiguration { StorageConnectionString = "hey, connect to storage!", PendingContainer = "the place where stuff lives" }; var partner = "ABC123"; var orderId = (string)null; var order = new CreateOrderMessage(); var storage = new OrderSubmissionBlobStorage(config, null); Action actionUnderTest = () => storage.SavePendingOrderAsync(partner, orderId, order).GetAwaiter().GetResult(); actionUnderTest.ShouldThrow <ArgumentException>("because the order id is required").And.ParamName.Should().Be(nameof(orderId)); }
public void SaveCompletedOrderAsyncValidatesThePartnerCode() { var config = new OrderSubmissionBlobStorageConfiguration { StorageConnectionString = "hey, connect to storage!", CompletedContainer = "the place where stuff lives" }; var order = new CreateOrderMessage { Identity = new OrderIdentity { PartnerOrderId = "ABC123" } }; var storage = new OrderSubmissionBlobStorage(config, null); Action actionUnderTest = () => storage.SaveCompletedOrderAsync(order).GetAwaiter().GetResult(); actionUnderTest.ShouldThrow <ArgumentException>("because the partner is required").And.ParamName.Should().Be(nameof(order.Identity.PartnerCode)); }
/// <summary> /// Stores an order as a final order which has completed submission. /// </summary> /// /// <param name="log">The logging instance to use for emitting information.</param> /// <param name="storage">The storage to use for the order.</param> /// <param name="createOrderMessage">The CreateOrderMessage representing the order.</param> /// <param name="correlationId">An optional identifier used to correlate activities across the disparate parts of processing, including external interations.</param> /// <param name="emulatedResult">An optional emulated result to use in place of interacting with storage.</param> /// /// <returns>The result of the operation.</returns> /// protected virtual async Task <OperationResult> StoreOrderAsCompletedAsync(ILogger log, IOrderStorage storage, CreateOrderMessage order, string correlationId = null, OperationResult emulatedResult = null) { OperationResult result; try { if (emulatedResult != null) { result = emulatedResult; } else { var key = await storage.SaveCompletedOrderAsync(order); result = new OperationResult { Outcome = Outcome.Success, Reason = String.Empty, Recoverable = Recoverability.Final, Payload = key }; } log.Information("Order details for {Partner}//{Order} have been saved as final. Emulated: {Emulated}. Result: {Result}", order?.Identity?.PartnerCode, order?.Identity?.PartnerOrderId, (emulatedResult != null), result); } catch (Exception ex) { log.Error(ex, "An error occured while saving {Partner}//{Order} as completed submission.", order.Identity.PartnerCode, order.Identity.PartnerOrderId); return(OperationResult.ExceptionResult); } return(result); }
public void ReceiveMessageFromListenerAndCallAnnouncer() { ModuleSettings setting = new ModuleSettings() { AppId = Guid.Empty, ListenOn = "test", SendTo = "test", }; var fakeMessageFormListener = new CreateOrderMessage { Id = Guid.Empty, IsTest = true, OrderId = 53462, OrderName = "Test order", }; var messageSendSettings = new MessageSettingsOut(setting.SendTo); var messageListenSettings = new MessageSettingsIn(setting.ListenOn); var loggerMock = new Mock <ILogger <UpdateAddressModule> >(); var queueListenerMok = new Mock <IListener>(); queueListenerMok.Setup(x => x.StartListening(messageListenSettings, null)); var queueAnnouncerMok = new Mock <IAnnouncer>(); queueAnnouncerMok.Setup(x => x.Announce(fakeMessageFormListener, It.IsAny <IMessageSettingsOut>())).Verifiable("Listener should call anouncer!"); var module = new UpdateAddressModule(setting, loggerMock.Object, queueListenerMok.Object, queueAnnouncerMok.Object); module.Start(); queueListenerMok.Raise(x => x.OnMessage += (test) => { }, fakeMessageFormListener); Task.Delay(2000); queueAnnouncerMok.VerifyAll(); //If we are in here it's mean success Assert.True(true); }
//Only for tests! Remove me public void ProduceFakeTestMessage() { using (var anouncer = serviceProvider.GetService <IAnnouncer>()) { while (true) { var text = Console.ReadLine(); var message = new CreateOrderMessage() { Id = Guid.NewGuid(), OrderId = 5425212, OrderName = text, IsTest = true, }; // for (int i = 0; i < 5; i++) { var messageSendSettings = new MessageSettingsOut(ApplicationMode.CHECK_IN.ToName()); anouncer.Announce(message, messageSendSettings); } } } }
/// <summary> /// Creates a new <see cref="CreateOrderMessage" /> based on the specified /// <paramref name="instance"/>. /// </summary> /// /// <param name="instance">The instance that this method was invoked on.</param> /// /// <returns>A CreateOrderMessage materialzied with data sourced from the order details. </returns> /// public static CreateOrderMessage ToCreateOrderMessage(this OrderDetails instance) { var createOrderMessage = new CreateOrderMessage(); if (instance == null) { return(createOrderMessage); } // Copy properties from the root of the details. createOrderMessage.Identity = new OrderIdentity { PartnerOrderId = instance.OrderId }; createOrderMessage.Customer = new Customer { Code = instance.UserId, LanguageCode = instance.Recipients.FirstOrDefault()?.LanguageCode }; createOrderMessage.Shipping = new OrderShippingInformation(); createOrderMessage.Instructions = new OrderInstructions(); createOrderMessage.Recipients = instance.Recipients.Select(recipient => OrderDetailsExtensions.CopyRecipientToNewRecipient(recipient)).ToList(); createOrderMessage.LineItems = instance.LineItems.Select(item => OrderDetailsExtensions.CopyLineItemToNewLineItem(item)).ToList(); return(createOrderMessage); }
public void Acknowledge(CreateOrderMessage msg) { var transaction = _builder.BuildFromMessage(msg); _fileSvc.SendFile(transaction.Value, msg.ControlNumber, 855); }
private static CreateOrderMessage get_message() { var line = new CreateOrderMessage() {ControlNumber = "23432", CustomerPO = "23432"}; line.Add(new CustomerOrderLine() {LineNumber = 1}); return line; }
static void Main(string[] args) { XmlConfigurator.Configure(new FileInfo("TestPublisher.log4net.xml")); IWindsorContainer container = new DefaultMassTransitContainer("TestPublisher.Castle.xml"); IServiceBus bus = ServiceLocator.Current.GetInstance <IServiceBus>(); var messaage = new CreateOrderMessage() { BusinessPartnerCode = BusinessPartner.FedEx.Code, BusinessPartnerNumber = BusinessPartner.FedEx.Number, ControlNumber = "1", CustomerPO = "PO-100", Customer = new Customer { CustomerID = "100", CustomerName = "test co." }, BusinessProcessName = "business process name", RequestDate = SystemTime.Now().ToString() }; messaage.Customer.AddAddress(new Address { Address1 = "test addr1", Address2 = "addr2", AddressCode = "TEST", AddressName = "office", AddressType = AddressTypeConstants.ShipTo, City = "austin", State = "TX", Zip = "88888" }); messaage.Add(new CustomerOrderLine { CustID = "100", CustomerPartNumber = "222", CustomerPO = "333", ItemDescription = "desc", ItemID = "444", LineNumber = 1, Notes = "note", OrderMultiple = 1, OrderNumber = "555", RequestedPrice = 6.0, RequestedQuantity = 2, RequestNumber = "1", TestMode = true }); messaage.LineItems.Add(new CustomerOrderLine { CustID = "100", CustomerPartNumber = "222b", CustomerPO = "333b", ItemDescription = "descb", ItemID = "444b", LineNumber = 2, Notes = "noteb", OrderMultiple = 2, OrderNumber = "555b", RequestedPrice = 7.0, RequestedQuantity = 3, RequestNumber = "1b", TestMode = true }); Thread.Sleep(4000); bus.Publish(messaage); bus.Dispose(); }
/// <summary> /// Saves an order that is pending submission. /// </summary> /// /// <param name="partner">The code of the partner assocaited with the order.</param> /// <param name="orderId">The unique identifier of the desired order.</param> /// <param name="order">The order data to save.</param> /// /// <returns>The key for the order in storage.</returns> /// public async Task <string> SavePendingOrderAsync(string partner, string orderId, CreateOrderMessage order) { if (partner == null) { throw new ArgumentNullException(nameof(partner)); } if (String.IsNullOrEmpty(partner)) { throw new ArgumentException("The order partner code is required", nameof(partner)); } if (orderId == null) { throw new ArgumentNullException(nameof(orderId)); } if (String.IsNullOrEmpty(orderId)) { throw new ArgumentException("The order identifier is required", nameof(orderId)); } if (order == null) { throw new ArgumentNullException(nameof(order)); } var blobName = this.FormatPendingOrderBlobName(partner, orderId); await this.UploadTextAsBlobAsync(this.configuration.StorageConnectionString, this.configuration.PendingContainer, blobName, JsonConvert.SerializeObject(order, this.serializerSettings)); return(blobName); }
static void Main(string[] args) { XmlConfigurator.Configure(new FileInfo("TestPublisher.log4net.xml")); IWindsorContainer container = new DefaultMassTransitContainer("TestPublisher.Castle.xml"); IServiceBus bus = ServiceLocator.Current.GetInstance<IServiceBus>(); var messaage = new CreateOrderMessage() { BusinessPartnerCode = BusinessPartner.FedEx.Code, BusinessPartnerNumber = BusinessPartner.FedEx.Number, ControlNumber = "1", CustomerPO = "PO-100", Customer = new Customer { CustomerID = "100", CustomerName = "test co." }, BusinessProcessName = "business process name", RequestDate = SystemTime.Now().ToString() }; messaage.Customer.AddAddress(new Address { Address1 = "test addr1", Address2 = "addr2", AddressCode = "TEST", AddressName = "office", AddressType = AddressTypeConstants.ShipTo, City = "austin", State = "TX", Zip = "88888" }); messaage.Add(new CustomerOrderLine { CustID = "100", CustomerPartNumber = "222", CustomerPO = "333", ItemDescription = "desc", ItemID = "444", LineNumber = 1, Notes = "note", OrderMultiple = 1, OrderNumber = "555", RequestedPrice = 6.0, RequestedQuantity = 2, RequestNumber = "1", TestMode = true }); messaage.LineItems.Add(new CustomerOrderLine { CustID = "100", CustomerPartNumber = "222b", CustomerPO = "333b", ItemDescription = "descb", ItemID = "444b", LineNumber = 2, Notes = "noteb", OrderMultiple = 2, OrderNumber = "555b", RequestedPrice = 7.0, RequestedQuantity = 3, RequestNumber = "1b", TestMode = true }); Thread.Sleep(4000); bus.Publish(messaage); bus.Dispose(); }