@mindline/sync 1.0.87 → 1.0.89

package/index.ts

@@ -14,6 +14,7 @@ import syncmilestones from './syncmilestones';
 import resources from './resources';
 import actors from './actors';
 import { log } from "console";
+
 const FILTER_FIELD = "workspaceIDs";
 // called by unit tests
 export function sum(a: number, b: number): number {
@@ -2491,4 +2492,1012 @@ async function readResources(instance: IPublicClientApplication, user: User): Pr
         return false;
     }
     return true;
+}
+
+//hybridspa.ts - calls to Mindline Config API
+
+// helper functions
+function getAPIScope(user: User): string {
+    let apiAppID: string = "8d95d21c-c378-4bb0-9f52-88c30d271e7a";
+    let authority: string = user.authority.toLowerCase();
+    if (authority.startsWith("https://login.microsoftonline.com/"))
+        apiAppID = "8d95d21c-c378-4bb0-9f52-88c30d271e7a";
+    else if (authority.startsWith("https://login.microsoftonline.us/"))
+        apiAppID = "48da942e-ea3d-49e4-a054-81649012f8f2";
+    else if (authority.startsWith("https://login.partner.microsoftonline.cn/"))
+        apiAppID = "c91d32e4-dcc5-4d77-826a-16e93ffce666";
+    let apiScope: string = `api://${apiAppID}/Config.Write`;
+    return apiScope;
+}
+// TODO: this is where you want to trigger a re-authentication if token expires
+async function mindlineDefineHeaders(
+    instance: IPublicClientApplication,
+    user: User
+): Promise<Headers> {
+    debugger;
+    const headers = new Headers();
+    headers.append("Content-Type", "application/json");
+    headers.append("accept", "*/*");
+    // always call acquireTokenSilent, handling expired tokens on exception
+    const apiScope: string = getAPIScope(user);
+    try {
+        let accounts: AccountInfo[] = instance.getAllAccounts();
+        let homeAccountId = user.oid + "." + user.tid;
+        let account: AccountInfo = null;
+        for (let i: number = 0; i < accounts.length; i++) {
+            if (accounts[i].homeAccountId == homeAccountId) {
+                account = accounts[i];
+            }
+        }
+        let response: AuthenticationResult = await instance.acquireTokenSilent({
+            scopes: [apiScope],
+            account: account
+        });
+        user.mindlineAccessToken = response.accessToken; // cache access token
+        console.log("Front end mindline token acquired silently: " + user.mindlineAccessToken.slice(0, 20));
+    }
+    catch (error: any) {
+        try {
+            console.log("Front end mindline token silent acquisition failure, triggering redirect: " + error);
+            // fallback to redirect if silent acquisition fails
+            let accounts: AccountInfo[] = instance.getAllAccounts();
+            let homeAccountId = user.oid + "." + user.tid;
+            let account: AccountInfo = null;
+            for (let i: number = 0; i < accounts.length; i++) {
+                if (accounts[i].homeAccountId == homeAccountId) {
+                    account = accounts[i];
+                }
+            }
+            // assumption: this redirect will trigger login flow callbacks in program.cs
+            instance.acquireTokenRedirect({
+                scopes: [apiScope],
+                account: account
+            });
+        }
+        catch (error: any) {
+            console.log("Front end mindline token redirect acquisition failure: " + error);
+        }
+    }
+    headers.append("Authorization", `Bearer ${user.mindlineAccessToken}`);
+    return headers;
+}
+export async function processErrors(response: Response): Promise<string> {
+    let errorString: string = "";
+    if (response.status === 401) {
+        errorString = response.statusText;
+        if (errorString != "") return errorString;
+    }
+    let data = await response.json();
+    // process errors from Mindline Config API
+    if (data.error !== undefined) {
+        errorString = `Error: ${data.error} Message: ${data.message}`;
+    } else if (data.errors !== undefined) {
+        let errorArray = Object.keys(data.errors);
+        let errorlist: string = "";
+        errorString = errorArray.reduce(
+            (acc, curr) => acc + curr + ": " + data.errors[curr] + " ",
+            errorlist
+        );
+    } else if (data.title !== undefined) {
+        errorString = data.title;
+    } else {
+        debugger;
+    }
+    return errorString;
+}
+//adminDelete
+export async function adminDelete(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    user: User,
+    workspaceId: string
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we need either oid or mail for the user and valid workspace id
+    if ((user.oid == "" && user.mail == "") || workspaceId == "") {
+        result.result = false;
+        result.error = "adminDelete: invalid parameters";
+        result.status = 500;
+        return result;
+    }
+    // define admin endpoint and add workspaceId parameter
+    let url: URL | null = null;
+    url = new URL(mindlineConfig.adminEndpoint());
+    url.searchParams.append("workspaceId", workspaceId);
+    url.searchParams.append("email", user.mail);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // make endpoint call
+    let options = { method: "DELETE", headers: headers };
+    try {
+        console.log("Attempting DELETE from /admin: " + url!.href);
+        let response = await fetch(url!.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful DELETE from /admin: ${url!.href}`);
+            return result;
+        } else {
+            result.error = await processErrors(response);
+            console.log(`Failed DELETE from /admin: ${url.href}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    } catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//adminsGet
+export async function adminsGet(
+    instance: IPublicClientApplication,
+    user: User,
+    workspaceID: string,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we need a workspace id
+    if (workspaceID === "") {
+        result.result = false;
+        result.status = 500;
+        result.error = "adminsGet: no workspace provided";
+        return result;
+    }
+    // create endpoint
+    let endpoint: string = mindlineConfig.adminsEndpoint();
+    // add parameter to endpoint
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("workspaceId", workspaceID);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, user);
+    // make endpoint call
+    let options = { method: "GET", headers: headers };
+    try {
+        if (debug) debugger;
+        console.log("Attempting GET from /admins: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            let returnedArray: Array<Object> = await response.json();
+            if (returnedArray != null) {
+                result.array = returnedArray;
+                let initialValue: string = "";
+                console.log(`Successful GET from /admins: ${result.array.reduce((acc, curr) => acc + curr.email + " ", initialValue)}`);
+                return result;
+            }
+            else {
+                result.error = `Failed GET from /admins: failed to JSON-parse response`;
+                console.log(result.error);
+                result.status = 500;
+                result.result = false;
+                return result;
+            }
+        }
+        else {
+            console.log(`Failed GET from /admins: ${url.href}`);
+            result.error = await processErrors(response);
+            result.status = 500;
+            result.result = false;
+            console.log(result.error);
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//adminPost: write validated admin to back end
+export async function adminPost(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    user: User,
+    workspaceId: string
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    if (user.mail == "" || user.authority == "" || user.tid === "") {
+        result.result = false;
+        result.error = "adminPost: invalid argument";
+        result.status = 500;
+        return result;
+    }
+    // create admin endpoint
+    let endpoint: string = mindlineConfig.adminEndpoint();
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // create admin body
+    let adminBody: string = `
+    {"email": "${user.mail}", 
+     "tenantId": "${user.tid}", 
+     "workspaceId": "${workspaceId}"
+    }`;
+    let options = { method: "POST", headers: headers, body: adminBody };
+    // make admin endpoint call
+    try {
+        console.log("Attempting POST to /admin: " + endpoint);
+        let response = await fetch(endpoint, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful POST to /admin: ${adminBody}`);
+            return result;
+        } else {
+            result.error = await processErrors(response);
+            console.log(`Failed POST to /admin: ${adminBody}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    } catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//configConsentReadPut
+export async function configConsentReadPut(instance: IPublicClientApplication, authorizedUser: User, configId: string, tid: string, consent: boolean): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // create parameterized config consent endpoint
+    let endpoint: string = mindlineConfig.configConsentEndpoint();
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("configurationId", configId);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // create body
+    let configConsentReadBody: string = `
+    {
+      "tenantId": "${tid}",
+      "isReadPermissionConsented": ${consent ? "true" : "false"}
+     }`;
+    // make endpoint call
+    let options = { method: "PUT", headers: headers, body: configConsentReadBody };
+    try {
+        console.log("Attempting PUT read consent to /configuration/consent: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful PUT to ${url.href}`);
+            return result;
+        }
+        else {
+            result.error = await processErrors(response);
+            console.log(`Failed PUT to ${url.href}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//configConsentWritePut
+export async function configConsentWritePut(instance: IPublicClientApplication, authorizedUser: User, configId: string, tid: string, consent: boolean): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // create parameterized config consent endpoint
+    let endpoint: string = mindlineConfig.configConsentEndpoint();
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("configurationId", configId);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // create body
+    let configConsentWriteBody: string = `
+    {
+      "tenantId": "${tid}",
+      "isWritePermissionConsented": ${consent ? "true" : "false"}
+     }`;
+    // make endpoint call
+    let options = { method: "PUT", headers: headers, body: configConsentWriteBody };
+    try {
+        console.log("Attempting PUT read consent to /configuration/consent: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful PUT to ${url.href}`);
+            return result;
+        }
+        else {
+            result.error = await processErrors(response);
+            console.log(`Failed PUT to ${url.href}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//configDelete
+export async function configDelete(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    config: Config,
+    workspaceId: string,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    if (config.id === "" || workspaceId == "") {
+        result.result = false;
+        result.error = "configPost: invalid config ID";
+        result.status = 500;
+        return result;
+    }
+    let url: URL | null = null;
+    url = new URL(mindlineConfig.configEndpoint());
+    url.searchParams.append("configurationId", config.id);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // make endpoint call
+    let options = { method: "DELETE", headers: headers };
+    try {
+        console.log("Attempting DELETE from /config: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful DELETE from /config`);
+            return result;
+        }
+        else {
+            result.error = await processErrors(response);
+            console.log(`Failed DELETE from ${url.href}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//configPatch
+export async function configPatch(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    configurationId: string,
+    enabled: boolean,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    if (configurationId === "") {
+        result.result = false;
+        result.error = "configPatch: invalid config ID";
+        result.status = 500;
+        return result;
+    }
+    // create parametrized config endpoint
+    let endpoint: string = mindlineConfig.configEnabledEndpoint();
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("configurationId", configurationId);
+    url.searchParams.append("isEnabled", enabled.toString());
+    // create config headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    let options = { method: "PATCH", headers: headers };
+    // make config endpoint call
+    try {
+        if (debug) debugger;
+        console.log("Attempting PATCH to /config: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful PATCH to ${url.href}: ${enabled.toString()}`);
+            return result;
+        }
+        else {
+            result.error = await processErrors(response);
+            console.log(`Failed PATCH to ${url.href}: ${enabled.toString()}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//configPost
+export async function configPost(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    config: Config,
+    workspaceId: string,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    if (config.id === "") {
+        result.result = false;
+        result.error = "configPost: invalid config ID";
+        result.status = 500;
+        return result;
+    }
+    // create no parameter config endpoint
+    let endpoint: string = mindlineConfig.configEndpoint();
+    // create config headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // create config body
+    let configBody: string = `
+    {
+      "workspaceId": "${workspaceId}",
+      "name": "${config.name}",
+      "description": "${config.description}",
+      "isEnabled": ${config.isEnabled},
+      "tenants": [`;
+    config.tenants.map((tci) => {
+        // be sure we send null and not "null" in body
+        let sourceGroupId: string = tci.sourceGroupId != "" ? `"${tci.sourceGroupId}"` : "null";
+        let sourceGroupName: string = tci.sourceGroupName != "" ? `"${tci.sourceGroupName}"` : "null";
+        let targetGroupId: string = tci.targetGroupId != "" ? `"${tci.targetGroupId}"` : "null";
+        let targetGroupName: string = tci.targetGroupName != "" ? `"${tci.targetGroupName}"` : "null";
+        // if last character is } we need a comma first
+        let needComma: boolean = configBody.slice(-1) === "}";
+        if (needComma) configBody += ",";
+        configBody += `{
+        "tenantId": "${tci.tid}",
+        "sourceGroupId": ${sourceGroupId},
+        "sourceGroupName": ${sourceGroupName},
+        "targetGroupId": ${targetGroupId},
+        "targetGroupName": ${targetGroupName},
+        "configurationTenantType": "${tci.configurationTenantType}"
+      }`;
+    });
+    configBody += `]}`;
+    let options = { method: "POST", headers: headers, body: configBody };
+    // make config endpoint call
+    try {
+        if (debug) debugger;
+        console.log("Attempting POST to /config: " + endpoint);
+        let response = await fetch(endpoint, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            let data = await response.json();
+            config.id = data;
+            console.log(
+                `Successful ConfigID: ${data} from POST to /config: ${configBody}`
+            );
+            return result;
+        }
+        else {
+            result.error = await processErrors(response);
+            console.log(`Failed PUT to /config: ${configBody}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.status = 500;
+        result.result = false;
+        result.error = error.message;
+        console.log(result.error);
+        return result;
+    }
+}
+//configPut
+export async function configPut(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    config: Config,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    if (config.id === "") {
+        result.result = false;
+        result.error = "configPost: invalid config ID";
+        result.status = 500;
+        return result;
+    }
+    // create parametrized config endpoint
+    let endpoint: string = mindlineConfig.configEndpoint();
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("configurationId", config.id);
+    // create config headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // create config body
+    let configBody: string = `
+    {
+      "name": "${config.name}",
+      "description": "${config.description}",
+      "tenants": [`;
+    config.tenants.map((tci: TenantConfigInfo) => {
+        // if last character is } we need a comma first
+        let needComma: boolean = configBody.slice(-1) === "}";
+        if (needComma) configBody += ",";
+        // be sure we send null and not "null" in body
+        let sourceGroupId: string = tci.sourceGroupId != "" ? `"${tci.sourceGroupId}"` : "null";
+        let sourceGroupName: string = tci.sourceGroupName != "" ? `"${tci.sourceGroupName}"` : "null";
+        let targetGroupId: string = tci.targetGroupId != "" ? `"${tci.targetGroupId}"` : "null";
+        let targetGroupName: string = tci.targetGroupName != "" ? `"${tci.targetGroupName}"` : "null";
+        configBody += `{
+          "tenantId": "${tci.tid}",
+          "sourceGroupId": ${sourceGroupId},
+          "sourceGroupName": ${sourceGroupName},
+          "targetGroupId": ${targetGroupId},
+          "targetGroupName": ${targetGroupName},
+          "configurationTenantType": "${tci.configurationTenantType}",
+          "deltaToken": "${tci.deltaToken}"
+        }`;
+    });
+    configBody += `]}`;
+    let options = { method: "PUT", headers: headers, body: configBody };
+    // make config endpoint call
+    try {
+        if (debug) debugger;
+        console.log("Attempting PUT to /config: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful PUT to ${url.href}: ${configBody}`);
+            return result;
+        }
+        else {
+            result.error = await processErrors(response);
+            console.log(`Failed PUT to ${url.href}: ${configBody}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//configsGet
+export async function configsGet(
+    instance: IPublicClientApplication,
+    user: User,
+    workspaceID: string,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we need a workspace id
+    if (workspaceID === "") {
+        result.result = false;
+        result.status = 500;
+        result.error = "configsGet: no workspace provided";
+        return result;
+    }
+    // create endpoint
+    let endpoint: string = mindlineConfig.configsEndpoint();
+    // add parameter to endpoint
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("workspaceId", workspaceID);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, user);
+    // make endpoint call
+    let options = { method: "GET", headers: headers };
+    try {
+        if (debug) debugger;
+        console.log("Attempting GET from /configurations: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            let returnedArray: Array<Object> = await response.json();
+            if (returnedArray != null) {
+                result.array = returnedArray;
+                let initialValue: string = "";
+                console.log(`Successful GET from /configurations: ${result.array.reduce((acc, curr) => acc + curr.name + " ", initialValue)}`);
+                return result;
+            }
+            else {
+                result.error = `Failed GET from /configurations: failed to JSON-parse response`;
+                console.log(result.error);
+                result.status = 500;
+                result.result = false;
+                return result;
+            }
+        }
+        else {
+            console.log(`Failed GET from /configurations: ${url.href}`);
+            result.error = await processErrors(response);
+            result.status = 500;
+            result.result = false;
+            console.log(result.error);
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//initPost
+export async function initPost(
+    instance: IPublicClientApplication,
+    user: User,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we expect valid company name and domain by this point
+    if (user.companyName === "" || user.companyDomain === "") {
+        result.result = false;
+        result.error = "initPost: invalid company name or domain"
+        result.status = 500;
+        return result;
+    }
+    // create init endpoint
+    let endpoint: string = mindlineConfig.initEndpoint();
+    // create init headers
+    const headers = await mindlineDefineHeaders(instance, user);
+    // create init body
+    let initBody: string = `
+  {
+    "tenantCreateModel": {
+      "tenantId": "${user.tid}",
+      "name": "${user.companyName}",
+      "domain": "${user.companyDomain}",
+      "type": "aad",
+      "authority": "${user.authority}"
+    }
+  }`;
+    let options = { method: "POST", headers: headers, body: initBody };
+    // make init endpoint call
+    try {
+        if (debug) debugger;
+        console.log("Attempting POST to /configuration/init: " + endpoint);
+        let response = await fetch(endpoint, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful POST to /configuration/init: ${initBody}`);
+            return result;
+        }
+        else {
+            result.error = await processErrors(response);
+            result.status = 500;
+            result.result = false;
+            console.log(`Failed POST to /configuration/init: ${initBody}`);
+            console.log(result.error);
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        console.log(result.error);
+    }
+    result.status = 500;
+    result.result = false;
+    return result;
+}
+//tenantDelete
+export async function tenantDelete(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    tenant: Tenant,
+    workspaceId: string,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we expect valid tid amd workspaceId
+    if (tenant.tid === "" || workspaceId === "") {
+        result.result = false;
+        result.error = "tenantDelete: invalid tid, workspaceId";
+        result.status = 500;
+        return result;
+    }
+    // create parametrized tenant endpoint
+    let url: URL = new URL(mindlineConfig.tenantEndpoint());
+    url.searchParams.append("tenantId", tenant.tid);
+    url.searchParams.append("workspaceId", workspaceId);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // make tenant endpoint call
+    let options = { method: "DELETE", headers: headers };
+    try {
+        console.log("Attempting DELETE from /tenant: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful DELETE from /tenant: ${url.href}`);
+            return result;
+        }
+        else {
+            console.log(`Failed DELETE from /tenant: ${url.href}`);
+            result.error = await processErrors(response);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(result.error);
+    }
+    return result;
+}
+//tenantsGet
+export async function tenantsGet(
+    instance: IPublicClientApplication,
+    user: User,
+    workspaceID: string,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we need a workspace id
+    if (workspaceID === "") {
+        result.result = false;
+        result.status = 500;
+        result.error = "tenantsGet: no workspace provided";
+        return result;
+    }
+    // create endpoint
+    let endpoint: string = mindlineConfig.tenantsEndpoint();
+    // add parameter to endpoint
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("workspaceId", workspaceID);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, user);
+    // make endpoint call
+    let options = { method: "GET", headers: headers };
+    try {
+        if (debug) debugger;
+        console.log(`Attempting GET from /tenants: ${url.href}`);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            let returnedArray: Array<Object> = await response.json();
+            if (returnedArray != null) {
+                result.array = returnedArray;
+                let initialValue: string = "";
+                console.log(`Successful GET from /tenants: ${result.array.reduce((acc, curr) => acc + curr.domain + " ", initialValue)}`);
+                return result;
+            }
+            else {
+                result.error = `Failed GET from /tenants: failed to JSON-parse response`;
+                console.log(result.error);
+                result.status = 500;
+                result.result = false;
+                return result;
+            }
+        }
+        else {
+            console.log(`Failed GET from /tenants: ${url.href}`);
+            result.error = await processErrors(response);
+            result.status = 500;
+            result.result = false;
+            console.log(result.error);
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//tenantPost: write validated tenant to back end
+export async function tenantPost(
+    instance: IPublicClientApplication,
+    addingUser: User,
+    tenant: Tenant,
+    workspaceId: string
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we expect valid tid, name, validated domain
+    if (tenant.tid === "" || tenant.name === "" || tenant.domain === "") {
+        result.result = false;
+        result.error = "tenantPost: invalid tid, name, domain";
+        result.status = 500;
+        return result;
+    }
+    // create parametrized tenant endpoint
+    let endpoint: string = mindlineConfig.tenantEndpoint();
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("workspaceId", workspaceId);
+    // create tenant headers
+    const headers = await mindlineDefineHeaders(instance, addingUser);
+    // create tenant body
+    let tenantBody: string = `
+    {"tenantId": "${tenant.tid}", 
+     "name": "${tenant.name}", 
+     "domain": "${tenant.domain}",
+     "type": 1,
+     "authority": "${tenant.authority}"
+    }`;
+    let options = { method: "POST", headers: headers, body: tenantBody };
+    // make tenant endpoint call
+    try {
+        console.log(`Attempting POST to ${url.href}: ${tenantBody}`);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful POST to ${url.href}: ${tenantBody}`);
+            return result;
+        }
+        else {
+            console.log(`Failed POST to ${url.href}: ${tenantBody}`);
+            result.error = await processErrors(response);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(result.error);
+    }
+    return result;
+}
+//workspacePut
+export async function workspacePut(instance: IPublicClientApplication, authorizedUser: User, workspaceId: string, workspaceName: string): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    if (workspaceId == "" || workspaceName == "") {
+        result.result = false;
+        result.error = "workspacePut: invalid workspace ID or name";
+        result.status = 500;
+        return result;
+    }
+    // create parameterized workspace endpoint
+    let endpoint: string = mindlineConfig.workspaceEndpoint();
+    let url: URL = new URL(endpoint);
+    url.searchParams.append("workspaceId", workspaceId);
+    url.searchParams.append("workspaceName", workspaceName);
+    // create workspace headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    let options = { method: "PUT", headers: headers };
+    // make config endpoint call
+    try {
+        console.log("Attempting PUT to /workspace: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful PUT to ${url.href}`);
+            return result;
+        }
+        else {
+            result.error = await processErrors(response);
+            console.log(`Failed PUT to ${url.href}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//workspacesGet
+export async function workspacesGet(
+    instance: IPublicClientApplication,
+    user: User,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we need a valid email address
+    if (user.mail == undefined || user.mail == "") {
+        result.result = false;
+        result.status = 500;
+        result.error = "adminsGet: no workspace provided";
+        return result;
+    }
+    // create workspaces endpoint
+    let endpoint: string = mindlineConfig.workspacesEndpoint();
+    // create workspace endpoint
+    let url: URL = new URL(endpoint);
+    // create workspace headers
+    const headers = await mindlineDefineHeaders(instance, user);
+    // make workspace endpoint call
+    let options = { method: "GET", headers: headers };
+    try {
+        if (debug) debugger;
+        console.log("Attempting GET from /workspaces endpoint: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            let returnedArray: Array<Object> = await response.json();
+            if (returnedArray != null) {
+                result.array = returnedArray;
+                let initialValue: string = "";
+                console.log(`Successful GET from /workspaces: ${result.array.reduce((acc, curr) => acc + curr.name + " ", initialValue)}`);
+                return result;
+            }
+            else {
+                result.error = `Failed GET from /workspaces: failed to JSON-parse response`;
+                console.log(result.error);
+                result.status = 500;
+                result.result = false;
+                return result;
+            }
+        }
+        else {
+            console.log(`Failed GET from /workspaces: ${url.href}`);
+            result.error = await processErrors(response);
+            result.status = 500;
+            result.result = false;
+            console.log(result.error);
+            return result;
+        }
+    }
+    catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
+}
+//readerPost
+export async function readerPost(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    config: Config
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    if (instance == null || authorizedUser == null) {
+        result.result = false;
+        result.error = "readerPost: invalid parameters";
+        result.status = 500;
+        return result;
+    }
+    // create reader endpoint
+    let readerEndpoint: string = mindlineConfig.readerStartSyncEndpoint();
+    let url: URL = new URL(readerEndpoint);
+    url.searchParams.append("configurationId", config.id);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // make reader endpoint call
+    let options = { method: "POST", headers: headers };
+    try {
+        console.log("Attempting POST to /startSync: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful POST to /startSync: ${readerEndpoint}`);
+            let jsonResponse = await response.json();
+            if (jsonResponse.PayloadStr != "") {
+                result.array = JSON.parse(jsonResponse.PayloadStr);
+            }
+            else {
+                result.result = false;
+                result.error = "readerPost: blank payload returned, sync may be disabled on back end";
+                result.status = 500;
+            }
+            return result;
+        } else {
+            result.error = await processErrors(response);
+            console.log(`Failed POST to /startSync: ${readerEndpoint}`);
+            console.log(result.error);
+            result.status = 500;
+            result.result = false;
+            return result;
+        }
+    } catch (error: any) {
+        result.error = error.message;
+        result.status = 500;
+        result.result = false;
+        console.log(error.message);
+    }
+    return result;
 }