anear-js-api 0.3.32 → 0.3.34

package/lib/messaging/AnearMessaging.js

@@ -1,9 +1,7 @@
 "use strict"
 const Ably = require('ably/promises')
 const AnearApi = require('../api/AnearApi')
-const ParticipantTimer = require('../utils/ParticipantTimer')
 const logger = require('../utils/Logger')
-const { Mutex } = require('async-mutex')
 
 const AppId = process.env.ANEARAPP_APP_ID
 
@@ -29,7 +27,6 @@ class AnearMessaging {
     this.api = new AnearApi()
     this.AnearEventClass = AnearEventClass
     this.AnearParticipantClass = AnearParticipantClass
-    this.mutex = new Mutex()
     this.anearEvents = {}
 
     const baseUrl          = this.api.api_base_url
@@ -53,7 +50,6 @@ class AnearMessaging {
     }
 
     this.eventChannels = {}
-    this.participantTimers = {}
 
     this.initRealtime(clientOptions)
   }
@@ -85,75 +81,6 @@ class AnearMessaging {
     return this.realtime.channels.get(channelName, channelParams)
   }
 
-  ensureParticipantTimer(anearEvent, participant, timeoutMsecs) {
-    // this is called when a new timer is being started for a privateMessage
-    // sent to a participant, or public message to all participants
-    // If the timer already exists and is paused, it is resumed with the timeRemaining
-    // [a starter function, timeRemaining] is returned 
-    let timeRemaining = timeoutMsecs
-    let timerStarter = () => {}
-
-    if (timeoutMsecs > 0) {
-      const timer = this.participantTimers[participant.id] || this.createTimer(anearEvent, participant, timeoutMsecs)
-
-      if (timer.isRunning) {
-        timeRemaining = timer.interrupt()
-      } else {
-        timerStarter = () => timer.start(timeoutMsecs)
-      }
-    }
-    logger.debug(`ensureParticipantTimer(timeRemaining: ${timeRemaining})`)
-
-    return [timerStarter, timeRemaining]
-  }
-
-  createTimer(anearEvent, participant, timeoutMsecs) {
-    const timer = new ParticipantTimer(
-      participant.id,
-      async () => await this.timerExpired(anearEvent, participant, timeoutMsecs)
-    )
-    this.participantTimers[participant.id] = timer
-
-    return timer
-  }
-
-  destroyParticipantTimer(participantId) {
-    // participant will not be receiving any more display messages
-    // so we close out and delete the ParticipantTimer
-    const timer = this.participantTimers[participantId]
-
-    if (timer) {
-      timer.reset()
-      delete this.participantTimers[participantId]
-    }
-  }
-
-  resetAllParticipantTimers() {
-    // turns off all participant timers
-    Object.values(this.participantTimers).forEach(timer => timer.reset())
-  }
-
-  interruptParticipantTimer(participantId) {
-    const timer = this.participantTimers[participantId]
-
-    if (timer && timer.isRunning) timer.interrupt()
-  }
-
-  resetParticipantTimer(participantId) {
-    // called after participant takes Action before timer expires
-    const timer = this.participantTimers[participantId]
-    if (timer) timer.reset()
-  }
-
-  async timerExpired(anearEvent, participant, timeoutMsecs) {
-    logger.debug(`participant (${anearEvent.id}, ${participant.id}) TIMED OUT after ${timeoutMsecs} msecs`)
-
-    delete this.participantTimers[participant.id]
-
-    await anearEvent.participantTimedOut(participant)
-    await anearEvent.update()
-  }
-
   async getAnearEventFromStorage(eventId) {
     return await this.AnearEventClass.getFromStorage(eventId, this.AnearParticipantClass, this)
   }
@@ -215,7 +142,7 @@ class AnearMessaging {
     let loadedEvent = anearEvent
 
     if (!eventExists) {
-      await this.runExclusive("createEventCallback", async () => {
+      await anearEvent.runExclusive("createEventCallback", async () => {
         await anearEvent.createdEventCallback()
         await anearEvent.persist()
         // start the state machine before initialiing Realtime Messaging
@@ -249,6 +176,8 @@ class AnearMessaging {
           const anearEvent = new this.AnearEventClass(eventJson, this.AnearParticipantClass, this)
           // This needs work!!
           // loadedEvent = await this.getAnearEventFromStorage(anearEvent.id)
+          // NOTE: there should be existing presence state to read from action channel
+          // to drive this...not a reload from storage
           // await this.refreshActiveParticipants(loadedEvent)
           //  await this.initEventRealtimeMessaging(loadedEvent)
           //  loadedEvent.startStateMachine()
@@ -262,7 +191,7 @@ class AnearMessaging {
 
   async refreshActiveParticipants(anearEvent) {
     await this.participants.reloadFromStorage(
-      p => this.processParticipantEnter(anearEvent, p.id, p.geoLocation)
+      p => this.processParticipantEnter(anearEvent, p.id)
     )
   }
 
@@ -399,7 +328,7 @@ class AnearMessaging {
     await this.processParticipantEnter(anearEvent, participantId, geoLocation)
   }
 
-  async processParticipantEnter(anearEvent, participantId, geoLocation) {
+  async processParticipantEnter(anearEvent, participantId, geoLocation = null) {
 
     logger.debug(`processing Participant Enter for event: ${anearEvent.id}, participant: ${participantId}`)
     //
@@ -411,15 +340,15 @@ class AnearMessaging {
       const participantJson = await this.api.getEventParticipantJson(participantId)
       const participant = new this.AnearParticipantClass(participantJson, anearEvent)
 
-      participant.geoLocation = geoLocation
-
       const persistedAnearParticipant = await this.getAnearParticipantFromStorage(participantId, anearEvent)
 
       if (persistedAnearParticipant) {
         participant.context = persistedAnearParticipant.context
       }
 
-      await this.runExclusive("participantEnterCallback", async () => {
+      await anearEvent.runExclusive("participantEnterCallback", async () => {
+        participant.geoLocation = geoLocation
+
         await this.setupPrivatePublishingChannel(participant)
         await anearEvent.participantEnter(participant)
         await anearEvent.update()
@@ -446,13 +375,15 @@ class AnearMessaging {
   }
 
   async participantLeaveMessagingCallback(anearEvent, message) {
-    // this can be just a temporary leave (a participant refreshing their browser for example), so pause any participant timers
+    // this can be just a temporary leave (a participant refreshing their browser for example),
+    // so pause any participant timers
     const userId = message.clientId
     const participantId = message.data.id
+    const participant = anearEvent.participants.getById(participantId)
 
-    logger.debug(`**** LEAVE PARTICIPANT ****  participantLeaveMessagingCallback(participant: ${participantId})`)
+    logger.debug(`**** LEAVE PARTICIPANT ****  participantLeaveMessagingCallback(participant: ${participant.id})`)
 
-    this.interruptParticipantTimer(participantId)
+    participant.interruptTimer()
   }
 
   async closeParticipant(anearEvent, participantId, callback = null) {
@@ -462,14 +393,14 @@ class AnearMessaging {
     // and cleaning out any remaining participants.
     logger.debug(`closeParticipant(${participantId})`)
 
-    this.destroyParticipantTimer(participantId)
-
-    const participant = await this.getAnearParticipantFromStorage(participantId, anearEvent)
+    const participant = anearEvent.participants.getById(participantId)
 
     if (participant) {
+      participant.destroyTimer()
+
       await this.detachParticipantPrivateChannel(anearEvent.id, participant)
 
-      await this.runExclusive("closeParticipant", async () => {
+      await anearEvent.runExclusive("closeParticipant", async () => {
         if (callback) {
           await callback(anearEvent, participant)
         }
@@ -501,16 +432,16 @@ class AnearMessaging {
     const participantId = message.data.participantId
     const payload = message.data.payload
 
-    this.resetParticipantTimer(participantId) // participant responded in time, reset any running timer
+    const participant = anearEvent.participants.getById(participantId)
+
+    participant.resetTimer() // participant responded in time, reset any running timer
 
     logger.debug(`participantActionMessagingCallback(${anearEvent.id}, ${participantId})`)
 
     const actionJSON = JSON.parse(payload)
     const [actionEventName, actionPayload] = Object.entries(actionJSON)[0]
 
-    const participant = await this.getAnearParticipantFromStorage(participantId, anearEvent)
-
-    await this.runExclusive("participantActionCallback", async () => {
+    await anearEvent.runExclusive("participantActionCallback", async () => {
       await anearEvent.participantAction(participant, actionEventName, actionPayload)
       await anearEvent.update()
       await participant.update()
@@ -540,18 +471,6 @@ 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}`)
@@ -593,14 +512,14 @@ class AnearMessaging {
     )
   }
 
-  setMultipleParticipantTimers(anearEvent, participants, timeoutMsecs) {
+  setMultipleParticipantTimers(participants, timeoutMsecs) {
     if (timeoutMsecs === 0) return [() => {}, 0]
 
     const participantTimers = []
 
     participants.forEach(
       participant => {
-        const [startTimer, _timeRemaining] = this.ensureParticipantTimer(anearEvent, participant, timeoutMsecs)
+        const [startTimer, _timeRemaining] = participant.ensureTimer(timeoutMsecs)
         participantTimers.push(startTimer)
       }
     )
@@ -612,7 +531,7 @@ class AnearMessaging {
     const eventId = anearEvent.id
     const channel = this.eventChannels[eventId].participants
 
-    const [startTimers, timeRemaining] = this.setMultipleParticipantTimers(eventId, participants, timeoutMsecs)
+    const [startTimers, timeRemaining] = this.setMultipleParticipantTimers(participants, timeoutMsecs)
 
     await this.publishMessage(
       channel,
@@ -637,7 +556,7 @@ class AnearMessaging {
     const channel = this.eventChannels[anearEvent.id].privates[userId]
     if (!channel) throw new Error(`private channel not found.  invalid user id ${userId}`)
 
-    const [startTimer, timeRemaining] = this.ensureParticipantTimer(anearEvent, participant, timeoutMsecs)
+    const [startTimer, timeRemaining] = participant.ensureTimer(timeoutMsecs)
 
     await this.publishMessage(
       channel,

package/lib/models/AnearEvent.js

@@ -1,5 +1,7 @@
 "use strict"
 
+const { Mutex } = require('async-mutex')
+
 const AnearXstate = require('../utils/AnearXstate')
 const { DefaultConfigFunc, DefaultOptionsFunc } = require('../utils/AnearXstateDefaults')
 
@@ -19,6 +21,7 @@ class AnearEvent extends JsonApiResource {
     this.messaging = messaging
     this.anearStateMachine = this.initStateMachine(json.previousState)
     this.participants = new Participants(this, json.participants)
+    this.mutex = new Mutex()
   }
 
   toJSON() {
@@ -177,6 +180,18 @@ class AnearEvent extends JsonApiResource {
     )
   }
 
+  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!`)
+  }
+
   async publishEventSpectatorsMessage(message) {
     await this.messaging.publishEventSpectatorsMessage(this, this.css, message)
   }

package/lib/models/AnearParticipant.js

@@ -1,19 +1,23 @@
 "use strict"
 const JsonApiResource = require('./JsonApiResource')
+const ParticipantTimer = require('../utils/ParticipantTimer')
+const logger = require('../utils/Logger')
+
 const HostUserType = "host"
 
 class AnearParticipant extends JsonApiResource {
   constructor(json, anearEvent) {
     super(json)
     this.anearEvent = anearEvent
+    this.timer = null
     this._state = json.state
     this._timestamp = json.timestamp
+    this._geoLocation = null
   }
 
   toJSON() {
     return {
       ...super.toJSON(),
-      geoLocation: this._geoLocation || null,
       state: this.state,
       timestamp: this.timestamp
     }
@@ -78,6 +82,59 @@ class AnearParticipant extends JsonApiResource {
   get privateChannelName() {
     return this.attributes['private-channel-name']
   }
+
+  ensureTimer(timeoutMsecs) {
+    // this is called when a new timer is being started for a privateMessage
+    // sent to a participant, or public message to all participants
+    // If the timer already exists and is paused, it is resumed with the timeRemaining
+    // [a starter function, timeRemaining] is returned
+    let timeRemaining = timeoutMsecs
+    let timerStarter = () => {}
+
+    if (timeoutMsecs > 0) {
+
+      this.timer ||= new ParticipantTimer(
+        this.id,
+        async () => await this.timerExpired(timeoutMsecs)
+      )
+
+      if (this.timer.isRunning) {
+        timeRemaining = this.timer.interrupt()
+      } else {
+        timerStarter = () => this.timer.start(timeoutMsecs)
+      }
+    }
+    logger.debug(`ensureTimer(timeRemaining: ${timeRemaining})`)
+
+    return [timerStarter, timeRemaining]
+  }
+
+  destroyTimer() {
+    // participant will not be receiving any more display messages
+    // so we close out and delete the timer
+    if (this.timer) {
+      this.timer.reset()
+      this.timer = null
+    }
+  }
+
+  async timerExpired(timeoutMsecs) {
+    logger.debug(`participant (${this.anearEvent.id}, ${this.id}) TIMED OUT after ${timeoutMsecs} msecs`)
+
+    this.timer = null
+
+    await this.anearEvent.participantTimedOut(this)
+    await this.anearEvent.update()
+  }
+
+  interruptTimer() {
+    if (this.timer && this.timer.isRunning) this.timer.interrupt()
+  }
+
+  resetTimer() {
+    // called after participant takes Action before timer expires
+    if (this.timer) this.timer.reset()
+  }
 }
 
 module.exports = AnearParticipant

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anear-js-api",
-  "version": "0.3.32",
+  "version": "0.3.34",
   "description": "Javascript Developer API for Anear Apps",
   "main": "lib/index.js",
   "scripts": {

package/tests/AnearParticipant.test.js

@@ -43,3 +43,40 @@ test('participant can be repeatedly rehydrated and updated', async () => {
     console.error(error)
   }
 })
+
+test('participant does not persist geoLocation', async () => {
+  try {
+    const someGeoLocation = {
+      coords: {
+        latitude: 25.7862067,
+        longitude: -80.1415718
+      }
+    }
+    const participant = new TestParticipant(player1, MockEvent)
+
+    participant.geoLocation = someGeoLocation
+
+    await participant.persist()
+
+    expect(participant.geoLocation.coords.latitude).toBe(someGeoLocation.coords.latitude)
+
+    let p = await TestParticipant.getFromStorage(player1.data.id, MockEvent)
+
+    expect(p.geoLocation).toBe(null)
+
+    expect(p.context.responses).toStrictEqual(['A', 'C', 'D', 'A'])
+    expect(p.anearEvent).toBe(MockEvent)
+    p.context.responses.push('B')
+
+    await p.update()
+
+    p = await TestParticipant.getFromStorage(player1.data.id, MockEvent)
+    expect(p.context.responses[4]).toBe('B')
+    expect(p.anearEvent).toBe(MockEvent)
+
+    await p.remove()
+
+  } catch(error) {
+    console.error(error)
+  }
+})