@mindline/sync 1.0.28 → 1.0.30

package/hybridspa.ts

@@ -1,136 +1,847 @@
-import {
+//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",
+// add here endpoints for API services you would like to use.
+export const graphConfig = {
+  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",
+
+  graphGroupsEndpoint: "https://graph.microsoft.com/v1.0/groups",
   graphMailEndpoint: "https://graph.microsoft.com/v1.0/me/messages",
-  graphTenantEndpoint:
+  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",
 };
-
-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,
+//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 = "configPost: invalid config ID";
+    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;
+}
+//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}"
+      }`;
   });
-  console.log(authResult);
-
-  return authResult;
+  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;
+  }
 }
-
-//See Profile
-function seeProfile(spaCode: string, instance: IPublicClientApplication) {
-  getTokenByCode(spaCode, instance)
-    .then((response) => {
-      callMSGraph(graphConfig.graphMeEndpoint, response.accessToken, updateUI);
-    })
-    .catch((error) => {
-      console.log(error);
-    });
+//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 {
+    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;
 }
-
-//Get Tenant Info
-export async function getTenantInfo(user: User, instance: IPublicClientApplication) {
-  debugger;
-
-  // 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 === "") {
-    try {
-      let response = await instance.acquireTokenByCode({ code: user.spacode });
-      user.accessToken = response.accessToken;
+//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;
+      }
     }
-    catch(error: any) {
-      console.log(error);
+    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;
     }
   }
-  
-  // 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 };
-  
+  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);
-    let data = await response.json();
-    if(data && data.displayName && data.displayName !== undefined)
-    {
-      user.companyName = data.displayName;
-      user.companyDomain = data.defaultDomainName;
+    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;
     }
-    console.log("Fetched Data from Graph API:", data);
   }
-  catch(error: any) {
-    console.log(error);
+  catch (error: any) {
+    result.error = error.message; 
+    result.status = 500;
+    result.result = false;
+    console.log(error.message);
   }
+  return result;
 }