private MP_EbayAmazonCategory[] GetAndSaveAmazonProcuctCategoryByProductSellerSku(
IDatabaseCustomerMarketPlace databaseCustomerMarketPlace,
AmazonSecurityInfo securityInfo,
string sellerSku,
ActionAccessType access,
RequestsCounterData requestCounter,
ElapsedTimeInfo elapsedTimeInfo
)
{
var categories = Helper.FindAmazonCategoryByProductSellerSKU(sellerSku, elapsedTimeInfo, databaseCustomerMarketPlace.Id);
if (categories == null)
{
var requestInfo = new AmazonProductsRequestInfoBySellerSku {
MarketplaceId = securityInfo.MarketplaceId,
MerchantId = securityInfo.MerchantId,
SellerSku = sellerSku,
ErrorRetryingInfo = this.amazonSettings,
MWSAuthToken = securityInfo.MWSAuthToken
};
categories = GetAndSaveAmazonProcuctCategory(databaseCustomerMarketPlace, requestInfo, access, requestCounter, elapsedTimeInfo);
}
return(categories);
}
public PermissionFilterAttribute(ActionAccessType accessType = ActionAccessType.Public, string targetController = null, string targetAction = null, bool addReturnUrl = true)
{
AccessType = accessType;
TargetController = targetController;
TargetAction = targetAction;
AddReturnUrl = addReturnUrl;
}
private MP_EbayAmazonCategory[] GetAndSaveAmazonProcuctCategory(
IDatabaseCustomerMarketPlace databaseCustomerMarketPlace,
AmazonProductsRequestInfoBySellerSku requestInfo,
ActionAccessType access,
RequestsCounterData requestCounter,
ElapsedTimeInfo elapsedTimeInfo
)
{
MP_EbayAmazonCategory[] categories = null;
AmazonProductItemBase productItem = null;
try {
productItem = ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
elapsedTimeInfo,
databaseCustomerMarketPlace.Id,
ElapsedDataMemberType.RetrieveDataFromExternalService,
() => AmazonServiceHelper.GetProductCategories(this.connectionInfo, requestInfo, access, requestCounter)
);
} catch (MarketplaceWebServiceProductsException) {
// Product not found or cannot be retrieved.
} // try
if (productItem != null)
{
var marketplace = databaseCustomerMarketPlace.Marketplace;
categories = Helper.AddAmazonCategories(marketplace, productItem, elapsedTimeInfo, databaseCustomerMarketPlace.Id);
} // if
return(categories);
}
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 ActionInfo CreateAction(string name = "Action", ActionAccessType accessType = ActionAccessType.Full)
{
return(new ActionInfo(name)
{
Action = () => { },
Access = accessType
});
}
public RequestsListInfo(AmazonRequestInfoBase amazonRequestInfo, string actionName, ActionAccessType access, ErrorRetryingInfo errorRetryingInfo, int timeOutInMinutes = 10)
{
UserId = amazonRequestInfo.MerchantId;
MarketPlaceId = amazonRequestInfo.MarketplaceId;
StartDate = amazonRequestInfo.StartDate;
EndDate = amazonRequestInfo.EndDate;
ActionName = actionName;
Access = access;
TimeOutInMinutes = timeOutInMinutes;
ErrorRetryingInfo = errorRetryingInfo;
RequestsCounter = new RequestsCounterData();
}
public override void Execute(ActionInfo actionInfo)
{
var actionName = actionInfo.Name;
var action = actionInfo.Action;
ActionAccessType accessType = actionInfo.Access;
Func <bool> func = () =>
{
action();
return(true);
};
InternalExecute(func, actionName, accessType);
}
private void UpdateClientOrdersInfo(
IDatabaseCustomerMarketPlace databaseCustomerMarketPlace,
AmazonSecurityInfo securityInfo,
ActionAccessType access,
MP_CustomerMarketplaceUpdatingHistory historyRecord
)
{
log.DebugFormat("UpdateClientOrdersInfo customer {0}, amazon mp {1}, access {2}", databaseCustomerMarketPlace.Customer.Id, databaseCustomerMarketPlace.DisplayName, access);
Helper.CustomerMarketplaceUpdateAction(
CustomerMarketplaceUpdateActionType.UpdateOrdersInfo,
databaseCustomerMarketPlace,
historyRecord,
() => CustomerMarketplaceUpdateAction(databaseCustomerMarketPlace, securityInfo, access, historyRecord)
);
} // UpdateClientOrdersInfo
internal AmazonProductItemBase RequestData(AmazonServiceProducts data, ActionAccessType access, RequestsCounterData requestCounte)
{
return(data.GetProductCategoriesBySellerSku(this, access, requestCounte));
}
private void GetOrdersByNextToken(AmazonOrdersRequestInfo requestInfo, string nextToken, ActionAccessType access, RequestsCounterData responseCounter, Func <List <AmazonOrderItem>, bool> func)
{
var sellerId = requestInfo.MerchantId;
var req = new ListOrdersByNextTokenRequest {
NextToken = nextToken,
SellerId = sellerId,
MWSAuthToken = requestInfo.MWSAuthToken
};
var response = AmazonWaitBeforeRetryHelper.DoServiceAction(
requestInfo.ErrorRetryingInfo,
ListOrdersTrapForThrottling,
"ListOrdersByNextToken",
access,
responseCounter,
() => _Service.ListOrdersByNextToken(req));
if (response != null && response.IsSetListOrdersByNextTokenResult())
{
var result = response.ListOrdersByNextTokenResult;
if (result.IsSetOrders())
{
var ordersList = ParseOrdersInfo(result.Orders, sellerId, access, requestInfo.CustomerId);
func(ordersList);
}
if (result.IsSetNextToken())
{
GetOrdersByNextToken(requestInfo, result.NextToken, access, responseCounter, func);
}
}
}
private RequestsCounterData GetListOrders(AmazonOrdersRequestInfo requestInfo, ActionAccessType access, Func <List <AmazonOrderItem>, bool> func)
{
var request = new ListOrdersRequest {
MarketplaceId = requestInfo.MarketplaceId,
SellerId = requestInfo.MerchantId,
MWSAuthToken = requestInfo.MWSAuthToken
};
if (requestInfo.StartDate.HasValue)
{
request.CreatedAfter = requestInfo.StartDate.Value.ToUniversalTime();
}
var responseCounter = new RequestsCounterData();
var response = AmazonWaitBeforeRetryHelper.DoServiceAction(
requestInfo.ErrorRetryingInfo,
ListOrdersTrapForThrottling,
"ListOrders",
access,
responseCounter,
() => _Service.ListOrders(request));
if (response == null || response.ListOrdersResult == null || !response.IsSetListOrdersResult())
{
return(null);
}
var result = response.ListOrdersResult;
if (result.IsSetOrders())
{
var ordersList = ParseOrdersInfo(result.Orders, request.SellerId, access, requestInfo.CustomerId);
func(ordersList);
}
if (result.IsSetNextToken())
{
GetOrdersByNextToken(requestInfo, result.NextToken, access, responseCounter, func);
}
return(responseCounter);
}
public static AmazonOrderItemDetailsList GetListItemsOrdered(IAmazonServiceOrdersConfigurator configurator, AmazonOrdersItemsRequestInfo requestInfo, ActionAccessType access, RequestsCounterData requestCounter)
{
return(new AmazonServiceOrders(configurator.AmazonService).GetListItemsOrdered(requestInfo, access, requestCounter));
}
public static AmazonProductItemBase GetProductCategories(AmazonServiceConnectionInfo connectionInfo, AmazonProductsRequestInfoBySellerSku requestInfo, ActionAccessType access, RequestsCounterData requestCounter)
{
var configurator = AmazonServiceConfigurationFactory.CreateServiceProductsConfigurator(connectionInfo);
return(AmazonServiceProducts.GetProductCategories(configurator, requestInfo, access, requestCounter));
}
private T DoServiceAction <T>(ITrapForThrottling trapForThrottling, string actionName, ActionAccessType access, RequestsCounterData requestCounter, Func <T> func, string details)
{
return(_WaitBeforeRetryController.Do(() =>
{
T response = default(T);
trapForThrottling.Execute(new ActionInfo(actionName)
{
Action = () =>
{
response = func();
requestCounter.IncrementRequests(actionName, details);
},
Access = access
});
return response;
},
ex =>
{
if (ex != null)
{
WriteLoggerHelper.Write(ex.Message, WriteLogType.Warning, null, ex);
Debug.WriteLine(ex);
}
if (ex is MarketplaceWebServiceProductsException)
{
var prodEx = ex as MarketplaceWebServiceProductsException;
if (prodEx.StatusCode == HttpStatusCode.InternalServerError ||
prodEx.StatusCode == HttpStatusCode.ServiceUnavailable ||
string.Equals(prodEx.ErrorCode, _RequestThrottledString, StringComparison.InvariantCultureIgnoreCase))
{
return true;
}
else if (prodEx.StatusCode == HttpStatusCode.Unauthorized || prodEx.StatusCode == HttpStatusCode.BadRequest)
{
return false;
}
}
else if (ex is MarketplaceWebServiceOrdersException)
{
var ordersEx = ex as MarketplaceWebServiceOrdersException;
if (ordersEx.StatusCode == HttpStatusCode.InternalServerError ||
ordersEx.StatusCode == HttpStatusCode.ServiceUnavailable ||
string.Equals(ordersEx.ErrorCode, _RequestThrottledString, StringComparison.InvariantCultureIgnoreCase))
{
return true;
}
else if (ordersEx.StatusCode == HttpStatusCode.Unauthorized)
{
return false;
}
}
else if (ex is MarketplaceWebServiceException)
{
var repEx = ex as MarketplaceWebServiceException;
if (repEx.StatusCode == HttpStatusCode.InternalServerError ||
repEx.StatusCode == HttpStatusCode.ServiceUnavailable ||
string.Equals(repEx.ErrorCode, _RequestThrottledString, StringComparison.InvariantCultureIgnoreCase))
{
return true;
}
else if (repEx.StatusCode == HttpStatusCode.Unauthorized)
{
return false;
}
}
return true;
}
));
}
public static RequestsCounterData GetListOrders(IAmazonServiceOrdersConfigurator configurator, AmazonOrdersRequestInfo requestInfo, ActionAccessType access, Func <List <AmazonOrderItem>, bool> func)
{
var service = configurator.AmazonService;
WriteToLog(string.Format("GetListOrders - SellerId: {0}, CreatedAfter (UTC) {1}, amazon mps id {2}, customer id {3} ", requestInfo.MerchantId, requestInfo.StartDate, requestInfo.GetMarketPlacesString(), requestInfo.CustomerId));
return(new AmazonServiceOrders(service).GetListOrders(requestInfo, access, func));
}
public static AmazonOrdersList GetUserOrders(IAmazonServiceReportsConfigurator configurator, AmazonOrdersRequestInfo requestInfo, ActionAccessType access)
{
var service = configurator.AmazonService;
var data = new AmazonServiceReports(service);
return(data.GetUserOrders(requestInfo, access));
}
private AmazonOrdersList GetUserOrders(AmazonOrdersRequestInfo amazonRequestInfo, ActionAccessType access)
{
const string getFlatFileOrdersDataRequestStr = "_GET_FLAT_FILE_ORDERS_DATA_";
var reportRequestList = new RequestsListInfo(amazonRequestInfo, "GetUserOrders", access /*timeout: 3 hours*/, amazonRequestInfo.ErrorRetryingInfo);
reportRequestList.AddRequest(getFlatFileOrdersDataRequestStr);
RequestAndWait(reportRequestList);
return(ParseOrdersResult(getFlatFileOrdersDataRequestStr, reportRequestList));
}
public static AmazonOrdersList GetReportOrders(AmazonServiceConnectionInfo connectionInfo, AmazonOrdersRequestInfo requestInfo, ActionAccessType access)
{
var configurator = AmazonServiceConfigurationFactory.CreateServiceReportsConfigurator(connectionInfo);
return(AmazonServiceReports.GetUserOrders(configurator, requestInfo, access));
}
public static RequestsCounterData GetListOrders(AmazonServiceConnectionInfo connectionInfo, AmazonOrdersRequestInfo requestInfo, ActionAccessType access, Func <List <AmazonOrderItem>, bool> func)
{
var configurator = AmazonServiceConfigurationFactory.CreateServiceOrdersConfigurator(connectionInfo);
return(AmazonServiceOrders.GetListOrders(configurator, requestInfo, access, func));
}
private UpdateActionResultInfo CustomerMarketplaceUpdateAction(
IDatabaseCustomerMarketPlace databaseCustomerMarketPlace,
AmazonSecurityInfo securityInfo,
ActionAccessType access,
MP_CustomerMarketplaceUpdatingHistory historyRecord
)
{
// save data to order table
//var webServiceConfigurator = CreateServiceReportsConfigurator(connectionInfo);
var elapsedTimeInfo = new ElapsedTimeInfo();
DateTime?startDate = ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
elapsedTimeInfo,
databaseCustomerMarketPlace.Id,
ElapsedDataMemberType.RetrieveDataFromDatabase,
() => Helper.GetLastAmazonOrderDate(databaseCustomerMarketPlace)
);
var now = DateTime.UtcNow;
if (!startDate.HasValue)
{
startDate = now.AddYears(-1);
// We want data since the 1st of the month.
startDate = startDate.Value.AddDays(-startDate.Value.Day).AddDays(1).Date;
} // if
var fromDate = startDate.Value;
var toDate = now;
var amazonOrdersRequestInfo = new AmazonOrdersRequestInfo {
StartDate = fromDate,
EndDate = toDate,
MarketplaceId = securityInfo.MarketplaceId,
MerchantId = securityInfo.MerchantId,
ErrorRetryingInfo = this.amazonSettings,
CustomerId = databaseCustomerMarketPlace.Customer.Id,
MWSAuthToken = securityInfo.MWSAuthToken
};
DateTime submittedDate = now;
log.InfoFormat(
"Fetching Amazon orders for customer: {0} marketplace: {1}",
databaseCustomerMarketPlace.Customer.Id,
databaseCustomerMarketPlace.Id
);
MP_AmazonOrder amazonOrder = null;
RequestsCounterData requestsCounter = ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
elapsedTimeInfo,
databaseCustomerMarketPlace.Id,
ElapsedDataMemberType.RetrieveDataFromExternalService,
() => AmazonServiceHelper.GetListOrders(this.connectionInfo, amazonOrdersRequestInfo, access, data => {
amazonOrder = Helper.StoreAmazonOrdersData(databaseCustomerMarketPlace, data, historyRecord, amazonOrder);
return(true);
})
);
var allOrders = ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
elapsedTimeInfo,
databaseCustomerMarketPlace.Id,
ElapsedDataMemberType.RetrieveDataFromDatabase,
() => Helper.GetAllAmazonOrdersData(submittedDate, databaseCustomerMarketPlace)
);
allOrders.RequestsCounter = requestsCounter;
if (allOrders.Count > 0)
{
var bestSaledOrderItemList = AnalyseOrder(allOrders).ToList();
if (bestSaledOrderItemList.Any())
{
foreach (var orderItem2 in bestSaledOrderItemList)
{
var orderItems = GetOrderItems(
securityInfo,
access,
orderItem2,
elapsedTimeInfo,
allOrders,
databaseCustomerMarketPlace.Id
);
orderItem2.OrderedItemsList = orderItems;
if (orderItems != null)
{
foreach (var orderItem in orderItems)
{
orderItem.Categories = GetAndSaveAmazonProcuctCategoryByProductSellerSku(
databaseCustomerMarketPlace,
securityInfo,
orderItem.SellerSKU,
access, allOrders.RequestsCounter,
elapsedTimeInfo
);
} // for each
} // if
} // for each
} // if
ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
elapsedTimeInfo,
databaseCustomerMarketPlace.Id,
ElapsedDataMemberType.StoreDataToDatabase,
() => Helper.StoreAmazonOrdersDetailsData(databaseCustomerMarketPlace, bestSaledOrderItemList)
);
} // if
return(new UpdateActionResultInfo {
Name = UpdateActionResultType.OrdersCount,
Value = (object)allOrders.Count,
RequestsCounter = allOrders.RequestsCounter,
ElapsedTime = elapsedTimeInfo
});
}
private T InternalExecute <T>(Func <T> func, string actionName, ActionAccessType accessType = ActionAccessType.Full)
{
var limitAccessRequestQuota = accessType == ActionAccessType.Full ? 0 : _LimitAccessRequestQuota;
var requestQuota = _RequestQuota - limitAccessRequestQuota;
var rez = default(T);
var done = false;
while (!done)
{
var now = DateTime.Now;
bool hasFree;
int timeFoFree = 0;
lock ( _Locker )
{
if (_CurrentRequestInProgress > 0)
{
var elapsedSeconds = (int)(now - _LastRequestTime.Value).TotalSeconds;
int reminder;
var canCellsForFreeCount = Math.DivRem(elapsedSeconds, (int)_RestoreRateInSeconds, out reminder);
if (canCellsForFreeCount > 0)
{
_LastRequestTime = now;
WriteToLog(string.Format("{0} [{1}: {2}] last restore cells time", _Name, actionName, now));
_CurrentRequestInProgress -= canCellsForFreeCount;
if (_CurrentRequestInProgress < 0)
{
_CurrentRequestInProgress = 0;
}
WriteToLog(string.Format("{0} [{1}: {2}] Total buzzy cells: {3} of {4}", _Name, actionName, now, _CurrentRequestInProgress, requestQuota));
if (_CurrentRequestInProgress == 0)
{
WriteToLog(string.Format("{0} [{1}: {2}] All cells free", _Name, actionName, now));
_LastRequestTime = null;
}
}
}
hasFree = requestQuota - _CurrentRequestInProgress > 0;
if (hasFree)
{
if (_CurrentRequestInProgress == 0)
{
WriteToLog(string.Format("{0} [{1}: {2}] Getting First cells", _Name, actionName, now));
_LastRequestTime = now;
}
++_CurrentRequestInProgress;
WriteToLog(string.Format("{0} [{1}: {2}] Total buzy cells: {3} of {4}", _Name, actionName, now, _CurrentRequestInProgress, requestQuota));
}
else
{
timeFoFree = _RestoreRateInSeconds - (int)(now - _LastRequestTime.Value).TotalSeconds;
WriteToLog(string.Format("{0} [{1}: {2}] Elapsed time for free Cells: {3} (sec)", _Name, actionName, now, timeFoFree));
}
}
if (hasFree)
{
WriteToLog(string.Format("{0} [{1}: {2}] execute method", _Name, actionName, now));
// execute action
rez = func();
done = true;
}
else
{
WriteToLog(string.Format("{0} [{1}: {2}] Start wait: {3} (sec)", _Name, actionName, now, timeFoFree));
if (_Finish.WaitOne(timeFoFree * 1000))
{
WriteToLog(string.Format("{0} [{1}: {2}] Exit raised", _Name, actionName, now));
done = true;
}
else
{
WriteToLog(string.Format("{0} [{1}: {2}] End wait", _Name, actionName, now));
}
}
done &= !_Finish.WaitOne(1);
}
return(rez);
}
private AmazonOrderItemDetailsList GetListItemsOrdered(AmazonOrdersItemsRequestInfo requestInfo, ActionAccessType access, RequestsCounterData requestCounter)
{
var orderId = requestInfo.OrderId;
var sellerId = requestInfo.MerchantId;
try {
var req = new ListOrderItemsRequest {
AmazonOrderId = orderId,
SellerId = sellerId,
MWSAuthToken = requestInfo.MWSAuthToken
};
var response = AmazonWaitBeforeRetryHelper.DoServiceAction(
requestInfo.ErrorRetryingInfo,
ListOrderItemsTrapForThrottling,
"ListOrderItems",
access,
requestCounter,
() => _Service.ListOrderItems(req));
var list = new AmazonOrderItemDetailsList(DateTime.UtcNow)
{
RequestsCounter = requestCounter
};
if (response == null)
{
return(list);
}
var result = response.ListOrderItemsResult;
if (result.IsSetOrderItems())
{
ParseOrderItems(list, result.OrderItems);
}
if (result.IsSetNextToken())
{
GetOrderItemsByNextToken(list, requestInfo, result.NextToken, access, requestCounter);
}
return(list);
} catch (MarketplaceWebServiceOrdersException) {
return(null);
}
}
public static T DoServiceAction <T>(ErrorRetryingInfo errorRetryingInfo, ITrapForThrottling trapForThrottling, string actionName, ActionAccessType access, RequestsCounterData requestCounter, Func <T> func, string details = null)
{
return(new AmazonWaitBeforeRetryHelper(errorRetryingInfo).DoServiceAction(trapForThrottling, actionName, access, requestCounter, func, details));
}
private void GetOrderItemsByNextToken(AmazonOrderItemDetailsList list, AmazonOrdersItemsRequestInfo requestInfo, string nextToken, ActionAccessType access, RequestsCounterData requestCounter)
{
var sellerId = requestInfo.MerchantId;
var req = new ListOrderItemsByNextTokenRequest {
NextToken = nextToken,
SellerId = sellerId,
MWSAuthToken = requestInfo.MWSAuthToken
};
var response = AmazonWaitBeforeRetryHelper.DoServiceAction(
requestInfo.ErrorRetryingInfo,
ListOrderItemsTrapForThrottling,
"ListOrderItemsByNextToken",
access,
requestCounter,
() => _Service.ListOrderItemsByNextToken(req));
if (response == null)
{
return;
}
var result = response.ListOrderItemsByNextTokenResult;
if (result.IsSetOrderItems())
{
ParseOrderItems(list, result.OrderItems);
}
if (result.IsSetNextToken())
{
GetOrderItemsByNextToken(list, requestInfo, result.NextToken, access, requestCounter);
}
}
private List <AmazonOrderItem> ParseOrdersInfo(List <Order> orders, string sellerId, ActionAccessType access, int customerId)
{
if (orders != null && orders.Any(x => x.IsSetPurchaseDate()))
{
var firstDate = orders.Min(x => x.PurchaseDate);
var lastDate = orders.Max(x => x.PurchaseDate);
WriteToLog(
string.Format(
"Amazon ParseOrdersInfo customerId {2}, sellerId {0} number of orders {1}, first order date {3} last order date {4}",
sellerId, orders.Count, customerId, firstDate, lastDate));
}
else
{
WriteToLog(string.Format("Amazon ParseOrdersInfo customerId {1}, sellerId {0} number of orders 0", sellerId, customerId));
}
var ordersList = new List <AmazonOrderItem>();
if (orders != null && orders.Any())
{
foreach (var order in orders)
{
try {
ordersList.Add(ParseOrder(order));
} catch (Exception ex) {
WriteToLog("failed to parse amazon order", WriteLogType.Warning, ex);
}
}
}
return(ordersList);
}
public static AmazonOrderItemDetailsList GetListItemsOrdered(AmazonServiceConnectionInfo connectionInfo, AmazonOrdersItemsRequestInfo requestInfo, ActionAccessType access, RequestsCounterData requestCounter)
{
var configurator = AmazonServiceConfigurationFactory.CreateServiceOrdersConfigurator(connectionInfo);
return(AmazonServiceOrders.GetListItemsOrdered(configurator, requestInfo, access, requestCounter));
}
