Flow completed up to invite list

Author: perki

src/appTemplates/Collector.js

@@ -1,6 +1,8 @@
 const { HDSLibError } = require('../errors');
+const CollectorInvite = require('./CollectorInvite');
 
 const COLLECTOR_STREAMID_SUFFIXES = {
+  archive: 'archive',
   internal: 'internal',
   public: 'public',
   pending: 'pending',
@@ -38,7 +40,11 @@ class Collector {
     this.name = streamData.name;
     this.appManaging = appManaging;
     this.#streamData = streamData;
-    this.#cache = {};
+    this.#cache = {
+      invites: {},
+      invitesInitialized: false,
+      invitesInitializing: false
+    };
   }
 
   /**
@@ -143,6 +149,76 @@ class Collector {
     return await this.#setStatus(Collector.STATUSES.active);
   }
 
+  #addOrUpdateInvite (eventData) {
+    const key = CollectorInvite.getKeyForEvent(eventData);
+    if (this.#cache.invites[key]) {
+      this.#cache.invites[key].setEventData(eventData);
+    } else {
+      this.#cache.invites[key] = new CollectorInvite(this, eventData);
+    }
+    return this.#cache.invites[key];
+  }
+
+  async getInvites (forceRefresh = false) {
+    while (this.#cache.invitesInitializing) (await new Promise((resolve) => { setTimeout(resolve, 100); }));
+    this.#cache.invitesInitializing = true;
+    if (!forceRefresh && this.#cache.invitesInitialized) return Object.values(this.#cache.invites);
+    const queryParams = { types: ['invite/collector-v1'], streams: [this.streamId], fromTime: 0, toTime: 8640000000000000, limit: 10000 };
+    try {
+      await this.appManaging.connection.getEventsStreamed(queryParams, (eventData) => {
+        this.#addOrUpdateInvite(eventData);
+      });
+    } catch (e) {
+      this.#cache.invitesInitialized = true;
+      this.#cache.invitesInitializing = false;
+      throw e;
+    }
+    this.#cache.invitesInitialized = true;
+    this.#cache.invitesInitializing = false;
+    return Object.values(this.#cache.invites);
+  }
+
+  async checkInbox () {
+    const tempr = [];
+
+    const params = { types: ['credentials/collector-v1'], limit: 1, streams: [this.streamIdFor(Collector.STREAMID_SUFFIXES.inbox)] };
+    const incomingCredentials = await this.appManaging.connection.apiOne('events.get', params, 'events');
+    for (const incomingCredential of incomingCredentials) {
+      // fetch corresponding invite
+      const inviteEvent = await this.appManaging.connection.apiOne('events.getOne', { id: incomingCredential.content.eventId }, 'event');
+      if (inviteEvent == null) throw new HDSLibError(`Cannot find invite event matching id: ${incomingCredential.content.eventId}`, incomingCredential);
+      // update inviteEvent and archive inbox message
+      const apiCalls = [
+        {
+          method: 'events.update',
+          params: {
+            id: inviteEvent.id,
+            update: {
+              streamIds: [this.streamIdFor(Collector.STREAMID_SUFFIXES.active)],
+              content: Object.assign(inviteEvent.content, { apiEndpoint: incomingCredential.content.apiEndpoint })
+            }
+          }
+        },
+        {
+          method: 'events.update',
+          params: {
+            id: incomingCredential.id,
+            update: {
+              streamIds: [this.streamIdFor(Collector.STREAMID_SUFFIXES.archive)]
+            }
+          }
+        }
+      ];
+      const results = await this.appManaging.connection.api(apiCalls);
+      const errors = results.filter((r) => (!r.event));
+      if (errors.length > 0) throw new HDSLibError('Error activating incoming request', errors);
+      const eventUpdated = results[0].event;
+      const inviteUpdated = this.#addOrUpdateInvite(eventUpdated);
+      tempr.push(inviteUpdated);
+    }
+    return tempr;
+  }
+
   /**
    * Create a "pending" invite to be sent to an app using AppSharingAccount
    * @param {string} name a default display name for this request
@@ -160,11 +236,8 @@ class Collector {
       }
     };
     const newInvite = await this.appManaging.connection.apiOne('events.create', eventParams, 'event');
-    const result = {
-      apiEndpoint: await this.sharingApiEndpoint(),
-      eventId: newInvite.id
-    };
-    return result;
+    const invite = this.#addOrUpdateInvite(newInvite);
+    return invite;
   }
 
   /**
@@ -260,6 +333,22 @@ class Collector {
   streamIdFor (suffix) {
     return this.streamId + '-' + suffix;
   }
+
+  /**
+   * Invite Status for streamId
+   * reverse of streamIdFor
+   */
+  inviteStatusForStreamId (streamId) {
+    if (!this.#cache.inviteStatusForStreamId) {
+      this.#cache.inviteStatusForStreamId = {};
+      for (const status of [COLLECTOR_STREAMID_SUFFIXES.pending, COLLECTOR_STREAMID_SUFFIXES.active, COLLECTOR_STREAMID_SUFFIXES.error]) {
+        this.#cache.inviteStatusForStreamId[this.streamIdFor(status)] = status;
+      }
+    }
+    const status = this.#cache.inviteStatusForStreamId[streamId];
+    if (status == null) throw new HDSLibError(`Cannot find status for streamId: ${streamId}`);
+    return status;
+  }
 }
 
 module.exports = Collector;

src/appTemplates/CollectorInvite.js

@@ -0,0 +1,69 @@
+const pryv = require('pryv');
+const { HDSLibError } = require('../errors');
+
+/**
+ * Collector Invite
+ * There is one Collector Invite per Collector => Enduser connection
+ */
+
+class CollectorInvite {
+  /**
+   * get the key that will be assigne to this event;
+   * @param {Event} eventData
+   * @returns {string}
+   */
+  static getKeyForEvent (eventData) {
+    return eventData.id;
+  }
+
+  /** @type {Collector} */
+  collector;
+  /** @type {Event} */
+  eventData;
+  /** @type {pryv.Connection} */
+  #connection;
+
+  get key () {
+    return CollectorInvite.getKeyForEvent(this.eventData);
+  }
+
+  get status () {
+    return this.collector.inviteStatusForStreamId(this.eventData.streamIds[0]);
+  }
+
+  get apiEndpoint () {
+    return this.eventData.content.apiEndpoint;
+  }
+
+  get connection () {
+    if (this.#connection == null) {
+      this.#connection = new pryv.Connection(this.apiEndpoint);
+    }
+    return this.#connection;
+  }
+
+  get displayName () {
+    return this.eventData.content.name;
+  }
+
+  constructor (collector, eventData) {
+    if (eventData.type !== 'invite/collector-v1') throw new HDSLibError('Wrong type of event', eventData);
+    this.collector = collector;
+    this.eventData = eventData;
+  }
+
+  setEventData (eventData) {
+    if (eventData.id !== this.eventData.id) throw new HDSLibError('CollectInvite event id does not match new Event');
+    this.eventData = eventData;
+  }
+
+  async getSharingData () {
+    if (this.status !== 'pending') throw new HDSLibError('Only pendings can be shared');
+    return {
+      apiEndpoint: await this.collector.sharingApiEndpoint(),
+      eventId: this.eventData.id
+    };
+  }
+}
+
+module.exports = CollectorInvite;

src/errors.js

@@ -1,6 +1,6 @@
 class HDSLibError extends Error {
   constructor (message, innerObject = { }) {
-    const msg = (innerObject.message !== null) ? message + ' >> ' + innerObject.message : message;
+    const msg = (innerObject.message != null) ? message + ' >> ' + innerObject.message : message;
     super(msg);
     this.innerObject = innerObject;
   }

tests/apptemplates.test.js

@@ -57,7 +57,7 @@ describe('[APTX] appTemplates', function () {
 
     // check StreamStructure
     const resultCheckStructure = await newCollector.checkStreamStructure();
-    assert.equal(resultCheckStructure.created.length, 6, 'Should create 5 streams');
+    assert.equal(resultCheckStructure.created.length, 7, 'Should create 7 streams');
     for (const created of resultCheckStructure.created) {
       assert.equal(created.parentId, newCollector.streamId, 'Should have collector stream as parentid');
     }
@@ -172,11 +172,14 @@ describe('[APTX] appTemplates', function () {
     // create invite
     const options = { customData: { hello: 'bob' } };
     const invite = await newCollector.createInvite('Invite One', options);
-    assert.equal(invite.apiEndpoint, await newCollector.sharingApiEndpoint());
-    assert.ok(invite.eventId.length > 5);
+    assert.equal(invite.status, 'pending');
+    const inviteSharingData = await invite.getSharingData();
+    assert.equal(inviteSharingData.apiEndpoint, await newCollector.sharingApiEndpoint());
+    assert.ok(invite.key.length > 5);
+    assert.ok(inviteSharingData.eventId.length > 5);
 
     // check invite can be found in "pendings"
-    const inviteEvent = await appManaging.connection.apiOne('events.getOne', { id: invite.eventId }, 'event');
+    const inviteEvent = await appManaging.connection.apiOne('events.getOne', { id: inviteSharingData.eventId }, 'event');
     assert.equal(inviteEvent.type, 'invite/collector-v1');
     assert.ok(inviteEvent.streamIds[0].endsWith('-pending'));
     assert.deepEqual(inviteEvent.content, { name: 'Invite One', customData: options.customData });
@@ -185,10 +188,10 @@ describe('[APTX] appTemplates', function () {
     const permissionsClient = [{ streamId: '*', level: 'manage' }];
     const clientUser = await createUserPermissions(user, permissionsClient, [], appClientName);
     const appClient = await AppClientAccount.newFromApiEndpoint(baseStreamIdClient, clientUser.appApiEndpoint, appClientName);
-    const collectorClient = await appClient.handleIncomingRequest(invite.apiEndpoint, invite.eventId);
+    const collectorClient = await appClient.handleIncomingRequest(inviteSharingData.apiEndpoint, inviteSharingData.eventId);
     assert.equal(collectorClient.eventData.streamIds[0], appClient.baseStreamId);
-    assert.equal(collectorClient.eventData.content.apiEndpoint, invite.apiEndpoint);
-    assert.equal(collectorClient.eventData.content.requesterEventId, invite.eventId);
+    assert.equal(collectorClient.eventData.content.apiEndpoint, inviteSharingData.apiEndpoint);
+    assert.equal(collectorClient.eventData.content.requesterEventId, inviteSharingData.eventId);
 
     // TODO check collectorClient.eventData.accessInfo
 
@@ -203,13 +206,22 @@ describe('[APTX] appTemplates', function () {
 
     // accept
     const acceptResult = await collectorClient.accept();
-    assert.equal(acceptResult.requesterEvent.content.eventId, invite.eventId);
+    assert.equal(acceptResult.requesterEvent.content.eventId, inviteSharingData.eventId);
     assert.ok(!!acceptResult.requesterEvent.content.apiEndpoint);
 
     // force refresh and check online
     const collectorClients2 = await appClient.getCollectorClients(true);
     assert.equal(collectorClients2.length, 1);
     assert.deepEqual(collectorClients2[0].accessData, acceptResult.accessData);
+
+    // Continue on Collector side
+    const invitesFromInbox = await newCollector.checkInbox();
+    assert.equal(invitesFromInbox[0].eventData.type, 'invite/collector-v1');
+    assert.equal(invitesFromInbox[0].status, 'active');
+
+    // check current invites
+    const invites = await newCollector.getInvites(true);
+    assert.equal(invites[0], invitesFromInbox[0]);
   });
 
   describe('[APCX] app Templates Client', function () {