@mindline/sync 1.0.104 → 1.0.105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindline/sync",
-  "version": "1.0.104",
+  "version": "1.0.105",
   "description": "sync is a node.js package encapsulating JavaScript classes required for configuring Mindline sync service.",
   "main": "dist/sync.es.js",
   "types": "dist/index.d.ts",

package/src/index.d.ts

@@ -337,7 +337,9 @@ declare module "@mindline/sync" {
     export function usersGet(instance: IPublicClientApplication, user: User | undefined): { users: string[], error: string };
     // ======================= Mindline SyncConfig API ===============================
     export function auditConfigAdd(instance: IPublicClientApplication, user: User, ac: AuditConfig, debug: boolean): Promise<APIResult>;
-    export function auditConfigRetrieve(instance: IPublicClientApplication, user: User, debug: boolean): Promise<APIResult>;
+    export function auditConfigRetrieve(instance: IPublicClientApplication, user: User, configurationId: string, debug: boolean): Promise<APIResult>;
+    export function auditConfigEdit(instance: IPublicClientApplication, user: User, configurationId: string, config: AuditConfig, debug: boolean): Promise<APIResult>; 
+    export function auditConfigRemove(instance: IPublicClientApplication, user: User, configurationId: string, debug: boolean): Promise<APIResult>; 
     export function auditEventsRetrieve(instance: IPublicClientApplication, user: User, debug: boolean): Promise<APIResult>;
     export function configEdit(instance: IPublicClientApplication, authorizedUser: User, config: SyncConfig, setConfigId: (id: string) => void, setSelectedConfigs: (selectedConfigs: { [id: string]: boolean | number[] }) => void, workspace: Workspace, ii: InitInfo, debug: boolean): APIResult;
     export function configEnable(instance: IPublicClientApplication, authorizedUser: User, configurationId: string, enabled: boolean, debug: boolean): APIResult;
@@ -351,6 +353,7 @@ declare module "@mindline/sync" {
     export function userAdd(instance: IPublicClientApplication, authorizedUser: User, user: User, workspaceId: string): APIResult;
     export function userRemove(instance: IPublicClientApplication, authorizedUser: User, user: User, workspaceId: string): APIResult;
     export function workspaceEdit(instance: IPublicClientApplication, authorizedUser: User, workspaceId: string, workspaceName: string): Promise<APIResult>;
+    export function workspaceConfigsGet(instance: IPublicClientApplication, user: User, workspaceId: string, debug: boolean): Promise<APIResult>;
     // ======================= PowerBI Access Token Retrieval ===============================
     export function getPowerBIAccessToken(instance: IPublicClientApplication, user: User): Promise<string>;
     // ======================= Azure REST API ===============================

package/src/index.ts

@@ -86,6 +86,9 @@ export class mindlineConfig {
     static workspacesEndpoint(): string {
         return `https://${mindlineConfig.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/workspaces`;
     };
+    static workspaceConfigsEndpoint(): string {
+        return `https://${mindlineConfig.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/workspace-configurations`;
+    };
     // SignalR endpoint
     static signalREndpoint(): string {
         return `https://${mindlineConfig.environmentTag}-signalrdispatcher-westus.azurewebsites.net/statsHub`;
@@ -2030,8 +2033,14 @@ export async function usersGet(instance: IPublicClientApplication, user: User |
 export async function auditConfigAdd(instance: IPublicClientApplication, user: User, ac: AuditConfig, debug: boolean): Promise<APIResult> {
     return auditConfigPost(instance, user, ac, debug);
 }
-export async function auditConfigRetrieve(instance: IPublicClientApplication, user: User, debug: boolean): Promise<APIResult> {
-    return auditConfigGet(instance, user, debug);
+export async function auditConfigRetrieve(instance: IPublicClientApplication, user: User, configurationId: string, debug: boolean): Promise<APIResult> {
+    return auditConfigGet(instance, user, configurationId, debug);
+}
+export async function auditConfigEdit(instance: IPublicClientApplication, user: User, configurationId: string, config: AuditConfig, debug: boolean): Promise<APIResult> {
+    return auditConfigPut(instance, user, configurationId, config, debug);
+}
+export async function auditConfigRemove(instance: IPublicClientApplication, user: User, configurationId: string, debug: boolean): Promise<APIResult> {
+    return auditConfigDelete(instance, user, configurationId, debug);
 }
 export async function auditEventsRetrieve(instance: IPublicClientApplication, authorizedUser: User, debug: boolean): Promise<APIResult> {
     return auditEventsGet(instance, authorizedUser, debug);
@@ -2098,30 +2107,44 @@ export async function configsRefresh(instance: IPublicClientApplication, authori
             // clear SyncConfig associations as we are about to reset
             workspace.associatedConfigs.length = 0;
             // GET configs associated with this workspace
-            let result: APIResult = await configsGet(instance, authorizedUser, workspace.id, debug);
+            let result: APIResult = await workspaceConfigsGet(instance, authorizedUser, workspace.id, debug);
             if (!result.result) return result;
             // process returned workspace components
             let configSelectedId: string = "";
             for (let cid of workspace.associatedConfigs) {
                 let config = ii.cs.find((c: SyncConfig) => c.id === cid);
                 if (config != null && config.sel) {
-                    configSelectedId = config.id;
+                    ii.cs.find((c: SyncConfig) => c.id === cid) ??
+                        ii.acs.find((a: AuditConfig) => a.id === cid);
+
+                    if (config && config.sel) {
+                        configSelectedId = config.id;
+                    }
                 }
+
+                // Pass combined list to processor
+                processReturnedConfigs(workspace, ii, result.array!, configSelectedId);
+                // tag components with workspaceIDs
+                ii.tagWithWorkspaces();
             }
-            processReturnedConfigs(workspace, ii, result.array!, configSelectedId);
-            // tag components with workspaceIDs
-            ii.tagWithWorkspaces();
+            return result;
+        } else {
+            // workspace not found
+            result.result = false;
+            result.error = "Workspace not found.";
+            result.status = 404;
+            return result;
         }
-        return result;
-    }
-    catch (error: any) {
+
+    } catch (error: any) {
         console.log(error.message);
         result.error = error.message;
+        result.result = false;
+        result.status = 500;
+        return result;
     }
-    result.result = false;
-    result.status = 500;
-    return result;
 }
+
 export async function configRemove(instance: IPublicClientApplication, authorizedUser: User, config: SyncConfig, workspaceId: string, debug: boolean): Promise<APIResult> {
     return configDelete(instance, authorizedUser, config, workspaceId, debug);
 }
@@ -2841,6 +2864,7 @@ export async function adminPost(
     }
     return result;
 }
+
 //auditConfigPost: write audit config to back end
 export async function auditConfigPost(
     instance: IPublicClientApplication,
@@ -2904,14 +2928,197 @@ export async function auditConfigPost(
     }
     return result;
 }
-//auditConfigPost: get audit config from back end
-export async function auditConfigGet(instance: IPublicClientApplication, user: User, debug: boolean): Promise<APIResult> {
+
+//auditConfigGET: get audit config from back end
+export async function auditConfigGet(
+    instance: IPublicClientApplication,
+    user: User,
+    configurationId: string,
+    debug: boolean): Promise<APIResult> {
     instance = instance;
     user = user;
     debug = debug;
+
+    let result: APIResult = new APIResult();
+
+    // Validate user
+    if (user.mail == undefined || user.mail == "") {
+        result.result = false;
+        result.status = 500;
+        result.error = "auditConfigGet: no user provided";
+        return result;
+    }
+
+    //Validate input
+    if (!configurationId || configurationId.trim() === "") {
+        result.result = false;
+        result.error = "auditConfigGet: configurationId is required";
+        result.status = 500;
+        return result;
+    }
+
+    //Define endpoint with query parameter (configurationId)
+    let endpoint: string = mindlineConfig.auditConfigEndpoint();
+    let url: URL = new URL(`${endpoint}/${configurationId}`);
+
+    //Create headers with Entra ID token
+    const headers = await mindlineDefineHeaders(instance, user);
+
+    let options = { method: "GET", headers: headers };
+
+    //Make the GET request
+    try {
+        if (debug) debugger;
+        console.log("Attempting GET to /audit-configuration: " + url.href);
+
+        const response = await fetch(url.href, options);
+
+        if (response.status === 200 && response.statusText === "OK") {
+            let data = await response.json();
+            result.result = true;
+            result.status = response.status;
+            console.log("Successful GET from /audit-configuration:", data);
+        } else {
+            result.error = await processErrors(response);
+            console.log("Failed GET from /audit-configuration: " + url.href);
+            console.log(result.error);
+            result.status = response.status;
+            result.result = false;
+        }
+    } catch (error: any) {
+        result.status = 500;
+        result.result = false;
+        result.error = error.message;
+        console.log("Error during auditConfigGet:", error.message);
+    }
+
+    return result;
+}
+
+//auditConfigPUT: put audit config from back end 
+export async function auditConfigPut(
+    instance: IPublicClientApplication,
+    user: User,
+    configurationId: string,
+    config: AuditConfig, // model with name, description, isEnabled, isReadPermissionConsented, email
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+
+    // Validate configurationId
+    if (!configurationId || configurationId.trim() === "") {
+        result.result = false;
+        result.error = "auditConfigPut: invalid configuration ID";
+        result.status = 500;
+        return result;
+    }
+
+    // Build endpoint with query parameter
+    let endpoint: string = mindlineConfig.auditConfigEndpoint();
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("configurationId", configurationId);
+
+    // Create headers with token
+    const headers = await mindlineDefineHeaders(instance, user);
+
+    // Build body 
+    let configBody: string = `
+    {
+      "name": "${config.name}",
+      "description": "${config.description}",
+      "isEnabled": ${config.isEnabled},
+      "isReadPermissionConsented": ${config.isReadPermissionConsented},
+      "email": "${config.email}"
+    }`;
+
+    let options = { method: "PUT", headers: headers, body: configBody };
+
+    // Call API
+    try {
+        if (debug) debugger;
+        console.log("Attempting PUT to /audit-configuration: " + url.href);
+
+        const response = await fetch(url.href, options);
+
+        if (response.status === 200 && response.statusText === "OK") {
+            result.result = true;
+            console.log(`Successful PUT to ${url.href}: ${configBody}`);
+        } else {
+            result.error = await processErrors(response);
+            console.error(`Failed PUT to ${url.href}: ${configBody}`);
+            result.status = response.status;
+            result.result = false;
+        }
+    } catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.error("Error during auditConfigPut:", error.message);
+    }
+
+    return result;
+}
+
+//auditConfigDELETE: delete audit config from back end 
+export async function auditConfigDelete(
+    instance: IPublicClientApplication,
+    user: User,
+    configurationId: string,
+    debug: boolean
+): Promise<APIResult> {
     let result: APIResult = new APIResult();
+
+    // Validate user
+    if (!user.mail) {
+        result.result = false;
+        result.status = 500;
+        result.error = "auditConfigDelete: no user provided";
+        return result;
+    }
+
+    // Validate configurationId
+    if (!configurationId || configurationId.trim() === "") {
+        result.result = false;
+        result.status = 500;
+        result.error = "auditConfigDelete: configurationId is required";
+        return result;
+    }
+
+    // Build endpoint with query parameter
+    let endpoint: string = mindlineConfig.auditConfigEndpoint();
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("configurationId", configurationId);
+
+    // Build request headers
+    const headers = await mindlineDefineHeaders(instance, user);
+    const options = { method: "DELETE", headers: headers };
+
+    try {
+        if (debug) debugger;
+        console.log(`Attempting DELETE to /audit-configuration: ${url.href}`);
+
+        const response = await fetch(url.href, options);
+
+        if (response.ok) {
+            result.result = true;
+            console.log(`Successful DELETE for configurationId ${configurationId}`);
+        } else {
+            result.error = await processErrors(response);
+            result.status = response.status;
+            result.result = false;
+            console.error(`Failed DELETE for configurationId ${configurationId}`);
+        }
+    } catch (error: any) {
+        result.status = 500;
+        result.result = false;
+        result.error = error.message;
+        console.error("Error during auditConfigDelete:", error.message);
+    }
+
     return result;
 }
+
+
 export async function auditEventsGet(instance: IPublicClientApplication, user: User, debug: boolean): Promise<APIResult> {
     let result: APIResult = new APIResult();
     // we need a valid user
@@ -3355,6 +3562,76 @@ export async function configsGet(
     }
     return result;
 }
+//workspaceConfigsGET
+export async function workspaceConfigsGet(
+    instance: IPublicClientApplication,
+    user: User | null | undefined,
+    workspaceId: string,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+
+    if (!workspaceId) {
+        result.result = false;
+        result.status = 500;
+        result.error = "workspaceConfigsGet: no workspace provided";
+        return result;
+    }
+
+    // Create endpoint
+    let endpoint: string = mindlineConfig.workspaceConfigsEndpoint();
+    // Add parameter to endpoint
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("workspaceId", workspaceId);
+
+    // Headers with Bearer token
+    const headers = await mindlineDefineHeaders(instance, user);
+
+    let options = { method: "GET", headers };
+
+    try {
+        if (debug) debugger;
+        console.log("Attempting GET from /workspaceConfigs: " + url.href);
+
+        const response = await fetch(url.href, options);
+
+        if (response.status === 200 && response.statusText === "OK") {
+            const returnedArray: Array<any> = await response.json();
+
+            if (returnedArray) {
+                // Filter by configurationType (sync or auditLog)
+                result.array = returnedArray.map((config) => ({
+                    id: config.id,
+                    name: config.name,
+                    description: config.description,
+                    configurationType: config.configurationType,
+                    isEnabled: config.isEnabled,
+                }));
+
+                console.log(
+                    `workspaceConfigsGet: found ${result.array.length} configs.`                   
+                );
+                return result;
+            } else {
+                result.error =
+                    "workspaceConfigsGet: failed to parse returned configs";
+                result.result = false;
+                result.status = 500;
+            }
+        } else {
+            result.error = await processErrors(response);
+            result.result = false;
+            result.status = response.status;
+            console.log(result.error);
+        }
+    } catch (error: any) {
+        result.error = error.message;
+        result.result = false;
+        result.status = 500;
+    }
+
+    return result;
+}
 //initPost
 export async function initPost(
     instance: IPublicClientApplication,