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