protected GetOrdersResponseType GetOrders(GetOrdersRequestType req, RequestsCounterData requestsCounter)
{
return(DataProvider.GetOrders(req, requestsCounter));
}
private TransactionSearchResponseType GetTransactions(DateTime startDate, DateTime endDate, PayPalRequestInfo reqInfo, RequestsCounterData requestsCounter, ref int daysFailedSoFar)
{
var request = new TransactionSearchReq {
TransactionSearchRequest = new TransactionSearchRequestType {
Version = Version,
StartDate = startDate.ToUniversalTime(),
StatusSpecified = true,
EndDate = endDate.ToUniversalTime(),
EndDateSpecified = true,
DetailLevel = new[] { DetailLevelCodeType.ReturnAll },
Status = PaymentTransactionStatusCodeType.Success
}
};
var userId = reqInfo.SecurityInfo.UserId;
bool needToRetry = true;
Exception lastEx = null;
int counter = 0;
while (needToRetry && counter <= CurrentValues.Instance.PayPalNumberOfRetries)
{
counter++;
try {
var cred = CreateCredentials(reqInfo.SecurityInfo);
WriteLog(string.Format("PayPalService TransactionSearch Starting ({0})", userId));
var service = CreateService(reqInfo);
TransactionSearchResponseType resp = service.TransactionSearch(ref cred, request);
WriteLog(string.Format(
"PayPalService TransactionSearch Request:\n{0}\nResponse:\n{1}",
request.TransactionSearchRequest.ToLogStr(),
resp.ToLogStr()
));
requestsCounter.IncrementRequests("TransactionSearch");
if (resp.Ack == AckCodeType.Failure)
{
throw ServiceRequestExceptionFactory.Create(new PayPalServiceResponceExceptionWrapper(resp));
}
WriteLog(string.Format("PayPalService TransactionSearch Ended ({0})", userId));
return(resp);
} catch (Exception ex) {
lastEx = ex;
if (ex is IServiceRequestException)
{
var exFail = ex as IServiceRequestException;
needToRetry = _CommonInternalErrors.Any(exFail.HasErrorWithCode);
}
WriteLoggerHelper.Write(string.Format("PayPalService TransactionSearch Error ({0}): need to retry: {2} \n {1} ", userId, ex.Message, needToRetry), WriteLogType.Error, null, ex);
}
}
WriteLoggerHelper.Write(string.Format("Failed fetching pay pal data from {0} to {1}", request.TransactionSearchRequest.StartDate, request.TransactionSearchRequest.EndDate), WriteLogType.Info, null, lastEx);
if (daysFailedSoFar == CurrentValues.Instance.PayPalMaxAllowedFailures)
{
WriteLoggerHelper.Write(string.Format("Max number of failures:{0} exceeded.", daysFailedSoFar), WriteLogType.Error, null, lastEx);
throw lastEx ?? new Exception();
}
daysFailedSoFar++;
return(null);
}
internal AmazonProductItemBase RequestData(AmazonServiceProducts data, ActionAccessType access, RequestsCounterData requestCounte)
{
return(data.GetProductCategoriesBySellerSku(this, access, requestCounte));
}
public abstract ResultInfoOrders GetOrders(RequestsCounterData requestsCounter);
private GetOrdersResponseType GetOrders(DateTime fromDate, DateTime toDate, int?pageNumber, RequestsCounterData requestsCounter)
{
var req = new GetOrdersRequestType
{
ModTimeFrom = fromDate.ToUniversalTime(),
ModTimeFromSpecified = true,
ModTimeTo = toDate.ToUniversalTime(),
ModTimeToSpecified = true,
Pagination = new PaginationType
{
EntriesPerPage = 200,
EntriesPerPageSpecified = true,
PageNumber = pageNumber.HasValue ? pageNumber.Value : 0,
PageNumberSpecified = pageNumber.HasValue
}
};
return(GetOrders(req, requestsCounter));
}
public override ResultInfoOrders GetOrders(RequestsCounterData requestsCounter)
{
var now = DateTime.Now;
var diffDays = (int)now.Subtract(FromDate).TotalDays;
WriteToLog("---------------------------------");
WriteToLog("{0:g} - {1:g}", FromDate, ToDate);
WriteToLog("Count Days: {0}", diffDays);
if (diffDays <= MAX_RETURN_DAYS)
{
WriteToLog("all.");
var orders = GetOrders(FromDate, ToDate, requestsCounter);
WriteToLog("---------------------------------");
return(orders);
}
int rem;
var iter = Math.DivRem(diffDays, MAX_RETURN_DAYS, out rem);
WriteToLog("Count Iterations: {0}", iter);
ResultInfoOrders rez = null;
for (int i = 0; i < iter; i++)
{
DateTime fromDate = i == 0 ? FromDate : FromDate.AddDays(i * MAX_RETURN_DAYS);
DateTime toDate = FromDate.AddDays((i + 1) * MAX_RETURN_DAYS);
WriteToLog("iter: {0,3}. {1:g} - {2:g}", i + 1, fromDate, toDate);
var orders = GetOrders(fromDate, toDate, requestsCounter);
if (rez == null)
{
rez = new ResultInfoOrders(orders);
}
else
{
rez.AddData(orders);
}
}
if (rem > 0)
{
DateTime fromDate = FromDate.AddDays(iter * MAX_RETURN_DAYS);
DateTime toDate = ToDate;
WriteToLog("remainder. {0:g} - {1:g}", fromDate, toDate);
var orders = GetOrders(fromDate, toDate, requestsCounter);
if (rez == null)
{
rez = new ResultInfoOrders(orders);
}
else
{
rez.AddData(orders);
}
}
WriteToLog("---------------------------------");
return(rez);
}
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);
}
}
}
} // constructor
public FetchResultCounters(RequestsCounterData requestCount, int orderCount)
{
RequestCount = requestCount ?? new RequestsCounterData();
OrderCount = orderCount;
} // constructor
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);
}
}
public static AmazonOrderItemDetailsList GetListItemsOrdered(IAmazonServiceOrdersConfigurator configurator, AmazonOrdersItemsRequestInfo requestInfo, ActionAccessType access, RequestsCounterData requestCounter)
{
return(new AmazonServiceOrders(configurator.AmazonService).GetListItemsOrdered(requestInfo, access, requestCounter));
}
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);
}
}
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
});
}
public void IncrementRequests(string method = null, string details = null) {
if (RequestsCounter == null)
RequestsCounter = new RequestsCounterData();
RequestsCounter.IncrementRequests(method, details);
} // IncrementRequests
public static AmazonProductItemBase GetProductCategories(AmazonServiceConnectionInfo connectionInfo, AmazonProductsRequestInfoBySellerSku requestInfo, ActionAccessType access, RequestsCounterData requestCounter)
{
var configurator = AmazonServiceConfigurationFactory.CreateServiceProductsConfigurator(connectionInfo);
return(AmazonServiceProducts.GetProductCategories(configurator, requestInfo, access, requestCounter));
}
public static AmazonOrderItemDetailsList GetListItemsOrdered(AmazonServiceConnectionInfo connectionInfo, AmazonOrdersItemsRequestInfo requestInfo, ActionAccessType access, RequestsCounterData requestCounter)
{
var configurator = AmazonServiceConfigurationFactory.CreateServiceOrdersConfigurator(connectionInfo);
return(AmazonServiceOrders.GetListItemsOrdered(configurator, requestInfo, access, requestCounter));
}
