public void Add(FetchResultCounters other)
            {
                if (other == null)
                {
                    return;
                }

                if (!other.RequestCount.IsEmpty)
                {
                    RequestCount.Add(other.RequestCount);
                }

                OrderCount += other.OrderCount;
            }     // Add
        }         // class FetchResultCounters

        private FetchResultCounters FetchOnePeriodTransactions(
            int mpID,
            IDatabaseCustomerMarketPlace databaseCustomerMarketPlace,
            ElapsedTimeInfo elapsedTimeInfo,
            DataProviderCreationInfo info,
            MP_CustomerMarketplaceUpdatingHistory historyRecord,
            FetchPeriod period
            )
        {
            this.log.Debug("Fetching eBay orders '{0}'@{1}...", mpID, period);

            ResultInfoOrders orders = ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
                elapsedTimeInfo,
                mpID,
                ElapsedDataMemberType.RetrieveDataFromExternalService,
                () => DataProviderGetOrders.GetOrders(
                    info,
                    new ParamsDataInfoGetOrdersFromDateToDateCreated(period.From, period.To)
                    )
                );

            EbayDatabaseOrdersList databaseOrdersList = ParseOrdersInfo(orders);

            DateTime?max = null;
            DateTime?min = null;

            foreach (EbayDatabaseOrderItem o in databaseOrdersList.Where(x => x.CreatedTime != null))
            {
                DateTime c = o.CreatedTime.Value;

                if ((min == null) || (c < min.Value))
                {
                    min = c;
                }

                if ((max == null) || (c > max.Value))
                {
                    max = c;
                }
            }             // for each

            this.log.Debug(
                "Fetching eBay orders '{0}'@{1}: {2} are ready to be stored; " +
                "min order date is '{3}', max order date is '{4}'.",
                mpID,
                period,
                Grammar.Number(databaseOrdersList.Count, "order"),
                (min == null) ? "N/A" : min.Value.ToString("d/MMM/yyyy H:mm:ss", CultureInfo.InvariantCulture),
                (max == null) ? "N/A" : max.Value.ToString("d/MMM/yyyy H:mm:ss", CultureInfo.InvariantCulture)
                );

            ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
                elapsedTimeInfo,
                mpID,
                ElapsedDataMemberType.StoreDataToDatabase,
                () => Helper.AddEbayOrdersData(databaseCustomerMarketPlace, databaseOrdersList, historyRecord)
                );

            this.log.Debug(
                "Fetching eBay orders '{0}'@{1}: {2} were stored.",
                mpID,
                period,
                Grammar.Number(databaseOrdersList.Count, "order")
                );

            EbayDatabaseOrdersList allEBayOrders = ElapsedTimeHelper.CalculateAndStoreElapsedTimeForCallInSeconds(
                elapsedTimeInfo,
                mpID,
                ElapsedDataMemberType.RetrieveDataFromDatabase,
                () => Helper.GetAllEBayOrders(orders.SubmittedDate, databaseCustomerMarketPlace)
                );

            this.log.Debug(
                "Fetching eBay orders '{0}'@{1}: {2} were loaded from DB.",
                mpID,
                period,
                Grammar.Number(allEBayOrders.Count, "order")
                );

            if (this.settings.DownloadCategories)
            {
                IEnumerable <string> topSealedProductItems = GetTopSealedProductItems(allEBayOrders);

                if (topSealedProductItems != null)
                {
                    List <MP_EBayOrderItemDetail> orderItemDetails = topSealedProductItems.Select(
                        item => FindEBayOrderItemInfo(
                            databaseCustomerMarketPlace,
                            info,
                            item,
                            databaseOrdersList.RequestsCounter,
                            elapsedTimeInfo
                            )
                        ).Where(d => d != null)
                                                                     .ToList();

                    Helper.UpdateOrderItemsInfo(orderItemDetails, elapsedTimeInfo, mpID);
                }         // if
            }             // if

            var frc = new FetchResultCounters(
                databaseOrdersList.RequestsCounter,
                (orders.Orders == null) ? 0 : orders.Orders.Count
                );

            this.log.Debug(
                "Done fetching eBay orders '{0}'@{1}: {2} fetched.",
                mpID,
                period,
                Grammar.Number(frc.OrderCount, "order")
                );

            return(frc);
        }         // FetchOnePeriodTransactions
        }         // UpdateUserInfo

        private IUpdateActionResultInfo FetchTransactions(
            IDatabaseCustomerMarketPlace databaseCustomerMarketPlace,
            DataProviderCreationInfo info,
            MP_CustomerMarketplaceUpdatingHistory historyRecord
            )
        {
            int mpID = databaseCustomerMarketPlace.Id;

            DateTime toDate = DateTime.UtcNow.Date;

            var elapsedTimeInfo = new ElapsedTimeInfo();

            DateTime fromDate = Helper.FindLastKnownEbayTransactionTime(mpID);

            var periods = new Stack <FetchPeriod>();

            DateTime t = toDate;

            while (t >= fromDate)
            {
                DateTime f = t.AddDays(-90).Date;

                periods.Push(new FetchPeriod {
                    To   = t.Date.AddDays(1).AddSeconds(-1),                   // convert to 23:59:59
                    From = (f < fromDate ? fromDate : f).Date,
                });

                t = f.AddDays(-1).Date;
            }             // while

            this.log.Debug(
                "Fetching eBay orders for marketplace '{0}' using these date range list: {1}.",
                mpID,
                string.Join("; ", periods)
                );

            var frc = new FetchResultCounters();

            foreach (var period in periods)
            {
                frc.Add(FetchOnePeriodTransactions(
                            mpID,
                            databaseCustomerMarketPlace,
                            elapsedTimeInfo,
                            info,
                            historyRecord,
                            period
                            ));
            }             // for each

            this.log.Debug(
                "Done fetching eBay orders for marketplace '{0}' using these date range list: {1}.",
                mpID,
                string.Join("; ", periods)
                );

            return(new UpdateActionResultInfo {
                Name = UpdateActionResultType.eBayOrdersCount,
                Value = frc.OrderCount,
                RequestsCounter = frc.RequestCount.IsEmpty ? null : frc.RequestCount,
                ElapsedTime = elapsedTimeInfo
            });
        }         // FetchTransactions