public override Core.OrderManagement.Orders.Events.OrderLineQuantityAdjusted ConvertToIntern(OrderLineQuantityAdjusted e)
{
return(new Core.OrderManagement.Orders.Events.OrderLineQuantityAdjusted(
OrderIdentifier.Parse(e.OrderIdentifier),
OrderLineIdentifier.Parse(e.OrderLineIdentifier),
e.Quantity));
}
private IPurchaseOrder GetOrder(OrderIdentifier identifier)
{
var order = m_purchaseOrderRepository.TryLoadOrderByOrderNumber(identifier.ErpOrderId);
if (order == null)
{
order = m_database.New <IPurchaseOrder>();
}
else if (order.OrderHash == identifier.OrderHash)
{
m_stopMapping = true;
Order = order;
return(null);
}
else
{
Order = order;
OrderItemsToDelete.AddRange(Order.Items.Select(i => i.Id));
}
order.OrderNumber = identifier.ErpOrderId;
Order = order;
return(Order);
}
public override Core.OrderManagement.Orders.Events.OrderLineCreated ConvertToIntern(OrderLineCreated e)
{
return(new Core.OrderManagement.Orders.Events.OrderLineCreated(
OrderIdentifier.Parse(e.OrderIdentifier),
OrderLineIdentifier.Parse(e.OrderLineIdentifier),
ProductIdentifier.Parse(e.ProductIdentifier),
ProductName.Create(e.ProductName),
e.Quantity));
}
public static Order Create(
IAggregateContext context,
OrderIdentifier orderIdentifier,
CustomerIdentifier customerIdentifier)
{
return(CreateWithEvent <Order, OrderCreated>(
context,
new OrderCreated(
orderIdentifier,
customerIdentifier)));
}
public IEnumerable <OrderHeader> GetByIdentifier(OrderIdentifier orderIdentifier)
{
using (ISession session = SessionFactory.GetNewSession("db2"))
{
var query = from o in session.Query <OrderHeader>()
select o;
query = query.Where(o => o.OrderIdentifier == orderIdentifier);
return(query.ToList());
}
}
public IEnumerable <PaymentRelease> GetByIdentifier(OrderIdentifier identifier)
{
using (ISession session = SessionFactory.GetNewSession("db1"))
{
var query = from o in session.Query <PaymentRelease>()
select o;
query = query.Where(o => o.OrderIdentifier == identifier);
return(query.ToList());
}
}
public OrderLineCreated(
OrderIdentifier orderIdentifier,
OrderLineIdentifier orderLineIdentifier,
ProductIdentifier productIdentifier,
ProductName productName,
int quantity)
{
OrderIdentifier = orderIdentifier;
OrderLineIdentifier = orderLineIdentifier;
ProductIdentifier = productIdentifier;
ProductName = productName;
Quantity = quantity;
}
private Order CreateOrder()
{
if (_eventStore == null)
{
throw new Exception("Event store is null");
}
var orderRepository = new OrderRepository(_eventStore, _aggregateContext);
_order = Order.Create(
_aggregateContext,
OrderIdentifier.New(),
CustomerIdentifier.New());
return(_order);
}
public void StopOrderTracking(OpenOrderModel order)
{
try
{
var exchange = _dictionaryModelsMapper.GetName <ExchangeModel>(order.ExchangeId);
var targetInstrument = _instrumentsNameMapper.GetExchangeInstrument(
_dictionaryModelsMapper.GetName <InstrumentModel>(order.InstrumentId), exchange);
var orderIdentifier = new OrderIdentifier(order.OrderId, targetInstrument);
_allOrders.TryRemove(order.OrderId, out OpenOrderModel removedOrder);
_ordersWatcher.StopOrderTracking(orderIdentifier, exchange);
_orderCancelationWatcher.RemoveFromWatcher(order);
}
catch (Exception e)
{
_logger?.Log(SeverityLevel.Error, $"Failed to start tracking for new order! Exchange: {order.ExchangeId}, OrderId = {order.OrderId}");
_logger?.Log(SeverityLevel.Error, e);
throw;
}
}
public void StopOrderTracking(OrderIdentifier orderIdentifier, string exchange)
{
try
{
if (_ordersToCheck.TryGetValue(exchange, out ConcurrentDictionary <string, OrderIdentifier> collection) &&
collection.ContainsKey(orderIdentifier.Value) && collection.TryRemove(orderIdentifier.Value, out OrderIdentifier order))
{
_logger?.Log(SeverityLevel.Debug, $"Order: {order}; Exchange: {exchange}. Removed from tracking service!");
}
else
{
_logger?.Log(SeverityLevel.Debug, $"Order: {orderIdentifier}; Exchange: {exchange}. Not found! Can't removed from tracking service!");
}
}
catch (Exception e)
{
_logger?.Log(SeverityLevel.Error, $"Failed to remove order: {orderIdentifier}; Exchange: {exchange} from tracking service!");
_logger?.Log(SeverityLevel.Error, e);
}
}
public void StartOrderTracking(OrderIdentifier orderIdentifier, string exchange)
{
try
{
var newCollection = new ConcurrentDictionary <string, OrderIdentifier>();
newCollection.AddOrUpdate(orderIdentifier.Value, orderIdentifier, (s, identifier) => orderIdentifier);
_ordersToCheck.AddOrUpdate(exchange, newCollection,
(s, list) =>
{
list.AddOrUpdate(orderIdentifier.Value, orderIdentifier,
(s1, identifier) => orderIdentifier);
return(list);
});
_logger?.Log(SeverityLevel.Debug, $"Add order: {orderIdentifier}; Exchange: {exchange}. To tracking service.");
}
catch (Exception e)
{
_logger?.Log(SeverityLevel.Error, $"Failed to add order: {orderIdentifier}; Exchange: {exchange}. To tracking service!");
_logger?.Log(SeverityLevel.Error, e);
}
}
public override Core.OrderManagement.Orders.Events.OrderLineRemoved ConvertToIntern(OrderLineRemoved e)
{
return(new Core.OrderManagement.Orders.Events.OrderLineRemoved(
OrderIdentifier.Parse(e.OrderIdentifier),
OrderLineIdentifier.Parse(e.OrderLineIdentifier)));
}
public OrderCreated(OrderIdentifier orderIdentifier, CustomerIdentifier customerIdentifier)
{
OrderIdentifier = orderIdentifier;
CustomerIdentifier = customerIdentifier;
}
public IHttpActionResult CreatePaymentRelease([FromBody] PaymentReleaseData data)
{
string apiKey;
try
{
apiKey = data.header.apikey;
}
catch (System.Exception)
{
logger.Log(ErrorType.ERR, "CreatePaymentRelease()", RequestContext.Principal.Identity.Name, "API key is missing.", "api/woood-payment-release/create");
return(Content(HttpStatusCode.Unauthorized, "API key is missing."));
}
var user = userRepository.GetByUsername(data.header.username);
if (apiKey != user.ApiKey)
{
logger.Log(ErrorType.ERR, "CreatePaymentRelease()", RequestContext.Principal.Identity.Name, "API key is not correct. Get a right API key from the service provider.", "api/woood-payment-release/create");
return(Content(HttpStatusCode.Unauthorized, "API key is not correct. Get a right API key from the service provider."));
}
if (!ModelState.IsValid)
{
logger.Log(ErrorType.ERR, "CreatePaymentRelease()", RequestContext.Principal.Identity.Name, ModelState.ToString(), "api/woood-payment-release/create");
return(BadRequest(ModelState));
}
try
{
var orderIdentifier = new OrderIdentifier(data.body.REFERENTIE, data.body.DEBITEURNR);
var existingOrders = orderRepository.GetByIdentifier(orderIdentifier);
if (existingOrders.Count() == 0)
{
logger.Log(ErrorType.ERR, "CreatePaymentRelease()", RequestContext.Principal.Identity.Name, "DEBITEURNR-REFERENTIE UNKNOWN", "api/woood-payment-release/create");
return(Content(HttpStatusCode.BadRequest, "DEBITEURNR-REFERENTIE UNKNOWN"));
}
var paymentToPost = new APIWoood.Logic.Models.PaymentRelease()
{
OrderIdentifier = orderIdentifier,
PAYMENT_RELEASE = data.body.PAYMENT_RELEASE,
};
paymentReleaseRepository.Insert(paymentToPost);
logger.Log(ErrorType.INFO, "CreatePaymentRelease()", RequestContext.Principal.Identity.Name, "The Release Payment was succesfully added", "api/woood-payment-release/create", startDate);
return(Ok(new
{
body = new
{
message = "The Release Payment was succesfully added"
}
}));
}
catch (Exception e)
{
logger.Log(ErrorType.ERR, "CreatePaymentRelease()", RequestContext.Principal.Identity.Name, e.Message, "api/woood-payment-release/create");
return(InternalServerError(e));
}
}
public override Core.OrderManagement.Orders.Events.OrderCreated ConvertToIntern(OrderCreated e)
{
return(new Core.OrderManagement.Orders.Events.OrderCreated(
OrderIdentifier.Parse(e.OrderIdentifier),
CustomerIdentifier.Parse(e.CustomerIdentifier)));
}
protected override IList <ApiMessage> ProcessResponseForTask(string response)
{
ChannelEngineDto dto = JsonConvert.DeserializeObject <ChannelEngineDto>(response);
IList <ApiMessage> messages = new List <ApiMessage>();
int itemCount = 0;
try
{
if (dto.Count > 0)
{
foreach (ChannelEngineOrderHeaderDto order in dto.Content)
{
string debiteurnr = order.ChannelName.Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries)[0].Trim();
OrderIdentifier identifier = new OrderIdentifier(order.ChannelOrderNo, debiteurnr);
// JsonConvert.SerializeObject(order);
// Check if the order already exists
var existingOrder = orderRepository.GetByIdentifier(identifier);
if (existingOrder.Count() == 0)
{
string shippingAddress = order.ShippingAddress.StreetName;
if (!string.IsNullOrEmpty(order.ShippingAddress.HouseNr))
{
shippingAddress += " " + order.ShippingAddress.HouseNr;
}
if (!string.IsNullOrEmpty(order.ShippingAddress.HouseNrAddition))
{
shippingAddress += " " + order.ShippingAddress.HouseNrAddition;
}
OrderHeader orderHeader = new OrderHeader
{
OrderIdentifier = identifier,
ORDERTOELICHTING = order.MerchantComment,
DS_NAAM = order.ShippingAddress.FirstName + " " + order.ShippingAddress.LastName,
DS_ADRES1 = shippingAddress,
DS_POSTCODE = order.ShippingAddress.ZipCode,
DS_PLAATS = order.ShippingAddress.City,
DS_LAND = order.ShippingAddress.CountryIso,
DS_TELEFOON = order.Phone,
DS_EMAIL = order.Email,
AUTHENTICATED_USER = "******",
CUSTOMERORDERID = order.Id,
SELECTIECODE = "TH"
};
foreach (ChannelEngineOrderLineDto line in order.Lines)
{
var nettoPrijs = line.UnitPriceInclVat - line.UnitVat;
if (line.ExpectedDeliveryDate.ToString() != "01/01/0001 00:00:00")
{
orderHeader.Lines.Add(new OrderLine
{
ITEMCODE = line.MerchantProductNo,
NETTO_PRIJS = (float)nettoPrijs,
NETT_PRICE_INCL_VAT = line.UnitPriceInclVat,
UNIT_VAT = line.UnitVat,
AANTAL = line.Quantity,
REQUESTEDDATE = line.ExpectedDeliveryDate,
OrderIdentifier = identifier
});
}
else
{
orderHeader.Lines.Add(new OrderLine
{
ITEMCODE = line.MerchantProductNo,
NETTO_PRIJS = (float)nettoPrijs,
NETT_PRICE_INCL_VAT = line.UnitPriceInclVat,
UNIT_VAT = line.UnitVat,
AANTAL = line.Quantity,
REQUESTEDDATE = null,
OrderIdentifier = identifier
});
}
}
orderRepository.Insert(orderHeader);
messages.Add(new ApiMessage
{
Code = 200,
Description = "Before: " + JsonConvert.SerializeObject(order) + ", After: " + JsonConvert.SerializeObject(orderHeader)
});
++itemCount;
}
}
}
}
catch (Exception ex)
{
messages.Add(new ApiMessage()
{
Code = 401,
Description = "Error in (ProcessResponseForTask): " + ex.Message
});
}
return(messages);
}
static void Main(string[] args)
{
Console.WriteLine("Starting the Phone Number Ordering App");
useHttp(true); //not https
port("8080");
startServerInstance();
post("/subscriptions/orders", (EagleRequest request, HttpListenerResponse response) =>
{
XmlSerializer serializer = new XmlSerializer(typeof(Notification));
Notification notification = (Notification)serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(request.Body)));
Console.WriteLine(notification.Status);
Console.WriteLine(notification.Message);
});
post("/subscriptions/disconnects", (EagleRequest request, HttpListenerResponse response) =>
{
XmlSerializer serializer = new XmlSerializer(typeof(Notification));
Notification notification = (Notification)serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(request.Body)));
Console.WriteLine(notification.Status);
Console.WriteLine(notification.Message);
var phoneNumber = notification.CompletedTelephoneNumbers[0];
storage.Remove(phoneNumber);
});
get("/availablePhoneNumbers", (EagleRequest request, HttpListenerResponse response) =>
{
var queryParams = request.RawRequest.QueryString;
var query = new Dictionary <string, object>()
{
{ "quantity", 10 },
};
if (queryParams.Get("zipCode") != null)
{
query.Add("zip", queryParams.Get("zipCode"));
}
if (queryParams.Get("areaCode") != null)
{
query.Add("areaCode", queryParams.Get("areaCode"));
}
try
{
var res = AvailableNumbers.List(client, query).Result;
return(res.TelephoneNumberList);
} catch (AggregateException ex)
{
if (ex.InnerException is BandwidthIrisException)
{
response.StatusCode = 400;
BandwidthIrisException irisEx = (BandwidthIrisException)ex.InnerException;
return(new Error
{
BandwidthErrorCode = irisEx.Code,
BandwidthErrorDescription = irisEx.Body.ToString(),
Description = "Bandwidth Invalid User Input",
Type = "validation"
});
}
throw ex;
}
});
post("/phoneNumbers", (EagleRequest request, HttpListenerResponse response) =>
{
string phoneNumber = request.Body.phoneNumber;
if (storage.ContainsKey(phoneNumber))
{
return(new Error
{
Type = "owned number",
Description = "You have already ordered this number."
});
}
OrderResult orderResult;
try
{
orderResult = Order.Create(client, new Order
{
CustomerOrderId = "customerOrderId",
SiteId = SITE_ID, //The site to order the number for
ExistingTelephoneNumberOrderType = new ExistingTelephoneNumberOrderType
{
TelephoneNumberList = new string[] { phoneNumber }
}
}).Result;
} catch (AggregateException ex)
{
if (ex.InnerException is BandwidthIrisException)
{
response.StatusCode = 400;
BandwidthIrisException irisEx = (BandwidthIrisException)ex.InnerException;
return(new Error
{
BandwidthErrorCode = irisEx.Code,
BandwidthErrorDescription = irisEx.Body.ToString(),
Description = "Bandwidth Invalid User Input",
Type = "validation"
});
}
throw ex;
}
var orderIdentifier = new OrderIdentifier
{
OrderId = orderResult.Order.OrderId,
PhoneNumber = phoneNumber
};
storage.Add(phoneNumber, orderIdentifier);
response.StatusCode = 201;
return(orderIdentifier);
});
get("/phoneNumbers", (EagleRequest request, HttpListenerResponse response) =>
{
return(storage.Values);
});
delete("/phoneNumbers/{phoneNumber}", (EagleRequest request, HttpListenerResponse response) =>
{
string phoneNumber = request.PathInfo.PathParameters.phoneNumber;
if (!storage.ContainsKey(phoneNumber))
{
response.StatusCode = 404;
return(new Error
{
Description = "This number has not ordered yet, cannot remove.",
Type = "not found"
});
}
try
{
Disconnect.Create(client, "orderName", phoneNumber);
}
catch (AggregateException ex)
{
if (ex.InnerException is BandwidthIrisException)
{
response.StatusCode = 400;
BandwidthIrisException irisEx = (BandwidthIrisException)ex.InnerException;
return(new Error
{
BandwidthErrorCode = irisEx.Code,
BandwidthErrorDescription = irisEx.Body.ToString(),
Description = "Bandwidth Invalid User Input",
Type = "validation"
});
}
throw ex;
}
response.StatusCode = 201;
return(new Dictionary <string, bool>()
{
{ "Recieved", true }
});
});
post("/stop", (EagleRequest request, HttpListenerResponse response) => {
stop();
return("Server Shutting Down");
});
Console.WriteLine("Server is Ready!!!!!!!!!");
WaitOnServerToStop();
}
public DDDSteps()
{
_eventStore = new TestEventStore();
_orderIdentifier = OrderIdentifier.New();
_aggregateContext = new TestAggregateContext();
}
public OrderLineQuantityAdjusted(OrderIdentifier orderIdentifier, OrderLineIdentifier orderLineIdentifier, int quantity)
{
OrderIdentifier = orderIdentifier;
OrderLineIdentifier = orderLineIdentifier;
Quantity = quantity;
}
static async Task Main()
{
var eventsConverter = new EventsConverter();
//var e = new Core.OrderManagement.Orders.Events.OrderCreated(OrderIdentity.New());
//System.Console.WriteLine(JsonSerializer.Serialize(e, new JsonSerializerOptions { WriteIndented = true }));
//var a = EventMapping.Convert(e);
//var json = JsonSerializer.Serialize(a, new JsonSerializerOptions { WriteIndented = true, Converters = { new IdentityJsonConverter() } });
//System.Console.WriteLine(json);
//var data2 = JsonSerializer.Deserialize<OrderCreated>(json);
//var e2 = EventMapping.Convert2(data2);
//System.Console.WriteLine(JsonSerializer.Serialize(e, e.GetType(), new JsonSerializerOptions { WriteIndented = true }));
//return;
var aggregateContext = new AggregateContext();
IEventStore eventStore = new EventStoreDb(eventsConverter, new Uri("http://localhost:2113"));
var productRepository = new ProductRepository(eventStore, aggregateContext);
var product1 = Product.Create(aggregateContext, ProductName.Create("Brood"));
await productRepository.SaveAsync(product1);
product1.ChangeName(ProductName.Create("Boterham"));
await productRepository.SaveAsync(product1);
var productRepository2 = new ProductRepository(eventStore, aggregateContext);
var product1A = await productRepository2.GetAsync(product1.Identifier);
//System.Console.WriteLine(JsonSerializer.Serialize(product, new JsonSerializerOptions { WriteIndented = true }));
//System.Console.WriteLine(JsonSerializer.Serialize(product2, new JsonSerializerOptions { WriteIndented = true }));
var orderRepository = new OrderRepository(eventStore, aggregateContext);
var order = Order.Create(
aggregateContext,
OrderIdentifier.New(),
CustomerIdentifier.New());
var faultyLine = order.CreateOrderLine(ProductIdentifier.New(), 1);
faultyLine.Remove();
var prod2 = ProductIdentifier.New();
var prod3 = ProductIdentifier.New();
var prod4 = ProductIdentifier.New();
order.CreateOrderLine(product1, 1);
order.CreateOrderLine(prod2, 2);
order.CreateOrderLine(prod3, 1);
order.CreateOrderLine(prod4, 1);
var prod3OrderLine = order.Lines.Get(prod3);
prod3OrderLine.Remove();
var prod1OrderLine = order.Lines.Get(product1.Identifier);
prod1OrderLine.AdjustQuantity(3);
await orderRepository.SaveAsync(order);
var order2 = await orderRepository.GetAsync(order.OrderIdentifier);
var product1B = await productRepository2.GetAsync(product1.Identifier);
product1B.ChangeName(ProductName.Create("Stok brood"));
await productRepository2.SaveAsync(product1B);
}
public IHttpActionResult CreateOrder([FromBody] OrderData data)
{
var jsonData = JsonConvert.SerializeObject(data);
string apiKey;
try
{
apiKey = data.header.apikey;
}
catch (System.Exception)
{
logger.Log(ErrorType.ERR, "CreateOrder()", RequestContext.Principal.Identity.Name, "API key is missing. " + jsonData, "api/woood-order/create");
return(Content(HttpStatusCode.Unauthorized, "API key is missing."));
}
var user = userRepository.GetByUsername(data.header.username);
if (apiKey != user.ApiKey)
{
logger.Log(ErrorType.ERR, "CreateOrder()", RequestContext.Principal.Identity.Name, "API key is not correct. Get a right API key from the service provider.", "api/woood-order/create");
return(Content(HttpStatusCode.Unauthorized, "API key is not correct. Get a right API key from the service provider."));
}
if (!ModelState.IsValid)
{
logger.Log(ErrorType.ERR, "CreateOrder()", RequestContext.Principal.Identity.Name, ModelState.ToString(), "api/woood-order/create");
return(BadRequest(ModelState));
}
var references = new List <string>();
int orderCount = 0;
foreach (var order in data.body.order)
{
try
{
var orderIdentifier = new OrderIdentifier(order.REFERENTIE, order.DEBITEURNR);
var existingOrders = orderRepository.GetByIdentifier(orderIdentifier);
if (existingOrders.Count() > 0)
{
logger.Log(ErrorType.ERR, "CreateOrder()", RequestContext.Principal.Identity.Name, "The combination of DEBITEURNR(" + order.DEBITEURNR + ") and REFERENTIE(" + order.REFERENTIE + ") must be unique", "api/woood-order/create");
return(Content(HttpStatusCode.BadRequest, "The combination of DEBITEURNR and REFERENTIE must be unique"));
}
if (order.item.Count() == 0)
{
logger.Log(ErrorType.ERR, "CreateOrder()", RequestContext.Principal.Identity.Name, "The order has no lines", "api/woood-order/create");
return(Content(HttpStatusCode.BadRequest, "The order has no lines"));
}
// Check if the user has access to the debtor
if (!DebtorBelongsToUser(user, order.DEBITEURNR))
{
logger.Log(ErrorType.ERR, "CreateOrder()", RequestContext.Principal.Identity.Name, "DEBITEURNR does not belong to the user", "api/woood-order/create");
return(Content(HttpStatusCode.BadRequest, "DEBITEURNR does not belong to the user"));
}
var orderToPost = new OrderHeader()
{
OrderIdentifier = orderIdentifier,
OMSCHRIJVING = order.OMSCHRIJVING,
STATUS = order.STATUS,
ORDERNR = order.ORDERNR,
SELECTIECODE = order.SELECTIECODE,
ORDERTOELICHTING = order.ORDERTOELICHTING,
ACCEPTATIE_VERZAMELEN = order.ACCEPTATIE_VERZAMELEN,
ACCEPTATIE_ORDERKOSTEN = order.ACCEPTATIE_ORDERKOSTEN,
DS_NAAM = order.DS_NAAM,
DS_AANSPREEKTITEL = order.DS_AANSPREEKTITEL,
DS_ADRES1 = order.DS_ADRES1,
DS_POSTCODE = order.DS_POSTCODE,
DS_PLAATS = order.DS_PLAATS,
DS_LAND = order.DS_LAND,
DS_TELEFOON = order.DS_TELEFOON,
DS_EMAIL = order.DS_EMAIL,
AUTHENTICATED_USER = data.header.username,
ACCEPTATIE_ORDERSPLITSING = order.ACCEPTATIE_ORDERSPLITSING,
PAYMENT_RELEASE_REQUIRED = order.PAYMENT_RELEASE_REQUIRED,
SR_SERVICE_PRODUCT = order.SR_SERVICE_PRODUCT,
SR_AFLEVEREN_AAN = order.SR_AFLEVEREN_AAN,
SR_LOCATIE = order.SR_LOCATIE,
SR_BEDRIJFSNAAM = order.SR_BEDRIJFSNAAM,
SR_BEWIJS = order.SR_BEDRIJFSNAAM,
SR_ORDERREF = order.SR_ORDERREF,
SR_REDEN = order.SR_REDEN,
SR_TOELICHTING = order.SR_TOELICHTING,
SR_PDF_ATTACHMENT = order.SR_PDF_ATTACHMENT
};
int orderLineCount = 0;
foreach (var item in order.item)
{
var orderLineToPost = new OrderLine()
{
OrderIdentifier = orderToPost.OrderIdentifier,
ITEMCODE = item.ITEMCODE,
AANTAL = item.AANTAL,
STATUS = item.STATUS,
ORDERNR = item.ORDERNR,
VERZENDWEEK = item.VERZENDWEEK
};
orderToPost.Lines.Add(orderLineToPost);
++orderLineCount;
}
orderRepository.Insert(orderToPost);
++orderCount;
references.Add(orderIdentifier.REFERENTIE);
}
catch (System.Exception e)
{
logger.Log(ErrorType.ERR, "CreateOrder()", RequestContext.Principal.Identity.Name, e.Message, "api/woood-order/create");
return(InternalServerError(e));
}
}
if (orderCount == 0)
{
logger.Log(ErrorType.ERR, "CreateOrder()", RequestContext.Principal.Identity.Name, "No orders added", "api/woood-order/create");
return(BadRequest("No orders added"));
}
logger.Log(ErrorType.INFO, "CreateOrder()", RequestContext.Principal.Identity.Name, new JavaScriptSerializer().Serialize(references), "api/woood-order/create", startDate);
return(Ok(new {
header = new
{
status_code = 200,
status_message = "OK"
},
body = new
{
message = "Order has been succesfully added",
references
}
}));
}
public OrderCustomerNameChanged(OrderIdentifier orderIdentifier, string customerName)
{
OrderIdentifier = orderIdentifier;
CustomerName = customerName;
}
public OrderLineRemoved(OrderIdentifier orderIdentifier, OrderLineIdentifier orderLineIdentifier)
{
OrderIdentifier = orderIdentifier;
OrderLineIdentifier = orderLineIdentifier;
}
