public OrderProductResult ManageOrderVendorProduct(MarketplaceOrderItem orderItem)
{
var orderProducts = new List <orderproduct>();
var vendorProducts = new List <vendorproduct>();
var shadowProduct = new shadow();
OrderProductResult result;
using (var context = new EisInventoryContext())
{
// let's get all its vendor products via its links
vendorProducts = context.vendorproductlinks
.Where(x => x.EisSKU == orderItem.SKU && x.IsActive)
.Select(x => x.vendorproduct)
.ToList();
// let's determine if this product is a shadow sku; WHY NOT USE THE SKUType of product? O.o
shadowProduct = context.shadows.FirstOrDefault(x => x.ShadowSKU == orderItem.SKU && x.IsConnected);
}
if (shadowProduct != null)
{
// let's take out the compatible vendor products that has available stock and sort by price asc
var compatibleVendorProducts = vendorProducts
.Where(x => x.Quantity > 0 && (shadowProduct.FactorQuantity % x.MinPack) == 0)
.OrderBy(x => x.SupplierPrice)
.ToList();
// iterate and determine the qualified vendor products
orderProducts = createOrderProducts(compatibleVendorProducts, orderItem.OrderItemId, orderItem.QtyOrdered, shadowProduct.FactorQuantity);
result = new OrderProductResult {
ItemPack = shadowProduct.FactorQuantity
};
}
else
{
// let's take out the compatible vendor products that has available stock and sort by price asc
var compatibleVendorProducts = vendorProducts
.Where(x => x.Quantity > 0 && x.MinPack == 1)
.OrderBy(x => x.SupplierPrice)
.ToList();
// iterate and determine the qualified vendor products
orderProducts = createOrderProducts(compatibleVendorProducts, orderItem.OrderItemId, orderItem.QtyOrdered, 1);
result = new OrderProductResult {
ItemPack = 1
};
}
// save the order products to the database
addOrderProducts(orderProducts);
// update the vendor product's quantity
UpdateVendorProductInventory(orderProducts, false);
result.OrderProducts = Mapper.Map <List <OrderProduct> >(orderProducts);
result.OrderItem = orderItem;
return(result);
}
public bool ReturnVendorProductInventory(MarketplaceOrderItem orderItem)
{
var orderProducts = new List <orderproduct>();
using (var context = new EisInventoryContext())
{
// get the order products assigned for this order item
orderProducts = context.orderproducts
.Where(x => x.OrderItemId == orderItem.OrderItemId)
.ToList();
}
// return back the vendor product inventory
return(_service.UpdateVendorProductInventory(orderProducts, true));
}
public void CreateOrderItemUpdateHistory(MarketplaceOrderItem orderItem, OrderStatus orderStatus, DateTime purchaseDate)
{
using (var context = new EisInventoryContext())
{
context.orderupdatehistories.Add(new orderupdatehistory
{
OrderItemId = orderItem.OrderItemId,
QtyOrdered = orderItem.QtyOrdered,
OrderStatus = orderStatus,
PurchaseDate = purchaseDate,
ResultDate = DateTime.UtcNow
});
// save changes
context.SaveChanges();
}
}
public void Should_Get_ShadowProduct_In_ManageOrderVendorProduct()
{
// arrange
var orderItem = new MarketplaceOrderItem
{
SKU = "BS1001221_6",
OrderItemId = "55981003740466",
OrderId = "01000012",
Title = "Scotchgard Scotch Gard Fabric Protector 14 Oz",
QtyOrdered = 1
};
var factorQty = 6;
var totalItemsRequired = orderItem.QtyOrdered * factorQty;
var service = new OrderService(new LogService());
// act
var result = service.ManageOrderVendorProduct(orderItem);
// assert
Assert.NotNull(result);
Assert.Equal(totalItemsRequired, result.TotalAvailableItems);
}
/// <summary>
/// Converts the response object into MarketplaceOrderItem object.
/// </summary>
/// <param name="orderorderItem">The given BigCommerce order product object.</param>
/// <returns>A MarketplaceOrderItem object</returns>
private MarketplaceOrderItem convertOrderItemResponseToMarketplaceOrderItem(BigCommerce4Net.Domain.OrdersProduct orderItem)
{
var marketplaceOrderItem = new MarketplaceOrderItem()
{
OrderId = orderItem.OrderId.ToString(),
MarketplaceItemId = orderItem.ProductId.ToString(),
OrderItemId = orderItem.Id.ToString(),
SKU = orderItem.Sku,
Title = orderItem.ProductName,
QtyOrdered = Convert.ToInt32(orderItem.Quantity),
QtyShipped = Convert.ToInt32(orderItem.QuantityShipped)
};
marketplaceOrderItem.Price = orderItem.BasePrice;
marketplaceOrderItem.ShippingPrice = orderItem.FixedShippingCost;
marketplaceOrderItem.GiftWrapPrice = orderItem.BaseWrappingCost;
marketplaceOrderItem.Tax = orderItem.PriceTax;
marketplaceOrderItem.GiftWrapTax = orderItem.WrappingCostTax;
//marketplaceOrderItem.ShippingDiscount = orderItem.;
marketplaceOrderItem.PromotionDiscount = orderItem.DiscountAmount;
return(marketplaceOrderItem);
}
public void Should_Update_Vendor_Product_Inventory()
{
// prepare
var orderItem = new MarketplaceOrderItem
{
SKU = "MI65155370_4",
OrderItemId = "00226200885258",
QtyOrdered = 2
};
var order = new MarketplaceOrder {
OrderItems = new List <MarketplaceOrderItem> {
orderItem
},
OrderStatus = OrderStatus.Canceled,
PurchaseDate = new DateTime(2016, 12, 26, 5, 48, 36) // 2016-12-26 05:48:36
};
var manager = new ProductInventoryManager();
// act
manager.UpdateOrderVendorProductInventory(new List <MarketplaceOrder> {
order
});
}
private MarketplaceOrder parsedMarketplaceOrder(OrderType orderType)
{
var order = new MarketplaceOrder();
order.SellerOrderId = orderType.OrderID; // eBay OrderId is the SalesRecordNumber
order.Marketplace = ChannelName;
order.OrderTotal = (decimal)orderType.Total.Value;
order.NumOfItemsShipped = 0; // let's init to 0 and reevaluate the actual value in transaction
//NumOfItemsUnshipped =1,
order.OrderStatus = parseOrderStatus(orderType.OrderStatus);
order.PurchaseDate = orderType.CreatedTime;
order.LastUpdateDate = orderType.PaidTime;
// get the shipping details
var address = orderType.ShippingAddress;
if (address != null)
{
order.ShippingAddressPhone = address.Phone;
order.ShippingAddressName = address.Name;
order.ShippingAddressLine1 = address.Street1;
order.ShippingAddressLine2 = address.Street2;
order.ShippingAddressLine3 = address.Street; // this is correct
order.ShippingCity = address.CityName;
order.ShippingStateOrRegion = address.StateOrProvince;
order.ShippingPostalCode = address.PostalCode;
}
// get th min and max of shipping date and shipping details
if (orderType.ShippingDetails != null && orderType.ShippingDetails.ShippingServiceOptions != null)
{
// get the sales record number which is the OrderId in our database for eBay
order.OrderId = orderType.ShippingDetails.SellingManagerSalesRecordNumber.ToString();
var shippingOption = orderType.ShippingDetails.ShippingServiceOptions;
var createdDate = orderType.CreatedTime;
order.EarliestShipDate = createdDate.AddDays(shippingOption[0].ShippingTimeMin);
order.LatestShipDate = createdDate.AddDays(shippingOption[0].ShippingTimeMax);
// set the order shipping service
order.ShipServiceLevel = shippingOption[0].ShippingService;
order.ShipmentServiceCategory = shippingOption[0].ShippingServicePriority.ToString();
}
// set the order's payment method used
if (orderType.CheckoutStatus.PaymentMethodSpecified)
{
order.PaymentMethod = orderType.CheckoutStatus.PaymentMethod.ToString();
}
// get the order transactions
var orderItems = new List <MarketplaceOrderItem>();
var orderTransactions = orderType.TransactionArray;
foreach (TransactionType tran in orderTransactions)
{
var orderItem = new MarketplaceOrderItem
{
OrderId = order.OrderId,
MarketplaceItemId = tran.Item.ItemID,
OrderItemId = tran.TransactionID,
SKU = tran.Item.SKU,
Title = tran.Item.Title,
QtyOrdered = tran.QuantityPurchased,
ConditionNote = tran.Item.ConditionDisplayName
};
// if the shipped time specified means it's already shipped?
if (orderType.ShippedTimeSpecified)
{
orderItem.QtyShipped = tran.QuantityPurchased;
order.NumOfItemsShipped += orderItem.QtyShipped;
}
orderItem.Price = (decimal)tran.TransactionPrice.Value;
orderItem.ShippingPrice = (decimal)tran.ActualShippingCost.Value;
orderItem.GiftWrapPrice = (decimal)tran.ActualHandlingCost.Value;
orderItem.Tax = (decimal)tran.Taxes.TotalTaxAmount.Value;
//orderItem.ShippingTax = orderItem.IsSetShippingTax() ? decimal.Parse(orderItem.ShippingTax.Amount) : 0;
//orderItem.GiftWrapTax = orderItem.IsSetGiftWrapTax() ? decimal.Parse(orderItem.GiftWrapTax.Amount) : 0;
//orderItem.ShippingDiscount = orderItem.IsSetShippingDiscount() ? decimal.Parse(orderItem.ShippingDiscount.Amount) : 0;
//orderItem.PromotionDiscount = orderItem.IsSetPromotionDiscount() ? decimal.Parse(orderItem.PromotionDiscount.Amount) : 0;
orderItems.Add(orderItem);
// set the order's buyer information
order.BuyerName = string.Format("{0} {1}", tran.Buyer.UserFirstName, tran.Buyer.UserLastName);
order.BuyerEmail = tran.Buyer.Email;
order.MarketplaceId = tran.TransactionSiteID.ToString();
order.SalesChannel = tran.Platform.ToString();
}
// get the adjustment and also the payment or refund payment
order.AmountPaid = (decimal)orderType.AmountPaid.Value;
order.AdjustmentAmount = (decimal)orderType.AdjustmentAmount.Value;
foreach (ExternalTransactionType extTran in orderType.ExternalTransaction)
{
order.PaymentOrRefundAmount += (decimal)extTran.PaymentOrRefundAmount.Value;
}
// set the order items for this order
order.OrderItems = orderItems;
return(order);
}
/// <summary>
/// Converts the response object into MarketplaceOrder object.
/// Also makes the call to get the items for the order.
/// </summary>
/// <param name="order">The given Amazon order objecdt.</param>
/// <returns>A MarketplaceOrder object</returns>
private MarketplaceOrder convertOrderResponseToMarketplaceOrder(MarketplaceWebServiceOrders.Model.Order order)
{
var orderStatus = (Inventory.Shared.Models.OrderStatus)Enum.Parse(typeof(Inventory.Shared.Models.OrderStatus), order.OrderStatus, true);
var marketplaceOrder = new MarketplaceOrder()
{
BuyerEmail = order.BuyerEmail,
BuyerName = order.BuyerName,
OrderTotal = order.IsSetOrderTotal() ? decimal.Parse(order.OrderTotal.Amount) : 0,
OrderId = order.AmazonOrderId,
Marketplace = ChannelName,
ShipServiceLevel = order.ShipServiceLevel,
ShipmentServiceCategory = order.ShipmentServiceLevelCategory,
NumOfItemsShipped = order.NumberOfItemsShipped,
NumOfItemsUnshipped = order.NumberOfItemsUnshipped,
PurchaseDate = order.PurchaseDate,
LastUpdateDate = order.LastUpdateDate,
PaymentMethod = order.PaymentMethod,
OrderStatus = orderStatus,
OrderType = order.OrderType,
EarliestShipDate = order.EarliestShipDate,
LatestShipDate = order.LatestShipDate,
EarliestDeliveryDate = order.EarliestDeliveryDate,
LatestDeliveryDate = order.LatestDeliveryDate,
MarketplaceId = order.MarketplaceId,
PurchaseOrderNumber = order.PurchaseOrderNumber,
SalesChannel = order.SalesChannel,
SellerOrderId = order.SellerOrderId,
};
if (order.IsSetShippingAddress())
{
marketplaceOrder.ShippingAddressLine1 = order.ShippingAddress.AddressLine1;
marketplaceOrder.ShippingAddressLine2 = order.ShippingAddress.AddressLine2;
marketplaceOrder.ShippingAddressLine3 = order.ShippingAddress.AddressLine3;
marketplaceOrder.ShippingCity = order.ShippingAddress.City;
marketplaceOrder.ShippingStateOrRegion = order.ShippingAddress.StateOrRegion;
marketplaceOrder.ShippingPostalCode = order.ShippingAddress.PostalCode;
marketplaceOrder.ShippingAddressName = order.ShippingAddress.Name;
marketplaceOrder.ShippingAddressPhone = order.ShippingAddress.Phone;
}
// do the request for the list of items for this order
var listOrderRequest = new ListOrderItemsRequest {
SellerId = _credential.MerchantId, AmazonOrderId = order.AmazonOrderId
};
var listItemsResponse = _ordersClient.ListOrderItems(listOrderRequest);
var nextToken = listItemsResponse.ListOrderItemsResult.NextToken;
var items = new List <MarketplaceOrderItem>();
ListOrderItemsByNextTokenResponse nextTokenResponse = null;
// convert the item responses to marketplace order item objects.
var orderItems = listItemsResponse.ListOrderItemsResult.OrderItems;
do
{
if (nextTokenResponse != null)
{
orderItems = nextTokenResponse.ListOrderItemsByNextTokenResult.OrderItems;
nextToken = nextTokenResponse.ListOrderItemsByNextTokenResult.NextToken;
}
// iterate and convert the marketplace order item into local object
for (var i = 0; i < orderItems.Count; i++)
{
var orderItem = orderItems[i];
var item = new MarketplaceOrderItem
{
OrderId = order.AmazonOrderId,
MarketplaceItemId = orderItem.ASIN,
OrderItemId = orderItem.OrderItemId,
SKU = orderItem.SellerSKU,
Title = orderItem.Title,
QtyOrdered = Convert.ToInt32(orderItem.QuantityOrdered),
QtyShipped = Convert.ToInt32(orderItem.QuantityShipped),
ConditionNote = orderItem.ConditionNote
};
item.Price = orderItem.IsSetItemPrice() ? decimal.Parse(orderItem.ItemPrice.Amount) : 0;
item.ShippingPrice = orderItem.IsSetShippingPrice() ? decimal.Parse(orderItem.ShippingPrice.Amount) : 0;
item.GiftWrapPrice = orderItem.IsSetGiftWrapPrice() ? decimal.Parse(orderItem.GiftWrapPrice.Amount) : 0;
item.Tax = orderItem.IsSetItemTax() ? decimal.Parse(orderItem.ItemTax.Amount) : 0;
item.ShippingTax = orderItem.IsSetShippingTax() ? decimal.Parse(orderItem.ShippingTax.Amount) : 0;
item.GiftWrapTax = orderItem.IsSetGiftWrapTax() ? decimal.Parse(orderItem.GiftWrapTax.Amount) : 0;
item.ShippingDiscount = orderItem.IsSetShippingDiscount() ? decimal.Parse(orderItem.ShippingDiscount.Amount) : 0;
item.PromotionDiscount = orderItem.IsSetPromotionDiscount() ? decimal.Parse(orderItem.PromotionDiscount.Amount) : 0;
items.Add(item);
}
// get the page order items if the next token not null
if (!string.IsNullOrWhiteSpace(nextToken))
{
// pause for 2 seconds, this is the restore reate for the ListOrderItemsByNextToken for every 30 quota
Thread.Sleep(2000);
var nextRequest = new ListOrderItemsByNextTokenRequest {
SellerId = _credential.MerchantId, NextToken = nextToken
};
nextTokenResponse = _ordersClient.ListOrderItemsByNextToken(nextRequest);
}
} while (!string.IsNullOrWhiteSpace(nextToken));
// set the order items to the local object
marketplaceOrder.OrderItems = items;
return(marketplaceOrder);
}
/// <summary>
/// Insert new record or update for order item into database
/// </summary>
/// <param name="item">The record of order item to save to database</param>
public void DoInsertOrUpdateOrderItem(MarketplaceOrderItem item)
{
try
{
using (var context = new EisInventoryContext())
{
// check if there is existing order item
var orderItem = context.orderitems
.FirstOrDefault(x => x.OrderItemId == item.OrderItemId && x.OrderId == item.OrderId);
if (orderItem == null)
{
context.orderitems.Add(new orderitem
{
OrderItemId = item.OrderItemId,
OrderId = item.OrderId,
ItemId = item.MarketplaceItemId,
SKU = item.SKU,
Title = item.Title,
QtyOrdered = item.QtyOrdered,
QtyShipped = item.QtyShipped,
Price = item.Price,
ShippingPrice = item.ShippingPrice,
GiftWrapPrice = item.GiftWrapPrice,
ItemTax = item.Tax,
ShippingTax = item.ShippingTax,
GiftWrapTax = item.GiftWrapTax,
ShippingDiscount = item.ShippingDiscount,
PromotionDiscount = item.PromotionDiscount,
ConditionNote = item.ConditionNote,
});
}
else
{
orderItem.ItemId = item.MarketplaceItemId;
orderItem.SKU = item.SKU;
orderItem.Title = item.Title;
orderItem.QtyOrdered = item.QtyOrdered;
orderItem.QtyShipped = item.QtyShipped;
orderItem.Price = item.Price;
orderItem.ShippingPrice = item.ShippingPrice;
orderItem.GiftWrapPrice = item.GiftWrapPrice;
orderItem.ItemTax = item.Tax;
orderItem.ShippingTax = item.ShippingTax;
orderItem.GiftWrapTax = item.GiftWrapTax;
orderItem.ShippingDiscount = item.ShippingDiscount;
orderItem.PromotionDiscount = item.PromotionDiscount;
orderItem.ConditionNote = item.ConditionNote;
}
// save the changes
context.SaveChanges();
}
}
catch (Exception ex)
{
Console.Error.WriteLine("Error occured on order item id: {0} \nError Message: {1} \n{2} ", item.OrderItemId, ex.Message, ex.StackTrace);
_logger.LogError(LogEntryType.OrderService,
string.Format("Error occured in inserting or creating order item {0} and order id {1} to DB <br/>Error message: {2}",
item.OrderItemId,
item.OrderId,
EisHelper.GetExceptionMessage(ex)),
ex.StackTrace);
}
}
