public async allocateContainer()

in src/Explorer/Explorer.tsx [383:465]
73 lines of code
15 McCabe index (conditional complexity)

  public async allocateContainer(poolId: PoolIdType, mode?: string): Promise<void> {
    const shouldUseNotebookStates = poolId === PoolIdType.DefaultPoolId ? true : false;
    const notebookServerInfo = shouldUseNotebookStates
      ? useNotebook.getState().notebookServerInfo
      : useQueryCopilot.getState().notebookServerInfo;

    const isAllocating = shouldUseNotebookStates
      ? useNotebook.getState().isAllocating
      : useQueryCopilot.getState().isAllocatingContainer;
    if (
      isAllocating === false &&
      (notebookServerInfo === undefined ||
        (notebookServerInfo && notebookServerInfo.notebookServerEndpoint === undefined))
    ) {
      const connectionStatus: ContainerConnectionInfo = {
        status: ConnectionStatusType.Connecting,
      };

      shouldUseNotebookStates && useNotebook.getState().setConnectionInfo(connectionStatus);

      let connectionInfo;
      let provisionData: IProvisionData;
      try {
        TelemetryProcessor.traceStart(Action.PhoenixConnection, {
          dataExplorerArea: Areas.Notebook,
        });
        if (shouldUseNotebookStates) {
          useNotebook.getState().setIsAllocating(true);
          provisionData = {
            cosmosEndpoint: userContext?.databaseAccount?.properties?.documentEndpoint,
            poolId: undefined,
          };
        } else {
          useQueryCopilot.getState().setIsAllocatingContainer(true);
          provisionData = {
            poolId: poolId,
            databaseId: useTabs.getState().activeTab.collection.databaseId,
            containerId: useTabs.getState().activeTab.collection.id(),
            mode: mode,
          };
        }
        connectionInfo = await this.phoenixClient.allocateContainer(provisionData);
        if (!connectionInfo?.data?.phoenixServiceUrl) {
          throw new Error(`PhoenixServiceUrl is invalid!`);
        }
        await this.setNotebookInfo(shouldUseNotebookStates, connectionInfo, connectionStatus);
        TelemetryProcessor.traceSuccess(Action.PhoenixConnection, {
          dataExplorerArea: Areas.Notebook,
        });
      } catch (error) {
        TelemetryProcessor.traceFailure(Action.PhoenixConnection, {
          dataExplorerArea: Areas.Notebook,
          status: error.status,
          error: getErrorMessage(error),
          errorStack: getErrorStack(error),
        });
        if (shouldUseNotebookStates) {
          connectionStatus.status = ConnectionStatusType.Failed;
          shouldUseNotebookStates
            ? useNotebook.getState().resetContainerConnection(connectionStatus)
            : useQueryCopilot.getState().resetContainerConnection();
          if (error?.status === HttpStatusCodes.Forbidden && error.message) {
            useDialog.getState().showOkModalDialog("Connection Failed", `${error.message}`);
          } else {
            useDialog
              .getState()
              .showOkModalDialog(
                "Connection Failed",
                "We are unable to connect to the temporary workspace. Please try again in a few minutes. If the error persists, file a support ticket.",
              );
          }
        }
        throw error;
      } finally {
        shouldUseNotebookStates
          ? useNotebook.getState().setIsAllocating(false)
          : useQueryCopilot.getState().setIsAllocatingContainer(false);
        this.refreshCommandBarButtons();
        this.refreshNotebookList();
        this._isInitializingNotebooks = false;
      }
    }
  }