@mindline/sync 1.0.106 → 1.0.107

package/package.json

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

package/src/index.ts

@@ -93,6 +93,9 @@ export class mindlineConfig {
     static signalREndpoint(): string {
         return `https://${mindlineConfig.environmentTag}-signalrdispatcher-westus.azurewebsites.net/statsHub`;
     };
+    static statsEndpoint(): string {
+        return `https://${mindlineConfig.environmentTag}-signalrdispatcher-westus.azurewebsites.net/api/stats`;
+    }
 }
 export class graphConfig {
     // graph API predicates
@@ -785,7 +788,7 @@ export class MilestoneArray {
             let result = localStorage.getItem("syncmilestones");
             if (result != null && typeof result === "string" && result !== "") {
                 let milestonesString: string = result;
-                let milestones: Object [] = JSON.parse(milestonesString);
+                let milestones: Object[] = JSON.parse(milestonesString);
                 if (milestones.length !== 0) {
                     if (bClearLocalStorage) {
                         localStorage.removeItem("syncmilestones");
@@ -812,7 +815,7 @@ export class MilestoneArray {
         if (this.milestones == null || this.milestones.length < 1) { debugger; return; }
         let currentRun: number = Number(this.milestones[0].Run);
         // create a new milestone and prepend to front of array
-        let newMilestone: Milestone = new Milestone(currentRun+1);
+        let newMilestone: Milestone = new Milestone(currentRun + 1);
         this.milestones.unshift(newMilestone);
         // re-define milestone array to trigger render
         this.milestones = this.milestones.map((ms: Milestone) => {
@@ -1027,7 +1030,9 @@ export class BatchArray {
         this.pb_total = 0;
         this.pb_timer = setInterval(() => {
             // if signalR has finished the sync, stop the timer
-            if (this.milestoneArray.milestones[0].Write != null) {
+            console.log("this.tenantNodes", this.tenantNodes)
+            let isCompletedOrNothingToSync = this.tenantNodes.map((tn: TenantNode) => tn.targets.map((ta) => ta.status === "complete" || tn.nothingtosync).reduce((prev, next) => prev && next)).reduce((prev, next) => prev && next);
+            if (isCompletedOrNothingToSync) {
                 clearInterval(this.pb_timer!);
                 this.pb_timer = null;
                 this.pb_progress = 100;
@@ -1074,12 +1079,15 @@ export class BatchArray {
         batchIdArray: Array<Object>,
         setRefreshDeltaTrigger: (workspace: string) => void,
         setReadersTotal: (readersTotal: number) => void,
+        setReadersExcluded: (readersExcluded: number) => void,
         setReadersCurrent: (readersCurrent: number) => void,
         setWritersTotal: (writersTotal: number) => void,
-        setWritersCurrent: (writersCurrent: number) => void ,
+        setWritersExcluded: (writersExcluded: number) => void,
+        setWritersCurrent: (writersCurrent: number) => void,
         setMilestones: (milestones: Milestone[]) => void,
         setConfigSyncResult: (result: string) => void,
-        bClearLocalStorage: boolean
+        bClearLocalStorage: boolean,
+        message: string
     ): void {
         bClearLocalStorage = bClearLocalStorage;
         // we have just completed a successful POST to startSync
@@ -1088,7 +1096,7 @@ export class BatchArray {
         // re-initialize batch array with Configuration updated by the succcessful POST to startSync
         this.init(config, syncPortalGlobalState, false);
         // define newMessage handler that can access *this*
-        let handler = (message: string) => {
+        let handler = (connection: signalR.HubConnection) => (message: string) => {
             console.log(message);
             let item = JSON.parse(message);
             // reset the countdown timer every time we get a message
@@ -1117,12 +1125,29 @@ export class BatchArray {
             for (let j = 0; j < statskeys.length; j++) {
                 let bTotalCount = statskeys[j].endsWith("TotalCount");
                 let bCurrentCount = statskeys[j].endsWith("CurrentCount");
+                let bExcludedCount = statskeys[j].endsWith("ExtCount");
                 let bDeferredCount = statskeys[j].endsWith("DeferredCount");
                 let bRescheduledCount = statskeys[j].endsWith("RescheduledCount");
+                if (bExcludedCount) {
+                    tenantNode.excluded = Math.max(Number(statsvalues[j]), tenantNode.excluded);
+                    tenantNode.targets.map(writerNode => {
+                        writerNode.excluded = tenantNode.excluded;
+                        writerNode.update(writerNode.total, writerNode.read, writerNode.excluded, writerNode.written, writerNode.deferred);
+                    })
+                }
+                if (bTotalCount) {
+                    bTotalCountZero = Number(statsvalues[j]) == 0;
+                    tenantNode.total = Math.max(Number(statsvalues[j]), tenantNode.total);
+                    tenantNode.targets.map(writerNode => {
+                        writerNode.total = tenantNode.total;
+                        writerNode.update(writerNode.total, writerNode.read, writerNode.excluded, writerNode.written, writerNode.deferred);
+                    })
+                }
                 if (statskeys[j].startsWith("Reader")) {
                     // parse tid from Reader key
                     let tidRegexp = /Reader\/TID:(.+)\/TotalCount/;
                     if (bCurrentCount) tidRegexp = /Reader\/TID:(.+)\/CurrentCount/;
+                    if (bExcludedCount) tidRegexp = /Reader\/TID:(.+)\/ExtCount/;
                     if (bDeferredCount) tidRegexp = /Reader\/TID:(.+)\/DeferredCount/;
                     if (bRescheduledCount) tidRegexp = /Reader\/TID:(.+)\/RescheduledCount/;
                     let matchTID = statskeys[j].match(tidRegexp);
@@ -1139,15 +1164,21 @@ export class BatchArray {
                     }
                     else {
                         bCurrentCountZero = Number(statsvalues[j]) == 0;
-                        tenantNode.read = Math.max(Number(statsvalues[j]), tenantNode.read);
-                        console.log(`----- ${tenantNode.name} Currently Read: ${tenantNode.read}`);
+                        if (bCurrentCount) {
+                            tenantNode.read = Math.max(Number(statsvalues[j]), tenantNode.read);
+                            console.log(`----- ${tenantNode.name} Currently Read: ${tenantNode.read}`);
+                        } else if (bDeferredCount) {
+                            tenantNode.deferred = Math.max(Number(statsvalues[j]), tenantNode.deferred);
+                            console.log(`----- ${tenantNode.name} Deferred: ${tenantNode.deferred}`);
+                        }
                     }
                 }
                 tenantNode.nothingtosync = bTotalCountZero && bCurrentCountZero;
                 if (statskeys[j].startsWith("Writer")) {
                     // parse tid from Writer key
-                    let tidRegexp = /Writer\/TID:(.+)\/TotalCount/;
+                    let tidRegexp = /Reader\/TID:(.+)\/TotalCount/;
                     if (bCurrentCount) tidRegexp = /Writer\/TID:(.+)\/CurrentCount/;
+                    if (bExcludedCount) tidRegexp = /Writer\/TID:(.+)\/ExtCount/;
                     if (bDeferredCount) tidRegexp = /Writer\/TID:(.+)\/DeferredCount/;
                     if (bRescheduledCount) tidRegexp = /Writer\/TID:(.+)\/RescheduledCount/;
                     let matchTID: RegExpMatchArray | null = statskeys[j].match(tidRegexp);
@@ -1163,9 +1194,11 @@ export class BatchArray {
                         debugger;
                         return;
                     }
+                    writerNode.total = Math.max(Number(tenantNode.total), writerNode.total);
+                    writerNode.total = Math.max(Number(tenantNode.total), writerNode.total);
                     writerNode.batchId = matchingPair.BatchId;
                     if (bTotalCount) {
-                        writerNode.total = Math.max(Number(statsvalues[j]), writerNode.total);
+                        writerNode.total = Math.max(Number(bTotalCount), writerNode.total);
                         console.log(`----- ${writerNode.name} TID: ${writerNode.tid} batchId: ${writerNode.batchId}`);
                         console.log(`----- ${writerNode.name} Total To Write: ${writerNode.total}`);
                     }
@@ -1182,11 +1215,12 @@ export class BatchArray {
                         debugger;
                         return;
                     }
-                    writerNode.update(writerNode.total, writerNode.read, writerNode.written, writerNode.deferred);
+                    writerNode.update(writerNode.total, writerNode.read, writerNode.excluded, writerNode.written, writerNode.deferred);
                 }
             }
             // update status based on all updates in this message
-            tenantNode.update(tenantNode.total, tenantNode.read, tenantNode.written, tenantNode.deferred);
+            tenantNode.update(tenantNode.total, tenantNode.read, tenantNode.excluded, tenantNode.written, tenantNode.deferred);
+
             // for each message, enumerate nodes to assess completion state
             let bReadingComplete: boolean = true;
             let bWritingComplete: boolean = true;
@@ -1194,34 +1228,41 @@ export class BatchArray {
             let bNothingToSync: boolean = true;
             let readerTotal: number = 0;
             let readerCurrent: number = 0;
+            let readerExcluded: number = 0;
             let writerTotal: number = 0;
             let writerCurrent: number = 0;
+            let writerExcluded: number = 0;
             this.tenantNodes.map((sourceTenantNode: TenantNode) => {
                 sourceTenantNode.targets.map((writerNode: TenantNode) => {
                     bWritingComplete &&= (writerNode.status == "complete" || writerNode.status == "failed");
                     bWritingStarted ||= (writerNode.total > 0 || writerNode.status != "not started");
                     writerTotal += Math.max(writerNode.total, sourceTenantNode.total);
                     writerCurrent += writerNode.written;
+                    writerExcluded += writerNode.excluded;
                 });
                 bNothingToSync &&= sourceTenantNode.nothingtosync;
                 bReadingComplete &&= (sourceTenantNode.status == "complete" || sourceTenantNode.status == "failed");
                 readerTotal += sourceTenantNode.total;
                 readerCurrent += sourceTenantNode.read;
+                readerExcluded += sourceTenantNode.excluded;
             });
             // set linear gauge max and current values
             setReadersTotal(readerTotal);
             setReadersCurrent(readerCurrent);
+            setReadersExcluded(readerExcluded);
             setWritersTotal(Math.max(writerTotal, readerTotal));
             setWritersCurrent(writerCurrent);
+            setWritersExcluded(writerExcluded);
             // check to see if there was nothing to sync
             if (bNothingToSync) {
                 this.milestoneArray.write(setMilestones);
+                connection.stop();
                 setConfigSyncResult("nothing to sync");
                 console.log(`Setting config sync result: "nothing to sync"`);
             }
             else {
                 // because it is an important milestone, we always check if we have *just* completed reading
-                if (bReadingComplete && this.milestoneArray.milestones[0].Read == null) {
+                if (bReadingComplete) {
                     this.milestoneArray.read(setMilestones);
                     setConfigSyncResult("reading complete");
                     console.log(`Setting config sync result: "reading complete"`);
@@ -1238,6 +1279,7 @@ export class BatchArray {
                 // with that out of the way, is writing complete?
                 if (bWritingComplete) {
                     this.milestoneArray.write(setMilestones);
+                    connection.stop();
                     setConfigSyncResult("sync complete");
                     console.log(`Setting config sync result: "complete"`);
                 }
@@ -1253,6 +1295,7 @@ export class BatchArray {
                 }
             }
         }
+
         // start SignalR connection based on each batchId
         batchIdArray.map((batchPair: any) => {
             const endpoint: string = mindlineConfig.signalREndpoint();
@@ -1265,7 +1308,10 @@ export class BatchArray {
                 .configureLogging(signalR.LogLevel.Information)
                 .build();
             // when you get a message, process the message
-            connection.on("newMessage", handler);
+            if (!!message && JSON.parse(message).TargetID === batchPair.BatchId) {
+                handler(connection)(message)
+            }
+            connection.on("newMessage", handler(connection));
             connection.onreconnecting(error => {
                 console.assert(connection.state === signalR.HubConnectionState.Reconnecting);
                 console.log(`Connection lost due to error "${error}". Reconnecting.`);
@@ -1284,8 +1330,7 @@ export class BatchArray {
         });
     }
     // start a sync cycle
-    async startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: SyncConfig | null | undefined): Promise<APIResult>
-    {
+    async startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: SyncConfig | null | undefined): Promise<APIResult> {
         let result: APIResult = new APIResult();
         if (this.tenantNodes == null || this.tenantNodes.length == 0) {
             // we should not have an empty batch array for a test
@@ -1308,8 +1353,9 @@ export class TenantNode {
     batchId: string;
     total: number = 0;
     read: number = 0;
+    excluded: number = 0;
     written: number = 0;
-    deferred: number =0 ;
+    deferred: number = 0;
     nothingtosync: boolean;
     targets: TenantNode[];
     constructor(tid: string, name: string, batchId: string) {
@@ -1319,22 +1365,23 @@ export class TenantNode {
         this.batchId = batchId;
         this.nothingtosync = false;
         this.targets = new Array<TenantNode>();
-        this.update(0, 0, 0, 0);
+        this.update(0, 0, 0, 0, 0);
     }
-    update(total: number, read: number, written: number, deferred: number): void {
+    update(total: number, read: number, excluded: number, written: number, deferred: number): void {
         this.total = total;
         this.read = read;
+        this.excluded = excluded;
         this.written = written;
         this.deferred = deferred;
         if (this.read === 0 && this.written === 0) this.status = "not started";
         if (this.read > 0) {
-            if (this.read < this.total) this.status = "in progress";
-            else if (this.read === this.total) this.status = "complete";
+            if (this.read + this.excluded < this.total) this.status = "in progress";
+            else if (this.read + this.excluded === this.total) this.status = "complete";
         }
         else if (this.written > 0) {
-            if (this.written + this.deferred < this.total) this.status = "in progress";
-            else if (this.written === this.total) this.status = "complete";
-            else if (this.written + this.deferred >= this.total) this.status = "failed";
+            if (this.written + this.deferred + this.excluded < this.total) this.status = "in progress";
+            else if (this.written + this.deferred + this.excluded === this.total) this.status = "complete";
+            else if (this.written + this.deferred + this.excluded >= this.total) this.status = "failed";
         }
     }
 }
@@ -1549,7 +1596,7 @@ export async function groupsGet(instance: IPublicClientApplication, user: User |
         return { groups: [], error: `Exception: ${error}` };
     }
 }
-export async function oauth2PermissionGrantsGet(options: RequestInit, user: User, spid: string, oid: string): Promise<{ grants: string|null, id: string|null, error: string }> {
+export async function oauth2PermissionGrantsGet(options: RequestInit, user: User, spid: string, oid: string): Promise<{ grants: string | null, id: string | null, error: string }> {
     try {
         // make /oauth2PermissionGrants endpoint call
         let spurl: string = getGraphEndpoint(user.authority) + graphConfig.graphOauth2PermissionGrantsPredicate;
@@ -1730,7 +1777,7 @@ export function signInIncrementally(user: User, scope: string): void {
     url.searchParams.append("loginHint", user.mail);
     window.location.assign(url.href);
 }
-export async function signOut(user: User): Promise<boolean>{
+export async function signOut(user: User): Promise<boolean> {
     if (user.oid == "1") return false;
     // set logout_hint in the .NET session for streamlined logout
     let userEndpoint: string = window.location.href;
@@ -1941,7 +1988,7 @@ export async function tenantUnauthenticatedLookup(tenant: Tenant, debug: boolean
     }
     return false; // failed, no need for UX to re-render
 }
-export async function userDelegatedScopesGet(instance: IPublicClientApplication, loggedInUser: User, tenant: Tenant): Promise<{ scopes: string|null, id: string|null, error: string }> {
+export async function userDelegatedScopesGet(instance: IPublicClientApplication, loggedInUser: User, tenant: Tenant): Promise<{ scopes: string | null, id: string | null, error: string }> {
     // need a logged in user and valid tenant to query graph
     if (loggedInUser == null || loggedInUser.spacode == "" || tenant == null) {
         debugger;
@@ -2053,8 +2100,7 @@ export async function configEdit(
     setSelectedConfigs: (selectedConfigs: { [id: string]: boolean | number[] }) => void,
     workspace: Workspace,
     ii: InitInfo,
-    debug: boolean): Promise<APIResult>
-{
+    debug: boolean): Promise<APIResult> {
     let result: APIResult = new APIResult();
     if (config.id === "1") {
         result = await configPost(instance, authorizedUser, config, workspace.id, debug);
@@ -2098,7 +2144,7 @@ export async function configConsentForRead(instance: IPublicClientApplication, a
 export async function configConsentForWrite(instance: IPublicClientApplication, authorizedUser: User, configId: string, tid: string, consent: boolean): Promise<APIResult> {
     return configConsentWritePut(instance, authorizedUser, configId, tid, consent);
 }
-export async function configsRefresh(instance: IPublicClientApplication, authorizedUser: User, workspaceId: string, ii: InitInfo, debug: boolean): Promise<APIResult> {
+export async function configsRefresh(instance: IPublicClientApplication, authorizedUser: User, workspaceId: string, ii: InitInfo, debug: boolean, currentConfig: SyncConfig): Promise<APIResult> {
     let result: APIResult = new APIResult();
     if (debug) debugger;
     try {
@@ -2107,26 +2153,35 @@ export async function configsRefresh(instance: IPublicClientApplication, authori
             // clear SyncConfig associations as we are about to reset
             workspace.associatedConfigs.length = 0;
             // GET configs associated with this workspace
-            let result: APIResult = await workspaceConfigsGet(instance, authorizedUser, workspace.id, debug);
+            let result: APIResult = await configGet(instance, authorizedUser, currentConfig, workspace.id, debug);
             if (!result.result) return result;
             // process returned workspace components
-            let configSelectedId: string = "";
-            for (let cid of workspace.associatedConfigs) {
-                let config = ii.cs.find((c: SyncConfig) => c.id === cid);
-                if (config != null && config.sel) {
-                    ii.cs.find((c: SyncConfig) => c.id === cid) ??
-                        ii.acs.find((a: AuditConfig) => a.id === cid);
+            // let configSelectedId: string = "";
+            // for (let cid of workspace.associatedConfigs) {
+            //     let config = ii.cs.find((c: SyncConfig) => c.id === cid);
+            //     if (config != null && config.sel) {
+            //         ii.cs.find((c: SyncConfig) => c.id === cid) ??
+            //             ii.acs.find((a: AuditConfig) => a.id === cid);
 
-                    if (config && config.sel) {
-                        configSelectedId = config.id;
-                    }
-                }
+            //         if (config && config.sel) {
+            //             configSelectedId = config.id;
+            //         }
+            //     }
 
-                // Pass combined list to processor
-                processReturnedConfigs(workspace, ii, result.array!, configSelectedId);
-                // tag components with workspaceIDs
-                ii.tagWithWorkspaces();
-            }
+            //     // Pass combined list to processor
+            //     processReturnedConfigs(workspace, ii, result.array!, currentConfig.id);
+            //     console.log("Init Info-----------", ii)
+            //     console.log("Init Info-----------", configSelectedId)
+            //     // tag components with workspaceIDs
+            //     ii.tagWithWorkspaces();
+            //     localStorage.setItem("BatchIdArray", "{}");
+            // }
+            // processReturnedConfigs(workspace, ii, result.array!, currentConfig.id);
+            // console.log("Init Info-----------", ii)
+            // console.log("Init Info-----------", currentConfig.id)
+            // tag components with workspaceIDs
+            ii.tagWithWorkspaces();
+            localStorage.setItem("BatchIdArray", "{}");
             return result;
         } else {
             // workspace not found
@@ -2200,8 +2255,7 @@ export async function userAdd(instance: IPublicClientApplication, authorizedUser
 export async function userRemove(instance: IPublicClientApplication, authorizedUser: User, user: User, workspaceId: string): Promise<APIResult> {
     return adminDelete(instance, authorizedUser, user, workspaceId);
 }
-export async function workspaceEdit(instance: IPublicClientApplication, authorizedUser: User, workspaceId: string, workspaceName: string): Promise<APIResult>
-{
+export async function workspaceEdit(instance: IPublicClientApplication, authorizedUser: User, workspaceId: string, workspaceName: string): Promise<APIResult> {
     return await workspacePut(instance, authorizedUser, workspaceId, workspaceName);
 }
 // retrieve Workspace(s), User(s), Tenant(s), SyncConfig(s) given newly logged in user
@@ -2359,6 +2413,7 @@ function processReturnedConfigs(workspace: Workspace, ii: InitInfo, returnedConf
         let idx = workspace.associatedConfigs.findIndex((c) => c === item.id);
         if (idx == -1) workspace.associatedConfigs.push(item.id);
     });
+    console.log("--------------ii-----------", ii)
     ii.save();
 }
 async function workspaceInfoGet(instance: IPublicClientApplication, user: User, ii: InitInfo, debug: boolean): Promise<APIResult> {
@@ -2463,9 +2518,9 @@ export async function getPowerBIAccessToken(
         }
         let response: AuthenticationResult = await instance.acquireTokenSilent({
             scopes: ["https://analysis.windows.net/powerbi/api/App.Read.All",
-                     "https://analysis.windows.net/powerbi/api/Dataset.ReadWrite.All",
-                     "https://analysis.windows.net/powerbi/api/Report.ReadWrite.All",
-                     "https://analysis.windows.net/powerbi/api/Workspace.ReadWrite.All"
+                "https://analysis.windows.net/powerbi/api/Dataset.ReadWrite.All",
+                "https://analysis.windows.net/powerbi/api/Report.ReadWrite.All",
+                "https://analysis.windows.net/powerbi/api/Workspace.ReadWrite.All"
             ],
             account: account!
         });
@@ -2586,7 +2641,7 @@ export async function elevateGlobalAdminToUserAccessAdmin(instance: IPublicClien
         console.log(error);
         return false;
     }
-    return true; 
+    return true;
 }
 async function readResources(instance: IPublicClientApplication, user: User): Promise<ResourceNode[]> {
     // need a logged in user to call Azure REST API
@@ -3256,6 +3311,56 @@ export async function configConsentWritePut(instance: IPublicClientApplication,
     return result;
 }
 //configDelete
+export async function configGet(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    config: SyncConfig,
+    workspaceId: string,
+    debug: boolean
+): Promise<APIResult> {
+    debug = debug;
+    let result: APIResult = new APIResult();
+    if (config.id === "" || workspaceId == "") {
+        result.result = false;
+        result.error = "configGet: invalid config ID";
+        result.status = 500;
+        return result;
+    }
+    let url: URL | null = null;
+    url = new URL(mindlineConfig.configEndpoint());
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // make endpoint call
+    let options = { method: "GET", headers: headers };
+    try {
+        console.log("Attempting GET from /config: " + url.href);
+        let response = await fetch(`${url.href}/${config.id}`, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful GET from /config`);
+            let data = await response.json()
+            return {
+                ...result,
+                array: [data]
+            };
+        }
+        else {
+            result.error = await processErrors(response);
+            console.log(`Failed GET 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;
+}
+//configDelete
 export async function configDelete(
     instance: IPublicClientApplication,
     authorizedUser: User,
@@ -3482,7 +3587,11 @@ export async function configPut(
         let response = await fetch(url.href, options);
         if (response.status === 200 && response.statusText === "OK") {
             console.log(`Successful PUT to ${url.href}: ${configBody}`);
-            return result;
+            let data = await response.json();
+            return {
+                ...result,
+                array: [data]
+            };
         }
         else {
             result.error = await processErrors(response);
@@ -3609,7 +3718,7 @@ export async function workspaceConfigsGet(
                 }));
 
                 console.log(
-                    `workspaceConfigsGet: found ${result.array.length} configs.`                   
+                    `workspaceConfigsGet: found ${result.array.length} configs.`
                 );
                 return result;
             } else {
@@ -4005,4 +4114,55 @@ export async function readerPost(
         console.log(error.message);
     }
     return result;
+}
+//readStats
+export async function readerStats(
+    instance: IPublicClientApplication,
+    authorizedUser: User,
+    tenantId: String
+): 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 stasEndpoint: string = mindlineConfig.statsEndpoint();
+    let url: URL = new URL(`${stasEndpoint}/${tenantId}`);
+    // create headers
+    const headers = await mindlineDefineHeaders(instance, authorizedUser);
+    // make reader endpoint call
+    let options = { method: "GET", headers: headers };
+    try {
+        console.log("Attempting GET to /stats: " + url.href);
+        let response = await fetch(url.href, options);
+        if (response.status === 200 && response.statusText === "OK") {
+            console.log(`Successful GET to /stats: ${stasEndpoint}`);
+            let jsonResponse = await response.json();
+            result.array = [jsonResponse];
+            return result;
+        } else if (response.status === 204) {
+            result.error = await processErrors(response);
+            console.log(`Failed GET to /stats: ${stasEndpoint}`);
+            console.log(result.error);
+            result.status = 204;
+            result.result = false;
+            return result;
+        } else {
+            result.error = await processErrors(response);
+            console.log(`Failed GET to /stats: ${stasEndpoint}`);
+            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;
 }