V2 Widget push

packages/changed-elements-react/public/locales/en/VersionCompare.json

@@ -1,9 +1,25 @@
 {
   "versionCompare": {
     "versionPickerTitle": "Version Compare",
+    "versionCompareInfo": "Discover what has changed between two iModel versions. To get started, click the + button, then choose the version to compare with. The data processing will begin in the background. Processing time may vary based on the data complexity. A notification will appear when results are available.",
+    "versionCompareLeaveFeedback": "Leave Feedback",
+    "versionCompareGettingStartedV2": "Click on the + comparison button to get started or check the progress of active comparison jobs.",
+    "versionComparisonStarting": "Comparison visualization starting.",
     "versionCompare": "Version Compare",
     "versionCompareBeta": "Version Compare",
+    "iModelVersions": "iModel versions",
+    "and": "and",
+    "jobProcessing": "are being processed in the background. You will receive a notification upon completion.",
+    "jobError":"An error occurred while processing changes between",
+    "jobComplete": "comparisons job is complete.",
+    "viewTheReport": "View The Report",
+    "withPrevious": "With previous",
+    "error": "Error",
+    "notProcessed": "Not Processed",
+    "queued": "Queued",
+    "available": "Available",
     "compare": "Compare",
+    "progress": "Progress",
     "comparisonLegend": "Comparison Legend",
     "loadingComparison": "Loading version comparison",
     "comparisonNotActive": "No version comparison active.",

packages/changed-elements-react/src/VersionCompareContext.tsx

@@ -3,13 +3,14 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 import { createContext, PropsWithChildren, ReactElement, useContext, useMemo } from "react";
-
 import type { IModelsClient } from "./clients/iModelsClient.js";
 import type { SavedFiltersManager } from "./SavedFiltersManager.js";
+import { IComparisonJobClient } from "./clients/IComparisonJobClient.js";
 
 export interface VersionCompareContextProps {
   iModelsClient: IModelsClient;
   savedFilters?: SavedFiltersManager | undefined;
+  comparisonJobClient?: IComparisonJobClient;
 }
 
 /**
@@ -20,9 +21,10 @@ export function VersionCompareContext(props: PropsWithChildren<VersionCompareCon
   const value = useMemo(
     () => ({
       iModelsClient: props.iModelsClient,
+      comparisonJobClient: props.comparisonJobClient,
       savedFilters: props.savedFilters,
     }),
-    [props.iModelsClient, props.savedFilters],
+    [props.comparisonJobClient, props.iModelsClient, props.savedFilters],
   );
   return <versionCompareContext.Provider value={value}>{props.children}</versionCompareContext.Provider>;
 }
@@ -44,6 +46,7 @@ Example:
 
 export interface VersionCompareContextValue {
   iModelsClient: IModelsClient;
+  comparisonJobClient?: IComparisonJobClient;
   savedFilters: SavedFiltersManager | undefined;
 }
 

packages/changed-elements-react/src/api/VersionCompareManager.ts

@@ -9,7 +9,6 @@ import {
   OutputMessagePriority
 } from "@itwin/core-frontend";
 import { KeySet } from "@itwin/presentation-common";
-
 import type { NamedVersion } from "../clients/iModelsClient.js";
 import { PropertyLabelCache } from "../dialogs/PropertyLabelCache.js";
 import type { ChangedElementEntry } from "./ChangedElementEntryCache.js";
@@ -374,6 +373,134 @@ export class VersionCompareManager {
     return success;
   }
 
+  /**
+   * Starts comparison by opening a new iModelConnection and setting up the store.
+   * @param currentIModel Current IModelConnection to be used to compare against
+   * @param currentVersion Current Version of the iModel
+   * @param targetVersion Target Version of the iModel, an IModelConnection is opened to it
+   * @param changedElements Array of elements that have changed and need to be visualized
+   */
+  public async startComparisonV2(
+    currentIModel: IModelConnection,
+    currentVersion: NamedVersion,
+    targetVersion: NamedVersion,
+    changedElements: ChangedElements[],
+  ): Promise<boolean> {
+    this._currentIModel = currentIModel;
+
+    let success = true;
+    try {
+      if (!targetVersion.changesetId) {
+        throw new Error("Cannot compare to a version if it doesn't contain a changeset Id");
+      }
+
+      // Setup visualization handler
+      this._initializeVisualizationHandler();
+      // Raise event that comparison is starting
+      this.versionCompareStarting.raiseEvent();
+
+      if (!this._currentIModel.iModelId || !this._currentIModel.iTwinId) {
+        throw new Error("Cannot compare with an iModel lacking iModelId or iTwinId (aka projectId)");
+      }
+
+      this.loadingProgressEvent.raiseEvent(
+        IModelApp.localization.getLocalizedString("VersionCompare:versionCompare.msg_openingTarget"),
+      );
+
+      // Open the target version IModel
+      const changesetId = targetVersion.changesetId;
+      this._targetIModel = await CheckpointConnection.openRemote(
+        this._currentIModel.iTwinId,
+        this._currentIModel.iModelId,
+        IModelVersion.asOfChangeSet(changesetId),
+      );
+
+      // Keep metadata around for UI uses and other queries
+      this.currentVersion = currentVersion;
+      this.targetVersion = targetVersion;
+
+      this.loadingProgressEvent.raiseEvent(
+        IModelApp.localization.getLocalizedString("VersionCompare:versionCompare.msg_getChangedElements"),
+      );
+
+      this.loadingProgressEvent.raiseEvent(
+        IModelApp.localization.getLocalizedString("VersionCompare:versionCompare.msg_initializingComparison"),
+      );
+
+      let wantedModelClasses = [
+        GeometricModel2dState.classFullName,
+        GeometricModel3dState.classFullName,
+      ];
+      if (this.options.wantedModelClasses) {
+        wantedModelClasses = this.options.wantedModelClasses;
+      }
+
+      await this.changedElementsManager.initialize(
+        this._currentIModel,
+        this._targetIModel,
+        changedElements,
+        this.wantAllModels ? undefined : wantedModelClasses,
+        false,
+        this.filterSpatial,
+        this.loadingProgressEvent,
+      );
+
+      const changedElementEntries = this.changedElementsManager.entryCache.getAll();
+
+      // We have parent Ids available if any entries contain undefined parent data
+      this._hasParentIds = changedElementEntries.some(
+        (entry) => entry.parent !== undefined && entry.parentClassId !== undefined,
+      );
+      // We have type of change available if any of the entries has a valid type of change value
+      this._hasTypeOfChange = changedElementEntries.some((entry) => entry.type !== 0);
+      // We have property filtering available if any of the entries has a valid array of changed properties
+      this._hasPropertiesForFiltering = changedElementEntries.some(
+        (entry) => entry.properties !== undefined && entry.properties.size !== 0,
+      );
+
+      // Get the entries
+      this.loadingProgressEvent.raiseEvent(
+        IModelApp.localization.getLocalizedString("VersionCompare:versionCompare.msg_findingAssemblies"),
+      );
+      await this.changedElementsManager.entryCache.initialLoad(changedElementEntries.map((entry) => entry.id));
+
+      // Reset the select tool to allow external iModels to be located
+      await IModelApp.toolAdmin.startDefaultTool();
+
+      // Enable visualization of version comparison
+      await this.enableVisualization(false);
+
+      // Raise event
+      this.versionCompareStarted.raiseEvent(this._currentIModel, this._targetIModel, changedElementEntries);
+      VersionCompareUtils.outputVerbose(VersionCompareVerboseMessages.versionCompareManagerStartedComparison);
+    } catch (ex) {
+      // Let user know comparison failed - TODO: Give better errors
+      const briefError = IModelApp.localization.getLocalizedString(
+        "VersionCompare:versionCompare.error_versionCompare",
+      );
+      const detailed = IModelApp.localization.getLocalizedString("VersionCompare:versionCompare.error_cantStart");
+      let errorMessage = "Unknown Error";
+      if (ex instanceof Error) {
+        errorMessage = ex.message;
+      } else if (typeof ex === "string") {
+        errorMessage = ex;
+      }
+
+      IModelApp.notifications.outputMessage(
+        new NotifyMessageDetails(OutputMessagePriority.Error, briefError, `${detailed}: ${errorMessage}`),
+      );
+      // Notify failure on starting comparison
+      this.versionCompareStartFailed.raiseEvent();
+      this._currentIModel = undefined;
+      this._targetIModel = undefined;
+
+      success = false;
+      VersionCompareUtils.outputVerbose(VersionCompareVerboseMessages.versionCompareManagerErrorStarting);
+    }
+
+    return success;
+  }
+
   /**
    * Enable visualization of version comparison.
    * @param wantTargetModified Show modified elements from target comparison in single viewport

packages/changed-elements-react/src/clients/ComparisonJobClient.ts

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import type {
+  ChangedElementsPayload, IComparisonJobClient, ComparisonJob, GetComparisonJobParams, GetComparisonJobResultParams,
+  PostComparisonJobParams,
+  DeleteComparisonJobParams
+} from "./IComparisonJobClient.js";
+import { callITwinApi, throwBadResponseCodeError } from "./iTwinApi.js";
+
+export interface ComparisonJobClientParams {
+  baseUrl: string;
+  getAccessToken: () => Promise<string>;
+}
+
+export class ComparisonJobClient implements IComparisonJobClient {
+  private static readonly _acceptHeader = "application/vnd.bentley.itwin-platform.v2+json";
+  private _baseUrl: string;
+  private _getAccessToken: () => Promise<string>;
+
+  constructor(args: ComparisonJobClientParams) {
+    this._baseUrl = args.baseUrl;
+    this._getAccessToken = args.getAccessToken;
+  }
+
+  /**
+   * Deletes comparison job.
+   * @returns void
+   * @throws on a non 2XX response
+  */
+  public async deleteComparisonJob(args: DeleteComparisonJobParams): Promise<void> {
+    return callITwinApi({
+      url: `${this._baseUrl}/comparisonJob/${args.jobId}/iTwin/${args.iTwinId}/iModel/${args.iModelId}`,
+      method: "DELETE",
+      getAccessToken: this._getAccessToken,
+      signal: args.signal,
+      headers: {
+        Accept: ComparisonJobClient._acceptHeader,
+        ...args.headers,
+      },
+    }) as unknown as Promise<void>;
+  }
+
+  /**
+ * Gets comparison job.
+ * @returns ComparisonJob
+ * @throws on a non 2XX response.
+*/
+  public async getComparisonJob(args: GetComparisonJobParams): Promise<ComparisonJob> {
+    return callITwinApi({
+      url: `${this._baseUrl}/comparisonJob/${args.jobId}/iTwin/${args.iTwinId}/iModel/${args.iModelId}`,
+      method: "GET",
+      getAccessToken: this._getAccessToken,
+      signal: args.signal,
+      headers: {
+        Accept: ComparisonJobClient._acceptHeader,
+        ...args.headers,
+      },
+    }) as unknown as Promise<ComparisonJob>;
+  }
+
+  /**
+  * Gets changed elements for given comparisonJob.
+ * @returns ChangedElements
+ * @throws on a non 2XX response.
+ */
+  public async getComparisonJobResult(args: GetComparisonJobResultParams): Promise<ChangedElementsPayload> {
+    const response = await fetch(
+      args.comparisonJob.comparison.href,
+      {
+        method: "GET",
+        headers: {
+          Accept: ComparisonJobClient._acceptHeader,
+        },
+      },
+    );
+
+    if (!response.ok) {
+      await throwBadResponseCodeError(response, "Changed Elements request failed.");
+    }
+    return response.json() as unknown as Promise<ChangedElementsPayload>;
+  }
+
+  /**
+  * Gets comparison job.
+  * @returns ComparisonJob
+  * @throws on a non 2XX response.
+  */
+  public async postComparisonJob(args: PostComparisonJobParams): Promise<ComparisonJob> {
+    return callITwinApi({
+      url: `${this._baseUrl}/comparisonJob`,
+      method: "POST",
+      getAccessToken: this._getAccessToken,
+      signal: args.signal,
+      headers: {
+        Accept: ComparisonJobClient._acceptHeader,
+        ...args.headers,
+      },
+      body: {
+        iTwinId: args.iTwinId,
+        iModelId: args.iModelId,
+        startChangesetId: args.startChangesetId,
+        endChangesetId: args.endChangesetId,
+      },
+    }) as unknown as Promise<ComparisonJob>;
+  }
+}