public AmazonLog Add(AmazonLogType type, AmazonLogStatus status, Exception elmahError, MarketplaceWebService.Model.Error amazonError,
AmazonApiSection? apiSection, string apiOperation, AmazonOrder amazonOrder, AmazonListing amazonListing, AmazonListingGroup amazonListingGroup,
string message = "", string details = "")
{
var log = new AmazonLog
{
LogType = type,
LogStatus = status,
AmazonOrder = amazonOrder,
ApiSection = apiSection,
ApiOperation = !String.IsNullOrWhiteSpace(apiOperation) ? apiOperation : null,
AmazonListing = amazonListing,
AmazonListingGroup = amazonListingGroup,
Message = !String.IsNullOrWhiteSpace(message) ? message : null,
Detail = !String.IsNullOrWhiteSpace(details) ? details : null,
Site = CurrentRequestData.CurrentSite
};
log.SetGuid(Guid.NewGuid());
if (elmahError != null)
{
log.Message = elmahError.Message;
log.Detail = elmahError.StackTrace;
}
if (amazonError != null)
{
log.ErrorCode = amazonError.Code;
log.ErrorType = amazonError.Type;
log.Message = amazonError.Message;
log.Detail = amazonError.Detail.ToString();
}
return Save(log);
}
public void Delete(AmazonOrder item)
{
_amazonLogService.Add(AmazonLogType.Orders, AmazonLogStatus.Delete,
null, null, null, null, item, null, null, "Amazon Order #" + item.AmazonOrderId);
_session.Transact(session => session.Delete(item));
}
public void SaveOrUpdate(AmazonOrder amazonOrder)
{
var orderId = amazonOrder.AmazonOrderId;
var id = amazonOrder.Id;
_session.Transact(session => session.SaveOrUpdate(amazonOrder));
_amazonLogService.Add(AmazonLogType.Orders, id>0?AmazonLogStatus.Update:AmazonLogStatus.Insert,
null, null, null, null, amazonOrder, null, null,"Amazon Order #"+orderId);
}
public AmazonOrder SetAmazonOrderItems(IEnumerable<OrderItem> rawOrderItems, AmazonOrder amazonOrder)
{
foreach (var rawOrderItem in rawOrderItems)
_validateAmazonOrderService.SetAmazonOrderItem(ref amazonOrder, rawOrderItem);
amazonOrder.Order = _validateAmazonOrderService.GetOrder(amazonOrder);
return amazonOrder;
}
public bool Update(AmazonOrder amazonOrder, Order order)
{
if (amazonOrder.Status == AmazonOrderStatus.Unshipped)
{
var shippingAddress = _validateAmazonOrderService.GetAmazonOrderAddress(order);
_validateAmazonOrderService.SetShippingAddress(amazonOrder, shippingAddress);
}
return true;
}
public void AmazonOrderService_GetByAmazonOrderId_ShouldReturnPersistedEntryFromSession()
{
var item = new AmazonOrder() { AmazonOrderId = "T1" };
Session.Transact(session => session.Save(item));
var results = _amazonOrderService.GetByAmazonOrderId("T1");
results.As<AmazonOrder>().Id.Should().Be(1);
}
public void AmazonOrderService_Update_ShouldUpdateInSession()
{
var item = new AmazonOrder();
Session.Transact(session => session.Save(item));
item.BuyerName = "T1";
_amazonOrderService.Update(item);
Session.Evict(item);
Session.Get<AmazonOrder>(1).BuyerName.Should().Be("T1");
}
public bool Update(AmazonOrder amazonOrder, Order order)
{
if (amazonOrder.Status == AmazonOrderStatus.Unshipped && order.OrderStatus == OrderStatusEnum.Canceled)
{
amazonOrder.Status = AmazonOrderStatus.Canceled;
_amazonOrderService.Update(amazonOrder);
_orderService.Cancel(amazonOrder.Order);
}
return true;
}
public void AmazonOrderService_Update_ShouldCallAddLog()
{
var item = new AmazonOrder(){AmazonOrderId = "1"};
Session.Transact(session => session.Save(item));
_amazonOrderService.Update(item);
A.CallTo(() => _amazonLogService.Add(AmazonLogType.Orders, AmazonLogStatus.Update,
null, null, null, null, item, null, null,
"Amazon Order #" + item.AmazonOrderId,string.Empty)
).MustHaveHappened();
}
public bool Update(AmazonOrder amazonOrder, Order order)
{
if (amazonOrder.Id == 0 || (amazonOrder.Status != AmazonOrderStatus.Shipped &&
amazonOrder.Status != AmazonOrderStatus.Canceled))
{
var shippingAddress = _validateAmazonOrderService.GetAmazonOrderAddress(order);
_validateAmazonOrderService.GetAmazonOrderDetails(order, ref amazonOrder, shippingAddress);
}
amazonOrder.NumberOfItemsShipped = order.NumberOfItemsShipped;
amazonOrder.Status = order.OrderStatus.GetEnumByValue<AmazonOrderStatus>();
return true;
}
public void SetAmazonOrderItem(ref AmazonOrder amazonOrder, OrderItem rawOrderItem)
{
AmazonOrderItem item =
amazonOrder.Items.SingleOrDefault(x => x.AmazonOrderItemId == rawOrderItem.OrderItemId);
if (item != null)
item.QuantityShipped = rawOrderItem.QuantityShipped;
else
{
AmazonOrderItem orderItem = GetAmazonOrderItem(amazonOrder, rawOrderItem);
amazonOrder.Items.Add(orderItem);
}
}
public void AmazonOrder_ShippingAmount_ShouldBeSumOfShippingPriceAmount()
{
var item1 = A.Fake<AmazonOrderItem>();
var item2 = A.Fake<AmazonOrderItem>();
A.CallTo(() => item1.ShippingPriceAmount).Returns(10);
A.CallTo(() => item2.ShippingPriceAmount).Returns(20);
var amazonOrder = new AmazonOrder()
{
Items = new List<AmazonOrderItem> { item1, item2 }
};
var result = amazonOrder.ShippingAmount;
result.Should().Be(30);
}
public void AmazonOrder_ItemTax_ShouldBeSumOfItemTaxAmount()
{
var item1 = A.Fake<AmazonOrderItem>();
var item2 = A.Fake<AmazonOrderItem>();
A.CallTo(() => item1.ItemTaxAmount).Returns(10);
A.CallTo(() => item2.ItemTaxAmount).Returns(20);
var amazonOrder = new AmazonOrder()
{
Items = new List<AmazonOrderItem> { item1, item2 }
};
var result = amazonOrder.ItemTax;
result.Should().Be(30);
}
private bool ProcessOrder(Order order, ref AmazonOrder amazonOrder, bool newOrder)
{
foreach (var update in _amazonUpdates.OrderBy(updates => updates.Order))
{
if (!update.Update(amazonOrder, order))
return false;
}
_amazonOrderService.SaveOrUpdate(amazonOrder);
if (newOrder)
foreach (var orderPlaced in _onAmazonOrderPlaceds)
orderPlaced.OnAmazonOrderPlaced(amazonOrder);
return true;
}
public bool Update(AmazonOrder amazonOrder, Order order)
{
if (amazonOrder.Items.Any())
return true;
try
{
var orderItems = _amazonOrdersApiService.ListOrderItems(amazonOrder.AmazonOrderId);
_importAmazonOrderService.SetAmazonOrderItems(orderItems, amazonOrder);
return true;
}
catch (Exception exception)
{
CurrentRequestData.ErrorSignal.Raise(exception);
return false;
}
}
public void GetAmazonOrderDetails(Order rawOrder, ref AmazonOrder order, AddressData shippingAddress)
{
order.AmazonOrderId = !String.IsNullOrWhiteSpace(rawOrder.AmazonOrderId)
? rawOrder.AmazonOrderId
: String.Empty;
order.BuyerEmail = !String.IsNullOrWhiteSpace(rawOrder.BuyerEmail) ? rawOrder.BuyerEmail : String.Empty;
order.BuyerName = !String.IsNullOrWhiteSpace(rawOrder.BuyerName) ? rawOrder.BuyerName : String.Empty;
order.PurchaseDate = TimeZoneInfo.ConvertTime(rawOrder.PurchaseDate, TimeZoneInfo.Utc,
CurrentRequestData.TimeZoneInfo);
order.PaymentMethod = rawOrder.PaymentMethod.GetEnumByValue<AmazonPaymentMethod>();
order.SalesChannel = !String.IsNullOrWhiteSpace(rawOrder.SalesChannel)
? rawOrder.SalesChannel
: String.Empty;
order.OrderType = !String.IsNullOrWhiteSpace(rawOrder.OrderType) ? rawOrder.OrderType : String.Empty;
order.OrderTotalAmount = (rawOrder.OrderTotal != null && rawOrder.OrderTotal.Amount != null)
? Decimal.Parse(rawOrder.OrderTotal.Amount, (new CultureInfo("en-GB", false)))
: 0;
order.OrderCurrency = (rawOrder.OrderTotal != null && rawOrder.OrderTotal.Amount != null)
? rawOrder.OrderTotal.CurrencyCode
: String.Empty;
order.MarketplaceId = !String.IsNullOrWhiteSpace(rawOrder.MarketplaceId)
? rawOrder.MarketplaceId
: String.Empty;
order.ShipServiceLevel = !String.IsNullOrWhiteSpace(rawOrder.ShipServiceLevel)
? rawOrder.ShipServiceLevel
: String.Empty;
order.ShipmentServiceLevelCategory = !String.IsNullOrWhiteSpace(rawOrder.ShipmentServiceLevelCategory)
? rawOrder.ShipmentServiceLevelCategory
: String.Empty;
SetShippingAddress(order, shippingAddress);
order.NumberOfItemsUnshipped = rawOrder.NumberOfItemsUnshipped;
order.NumberOfItemsShipped = rawOrder.NumberOfItemsShipped;
order.FulfillmentChannel = rawOrder.FulfillmentChannel.GetEnumByValue<AmazonFulfillmentChannel>();
order.LastUpdatedDate = TimeZoneInfo.ConvertTime(rawOrder.LastUpdateDate, TimeZoneInfo.Utc,
CurrentRequestData.TimeZoneInfo);
}
public void MarkAsShipped(AmazonOrder amazonOrder)
{
amazonOrder.Status = AmazonOrderStatus.Shipped;
SaveOrUpdate(amazonOrder);
}
private Ecommerce.Entities.Orders.Order GetOrderDetails(AmazonOrder amazonOrder)
{
return new Ecommerce.Entities.Orders.Order
{
ShippingAddress = amazonOrder.ShippingAddress,
BillingAddress = amazonOrder.ShippingAddress,
PaymentMethod = amazonOrder.PaymentMethod.GetDescription(),
PaidDate = amazonOrder.PurchaseDate,
Total = amazonOrder.OrderTotalAmount,
TotalPaid = amazonOrder.OrderTotalAmount,
Subtotal = amazonOrder.ItemAmount,
DiscountAmount = amazonOrder.ItemDiscountAmount,
ShippingTax = amazonOrder.ShippingTax,
ShippingTotal = amazonOrder.ShippingTotal,
OrderEmail = amazonOrder.BuyerEmail,
IsCancelled = false,
SalesChannel = AmazonApp.SalesChannel,
PaymentStatus = PaymentStatus.Paid,
CreatedOn =
amazonOrder.PurchaseDate.HasValue ? (DateTime)amazonOrder.PurchaseDate : CurrentRequestData.Now
};
}
private void GetOrderLines(AmazonOrder amazonOrder, ref Ecommerce.Entities.Orders.Order order)
{
foreach (AmazonOrderItem amazonOrderItem in amazonOrder.Items)
{
var orderLine = new OrderLine
{
Order = order,
UnitPrice =
amazonOrderItem.QuantityOrdered > 0
? (amazonOrderItem.ItemPriceAmount / amazonOrderItem.QuantityOrdered)
: 0,
Price = amazonOrderItem.ItemPriceAmount,
Name = amazonOrderItem.Title,
Tax = amazonOrderItem.ItemTaxAmount,
Discount = amazonOrderItem.PromotionDiscountAmount,
Quantity = Decimal.ToInt32(amazonOrderItem.QuantityOrdered),
SKU = amazonOrderItem.SellerSKU
};
order.OrderLines.Add(orderLine);
_session.Transact(session => session.Save(orderLine));
}
}
public void AmazonOrder_ShippingTotal_ShouldBeSumOShippingAmountShippingTaxMinusShippingDiscountAmount()
{
var item1 = A.Fake<AmazonOrderItem>();
A.CallTo(() => item1.ShippingPriceAmount).Returns(10);
A.CallTo(() => item1.ShippingTaxAmount).Returns(10);
A.CallTo(() => item1.ShippingDiscountAmount).Returns(10);
var amazonOrder = new AmazonOrder()
{
Items = new List<AmazonOrderItem> { item1 }
};
var result = amazonOrder.ShippingTotal;
result.Should().Be(10);
}
public void AmazonOrder_Tax_ShouldBeSumOfItemTaxShippingTaxGiftWrapTax()
{
var item1 = A.Fake<AmazonOrderItem>();
A.CallTo(() => item1.ItemTaxAmount).Returns(10);
A.CallTo(() => item1.ShippingTaxAmount).Returns(10);
A.CallTo(() => item1.GiftWrapTaxAmount).Returns(10);
var amazonOrder = new AmazonOrder()
{
Items = new List<AmazonOrderItem> { item1 }
};
var result = amazonOrder.Tax;
result.Should().Be(30);
}
public FileStream GetOrderFulfillmentFeed(AmazonOrder order)
{
return _amazonGenerateFeedContentService.GetSingleFeed(_amazonGenerateFeedContentService.GetOrderFulfillment(order),
AmazonEnvelopeMessageType.OrderFulfillment, null);
}
private AmazonOrderItem GetAmazonOrderItem(AmazonOrder amazonOrder, OrderItem rawOrderItem)
{
Currency currency = _ecommerceSettings.Currency();
return new AmazonOrderItem
{
ASIN = !String.IsNullOrWhiteSpace(rawOrderItem.ASIN) ? rawOrderItem.ASIN : String.Empty,
AmazonOrder = amazonOrder,
AmazonOrderItemId =
!String.IsNullOrWhiteSpace(rawOrderItem.OrderItemId) ? rawOrderItem.OrderItemId : String.Empty,
Title = !String.IsNullOrWhiteSpace(rawOrderItem.Title) ? rawOrderItem.Title : String.Empty,
SellerSKU =
!String.IsNullOrWhiteSpace(rawOrderItem.SellerSKU) ? rawOrderItem.SellerSKU : String.Empty,
Condition =
!String.IsNullOrWhiteSpace(rawOrderItem.ConditionId)
? rawOrderItem.ConditionId.GetEnumByValue<AmazonListingCondition>()
: AmazonListingCondition.New,
ConditionSubtype =
!String.IsNullOrWhiteSpace(rawOrderItem.ConditionSubtypeId)
? rawOrderItem.ConditionSubtypeId.GetEnumByValue<AmazonListingCondition>()
: AmazonListingCondition.New,
GiftWrapPriceAmount =
(rawOrderItem.GiftWrapPrice != null && rawOrderItem.GiftWrapPrice.Amount != null)
? Decimal.Parse(rawOrderItem.GiftWrapPrice.Amount, new CultureInfo("en-GB", false))
: 0,
GiftWrapPriceCurrency =
(rawOrderItem.GiftWrapPrice != null && rawOrderItem.GiftWrapPrice.CurrencyCode != null)
? rawOrderItem.GiftWrapPrice.CurrencyCode
: currency.Code,
GiftWrapTaxAmount =
(rawOrderItem.GiftWrapTax != null && rawOrderItem.GiftWrapTax.Amount != null)
? Decimal.Parse(rawOrderItem.GiftWrapTax.Amount, new CultureInfo("en-GB", false))
: 0,
GiftWrapTaxCurrency =
(rawOrderItem.GiftWrapTax != null && rawOrderItem.GiftWrapTax.CurrencyCode != null)
? rawOrderItem.GiftWrapTax.CurrencyCode
: currency.Code,
ItemPriceAmount =
(rawOrderItem.ItemPrice != null && rawOrderItem.ItemPrice.Amount != null)
? Decimal.Parse(rawOrderItem.ItemPrice.Amount, new CultureInfo("en-GB", false))
: 0,
ItemPriceCurrency =
(rawOrderItem.ItemPrice != null && rawOrderItem.ItemPrice.CurrencyCode != null)
? rawOrderItem.ItemPrice.CurrencyCode
: currency.Code,
ItemTaxAmount =
(rawOrderItem.ItemTax != null && rawOrderItem.ItemTax.Amount != null)
? Decimal.Parse(rawOrderItem.ItemTax.Amount, new CultureInfo("en-GB", false))
: 0,
ItemTaxCurrency =
(rawOrderItem.ItemTax != null && rawOrderItem.ItemTax.CurrencyCode != null)
? rawOrderItem.ItemTax.CurrencyCode
: currency.Code,
PromotionDiscountAmount =
(rawOrderItem.PromotionDiscount != null && rawOrderItem.PromotionDiscount.Amount != null)
? Decimal.Parse(rawOrderItem.PromotionDiscount.Amount, new CultureInfo("en-GB", false))
: 0,
PromotionDiscountCurrency =
(rawOrderItem.PromotionDiscount != null && rawOrderItem.PromotionDiscount.CurrencyCode != null)
? rawOrderItem.PromotionDiscount.CurrencyCode
: currency.Code,
QuantityOrdered = rawOrderItem.QuantityOrdered,
QuantityShipped = rawOrderItem.QuantityShipped,
ShippingDiscountAmount =
(rawOrderItem.ShippingDiscount != null && rawOrderItem.ShippingDiscount.Amount != null)
? Decimal.Parse(rawOrderItem.ShippingDiscount.Amount, new CultureInfo("en-GB", false))
: 0,
ShippingDiscountCurrency =
(rawOrderItem.ShippingDiscount != null && rawOrderItem.ShippingDiscount.CurrencyCode != null)
? rawOrderItem.ShippingDiscount.CurrencyCode
: currency.Code,
ShippingPriceAmount =
(rawOrderItem.ShippingPrice != null && rawOrderItem.ShippingPrice.Amount != null)
? Decimal.Parse(rawOrderItem.ShippingPrice.Amount, new CultureInfo("en-GB", false))
: 0,
ShippingPriceCurrency =
(rawOrderItem.ShippingPrice != null && rawOrderItem.ShippingPrice.CurrencyCode != null)
? rawOrderItem.ShippingPrice.CurrencyCode
: currency.Code,
ShippingTaxAmount =
(rawOrderItem.ShippingTax != null && rawOrderItem.ShippingTax.Amount != null)
? Decimal.Parse(rawOrderItem.ShippingTax.Amount, new CultureInfo("en-GB", false))
: 0,
ShippingTaxCurrency =
(rawOrderItem.ShippingTax != null && rawOrderItem.ShippingTax.CurrencyCode != null)
? rawOrderItem.ShippingTax.CurrencyCode
: currency.Code,
};
}
public void SetShippingAddress(AmazonOrder amazonOrder, AddressData address)
{
amazonOrder.ShippingAddress = address;
}
public OrderFulfillment GetOrderFulfillment(AmazonOrder amazonOrder)
{
var orderFulfillment = new OrderFulfillment()
{
Item=amazonOrder.AmazonOrderId,
ItemElementName = ItemChoiceType2.AmazonOrderID,
FulfillmentData = new OrderFulfillmentFulfillmentData()
{
Item="Other",
ShippingMethod = "Standard"
},
Item1 = new OrderFulfillmentItemCollection()
};
orderFulfillment.FulfillmentDate = amazonOrder.Order.ShippingDate.HasValue ? amazonOrder.Order.ShippingDate.Value.ToUniversalTime().AddMinutes(-15) : DateTime.UtcNow.AddMinutes(-15); //-15 because server times differ
foreach (var amazonOrderItem in amazonOrder.Items)
{
var item = new OrderFulfillmentItem()
{
Item = amazonOrderItem.AmazonOrderItemId,
ItemElementName = ItemChoiceType3.AmazonOrderItemCode,
Quantity = decimal.ToInt32(amazonOrderItem.QuantityOrdered).ToString()
};
orderFulfillment.Item1.Add(item);
}
return orderFulfillment;
}
public void AmazonOrderService_Delete_ShouldRemoveItemFromTheSession()
{
var item = new AmazonOrder();
Session.Transact(session => session.Save(item));
_amazonOrderService.Delete(item);
Session.QueryOver<AmazonOrder>().RowCount().Should().Be(0);
}
public Ecommerce.Entities.Orders.Order GetOrder(AmazonOrder amazonOrder)
{
Ecommerce.Entities.Orders.Order order = amazonOrder.Order ?? new Ecommerce.Entities.Orders.Order();
if (order.Id == 0)
{
order = GetOrderDetails(amazonOrder);
Ecommerce.Entities.Orders.Order order1 = order;
_session.Transact(session => session.Save(order1));
GetOrderLines(amazonOrder, ref order);
_setTax.SetTax(ref order, amazonOrder.Tax);
}
order.ShippingStatus = amazonOrder.Status.GetEnumByValue<ShippingStatus>();
return order;
}
