From 76808d66ab33b180954b745e780f42e97e91c142 Mon Sep 17 00:00:00 2001
From: Ayoub Zayati <azayati@exoplatform.com>
Date: Fri, 11 Sep 2026 09:26:45 +0200
Subject: [PATCH] fix: Visio list marks only the occurrence holding the running
 call - EXO-90147 (#408)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Prior this change, every occurrence of a recurring series resolved to the same call id — the occurrences all share one conference URL, which is what matchStartedCallId() matches on — so a single running call marked the whole series LIVE: next week's occurrence was announced as happening now, with a "Started less than a minute ago" footer above next week's slot.

After this commit, the running call is attributed to a single occurrence — the one nearest in time among those that may hold it, bounded by the join-ahead window the Join button already uses (JOIN_AHEAD_MS, moved to VisioMerge.js so the live window and the join window are the same one). Only that occurrence is marked LIVE. The other occurrences of the series stay listed as upcoming, per the task: only the LIVE state is withdrawn from them. The series still counts as scheduled, so the call is not listed a second time as an ad-hoc one.

Three cases the attribution handles deliberately: the occurrence in progress, the one that just ended when a meeting overruns, and the next one when people join early. A running call that no occurrence can hold is not shown — a false "happening now" is the defect being fixed.

Testing
This webapp has no JS test runner and none is added by this PR: the drawer's merge layer is not covered in CI. The change was verified instead by a Node harness over the real VisioMerge.js module — 11 scenarios (the reported case, overrun, early join, the ±15 min boundary, a stale call, two concurrent series, the no-duplicate-ad-hoc case, and the controls), green at head, each pin mutation-verified against the previous commit. It was also reproduced and checked manually in the drawer. eslint with the repo config is clean on both files; the two vue/multiline-html-element-content-newline warnings at VisioCard.vue:81 pre-exist on the base branch.

(cherry picked from commit bc334f4dc7f924afbd972b77bee21533e058ae99)
---
 .../VisioDrawer/components/VisioCard.vue      |   9 +-
 .../vue-apps/VisioDrawer/js/VisioMerge.js     | 120 +++++++++++++++++-
 2 files changed, 118 insertions(+), 11 deletions(-)

diff --git a/webapp/src/main/webapp/vue-apps/VisioDrawer/components/VisioCard.vue b/webapp/src/main/webapp/vue-apps/VisioDrawer/components/VisioCard.vue
index 8bc4cea8e..0fb3c841b 100644
--- a/webapp/src/main/webapp/vue-apps/VisioDrawer/components/VisioCard.vue
+++ b/webapp/src/main/webapp/vue-apps/VisioDrawer/components/VisioCard.vue
@@ -244,17 +244,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 </template>
 
 <script>
-import {LIVE, NOW, READY, UPCOMING} from '../js/VisioMerge.js';
+import {JOIN_AHEAD_MS, LIVE, NOW, READY, UPCOMING} from '../js/VisioMerge.js';
 import {formatTime, formatDay, isSameDay, splitDuration} from '../js/VisioFormat.js';
 import {copyText} from '../js/VisioClipboard.js';
 
-/**
- * How close an upcoming meeting must be before joining it is offered. Arriving
- * a quarter of an hour early is intent; a button on next week's meeting is a
- * mis-click waiting to announce a meeting that is not happening.
- */
-const JOIN_AHEAD_MS = 15 * 60 * 1000;
-
 export default {
   props: {
     entry: {
diff --git a/webapp/src/main/webapp/vue-apps/VisioDrawer/js/VisioMerge.js b/webapp/src/main/webapp/vue-apps/VisioDrawer/js/VisioMerge.js
index facb87318..5e5b75393 100644
--- a/webapp/src/main/webapp/vue-apps/VisioDrawer/js/VisioMerge.js
+++ b/webapp/src/main/webapp/vue-apps/VisioDrawer/js/VisioMerge.js
@@ -47,6 +47,17 @@ export const READY = 'ready';
 /** The call state web conferencing persists for a running call. */
 const STATE_STARTED = 'started';
 
+/**
+ * How close an upcoming meeting must be before joining it is offered. Arriving
+ * a quarter of an hour early is intent; a button on next week's meeting is a
+ * mis-click waiting to announce a meeting that is not happening.
+ * <p>
+ * The same window decides which occurrence of a series a running call is held
+ * in, so the two answers cannot disagree: what the drawer calls live is what it
+ * lets you join.
+ */
+export const JOIN_AHEAD_MS = 15 * 60 * 1000;
+
 /**
  * Turns the raw REST payload of one agenda event into the flat shape the
  * drawer works with, or null when the event carries no visio at all.
@@ -149,6 +160,105 @@ export function matchStartedCallId(url, ids) {
   return ids.find(id => id && path.endsWith(`/${id}`)) || null;
 }
 
+/**
+ * The occurrence each started call is being held in, keyed by call id.
+ * <p>
+ * A recurrent series shares ONE conference URL across every occurrence, so the
+ * call id resolved from that URL is the same for all of them and a running call
+ * would otherwise light up the whole series as LIVE — next month's occurrence
+ * announced as happening now. The call is held in exactly one of them: the
+ * nearest in time among those that may hold it at all, which is the occurrence
+ * in progress when there is one, the one that just ended when the meeting
+ * overruns, and the next one when people join early — within JOIN_AHEAD_MS,
+ * never a later date of the series (see canHoldCall below).
+ *
+ * @param {Array} events - the normalized scheduled entries
+ * @param {Array} startedIds - the ids of the started calls
+ * @param {number} nowTime - the reference instant, in milliseconds
+ * @returns {object} call id -> the key of the entry holding it; a started call
+ *          that no occurrence can hold is absent, and shows nowhere
+ */
+export function liveCallOwners(events, startedIds, nowTime) {
+  // Plain maps: a call id is server data, and `in` on an object literal answers
+  // true for every name Object.prototype happens to carry.
+  const owners = Object.create(null);
+  const distances = Object.create(null);
+  (events || []).forEach(event => {
+    const callId = callIdOf(event, startedIds);
+    if (!isStarted(callId, startedIds) || !canHoldCall(event, nowTime)) {
+      return;
+    }
+    const distance = distanceToNow(event, nowTime);
+    if (!(callId in owners) || distance < distances[callId]) {
+      owners[callId] = event.key;
+      distances[callId] = distance;
+    }
+  });
+  return owners;
+}
+
+/**
+ * The call id one scheduled entry resolves to, running or not.
+ * <p>
+ * Written once and read by both passes below: an ownership map keyed on a
+ * differently resolved id would stop matching the entries it is compared
+ * against, and a whole series would quietly lose its live state with nothing
+ * to show for it.
+ *
+ * @param {object} event - a normalized event entry
+ * @param {Array} startedIds - the ids of the started calls
+ * @returns {string} the call id, or null
+ */
+function callIdOf(event, startedIds) {
+  return event.callId || matchStartedCallId(event.url, startedIds);
+}
+
+/**
+ * Whether that call is one of the running ones.
+ *
+ * @param {string} callId - the resolved call id, may be null
+ * @param {Array} startedIds - the ids of the started calls
+ * @returns {boolean} true when the call is started
+ */
+function isStarted(callId, startedIds) {
+  return !!callId && (startedIds || []).indexOf(callId) >= 0;
+}
+
+/**
+ * Whether an occurrence can be the one a running call is being held in: it has
+ * begun, or is close enough that people are joining early. A later date the
+ * same series happens to have is not a candidate, however lonely the call is —
+ * claiming it would announce next week's meeting as happening now, which is the
+ * whole point of the attribution.
+ * <p>
+ * The past side needs no bound of its own: the drawer reads only PAST_WINDOW_MS
+ * back, so an occurrence old enough to be a stale claim is never fetched.
+ *
+ * @param {object} event - a normalized event entry
+ * @param {number} nowTime - the reference instant, in milliseconds
+ * @returns {boolean} true when the occurrence may hold the call
+ */
+function canHoldCall(event, nowTime) {
+  return event.start.getTime() - nowTime <= JOIN_AHEAD_MS;
+}
+
+/**
+ * How far one occurrence is from now: nothing while it is being held, the wait
+ * before it starts, or the time since it ended.
+ *
+ * @param {object} event - a normalized event entry
+ * @param {number} nowTime - the reference instant, in milliseconds
+ * @returns {number} the distance in milliseconds
+ */
+function distanceToNow(event, nowTime) {
+  const start = event.start.getTime();
+  const end = event.end.getTime();
+  if (start <= nowTime && end > nowTime) {
+    return 0;
+  }
+  return start > nowTime ? start - nowTime : nowTime - end;
+}
+
 /**
  * The tri-state model, built from what each side actually knows.
  * <p>
@@ -168,12 +278,16 @@ export function buildEntries({events, startedIds, adhocCalls, instant, now}) {
   // out of the ad-hoc pass below rather than shown twice.
   const entries = (instant || []).slice();
   const matched = entries.map(entry => entry.callId);
+  const owners = liveCallOwners(events, startedIds, nowTime);
   (events || []).forEach(event => {
-    const callId = event.callId || matchStartedCallId(event.url, startedIds);
-    const live = !!callId && startedIds.indexOf(callId) >= 0;
-    if (live) {
+    const callId = callIdOf(event, startedIds);
+    const started = isStarted(callId, startedIds);
+    if (started) {
+      // Claimed by the series as a whole: whichever occurrence holds the call,
+      // it is a scheduled one and must not be listed again as an ad-hoc call.
       matched.push(callId);
     }
+    const live = started && owners[callId] === event.key;
     const state = eventState(event, live, nowTime);
     if (state) {
       entries.push(Object.assign({}, event, {