@openeventkit/event-site 2.1.18 → 2.1.21

package/src/workers/sync_strategies/activity_synch_strategy.js

@@ -4,7 +4,8 @@ import {insertSorted, intCheck, rebuildIndex} from "../../utils/arrayUtils";
 import {
     BUCKET_EVENTS_DATA_KEY,
     BUCKET_EVENTS_IDX_DATA_KEY,
-    BUCKET_SPEAKERS_DATA_KEY, BUCKET_SPEAKERS_IDX_DATA_KEY,
+    BUCKET_SPEAKERS_DATA_KEY,
+    BUCKET_SPEAKERS_IDX_DATA_KEY,
     BUCKET_SUMMIT_DATA_KEY,
     saveFile
 } from "../../utils/dataUpdatesUtils";
@@ -15,123 +16,167 @@ import moment from "moment-timezone";
  */
 class ActivitySynchStrategy extends AbstractSynchStrategy{
 
-    async process(payload){
+    _removeEventById(entity_id, eventsData){
+        // was deleted ( un - published)
+        // try to get from index
+        const idx = this.allIDXEvents[entity_id] ?? -1;
+        console.log(`ActivitySynchStrategy::_removeEventById unpublished presentation ${entity_id} idx ${idx}`);
 
-        console.log(`ActivitySynchStrategy::process`, payload);
+        // Remove from array and index
+        const pruned = eventsData.filter(e => e.id !== entity_id);
+        delete this.allIDXEvents[entity_id];
+        return pruned;
+    }
 
-        const {entity_operator, entity_id} = payload;
+    _touchSummitTimestamp() {
+        this.summit = {
+            ...this.summit,
+            timestamp: moment().unix(),
+        };
+    }
 
-        let entity = await fetchEventById(this.summit.id, entity_id, this.accessToken);
-        if(this.accessToken) {
-            const streaming_info = await fetchStreamingInfoByEventId(this.summit.id, entity_id, this.accessToken);
-            if(streaming_info) entity = {...entity, ...streaming_info};
+    /** Standard result payload + log */
+    _result(payload, entity, eventsData) {
+        const res = {
+            payload,
+            entity: entity,
+            summit: this.summit,
+            eventsData,
+            allIDXEvents: this.allIDXEvents,
+            allSpeakers: this.allSpeakers,
+            allIDXSpeakers: this.allIDXSpeakers,
+        };
+        console.log("ActivitySynchStrategy::process done", res);
+        return res;
+    }
+
+    async _persistAll(eventsData) {
+        this._touchSummitTimestamp();
+        const localNowUtc = Date.now();
+
+        await Promise.all([
+            saveFile(this.summit.id, BUCKET_SUMMIT_DATA_KEY, this.summit, localNowUtc),
+            saveFile(this.summit.id, BUCKET_EVENTS_DATA_KEY, eventsData, localNowUtc),
+            saveFile(this.summit.id, BUCKET_EVENTS_IDX_DATA_KEY, this.allIDXEvents, localNowUtc),
+            saveFile(this.summit.id, BUCKET_SPEAKERS_DATA_KEY, this.allSpeakers, localNowUtc),
+            saveFile(this.summit.id, BUCKET_SPEAKERS_IDX_DATA_KEY, this.allIDXSpeakers, localNowUtc),
+        ]);
+    }
+
+    async _handleDeleteOrUnpublish(entityId, payload, eventsData) {
+        console.log(
+            `ActivitySynchStrategy::_handleDeleteOrUnpublish delete/unpublish presentation ${entityId}`
+        );
+
+        // Remove and rebuild index
+        const newEventsData = this._removeEventById(entityId, eventsData);
+        this.allIDXEvents = rebuildIndex(newEventsData);
+
+        // Persist
+        try {
+            console.log("ActivitySynchStrategy::_handleDeleteOrUnpublish updating cache files (delete)");
+            await this._persistAll(newEventsData);
+        } catch (e) {
+            console.error(e);
         }
 
-        let eventsData = [...this.allEvents];
+        // No entity on delete/unpublish
+        return this._result(payload, null, newEventsData);
+    }
 
-        if (entity_operator === 'UPDATE') {
+    /** Insert/update a single person (speaker/moderator) into arrays + index */
+    _upsertSpeaker(person) {
+        if (!person) return;
+        const idx = this.allIDXSpeakers[person.id] ?? -1;
+        if (idx === -1 || !this.allSpeakers[idx]) {
+            this.allSpeakers.push(person);
+            this.allIDXSpeakers[person.id] = this.allSpeakers.length - 1;
+        } else {
+            this.allSpeakers[idx] = person;
+        }
+    }
 
-            if(!entity){
-                // was deleted ( un - published)
-                // try to get from index
-                const idx = this.allIDXEvents[entity_id] ?? -1;
-                console.log(`ActivitySynchStrategy::process unpublished presentation ${entity_id} idx ${idx}`);
+    /** Apply speakers & moderator coming from an entity */
+    _applyPeopleFromEntity(entity) {
+        if (Array.isArray(entity?.speakers)) {
+            for (const s of entity.speakers) this._upsertSpeaker(s);
+        }
+        if (entity?.moderator) this._upsertSpeaker(entity.moderator);
+    }
 
-                if(idx === -1)
-                    return Promise.reject('ActivitySynchStrategy::process unpublished idx === -1.'); // does not exists on index ...
-                // Remove from array and index
-                eventsData = eventsData.filter(e => e.id !== entity_id);
-                delete this.allIDXEvents[entity_id];
-            }
-            else {
-                // Entity is published or updated
-
-                // Remove any existing version of this event
-                eventsData = eventsData.filter(e => e.id !== entity.id);
-
-                // Re-insert the updated entity into sorted position
-
-                this.allIDXEvents[entity.id] = insertSorted(eventsData, entity, (a, b) => {
-                    if (a.start_date === b.start_date) {
-                        if (a.end_date === b.end_date) {
-                            return intCheck(a.id, b.id);
-                        }
-                        return intCheck(a.end_date, b.end_date);
-                    }
-                    return intCheck(a.start_date, b.start_date);
-                });
-
-                // Rebuild the full event index to be safe
-
-                this.allIDXEvents = rebuildIndex(eventsData);
-
-                // Update speakers
-                if (entity.speakers) {
-                    console.log(`ActivitySynchStrategy::process updating speakers`, entity.speakers);
-                    for (const speaker of entity.speakers) {
-                        const idx = this.allIDXSpeakers[speaker.id] ?? -1;
-                        if (idx === -1 || !this.allSpeakers[idx]) {
-                            console.log(`ActivitySynchStrategy::process speaker does not exists, inserting it at end`, speaker);
-                            this.allSpeakers.push(speaker);
-                            this.allIDXSpeakers[speaker.id] = this.allSpeakers.length - 1;
-                        } else {
-                            console.log(`ActivitySynchStrategy::process updating speaker at idx ${idx}`, speaker);
-                            this.allSpeakers[idx] = speaker;
-                        }
-                    }
-                }
+    async _handleUpsert(entity, payload, eventsData) {
+        console.log("ActivitySynchStrategy::process upsert", { id: entity?.id });
 
-                // Update moderator
-                if (entity.moderator) {
-                    console.log(`ActivitySynchStrategy::process updating moderator`, entity.moderator);
-                    const idx = this.allIDXSpeakers[entity.moderator.id] ?? -1;
-                    if (idx === -1 || !this.allSpeakers[idx]) {
-                        console.log(`ActivitySynchStrategy::process moderator does not exists, inserting it at end`, entity.moderator);
-                        this.allSpeakers.push(entity.moderator);
-                        this.allIDXSpeakers[entity.moderator.id] = this.allSpeakers.length - 1;
-                    } else {
-                        console.log(`ActivitySynchStrategy::process updating moderator at idx ${idx}`, entity.moderator);
-                        this.allSpeakers[idx] = entity.moderator;
-                    }
-                }
+        // Entity is published or updated
 
-            }
+        // Remove any existing version of this event
+        const without = eventsData.filter(e => e.id !== entity.id);
 
-            // update files on cache
-            console.log(`ActivitySynchStrategy::process updating cache files`);
-
-            // Update summit timestamp to trigger data reload downstream
-            this.summit = {
-                ...this.summit,
-                timestamp: moment().unix(),
-            };
-            // Persist everything
-            try {
-                const localNowUtc = Date.now();
-
-                await saveFile(this.summit.id, BUCKET_SUMMIT_DATA_KEY, this.summit, localNowUtc);
-                await saveFile(this.summit.id, BUCKET_EVENTS_DATA_KEY, eventsData, localNowUtc);
-                await saveFile(this.summit.id, BUCKET_EVENTS_IDX_DATA_KEY, this.allIDXEvents, localNowUtc);
-                await saveFile(this.summit.id, BUCKET_SPEAKERS_DATA_KEY, this.allSpeakers, localNowUtc);
-                await saveFile(this.summit.id, BUCKET_SPEAKERS_IDX_DATA_KEY, this.allIDXSpeakers, localNowUtc);
-            } catch (e) {
-                console.error(e);
+        // Re-insert the updated entity into sorted position
+
+        this.allIDXEvents[entity.id] = insertSorted(without, entity, (a, b) => {
+            if (a.start_date === b.start_date) {
+                if (a.end_date === b.end_date) {
+                    return intCheck(a.id, b.id);
+                }
+                return intCheck(a.end_date, b.end_date);
             }
+            return intCheck(a.start_date, b.start_date);
+        });
 
-            const res = {
-                payload,
-                entity,
-                summit: this.summit,
-                eventsData,
-                allIDXEvents: this.allIDXEvents,
-                allSpeakers: this.allSpeakers,
-                allIDXSpeakers: this.allIDXSpeakers,
-            };
+        // Rebuild full index for safety/consistency
+        this.allIDXEvents = rebuildIndex(without);
 
-            console.log(`ActivitySynchStrategy::process done`, res);
 
-            return Promise.resolve(res);
+        // Update speakers & moderator
+        this._applyPeopleFromEntity(entity);
+
+        // Persist
+        try {
+            console.log("ActivitySynchStrategy::process updating cache files (upsert)");
+            await this._persistAll(without);
+        } catch (e) {
+            console.error(e);
+        }
+
+
+        return this._result(payload, entity, without);
+    }
+
+    async process(payload){
+
+        console.log(`ActivitySynchStrategy::process`, payload);
+
+        const {entity_operator, entity_id} = payload;
+
+        let eventsData = [...this.allEvents];
+
+        switch (entity_operator) {
+            case 'INSERT':
+            case 'UPDATE':{
+                let entity = await fetchEventById(this.summit.id, entity_id, this.accessToken);
+                if(this.accessToken) {
+                    const streaming_info = await fetchStreamingInfoByEventId(this.summit.id, entity_id, this.accessToken);
+                    if(streaming_info) entity = {...entity, ...streaming_info};
+                }
+
+                if(!entity){
+                    // was deleted ( un - published)
+                    return this._handleDeleteOrUnpublish(entity_id, payload, eventsData);
+                }
+                // Normal upsert flow
+                return this._handleUpsert(entity, payload, eventsData);
+            }
+            case 'DELETE':{
+                // was hard deleted
+                return this._handleDeleteOrUnpublish(entity_id, payload, eventsData);
+            }
         }
+
+        // Unknown op
+        const msg = `ActivitySynchStrategy::process unknown entity_operator '${entity_operator}'`;
+        console.warn(msg);
+        throw new Error(msg);
     }
 }
 

package/src/workers/sync_strategies/speaker_synch_strategy.js

@@ -36,7 +36,7 @@ class SpeakerSynchStrategy extends AbstractSynchStrategy {
         this.allIDXSpeakers = rebuildIndex(this.allSpeakers);
 
         // Update events where speaker is listed
-        for (const eventId of entity.all_presentations || []) {
+        for (const eventId of entity.presentations || []) {
             const res = getIndexedItem(this.allIDXEvents, eventsData, eventId);
             if (!res || !Array.isArray(res.item.speakers)) {
                 console.log(`SpeakerSynchStrategy::process: event ${eventId} not found or invalid`);
@@ -54,7 +54,7 @@ class SpeakerSynchStrategy extends AbstractSynchStrategy {
         }
 
         // Update events where speaker is moderator
-        for (const eventId of entity.all_moderated_presentations || []) {
+        for (const eventId of entity.moderated_presentations || []) {
             const res = getIndexedItem(this.allIDXEvents, eventsData, eventId);
             if (!res) {
                 console.log(`SpeakerSynchStrategy::process: moderator event ${eventId} not found`);
@@ -111,4 +111,4 @@ class SpeakerSynchStrategy extends AbstractSynchStrategy {
 
 }
 
-export default SpeakerSynchStrategy;
+export default SpeakerSynchStrategy;

package/src/workers/sync_strategies/track_synch_strategy.js

@@ -1,76 +1,177 @@
 import AbstractSynchStrategy from "./abstract_synch_strategy";
 import {fetchTrackById} from "../../actions/fetch-entities-actions";
 import {
-  BUCKET_EVENTS_DATA_KEY,
-  BUCKET_SUMMIT_DATA_KEY,
-  saveFile
+    BUCKET_EVENTS_DATA_KEY,
+    BUCKET_EVENTS_IDX_DATA_KEY,
+    BUCKET_SUMMIT_DATA_KEY,
+    saveFile
 } from "../../utils/dataUpdatesUtils";
 import moment from "moment-timezone";
+import {rebuildIndex} from "../../utils/arrayUtils";
+
 /**
  * TrackSynchStrategy
  */
-class TrackSynchStrategy extends AbstractSynchStrategy{
+class TrackSynchStrategy extends AbstractSynchStrategy {
+
+
+    _normalizeTracks(tracks) {
+        const base = Array.isArray(tracks) ? tracks : [];
+        return base.map(t => ({
+            ...t,
+            subtracks: Array.isArray(t?.subtracks) ? t.subtracks : []
+        }));
+    }
+
+    _touchSummitTimestamp() {
+        this.summit = {
+            ...this.summit,
+            timestamp: moment().unix(),
+        };
+    }
+
+    _stripEntityEverywhere(tracks, entityId) {
+        return this._normalizeTracks(tracks)
+            .filter(t => t.id !== entityId) // remove it from top level ...
+            // then remove it from subtracks
+            .map(t => ({ ...t, subtracks: t.subtracks.filter(st => st?.id !== entityId) }));
+    }
 
-  async process(payload){
+    async _persistAll() {
+        this._touchSummitTimestamp();
+        const localNowUtc = Date.now();
+
+        await Promise.all([
+            saveFile(this.summit.id, BUCKET_EVENTS_DATA_KEY, this.allEvents, localNowUtc),
+            saveFile(this.summit.id, BUCKET_SUMMIT_DATA_KEY, this.summit, localNowUtc),
+            saveFile(this.summit.id, BUCKET_EVENTS_IDX_DATA_KEY, this.allIDXEvents, localNowUtc),
+        ]);
+    }
 
-    console.log(`TrackSynchStrategy::process`, payload);
+    _result(payload, entity) {
+        return {
+            payload,
+            entity: entity,
+            summit: this.summit,
+            eventsData: this.allEvents,
+            allIDXEvents: this.allIDXEvents,
+            allSpeakers: this.allSpeakers,
+            allIDXSpeakers: this.allIDXSpeakers
+        };
+    }
 
-    const {entity_operator, entity_id} = payload;
+    _upsertIntoParentSubtracks(tracks, parentId, entity) {
+        if (parentId === entity.id) {
+            console.warn(`TrackSynchStrategy::_upsertIntoParentSubtracks ignored self-parent for ${entity.id}`);
+            return tracks;
+        }
+
+        let found = false;
+        const normalizedEntity = { ...entity, subtracks: Array.isArray(entity.subtracks) ? entity.subtracks : [] };
+        const next = tracks.map(t => {
+            if (t.id !== parentId) return t;
+            // found the parent
+            found = true;
+            // get current idx if exists as subtrack ...
+            const idx = t.subtracks.findIndex(st => st?.id === entity.id);
+            const subtracks = idx === -1
+                ? [...t.subtracks, { ...normalizedEntity }] // not found it as subtrack .. then add it
+                : t.subtracks.map(st => (st?.id === entity.id ? { ...st, ...normalizedEntity } : st));// else update it
+            return { ...t, subtracks };
+        });
+        if (!found) {
+            console.warn(`TrackSynchStrategy::_upsertIntoParentSubtracks parent ${parentId} not found for track ${entity.id}`);
+        }
+        return next;
+    }
 
-    const entity = await fetchTrackById(this.summit.id, entity_id, this.accessToken);
+    async _handleUpsert(entity, payload) {
+        // remove it from top level and subtracks
+        let tracks = this._stripEntityEverywhere(this.summit?.tracks, entity.id);
+        // top level re insert
+        const normalizedEntity = { ...entity, subtracks: Array.isArray(entity.subtracks) ? entity.subtracks : [] };
+        tracks.push(normalizedEntity)
 
-    if (entity_operator === 'UPDATE') {
-      if (!entity) return Promise.reject('TrackSynchStrategy::process entity not found.');
+        if (entity.parent_id > 0) {
+            // re insert or update it
+            tracks = this._upsertIntoParentSubtracks(tracks, entity.parent_id, entity);
+        }
 
-      // update summit
+        // update summit racks
 
-      this.summit = {
-        ...this.summit,
-        timestamp : moment().unix(),
-        tracks : this.summit.tracks.map(t => {
-          if(t?.id === entity_id) return {...t, ...entity};
+        this.summit = { ...this.summit, tracks };
 
-          return {...t, subtracks: t.subtracks.map(st => {
-              if(st?.id === entity_id) return {...st, ...entity};
-              return st;
-            })};
+        // update events
+        this.allEvents = this.allEvents.map(ev => {
+            if (ev?.track?.id === entity.id) return ({...ev, track: entity});
+            return ev;
         })
-      };
-      // update events
-      this.allEvents = this.allEvents.map(ev => {
-        if (ev?.track?.id === entity_id) return ({...ev, track: entity});
-        return ev;
-      })
 
-      // update files on cache
-      console.log(`TrackSynchStrategy::process updating cache files`);
+        // Rebuild index to keep positions in sync
+        this.allIDXEvents = rebuildIndex(this.allEvents);
+        // Persist
+        try {
+            console.log("TrackSynchStrategy::process updating cache files (upsert)");
+            await this._persistAll();
+        } catch (e) {
+            console.error(e);
+        }
+
+        return this._result(payload, entity);
+    }
 
-      try {
-        const localNowUtc = Date.now();
+    async _handleDelete(entityId, payload) {
+        console.log(
+            `TrackSynchStrategy::_handleDelete delete track ${entityId}`
+        );
+        // remove track from top level / childs
+        let tracks = this._stripEntityEverywhere(this.summit?.tracks, entityId);
+        // clean orphan childs ...
+        tracks = tracks.map(t => (t?.parent_id === entityId ? { ...t, parent_id: 0 } : t));
+
+        this.summit = {
+            ...this.summit,
+            tracks: [...tracks],
+        };
+
+        // update events remove events with that track
+        this.allEvents = this.allEvents.filter(ev => ev.track?.id !== entityId);
+        // Rebuild index to keep positions in sync
+        this.allIDXEvents = rebuildIndex(this.allEvents);
+        // Persist
+        try {
+            console.log("TrackSynchStrategy::_handleDelete updating cache files (delete)");
+            await this._persistAll();
+        } catch (e) {
+            console.error(e);
+        }
+
+        // No entity on delete/unpublish
+        return this._result(payload, null);
+    }
 
-        await saveFile(this.summit.id, BUCKET_EVENTS_DATA_KEY, this.allEvents, localNowUtc);
-        await saveFile(this.summit.id, BUCKET_SUMMIT_DATA_KEY, this.summit, localNowUtc);
+    async process(payload) {
 
-      }
-      catch (e){
-        console.log(e);
-      }
+        console.log(`TrackSynchStrategy::process`, payload);
 
-      let res = {
-        payload,
-        entity,
-        summit : this.summit,
-        eventsData: this.allEvents,
-        allIDXEvents : this.allIDXEvents,
-        allSpeakers : this.allSpeakers,
-        allIDXSpeakers : this.allIDXSpeakers
-      };
+        const {entity_operator, entity_id} = payload;
 
-      console.log(`TrackSynchStrategy::process done`, res);
+        switch (entity_operator) {
+            case 'INSERT':
+            case 'UPDATE':{
+                const entity = await fetchTrackById(this.summit.id, entity_id, this.accessToken);
+                if (!entity) return Promise.reject('TrackSynchStrategy::process entity not found.');
+                return this._handleUpsert(entity, payload);
+            }
+            case 'DELETE':{
+                return this._handleDelete(entity_id, payload);
+            }
+        }
 
-      return Promise.resolve(res);
+        const msg = `TrackSynchStrategy::process unknown entity_operator '${entity_operator}'`;
+        console.warn(msg);
+        throw new Error(msg);
     }
-  }
 }
 
 export default TrackSynchStrategy;