internal async Task <IEnumerable <InventoryStatusResponse> > ReviseInventoriesStatusAsync(IEnumerable <InventoryStatusRequest> products, string mark)
{
var methodParameters = products.ToJson();
try
{
EbayLogger.LogTraceStarted(this.CreateMethodCallInfo(methodParameters, mark));
var reviseInventoriesStatus = await this.EbayServiceLowLevel.ReviseInventoriesStatusAsync(products, mark).ConfigureAwait(false);
var inventoryStatusResponses = reviseInventoriesStatus as IList <InventoryStatusResponse> ?? reviseInventoriesStatus.ToList();
var errorsToSkip = new List <ResponseError> {
EbayErrors.EbayPixelSizeError, EbayErrors.LvisBlockedError, EbayErrors.UnsupportedListingType, EbayErrors.ReplaceableValue, EbayErrors.VariationLevelSKUAndItemIDShouldBeSupplied
};
var errorsThatMustBeSkipped = inventoryStatusResponses.CollectAllErros().Where(x => errorsToSkip.Any(y => y.ErrorCode == x.ErrorCode)).ToList();
EbayLogger.LogTraceInnerError(this.CreateMethodCallInfo(methodParameters, mark, errorsThatMustBeSkipped.ToJson()));
inventoryStatusResponses.SkipErrorsAndDo(null, errorsThatMustBeSkipped);
inventoryStatusResponses.ThrowOnError(x => (x.Select(y => ( InventoryStatusResponse )y).ToList()).ToJson());
var items = inventoryStatusResponses.Where(y => y.Items != null).SelectMany(x => x.Items).ToList();
var briefInfo = items.ToJson();
EbayLogger.LogTraceEnded(this.CreateMethodCallInfo(methodParameters, mark, methodResult: briefInfo));
return(reviseInventoriesStatus);
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error.{0})", this.CreateMethodCallInfo(methodParameters, mark)), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
public async Task <List <string> > GetSaleRecordsNumbersAsync(params string[] saleRecordsIDs)
{
var methodParameters = saleRecordsIDs.ToJson();
var mark = Guid.NewGuid().ToString();
try
{
EbayLogger.LogTraceStarted(this.CreateMethodCallInfo(methodParameters, mark));
var seleRecordsIdsFilteredOnlyExisting = new List <string>();
if (saleRecordsIDs == null || !saleRecordsIDs.Any())
{
return(seleRecordsIdsFilteredOnlyExisting);
}
var salerecordIds = saleRecordsIDs.ToList();
var currentMethod = GetCallerMethodName();
var millisecondsDelay = DelayForMethod.ContainsKey(currentMethod) ? DelayForMethod[currentMethod] : DEFAULT_DELAY_MILLISECONDS;
var cts = new CancellationTokenSource(millisecondsDelay);
var getSellingManagerSoldListingsResponses = await salerecordIds.ProcessInBatchAsync(this.EbayServiceLowLevel.MaxThreadsCount, async x => await this.EbayServiceLowLevel.GetSellngManagerOrderByRecordNumberAsync( x, mark, cts.Token ).ConfigureAwait(false)).ConfigureAwait(false);
var sellingManagerSoldListingsResponses = getSellingManagerSoldListingsResponses as IList <GetSellingManagerSoldListingsResponse> ?? getSellingManagerSoldListingsResponses.ToList();
sellingManagerSoldListingsResponses.SkipErrorsAndDo(x => EbayLogger.LogTraceInnerError(this.CreateMethodCallInfo(methodParameters, mark, x.Errors.ToJson())), new List <ResponseError> {
EbayErrors.EbayPixelSizeError, EbayErrors.LvisBlockedError, EbayErrors.UnsupportedListingType, EbayErrors.RequestedUserIsSuspended
});
sellingManagerSoldListingsResponses.ThrowOnError();
if (!sellingManagerSoldListingsResponses.Any())
{
return(seleRecordsIdsFilteredOnlyExisting);
}
var allReceivedOrders = sellingManagerSoldListingsResponses.SelectMany(x => x.Orders).ToList();
var alllReceivedOrdersDistinct = allReceivedOrders.Distinct(new OrderEqualityComparerByRecordId()).Select(x => x.SaleRecordID).ToList();
seleRecordsIdsFilteredOnlyExisting = (from s in saleRecordsIDs join d in alllReceivedOrdersDistinct on s equals d select s).ToList();
var resultSaleRecordNumbersBriefInfo = seleRecordsIdsFilteredOnlyExisting.ToJson();
EbayLogger.LogTraceEnded(this.CreateMethodCallInfo(methodParameters, mark, methodResult: resultSaleRecordNumbersBriefInfo));
return(seleRecordsIdsFilteredOnlyExisting);
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error. Was called:{0}", this.CreateMethodCallInfo(methodParameters, mark)), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
public async Task <IEnumerable <Models.GetSellerListResponse.Item> > GetProductsDetailsAsync()
{
try
{
return(await this.GetProductsDetailsAsync(this._ebayWorkingStart, DateTime.Now).ConfigureAwait(false));
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error. Was called with()"), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
public async Task <IEnumerable <Models.GetSellerListResponse.Item> > GetProductsDetailsAsync(DateTime createTimeFromStart, DateTime createTimeFromTo)
{
var mark = new Guid().ToString();
var methodParameters = string.Format("CreateTimeFrom:{0},CreateTimeTo:{1}", createTimeFromStart, createTimeFromTo);
try
{
var products = new List <Models.GetSellerListResponse.Item>();
var quartalsStartList = GetListOfTimeRanges(createTimeFromStart, createTimeFromTo).ToList();
var getSellerListAsyncTasks = new List <Task <GetSellerListResponse> >();
var sellerListAsync = await this.EbayServiceLowLevel.GetSellerListAsync(quartalsStartList[0], quartalsStartList[1].AddSeconds(-1), GetSellerListTimeRangeEnum.StartTime, mark).ConfigureAwait(false);
sellerListAsync.SkipErrorsAndDo(c => EbayLogger.LogTraceInnerError(this.CreateMethodCallInfo(methodParameters, mark, sellerListAsync.Errors.ToJson())), new List <ResponseError> {
EbayErrors.RequestedUserIsSuspended
});
sellerListAsync.ThrowOnError();
products.AddRange(sellerListAsync.Items);
for (var i = 1; i < quartalsStartList.Count - 1; i++)
{
getSellerListAsyncTasks.Add(this.EbayServiceLowLevel.GetSellerListAsync(quartalsStartList[i], quartalsStartList[i + 1].AddSeconds(-1), GetSellerListTimeRangeEnum.StartTime, mark));
}
await Task.WhenAll(getSellerListAsyncTasks).ConfigureAwait(false);
products.AddRange(getSellerListAsyncTasks.SelectMany(task => task.Result.Items).ToList());
var productsDetails = await this.GetItemsAsync(products, mark).ConfigureAwait(false);
var productsDetailsDevidedByVariations = SplitByVariationsOrReturnEmpty(productsDetails);
return(productsDetailsDevidedByVariations);
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error. Was called with({0},{1})", createTimeFromStart, createTimeFromTo), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
public async Task <IEnumerable <Order> > GetOrdersAsync(DateTime dateFrom, DateTime dateTo)
{
var methodParameters = string.Format("{{dateFrom:{0},dateTo:{1}}}", dateFrom, dateTo);
var mark = Guid.NewGuid().ToString();
try
{
EbayLogger.LogTraceStarted(this.CreateMethodCallInfo(methodParameters, mark));
var daysBeforeNow = (DateTime.UtcNow - dateFrom).Days;
if (daysBeforeNow > MaximumTimeWindowAllowed)
{
var daysExcess = daysBeforeNow - MaximumTimeWindowAllowed;
var amendement = -1 * daysExcess;
dateFrom.AddDays(amendement);
}
List <Order> result;
if (dateFrom > dateTo)
{
result = new List <Order>();
}
else
{
var getOrdersResponse = await this.EbayServiceLowLevel.GetOrdersAsync(dateFrom, dateTo, GetOrdersTimeRangeEnum.ModTime, mark).ConfigureAwait(false);
getOrdersResponse.SkipErrorsAndDo(c => EbayLogger.LogTraceInnerError(this.CreateMethodCallInfo(methodParameters, mark, getOrdersResponse.Errors.ToJson())), new List <ResponseError> {
EbayErrors.RequestedUserIsSuspended
});
getOrdersResponse.ThrowOnError();
result = getOrdersResponse.Orders;
}
EbayLogger.LogTraceEnded(this.CreateMethodCallInfo(methodParameters, mark, methodResult: result.ToJson()));
return(result);
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error. Was called:{0}", this.CreateMethodCallInfo(methodParameters, mark)), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
public async Task <IEnumerable <Item> > GetActiveProductsAsync(CancellationToken ct, bool getOnlyGtcDuration = false)
{
var methodParameters = new Func <string>(() => string.Format("{{getOnlyGtcDuration: {0}, cancellationTokenIsCancelled:{1}}}", getOnlyGtcDuration, ct.IsCancellationRequested));
var mark = Guid.NewGuid().ToString();
try
{
if (ct.IsCancellationRequested)
{
return(null);
}
EbayLogger.LogTraceStarted(this.CreateMethodCallInfo(methodParameters(), mark));
var sellerListsAsync = await this.EbayServiceLowLevel.GetSellerListCustomResponsesWithMaxThreadsRestrictionAsync(ct, DateTime.UtcNow, DateTime.UtcNow.AddDays(Maxtimerange), GetSellerListTimeRangeEnum.EndTime, mark).ConfigureAwait(false)
?? new List <GetSellerListCustomResponse>();
var getSellerListCustomResponses = sellerListsAsync as IList <GetSellerListCustomResponse> ?? sellerListsAsync.ToList();
getSellerListCustomResponses.SkipErrorsAndDo(c => EbayLogger.LogTraceInnerError(this.CreateMethodCallInfo(methodParameters(), mark, c.Errors.ToJson())), new List <ResponseError> {
EbayErrors.RequestedUserIsSuspended
});
getSellerListCustomResponses.ThrowOnError();
if (getOnlyGtcDuration)
{
getSellerListCustomResponses.ForEach(x => x.Items = x.Items.Where(y => y.Duration.ToUpper().Equals(DurationGTC)).ToList());
}
var items = getSellerListCustomResponses.SelectMany(x => x.ItemsSplitedByVariations);
var resultSellerListBriefInfo = items.ToJson();
EbayLogger.LogTraceEnded(this.CreateMethodCallInfo(methodParameters(), mark, methodResult: resultSellerListBriefInfo));
return(items);
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error. Was called:{0}", this.CreateMethodCallInfo(methodParameters(), mark)), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
public async Task <List <string> > GetOrdersIdsAsync(params string[] sourceOrdersIds)
{
var methodParameters = sourceOrdersIds.ToJson();
var mark = Guid.NewGuid().ToString();
try
{
EbayLogger.LogTraceStarted(this.CreateMethodCallInfo(methodParameters, mark));
if (sourceOrdersIds == null || !sourceOrdersIds.Any())
{
return(new List <string>());
}
var getOrdersResponse = await this.EbayServiceLowLevel.GetOrdersAsync(mark, sourceOrdersIds).ConfigureAwait(false);
getOrdersResponse.SkipErrorsAndDo(c => EbayLogger.LogTraceInnerError(this.CreateMethodCallInfo(methodParameters, mark, getOrdersResponse.Errors.ToJson())), new List <ResponseError> {
EbayErrors.EbayPixelSizeError, EbayErrors.LvisBlockedError, EbayErrors.UnsupportedListingType, EbayErrors.RequestedUserIsSuspended
});
getOrdersResponse.ThrowOnError();
if (getOrdersResponse.Orders == null)
{
return(new List <string>());
}
var distinctOrdersIds = getOrdersResponse.Orders.Distinct(new OrderEqualityComparerById()).Select(x => x.GetOrderId(false)).ToList();
var existsOrders = (from s in sourceOrdersIds join d in distinctOrdersIds on s equals d select s).ToList();
EbayLogger.LogTraceEnded(this.CreateMethodCallInfo(methodParameters, mark, methodResult: existsOrders.ToJson()));
return(existsOrders);
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error. Was called:{0}", this.CreateMethodCallInfo(methodParameters, mark)), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
protected async Task <IEnumerable <UpdateInventoryResponse> > UpdateInventoryCallEconomAlgorithmAsync(IEnumerable <UpdateInventoryRequest> products)
{
var updateInventoryRequests = products as IList <UpdateInventoryRequest> ?? products.ToList();
var methodParameters = updateInventoryRequests.ToJson();
var mark = Guid.NewGuid().ToString();
try
{
EbayLogger.LogTraceStarted(this.CreateMethodCallInfo(methodParameters, mark));
updateInventoryRequests.ForEach(x => x.Quantity = x.Quantity < 0 ? 0 : x.Quantity);
var exceptions = new List <Exception>();
#region revise inventory status
var reviseInventoryStatusResponses = new List <InventoryStatusResponse>();
var reviseInventoryStatusResponsesWithErrors = new List <InventoryStatusResponse>();
try
{
var reviseInventoryStatusRequests = updateInventoryRequests.Select(x => new InventoryStatusRequest {
ItemId = x.ItemId, Sku = x.Sku, Quantity = x.Quantity
}).ToList();
var temp = await this.EbayServiceLowLevel.ReviseInventoriesStatusAsync(reviseInventoryStatusRequests, mark).ConfigureAwait(false);
reviseInventoryStatusResponses = temp.ToList();
var reviseInventoryStatusResponsesList = temp.ToList();
EbayLogger.LogTrace(this.CreateMethodCallInfo(methodParameters, mark, methodResult: reviseInventoryStatusResponsesList.ToJson(), additionalInfo: "ReviseInventoryStatus responses."));
var errorsToSkip = new List <ResponseError> {
EbayErrors.EbayPixelSizeError, EbayErrors.LvisBlockedError, EbayErrors.UnsupportedListingType, EbayErrors.ReplaceableValue, EbayErrors.VariationLevelSKUAndItemIDShouldBeSupplied
};
var errorsFromResponsesThatMustBeSkipped = reviseInventoryStatusResponsesList.CollectAllErros().Where(x => errorsToSkip.Any(y => y.ErrorCode == x.ErrorCode)).ToList();
EbayLogger.LogTraceInnerErrorSkipped(this.CreateMethodCallInfo(methodParameters, mark, errorsFromResponsesThatMustBeSkipped.ToJson()));
reviseInventoryStatusResponsesList.SkipErrorsAndDo(null, errorsFromResponsesThatMustBeSkipped);
reviseInventoryStatusResponsesWithErrors = reviseInventoryStatusResponsesList.GetOnlyResponsesWithErrors(null).ToList();
var reviseInventoryStatusResponsesWithoutErrors = reviseInventoryStatusResponsesList.GetOnlyResponsesWithoutErrors(null);
var items = reviseInventoryStatusResponsesWithoutErrors.Where(y => y.Items != null).SelectMany(x => x.Items).ToList();
EbayLogger.LogTrace(this.CreateMethodCallInfo(methodParameters, mark, methodResult: items.ToJson(), additionalInfo: "Products updated without errors with helpof ReviseInventoryStatus."));
EbayLogger.LogTrace(this.CreateMethodCallInfo(methodParameters, mark, methodResult: reviseInventoryStatusResponsesWithErrors.ToJson(), additionalInfo: "Products updated with errors with helpof ReviseInventoryStatus. Will be retryed with ReviseFixedPriseItem."));
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error:{0})", this.CreateMethodCallInfo(methodParameters, mark)), exception);
LogTraceException(ebayException.Message, ebayException);
exceptions.Add(exception);
}
#endregion
#region revise fixed price item
var reviseFixedPriceItemResponses = new List <ReviseFixedPriceItemResponse>();
if (reviseInventoryStatusResponsesWithErrors.Any())
{
try
{
var reviseInventoryStatusResponsesWithErrorsItems = reviseInventoryStatusResponsesWithErrors.Where(y => y.RequestedItems != null).SelectMany(y => y.RequestedItems).ToList();
var productsToReviseFixedPriceItem = updateInventoryRequests.Where(x => x != null).Where(x => reviseInventoryStatusResponsesWithErrorsItems.Any(z => z.ItemId == x.ItemId && z.Sku == x.Sku)).ToList();
var reviseFixedPriceItemRequests = productsToReviseFixedPriceItem.Select(x => new ReviseFixedPriceItemRequest()
{
ConditionID = x.ConditionID, IsVariation = x.IsVariation, ItemId = x.ItemId, Quantity = x.Quantity, Sku = x.Sku
});
EbayLogger.LogTrace(this.CreateMethodCallInfo(reviseFixedPriceItemRequests.ToJson(), mark, additionalInfo: "Trying to update products with helpof ReviseFixedPriseItem."));
var reviseFixedPriceItemResponsesEnumerable = await reviseFixedPriceItemRequests.ProcessInBatchAsync(this.EbayServiceLowLevel.MaxThreadsCount, async x =>
{
ReviseFixedPriceItemResponse res = null;
var IsItVariationItem = false;
var repeatCount = 0;
await ActionPolicies.GetAsyncShort.Do(async() =>
{
if (repeatCount == 0)
{
IsItVariationItem = x.IsVariation;
}
res = await this.EbayServiceLowLevel.ReviseFixedPriceItemAsync(x, mark, IsItVariationItem).ConfigureAwait(false);
if (res.Item == null)
{
res.Item = new Models.ReviseFixedPriceItemResponse.Item();
}
res.Item.Sku = x.Sku;
res.Item.ItemId = x.ItemId;
res.SkipErrorsAndDo(c => EbayLogger.LogTraceInnerError(this.CreateMethodCallInfo(methodParameters, mark, res.Errors.ToJson())), new List <ResponseError> {
EbayErrors.EbayPixelSizeError, EbayErrors.LvisBlockedError, EbayErrors.UnsupportedListingType, EbayErrors.ReplaceableValue
});
if (res.Errors == null || !res.Errors.Any())
{
return;
}
if (res.Errors != null && res.Errors.Exists(y => y.ErrorCode == "21916585"))
{
IsItVariationItem = !IsItVariationItem;
}
if (repeatCount++ < 3)
{
throw new EbayCommonException(string.Format("Error.{0}", this.CreateMethodCallInfo(x.ToJson(), mark, res.Errors.ToJson())));
}
}).ConfigureAwait(false);
return(res);
}).ConfigureAwait(false);
reviseFixedPriceItemResponses = reviseFixedPriceItemResponsesEnumerable.ToList();
reviseFixedPriceItemResponses.ThrowOnError(x => (x.Select(y => ( ReviseFixedPriceItemResponse )y).ToList()).ToJson());
var items = reviseFixedPriceItemResponses.Where(y => y.Item != null).Select(x => x.Item).ToList();
EbayLogger.LogTrace(this.CreateMethodCallInfo(methodParameters, mark, methodResult: items.ToJson()));
}
catch (Exception exc)
{
exceptions.Add(exc);
}
}
#endregion
if (exceptions.Count > 0)
{
throw new AggregateException(exceptions);
}
var updateInventoryResponses = new List <UpdateInventoryResponse>();
updateInventoryResponses.AddRange(reviseInventoryStatusResponses.ToUpdateInventoryResponses().ToList());
updateInventoryResponses.AddRange(reviseFixedPriceItemResponses.ToUpdateInventoryResponses().ToList());
EbayLogger.LogTraceEnded(this.CreateMethodCallInfo(methodParameters, mark, methodResult: updateInventoryResponses.ToJson()));
return(updateInventoryResponses);
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error:{0})", this.CreateMethodCallInfo(methodParameters, mark)), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
protected async Task <IEnumerable <UpdateInventoryResponse> > UpdateInventoryCallExpensiveAlgorithmAsync(IEnumerable <UpdateInventoryRequest> products)
{
var updateInventoryRequests = products as IList <UpdateInventoryRequest> ?? products.ToList();
var methodParameters = updateInventoryRequests.ToJson();
var mark = Guid.NewGuid().ToString();
try
{
EbayLogger.LogTraceStarted(this.CreateMethodCallInfo(methodParameters, mark));
updateInventoryRequests.ForEach(x => x.Quantity = x.Quantity < 0 ? 0 : x.Quantity);
var inventoryStatusRequests = updateInventoryRequests.Where(x => x.Quantity > 0).Select(x => new InventoryStatusRequest {
ItemId = x.ItemId, Sku = x.Sku, Quantity = x.Quantity
}).ToList();
var reviseFixedPriceItemRequests = updateInventoryRequests.Where(x => x.Quantity == 0).Select(x => new ReviseFixedPriceItemRequest {
ItemId = x.ItemId, Sku = x.Sku, Quantity = x.Quantity, ConditionID = x.ConditionID, IsVariation = x.IsVariation
}).ToList();
var exceptions = new List <Exception>();
var updateProductsResponses = Enumerable.Empty <InventoryStatusResponse>();
try
{
updateProductsResponses = await this.ReviseInventoriesStatusAsync(inventoryStatusRequests, mark).ConfigureAwait(false);
}
catch (Exception exc)
{
exceptions.Add(exc);
}
var updateFixedPriceItemResponses = Enumerable.Empty <ReviseFixedPriceItemResponse>();
try
{
updateFixedPriceItemResponses = await this.ReviseFixePriceItemsAsync(reviseFixedPriceItemRequests, mark).ConfigureAwait(false);
}
catch (Exception exc)
{
exceptions.Add(exc);
}
if (exceptions.Count > 0)
{
throw new AggregateException(exceptions);
}
var updateInventoryResponses = new List <UpdateInventoryResponse>();
updateInventoryResponses.AddRange(updateProductsResponses.ToUpdateInventoryResponses().ToList());
updateInventoryResponses.AddRange(updateFixedPriceItemResponses.ToUpdateInventoryResponses().ToList());
EbayLogger.LogTraceEnded(this.CreateMethodCallInfo(methodParameters, mark, methodResult: updateInventoryResponses.ToJson()));
return(updateInventoryResponses);
}
catch (Exception exception)
{
var ebayException = new EbayCommonException(string.Format("Error:{0})", this.CreateMethodCallInfo(methodParameters, mark)), exception);
LogTraceException(ebayException.Message, ebayException);
throw ebayException;
}
}
