private AmazonOrderItemDetailsList GetOrderItems(
AmazonSecurityInfo securityInfo,
ActionAccessType access,
AmazonOrderItem orderItem2,
ElapsedTimeInfo elapsedTimeInfo,
AmazonOrdersList orders,
int mpId
)
{
var itemsRequestInfo = new AmazonOrdersItemsRequestInfo {
MarketplaceId = securityInfo.MarketplaceId,
MerchantId = securityInfo.MerchantId,
OrderId = orderItem2.OrderId,
ErrorRetryingInfo = this.amazonSettings,
MWSAuthToken = securityInfo.MWSAuthToken
};
AmazonOrderItemDetailsList orderItems = ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
elapsedTimeInfo,
mpId,
ElapsedDataMemberType
.RetrieveDataFromExternalService,
() => AmazonServiceHelper.GetListItemsOrdered(this.connectionInfo, itemsRequestInfo, access, orders.RequestsCounter)
);
return(orderItems);
}
private void ParseOrdersStream(AmazonOrdersList orders, MemoryStream stream)
{
using (var sr = new StreamReader(stream)) {
// заголовок
var h = sr.ReadLine();
while (sr.Peek() >= 0)
{
var item = new AmazonOrderItem();
var str = sr.ReadLine();
var list = str.Split(new[] { '\t' });
item.OrderId = GetData(list, AmazonOrderDataEnum.OrderId);
item.LastUpdateDate = ConvertToDate(GetData(list, AmazonOrderDataEnum.PaymentsDate));
item.PurchaseDate = ConvertToDate(GetData(list, AmazonOrderDataEnum.PurchaseDate));
item.NumberOfItemsShipped = ConvertToInt(GetData(list, AmazonOrderDataEnum.QuantityPurchased));
item.OrderTotal = new AmountInfo {
Value = ConvertToDouble(GetData(list, AmazonOrderDataEnum.ItemPrice)),
CurrencyCode = GetData(list, AmazonOrderDataEnum.Currency)
};
item.OrderStatus = AmazonOrdersList2ItemStatusType.Shipped;
orders.Add(item);
}
}
}
private AmazonOrderItem ParseOrder(Order order)
{
var orderInfo = new AmazonOrderItem();
if (order.IsSetAmazonOrderId())
{
orderInfo.OrderId = order.AmazonOrderId;
}
if (order.IsSetSellerOrderId())
{
orderInfo.SellerOrderId = order.SellerOrderId;
}
if (order.IsSetPurchaseDate())
{
orderInfo.PurchaseDate = order.PurchaseDate;
}
if (order.IsSetLastUpdateDate())
{
orderInfo.LastUpdateDate = order.LastUpdateDate;
}
if (order.IsSetOrderStatus())
{
orderInfo.OrderStatus = ConvertOrderStatus(order.OrderStatus);
}
orderInfo.OrderTotal = ConvertToAmount(order.IsSetOrderTotal(), order.OrderTotal);
if (order.IsSetNumberOfItemsShipped())
{
orderInfo.NumberOfItemsShipped = (int)order.NumberOfItemsShipped;
}
if (order.IsSetNumberOfItemsUnshipped())
{
orderInfo.NumberOfItemsUnshipped = (int)order.NumberOfItemsUnshipped;
}
if (order.IsSetPaymentExecutionDetail())
{
orderInfo.PaymentsInfo = new AmazonOrderItem2PaymentsInfoList();
foreach (PaymentExecutionDetailItem paymentExecutionDetailItem in order.PaymentExecutionDetail)
{
var orderPayment = new AmazonOrderItem2PaymentInfoListItem();
orderPayment.MoneyInfo = ConvertToAmount(paymentExecutionDetailItem.IsSetPayment(), paymentExecutionDetailItem.Payment);
if (paymentExecutionDetailItem.IsSetPaymentMethod())
{
orderPayment.PaymentMethod = paymentExecutionDetailItem.PaymentMethod;
}
orderInfo.PaymentsInfo.Add(orderPayment);
}
}
return(orderInfo);
}
public decimal GetNumberOfShippedProducts(DateTime from, DateTime to)
{
AmazonOrder amazonOrderAlias = null;
AmazonOrderItem amazonOrderItemAlias = null;
return(_session.QueryOver(() => amazonOrderItemAlias)
.JoinAlias(() => amazonOrderItemAlias.AmazonOrder, () => amazonOrderAlias)
.Where(() => amazonOrderAlias.PurchaseDate >= from && amazonOrderAlias.PurchaseDate <= to)
.Cacheable().List().Sum(x => x.QuantityShipped));
}
public static OrderItemTwo FromOrderItem(AmazonOrderItem item)
{
return(new OrderItemTwo()
{
OrderId = item.OrderId,
OrderStatus = item.OrderStatus,
Total = item.OrderTotal.Value,
PurchaseDate = item.PurchaseDate,
NumberOfItemsShipped = item.NumberOfItemsShipped
});
}
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);
}
}
/// <summary>
/// Saves the order item.
/// </summary>
/// <param name="orderItem">The order item.</param>
/// <returns></returns>
public Optional <int> SaveOrderItem(AmazonOrderItem orderItem)
{
using (var connection = GetOpenedSqlConnection2()) {
var cmd = new MultiInsertCommandGenerator <AmazonOrderItem>()
.WithOptionalConnection(connection.SqlConnection())
.WithTableName(Tables.AmazonOrderItem)
.WithModels(orderItem.ToEnumerable())
.WithSkipColumns(o => o.Id)
.WithOutputColumns(o => o.Id)
.Verify()
.GenerateCommands()
.First();
using (var sqlCommand = cmd) {
return(ExecuteScalarAndLog <int>(sqlCommand));
}
}
}
private static ScannedItem LocateScannedItemBasedOnCost(AmazonOrderItem[] amazonOrderItems, ChaseCreditLineItem amazonLineItem, decimal cost)
{
IEnumerable <AmazonOrderItem> orders =
from orderItem in amazonOrderItems
where orderItem.ItemTotal == cost && !orderItem.IsUsed && orderItem.OrderDate <= amazonLineItem.PostingDate
orderby orderItem.OrderDate
select orderItem;
AmazonOrderItem order = orders.FirstOrDefault();
ScannedItem scannedItem = null;
if (order != null)
{
order.IsUsed = true;
scannedItem = new ScannedItem()
{
ItemTotal = cost,
OrderDate = order.OrderDate,
PostingDate = amazonLineItem.PostingDate,
Title = order.Title,
WasFound = true
};
}
else
{
// Check for suscription savings - appears that these appear w/ + Gift Card in the description (HACK)
IEnumerable <AmazonOrderItem> subscriptionOrders =
from orderItem in amazonOrderItems
where orderItem.PaymentInstrumentType.Contains("Gift") && !orderItem.IsUsed && orderItem.OrderDate <= amazonLineItem.PostingDate &&
((Math.Round(orderItem.ItemSubtotal * (decimal)0.9595 + orderItem.ItemSubtotalTax, 2) == cost) || (Math.Round(orderItem.ItemSubtotal * (decimal)0.8595 + orderItem.ItemSubtotalTax, 2) == cost))
orderby orderItem.OrderDate
select orderItem;
order = subscriptionOrders.FirstOrDefault();
if (order != null)
{
order.IsUsed = true;
scannedItem = new ScannedItem()
{
ItemTotal = cost,
OrderDate = order.OrderDate,
PostingDate = amazonLineItem.PostingDate,
Title = order.Title,
WasFound = true
};
}
else
{
// Check for aggregate orders on the same day
List <IGrouping <DateTime, AmazonOrderItem> > orderGroups = new List <IGrouping <DateTime, AmazonOrderItem> >();
IEnumerable <IGrouping <DateTime, AmazonOrderItem> > ordersByDate = amazonOrderItems.GroupBy((o) => o.OrderDate);
foreach (IGrouping <DateTime, AmazonOrderItem> orderByDate in ordersByDate)
{
if (orderByDate.Count() > 1)
{
decimal total = orderByDate.Sum((o) => o.ItemTotal);
if (total == cost)
{
orderGroups.Add(orderByDate);
}
}
}
if (orderGroups.Any())
{
IOrderedEnumerable <IGrouping <DateTime, AmazonOrderItem> > orderGroupsOrderedByDate = orderGroups.OrderBy((groupedItem) => groupedItem.Key);
IGrouping <DateTime, AmazonOrderItem> orderGroup = orderGroupsOrderedByDate.First();
StringBuilder builder = new StringBuilder();
foreach (AmazonOrderItem items in orderGroup)
{
builder.Append(items.Title);
builder.Append(" ");
items.IsUsed = true;
}
scannedItem = new ScannedItem()
{
ItemTotal = cost,
OrderDate = orderGroup.Key,
PostingDate = amazonLineItem.PostingDate,
Title = builder.ToString(),
WasFound = true
};
}
}
}
return(scannedItem);
}
/// <summary>
/// Creates the amazon order item.
/// </summary>
/// <param name="order">The order.</param>
/// <returns></returns>
private AmazonOrderItemAndPayments CreateAmazonOrderItem(Src.OrdersApi.Model.Order order)
{
AmazonOrderItemAndPayments orderItemAndPayments = new AmazonOrderItemAndPayments();
var item = new AmazonOrderItem();
if (order.IsSetAmazonOrderId())
{
item.OrderId = order.AmazonOrderId;
}
if (order.IsSetSellerOrderId())
{
item.SellerOrderId = order.SellerOrderId;
}
if (order.IsSetPurchaseDate())
{
item.PurchaseDate = order.PurchaseDate;
}
if (order.IsSetLastUpdateDate())
{
item.LastUpdateDate = order.LastUpdateDate;
}
if (order.IsSetOrderStatus())
{
#region Comment
// Pending, The order has been placed but payment has not been authorized. The order is not ready for shipment. Note that for orders with OrderType = Standard, the initial order status is Pending. For orders with OrderType = Preorder (available in JP only), the initial order status is PendingAvailability, and the order passes into the Pending status when the payment authorization process begins.
// Unshipped, Payment has been authorized and order is ready for shipment, but no items in the order have been shipped.
// PartiallyShipped, One or more (but not all) items in the order have been shipped.
// Shipped, All items in the order have been shipped.
// Canceled, The order was canceled.
// Unfulfillable, The order cannot be fulfilled. This state applies only to Amazon-fulfilled orders that were not placed on Amazon's retail web site.
// PendingAvailability, This status is available for pre-orders only. The order has been placed, payment has not been authorized, and the release date of the item is in the future. The order is not ready for shipment. Note that Preorder is a possible OrderType value in Japan (JP) only.
// InvoiceUnconfirmed, All items in the order have been shipped. The seller has not yet given confirmation to Amazon that the invoice has been shipped to the buyer. Note: This value is available only in China (CN).
// All default
#endregion
item.OrderStatus = order.OrderStatus;
}
if (order.IsSetNumberOfItemsShipped())
{
item.NumberOfItemsShipped = (int)order.NumberOfItemsShipped;
}
if (order.IsSetNumberOfItemsUnshipped())
{
item.NumberOfItemsUnshipped = (int)order.NumberOfItemsUnshipped;
}
if (order.IsSetOrderTotal() && order.OrderTotal.IsSetAmount())
{
item.OrderTotal = decimal.Parse(order.OrderTotal.Amount);
if (order.OrderTotal.IsSetCurrencyCode())
{
item.OrderTotalCurrency = order.OrderTotal.CurrencyCode;
}
else
{
Log.Error("got empty currency code");
}
}
if (order.IsSetPaymentExecutionDetail())
{
orderItemAndPayments.Payments = order.PaymentExecutionDetail
.Select(CreatePayment)
.ToList();
}
orderItemAndPayments.OrderItem = item;
return(orderItemAndPayments);
}
