Refactor views to support dynamic updates.

2024-07-26 19:15:38 -07:00
parent 33dee47205
commit d5c4e56c45
80 changed files with 3714 additions and 4021 deletions
@@ -0,0 +1,131 @@
+import { CapabilitySearchOptions, MediaQuery } from '../../camera-manager/types';
+import { MEDIA_CHUNK_SIZE_DEFAULT } from '../../const';
+import { ClipsOrSnapshotsOrAll } from '../../types';
+import { findBestMediaIndex } from '../../utils/find-best-media-index';
+import {
+  EventMediaQueries,
+  MediaQueries,
+  RecordingMediaQueries,
+} from '../../view/media-queries';
+import { MediaQueriesResults } from '../../view/media-queries-results';
+import { CardViewAPI } from '../types';
+import { QueryExecutorOptions, QueryWithResults } from './types';
+
+export class QueryExecutor {
+  protected _api: CardViewAPI;
+
+  constructor(api: CardViewAPI) {
+    this._api = api;
+  }
+
+  public async executeDefaultEventQuery(options?: {
+    cameraID?: string;
+    eventsMediaType?: ClipsOrSnapshotsOrAll;
+    executorOptions?: QueryExecutorOptions;
+  }): Promise<QueryWithResults | null> {
+    const capabilitySearch: CapabilitySearchOptions =
+      !options?.eventsMediaType || options?.eventsMediaType === 'all'
+        ? {
+            anyCapabilities: ['clips', 'snapshots'],
+          }
+        : options.eventsMediaType;
+
+    const cameraManager = this._api.getCameraManager();
+    const cameraIDs = options?.cameraID
+      ? cameraManager
+          .getStore()
+          .getAllDependentCameras(options.cameraID, capabilitySearch)
+      : cameraManager.getStore().getCameraIDsWithCapability(capabilitySearch);
+    if (!cameraIDs.size) {
+      return null;
+    }
+
+    const rawQueries = cameraManager.generateDefaultEventQueries(cameraIDs, {
+      limit: this._getChunkLimit(),
+      ...(options?.eventsMediaType === 'clips' && { hasClip: true }),
+      ...(options?.eventsMediaType === 'snapshots' && { hasSnapshot: true }),
+    });
+    if (!rawQueries) {
+      return null;
+    }
+    const queries = new EventMediaQueries(rawQueries);
+    const results = await this.execute(queries, options?.executorOptions);
+    return results
+      ? {
+          query: queries,
+          queryResults: results,
+        }
+      : null;
+  }
+
+  public async executeDefaultRecordingQuery(options?: {
+    cameraID?: string;
+    executorOptions?: QueryExecutorOptions;
+  }): Promise<QueryWithResults | null> {
+    const cameraManager = this._api.getCameraManager();
+    const cameraIDs = options?.cameraID
+      ? cameraManager.getStore().getAllDependentCameras(options.cameraID, 'recordings')
+      : cameraManager.getStore().getCameraIDsWithCapability('recordings');
+    if (!cameraIDs.size) {
+      return null;
+    }
+
+    const rawQueries = cameraManager.generateDefaultRecordingQueries(cameraIDs, {
+      limit: this._getChunkLimit(),
+    });
+    if (!rawQueries) {
+      return null;
+    }
+    const queries = new RecordingMediaQueries(rawQueries);
+    const results = await this.execute(queries, options?.executorOptions);
+    return results ? { query: queries, queryResults: results } : null;
+  }
+
+  public async execute(
+    query: MediaQueries,
+    executorOptions?: QueryExecutorOptions,
+  ): Promise<MediaQueriesResults | null> {
+    const queries = query.getQueries();
+    if (!queries) {
+      return null;
+    }
+
+    const mediaArray = await this._api
+      .getCameraManager()
+      .executeMediaQueries<MediaQuery>(queries, {
+        useCache: executorOptions?.useCache,
+      });
+    if (!mediaArray) {
+      return null;
+    }
+
+    const queryResults = new MediaQueriesResults({ results: mediaArray });
+    if (executorOptions?.rejectResults?.(queryResults)) {
+      return null;
+    }
+
+    if (executorOptions?.selectResult?.id) {
+      queryResults.selectBestResult((media) =>
+        media.findIndex((m) => m.getID() === executorOptions.selectResult?.id),
+      );
+    } else if (executorOptions?.selectResult?.func) {
+      queryResults.selectResultIfFound(executorOptions.selectResult.func);
+    } else if (executorOptions?.selectResult?.time) {
+      queryResults.selectBestResult((media) =>
+        findBestMediaIndex(
+          media,
+          executorOptions.selectResult?.time?.time as Date,
+          executorOptions.selectResult?.time?.favorCameraID,
+        ),
+      );
+    }
+    return queryResults;
+  }
+
+  protected _getChunkLimit(): number {
+    const cardWideConfig = this._api.getConfigManager().getCardWideConfig();
+    return (
+      cardWideConfig?.performance?.features.media_chunk_size ?? MEDIA_CHUNK_SIZE_DEFAULT
+    );
+  }
+}