From 6ef33c241f5676eab2df8585e08cde723e93234b Mon Sep 17 00:00:00 2001 From: Tim Dykes Date: Mon, 16 Mar 2026 21:45:10 +1100 Subject: [PATCH 1/9] fixed wonky alerts re-open (#340) alerts would re expand when their under obs changed --- src/pages/tasking/components/alerts.js | 45 ++++++++++++++++++++++---- 1 file changed, 38 insertions(+), 7 deletions(-) diff --git a/src/pages/tasking/components/alerts.js b/src/pages/tasking/components/alerts.js index 62eed616..b7f3bac2 100644 --- a/src/pages/tasking/components/alerts.js +++ b/src/pages/tasking/components/alerts.js @@ -40,18 +40,23 @@ function createLeafletControl(L) { function renderRules(container, rules, opts = {}) { const allowCollapse = opts.allowCollapse !== false; container.style.display = rules.length ? '' : 'none'; - container.innerHTML = ''; + + // Build a set of active rule IDs so we can remove stale DOM elements + const activeIds = new Set(rules.map(r => r.id)); + + // Remove DOM elements for rules that are no longer active + container.querySelectorAll('[data-rule-id]').forEach(el => { + if (!activeIds.has(el.getAttribute('data-rule-id'))) { + el.remove(); + } + }); for (const rule of rules) { - // --- restore / update state for this rule --- + // --- restore / initialise state for this rule --- let state = ruleState.get(rule.id); if (!state) { state = { collapsed: false, open: false, lastCount: rule.count }; } else { - // if the count changed while collapsed, auto-expand - if (state.collapsed && rule.count !== state.lastCount) { - state.collapsed = false; - } state.lastCount = rule.count; } if (!allowCollapse) { @@ -60,7 +65,33 @@ function renderRules(container, rules, opts = {}) { } ruleState.set(rule.id, state); - const div = document.createElement('div'); + // --- check if a DOM element already exists for this rule --- + let div = container.querySelector(`[data-rule-id="${rule.id}"]`); + + if (div) { + // --- IN-PLACE UPDATE: only patch count + items, preserve all user state --- + const countEl = div.querySelector('.alerts__count'); + if (countEl) countEl.textContent = rule.count; + + const ul = div.querySelector('.alerts__list'); + if (ul) { + ul.innerHTML = rule.items.map(it => `
  • ${it.label}
    • `).join(''); + // Re-attach item click handlers + if (typeof rule.onClick === 'function') { + ul.querySelectorAll('li[data-id]').forEach(li => { + li.style.cursor = 'pointer'; + li.addEventListener('mouseenter', () => li.style.textDecoration = 'underline'); + li.addEventListener('mouseleave', () => li.style.textDecoration = ''); + li.addEventListener('click', () => rule.onClick(li.getAttribute('data-id'))); + }); + } + } + continue; // skip full creation — DOM element (incl classes) stays as-is + } + + // --- FIRST-TIME CREATION for this rule --- + div = document.createElement('div'); + div.setAttribute('data-rule-id', rule.id); var width = '280px' div.className = `leaflet-control alerts alerts--${rule.level}`; if (state.collapsed) { From 7c95d7b735a1b7533a7ad8c2959a5e4628831d8d Mon Sep 17 00:00:00 2001 From: Tim Dykes Date: Mon, 16 Mar 2026 21:47:46 +1100 Subject: [PATCH 2/9] Lad robo task (#341) * first try at weights tasking suggest teams on some weights * first try at UI fixes --- src/pages/tasking/bindings/fastTooltip.js | 79 ++++++++ src/pages/tasking/components/job_popup.js | 9 +- src/pages/tasking/main.js | 2 + src/pages/tasking/models/Job.js | 3 +- .../tasking/utils/TeamSuggestionEngine.js | 174 ++++++++++++++++++ src/pages/tasking/viewmodels/Config.js | 62 +++++++ src/pages/tasking/viewmodels/InstantTask.js | 48 ++++- static/pages/tasking.html | 152 ++++++++++++++- styles/pages/tasking.css | 44 +++++ 9 files changed, 565 insertions(+), 8 deletions(-) create mode 100644 src/pages/tasking/bindings/fastTooltip.js create mode 100644 src/pages/tasking/utils/TeamSuggestionEngine.js diff --git a/src/pages/tasking/bindings/fastTooltip.js b/src/pages/tasking/bindings/fastTooltip.js new file mode 100644 index 00000000..5acbbfed --- /dev/null +++ b/src/pages/tasking/bindings/fastTooltip.js @@ -0,0 +1,79 @@ +/** + * Knockout binding: fastTooltip + * + * Usage: data-bind="fastTooltip: someTextValue" + * + * Shows a fixed-position tooltip instantly on hover (0.1s fade). + * Works inside overflow:hidden / scroll containers. + */ +import ko from 'knockout'; + + +let bubble = null; + +function getBubble() { + if (!bubble) { + bubble = document.createElement('div'); + bubble.className = 'fast-tooltip-bubble'; + document.body.appendChild(bubble); + } + return bubble; +} + +function showTip(el, text) { + if (!text) return; + const b = getBubble(); + b.textContent = text; + b.classList.remove('show'); + + const rect = el.getBoundingClientRect(); + // Position off-screen to measure without flicker + b.style.left = '-9999px'; + b.style.top = '-9999px'; + b.style.display = 'block'; + + // measure + void b.offsetWidth; + const bRect = b.getBoundingClientRect(); + + let top = rect.top - bRect.height - 6; + let left = rect.right - bRect.width; + + if (top < 4) top = rect.bottom + 6; + if (left < 4) left = 4; + if (left + bRect.width > window.innerWidth - 4) { + left = window.innerWidth - bRect.width - 4; + } + + b.style.top = top + 'px'; + b.style.left = left + 'px'; + // Force reflow then fade in via class (no inline opacity override) + void b.offsetWidth; + b.classList.add('show'); +} + +function hideTip() { + if (bubble) { + bubble.classList.remove('show'); + bubble.style.display = 'none'; + } +} + +ko.bindingHandlers.fastTooltip = { + init: function (element, valueAccessor) { + element.addEventListener('mouseenter', function () { + const text = ko.unwrap(valueAccessor()); + showTip(element, text); + }); + element.addEventListener('mouseleave', function () { + hideTip(); + }); + + ko.utils.domNodeDisposal.addDisposeCallback(element, function () { + hideTip(); + }); + }, + update: function () { + // text is read live on mouseenter, nothing to do here + } +}; diff --git a/src/pages/tasking/components/job_popup.js b/src/pages/tasking/components/job_popup.js index 71c30060..f91f4f16 100644 --- a/src/pages/tasking/components/job_popup.js +++ b/src/pages/tasking/components/job_popup.js @@ -82,9 +82,14 @@ export function buildJobPopupKO() { class="dropdown-item text-start py-1" data-bind="click: taskTeamToJobWithConfirm, event: { mouseenter: mouseInTeamInInstantTaskPopup, mouseleave: mouseOutTeamInInstantTaskPopup }"> -
    - + + + + + +
    diff --git a/src/pages/tasking/main.js b/src/pages/tasking/main.js index 0d579408..3844e678 100644 --- a/src/pages/tasking/main.js +++ b/src/pages/tasking/main.js @@ -48,6 +48,7 @@ import { installRowVisibilityBindings } from "./bindings/rowVisibility.js"; import { installDragDropRowBindings } from "./bindings/dragDropRows.js"; import { installSortableArrayBindings } from "./bindings/sortableArray.js"; import { noBubbleFromDisabledButtonsBindings } from "./bindings/noBubble.js" +import "./bindings/fastTooltip.js"; // registers ko.bindingHandlers.fastTooltip import { registerTransportCamerasLayer } from "./mapLayers/transport.js"; import { registerUnitBoundaryLayer } from "./mapLayers/geoservices.js"; @@ -965,6 +966,7 @@ function VM() { }, map: self.mapVM, filteredTeams: self.filteredTeams, + config: self.config, isIncidentPinned: (id) => self.isIncidentPinned(id), toggleIncidentPinned: (id) => self.toggleIncidentPinned(id), } diff --git a/src/pages/tasking/models/Job.js b/src/pages/tasking/models/Job.js index 456e659e..db4d3aea 100644 --- a/src/pages/tasking/models/Job.js +++ b/src/pages/tasking/models/Job.js @@ -34,6 +34,7 @@ export function Job(data = {}, deps = {}) { openJobStatusConfirmModal = (_job, _newStatus) => { /* noop */ }, map = null, filteredTeams = ko.observableArray([]), + config = null, isIncidentPinned = () => false, toggleIncidentPinned = () => false, } = deps; @@ -104,7 +105,7 @@ export function Job(data = {}, deps = {}) { return Array.isArray(self.unacceptedNotifications()) && self.unacceptedNotifications().length > 0; }); - self.instantTask = new InstantTaskViewModel({ job: self, map: map, filteredTeams: filteredTeams }); + self.instantTask = new InstantTaskViewModel({ job: self, map: map, filteredTeams: filteredTeams, config: config }); //refs to other obs diff --git a/src/pages/tasking/utils/TeamSuggestionEngine.js b/src/pages/tasking/utils/TeamSuggestionEngine.js new file mode 100644 index 00000000..64764974 --- /dev/null +++ b/src/pages/tasking/utils/TeamSuggestionEngine.js @@ -0,0 +1,174 @@ +/** + * TeamSuggestionEngine + * + * Rule-based scoring system for suggesting which team to task to a job. + * + * Rules: + * RESCUE priority jobs → + * Prefer the nearest team with ZERO active taskings. + * If every team has at least one tasking, fall back to the nearest team. + * + * ALL OTHER priorities → + * Score = (normalisedDistance × distanceWeight) + (normalisedTaskings × taskingWeight) + * Suggest the team with the lowest combined score. + * + * The user can tweak the distance vs tasking weights per priority class + * via the config modal. + */ + +/** + * @typedef {Object} SuggestionWeights + * @property {number} rescueDistanceWeight 0–100 slider value + * @property {number} rescueTaskingWeight 0–100 slider value + * @property {number} normalDistanceWeight 0–100 slider value (non-rescue) + * @property {number} normalTaskingWeight 0–100 slider value (non-rescue) + * @property {boolean} enabled master on/off toggle + */ + +const DEFAULT_WEIGHTS = { + enabled: true, + rescueDistanceWeight: 90, + rescueTaskingWeight: 10, + normalDistanceWeight: 50, + normalTaskingWeight: 50, +}; + +/** + * Given a list of enriched team objects (with `distanceMeters` and + * `taskingCount`) and the job's priority ID, returns an array of + * { index, reason } objects for the top-N suggested teams (best first), + * or [] if disabled/impossible. + * + * @param {{ distanceMeters: number|null, taskingCount: number }[]} teams + * @param {number|null} priorityId Enum.JobPriorityType id (1 = Rescue) + * @param {SuggestionWeights} weights + * @param {number} [count=2] how many suggestions to return + * @returns {{ index: number, reason: string }[]} best first + */ +export function suggestTeamIndices(teams, priorityId, weights, count = 2) { + const w = { ...DEFAULT_WEIGHTS, ...weights }; + + if (!w.enabled || !teams || teams.length === 0) return []; + + const isRescue = priorityId === 1; // Enum.JobPriorityType.Rescue.Id + + if (isRescue) { + return rescueStrategyN(teams, w, count); + } + return generalStrategyN(teams, w, count); +} + + +/* ------------------------------------------------------------------ */ +/* Rescue strategy (top N) */ +/* ------------------------------------------------------------------ */ +function rescueStrategyN(teams, w, count) { + const withDist = teams + .map((t, i) => ({ ...t, _idx: i })) + .filter(t => t.distanceMeters != null && Number.isFinite(t.distanceMeters)); + + if (withDist.length === 0) return []; + + // Prefer teams with zero taskings + const idle = withDist.filter(t => t.taskingCount === 0); + + if (idle.length > 0) { + idle.sort((a, b) => a.distanceMeters - b.distanceMeters); + return idle.slice(0, count).map((t, rank) => { + const distKm = (t.distanceMeters / 1000).toFixed(1); + const prefix = rank === 0 ? 'Nearest' : `#${rank + 1} nearest`; + return { + index: t._idx, + reason: `${prefix} idle team — ${distKm} km, 0 taskings (rescue)`, + }; + }); + } + + // If user has set non-trivial weights, use weighted scoring even for rescue + const dw = Math.max(0, w.rescueDistanceWeight); + const tw = Math.max(0, w.rescueTaskingWeight); + + if (tw > 0) { + return scoredIndices(withDist, dw, tw, count, 'rescue, all teams busy'); + } + + // Pure distance fallback + withDist.sort((a, b) => a.distanceMeters - b.distanceMeters); + return withDist.slice(0, count).map((t, rank) => { + const distKm = (t.distanceMeters / 1000).toFixed(1); + const prefix = rank === 0 ? 'Nearest' : `#${rank + 1} nearest`; + return { + index: t._idx, + reason: `${prefix} team — ${distKm} km, ${t.taskingCount} tasking(s) (rescue, all busy)`, + }; + }); +} + + +/* ------------------------------------------------------------------ */ +/* General (non-rescue) strategy (top N) */ +/* ------------------------------------------------------------------ */ +function generalStrategyN(teams, w, count) { + const withDist = teams + .map((t, i) => ({ ...t, _idx: i })) + .filter(t => t.distanceMeters != null && Number.isFinite(t.distanceMeters)); + + if (withDist.length === 0) return []; + + const dw = Math.max(0, w.normalDistanceWeight); + const tw = Math.max(0, w.normalTaskingWeight); + + if (dw === 0 && tw === 0) return []; // both zeroed → no suggestion + + return scoredIndices(withDist, dw, tw, count, 'standard'); +} + + +/* ------------------------------------------------------------------ */ +/* Shared min-max normalised scoring */ +/* ------------------------------------------------------------------ */ +function scoredIndices(items, distWeight, taskWeight, count, tag) { + if (items.length === 0) return []; + + const totalWeight = distWeight + taskWeight; + if (totalWeight === 0) return []; + + const dw = distWeight / totalWeight; // normalise to 0-1 + const tw = taskWeight / totalWeight; + const dwPct = Math.round(dw * 100); + const twPct = Math.round(tw * 100); + + // min/max for normalisation + const distances = items.map(t => t.distanceMeters); + const taskings = items.map(t => t.taskingCount); + + const dMin = Math.min(...distances); + const dMax = Math.max(...distances); + const tMin = Math.min(...taskings); + const tMax = Math.max(...taskings); + + const dRange = dMax - dMin || 1; // avoid /0 + const tRange = tMax - tMin || 1; + + const scored = items.map(t => { + const normDist = (t.distanceMeters - dMin) / dRange; // 0 = closest + const normTask = (t.taskingCount - tMin) / tRange; // 0 = fewest + const score = normDist * dw + normTask * tw; + return { _idx: t._idx, score, normDist, normTask, raw: t }; + }); + + scored.sort((a, b) => a.score - b.score); + + return scored.slice(0, count).map((s, rank) => { + const parts = []; + if (dwPct > 0) parts.push(`dist ${dwPct}%`); + if (twPct > 0) parts.push(`task ${twPct}%`); + const weightDesc = parts.join(' / '); + const prefix = rank === 0 ? 'Best' : `#${rank + 1}`; + const distKm = (s.raw.distanceMeters / 1000).toFixed(1); + return { + index: s._idx, + reason: `${prefix} score ${s.score.toFixed(2)} (${weightDesc}) — ${distKm} km, ${s.raw.taskingCount} tasking(s) [${tag}]`, + }; + }); +} diff --git a/src/pages/tasking/viewmodels/Config.js b/src/pages/tasking/viewmodels/Config.js index ac7ea483..064ef544 100644 --- a/src/pages/tasking/viewmodels/Config.js +++ b/src/pages/tasking/viewmodels/Config.js @@ -96,6 +96,39 @@ export function ConfigVM(root, deps) { self.pinnedTeamIds = ko.observableArray([]); self.pinnedIncidentIds = ko.observableArray([]); + // ── Instant Task Suggestion Engine ── + self.suggestionEnabled = ko.observable(true); + self.rescueDistanceWeight = ko.observable(90); + self.rescueTaskingWeight = ko.observable(10); + self.normalDistanceWeight = ko.observable(50); + self.normalTaskingWeight = ko.observable(50); + + // Keep rescue sliders summing to ~100 (optional visual aid) + self.rescueDistanceWeightDisplay = ko.pureComputed(() => { + const d = Number(self.rescueDistanceWeight()) || 0; + const t = Number(self.rescueTaskingWeight()) || 0; + const total = d + t || 1; + return Math.round(d / total * 100); + }); + self.rescueTaskingWeightDisplay = ko.pureComputed(() => { + const d = Number(self.rescueDistanceWeight()) || 0; + const t = Number(self.rescueTaskingWeight()) || 0; + const total = d + t || 1; + return Math.round(t / total * 100); + }); + self.normalDistanceWeightDisplay = ko.pureComputed(() => { + const d = Number(self.normalDistanceWeight()) || 0; + const t = Number(self.normalTaskingWeight()) || 0; + const total = d + t || 1; + return Math.round(d / total * 100); + }); + self.normalTaskingWeightDisplay = ko.pureComputed(() => { + const d = Number(self.normalDistanceWeight()) || 0; + const t = Number(self.normalTaskingWeight()) || 0; + const total = d + t || 1; + return Math.round(t / total * 100); + }); + // Dark mode helper (defined early so it can be called in afterConfigLoad) self._applyDarkMode = () => { if (self.darkMode()) { @@ -179,6 +212,11 @@ export function ConfigVM(root, deps) { clusterRadius: Number(self.clusterRadius()) || 60, clusterRescueJobs: !!self.clusterRescueJobs(), alertsCollapsibleRules: !!self.alertsCollapsibleRules(), + suggestionEnabled: !!self.suggestionEnabled(), + rescueDistanceWeight: Number(self.rescueDistanceWeight()) || 0, + rescueTaskingWeight: Number(self.rescueTaskingWeight()) || 0, + normalDistanceWeight: Number(self.normalDistanceWeight()) || 0, + normalTaskingWeight: Number(self.normalTaskingWeight()) || 0, }); // Helpers @@ -478,6 +516,23 @@ export function ConfigVM(root, deps) { self.alertsCollapsibleRules(cfg.alertsCollapsibleRules); } + // Instant Task Suggestion Engine weights + if (typeof cfg.suggestionEnabled === 'boolean') { + self.suggestionEnabled(cfg.suggestionEnabled); + } + if (typeof cfg.rescueDistanceWeight === 'number') { + self.rescueDistanceWeight(cfg.rescueDistanceWeight); + } + if (typeof cfg.rescueTaskingWeight === 'number') { + self.rescueTaskingWeight(cfg.rescueTaskingWeight); + } + if (typeof cfg.normalDistanceWeight === 'number') { + self.normalDistanceWeight(cfg.normalDistanceWeight); + } + if (typeof cfg.normalTaskingWeight === 'number') { + self.normalTaskingWeight(cfg.normalTaskingWeight); + } + self.afterConfigLoad() @@ -618,6 +673,13 @@ export function ConfigVM(root, deps) { self.save(); }) + // Auto-save suggestion engine settings + self.suggestionEnabled.subscribe(() => { self.save(); }); + self.rescueDistanceWeight.subscribe(() => { self.save(); }); + self.rescueTaskingWeight.subscribe(() => { self.save(); }); + self.normalDistanceWeight.subscribe(() => { self.save(); }); + self.normalTaskingWeight.subscribe(() => { self.save(); }); + self.darkMode.subscribe((isDark) => { self._applyDarkMode(); diff --git a/src/pages/tasking/viewmodels/InstantTask.js b/src/pages/tasking/viewmodels/InstantTask.js index 58c6d7c7..24707860 100644 --- a/src/pages/tasking/viewmodels/InstantTask.js +++ b/src/pages/tasking/viewmodels/InstantTask.js @@ -1,11 +1,14 @@ var ko = require('knockout'); +import { suggestTeamIndices } from '../utils/TeamSuggestionEngine.js'; + export class InstantTaskViewModel { - constructor({ job, map, filteredTeams }) { + constructor({ job, map, filteredTeams, config }) { this.job = job; // expects KO observables on the job (latitude/longitude/name/etc.) this.map = map; this.filteredTeams = filteredTeams; // from main VM + this.config = config; // ConfigVM (may be null during early init) } @@ -34,7 +37,7 @@ export class InstantTaskViewModel { const term = (this.popupTeamFilter() || "").toLowerCase().trim(); const list = this.filteredTeams() || []; const job = this.job; - return list + const enriched = list .filter(tm => !term || (tm.callsign() || "").toLowerCase().includes(term) ) @@ -45,8 +48,9 @@ export class InstantTaskViewModel { ) .map(tm => { const { distance, backBearing } = bestDistanceAndBearing(tm, job); + const taskingCount = tm.filteredTaskings().length; const summaryLine = [ - tm.filteredTaskings().length + ' tasking(s)', + taskingCount + ' tasking(s)', distance != null ? fmtDist(distance) : null, backBearing != null ? fmtBearing(backBearing) : null, distance == null && backBearing == null ? "Location unknown" : null, @@ -54,9 +58,12 @@ export class InstantTaskViewModel { return { team: tm, taskings: tm.filteredTaskings, + taskingCount, currentTaskingSummary: tm.currentTaskingSummary, summaryLine, distanceMeters: distance, + isSuggested: false, // will be set below + suggestionReason: '', // will be set below mouseInTeamInInstantTaskPopup: () => { this.drawCrowsFliesToAssetPassedTeam(tm); }, @@ -80,6 +87,41 @@ export class InstantTaskViewModel { const db = b.distanceMeters ?? Number.POSITIVE_INFINITY; return da - db; }); + + // ── Suggestion engine ── + const cfg = this.config; + if (cfg && enriched.length > 0) { + const weights = { + enabled: cfg.suggestionEnabled ? !!ko.unwrap(cfg.suggestionEnabled) : true, + rescueDistanceWeight: cfg.rescueDistanceWeight ? Number(ko.unwrap(cfg.rescueDistanceWeight)) : 90, + rescueTaskingWeight: cfg.rescueTaskingWeight ? Number(ko.unwrap(cfg.rescueTaskingWeight)) : 10, + normalDistanceWeight: cfg.normalDistanceWeight ? Number(ko.unwrap(cfg.normalDistanceWeight)) : 50, + normalTaskingWeight: cfg.normalTaskingWeight ? Number(ko.unwrap(cfg.normalTaskingWeight)) : 50, + }; + + const priorityId = job.priorityId ? ko.unwrap(job.priorityId) : null; + const results = suggestTeamIndices(enriched, priorityId, weights, 2); + + // Mark suggested teams with reason, then move them to the top (best first) + const suggested = []; + for (const { index, reason } of results) { + if (index >= 0 && index < enriched.length) { + enriched[index].isSuggested = true; + enriched[index].suggestionReason = reason; + } + } + // Pull them out in reverse index order to avoid shifting + const sortedIdxDesc = results + .map(r => r.index) + .filter(i => i >= 0 && i < enriched.length) + .sort((a, b) => b - a); + for (const idx of sortedIdxDesc) { + suggested.unshift(enriched.splice(idx, 1)[0]); + } + enriched.unshift(...suggested); + } + + return enriched; }); } diff --git a/static/pages/tasking.html b/static/pages/tasking.html index bf194985..ded3c3ab 100644 --- a/static/pages/tasking.html +++ b/static/pages/tasking.html @@ -1245,9 +1245,14 @@ class="dropdown-item text-start py-1" data-bind="click: taskTeamToJobWithConfirm, event: { mouseenter: mouseInTeamInInstantTaskPopup, mouseleave: mouseOutTeamInInstantTaskPopup }"> -
    - + + + + + +
    @@ -2610,6 +2615,149 @@

    + + +
    +

    + +

    + +
    +
    + +

    + When enabled, the instant-task dropdown will suggest a team using a + rule-based engine. The suggested team appears at the top of the list with a + icon. +

    + + +
    + + +
    + +
    + + +
    +
    + Rules +
    +
    +
      +
    • + Rescue priority: + Prefer the nearest team with zero active taskings. + If all teams already have taskings, fall back to weighted scoring below. +
      • +
    • + All other priorities: + Score every team using a weighted combination of + distance and tasking count, then suggest the lowest-scored team. +
      • +
    +
    +
    + +
    + + +
    +
    + + Rescue Weights + + + +
    + Low + + High +
    + + +
    + Low + + High +
    + +
    + For Rescue jobs, idle teams (zero taskings) are always + preferred first. These weights apply when all teams have + at least one tasking. +
    +
    +
    + + +
    +
    + + Standard Weights + + + +
    + Low + + High +
    + + +
    + Low + + High +
    + +
    + For non-rescue jobs (Immediate, Priority, General). + Balances proximity with how busy each team already is. +
    +
    +
    + +
    +
    + +
    +
    +
    + diff --git a/styles/pages/tasking.css b/styles/pages/tasking.css index 81d78820..1c00a748 100644 --- a/styles/pages/tasking.css +++ b/styles/pages/tasking.css @@ -2000,6 +2000,50 @@ overflow: hidden; position: fixed !important; } +/* Instant task suggestion highlight */ +.instant-task-suggested { + background-color: rgba(13, 110, 253, 0.08); + border-left: 3px solid #0d6efd; + padding-left: 9px !important; +} +.instant-task-suggested:hover { + background-color: rgba(13, 110, 253, 0.15); +} +.dark-mode .instant-task-suggested { + background-color: rgba(100, 160, 255, 0.12); + border-left-color: #6ea8fe; +} +.dark-mode .instant-task-suggested:hover { + background-color: rgba(100, 160, 255, 0.22); +} + +/* Fast tooltip (no native delay) — positioned fixed via JS to escape overflow clipping */ +.fast-tooltip { + display: inline-flex; + cursor: default; +} +.fast-tooltip-bubble { + position: fixed; + padding: 5px 8px; + background: #333; + color: #fff; + font-size: 11px; + font-weight: 500; + line-height: 1.35; + white-space: nowrap; + border-radius: 3px; + pointer-events: none; + z-index: 9999; + opacity: 0; + transition: opacity 0.1s ease; +} +.fast-tooltip-bubble.show { + opacity: 1; +} +.dark-mode .fast-tooltip-bubble { + background: #555; +} + /* Sector dropdown button */ .sector-dropdown-btn { background: none; From a4e40e6e6052fb578b2f72d25f529be3d12e0bb6 Mon Sep 17 00:00:00 2001 From: Tim Dykes Date: Tue, 17 Mar 2026 11:43:58 +1100 Subject: [PATCH 3/9] swapped the logic to 100 base --- src/pages/tasking/components/job_popup.js | 1 + src/pages/tasking/utils/TeamSuggestionEngine.js | 15 ++++++++------- static/pages/tasking.html | 1 + 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/pages/tasking/components/job_popup.js b/src/pages/tasking/components/job_popup.js index f91f4f16..0c4d5b9a 100644 --- a/src/pages/tasking/components/job_popup.js +++ b/src/pages/tasking/components/job_popup.js @@ -41,6 +41,7 @@ export function buildJobPopupKO() {
    From 40763a20cf7434a44cd5aedd4cca8229c3171c59 Mon Sep 17 00:00:00 2001 From: Tim Dykes Date: Tue, 17 Mar 2026 21:28:28 +1100 Subject: [PATCH 5/9] Lad als routing (#342) * wording fixups * use amazon for pathing for suggested task --- src/pages/tasking/bindings/bsDropdownOpen.js | 33 +++ src/pages/tasking/components/job_popup.js | 8 +- src/pages/tasking/main.js | 1 + .../tasking/utils/TeamSuggestionEngine.js | 92 ++++-- src/pages/tasking/utils/batchRoute.js | 133 +++++++++ src/pages/tasking/viewmodels/Config.js | 13 + src/pages/tasking/viewmodels/InstantTask.js | 266 ++++++++++++++++-- src/pages/tasking/viewmodels/Map.js | 16 ++ static/pages/tasking.html | 34 ++- styles/pages/tasking.css | 5 + 10 files changed, 558 insertions(+), 43 deletions(-) create mode 100644 src/pages/tasking/bindings/bsDropdownOpen.js create mode 100644 src/pages/tasking/utils/batchRoute.js diff --git a/src/pages/tasking/bindings/bsDropdownOpen.js b/src/pages/tasking/bindings/bsDropdownOpen.js new file mode 100644 index 00000000..a6dc6589 --- /dev/null +++ b/src/pages/tasking/bindings/bsDropdownOpen.js @@ -0,0 +1,33 @@ +/** + * bsDropdownOpen – Knockout custom binding + * + * Bridges Bootstrap 5 dropdown show/hide events to a KO observable. + * Apply to the parent element that contains the toggle button and the + * `.dropdown-menu`. The observable is set to `true` on `shown.bs.dropdown` + * and `false` on `hidden.bs.dropdown`. + * + * Usage: + *
    …
    + * + * @module bindings/bsDropdownOpen + */ + +var ko = require('knockout'); + +ko.bindingHandlers.bsDropdownOpen = { + init(element, valueAccessor) { + const obs = valueAccessor(); + + const onShown = () => obs(true); + const onHidden = () => obs(false); + + element.addEventListener('shown.bs.dropdown', onShown); + element.addEventListener('hidden.bs.dropdown', onHidden); + + // Clean up listeners when the element is removed from the DOM + ko.utils.domNodeDisposal.addDisposeCallback(element, () => { + element.removeEventListener('shown.bs.dropdown', onShown); + element.removeEventListener('hidden.bs.dropdown', onHidden); + }); + }, +}; diff --git a/src/pages/tasking/components/job_popup.js b/src/pages/tasking/components/job_popup.js index 0c4d5b9a..e28f78b3 100644 --- a/src/pages/tasking/components/job_popup.js +++ b/src/pages/tasking/components/job_popup.js @@ -39,7 +39,7 @@ export function buildJobPopupKO() {
    -
    +
    diff --git a/src/pages/tasking/main.js b/src/pages/tasking/main.js index 3844e678..ff8760e3 100644 --- a/src/pages/tasking/main.js +++ b/src/pages/tasking/main.js @@ -49,6 +49,7 @@ import { installDragDropRowBindings } from "./bindings/dragDropRows.js"; import { installSortableArrayBindings } from "./bindings/sortableArray.js"; import { noBubbleFromDisabledButtonsBindings } from "./bindings/noBubble.js" import "./bindings/fastTooltip.js"; // registers ko.bindingHandlers.fastTooltip +import "./bindings/bsDropdownOpen.js"; // registers ko.bindingHandlers.bsDropdownOpen import { registerTransportCamerasLayer } from "./mapLayers/transport.js"; import { registerUnitBoundaryLayer } from "./mapLayers/geoservices.js"; diff --git a/src/pages/tasking/utils/TeamSuggestionEngine.js b/src/pages/tasking/utils/TeamSuggestionEngine.js index 429c0033..24c842a8 100644 --- a/src/pages/tasking/utils/TeamSuggestionEngine.js +++ b/src/pages/tasking/utils/TeamSuggestionEngine.js @@ -13,6 +13,11 @@ * 100 = best possible match, 0 = worst. Suggest the team with the * highest combined score. * + * When `travelTimeSeconds` is available on a team object (from Amazon + * Location Service routing), it is used as the proximity dimension instead + * of haversine distance. This gives more accurate suggestions because road + * travel time accounts for road network topology and speed limits. + * * The user can tweak the distance vs tasking weights per priority class * via the config modal. */ @@ -40,7 +45,7 @@ const DEFAULT_WEIGHTS = { * { index, reason } objects for the top-N suggested teams (best first), * or [] if disabled/impossible. * - * @param {{ distanceMeters: number|null, taskingCount: number }[]} teams + * @param {{ distanceMeters: number|null, travelTimeSeconds: number|null, taskingCount: number }[]} teams * @param {number|null} priorityId Enum.JobPriorityType id (1 = Rescue) * @param {SuggestionWeights} weights * @param {number} [count=2] how many suggestions to return @@ -74,13 +79,13 @@ function rescueStrategyN(teams, w, count) { const idle = withDist.filter(t => t.taskingCount === 0); if (idle.length > 0) { - idle.sort((a, b) => a.distanceMeters - b.distanceMeters); + // Sort by travel time if available, otherwise by haversine distance + idle.sort((a, b) => proximityValue(a) - proximityValue(b)); return idle.slice(0, count).map((t, rank) => { - const distKm = (t.distanceMeters / 1000).toFixed(1); const prefix = rank === 0 ? 'Nearest' : `#${rank + 1} nearest`; return { index: t._idx, - reason: `${prefix} idle team — ${distKm} km, 0 taskings (rescue)`, + reason: `${prefix} idle team — ${fmtProximity(t)}, 0 taskings (rescue)`, }; }); } @@ -94,13 +99,12 @@ function rescueStrategyN(teams, w, count) { } // Pure distance fallback - withDist.sort((a, b) => a.distanceMeters - b.distanceMeters); + withDist.sort((a, b) => proximityValue(a) - proximityValue(b)); return withDist.slice(0, count).map((t, rank) => { - const distKm = (t.distanceMeters / 1000).toFixed(1); const prefix = rank === 0 ? 'Nearest' : `#${rank + 1} nearest`; return { index: t._idx, - reason: `${prefix} team — ${distKm} km, ${t.taskingCount} tasking(s) (rescue, all busy)`, + reason: `${prefix} team — ${fmtProximity(t)}, ${t.taskingCount} tasking(s) (rescue, all busy)`, }; }); } @@ -139,22 +143,26 @@ function scoredIndices(items, distWeight, taskWeight, count, tag) { const dwPct = Math.round(dw * 100); const twPct = Math.round(tw * 100); - // min/max for normalisation - const distances = items.map(t => t.distanceMeters); - const taskings = items.map(t => t.taskingCount); + // Use travel time as proximity dimension when available, fall back to distance + const proxValues = items.map(t => proximityValue(t)); + const taskings = items.map(t => t.taskingCount); - const dMin = Math.min(...distances); - const dMax = Math.max(...distances); + const dMin = Math.min(...proxValues); + const dMax = Math.max(...proxValues); const tMin = Math.min(...taskings); const tMax = Math.max(...taskings); const dRange = dMax - dMin || 1; // avoid /0 const tRange = tMax - tMin || 1; - const scored = items.map(t => { - const normDist = 1 - (t.distanceMeters - dMin) / dRange; // 1 = closest, 0 = farthest - const normTask = 1 - (t.taskingCount - tMin) / tRange; // 1 = fewest, 0 = most - const score = (normDist * dw + normTask * tw) * 100; // 0–100 scale + // Are any teams using road-routing data? + const hasAnyRouting = items.some(t => t.travelTimeSeconds != null && Number.isFinite(t.travelTimeSeconds)); + const proxLabel = hasAnyRouting ? 'travel' : 'dist'; + + const scored = items.map((t, i) => { + const normDist = 1 - (proxValues[i] - dMin) / dRange; // 1 = closest/fastest, 0 = farthest/slowest + const normTask = 1 - (t.taskingCount - tMin) / tRange; // 1 = fewest, 0 = most + const score = (normDist * dw + normTask * tw) * 100; // 0–100 scale return { _idx: t._idx, score, normDist, normTask, raw: t }; }); @@ -162,14 +170,60 @@ function scoredIndices(items, distWeight, taskWeight, count, tag) { return scored.slice(0, count).map((s, rank) => { const parts = []; - if (dwPct > 0) parts.push(`dist ${dwPct}%`); + if (dwPct > 0) parts.push(`${proxLabel} ${dwPct}%`); if (twPct > 0) parts.push(`task ${twPct}%`); const weightDesc = parts.join(' / '); const prefix = rank === 0 ? 'Best' : `#${rank + 1}`; - const distKm = (s.raw.distanceMeters / 1000).toFixed(1); return { index: s._idx, - reason: `${prefix} match ${s.score.toFixed(0)}% (${weightDesc}) — ${distKm} km, ${s.raw.taskingCount} tasking(s) [${tag}]`, + reason: `${prefix} match ${s.score.toFixed(0)}% (${weightDesc}) — ${fmtProximity(s.raw)}, ${s.raw.taskingCount} tasking(s) [${tag}]`, }; }); } + + +/* ------------------------------------------------------------------ */ +/* Proximity helpers */ +/* ------------------------------------------------------------------ */ + +/** + * Returns a single numeric "proximity" value for sorting / normalisation. + * + * Prefers `travelTimeSeconds` (road routing) when available because it + * accounts for road topology and speed limits. Falls back to haversine + * `distanceMeters`. Lower value = closer/faster. + * + * @param {{ travelTimeSeconds?: number|null, distanceMeters: number }} t + * @returns {number} + */ +function proximityValue(t) { + if (t.travelTimeSeconds != null && Number.isFinite(t.travelTimeSeconds)) { + return t.travelTimeSeconds; + } + return t.distanceMeters; +} + +/** + * Human-readable proximity string for reason tooltips. + * Shows travel time + road distance when routing data is available, + * otherwise just the haversine distance. + * + * @param {{ travelTimeSeconds?: number|null, distanceMeters: number }} t + * @returns {string} + */ +function fmtProximity(t) { + const distKm = (t.distanceMeters / 1000).toFixed(1); + if (t.travelTimeSeconds != null && Number.isFinite(t.travelTimeSeconds)) { + const totalMin = Math.round(t.travelTimeSeconds / 60); + let timeStr; + if (totalMin < 60) { + timeStr = `${totalMin} min`; + } else { + const hr = Math.floor(totalMin / 60); + const min = totalMin % 60; + timeStr = min > 0 ? `${hr} hr ${min} min` : `${hr} hr`; + } + return `${timeStr}, ${distKm} km road`; + } + return `${distKm} km`; +} diff --git a/src/pages/tasking/utils/batchRoute.js b/src/pages/tasking/utils/batchRoute.js new file mode 100644 index 00000000..05de6bb7 --- /dev/null +++ b/src/pages/tasking/utils/batchRoute.js @@ -0,0 +1,133 @@ +/** + * batchRoute.js + * + * Lightweight helper that fetches road-routing summaries (distance + travel + * time) for multiple origin→destination pairs via the same Amazon Location + * Service Lambda used by the map routing controls. + * + * Each pair produces a single POST to the route endpoint. All requests + * run in parallel and are individually fault-tolerant — a failed route + * resolves to `null` rather than rejecting the batch. + * + * @module batchRoute + */ + +const ROUTE_URL = "https://lambda.lighthouse-extension.com/lad/route"; + +/** + * @typedef {Object} RouteSummary + * @property {number} distanceMeters Road distance in metres. + * @property {number} travelTimeSeconds Estimated travel time in seconds. + * @property {number[][]|null} geometry Route polyline as [[lat,lng], …] or null. + */ + +/** + * Fetch road-routing summaries for an array of origin→destination pairs. + * + * @param {{ fromLat: number, fromLng: number, toLat: number, toLng: number }[]} pairs + * Array of coordinate pairs to route between. + * @param {Object} [opts] + * @param {string} [opts.travelMode="Car"] ALS travel mode. + * @param {number} [opts.timeoutMs=10000] Per-request timeout. + * @param {AbortSignal} [opts.signal] Optional abort signal to + * cancel all in-flight requests. + * @returns {Promise<(RouteSummary|null)[]>} + * Array aligned with `pairs`. Each entry is either a summary object or + * `null` if that individual route failed. + */ +export async function batchRoute(pairs, opts = {}) { + const { travelMode = "Car", timeoutMs = 10000, signal } = opts; + + const promises = pairs.map(({ fromLat, fromLng, toLat, toLng }) => { + const controller = new AbortController(); + const timer = setTimeout(() => controller.abort(), timeoutMs); + + // Honour external abort as well + if (signal) { + signal.addEventListener("abort", () => controller.abort(), { once: true }); + } + + const payload = { + coordinates: [ + [fromLng, fromLat], // ALS expects [lng, lat] + [toLng, toLat], + ], + travelMode, + }; + + return fetch(ROUTE_URL, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify(payload), + signal: controller.signal, + }) + .then(res => { + clearTimeout(timer); + if (!res.ok) return null; + return res.json(); + }) + .then(json => { + if (!json) return null; + return extractSummary(json); + }) + .catch(() => { + clearTimeout(timer); + return null; // swallow per-route failures + }); + }); + + return Promise.all(promises); +} + +/** + * Pulls distance (metres) and time (seconds) from the ALS Lambda response. + * + * The Lambda returns the raw Amazon Routes API shape: + * `{ Routes: [{ Summary: { Overview: { Distance, Duration } } }] }` + * + * Falls back through several structural variants for robustness. + * + * @param {Object} json Parsed API response. + * @returns {RouteSummary|null} + */ +function extractSummary(json) { + const routes = json?.Routes ?? json?.routes ?? (Array.isArray(json) ? json : null); + if (!routes || !routes.length) return null; + + const r = routes[0]; + const src = + r?.Summary?.Overview ?? + r?.summary?.overview ?? + r?.Summary ?? + r?.summary ?? + null; + + if (!src) return null; + + const distanceMeters = typeof src.Distance === "number" ? Math.round(src.Distance) : null; + const travelTimeSeconds = typeof src.Duration === "number" ? Math.round(src.Duration) : null; + + if (distanceMeters == null && travelTimeSeconds == null) return null; + + // Extract route geometry from Legs[].Geometry.LineString => [[lat,lng], …] + const legs = r?.Legs ?? r?.legs ?? []; + let geometry = null; + if (Array.isArray(legs) && legs.length) { + const coords = []; + for (const leg of legs) { + const geom = leg?.Geometry ?? leg?.geometry; + const ls = geom?.LineString ?? geom?.lineString; + if (Array.isArray(ls) && ls.length) { + for (let i = 0; i < ls.length; i++) { + // Skip duplicate join-point between legs + if (coords.length && i === 0) continue; + // ALS returns [lng, lat] — flip to [lat, lng] for Leaflet + coords.push([ls[i][1], ls[i][0]]); + } + } + } + if (coords.length >= 2) geometry = coords; + } + + return { distanceMeters, travelTimeSeconds, geometry }; +} diff --git a/src/pages/tasking/viewmodels/Config.js b/src/pages/tasking/viewmodels/Config.js index 064ef544..43e56f6c 100644 --- a/src/pages/tasking/viewmodels/Config.js +++ b/src/pages/tasking/viewmodels/Config.js @@ -103,6 +103,14 @@ export function ConfigVM(root, deps) { self.normalDistanceWeight = ko.observable(50); self.normalTaskingWeight = ko.observable(50); + /** + * When true, the suggestion engine fetches road travel times from + * Amazon Location Service to rank teams by actual driving time + * instead of crow-flies distance. + * @type {ko.Observable} + */ + self.suggestionUseRouting = ko.observable(false); + // Keep rescue sliders summing to ~100 (optional visual aid) self.rescueDistanceWeightDisplay = ko.pureComputed(() => { const d = Number(self.rescueDistanceWeight()) || 0; @@ -217,6 +225,7 @@ export function ConfigVM(root, deps) { rescueTaskingWeight: Number(self.rescueTaskingWeight()) || 0, normalDistanceWeight: Number(self.normalDistanceWeight()) || 0, normalTaskingWeight: Number(self.normalTaskingWeight()) || 0, + suggestionUseRouting: !!self.suggestionUseRouting(), }); // Helpers @@ -532,6 +541,9 @@ export function ConfigVM(root, deps) { if (typeof cfg.normalTaskingWeight === 'number') { self.normalTaskingWeight(cfg.normalTaskingWeight); } + if (typeof cfg.suggestionUseRouting === 'boolean') { + self.suggestionUseRouting(cfg.suggestionUseRouting); + } self.afterConfigLoad() @@ -679,6 +691,7 @@ export function ConfigVM(root, deps) { self.rescueTaskingWeight.subscribe(() => { self.save(); }); self.normalDistanceWeight.subscribe(() => { self.save(); }); self.normalTaskingWeight.subscribe(() => { self.save(); }); + self.suggestionUseRouting.subscribe(() => { self.save(); }); self.darkMode.subscribe((isDark) => { self._applyDarkMode(); diff --git a/src/pages/tasking/viewmodels/InstantTask.js b/src/pages/tasking/viewmodels/InstantTask.js index 24707860..4001e990 100644 --- a/src/pages/tasking/viewmodels/InstantTask.js +++ b/src/pages/tasking/viewmodels/InstantTask.js @@ -1,19 +1,93 @@ var ko = require('knockout'); import { suggestTeamIndices } from '../utils/TeamSuggestionEngine.js'; - - +import { batchRoute } from '../utils/batchRoute.js'; + + +/** + * ViewModel for the "instant task" dropdown attached to each job row and + * map popup. Provides a filtered, distance-sorted, suggestion-enriched + * list of teams that can be tasked to the parent job with a single click. + * + * When the dropdown opens the list renders immediately using haversine + * (crow-flies) distances. If road-routing is enabled in config, Amazon + * Location Service travel times are fetched in the background. When + * results arrive the computed re-evaluates, the summary lines update with + * actual travel times, and the suggestion engine re-ranks using road + * distance instead of haversine. + */ export class InstantTaskViewModel { constructor({ job, map, filteredTeams, config }) { - this.job = job; // expects KO observables on the job (latitude/longitude/name/etc.) + this.job = job; this.map = map; - this.filteredTeams = filteredTeams; // from main VM - this.config = config; // ConfigVM (may be null during early init) + this.filteredTeams = filteredTeams; + this.config = config; + + /** + * In-memory cache of route results keyed by `"teamId"`. + * Each value stores the route summary plus the origin/destination + * coordinates that were used, so stale entries can be detected + * when teams or jobs move. + * + * Shape: `{ distanceMeters, travelTimeSeconds, fromLat, fromLng, toLat, toLng }` or `null` (in-flight). + * @type {Map} + */ + this._routeCache = new Map(); + + /** + * Last-known job coordinates used for route lookups. + * When the job moves, the entire cache is flushed. + * @type {{ lat: number|null, lon: number|null }} + */ + this._lastJobCoords = { lat: null, lon: null }; + + /** + * Minimum movement (in metres) of either endpoint before a cached + * route entry is considered stale and evicted. + * @type {number} + */ + this._movementThreshold = 100; + + /** + * Bumped after route results arrive so `popupFilteredTeams` re-evaluates. + * @type {ko.Observable} + */ + this._routeCacheTick = ko.observable(0); + + /** + * AbortController for the current in-flight batch route request. + * Allows cancellation when the dropdown closes before results arrive. + * @type {AbortController|null} + */ + this._routeAbort = null; + + /** + * Set to `true` after routes are kicked off for the current + * dropdown session. Reset to `false` when the dropdown closes + * so the next open triggers a fresh fetch. + * @type {boolean} + */ + this._routesFetchedThisOpen = false; + + // When the instant-task dropdown closes, cancel pending route + // requests and reset the fetch-once flag for the next open. + this.dropdownOpen.subscribe(open => { + if (!open) { + if (this._routeAbort) { + this._routeAbort.abort(); + this._routeAbort = null; + } + this._routesFetchedThisOpen = false; + } + }); } popupActive = ko.observable(false); // gate to stop it from processing every time something changes under it + /** True only while the instant-task Bootstrap dropdown is shown. */ + dropdownOpen = ko.observable(false); + popupTeamFilter = ko.observable(''); @@ -22,6 +96,20 @@ export class InstantTaskViewModel { this.map.drawCrowsFliesToAssetPassedTeam(team, this.job) } + /** + * Draw the cached road-route polyline for a team, or fall back to + * crow-flies if no geometry is available. + */ + drawRouteOrCrowsFlies = (tm, teamId) => { + const cached = this._routeCache.get(teamId); + if (cached && cached.geometry) { + this.map.clearCrowFliesLine(); + this.map.drawRoutePolyline(cached.geometry); + } else { + this.drawCrowsFliesToAssetPassedTeam(tm); + } + } + removeCrowsFlies = () => { this.map.clearCrowFliesLine(); } @@ -34,9 +122,38 @@ export class InstantTaskViewModel { if (!this.popupActive()) return []; // short-circuit + // Read the route-cache tick so this computed re-fires after routes arrive + this._routeCacheTick(); + const term = (this.popupTeamFilter() || "").toLowerCase().trim(); const list = this.filteredTeams() || []; const job = this.job; + + const jLat = unwrapNum(job?.address?.latitude); + const jLon = unwrapNum(job?.address?.longitude); + + const cfg = this.config; + const useRouting = cfg && cfg.suggestionUseRouting ? !!ko.unwrap(cfg.suggestionUseRouting) : false; + const dropdownIsOpen = this.dropdownOpen(); + + // ── Invalidate entire cache when the job/incident has moved ── + if (jLat != null && jLon != null) { + const prev = this._lastJobCoords; + if (prev.lat != null && prev.lon != null) { + const jobDrift = haversineMeters(prev.lat, prev.lon, jLat, jLon); + if (jobDrift > this._movementThreshold) { + this._routeCache.clear(); + } + } + this._lastJobCoords = { lat: jLat, lon: jLon }; + } + + /** Max number of route lookups per evaluation (nearest teams only). */ + const ROUTE_LIMIT = 5; + + // Teams that could use a route lookup (collected during map, trimmed after) + const routeCandidates = []; + const enriched = list .filter(tm => !term || (tm.callsign() || "").toLowerCase().includes(term) @@ -47,25 +164,55 @@ export class InstantTaskViewModel { ) ) .map(tm => { - const { distance, backBearing } = bestDistanceAndBearing(tm, job); + const { distance, backBearing, assetLat, assetLon } = bestDistanceAndBearing(tm, job); const taskingCount = tm.filteredTaskings().length; - const summaryLine = [ + + // Check route cache — evict if team's asset has moved + const teamId = String(ko.unwrap(tm.id)); + let cached = this._routeCache.get(teamId); + if (cached && assetLat != null && assetLon != null) { + const drift = haversineMeters(cached.fromLat, cached.fromLng, assetLat, assetLon); + if (drift > this._movementThreshold) { + this._routeCache.delete(teamId); + cached = undefined; + } + } + const hasRoute = cached && cached.travelTimeSeconds != null; + + // Build summary line — include travel time when available + const summaryParts = [ taskingCount + ' tasking(s)', - distance != null ? fmtDist(distance) : null, + hasRoute ? fmtTime(cached.travelTimeSeconds) : null, + hasRoute ? fmtDist(cached.distanceMeters) + ' road' : (distance != null ? fmtDist(distance) : null), backBearing != null ? fmtBearing(backBearing) : null, distance == null && backBearing == null ? "Location unknown" : null, ].filter(Boolean).join(' • '); + + // For the suggestion engine: prefer road distance, fall back to haversine + const effectiveDistance = hasRoute ? cached.distanceMeters : distance; + + // Collect candidate for route fetching (only on first eval after dropdown opens) + if (useRouting && dropdownIsOpen && !this._routesFetchedThisOpen && !this._routeCache.has(teamId) && assetLat != null && jLat != null) { + routeCandidates.push({ + teamId, fromLat: assetLat, fromLng: assetLon, + toLat: jLat, toLng: jLon, + _haversine: distance ?? Number.POSITIVE_INFINITY, + }); + } + return { team: tm, taskings: tm.filteredTaskings, taskingCount, currentTaskingSummary: tm.currentTaskingSummary, - summaryLine, - distanceMeters: distance, - isSuggested: false, // will be set below - suggestionReason: '', // will be set below + summaryLine: summaryParts, + distanceMeters: effectiveDistance, + travelTimeSeconds: hasRoute ? cached.travelTimeSeconds : null, + isSuggested: false, + suggestionReason: '', + routeLoading: false, // updated below after trimming to nearest N mouseInTeamInInstantTaskPopup: () => { - this.drawCrowsFliesToAssetPassedTeam(tm); + this.drawRouteOrCrowsFlies(tm, teamId); }, mouseOutTeamInInstantTaskPopup: () => { this.removeCrowsFlies(); @@ -77,8 +224,6 @@ export class InstantTaskViewModel { dropdown.classList.remove('show'); } this.taskTeamToJobWithConfirm(tm); - // Close the dropdown - } }; }) @@ -88,8 +233,25 @@ export class InstantTaskViewModel { return da - db; }); + // ── Kick off async route fetching for nearest uncached teams (once per open) ── + if (routeCandidates.length > 0) { + // Sort candidates by haversine so we only route the closest teams + routeCandidates.sort((a, b) => a._haversine - b._haversine); + const routeNeeded = routeCandidates.slice(0, ROUTE_LIMIT); + + // Mark those teams as loading in the enriched list + const routeSet = new Set(routeNeeded.map(r => r.teamId)); + for (const item of enriched) { + if (routeSet.has(String(ko.unwrap(item.team.id)))) { + item.routeLoading = true; + } + } + + this._routesFetchedThisOpen = true; + this._fetchRoutes(routeNeeded); + } + // ── Suggestion engine ── - const cfg = this.config; if (cfg && enriched.length > 0) { const weights = { enabled: cfg.suggestionEnabled ? !!ko.unwrap(cfg.suggestionEnabled) : true, @@ -124,6 +286,48 @@ export class InstantTaskViewModel { return enriched; }); + /** + * Fires off parallel route requests for teams not yet in the cache. + * When results arrive the cache is populated, the tick is bumped, and + * `popupFilteredTeams` re-evaluates automatically. + * + * Safe to call multiple times — teams already in-flight or cached are + * skipped because the caller only passes uncached team IDs. + * + * @param {{ teamId: string, fromLat: number, fromLng: number, toLat: number, toLng: number }[]} pairs + */ + _fetchRoutes = (pairs) => { + // Mark these as "in-flight" in cache so we don't re-request + for (const p of pairs) { + this._routeCache.set(p.teamId, null); + } + + // Abort any previous batch + if (this._routeAbort) this._routeAbort.abort(); + const controller = new AbortController(); + this._routeAbort = controller; + + batchRoute(pairs, { signal: controller.signal }) + .then(results => { + if (controller.signal.aborted) return; + + for (let i = 0; i < pairs.length; i++) { + const summary = results[i]; + const p = pairs[i]; + // Store the coordinates alongside the result for staleness checks + this._routeCache.set(p.teamId, summary + ? { ...summary, fromLat: p.fromLat, fromLng: p.fromLng, toLat: p.toLat, toLng: p.toLng } + : summary); + } + + // Bump tick so the computed re-evaluates with route data + this._routeCacheTick(this._routeCacheTick() + 1); + }) + .catch(() => { + // Silently ignore — haversine fallback remains in place + }); + }; + } @@ -166,8 +370,8 @@ function backBearingDegrees(bearing) { function bearingToCardinal(bearing) { if (bearing == null || !Number.isFinite(bearing)) return null; const dirs = [ - "North", "North-East", "East", "South-East", - "South", "South-West", "West", "North-West" + "↑", "↗", "→", "↘", + "↓", "↙", "←", "↖" ]; const idx = Math.round(bearing / 45) % 8; return dirs[idx]; @@ -176,11 +380,13 @@ function bearingToCardinal(bearing) { function bestDistanceAndBearing(team, job) { const jLat = unwrapNum(job?.address?.latitude); const jLon = unwrapNum(job?.address?.longitude); - if (jLat == null || jLon == null) return { distance: null, bearing: null }; + if (jLat == null || jLon == null) return { distance: null, bearing: null, assetLat: null, assetLon: null }; const assets = ko.unwrap(team?.trackableAssets) || []; let best = null; let bestBearing = null; + let bestAssetLat = null; + let bestAssetLon = null; for (const a of assets) { let lat = unwrapNum(a?.latitude), lon = unwrapNum(a?.longitude); @@ -194,17 +400,35 @@ function bestDistanceAndBearing(team, job) { if (best == null || d < best) { best = d; bestBearing = bearingDegrees(lat, lon, jLat, jLon); + bestAssetLat = lat; + bestAssetLon = lon; } } const backBearing = bestBearing != null ? backBearingDegrees(bestBearing) : null; - return { distance: best, bearing: bestBearing, backBearing }; + return { distance: best, bearing: bestBearing, backBearing, assetLat: bestAssetLat, assetLon: bestAssetLon }; } const fmtBearing = b => - b == null ? "-" : `${bearingToCardinal(b)} (${Math.round(b)}°)`; + b == null ? "-" : `${bearingToCardinal(b)} ${Math.round(b)}°`; const fmtDist = m => m == null ? "-" : (m < 950 ? `${Math.round(m)} m` : `${(m / 1000).toFixed(1)} km`); +/** + * Formats a travel time in seconds for display. + * Examples: "3 min", "1 hr 25 min". + * + * @param {number|null} s Travel time in seconds. + * @returns {string} + */ +const fmtTime = s => { + if (s == null || !Number.isFinite(s)) return "-"; + const totalMin = Math.round(s / 60); + if (totalMin < 60) return `${totalMin} min`; + const hr = Math.floor(totalMin / 60); + const min = totalMin % 60; + return min > 0 ? `${hr} hr ${min} min` : `${hr} hr`; +}; + diff --git a/src/pages/tasking/viewmodels/Map.js b/src/pages/tasking/viewmodels/Map.js index e9dbf27b..ee27d198 100644 --- a/src/pages/tasking/viewmodels/Map.js +++ b/src/pages/tasking/viewmodels/Map.js @@ -685,6 +685,22 @@ export function MapVM(Lmap, root) { self.crowFliesLine.addTo(self.map); }; + /** + * Draw a road-route polyline on the map (reuses the crowFliesLine slot + * so it is cleared by the same `clearCrowFliesLine` call). + * + * @param {number[][]} latLngs Array of [lat, lng] pairs. + */ + self.drawRoutePolyline = (latLngs) => { + self.clearCrowFliesLine(); + if (!latLngs || latLngs.length < 2) return; + self.crowFliesLine = L.polyline(latLngs, { + weight: 4, + color: '#2196F3', + opacity: 0.85, + }).addTo(self.map); + }; + self.drawCrowsFliesToAssetPassedTeam = (team, job) => { self.clearCrowFliesLine(); if (!team || !job) return; diff --git a/static/pages/tasking.html b/static/pages/tasking.html index c9951f4d..dd9c0b60 100644 --- a/static/pages/tasking.html +++ b/static/pages/tasking.html @@ -1213,7 +1213,8 @@
    + role="group" + data-bind="bsDropdownOpen: j.instantTask.dropdownOpen">
    + +
    + + Calculating travel time… +
    + @@ -2652,6 +2659,24 @@

    + +
    + + +
    + When enabled, suggestions use Lighthouse road routing for + actual driving times instead of crow-flies distance. + The dropdown loads instantly with haversine distances, + then updates when travel times arrive. +
    +
    +
    @@ -2667,7 +2692,12 @@

  • All other priorities: Score every team using a weighted combination of - distance and tasking count, then suggest the lowest-scored team. + distance and tasking count, then suggest the highest-scored team. +
    • +
  • + Road routing: + When enabled, travel times from Lighthouse Location Service + replace crow-flies distance for more accurate ranking.

    • diff --git a/styles/pages/tasking.css b/styles/pages/tasking.css index 1c00a748..ba3907a9 100644 --- a/styles/pages/tasking.css +++ b/styles/pages/tasking.css @@ -1996,6 +1996,11 @@ overflow: hidden; z-index: 3000 !important; } +.job-taskteam-dropdown .dropdown-item { + white-space: normal; + word-break: break-word; +} + .job-taskteam-dropdown.show { position: fixed !important; } From 066da5005709cad1feaee92b2eaa3ddc5ca2271f Mon Sep 17 00:00:00 2001 From: Tim Dykes Date: Tue, 17 Mar 2026 21:37:19 +1100 Subject: [PATCH 6/9] incidents without GPS broke stuff --- .../tasking/utils/TeamSuggestionEngine.js | 5 ++++- src/pages/tasking/viewmodels/InstantTask.js | 4 +++- src/pages/tasking/viewmodels/Map.js | 20 +++++++++++-------- 3 files changed, 19 insertions(+), 10 deletions(-) diff --git a/src/pages/tasking/utils/TeamSuggestionEngine.js b/src/pages/tasking/utils/TeamSuggestionEngine.js index 24c842a8..e7a50c6e 100644 --- a/src/pages/tasking/utils/TeamSuggestionEngine.js +++ b/src/pages/tasking/utils/TeamSuggestionEngine.js @@ -200,7 +200,7 @@ function proximityValue(t) { if (t.travelTimeSeconds != null && Number.isFinite(t.travelTimeSeconds)) { return t.travelTimeSeconds; } - return t.distanceMeters; + return t.distanceMeters ?? Infinity; } /** @@ -212,6 +212,9 @@ function proximityValue(t) { * @returns {string} */ function fmtProximity(t) { + if (t.distanceMeters == null || !Number.isFinite(t.distanceMeters)) { + return 'distance unknown'; + } const distKm = (t.distanceMeters / 1000).toFixed(1); if (t.travelTimeSeconds != null && Number.isFinite(t.travelTimeSeconds)) { const totalMin = Math.round(t.travelTimeSeconds / 60); diff --git a/src/pages/tasking/viewmodels/InstantTask.js b/src/pages/tasking/viewmodels/InstantTask.js index 4001e990..3d032a48 100644 --- a/src/pages/tasking/viewmodels/InstantTask.js +++ b/src/pages/tasking/viewmodels/InstantTask.js @@ -180,12 +180,14 @@ export class InstantTaskViewModel { const hasRoute = cached && cached.travelTimeSeconds != null; // Build summary line — include travel time when available + const noJobLocation = jLat == null || jLon == null; const summaryParts = [ taskingCount + ' tasking(s)', hasRoute ? fmtTime(cached.travelTimeSeconds) : null, hasRoute ? fmtDist(cached.distanceMeters) + ' road' : (distance != null ? fmtDist(distance) : null), backBearing != null ? fmtBearing(backBearing) : null, - distance == null && backBearing == null ? "Location unknown" : null, + noJobLocation ? "No incident location" : + (distance == null && backBearing == null ? "Team location unknown" : null), ].filter(Boolean).join(' • '); // For the suggestion engine: prefer road distance, fall back to haversine diff --git a/src/pages/tasking/viewmodels/Map.js b/src/pages/tasking/viewmodels/Map.js index ee27d198..14967c44 100644 --- a/src/pages/tasking/viewmodels/Map.js +++ b/src/pages/tasking/viewmodels/Map.js @@ -708,11 +708,13 @@ export function MapVM(Lmap, root) { let fromLat = null, fromLng = null; if (team.trackableAssets && team.trackableAssets().length > 0) { const a = team.trackableAssets()[0]; - fromLat = +ko.unwrap(a.latitude); - fromLng = +ko.unwrap(a.longitude); + const aLat = ko.unwrap(a.latitude), aLng = ko.unwrap(a.longitude); + if (aLat != null && aLng != null) { fromLat = +aLat; fromLng = +aLng; } } - const toLat = +ko.unwrap(job.address.latitude); - const toLng = +ko.unwrap(job.address.longitude); + const rawToLat = ko.unwrap(job.address?.latitude); + const rawToLng = ko.unwrap(job.address?.longitude); + const toLat = rawToLat != null ? +rawToLat : NaN; + const toLng = rawToLng != null ? +rawToLng : NaN; if (!(Number.isFinite(fromLat) && Number.isFinite(fromLng) && Number.isFinite(toLat) && Number.isFinite(toLng))) return; @@ -742,11 +744,13 @@ export function MapVM(Lmap, root) { let fromLat = null, fromLng = null; if (tasking.team.trackableAssets && tasking.team.trackableAssets().length > 0) { const a = asset || tasking.team.trackableAssets()[0]; - fromLat = +ko.unwrap(a.latitude); - fromLng = +ko.unwrap(a.longitude); + const aLat = ko.unwrap(a.latitude), aLng = ko.unwrap(a.longitude); + if (aLat != null && aLng != null) { fromLat = +aLat; fromLng = +aLng; } } - const toLat = +ko.unwrap(tasking.job.address.latitude); - const toLng = +ko.unwrap(tasking.job.address.longitude); + const rawToLat = ko.unwrap(tasking.job.address?.latitude); + const rawToLng = ko.unwrap(tasking.job.address?.longitude); + const toLat = rawToLat != null ? +rawToLat : NaN; + const toLng = rawToLng != null ? +rawToLng : NaN; if (!(Number.isFinite(fromLat) && Number.isFinite(fromLng) && Number.isFinite(toLat) && Number.isFinite(toLng))) return; From 5afb4aeb97dfbad4388ca078f9514a015a99a2c9 Mon Sep 17 00:00:00 2001 From: Tim Dykes Date: Thu, 19 Mar 2026 16:50:50 +1100 Subject: [PATCH 7/9] changing HQ flushes sector list out (#344) --- src/pages/tasking/main.js | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/src/pages/tasking/main.js b/src/pages/tasking/main.js index ff8760e3..8213e982 100644 --- a/src/pages/tasking/main.js +++ b/src/pages/tasking/main.js @@ -817,19 +817,28 @@ function VM() { self.sectorsLoading(true); const t = await getToken(); // blocks here until token is ready BeaconClient.sectors.search(hqs, apiHost, params.userId, t, (res) => { + // Clear stale sectors from previous HQ selection + self.sectorsById.clear(); + self.sectors.removeAll(); + + const returnedIds = new Set(); (res?.Results || []).forEach( (sectorJson) => { - let sector = self.sectorsById.get(sectorJson.Id); - if (sector) { - sector.updateFromJson(sectorJson); - } else { - // new sector - sector = new Sector(sectorJson); - self.sectorsById.set(sector.id(), sector); - self.sectors.push(sector); - } + returnedIds.add(String(sectorJson.Id)); + let sector = new Sector(sectorJson); + self.sectorsById.set(sector.id(), sector); + self.sectors.push(sector); } ); + + // Remove any active sector filters that no longer exist + const staleFilters = (self.config.sectorFilters() || []).filter( + sf => !returnedIds.has(String(sf.id)) + ); + if (staleFilters.length > 0) { + self.config.sectorFilters.removeAll(staleFilters); + } + self.sectorsLoading(false); }, (count, total) => { if (count != -1 && total != -1) { From 553a86b7ea4721f89a6f8b9baf65498e4fdf5896 Mon Sep 17 00:00:00 2001 From: Tim Dykes Date: Thu, 19 Mar 2026 21:30:32 +1100 Subject: [PATCH 8/9] allow sectors on teams (#345) --- src/pages/tasking/main.js | 28 +++++++++---- src/pages/tasking/models/Team.js | 9 ++++ src/pages/tasking/viewmodels/Config.js | 52 +++++++++++++++++++++-- static/pages/tasking.html | 58 +++++++++++--------------- 4 files changed, 102 insertions(+), 45 deletions(-) diff --git a/src/pages/tasking/main.js b/src/pages/tasking/main.js index 8213e982..d7e81369 100644 --- a/src/pages/tasking/main.js +++ b/src/pages/tasking/main.js @@ -661,17 +661,20 @@ function VM() { return ko.utils.arrayFilter(this.jobs(), jb => { const statusName = jb.statusName(); const jobHqId = String(jb.entityAssignedTo.id()); - const sectorId = String(jb.sector().id()); const hqMatch = hqIds.size === 0 || hqIds.has(jobHqId); - const sectorMatch = sectorIds.size === 0 || sectorIds.has(sectorId); - //must match sector filter - //if no sector and config says to exclude, filter out - if (!jb.sector().id() && self.config.includeIncidentsWithoutSector() === false) { - return false; - } + // Sector filtering — only when scope includes incidents + if (self.config.applySectorsToIncidents() && sectorIds.size > 0) { + const sectorId = String(jb.sector().id()); + const sectorMatch = sectorIds.has(sectorId); + + //if no sector and config says to exclude, filter out + if (!jb.sector().id() && self.config.includeIncidentsWithoutSector() === false) { + return false; + } - if (jb.sector().id() && !sectorMatch) return false; + if (jb.sector().id() && !sectorMatch) return false; + } // If allow-list non-empty, only show jobs whose status is in it if (allowedStatusSet.size > 0 && !allowedStatusSet.has(statusName)) { @@ -728,6 +731,8 @@ function VM() { const allowed = self.config.teamStatusFilter(); // allow-list const allowedSet = new Set(allowed || []); const hqFilterIds = new Set((self.config.teamFilters() || []).map(f => String(f.id))); + const applySectorsToTeams = self.config.applySectorsToTeams(); + const sectorIds = new Set((self.config.sectorFilters() || []).map(s => String(s.id))); var start = new Date(); var end = new Date(); @@ -759,6 +764,13 @@ function VM() { return false; } + // Sector filtering — only when scope includes teams + if (applySectorsToTeams && sectorIds.size > 0) { + const teamSectorId = String(tm.sector()?.id?.() || ''); + if (teamSectorId && !sectorIds.has(teamSectorId)) return false; + if (!teamSectorId && self.config.includeIncidentsWithoutSector() === false) return false; + } + const statusDate = tm.statusDate(); if (statusDate < start || statusDate > end) { return false; diff --git a/src/pages/tasking/models/Team.js b/src/pages/tasking/models/Team.js index d9129860..b61b38cd 100644 --- a/src/pages/tasking/models/Team.js +++ b/src/pages/tasking/models/Team.js @@ -2,6 +2,7 @@ import ko from "knockout"; import { Entity } from "./Entity.js"; +import { Sector } from "./Sector.js"; import { openURLInBeacon } from '../utils/chromeRunTime.js'; @@ -63,6 +64,7 @@ export function Team(data = {}, deps = {}) { self.callsign = ko.observable(data.Callsign ?? ""); self.assignedTo = ko.observable(new Entity(data.AssignedTo || data.CreatedAt)); //safety code for beacon bug self.teamStatusType = ko.observable(data.TeamStatusType || null); // {Id,Name,Description} + self.sector = ko.observable(new Sector(data.Sector || {})); self.members = ko.observableArray(data.Members); self.taskedJobCount = ko.observable(data.TaskedJobCount || 0); self.teamLeader = ko.computed(function () { @@ -486,6 +488,13 @@ export function Team(data = {}, deps = {}) { if (d.TeamStatusType !== undefined) this.teamStatusType(d.TeamStatusType); if (d.Members !== undefined) this.members(d.Members); if (d.AssignedTo !== undefined && d.CreatedAt !== undefined) this.assignedTo(new Entity(d.AssignedTo || d.CreatedAt)); //safety for beacon bug + if (d.Sector !== undefined) { + if (d.Sector === null) { + this.sector(new Sector({})); + } else { + this.sector().updateFromJson(d.Sector); + } + } if (d.statusId !== undefined) this.updateStatusById(d.statusId); if (d.TeamStatusStartDate !== undefined) this.statusDate(new Date(d.TeamStatusStartDate)); } diff --git a/src/pages/tasking/viewmodels/Config.js b/src/pages/tasking/viewmodels/Config.js index 43e56f6c..7899759a 100644 --- a/src/pages/tasking/viewmodels/Config.js +++ b/src/pages/tasking/viewmodels/Config.js @@ -40,6 +40,8 @@ export function ConfigVM(root, deps) { //Sectors self.sectorFilters = ko.observableArray([]); // [{id, name}] self.includeIncidentsWithoutSector = ko.observable(true); + self.applySectorsToIncidents = ko.observable(true); + self.applySectorsToTeams = ko.observable(false); //Map layer order @@ -213,6 +215,8 @@ export function ConfigVM(root, deps) { teamTaskStatusFilter: ko.toJS(self.teamTaskStatusFilter), sectorFilters: ko.toJS(self.sectorFilters), includeIncidentsWithoutSector: !!self.includeIncidentsWithoutSector(), + applySectorsToIncidents: !!self.applySectorsToIncidents(), + applySectorsToTeams: !!self.applySectorsToTeams(), pinnedTeamIds: ko.toJS(self.pinnedTeamIds), pinnedIncidentIds: ko.toJS(self.pinnedIncidentIds), paneOrder: self.paneOrder().map(p => p.id), @@ -437,6 +441,8 @@ export function ConfigVM(root, deps) { cfg.teamTaskStatusFilter = self.teamTaskStatusFilterDefaults; cfg.sectorFilters = []; cfg.includeIncidentsWithoutSector = true; + cfg.applySectorsToIncidents = true; + cfg.applySectorsToTeams = false; cfg.pinnedTeamIds = []; cfg.pinnedIncidentIds = []; @@ -474,6 +480,12 @@ export function ConfigVM(root, deps) { if (typeof cfg.includeIncidentsWithoutSector === 'boolean') { self.includeIncidentsWithoutSector(cfg.includeIncidentsWithoutSector); } + if (typeof cfg.applySectorsToIncidents === 'boolean') { + self.applySectorsToIncidents(cfg.applySectorsToIncidents); + } + if (typeof cfg.applySectorsToTeams === 'boolean') { + self.applySectorsToTeams(cfg.applySectorsToTeams); + } // filters if (cfg.locationFilters) { @@ -636,8 +648,33 @@ export function ConfigVM(root, deps) { self.loadShared(id); }; + /** + * Collect the HQ IDs relevant for sector lookup based on which + * scope toggles are active (incidents, teams, or both). + * @returns {Array} + */ + self._sectorHqIds = () => { + const ids = new Set(); + if (self.applySectorsToIncidents()) { + (self.incidentFilters() || []).forEach(f => ids.add(f.id)); + } + if (self.applySectorsToTeams()) { + (self.teamFilters() || []).forEach(f => ids.add(f.id)); + } + return [...ids]; + }; + + /** Trigger a sector refresh using the current scope-aware HQ list. */ + self._refreshSectors = () => { + if (self._suppressSectorRefresh) return; + if (!self.applySectorsToIncidents() && !self.applySectorsToTeams()) return; + const ids = self._sectorHqIds(); + if (ids.length === 0) return; // no HQs selected — nothing to search + deps.fetchAllSectors(ids); + }; + self.afterConfigLoad = () => { - deps.fetchAllSectors(self.incidentFilters().map(i => i.id)); + self._refreshSectors(); root.mapVM?.applyPaneOrder?.(self.paneOrder().map(p => p.id)); root.mapVM?.applyClusterRadius?.(Number(self.clusterRadius()) || 60); root.mapVM?.applyClusterEnabled?.(!!self.clusterEnabled()); @@ -650,13 +687,22 @@ export function ConfigVM(root, deps) { } - // run once on construction + // run once on construction — suppress sector refresh until afterConfigLoad + self._suppressSectorRefresh = true; self.loadFromStorage() + self._suppressSectorRefresh = false; self.incidentFilters.subscribe(() => { - deps.fetchAllSectors(self.incidentFilters().map(i => i.id)); + self._refreshSectors(); }, null, "arrayChange"); + self.teamFilters.subscribe(() => { + self._refreshSectors(); + }, null, "arrayChange"); + + self.applySectorsToIncidents.subscribe(() => self._refreshSectors()); + self.applySectorsToTeams.subscribe(() => self._refreshSectors()); + self.includeIncidentsWithoutSector.subscribe(() => { root.fetchAllJobsData(); }) diff --git a/static/pages/tasking.html b/static/pages/tasking.html index dd9c0b60..1fb9350a 100644 --- a/static/pages/tasking.html +++ b/static/pages/tasking.html @@ -894,35 +894,6 @@
    - -
  • - -
    -
    - - -
    -
    -
    - - -
    -
    -
    -

      • + data-bind="foreach: { data: trackableAssetEntries, as: 'entry' }">
    • - + +
      @@ -3302,7 +3314,7 @@
      @@ -3376,10 +3388,10 @@
      Action Items
    Subject
    -
    Text
    -
    diff --git a/styles/pages/darkmode.css b/styles/pages/darkmode.css index 12846812..979ae719 100644 --- a/styles/pages/darkmode.css +++ b/styles/pages/darkmode.css @@ -765,6 +765,16 @@ body.dark-mode .team-asset-row { color: #e0e0e0; } +body.dark-mode .team-asset-row button.asset-flyto-btn { + background: transparent; + border-color: #555; + color: #e0e0e0; +} + +body.dark-mode .team-asset-row button.asset-flyto-btn:hover { + background-color: rgba(255, 255, 255, 0.08); +} + /* Job popup taskings table */ body.dark-mode .job-popup, body.dark-mode .job-popup #JobDetails, diff --git a/styles/pages/tasking.css b/styles/pages/tasking.css index ba3907a9..99358112 100644 --- a/styles/pages/tasking.css +++ b/styles/pages/tasking.css @@ -990,6 +990,33 @@ tr.job:hover { border-bottom: none; } +/* Matched-asset flyTo button */ +.team-asset-row button.asset-flyto-btn { + background: transparent; + border: 1px solid #ccc; + border-radius: 4px; + padding: 2px 6px; + text-align: left; + cursor: pointer; + color: inherit; + transition: background-color 0.15s; +} +.team-asset-row button.asset-flyto-btn:hover { + background-color: rgba(0, 0, 0, 0.06); +} + +/* Default-asset star toggle */ +.default-asset-btn { + font-size: 0.85rem; + line-height: 1; + cursor: pointer; + opacity: 0.7; + transition: opacity 0.15s; +} +.default-asset-btn:hover { + opacity: 1; +} + /* Base Leaflet divIcon wrapper for your SVG markers */ .leaflet-marker-icon.job-svg-marker { display: block; /* kill inline baseline spacing */