@mindline/sync 1.0.18 → 1.0.20

package/configs.json

@@ -16,6 +16,6 @@
             "targetGroup": "TODO"
         }
     ],
-    "enabled": "false"
+    "enabled": ""
   }
 ]

package/hybridspa.ts

@@ -0,0 +1,126 @@
+import { IPublicClientApplication, AuthenticationResult } from '@azure/msal-browser';
+import { User } from '@mindline/sync';
+
+// 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",
+};
+
+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 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));
+}
+
+///get Token
+function getTokenByCode(spaCode) {
+  var code = spaCode;
+  const scopes = ["user.read"];
+
+  console.log("MSAL: acquireTokenByCode hybrid parameters present");
+
+  var authResult = msalInstance.acquireTokenByCode({
+    code,
+    scopes,
+  });
+  console.log(authResult);
+
+  return authResult;
+}
+
+//See Profile
+function seeProfile(spaCode) {
+  getTokenByCode(spaCode)
+    .then((response) => {
+      callMSGraph(graphConfig.graphMeEndpoint, response.accessToken, updateUI);
+    })
+    .catch((error) => {
+      console.log(error);
+    });
+}
+
+//Get Tenant Info
+export function getTenantInfo(user: User, instance: IPublicClientApplication) {
+  debugger;
+
+  let authResult: AuthenticationResult;
+  instance
+    .acquireTokenByCode({ code: user.spacode })
+    .then((result) => (authResult = result))
+    .catch((e: any) => {
+      console.log(e);
+    });
+
+  const headers = new Headers();
+  const bearer = `Bearer ${authResult.accessToken}`;
+  headers.append("Authorization", bearer);
+
+  const options = {
+    method: "GET",
+    headers: headers,
+  };
+
+  var tenantEndpoint = graphConfig.graphTenantEndpoint;
+  tenantEndpoint += "(tenantId='";
+  tenantEndpoint += user.tid;
+  tenantEndpoint += "')";
+
+  console.log(
+    "request made to Graph API tenant endpoint at: " + new Date().toString()
+  );
+
+  fetch(tenantEndpoint, options)
+    .then((response) => response.json())
+    .then((response) => {
+      console.log("Successfully Fetched Data from Graph API:", response);
+    })
+    .catch((error) => console.log(error));
+
+  user.companyName = response.displayName;
+  user.companyDomain = response.defaultDomainName;
+}

package/{index.test.js → index.test.ts}

@@ -1,12 +1,11 @@
-import {sum, User, InitInfo, InitGet } from "./index.js";
+import {sum, User, InitInfo, InitGet } from "index";
 import {test, expect} from "vitest";
 
 test("adds 1 + 2 to equal 3", () => {
   expect(sum(1, 2)).toBe(3);
 });
 test("loads config based on a user and expects function to return true", () => {
-  let u = new User();
   let ii = new InitInfo();
-  expect(InitGet(u, ii)).toBe(true);
-  expect(ii.us.length).toBe(6);
+  let bResult:boolean = InitGet(ii, null);
+  expect(bResult);
 });

package/{index.js → index.ts}

@@ -11,7 +11,18 @@ export function helloNpm() {
 const FILTER_FIELD = "workspaceIDs";
 
 export class User {
-  constructor(){
+  oid: string;
+  name: string;
+  mail: string;
+  authority: string;
+  tid: string;
+  companyName: string;
+  companyDomain: string;
+  associatedWorkspaces: string[];
+  workspaceIDs: string;
+  session: string;
+  spacode: string;
+  constructor() {
     this.oid = "";
     this.name = "";
     this.mail = "";
@@ -19,13 +30,22 @@ export class User {
     this.tid = "";
     this.companyName = "";
     this.companyDomain = "";
-    this.associatedWorkspaces = {};
+    this.associatedWorkspaces = new Array();
     this.workspaceIDs = "";
     this.session = "";
+    this.spacode = "";
   }
 }
 
 export class Target {
+  tid: string;
+  name: string;
+  domain: string;
+  type: string;
+  authority: string;
+  readServicePrincipal: string;
+  writeServicePrincipal: string;
+  workspaceIDs: string;
   constructor(){
     this.tid = "";
     this.name = "";
@@ -38,35 +58,56 @@ export class Target {
   }
 }
 
+export class TargetConfigInfo {
+  tid: string;
+  sourceGroups: string[];
+  targetGroup: string;
+}
+
 export class Config {
+  id: string;
+  name: string;
+  description: string;
+  targetConfigs: TargetConfigInfo[];
+  enabled: boolean;
+  workspaceIDs: string;
   constructor(){
     this.id = "";
     this.name = "";
     this.description = "";
-    this.targetConfigs = {};
+    this.targetConfigs = new Array();
     this.enabled = false;
     this.workspaceIDs = "";
   }
 }
 
 export class Workspace {
+  id: string;
+  name: string;
+  associatedUsers: string[];
+  associatedTargets: string[];
+  associatedConfigs: string[];
   constructor(){
     this.id = "";
     this.name = "";
-    this.associatedUsers = {};
-    this.associatedTargets = {};
-    this.associatedConfigs = {};
+    this.associatedUsers = new Array();
+    this.associatedTargets = new Array();
+    this.associatedConfigs = new Array();
   }
 }
 
 export class InitInfo {
-  constructor() {
-    this.us = {};
-    this.ts = {};
-    this.cs = {};
-    this.ws = {};
+  us: User[];
+  ts: Target[];
+  cs: Config[];
+  ws: Workspace[];
+  constructor(){
+    this.us = new Array();
+    this.ts = new Array();
+    this.cs = new Array();
+    this.ws = new Array();
   }
-  initWorkspaceIDs() {
+  tagWithWorkspaces(): boolean {
     // for each Workspace tag associated User, Target, Config with Workspace.id
     for (let workspace of this.ws) {
       // find matching Users to tag with this workspace
@@ -118,15 +159,16 @@ export class InitInfo {
 }
 
 import { deserializeArray } from 'class-transformer';
+import { IPublicClientApplication } from '@azure/msal-browser';
+import { getTenantInfo } from './hybridspa';
 import users from "./users.json";
 import targets from "./targets.json";
 import configs from "./configs.json";
 import workspaces from "./workspaces.json";
 
-// retrieve Workspace(s), User(s), Target(s), Config(s) given logged in user
-export function InitGet(user, ii)
+// get hardcoded data from JSON
+function DummyInit(ii)
 {
-  // for now, just get hardcoded data from JSON
   var usersString = JSON.stringify(users);
   var targetsString = JSON.stringify(targets);
   var configsString = JSON.stringify(configs);
@@ -143,6 +185,57 @@ export function InitGet(user, ii)
   }
   return true;
 }
+// retrieve Workspace(s), User(s), Target(s), Config(s) given logged in user
+    // three InitGet scenarios
+    // scenario 1: empty user array, read defaults
+    // scenario 2: user array with dummy user at end, return without doing anything
+    // scenario 3: user array with non-dummy user at end, call back end Init
+    //    (1) TODO: Azure AD: lookup companyDomain and companyName
+    //      look up tenant name
+    //      look up tenant domain
+    //      TODO: Mindline: post complete user to init endpoint
+    //      create and push partial tenant at end of target array
+    //      post user and partial tenant to InitInfo
+    //      Return: success return value, need to query for associations
+    //    (2) Sync NPM: ii.ws: once InitInfo completes, retrieve workspaces for the new user
+    //      TODO: Mindline: retrieve associated workspaces
+    //      Returns: associated workspaces
+    //    (3) Sync NPM:
+    //      TODO: Mindline: retrieve associated admins, targets for each workspace
+    //      ii.us / ii.ts / ii.cs: query components of each associated workspaces
+    //      Returns: users, targets, configs for each workspace
+export function InitGet(ii: InitInfo, instance: IPublicClientApplication)
+{
+  debugger;
+
+  // if empty user array, retrieve dummy data from JSON to populate UI
+  let l = ii.us.length;
+  if(l === 0) return DummyInit(ii);
+
+  // if last user is a dummy user, then we have nothing
+  let user:User = ii.us[l-1];
+  if(user.oid === "1") return true;
+
+  // have real user: remove dummy user, target, config, workspace if they exist
+  let dummyIndex = ii.us.findIndex((u) => u.oid === "1");
+  ii.us.splice(dummyIndex, 1);
+  dummyIndex = ii.ts.findIndex((u) => u.tid === "1");
+  ii.ts.splice(dummyIndex, 1);
+  dummyIndex = ii.cs.findIndex((u) => u.id === "1");
+  ii.cs.splice(dummyIndex, 1);
+  dummyIndex = ii.ws.findIndex((u) => u.id === "1");
+  ii.ws.splice(dummyIndex, 1);
+
+  // why would instance be null here? investigate!
+  if(instance===null) {
+    debugger;
+    return false;
+  }
+
+  // valid user, query AAD for associated company name and domain
+  getTenantInfo(user, instance);
+  return;
+}
 
 export function AddTarget()
 {

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@mindline/sync",
   "type": "module",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "sync is a node.js package encapsulating javscript classes required for configuring Mindline sync service.",
-  "exports": "./index.js",
+  "exports": "./index.ts",
+  "main": "./index.ts",
   "scripts": {
     "test": "vitest",
     "coverage": "vitest run --coverage"
@@ -15,6 +16,7 @@
     "vitest": "^0.29.8"
   },
   "dependencies": {
+    "@azure/msal-browser": "^2.37.0",
     "class-transformer": "^0.5.1",
     "reflect-metadata": "^0.1.13"
   },

package/sync.d.ts

@@ -1,3 +1,5 @@
+import { IPublicClientApplication } from "@azure/msal-browser";
+
 declare module "@mindline/sync" {
   export function sum(a: number, b: number): number;
   export function helloNpm(): string;
@@ -14,15 +16,15 @@ declare module "@mindline/sync" {
     associatedWorkspaces: string[];
     workspaceIDs: string;
     session: string;
+    spacode: string;
   }
 
   // target (Azure AD tenant, AD domain, Google workspace)
-  enum TargetType { AAD = 1, AD, Google }
   export class Target {
     tid: string;        // from AAD ID token
     name: string;       // findTenantInformationByTenantId
     domain: string;     // findTenantInformationByTenantId
-    type: TargetType;   // always AAD for now
+    type: string;       // always AAD=1 for now
     authority: string;  // from AAD ID auth response
     readServicePrincipal: string; // from AAD consent
     writeServicePrincipal: string; // from AAD consent
@@ -32,7 +34,7 @@ declare module "@mindline/sync" {
   // config
   export class TargetConfigInfo {
     tid: string;            // target identifier
-    sourceGroups: string[]; // source groups - we can confiure multiple source groups for reading (*may* slow things down, but less work for admin)
+    sourceGroups: string[]; // source groups - we can configure multiple source groups for reading (*may* slow things down, but less work for admin)
     targetGroup: string;    // target group - we only write users to a single target group (complex to fiugure out which users get written to which groups)
   }
   export class Config {
@@ -61,7 +63,7 @@ declare module "@mindline/sync" {
     tagWithWorkspaces(): boolean;
   }
 
-  export function InitGet(u: User, ii: InitInfo): boolean;
+  export function InitGet(ii: InitInfo, instance: IPublicClientApplication): boolean;
   export function AddTarget(): boolean;
   export function CompleteTarget(): boolean;
   export function AddUser(): boolean;