anear-js-api 0.2.2 → 0.3.2

package/lib/api/AnearApi.js

@@ -24,6 +24,13 @@ class AnearApi extends ApiService {
     return json
   }
 
+  async getApp(appId) {
+    logger.debug(`API: GET app ${appId}`)
+
+    const json = await this.get("apps", {id: appId})
+    return json
+  }
+
   async getZoneEvents(zoneId) {
     logger.debug(`API: GET zone_events ${zoneId}`)
 
@@ -38,7 +45,7 @@ class AnearApi extends ApiService {
     try {
       const json = await this.post("transitions", {event_name: eventName}, relationships)
       const attrs = json.data.attributes
-      logger.info(`newState is ${attrs.state}`)
+      logger.info(`API: newState is ${attrs.state}`)
       return attrs
     } catch(err) {
       logger.error(err)

package/lib/api/ApiService.js

@@ -1,7 +1,7 @@
 "use strict"
 const ErrorResponse = require('./ErrorResponse')
 const qs = require('qs')
-const fetch = require('node-fetch')
+const fetch = require('cross-fetch')
 
 const DeveloperApiURL = "https://api.anearapp.com/developer/v1"
 

package/lib/index.js

@@ -2,11 +2,10 @@
 
 const JsonApiResource = require('./models/JsonApiResource')
 const JsonApiArrayResource = require('./models/JsonApiArrayResource')
-const AnearEvent = require('./models/AnearEvent')
+const {AnearEvent, logger} = require('./models/AnearEvent')
 const AnearParticipant = require('./models/AnearParticipant')
 const AnearMessaging = require('./messaging/AnearMessaging')
 const AnearApiService = require('./api/ApiService')
-const Logger = require('./utils/Logger')
 const Fixtures = require('../tests/fixtures')
 const MockMessaging = require('./messaging/__mocks__/AnearMessaging')
 
@@ -14,10 +13,10 @@ module.exports = {
   JsonApiResource,
   JsonApiArrayResource,
   AnearEvent,
+  logger,
   AnearParticipant,
   AnearMessaging,
   AnearApiService,
-  Logger,
   Fixtures,
   MockMessaging,
 }

package/lib/messaging/AnearMessaging.js

@@ -2,6 +2,7 @@
 const Ably = require('ably/promises')
 const AnearApi = require('../api/AnearApi')
 const logger = require('../utils/Logger')
+const { Mutex } = require('async-mutex')
 
 const AppId = process.env.ANEARAPP_APP_ID
 
@@ -12,6 +13,9 @@ const CreateEventMessageType     = 'create_event'
 const ExitEventMessageType       = 'exit_event'
 const EventTransitionMessageType = 'event_transition'
 
+const PRESENCE_ENTER = 'enter'
+const PRESENCE_LEAVE = 'leave'
+
 // any channel messages sent with 5 secs (5s) of initial attach will be delivered
 // to the subscribers
 const ChannelParams = {params: {rewind: "5s"}}
@@ -26,6 +30,7 @@ class AnearMessaging {
     this.api = new AnearApi()
     this.AnearEventClass = AnearEventClass
     this.AnearParticipantClass = AnearParticipantClass
+    this.mutex = new Mutex()
 
 
     const baseUrl          = this.api.api_base_url
@@ -62,13 +67,21 @@ class AnearMessaging {
     this.realtime.connection.on(
       "connected",
       async () => {
+        await this.getAppInfo(AppId)
         logger.info("Ably connected!")
-        await this.reloadAnyEventsInProgress(AppId)
         await this.setupCreateEventChannel()
+        await this.reloadAnyEventsInProgress(AppId)
       }
     )
   }
 
+  async getAppInfo(appId) {
+    const anearApp = await this.api.getApp(appId)
+    logger.info("================")
+    logger.info(`STARTING APP ${anearApp.data.attributes['short-name']}`)
+    logger.info("================")
+  }
+
   getChannel(channelName, channelParams = ChannelParams) {
     return this.realtime.channels.get(channelName, channelParams)
   }
@@ -81,31 +94,31 @@ class AnearMessaging {
     }
   }
 
-  setParticipantTimer(eventId, anearParticipant, timeoutMilliseconds) {
-    const participantId = anearParticipant.id
+  setParticipantTimer(eventId, participant, timeoutMilliseconds) {
+    const participantId = participant.id
 
     this.clearParticipantTimer(participantId)
 
     if (timeoutMilliseconds === 0) return
 
-    logger.debug(`setting ${timeoutMilliseconds} msec timer for event ${eventId}, participant ${anearParticipant.id}`)
+    logger.debug(`setting ${timeoutMilliseconds} msec timer for event ${eventId}, participant ${participant.id}`)
 
     this.participantTimers[participantId] = setTimeout(
-      async () => await this.timerExpired(eventId, anearParticipant, timeoutMilliseconds),
+      async () => await this.timerExpired(eventId, participant, timeoutMilliseconds),
       timeoutMilliseconds
     )
   }
 
-  async timerExpired(eventId, anearParticipant, timeoutMilliseconds) {
-    const participantId = anearParticipant.id
+  async timerExpired(eventId, participant, timeoutMilliseconds) {
+    const participantId = participant.id
 
     logger.debug(`participant (${eventId}, ${participantId}) TIMED OUT after ${timeoutMilliseconds} msecs`)
 
     await this.getAnearEventWithLockFromStorage(
       eventId,
       async anearEvent => {
-        const anearParticipant = await this.getAnearParticipantFromStorage(participantId)
-        await anearEvent.participantTimedOut(anearParticipant)
+        const participant = await this.getAnearParticipantFromStorage(participantId)
+        await anearEvent.participantTimedOut(participant)
         await anearEvent.update()
       }
     )
@@ -115,25 +128,10 @@ class AnearMessaging {
     return await this.AnearEventClass.getFromStorage(eventId, this)
   }
 
-  async getAnearEventWithLockFromStorage(eventId, callback) {
-    return await this.AnearEventClass.getWithLockFromStorage(
-      eventId,
-      callback,
-      this
-    )
-  }
-
   async getAnearParticipantFromStorage(participantId) {
     return await this.AnearParticipantClass.getFromStorage(participantId)
   }
 
-  async getAnearParticipantWithLockFromStorage(participantId, callback) {
-    return await this.AnearParticipantClass.getWithLockFromStorage(
-      participantId,
-      callback
-    )
-  }
-
   async initEventRealtimeMessaging(anearEvent) {
 
     if (this.eventChannels.hasOwnProperty(anearEvent.id)) {
@@ -162,34 +160,45 @@ class AnearMessaging {
     // create the AnearEvent subclass, persist it in storage, and
     // initialize its realtime messaging
     //
-    logger.info(`Ably message received....createEventMessagingCallback(${message.name})`)
+    logger.info(`createEventMessagingCallback(${message.name})`)
 
     try {
       const eventJson = JSON.parse(message.data)
       const anearEvent = new this.AnearEventClass(eventJson, this)
+
       //
       // if we are getting this event create message from history after a quick restart,
       // we just return if the event already exists
       //
-      await this.loadOrPersistEventAndInitMessaging(anearEvent)
+      await this.loadOrPersistEventAndInitialize(anearEvent)
     } catch(err) {
       logger.error(err)
     }
   }
 
-  async loadOrPersistEventAndInitMessaging(anearEvent) {
+  async loadOrPersistEventAndInitialize(anearEvent) {
     const eventExists = await anearEvent.exists()
 
     logger.info(`Event ${anearEvent.id} ${eventExists ? "already exists" : "does not exist"} in Storage`)
 
+    let loadedEvent = anearEvent
+
     if (!eventExists) {
-      await anearEvent.createdEventCallback()
-      await anearEvent.persist()
+      await this.runExclusive("createEventCallback", async () => {
+        await anearEvent.createdEventCallback()
+        await anearEvent.persist()
+        anearEvent.startStateMachine()
+        await this.initEventRealtimeMessaging(anearEvent)
+      })
+    } else {
+      loadedEvent = await this.getAnearEventFromStorage(anearEvent.id)
+      await this.initEventRealtimeMessaging(loadedEvent)
+      loadedEvent.startStateMachine()
     }
 
-    logger.info(`New ${anearEvent.constructor.name} Event: `, anearEvent.toJSON())
+    logger.info(`New ${loadedEvent.constructor.name} Event: `, loadedEvent.toJSON())
 
-    await this.initEventRealtimeMessaging(anearEvent)
+    return loadedEvent
   }
 
   async reloadAnyEventsInProgress(appId) {
@@ -202,7 +211,8 @@ class AnearMessaging {
         for (const eventData of events) {
           const eventJson = await this.api.getEvent(eventData.id)
           const anearEvent = new this.AnearEventClass(eventJson, this)
-          await this.loadOrPersistEventAndInitMessaging(anearEvent)
+          // const loadedEvent = await this.loadOrPersistEventAndInitialize(anearEvent)
+          // await this.refreshActiveParticipants(loadedEvent) DOES NOT WORK YET
         }
       }
     } catch (err) {
@@ -210,6 +220,20 @@ class AnearMessaging {
     }
   }
 
+  async refreshActiveParticipants(anearEvent) {
+    const allParticipants = anearEvent.participants.active(false)
+
+    return Promise.all(
+      allParticipants.map(
+        async participant => await this.processParticipantEnter(
+          anearEvent,
+          participant.id,
+          participant.geoLocation
+        )
+      )
+    )
+  }
+
   async setupCreateEventChannel() {
     logger.info(`attaching to channel ${AnearCreateEventChannelName}`)
 
@@ -238,14 +262,14 @@ class AnearMessaging {
 
     this.subscribePresenceEvent(
       spectatorsChannel,
-      'enter',
-      async message => await this.spectatorEnterMessagingCallback(anearEvent.id, message)
+      PRESENCE_ENTER,
+      async message => await this.spectatorEnterMessagingCallback(anearEvent, message)
     )
 
     this.subscribePresenceEvent(
       spectatorsChannel,
-      'leave',
-      async message => await this.spectatorLeaveMessagingCallback(anearEvent.id, message)
+      PRESENCE_LEAVE,
+      async message => await this.spectatorLeaveMessagingCallback(anearEvent, message)
     )
   }
 
@@ -258,23 +282,23 @@ class AnearMessaging {
 
     await this.subscribePresenceEventWithHistory(
       actionsChannel,
-      'enter',
-      async message => await this.participantEnterMessagingCallback(anearEvent.id, message)
+      PRESENCE_ENTER,
+      async message => await this.participantEnterMessagingCallback(anearEvent, message)
     )
     this.subscribeEventMessages(
       actionsChannel,
       ActionMessageType,
-      async message => await this.participantActionMessagingCallback(anearEvent.id, message)
+      async message => await this.participantActionMessagingCallback(anearEvent, message)
     )
     this.subscribePresenceEvent(
       actionsChannel,
-      'leave',
-      async message => await this.participantLeaveMessagingCallback(anearEvent.id, message)
+      PRESENCE_LEAVE,
+      async message => await this.participantLeaveMessagingCallback(anearEvent, message)
     )
     this.subscribeEventMessages(
       actionsChannel,
       ExitEventMessageType,
-      async message => await this.participantExplicitExitMessagingCallback(anearEvent.id, message)
+      async message => await this.participantExplicitExitMessagingCallback(anearEvent, message)
     )
   }
 
@@ -298,20 +322,22 @@ class AnearMessaging {
     return participantsChannel
   }
 
-  async participantExplicitExitMessagingCallback(eventId, message) {
+  async participantExplicitExitMessagingCallback(anearEvent, message) {
     //
     // client user deliberately cancels out of event
     //
     const participantId = message.data.participantId
 
-    logger.debug(`ExitEventMessage received from ${participantId} for event ${eventId}`)
+    logger.debug(`ExitEventMessage received from ${participantId} for event ${anearEvent.id}`)
 
-    await this.closeParticipant(eventId, participantId,
-      (anearEvent, anearParticipant) => anearEvent.participantClose(anearParticipant)
+    await this.closeParticipant(
+      anearEvent,
+      participantId,
+      (anearEvent, participant) => anearEvent.participantClose(participant)
     )
   }
 
-  async participantEnterMessagingCallback(eventId, presenceMessage) {
+  async participantEnterMessagingCallback(anearEvent, presenceMessage) {
     // presenceMessage.clientId is the participant's user_id
     // presenceMessage.data = {
     //   id: participantId,
@@ -321,89 +347,83 @@ class AnearMessaging {
     const participantId = presenceMessage.data.id
     const geoLocation = presenceMessage.data.geoLocation
 
-    logger.debug(`**** ENTER PARTICIPANT ****  event: ${eventId}, participant: ${participantId}`)
+    logger.debug(`**** ENTER PARTICIPANT ****  event: ${anearEvent.id}, participant: ${participantId}`)
 
+    await this.processParticipantEnter(anearEvent, participantId, geoLocation)
+  }
+
+  async processParticipantEnter(anearEvent, participantId, geoLocation) {
+
+    logger.debug(`processing Participant Enter for event: ${anearEvent.id}, participant: ${participantId}`)
     //
     // get the participant data from the API (this will also validate the participant).
     // check if the participant is already in storage, and if so, instantiate, else
     // instantiate from API response
     //
     try {
-      logger.debug(`API fetch participant info for ${participantId}`)
-
-      const anearParticipantJson = await this.api.getEventParticipantJson(participantId)
-      const anearParticipant = new this.AnearParticipantClass(anearParticipantJson)
+      const participantJson = await this.api.getEventParticipantJson(participantId)
+      const participant = new this.AnearParticipantClass(participantJson)
 
-      anearParticipant.geoLocation = geoLocation
-
-      await this.setupPrivatePublishingChannel(anearParticipant)
+      participant.geoLocation = geoLocation
 
       const persistedAnearParticipant = await this.AnearParticipantClass.getFromStorage(participantId)
 
-      const eventLockCallback = async (anearEvent) => {
-        await anearEvent.participantEnter(anearParticipant)
-        await anearEvent.update()
-      }
-
       if (persistedAnearParticipant) {
-        anearParticipant.appData = persistedAnearParticipant.appData
-        await anearParticipant.update()
+        participant.context = persistedAnearParticipant.context
       }
 
-      await this.getAnearEventWithLockFromStorage(anearParticipant.eventId, eventLockCallback)
-
+      await this.runExclusive("participantEnterCallback", async () => {
+        await this.setupPrivatePublishingChannel(participant)
+        await anearEvent.participantEnter(participant)
+        await anearEvent.update()
+      })
     } catch(error) {
       // participant not found or is not currently marked active at the API service
       // don't allow participation.  FIX: we need to publish to the private channel
       // with an error message type.
-      logger.error(`participantEnterMessagingCallback(${eventId}, ${participantId}) error: `, error)
+      logger.error(`processParticipanEnter(${anearEvent.id}, ${participantId}) error: `, error)
     }
   }
 
-  async spectatorEnterMessagingCallback(eventId, message) {
+  async spectatorEnterMessagingCallback(anearEvent, message) {
     const userId = message.clientId
-    const anearEvent = await this.getAnearEventFromStorage(eventId)
 
-    logger.debug(`**** ENTER SPECTATOR ****  event: ${eventId}, user: ${userId}`)
+    logger.debug(`**** ENTER SPECTATOR ****  event: ${anearEvent.id}, user: ${userId}`)
 
     await anearEvent.refreshSpectator()
   }
 
-  async spectatorLeaveMessagingCallback(eventId, message) {
+  async spectatorLeaveMessagingCallback(anearEvent, message) {
     const userId = message.clientId
-    logger.debug(`**** LEAVE SPECTATOR ****  event: ${eventId}, user: ${userId}`)
+    logger.debug(`**** LEAVE SPECTATOR ****  event: ${anearEvent.id}, user: ${userId}`)
   }
 
-  async participantLeaveMessagingCallback(eventId, message) {
+  async participantLeaveMessagingCallback(anearEvent, message) {
     // this can be just a temporary leave (refresh browser for example), so we don't do anything
     // for now
     const userId = message.clientId
     logger.debug(`**** LEAVE PARTICIPANT ****  participantLeaveMessagingCallback(user: ${userId})`)
   }
 
-  async closeParticipant(eventId, participantId, callback) {
+  async closeParticipant(anearEvent, participantId, callback) {
     logger.debug(`closeParticipant(${participantId})`)
 
     this.clearParticipantTimer(participantId)
 
-    await this.getAnearEventWithLockFromStorage(
-      eventId,
-      async (anearEvent) => {
-        const anearParticipant = await this.getAnearParticipantFromStorage(participantId)
-
+    const participant = await this.getAnearParticipantFromStorage(participantId)
 
-        if (anearParticipant) {
-          await this.detachParticipantPrivateChannel(eventId, anearParticipant)
+    if (participant) {
+      await this.detachParticipantPrivateChannel(anearEvent.id, participant)
 
-          await callback(anearEvent, anearParticipant)
-          await anearEvent.update()
-        }
-      }
-    )
+      await this.runExclusive("closeParticipant", async () => {
+        await callback(anearEvent, participant)
+        await anearEvent.update()
+      })
+    }
   }
 
-  async detachParticipantPrivateChannel(eventId, anearParticipant) {
-    const userId = anearParticipant.userId
+  async detachParticipantPrivateChannel(eventId, participant) {
+    const userId = participant.userId
     const channel = this.eventChannels[eventId].privates[userId]
 
     if (channel) {
@@ -411,26 +431,33 @@ class AnearMessaging {
       delete this.eventChannels[eventId].privates[userId]
     }
   }
-
-  async participantActionMessagingCallback(eventId, message) {
+  async participantActionMessagingCallback(anearEvent, message) {
+    // e.g. message.data
+    //   {
+    //     participantId: "93387343489",
+    //     payload: "{"reviewResponse":{"questionId": "ab88373ccf", "decision":"approved"}}"
+    //   }
+    //
+    //   actionEventName => "reviewResponse"
+    //   actionPayload => {questionId: "ab88373ccf", decision:"approved"}
+    //
     const payload = message.data.payload
     const participantId = message.data.participantId
 
-    logger.debug(`participantActionMessagingCallback(${eventId}, ${participantId})`)
+    logger.debug(`participantActionMessagingCallback(${anearEvent.id}, ${participantId})`)
 
     this.clearParticipantTimer(participantId)
 
     const actionJSON = JSON.parse(payload)
     const [actionEventName, actionPayload] = Object.entries(actionJSON)[0]
 
-    await this.getAnearEventWithLockFromStorage(
-      eventId,
-      async anearEvent => {
-        const anearParticipant = await this.getAnearParticipantFromStorage(participantId)
-        await anearEvent.participantAction(anearParticipant, actionEventName, actionPayload)
-        await anearEvent.update()
-      }
-    )
+    const participant = await this.getAnearParticipantFromStorage(participantId)
+
+    await this.runExclusive("participantActionCallback", async () => {
+      await anearEvent.participantAction(participant, actionEventName, actionPayload)
+      await anearEvent.update()
+      await participant.update()
+    })
   }
 
   async eventBroadcastMessagingCallback(eventId, message) {
@@ -441,12 +468,12 @@ class AnearMessaging {
     await anearEvent.update()
   }
 
-  async setupPrivatePublishingChannel(anearParticipant) {
-    const privateChannel = this.getChannel(anearParticipant.privateChannelName, {})
-    this.eventChannels[anearParticipant.eventId].privates[anearParticipant.userId] = privateChannel
+  async setupPrivatePublishingChannel(participant) {
+    const privateChannel = this.getChannel(participant.privateChannelName, {})
+    this.eventChannels[participant.eventId].privates[participant.userId] = privateChannel
     await this.attachChannel(privateChannel)
 
-    logger.debug(`setupPrivatePublishingChannel(${anearParticipant.privateChannelName}) state ${privateChannel.state}`)
+    logger.debug(`setupPrivatePublishingChannel(${participant.privateChannelName}) state ${privateChannel.state}`)
   }
 
   async attachChannel(channel) {
@@ -457,6 +484,18 @@ class AnearMessaging {
     }
   }
 
+  async runExclusive(name, callback) {
+    logger.debug(`waiting for ${name} mutex`)
+
+    await this.mutex.runExclusive(
+      async () => {
+        logger.debug(`mutex ${name} locked!`)
+        await callback()
+      }
+    )
+    logger.debug(`mutex ${name} released!`)
+  }
+
   subscribeEventMessages(channel, messageType, callback) {
     channel.subscribe(messageType, callback)
     logger.debug(`subscribed to ${messageType} messages on ${channel.name}`)
@@ -505,7 +544,7 @@ class AnearMessaging {
     if (timeoutMilliseconds === 0) return
 
     participants.forEach(
-      anearParticipant => this.setParticipantTimer(eventId, anearParticipant, timeoutMilliseconds)
+      participant => this.setParticipantTimer(eventId, participant, timeoutMilliseconds)
     )
   }
 
@@ -521,18 +560,18 @@ class AnearMessaging {
 
   async publishEventPrivateMessage(
           eventId,
-          anearParticipant,
+          participant,
           messageType,
           css,
           message,
           timeoutMilliseconds=0,
           timeoutCallback=null) {
 
-    const userId = anearParticipant.userId
+    const userId = participant.userId
     const channel = this.eventChannels[eventId].privates[userId]
     if (!channel) throw new Error(`private channel not found.  invalid user id ${userId}`)
 
-    const setTimerFunction = () => this.setParticipantTimer(eventId, anearParticipant, timeoutMilliseconds)
+    const setTimerFunction = () => this.setParticipantTimer(eventId, participant, timeoutMilliseconds)
 
     await this.publishChannelMessageWithTimeout(
       channel,