@mindline/sync 1.0.29 → 1.0.31

package/hybridspa.ts

@@ -1,134 +1,893 @@
-import {
-  IPublicClientApplication,
-  AuthenticationResult,
+//hybridspa.ts - calls to Mindline Config API
+import {
+    User,
+    Tenant,
+    Config,
+    APIResult
+} from "./index";
+import {
+    IPublicClientApplication,
+    AuthenticationResult,
 } from "@azure/msal-browser";
-import { User } from "@mindline/sync";
+import { deserializeArray } from "class-transformer";
 
-// Add here the endpoints for MS Graph API services you would like to use.
-const graphConfig = {
-  graphMeEndpoint: "https://graph.microsoft.com/v1.0/me",
-  graphMailEndpoint: "https://graph.microsoft.com/v1.0/me/messages",
-  graphTenantEndpoint:
-    "https://graph.microsoft.com/beta/tenantRelationships/findTenantInformationByTenantId",
+// add here endpoints for API services you would like to use.
+export const graphConfig = {
+    // config API endpoints
+    adminEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/admin",
+    adminIncompleteEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/incomplete-admin",
+    adminsEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/admins",
+    configEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/configuration",
+    configsEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/configurations",
+    initEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/configuration/init",
+    tenantEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/tenant",
+    tenantsEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/tenants",
+    workspaceEndpoint:
+        "https://dev-configurationapi-westus.azurewebsites.net/api/v1/workspaces",
+    // graph API endpoints
+    graphGroupsEndpoint: "https://graph.microsoft.com/v1.0/groups",
+    graphMailEndpoint: "https://graph.microsoft.com/v1.0/me/messages",
+    graphMeEndpoint: "https://graph.microsoft.com/v1.0/me",
+    graphTenantByDomainEndpoint:
+        "https://graph.microsoft.com/beta/tenantRelationships/findTenantInformationByDomainName",
+    graphTenantByIdEndpoint:
+        "https://graph.microsoft.com/beta/tenantRelationships/findTenantInformationByTenantId",
+    graphUsersEndpoint: "https://graph.microsoft.com/v1.0/users",
+    // reader endpoint to trigger sync start
+    readerEndpoint: "https://dev-fn-reader-westus.azurewebsites.net/api/startSync/"
 };
-
-function updateUI(data, endpoint) {
-  console.log("Graph API responded at: " + new Date().toString());
-
-  if (endpoint === graphConfig.graphMeEndpoint) {
-    console.log(data.jobTitle);
-    console.log(data.mail);
-    console.log(data.businessPhones[0]);
-    console.log(data.officeLocation);
-  } else if (endpoint === graphConfig.graphMailEndpoint) {
-    if (data.value.length < 1) {
-      alert("Your mailbox is empty!");
-    } else {
-      console.log("Displaying Emails for the signed in user.");
-      data.value.map((d, i) => {
-        // Keeping it simple
-        if (i < 10) {
-          console.log(data.officeLocation);
-          console.log(d.subject);
-          console.log(d.from.emailAddress.address);
-        }
-      });
-    }
-  }
+// helper functions
+async function defineHeaders(
+    instance: IPublicClientApplication,
+    user: User
+): Promise<Headers> {
+    const headers = new Headers();
+    headers.append("Content-Type", "application/json");
+    headers.append("accept", "*/*");
+    // authorization header - if needed, retrieve and cache access token
+    if (user.accessToken == null || user.accessToken === "") {
+        try {
+            let response: AuthenticationResult = await instance.acquireTokenByCode({
+                code: user.spacode,
+            });
+            user.accessToken = response.accessToken; // cache access token
+            console.log("Front end token acquired: " + user.accessToken.slice(0, 20));
+        }
+        catch (error: any) {
+            console.log("Front end token failure: " + error);
+        }
+    }
+    headers.append("Authorization", `Bearer ${user.accessToken}`);
+    return headers;
 }
-
-// Helper function to call MS Graph API endpoint
-// using authorization bearer token scheme
-function callMSGraph(endpoint, token, callback) {
-  const headers = new Headers();
-  const bearer = `Bearer ${token}`;
-  headers.append("Authorization", bearer);
-
-  const options = {
-    method: "GET",
-    headers: headers,
-  };
-
-  console.log("request made to Graph API at: " + new Date().toString());
-
-  fetch(endpoint, options)
-    .then((response) => response.json())
-    .then((response) => callback(response, endpoint))
-    .then((result) => {
-      console.log("Successfully Fetched Data from Graph API:", result);
-    })
-    .catch((error) => console.log(error));
+async function processErrors(response: Response): Promise<string> {
+    let errorString: string = "";
+    if (response.status === 401) {
+        errorString = response.statusText;
+    }
+    else {
+        let data = await response.json();
+        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;
 }
-
-///get Token
-function getTokenByCode(spaCode: string, instance: IPublicClientApplication) {
-  var code = spaCode;
-  const scopes = ["user.read"];
-
-  console.log("MSAL: acquireTokenByCode hybrid parameters present");
-
-  var authResult = instance.acquireTokenByCode({
-    code,
-    scopes,
-  });
-  console.log(authResult);
-
-  return authResult;
+//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;
+    }
+    // are we performing deletion of a full admin?
+    let url: URL | null = null;
+    if (user.oid !== user.mail) {
+        url = new URL(graphConfig.adminEndpoint);
+        url.searchParams.append("userId", user.oid);
+        url.searchParams.append("workspaceId", workspaceId);
+    }
+    // or of an incomplete admin?
+    else if (user.mail !== "") {
+        url = new URL(graphConfig.adminIncompleteEndpoint);
+        url.searchParams.append("email", user.mail);
+        url.searchParams.append("workspaceId", workspaceId);
+    }
+    // create headers
+    const headers = await defineHeaders(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;
 }
-
-//See Profile
-function seeProfile(spaCode: string, instance: IPublicClientApplication) {
-  getTokenByCode(spaCode, instance)
-    .then((response) => {
-      callMSGraph(graphConfig.graphMeEndpoint, response.accessToken, updateUI);
-    })
-    .catch((error) => {
-      console.log(error);
+//adminsGet
+export async function adminsGet(
+    instance: IPublicClientApplication,
+    authorizedUser: 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 adminsEndpoint: string = graphConfig.adminsEndpoint;
+    // add parameter to endpoint
+    let url: URL = new URL(adminsEndpoint);
+    url.searchParams.append("workspaceId", workspaceID);
+    // create headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // 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 == null ||
+        user.mail === "" ||
+        user.authority == null ||
+        user.authority === "" ||
+        user.tid == null ||
+        user.tid === "" ||
+        user.companyName == null ||
+        user.companyName === "" ||
+        user.companyDomain == null ||
+        user.companyDomain === ""
+    ) {
+        result.result = false;
+        result.error = "configPost: invalid config ID";
+        result.status = 500;
+        return result;
+    }
+    // create admin endpoint
+    let adminEndpoint: string = graphConfig.adminEndpoint;
+    // create headers
+    const headers = await defineHeaders(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: " + adminEndpoint);
+        let response = await fetch(adminEndpoint, 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;
+}
+//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(graphConfig.configEndpoint);
+    url.searchParams.append("configurationId", config.id);
+    // create headers
+    const headers = await defineHeaders(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;
+}
+//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 configEndpoint: string = graphConfig.configEndpoint;
+    // create config headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // create config body
+    let configBody: string = `
+    {
+      "workspaceId": "${workspaceId}",
+      "name": "${config.name}",
+      "description": "${config.description}",
+      "isEnabled": ${config.isEnabled},
+      "tenants": [`;
+    config.tenants.map((tci) => {
+        // if last character is } we need a comma first
+        let needComma: boolean = configBody.slice(-1) === "}";
+        if (needComma) configBody += ",";
+        configBody += `{
+        "tenantId": "${tci.tid}",
+        "sourceGroupId": "${tci.sourceGroupId}",
+        "sourceGroupName": "${tci.sourceGroupName}",
+        "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: " + configEndpoint);
+        let response = await fetch(configEndpoint, 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;
+    }
 }
-
-//Get Tenant Info
-export async function getTenantInfo(user: User, instance: IPublicClientApplication) {
-  // do we already have a valid company name?
-  if (typeof user.companyName !== 'undefined' && user.companyName !== "") return;
-
-  // create tenant info endpoint
-  var tenantEndpoint = graphConfig.graphTenantEndpoint;
-  tenantEndpoint += "(tenantId='";
-  tenantEndpoint += user.tid;
-  tenantEndpoint += "')";
-  console.log("Time: " + new Date().toString());
-  console.log("Tenant Info Endpoint: " + tenantEndpoint);
-
-  // if needed, retrieve and cache access token
-  if (typeof user.accessToken === 'undefined' || user.accessToken === "") {
+//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 configEndpoint: string = graphConfig.configEndpoint;
+    let url: URL = new URL(configEndpoint);
+    url.searchParams.append("configurationId", config.id);
+    // create config headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // create config body
+    let configBody: string = `
+    {
+      "name": "${config.name}",
+      "description": "${config.description}",
+      "isEnabled": ${config.isEnabled},
+      "tenants": [`;
+    config.tenants.map((tci) => {
+        // if last character is } we need a comma first
+        let needComma: boolean = configBody.slice(-1) === "}";
+        if (needComma) configBody += ",";
+        // decide whethere to send source group values
+        configBody += `{
+      "tenantId": "${tci.tid}",
+      "sourceGroupId": "${tci.sourceGroupId}",
+      "sourceGroupName": "${tci.sourceGroupName}",
+      "configurationTenantType": "${tci.configurationTenantType}"
+    }`;
+    });
+    configBody += `]}`;
+    let options = { method: "PUT", headers: headers, body: configBody };
+    // make config endpoint call
     try {
-      let response = await instance.acquireTokenByCode({ code: user.spacode });
-      user.accessToken = response.accessToken;
-    }
-    catch(error: any) {
-      console.log(error);
-    }
-  }
-  
-  // prepare Authorization headers as part of options
-  const headers = new Headers();
-  const bearer = `Bearer ${user.accessToken}`;
-  headers.append("Authorization", bearer);
-  const options = { method: "GET", headers: headers };
-  
-  // make tenant endpoint call
-  try {
-    let response = await fetch(tenantEndpoint, options);
-    let data = await response.json();
-    if(data && data.displayName && data.displayName !== undefined)
+        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,
+    authorizedUser: 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 configsEndpoint: string = graphConfig.configsEndpoint;
+    // add parameter to endpoint
+    let url: URL = new URL(configsEndpoint);
+    url.searchParams.append("workspaceId", workspaceID);
+    // create headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // 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,
+    authorizedUser: User,
+    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 initEndpoint: string = graphConfig.initEndpoint;
+    // create init headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // 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: " + initEndpoint);
+        let response = await fetch(initEndpoint, 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(graphConfig.tenantEndpoint);
+    url.searchParams.append("tenantId", tenant.tid);
+    url.searchParams.append("workspaceId", workspaceId);
+    // create headers
+    const headers = await defineHeaders(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,
+    authorizedUser: 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 tenantsEndpoint: string = graphConfig.tenantsEndpoint;
+    // add parameter to endpoint
+    let url: URL = new URL(tenantsEndpoint);
+    url.searchParams.append("workspaceId", workspaceID);
+    // create headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // 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 tenantEndpoint: string = graphConfig.tenantEndpoint;
+    let url: URL = new URL(tenantEndpoint);
+    url.searchParams.append("workspaceId", workspaceId);
+    // create tenant headers
+    const headers = await defineHeaders(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;
+}
+//tenantPut: write access token for onboarded tenant
+export async function tenantPut(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    tenant: Tenant,
+    debug: boolean
+): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    // we expect valid tid
+    if (tenant.tid === "") {
+        result.result = false;
+        result.error = "tenantPut: invalid tid";
+        result.status = 500;
+        return result;
+    }
+    // create tenant endpoint
+    let tenantEndpoint: string = graphConfig.tenantEndpoint;
+    // create tenant headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // be sure we send null and not "null" in body
+    let readAccessToken: string = tenant.readServicePrincipal
+        ? `"${tenant.readServicePrincipal}"`
+        : "null";
+    let writeAccessToken: string = tenant.writeServicePrincipal
+        ? `"${tenant.writeServicePrincipal}"`
+        : "null";
+    // create tenant body
+    let tenantBody: string = `
+  {"tenantId": "${tenant.tid}", "readServicePrincipal": ${readAccessToken}, "writeServicePrincipal": ${writeAccessToken}}`;
+    let options = { method: "PUT", headers: headers, body: tenantBody };
+    // make tenant endpoint call
+    try {
+        if (debug) debugger;
+        console.log(`Attempting PUT to ${tenantEndpoint}`);
+        let response = await fetch(tenantEndpoint, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful PUT to ${tenantEndpoint}`);
+            return result;
+        }
+        else {
+            console.log(`Failed PUT to ${tenantEndpoint}: ${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;
+}
+//workspacesGet
+export async function workspacesGet(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    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 workspaceEndpoint: string = graphConfig.workspaceEndpoint;
+    // add email parameter to endpoint
+    let url: URL = new URL(workspaceEndpoint);
+    url.searchParams.append("userEmail", user.mail);
+    // create workspace headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // 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)
     {
-      user.companyName = data.displayName;
-      user.companyDomain = data.defaultDomainName;
-    }
-    console.log("Fetched Data from Graph API:", data);
-  }
-  catch(error: any) {
-    console.log(error);
-  }
-}
+        result.result = false;
+        result.error = "readerPost: invalid parameters";
+        result.status = 500;
+        return result;
+    }
+    // create reader endpoint with config ID
+    let readerEndpoint: string = graphConfig.readerEndpoint + config.id;
+    // create headers
+    const headers = await defineHeaders(instance, authorizedUser);
+    // make reader endpoint call
+    let options = { method: "POST", headers: headers };
+    try {
+        console.log("Attempting POST to /startSync: " + readerEndpoint);
+        debugger;
+        let response = await fetch(readerEndpoint, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful POST to /startSync: ${readerEndpoint}`);
+            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;
+}