Add UX for error Information for Phoenix workspace connection (#1234)

* Add UX for error Information

* update text messages

src/Phoenix/PhoenixClient.ts

@@ -1,3 +1,4 @@
+import { useDialog } from "Explorer/Controls/Dialog";
 import promiseRetry, { AbortError } from "p-retry";
 import { Action } from "Shared/Telemetry/TelemetryConstants";
 import { allowedJunoOrigins, validateEndpoint } from "Utils/EndpointValidation";
@@ -16,9 +17,14 @@ import {
   ContainerConnectionInfo,
   ContainerInfo,
   IContainerData,
+  IMaxAllocationTimeExceeded,
+  IMaxDbAccountsPerUserExceeded,
+  IMaxUsersPerDbAccountExceeded,
   IPhoenixConnectionInfoResult,
   IProvisionData,
   IResponse,
+  IValidationError,
+  PhoenixErrorType,
 } from "../Contracts/DataModels";
 import { useNotebook } from "../Explorer/Notebook/useNotebook";
 import * as TelemetryProcessor from "../Shared/Telemetry/TelemetryProcessor";
@@ -45,23 +51,25 @@ export class PhoenixClient {
     provisionData: IProvisionData,
     operation: string
   ): Promise<IResponse<IPhoenixConnectionInfoResult>> {
+    let response;
     try {
-      const response = await fetch(`${this.getPhoenixControlPlanePathPrefix()}/containerconnections`, {
+      response = await fetch(`${this.getPhoenixControlPlanePathPrefix()}/containerconnections`, {
         method: operation === "allocate" ? "POST" : "PATCH",
         headers: PhoenixClient.getHeaders(),
         body: JSON.stringify(provisionData),
       });
-
-      let data: IPhoenixConnectionInfoResult;
-      if (response.status === HttpStatusCodes.OK) {
-        data = await response.json();
+      const responseJson = await response?.json();
+      if (response.status === HttpStatusCodes.Forbidden) {
+        throw new Error(this.ConvertToForbiddenErrorString(responseJson));
       }
       return {
         status: response.status,
-        data,
+        data: responseJson,
       };
     } catch (error) {
-      console.error(error);
+      if (response.status === HttpStatusCodes.Forbidden) {
+        error.status = HttpStatusCodes.Forbidden;
+      }
       throw error;
     }
   }
@@ -108,6 +116,18 @@ export class PhoenixClient {
           });
           useNotebook.getState().resetContainerConnection(connectionStatus);
           useNotebook.getState().setIsRefreshed(!useNotebook.getState().isRefreshed);
+          useDialog
+            .getState()
+            .showOkModalDialog(
+              "Disconnected",
+              "Disconnected from temporary workspace. Please click on connect button to connect to temporary workspace."
+            );
+          throw new AbortError(response.statusText);
+        } else if (response?.status === HttpStatusCodes.Forbidden) {
+          const validationMessage = this.ConvertToForbiddenErrorString(await response.json());
+          if (validationMessage) {
+            useDialog.getState().showOkModalDialog("Connection Failed", `${validationMessage}`);
+          }
           throw new AbortError(response.statusText);
         }
         throw new Error(response.statusText);
@@ -177,4 +197,48 @@ export class PhoenixClient {
       [HttpHeaders.contentType]: "application/json",
     };
   }
+
+  public ConvertToForbiddenErrorString(jsonData: IValidationError): string {
+    const errInfo = jsonData;
+    switch (errInfo?.type) {
+      case PhoenixErrorType.MaxAllocationTimeExceeded: {
+        const maxAllocationTimeExceeded = errInfo as IMaxAllocationTimeExceeded;
+        const allocateAfterTimestamp = new Date(maxAllocationTimeExceeded?.earliestAllocationTimestamp);
+        allocateAfterTimestamp.setDate(allocateAfterTimestamp.getDate() + 1);
+        return (
+          `${errInfo.message}` +
+          " Max allocation time for a day to a user is " +
+          `${maxAllocationTimeExceeded.maxAllocationTimePerDayPerUserInMinutes}` +
+          ". Please try again after " +
+          `${allocateAfterTimestamp.toLocaleString()}`
+        );
+      }
+      case PhoenixErrorType.MaxDbAccountsPerUserExceeded: {
+        const maxDbAccountsPerUserExceeded = errInfo as IMaxDbAccountsPerUserExceeded;
+        return (
+          `${errInfo.message}` +
+          " Max simultaneous connections allowed per user is " +
+          `${maxDbAccountsPerUserExceeded.maxSimultaneousConnectionsPerUser}` +
+          "."
+        );
+      }
+      case PhoenixErrorType.MaxUsersPerDbAccountExceeded: {
+        const maxUsersPerDbAccountExceeded = errInfo as IMaxUsersPerDbAccountExceeded;
+        return (
+          `${errInfo.message}` +
+          " Max simultaneous users allowed per DbAccount is " +
+          `${maxUsersPerDbAccountExceeded.maxSimultaneousUsersPerDbAccount}` +
+          "."
+        );
+      }
+      case PhoenixErrorType.AllocationValidationResult:
+      case PhoenixErrorType.RegionNotServicable:
+      case PhoenixErrorType.SubscriptionNotAllowed: {
+        return `${errInfo.message}`;
+      }
+      default: {
+        return undefined;
+      }
+    }
+  }
 }