gloomberb 0.6.1 → 0.7.1

package/src/sources/provider-router.test.ts

@@ -195,6 +195,128 @@ describe("AssetDataRouter", () => {
     expect(holders.holders[0]?.name).toBe("Vanguard Group Inc");
   });
 
+  test("falls back to later analyst providers when rating targets are missing", async () => {
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "cloud",
+          symbol,
+          ratings: [{ date: "2026-05-01", firm: "Cloud Firm", action: "Raises", current: "Buy", prior: "Buy" }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "yahoo",
+          symbol,
+          ratings: [{
+            date: "2026-05-01",
+            firm: "Yahoo Firm",
+            action: "Raises",
+            current: "Buy",
+            prior: "Buy",
+            currentPriceTarget: 680,
+            priorPriceTarget: 595,
+          }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+
+    const router = new AssetDataRouter(yahooProvider, [cloudProvider]);
+    const research = await router.getAnalystResearch("AAPL", "NASDAQ");
+
+    expect(research.providerId).toBe("yahoo");
+    expect(research.ratings[0]?.currentPriceTarget).toBe(680);
+    expect(research.ratings[0]?.priorPriceTarget).toBe(595);
+  });
+
+  test("prefers cached analyst records with rating targets", async () => {
+    const dbPath = createTempDbPath("cached-analyst-targets");
+    const persistence = new AppPersistence(dbPath);
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "cloud",
+          symbol,
+          ratings: [{ date: "2026-05-01", firm: "Cloud Firm", action: "Raises", current: "Buy", prior: "Buy" }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "yahoo",
+          symbol,
+          ratings: [{
+            date: "2026-05-01",
+            firm: "Yahoo Firm",
+            action: "Raises",
+            current: "Buy",
+            prior: "Buy",
+            currentPriceTarget: 680,
+            priorPriceTarget: 595,
+          }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const unavailableProvider = (id: string, priority: number): DataProvider => ({
+      ...fallbackProvider,
+      id,
+      name: id,
+      priority,
+      async getAnalystResearch() {
+        throw new Error(`${id} should not be fetched`);
+      },
+    });
+
+    try {
+      const seedRouter = new AssetDataRouter(yahooProvider, [cloudProvider], persistence.resources);
+      await seedRouter.getAnalystResearch("AAPL", "NASDAQ");
+
+      const cachedRouter = new AssetDataRouter(
+        unavailableProvider("yahoo", 1000),
+        [unavailableProvider("cloud", 100)],
+        persistence.resources,
+      );
+      const research = await cachedRouter.getAnalystResearch("AAPL", "NASDAQ");
+
+      expect(research.providerId).toBe("yahoo");
+      expect(research.ratings[0]?.currentPriceTarget).toBe(680);
+      expect(research.ratings[0]?.priorPriceTarget).toBe(595);
+    } finally {
+      persistence.close();
+    }
+  });
+
   test("prefers broker quotes over fallback quotes", async () => {
     const router = new AssetDataRouter(fallbackProvider);
     const broker: BrokerAdapter = {

package/src/sources/provider-router.ts

@@ -8,9 +8,11 @@ import type {
   CachedFinancialsTarget,
   DataProvider,
   MarketDataRequestContext,
+  QuoteBatchResult,
   QuoteSubscriptionTarget,
   SearchRequestContext,
   SecFilingItem,
+  TickerFinancialsBatchResult,
 } from "../types/data-provider";
 import type { CapabilityRouteSource } from "../types/capability-route-source";
 import { routeSourcePriority } from "../types/capability-route-source";
@@ -134,10 +136,6 @@ function isIntradayRange(range: TimeRange): boolean {
   return range === "1D" || range === "1W" || range === "1M" || range === "3M";
 }
 
-function hasMeaningfulFundamentals(data: TickerFinancials | null | undefined): boolean {
-  return !!data && Object.keys(data.fundamentals ?? {}).length > 0;
-}
-
 function hasMeaningfulProfile(data: TickerFinancials | null | undefined): boolean {
   return !!data && !!(
     data.profile?.description
@@ -154,6 +152,16 @@ function hasAnalystResearchValue(data: AnalystResearchData): boolean {
     || data.revenueEstimates.length > 0;
 }
 
+function hasAnalystRatingPriceTargets(data: AnalystResearchData): boolean {
+  return data.ratings.some((rating) => (
+    rating.currentPriceTarget != null || rating.priorPriceTarget != null
+  ));
+}
+
+function isAnalystResearchMissingRatingTargets(data: AnalystResearchData): boolean {
+  return data.ratings.length > 0 && !hasAnalystRatingPriceTargets(data);
+}
+
 function hasCorporateActionsValue(data: CorporateActionsData): boolean {
   return data.dividends.length > 0
     || data.splits.length > 0
@@ -349,6 +357,135 @@ export class AssetDataRouter implements DataProvider {
     return results;
   }
 
+  async getQuotesBatch(
+    targets: QuoteSubscriptionTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<QuoteBatchResult[]> {
+    const forceRefresh = options.forceRefresh === true;
+    const results = new Array<QuoteBatchResult | null>(targets.length).fill(null);
+    const misses: Array<{ index: number; target: QuoteSubscriptionTarget }> = [];
+
+    targets.forEach((target, index) => {
+      const context = target.context;
+      const entityKey = this.getEntityKey(target.symbol, target.exchange, context?.instrument);
+      const variantKeys = this.getTickerVariantCandidates(target.exchange);
+      const sourceKeys = [
+        ...this.getBrokerCandidatesForContext(context, false).map((candidate) => this.brokerSourceKey(candidate)),
+        ...this.getProviderSourceKeys(),
+      ];
+      const rawCached = this.selectCachedResource<Quote>("quote", entityKey, variantKeys, sourceKeys, false);
+      const cached = rawCached && !isQuoteStaleForCurrentSession(rawCached.value)
+        ? rawCached
+        : null;
+      if (cached && !forceRefresh && !cached.stale) {
+        results[index] = { target, quote: cached.value };
+        return;
+      }
+      misses.push({ index, target });
+    });
+
+    const batchProvider = this.providersInPriorityOrder().find((provider) => provider.getQuotesBatch);
+    const providerMisses = misses.filter(({ target }) => !this.hasBrokerContext(target.context));
+    const providerIndexes = new Map<string, Array<{ index: number; target: QuoteSubscriptionTarget }>>();
+    if (batchProvider && providerMisses.length > 0) {
+      for (const entry of providerMisses) {
+        const key = this.quoteBatchKey(entry.target);
+        const bucket = providerIndexes.get(key) ?? [];
+        bucket.push(entry);
+        providerIndexes.set(key, bucket);
+      }
+      const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
+      const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, options).catch(() => []);
+      for (const item of batchResults) {
+        if (!item.quote) continue;
+        const key = this.quoteBatchKey(item.target);
+        const sourceKey = this.providerSourceKey(batchProvider);
+        for (const entry of providerIndexes.get(key) ?? []) {
+          const entityKey = this.getEntityKey(entry.target.symbol, entry.target.exchange, entry.target.context?.instrument);
+          const variantKey = this.getTickerVariantCandidates(entry.target.exchange)[0] ?? "";
+          this.cacheResource("quote", entityKey, variantKey, sourceKey, item.quote, this.resolveProviderPolicy("quote", batchProvider));
+          results[entry.index] = { target: entry.target, quote: item.quote };
+        }
+      }
+    }
+
+    await Promise.all(misses.map(async ({ index, target }) => {
+      if (results[index]) return;
+      try {
+        const quote = await this.getQuote(target.symbol, target.exchange, {
+          ...target.context,
+          cacheMode: forceRefresh ? "refresh" : "default",
+        });
+        results[index] = { target, quote };
+      } catch (error) {
+        results[index] = { target, quote: null, error };
+      }
+    }));
+
+    return results.map((result, index) => result ?? { target: targets[index]!, quote: null });
+  }
+
+  async getTickerFinancialsBatch(
+    targets: CachedFinancialsTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<TickerFinancialsBatchResult[]> {
+    const forceRefresh = options.forceRefresh === true;
+    const results = new Array<TickerFinancialsBatchResult | null>(targets.length).fill(null);
+    const misses: Array<{ index: number; target: CachedFinancialsTarget }> = [];
+
+    targets.forEach((target, index) => {
+      const context = this.contextFromCachedTarget(target);
+      const cached = this.readCachedMergedFinancialsSelection(target.symbol, target.exchange, context, true);
+      if (cached.value && !forceRefresh) {
+        results[index] = { target, financials: cached.value };
+        return;
+      }
+      misses.push({ index, target });
+    });
+
+    const batchProvider = this.providersInPriorityOrder().find((provider) => provider.getTickerFinancialsBatch);
+    const providerMisses = misses.filter(({ target }) => !this.hasCachedTargetBrokerContext(target));
+    const providerIndexes = new Map<string, Array<{ index: number; target: CachedFinancialsTarget }>>();
+    if (batchProvider && providerMisses.length > 0) {
+      for (const entry of providerMisses) {
+        const key = this.cachedFinancialsBatchKey(entry.target);
+        const bucket = providerIndexes.get(key) ?? [];
+        bucket.push(entry);
+        providerIndexes.set(key, bucket);
+      }
+      const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
+      const batchResults = await batchProvider.getTickerFinancialsBatch!(uniqueTargets, options).catch(() => []);
+      for (const item of batchResults) {
+        if (!item.financials) continue;
+        const key = this.cachedFinancialsBatchKey(item.target);
+        const value = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(item.financials));
+        if (!value) continue;
+        const sourceKey = this.providerSourceKey(batchProvider);
+        for (const entry of providerIndexes.get(key) ?? []) {
+          const entityKey = this.getEntityKey(entry.target.symbol, entry.target.exchange, entry.target.instrument ?? undefined);
+          const variantKey = this.getTickerVariantCandidates(entry.target.exchange)[0] ?? "";
+          this.cacheResource("financials", entityKey, variantKey, sourceKey, value, this.resolveProviderPolicy("financials", batchProvider));
+          results[entry.index] = { target: entry.target, financials: value };
+        }
+      }
+    }
+
+    await Promise.all(misses.map(async ({ index, target }) => {
+      if (results[index]) return;
+      try {
+        const financials = await this.getTickerFinancials(target.symbol, target.exchange, {
+          ...this.contextFromCachedTarget(target),
+          cacheMode: forceRefresh ? "refresh" : "default",
+        });
+        results[index] = { target, financials };
+      } catch (error) {
+        results[index] = { target, financials: null, error };
+      }
+    }));
+
+    return results.map((result, index) => result ?? { target: targets[index]!, financials: null });
+  }
+
   async getTickerFinancials(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<TickerFinancials> {
     const cached = this.readCachedMergedFinancialsSelection(ticker, exchange, context, false);
     const forceRefresh = context?.cacheMode === "refresh";
@@ -522,9 +659,9 @@ export class AssetDataRouter implements DataProvider {
   async getAnalystResearch(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<AnalystResearchData> {
     const entityKey = this.getEntityKey(ticker, exchange, context?.instrument);
     const variantKeys = this.getTickerVariantCandidates(exchange);
-    const cached = this.selectCachedResource<AnalystResearchData>("analystResearch", entityKey, variantKeys, this.getProviderSourceKeys(), false);
+    const cached = this.selectCachedAnalystResearch(entityKey, variantKeys, this.getProviderSourceKeys(), false);
     const forceRefresh = context?.cacheMode === "refresh";
-    if (cached && !forceRefresh) {
+    if (cached && !forceRefresh && !isAnalystResearchMissingRatingTargets(cached.value)) {
       this.scheduleRevalidation(this.makeRevalidationKey("analystResearch", ticker, exchange, context), async () => {
         await this.revalidateAnalystResearch(ticker, exchange, context);
       });
@@ -880,7 +1017,17 @@ export class AssetDataRouter implements DataProvider {
     sourceKeys: string[],
     allowExpired: boolean,
   ): CachedResourceRecord<T> | null {
-    return this.listCachedResources(kind, entityKey, variantKeys, sourceKeys, allowExpired)[0] ?? null;
+    return this.listCachedResources<T>(kind, entityKey, variantKeys, sourceKeys, allowExpired)[0] ?? null;
+  }
+
+  private selectCachedAnalystResearch(
+    entityKey: string,
+    variantKeys: string[],
+    sourceKeys: string[],
+    allowExpired: boolean,
+  ): CachedResourceRecord<AnalystResearchData> | null {
+    const records = this.listCachedResources<AnalystResearchData>("analystResearch", entityKey, variantKeys, sourceKeys, allowExpired);
+    return records.find((record) => !isAnalystResearchMissingRatingTargets(record.value)) ?? records[0] ?? null;
   }
 
   private selectCachedArrayResource<T>(
@@ -1009,14 +1156,42 @@ export class AssetDataRouter implements DataProvider {
     );
   }
 
-  private getStreamingBrokerCandidate(target: QuoteSubscriptionTarget): BrokerCandidate | null {
-    const hasBrokerContext = !!(
-      target.context?.brokerId
-      || target.context?.brokerInstanceId
-      || target.context?.instrument?.brokerId
-      || target.context?.instrument?.brokerInstanceId
+  private hasBrokerContext(context?: MarketDataRequestContext): boolean {
+    return !!(
+      context?.brokerId ||
+      context?.brokerInstanceId ||
+      context?.instrument?.brokerId ||
+      context?.instrument?.brokerInstanceId
+    );
+  }
+
+  private hasCachedTargetBrokerContext(target: CachedFinancialsTarget): boolean {
+    return !!(
+      target.brokerId ||
+      target.brokerInstanceId ||
+      target.instrument?.brokerId ||
+      target.instrument?.brokerInstanceId
     );
-    if (!hasBrokerContext) return null;
+  }
+
+  private contextFromCachedTarget(target: CachedFinancialsTarget): MarketDataRequestContext {
+    return {
+      brokerId: target.brokerId,
+      brokerInstanceId: target.brokerInstanceId,
+      instrument: target.instrument ?? null,
+    };
+  }
+
+  private quoteBatchKey(target: QuoteSubscriptionTarget): string {
+    return `${target.symbol.trim().toUpperCase()}:${canonicalExchange(target.exchange ?? "")}`;
+  }
+
+  private cachedFinancialsBatchKey(target: CachedFinancialsTarget): string {
+    return `${target.symbol.trim().toUpperCase()}:${canonicalExchange(target.exchange ?? "")}`;
+  }
+
+  private getStreamingBrokerCandidate(target: QuoteSubscriptionTarget): BrokerCandidate | null {
+    if (!this.hasBrokerContext(target.context)) return null;
     return this.getBrokerCandidatesForContext(target.context, false)
       .find((candidate) => typeof candidate.broker.subscribeQuotes === "function") ?? null;
   }
@@ -1583,6 +1758,7 @@ export class AssetDataRouter implements DataProvider {
     const entityKey = this.getEntityKey(ticker, exchange, context?.instrument);
     const variantKey = this.getTickerVariantCandidates(exchange)[0] ?? "";
     let firstEmptyResult: SourceResult<AnalystResearchData> | null = null;
+    let firstIncompleteResult: SourceResult<AnalystResearchData> | null = null;
     let lastError: unknown = null;
 
     for (const provider of this.providersInPriorityOrder()) {
@@ -1591,7 +1767,13 @@ export class AssetDataRouter implements DataProvider {
         const value = await provider.getAnalystResearch(ticker, exchange, context);
         const sourceKey = this.providerSourceKey(provider);
         this.cacheResource("analystResearch", entityKey, variantKey, sourceKey, value, this.resolveProviderPolicy("analystResearch", provider));
-        if (hasAnalystResearchValue(value)) return { sourceKey, value };
+        if (hasAnalystResearchValue(value)) {
+          if (isAnalystResearchMissingRatingTargets(value)) {
+            firstIncompleteResult ??= { sourceKey, value };
+            continue;
+          }
+          return { sourceKey, value };
+        }
         firstEmptyResult ??= { sourceKey, value };
       } catch (error) {
         lastError = error;
@@ -1601,6 +1783,7 @@ export class AssetDataRouter implements DataProvider {
       }
     }
 
+    if (firstIncompleteResult) return firstIncompleteResult;
     if (firstEmptyResult) return firstEmptyResult;
     if (lastError) throw lastError;
     return null;

package/src/sources/yahoo-finance.test.ts

@@ -32,4 +32,48 @@ describe("YahooFinanceClient exchange aliases", () => {
     });
     expect(history[0]?.close).toBe(200);
   });
+
+  test("preserves analyst rating price targets from upgrade history", async () => {
+    const provider = new YahooFinanceClient() as any;
+    let requestUrl = "";
+    provider.getSymbolsToTry = () => ["AMD"];
+    provider.fetchJsonWithCrumb = async (_label: string, url: string) => {
+      requestUrl = url;
+      return {
+        quoteSummary: {
+          result: [{
+            price: { symbol: "AMD", currency: "USD", exchangeName: "NasdaqGS" },
+            financialData: {},
+            recommendationTrend: { trend: [] },
+            earningsTrend: { trend: [] },
+            upgradeDowngradeHistory: {
+              history: [{
+                epochGradeDate: 1778188318,
+                firm: "Citigroup",
+                toGrade: "Neutral",
+                fromGrade: "Neutral",
+                action: "main",
+                priceTargetAction: "Raises",
+                currentPriceTarget: 358,
+                priorPriceTarget: 248,
+              }],
+            },
+          }],
+        },
+      };
+    };
+
+    const research = await provider.getAnalystResearch("AMD", "NASDAQ");
+
+    expect(requestUrl).toContain("upgradeDowngradeHistory");
+    expect(research.ratings[0]).toMatchObject({
+      date: "2026-05-07",
+      firm: "Citigroup",
+      action: "Raises",
+      current: "Neutral",
+      prior: "Neutral",
+      currentPriceTarget: 358,
+      priorPriceTarget: 248,
+    });
+  });
 });

package/src/sources/yahoo-finance.ts

@@ -179,6 +179,8 @@ type QuoteSummaryResponse = {
           priceTargetAction?: string;
           toGrade?: string;
           fromGrade?: string;
+          currentPriceTarget?: { raw?: number } | number | null;
+          priorPriceTarget?: { raw?: number } | number | null;
         }>;
       };
       earningsTrend?: {
@@ -412,12 +414,16 @@ function mapYahooAnalystResearchResponse(
         const action = normalizeYahooRatingAction(rating.action, rating.priceTargetAction);
         const current = rating.toGrade?.trim();
         const prior = rating.fromGrade?.trim();
+        const currentPriceTarget = financeRawNumber(rating.currentPriceTarget);
+        const priorPriceTarget = financeRawNumber(rating.priorPriceTarget);
         return {
           date,
           firm,
           ...(action ? { action } : {}),
           ...(current ? { current } : {}),
           ...(prior ? { prior } : {}),
+          ...(currentPriceTarget != null ? { currentPriceTarget } : {}),
+          ...(priorPriceTarget != null ? { priorPriceTarget } : {}),
         };
       })
       .filter((rating): rating is AnalystResearchData["ratings"][number] => rating !== null)

package/src/state/app-bootstrap.ts

@@ -54,6 +54,8 @@ export interface InitializeAppStateArgs {
   primeCachedFinancials?: (entries: Array<{ ticker: TickerRecord; financials: TickerFinancials }>) => void;
   refreshTicker: (symbol: string, exchange?: string, tickerOverride?: TickerRecord | null, priority?: number) => void;
   refreshQuote: (symbol: string, exchange?: string, tickerOverride?: TickerRecord | null, priority?: number) => void;
+  refreshTickersBatch?: (entries: Array<{ ticker: TickerRecord; priority: number }>) => void;
+  refreshQuotesBatch?: (entries: Array<{ ticker: TickerRecord; priority: number }>) => void;
   autoImportBrokerPositions: (tickerMap: Map<string, TickerRecord>) => Promise<void>;
   persistedBrokerAccounts?: Record<string, BrokerAccount[]>;
 }
@@ -211,11 +213,11 @@ function buildCachedFinancialTarget(ticker: TickerRecord): CachedFinancialsTarge
   };
 }
 
-function resolveCachedFinancialPrimeEntries(
+async function resolveCachedFinancialPrimeEntries(
   refreshPlan: RefreshPlanEntry[],
   sessionSnapshot: AppSessionSnapshot | null | undefined,
   dataProvider: DataProvider,
-): Array<{ ticker: TickerRecord; financials: TickerFinancials }> {
+): Promise<Array<{ ticker: TickerRecord; financials: TickerFinancials }>> {
   if (!dataProvider.getCachedFinancialsForTargets) return [];
 
   const sessionTargetsBySymbol = new Map<string, CachedFinancialsTarget>();
@@ -226,7 +228,7 @@ function resolveCachedFinancialPrimeEntries(
   const financialEntries = refreshPlan.filter((entry) => entry.mode === "financials");
   if (financialEntries.length === 0) return [];
 
-  const cachedFinancials = dataProvider.getCachedFinancialsForTargets(
+  const cachedFinancials = await dataProvider.getCachedFinancialsForTargets(
     financialEntries.map(({ ticker }) => (
       sessionTargetsBySymbol.get(ticker.metadata.ticker.trim().toUpperCase()) ?? buildCachedFinancialTarget(ticker)
     )),
@@ -252,6 +254,8 @@ export async function initializeAppState({
   primeCachedFinancials,
   refreshTicker,
   refreshQuote,
+  refreshTickersBatch,
+  refreshQuotesBatch,
   autoImportBrokerPositions,
   persistedBrokerAccounts = {},
 }: InitializeAppStateArgs): Promise<void> {
@@ -341,7 +345,7 @@ export async function initializeAppState({
   });
 
   if (primeCachedFinancials) {
-    const cachedPrimeEntries = measurePerf(
+    const cachedPrimeEntries = await measurePerfAsync(
       "startup.resolve-cached-financial-prime",
       () => resolveCachedFinancialPrimeEntries(refreshPlan, sessionSnapshot, dataProvider),
       { financialRefreshCount: refreshPlan.filter((entry) => entry.mode === "financials").length },
@@ -362,10 +366,19 @@ export async function initializeAppState({
   });
 
   measurePerf("startup.enqueue-refresh-plan", () => {
-    for (const entry of refreshPlan) {
-      if (entry.mode === "financials") {
+    const financialEntries = refreshPlan.filter((entry) => entry.mode === "financials");
+    const quoteEntries = refreshPlan.filter((entry) => entry.mode === "quote");
+    if (refreshTickersBatch) {
+      refreshTickersBatch(financialEntries.map((entry) => ({ ticker: entry.ticker, priority: entry.priority })));
+    } else {
+      for (const entry of financialEntries) {
         refreshTicker(entry.ticker.metadata.ticker, entry.ticker.metadata.exchange, entry.ticker, entry.priority);
-      } else {
+      }
+    }
+    if (refreshQuotesBatch) {
+      refreshQuotesBatch(quoteEntries.map((entry) => ({ ticker: entry.ticker, priority: entry.priority })));
+    } else {
+      for (const entry of quoteEntries) {
         refreshQuote(entry.ticker.metadata.ticker, entry.ticker.metadata.exchange, entry.ticker, entry.priority);
       }
     }