public async Task <ActionResult> SendOrderPaymentRequest([FromRoute] Guid orderGuid)
{
// get the exploded order w/ the line items
var dbOrderExploded = await _dbContext.GetOrderExplodedAsync(orderGuid);
// if we did not find a matching order
if (dbOrderExploded == null)
{
return(NotFound($"OrderGuid: [{orderGuid}] not found"));
}
// Biz Logic: Cannot change the order if it has already been paid for.
if (dbOrderExploded.Status == Enums.ORDER_STATUS.Paid)
{
return(BadRequest(new ArgumentException($"You cannot send the Payment link AFTER the order is paid.", nameof(orderGuid))));
}
// Biz Logic: Cannot send SMS if there are no line items
if (dbOrderExploded.OrderLineItems == null || dbOrderExploded.OrderLineItems.Count == 0)
{
return(BadRequest(new ArgumentException($"You cannot send the Payment link if the order does not have any line items", nameof(orderGuid))));
}
await SendSMSMessageAsync(dbOrderExploded, _webUrlConfig);
// only create the demo customer orders if this order was itself NOT a demo customer order
// this allows the SMS for a specific demo customer order to be resent
if (!dbOrderExploded.RefOrderId.HasValue)
{
var dbDemoCustomersOrders = await _dbContext.GetOrdersViaRefOrderIdAsync(dbOrderExploded.OrderId);
// Step 4:1 Get the merchant's demo customers
var dbDemoCustomers = await _dbContext.GetDemoCustomersAsync(dbOrderExploded.MerchantId);
// Step 4:2 Loop for each demo customer
foreach (var dbDemoCustomer in dbDemoCustomers)
{
var matchingOrder = dbDemoCustomersOrders.FirstOrDefault(dco => dco.PhoneNumber == dbDemoCustomer.CustomerPhoneNo);
if (matchingOrder != null)
{
continue; // skip if demo order is already created, can happen if we resend sms on the "main" order
}
// create the exploded order
var newDemoCustomerOrderExploded = new NewOrderMBE()
{
CustomerName = dbDemoCustomer.CustomerName,
CustomerPhoneNo = dbDemoCustomer.CustomerPhoneNo,
OrderLineItems = dbOrderExploded.OrderLineItems.ConvertAll(oli => (NewOrderLineItemMBE)oli)
};
// insert the order
var dbDemoCustomerExplodedOrder = await InsertNewExplodedOrderAsync(dbOrderExploded.MerchantId, newDemoCustomerOrderExploded, dbOrderExploded.OrderId);
// send sms message to demo customer
await SendSMSMessageAsync(dbDemoCustomerExplodedOrder, _webUrlConfig);
}
}
return(NoContent());
}
public async Task <ActionResult> UpdateOrder(Guid orderGuid, [FromBody] NewOrderMBE updatedOrder)
{
if (orderGuid != GeneralConstants.ORDER_1_GUID)
{
return(NotFound($"Merchant order with ID: {orderGuid} not found"));
}
await Task.Delay(100);
return(NoContent());
}
public async Task <ActionResult <MerchantOrderMBE> > CreateOrder([FromBody] NewOrderMBE newOrder)
{
//trims customer name so that it doesn't have trailing characters
newOrder.CustomerName = newOrder.CustomerName.Trim();
#region === Validation =================================================
// validate request data
if (string.IsNullOrEmpty(newOrder.CustomerName))
{
return(BadRequest(new ArgumentNullException(@"You must supply a non blank value for the Order Name.", nameof(newOrder.CustomerName))));
}
else if (string.IsNullOrEmpty(newOrder.CustomerPhoneNo))
{
return(BadRequest(new ArgumentNullException(@"You must supply a non blank value for the Order Phone No.", nameof(newOrder.CustomerPhoneNo))));
}
foreach (var orderLineItem in newOrder.OrderLineItems)
{
var catalogItem = await _dbContext.GetCatalogItemAsync(orderLineItem.ItemGuid);
if (catalogItem == null)
{
return(BadRequest(new ArgumentNullException($"Error : [{orderLineItem.ItemGuid}] Is not a valid catalog item guid.", nameof(orderLineItem.ItemGuid))));
}
}
(bool isValidPhoneNo, string formatedPhoneNo, string normalizedPhoneNo) = Utilities.PhoneNoHelpers.NormalizePhoneNo(newOrder.CustomerPhoneNo);
if (!isValidPhoneNo)
{
return(BadRequest(new ArgumentNullException($"[{newOrder.CustomerPhoneNo}] is NOT a supported Phone No format.", nameof(newOrder.CustomerPhoneNo))));
}
else
{
newOrder.CustomerPhoneNo = formatedPhoneNo;
}
#endregion
//query the db for the active merchant
var dbActiveMerchant = await _dbContext.GetActiveMerchantAsync();
try
{
// insert the order
var dbExplodedOrder = await InsertNewExplodedOrderAsync(dbActiveMerchant.MerchantId, newOrder);
// convert to MBE
var explodedOrder = BuildExplodedMerchantOrderMBE(dbExplodedOrder);
// return the response
return(CreatedAtAction(nameof(GetOrder), new { orderGuid = explodedOrder.OrderGuid }, explodedOrder));
}
catch (Exception ex)
{
return(BadRequest(new ApplicationException($"Error: [{ex.Message}] Failed trying to create merchant order.")));
}
}
private async Task <OrderDBE> InsertNewExplodedOrderAsync(int merchantId, NewOrderMBE newExplodedOrder, int?refOrderId = null)
{
//Step 1: Store the new merchant Order
var newDBOrder = new OrderDBE()
{
Status = Enums.ORDER_STATUS.New,
MerchantId = merchantId,
CustomerName = newExplodedOrder.CustomerName,
PhoneNumber = newExplodedOrder.CustomerPhoneNo,
OrderDateTimeUTC = DateTime.UtcNow,
RefOrderId = refOrderId
};
await _dbContext.InsertOrderAsync(newDBOrder);
//Step 2: create the first event
var newDBOrderEvent = new OrderEventDBE()
{
OrderId = newDBOrder.OrderId,
EventDateTimeUTC = DateTime.UtcNow,
OrderStatus = Enums.ORDER_STATUS.New,
EventDescription = refOrderId.HasValue ? $"Order created (from {refOrderId.Value})." : "Order created"
};
await _dbContext.InsertOrderEventAsync(newDBOrderEvent);
//newDBOrder.OrderEvents.Add(newDBOrderEvent); // build exploded order
//Step 3: iterate through orderLineItems collection to save it in the db
foreach (var orderLineItem in newExplodedOrder.OrderLineItems)
{
var catalogItem = await _dbContext.GetCatalogItemAsync(orderLineItem.ItemGuid);
var newDBOrderLineItem = new OrderLineItemDBE()
{
ItemName = catalogItem.ItemName,
ItemUnitPrice = catalogItem.ItemUnitPrice,
OrderId = newDBOrder.OrderId,
CatalogItemGuid = orderLineItem.ItemGuid
};
await _dbContext.InsertOrderLineItemAsync(newDBOrderLineItem);
//newDBOrder.OrderLineItems.Add(newDBOrderLineItem); // build exploded order
}
return(newDBOrder);
}
public async Task <ActionResult <MerchantOrderMBE> > CreateOrder([FromBody] NewOrderMBE newOrder)
{
var order = new MerchantOrderMBE
{
OrderGuid = GeneralConstants.ORDER_1_GUID,
OrderId = 1234,
MerchantGuid = GeneralConstants.MERCHANT_1_GUID,
Name = "Joe Smith",
PhoneNumber = "(333) 333-3333",
OrderStatus = Enums.ORDER_STATUS.New,
OrderLineItems = new List <CatalogItemMBE>
{
new CatalogItemMBE
{
ItemGuid = Guid.NewGuid()
},
new CatalogItemMBE
{
ItemGuid = Guid.NewGuid()
}
},
OrderEvents = new List <OrderEventMBE>
{
new OrderEventMBE
{
EventDateTimeUTC = new DateTime(20, 11, 11, 07, 58, 00),
OrderStatus = Enums.ORDER_STATUS.New,
EventDescription = "A new order has been created."
}
}
};
await Task.Delay(100);
return(CreatedAtAction(nameof(GetOrder), new { orderID = order.OrderGuid }, order));
}
public async Task <ActionResult> UpdateOrder([FromRoute] Guid orderGuid, [FromBody] NewOrderMBE updatedOrder)
{
// get the existing order
var dbOrder = await _dbContext.GetOrderAsync(orderGuid);
// if we did not find a matching order
if (dbOrder == null)
{
return(BadRequest(new ArgumentException($"OrderGuid: [{orderGuid}] not found", nameof(orderGuid))));
}
// Biz Logic: Cannot change the order if it has already been paid for.
if (dbOrder.Status == Enums.ORDER_STATUS.SMS_Sent || dbOrder.Status == Enums.ORDER_STATUS.Paid)
{
return(BadRequest(new ArgumentException($"Changes are not allowed after the SMS has been sent or the order has been paid", nameof(orderGuid))));
}
#region === Validation =================================================
// validate the input params
if (string.IsNullOrEmpty(updatedOrder.CustomerName))
{
return(BadRequest(new ArgumentException(@"The order name cannot be blank.", nameof(updatedOrder.CustomerName))));
}
else if (string.IsNullOrEmpty(updatedOrder.CustomerPhoneNo))
{
return(BadRequest(new ArgumentException(@"The order phone number cannot be blank.", nameof(updatedOrder.CustomerPhoneNo))));
}
(bool isValidPhoneNo, string formatedPhoneNo, _) = PhoneNoHelpers.NormalizePhoneNo(updatedOrder.CustomerPhoneNo);
if (!isValidPhoneNo)
{
return(BadRequest(new ArgumentNullException(nameof(updatedOrder.CustomerPhoneNo), $"[{updatedOrder.CustomerPhoneNo}] is NOT a supported Phone No format.")));
}
else
{
updatedOrder.CustomerPhoneNo = formatedPhoneNo;
}
// validate the catalog guids
foreach (var orderLineItem in updatedOrder.OrderLineItems)
{
// try to find the catalog item
var catalogItem = await _dbContext.GetCatalogItemAsync(orderLineItem.ItemGuid);
// if it did not exist (ie: a invalid guid)
if (catalogItem == null)
{
return(BadRequest(new ArgumentNullException(nameof(orderLineItem.ItemGuid), $"Error : [{orderLineItem.ItemGuid}] Is not a valid catalog item guid.")));
}
}
#endregion
try
{
// Step 1: update the dbOrder with the values we just got
dbOrder.CustomerName = updatedOrder.CustomerName;
dbOrder.PhoneNumber = updatedOrder.CustomerPhoneNo;
dbOrder.Status = Enums.ORDER_STATUS.Updated;
await _dbContext.UpdateOrderAsync(dbOrder);
// Step 2: in this demo code we are just going to delete and re-add the order line items
await _dbContext.DeleteOrderLineItemsAsync(dbOrder.OrderId);
//iterate through orderLineItems collection to save it in the db
foreach (var orderLineItem in updatedOrder.OrderLineItems)
{
var catalogItem = await _dbContext.GetCatalogItemAsync(orderLineItem.ItemGuid);
var dbOrderLineItem = new OrderLineItemDBE()
{
ItemName = catalogItem.ItemName,
ItemUnitPrice = catalogItem.ItemUnitPrice,
OrderId = dbOrder.OrderId,
CatalogItemGuid = orderLineItem.ItemGuid
};
await _dbContext.InsertOrderLineItemAsync(dbOrderLineItem);
}
// Step 3: create an event
var dbOrderEvent = new OrderEventDBE()
{
OrderId = dbOrder.OrderId,
EventDateTimeUTC = DateTime.UtcNow,
OrderStatus = Enums.ORDER_STATUS.Updated,
EventDescription = "Order updated."
};
//save order event
await _dbContext.InsertOrderEventAsync(dbOrderEvent);
return(NoContent());
}
catch (Exception ex)
{
return(BadRequest(new ApplicationException($"Error: [{ex.Message}] Failed to update merchant order.")));
}
}
