Upload via GUI (23 Dateien)

chrome-erweiterung/README.md

@@ -9,6 +9,7 @@ DeskHub in der Browserleiste: **Tickets lesen und beantworten**, Aufgaben, eigen
 - **Ticket-Ansicht direkt in der Erweiterung:** Verlauf als Chat (Kunde, Mitarbeiter, interne Notizen, Kommentare, Anhänge), **Antworten** (mit Textbausteinen, Signatur-Auswahl und Status nach dem Senden), **interne Notiz**, **Status ändern** (mit Abschlussgrund), **zuweisen** (auch „Mir zuweisen“), **Wiedervorlage**, **Beobachten**, Ticket im Browser öffnen. Strg+Enter sendet. Ein angefangener Text bleibt als Entwurf erhalten, auch wenn sich das Popup schließt.
 - **Aufgaben:** meine, alle offenen, erledigte; abhaken, neue Aufgabe mit Fälligkeit, Bearbeiter und Ticket, löschen.
 - **Neu:** Ticket anlegen (Anfrager, Betreff, Beschreibung, Abteilung, Priorität, Bearbeiter, Kunden benachrichtigen).
+- **Update-Hinweis:** Alle 6 Stunden fragt die Erweiterung den Server, ob in der Plugin-Webseite eine neuere Version liegt, und zeigt dann eine Benachrichtigung und auf der Startseite einen Hinweis mit Weg zur Download-Seite.
 - **Mehr:** Konto, Meldungen einzeln ein-/ausschalten, Darstellung (automatisch, hell, dunkel), Team-Übersicht mit Status, Weboberfläche öffnen, Abmelden.
 - **Seitenleiste:** Das Symbol oben rechts im Popup öffnet DeskHub in der Seitenleiste von Chrome (bleibt offen, volle Höhe). Alternativ als eigenes Fenster.
 - **Zähler und Benachrichtigungen:** Jede Minute fragt die Erweiterung den Server nach Neuem; die Zahl am Symbol zählt, was seit dem letzten Öffnen dazugekommen ist.

chrome-erweiterung/app.js

@@ -71,7 +71,7 @@ async function navigate(view, p = {}) {
 
   const nav = h('nav', { class: 'nav', 'aria-label': 'Hauptmenü' }, TABS.map(([key, label, ic]) => h('button', { class: key === activeTab ? 'on' : '', onclick: () => ctx.go(key), 'aria-label': label }, icon(ic, 20), label)));
   app.replaceChildren(header, content, nav);
-  chrome.runtime.sendMessage({ type: 'reset-badge' }).catch(() => {});
+  chrome.runtime.sendMessage({ type: 'poll-now' }).catch(() => {}); // Zähler aktualisieren (zum Beispiel nach dem Öffnen eines Tickets)
   try { await VIEWS[view]?.(body, ctx, p); } catch (e) { body.replaceChildren(h('div', { class: 'msg err', role: 'alert' }, errText(e))); }
 }
 

chrome-erweiterung/background.js

@@ -1,8 +1,9 @@
 // Hintergrunddienst: prüft jede Minute auf Neues, zeigt Zähler und Benachrichtigungen, Rechtsklick-Menü,
 // Tastenkürzel und die Adressleisten-Suche („dh“ + Leertaste).
-import { apiCall, getSession, getSettings, truncate } from './lib/core.js';
+import { apiCall, getSession, getSettings, truncate, checkForExtensionUpdate } from './lib/core.js';
 
 const ALARM = 'deskhub-poll';
+const UPDATE_ALARM = 'deskhub-update';
 const MENU = 'deskhub-create';
 const APP = 'app.html';
 
@@ -12,7 +13,22 @@ async function setBadge(count, color = '#0f766e') {
 }
 
 async function ensureAlarm() {
-  if (!(await chrome.alarms.get(ALARM))) chrome.alarms.create(ALARM, { periodInMinutes: 1, delayInMinutes: 0.1 });
+  // Alle 30 Sekunden (Chrome erlaubt das ab Version 120, ältere runden auf eine Minute); eine ältere Uhr mit anderem Takt wird ersetzt
+  const current = await chrome.alarms.get(ALARM);
+  if (!current || current.periodInMinutes !== 0.5) chrome.alarms.create(ALARM, { periodInMinutes: 0.5, delayInMinutes: 0.1 });
+  if (!(await chrome.alarms.get(UPDATE_ALARM))) chrome.alarms.create(UPDATE_ALARM, { periodInMinutes: 360, delayInMinutes: 1 });
+}
+
+/** Neue Version der Erweiterung? Einmal pro Version eine Benachrichtigung, der Hinweis steht außerdem auf der Startseite. */
+export async function checkUpdate(force = false) {
+  const info = await checkForExtensionUpdate({ force });
+  if (!info) return null;
+  const { updateNotified } = await chrome.storage.local.get('updateNotified');
+  if (updateNotified !== info.version) {
+    await chrome.storage.local.set({ updateNotified: info.version });
+    chrome.notifications.create('deskhub-update', { type: 'basic', iconUrl: 'icons/icon128.png', title: 'DeskHub-Erweiterung', message: `Version ${info.version} ist verfügbar. Auf der Startseite der Erweiterung steht, wie du sie bekommst.` });
+  }
+  return info;
 }
 async function ensureSetup() {
   await ensureAlarm();
@@ -24,16 +40,39 @@ async function ensureSetup() {
 ensureAlarm();
 
 chrome.runtime.onInstalled.addListener(ensureSetup);
-chrome.runtime.onStartup.addListener(async () => { await ensureSetup(); poll(); });
+chrome.runtime.onStartup.addListener(async () => { await ensureSetup(); poll(); checkUpdate(); });
 
-/** Fragt den Server nach Neuem seit dem letzten Mal. Merkt sich die Serverzeit als Bezugspunkt (kein Uhrzeit-Abgleich mit dem PC nötig). */
+/**
+ * Fragt den Server nach dem echten Stand: Der Zähler zeigt, wie viele Tickets jetzt Aufmerksamkeit brauchen (offen, dir zugewiesen oder noch
+ * niemandem, seit der letzten Kundennachricht nicht geöffnet). Wird ein Ticket geöffnet, beantwortet oder übernommen, sinkt er beim nächsten
+ * Abruf von selbst, auch wenn das in der Weboberfläche oder im Windows-Programm geschah. Benachrichtigt wird nur für Tickets, die neu dazukommen.
+ * Ältere Server ohne diese Angabe liefern nur „seit dem letzten Mal“: Dafür bleibt die frühere, aufsummierende Zählung als Rückfall.
+ */
 export async function poll() {
   const session = await getSession();
   if (!session) { await setBadge(0); return { skipped: true }; }
-  const { lastSeen, badgeCount = 0 } = await chrome.storage.local.get(['lastSeen', 'badgeCount']);
+  const { lastSeen, badgeCount = 0, knownIds = null } = await chrome.storage.local.get(['lastSeen', 'badgeCount', 'knownIds']);
   try {
     const { data } = await apiCall('activity.php', { query: lastSeen ? { since: lastSeen } : {} });
     const settings = await getSettings();
+    if (data.attention && Array.isArray(data.attention.unassigned) && Array.isArray(data.attention.mine)) {
+      const unassigned = settings.notifyUnassigned ? data.attention.unassigned : [];
+      const mine = settings.notifyMine ? data.attention.mine : [];
+      const known = new Set(knownIds || []);
+      const freshUnassigned = knownIds === null ? 0 : unassigned.filter((id) => !known.has(id)).length;
+      const freshMine = knownIds === null ? 0 : mine.filter((id) => !known.has(id)).length;
+      const ids = [...unassigned, ...mine];
+      await chrome.storage.local.set({ lastSeen: data.serverTime, badgeCount: ids.length, knownIds: ids });
+      await setBadge(ids.length);
+      const fresh = freshUnassigned + freshMine;
+      if (fresh > 0 && settings.notifications) {
+        const parts = [];
+        if (freshUnassigned) parts.push(`${freshUnassigned} neu und nicht zugewiesen`);
+        if (freshMine) parts.push(`${freshMine} Aktualisierung${freshMine === 1 ? '' : 'en'} bei deinen Tickets`);
+        chrome.notifications.create('deskhub-new', { type: 'basic', iconUrl: 'icons/icon128.png', title: 'DeskHub', message: parts.join(', '), priority: 1 });
+      }
+      return { fresh, total: ids.length };
+    }
     const unassigned = settings.notifyUnassigned ? data.newUnassigned || 0 : 0;
     const replies = settings.notifyMine ? data.newReplies || 0 : 0;
     const fresh = unassigned + replies;
@@ -58,7 +97,7 @@ export async function poll() {
   }
 }
 
-chrome.alarms.onAlarm.addListener((alarm) => { if (alarm.name === ALARM) poll(); });
+chrome.alarms.onAlarm.addListener((alarm) => { if (alarm.name === ALARM) poll(); else if (alarm.name === UPDATE_ALARM) checkUpdate(); });
 
 const openWindow = (query = '') => chrome.windows.create({ url: chrome.runtime.getURL(`${APP}?mode=window${query}`), type: 'popup', width: 460, height: 760 });
 
@@ -98,10 +137,12 @@ chrome.notifications.onClicked.addListener(async (id) => {
 
 chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
   (async () => {
-    if (msg?.type === 'reset-badge') { await chrome.storage.local.set({ badgeCount: 0 }); await setBadge(0); sendResponse({ ok: true }); }
+    // Der Zähler wird nicht mehr beim Öffnen geleert: Er folgt dem Stand auf dem Server. „reset-badge“ (ältere Fenster) fragt deshalb nur neu ab.
+    if (msg?.type === 'reset-badge') sendResponse(await poll());
     else if (msg?.type === 'poll-now') sendResponse(await poll());
+    else if (msg?.type === 'check-update') sendResponse({ update: await checkUpdate(true) });
     else if (msg?.type === 'presence') { await apiCall('presence.php', { method: 'POST', body: {} }).catch(() => {}); sendResponse({ ok: true }); }
-    else if (msg?.type === 'session-changed') { await ensureAlarm(); await chrome.storage.local.remove(['lastSeen', 'badgeCount']); await setBadge(0); sendResponse(await poll()); }
+    else if (msg?.type === 'session-changed') { await ensureAlarm(); await chrome.storage.local.remove(['lastSeen', 'badgeCount', 'knownIds']); await setBadge(0); sendResponse(await poll()); }
     else sendResponse({ ok: false });
   })().catch((e) => { try { sendResponse({ error: (e && e.code) || 'ERROR' }); } catch { /* Fenster schon zu */ } });
   return true; // Antwort kommt asynchron

chrome-erweiterung/lib/core.js

@@ -134,6 +134,41 @@ export async function openWeb(path) {
   return chrome.tabs.create({ url: u.href });
 }
 
+/** Vergleicht zwei Versionsnummern ("2.0.0" gegen "2.1"): negativ, null oder positiv. Nicht-Zahlen zählen als 0. */
+export function compareVersions(a, b) {
+  const pa = String(a).split(/[.+-]/).map((x) => parseInt(x, 10) || 0);
+  const pb = String(b).split(/[.+-]/).map((x) => parseInt(x, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length, 3); i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+
+const UPDATE_CHECK_EVERY_MS = 6 * 3600 * 1000;
+
+/**
+ * Fragt den Server, ob es eine neuere Version dieser Erweiterung gibt (die Plugin-Webseite liefert sie über DeskHub). Das Ergebnis steht
+ * in storage.local unter "update": { version, notes, size, checkedAt } oder null, wenn die Erweiterung aktuell ist. Höchstens alle 6 Stunden,
+ * außer mit force. Netzwerkfehler ändern nichts.
+ */
+export async function checkForExtensionUpdate({ force = false } = {}) {
+  const session = await getSession();
+  if (!session) return null;
+  const { update, updateCheckedAt = 0 } = await chrome.storage.local.get(['update', 'updateCheckedAt']);
+  if (!force && Date.now() - updateCheckedAt < UPDATE_CHECK_EVERY_MS) return update || null;
+  try {
+    const { data } = await apiCall('app_update.php', { query: { platform: 'chrome' } });
+    const current = chrome.runtime.getManifest().version;
+    const newer = data?.available && data.version && compareVersions(data.version, current) > 0;
+    const info = newer ? { version: String(data.version), notes: String(data.notes || ''), size: Number(data.size) || 0, checkedAt: Date.now() } : null;
+    await chrome.storage.local.set({ update: info, updateCheckedAt: Date.now() });
+    return info;
+  } catch {
+    return update || null; // Fehler: beim nächsten Mal erneut
+  }
+}
+
 /** Maskiert Text und macht Zeilenumbrüche zu <br>: Der Server nimmt Ticket-Nachrichten als HTML an und bereinigt sie zusätzlich. */
 export function plainToHtml(text) {
   return String(text ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\r\n|\r|\n/g, '<br>');

chrome-erweiterung/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "DeskHub",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "DeskHub in der Browserleiste: Tickets lesen und beantworten, Aufgaben, Status, Benachrichtigungen und schnell ein Ticket anlegen.",
   "minimum_chrome_version": "116",
   "icons": { "16": "icons/icon16.png", "32": "icons/icon32.png", "48": "icons/icon48.png", "128": "icons/icon128.png" },

chrome-erweiterung/test/core.test.mjs

@@ -30,7 +30,7 @@ function makeChrome() {
     notifications: { create(id, o) { calls.notifications.push({ id, ...o }); }, clear() {}, onClicked: listener() },
     alarms: { async get() { return null; }, create() {}, onAlarm: listener() },
     contextMenus: { removeAll(cb) { cb?.(); }, create(o) { calls.menus.push(o); }, onClicked: listener() },
-    runtime: { onInstalled: listener(), onStartup: listener(), onMessage: listener(), getURL: (p) => 'chrome-extension://x/' + p, async sendMessage() { return {}; } },
+    runtime: { getManifest: () => ({ version: '2.0.0' }), onInstalled: listener(), onStartup: listener(), onMessage: listener(), getURL: (p) => 'chrome-extension://x/' + p, async sendMessage() { return {}; } },
   };
   return { chromeMock, store, calls };
 }
@@ -287,3 +287,97 @@ test('Manifest: Serverzugriff ohne Rückfrage, nur nötige Rechte, strenge Inhal
   assert.doesNotMatch(m.content_security_policy.extension_pages, /unsafe-inline|unsafe-eval/);
   for (const f of Object.values(m.icons)) await readFile(new URL('../' + f, import.meta.url));
 });
+
+test('Versionen vergleichen', async () => {
+  const { compareVersions } = await fresh();
+  assert.ok(compareVersions('2.1.0', '2.0.0') > 0);
+  assert.ok(compareVersions('2.0.10', '2.0.9') > 0, 'Zahlen, nicht Text');
+  assert.equal(compareVersions('2.0', '2.0.0'), 0);
+  assert.ok(compareVersions('2.0.0', '2.0.1') < 0);
+  assert.ok(compareVersions('10.0.0', '9.9.9') > 0);
+  assert.equal(compareVersions('2.0.0-beta', '2.0.0'), 0, 'Zusätze zählen nicht');
+});
+
+test('Update-Prüfung: neuere Version wird gemerkt, aktuelle nicht, höchstens alle 6 Stunden', async () => {
+  const { checkForExtensionUpdate, setSession } = await fresh();
+  // ohne Anmeldung nichts
+  globalThis.fetch = makeFetch({});
+  assert.equal(await checkForExtensionUpdate(), null);
+  assert.equal(globalThis.fetch.log.length, 0);
+  await setSession(SESSION);
+  let version = '2.1.0';
+  globalThis.fetch = makeFetch({ 'GET app_update.php': () => ({ body: { available: true, platform: 'chrome', version, sha256: 'x', size: 35609, notes: 'Neues Design' } }) });
+  const info = await checkForExtensionUpdate();
+  assert.equal(info.version, '2.1.0'); assert.equal(info.notes, 'Neues Design');
+  assert.equal(globalThis.fetch.log[0].url.searchParams.get('platform'), 'chrome');
+  assert.equal(env.store.update.version, '2.1.0');
+  // zweiter Aufruf direkt danach fragt den Server nicht noch einmal
+  await checkForExtensionUpdate();
+  assert.equal(globalThis.fetch.log.length, 1);
+  // mit force und inzwischen gleicher Version: kein Hinweis mehr
+  version = '2.0.0';
+  assert.equal(await checkForExtensionUpdate({ force: true }), null);
+  assert.equal(env.store.update, null);
+  // Serverfehler lassen den bisherigen Stand unverändert
+  version = '2.5.0';
+  await checkForExtensionUpdate({ force: true });
+  globalThis.fetch = async () => { throw new TypeError('fail'); };
+  const again = await checkForExtensionUpdate({ force: true });
+  assert.equal(again.version, '2.5.0', 'bei einem Netzwerkfehler bleibt der letzte Stand');
+  // keine Version veröffentlicht
+  globalThis.fetch = makeFetch({ 'GET app_update.php': { body: { available: false, platform: 'chrome' } } });
+  assert.equal(await checkForExtensionUpdate({ force: true }), null);
+});
+
+// ── Zähler nach echtem Stand (neuer Server) ───────────────────────────────────
+test('Zähler: zeigt den echten Stand, erster Abruf meldet nichts', async () => {
+  const { core, bg } = await freshBackground();
+  await core.setSession(SESSION);
+  globalThis.fetch = makeFetch({ 'GET activity.php': { body: { newReplies: 0, newUnassigned: 0, attention: { unassigned: [5], mine: [7] }, serverTime: 't1' } } });
+  const r = await bg.poll();
+  assert.equal(env.calls.badge.text, '2');
+  assert.equal(r.total, 2); assert.equal(r.fresh, 0);
+  assert.equal(env.calls.notifications.length, 0, 'beim ersten Abruf (Bezugspunkt) keine Meldung');
+});
+
+test('Zähler: sinkt von selbst, wenn das Ticket anderswo bearbeitet wurde, und bleibt nicht stehen', async () => {
+  const { core, bg } = await freshBackground();
+  await core.setSession(SESSION);
+  await chrome.storage.local.set({ lastSeen: 't0', knownIds: [5], badgeCount: 1 });
+  globalThis.fetch = makeFetch({ 'GET activity.php': { body: { newReplies: 1, newUnassigned: 0, attention: { unassigned: [], mine: [] }, serverTime: 't2' } } });
+  const r = await bg.poll();
+  assert.equal(env.calls.badge.text, '', 'kein Ticket braucht mehr Aufmerksamkeit: Zähler leer');
+  assert.equal(r.total, 0); assert.equal(r.fresh, 0);
+  assert.deepEqual((await chrome.storage.local.get('knownIds')).knownIds, []);
+});
+
+test('Zähler: meldet nur Tickets, die neu dazukommen, nicht schon bekannte', async () => {
+  const { core, bg } = await freshBackground();
+  await core.setSession(SESSION);
+  await chrome.storage.local.set({ lastSeen: 't0', knownIds: [5, 7] });
+  globalThis.fetch = makeFetch({ 'GET activity.php': { body: { attention: { unassigned: [9, 5], mine: [7, 11] }, serverTime: 't3' } } });
+  const r = await bg.poll();
+  assert.equal(r.total, 4); assert.equal(r.fresh, 2);
+  assert.equal(env.calls.badge.text, '4');
+  assert.match(env.calls.notifications[0].message, /1 neu und nicht zugewiesen, 1 Aktualisierung bei deinen Tickets/);
+  env.calls.notifications.length = 0;
+  const r2 = await bg.poll();
+  assert.equal(r2.fresh, 0); assert.equal(env.calls.notifications.length, 0, 'gleicher Stand: keine zweite Meldung');
+});
+
+test('Zähler: Meldungsarten schalten auch den Zähler ab', async () => {
+  const { core, bg } = await freshBackground();
+  await core.setSession(SESSION); await core.setSettings({ notifyUnassigned: false });
+  globalThis.fetch = makeFetch({ 'GET activity.php': { body: { attention: { unassigned: [1, 2, 3], mine: [4] }, serverTime: 't' } } });
+  await bg.poll();
+  assert.equal(env.calls.badge.text, '1');
+});
+
+test('Zähler: wiederholte Abfragen ändern einen unveränderten Stand nicht (nichts wird nebenbei geleert)', async () => {
+  const { core, bg } = await freshBackground();
+  await core.setSession(SESSION);
+  await chrome.storage.local.set({ lastSeen: 't0', knownIds: [5, 6], badgeCount: 2 });
+  globalThis.fetch = makeFetch({ 'GET activity.php': { body: { attention: { unassigned: [5, 6], mine: [] }, serverTime: 't4' } } });
+  for (let i = 0; i < 3; i++) { const r = await bg.poll(); assert.equal(r.total, 2); assert.equal(r.fresh, 0); }
+  assert.equal(env.calls.badge.text, '2');
+});

chrome-erweiterung/views/home.js

@@ -1,6 +1,6 @@
 // Start: Begrüßung, eigener Status, Kennzahlen, als Nächstes fällige Tickets.
 import { h, clear, icon, toast, errText } from '../lib/dom.js';
-import { apiCall, AVAILABILITY } from '../lib/core.js';
+import { apiCall, AVAILABILITY, openWeb, compareVersions } from '../lib/core.js';
 import { spinner, ticketList, showError, segmented } from '../lib/ui.js';
 
 export async function renderHome(host, ctx) {
@@ -15,6 +15,17 @@ export async function renderHome(host, ctx) {
     const stack = h('div', { class: 'stack' });
     stack.append(h('div', {}, h('div', { class: 'muted' }, new Date().toLocaleDateString('de-DE', { weekday: 'long', day: 'numeric', month: 'long' })), h('div', { class: 'hello' }, `Hallo ${first || ''}`.trim())));
 
+    // Neue Version der Erweiterung: Hinweis mit Weg zum Download (die Seite „Apps“ der Weboberfläche)
+    try {
+      const { update } = await chrome.storage.local.get('update');
+      if (update && compareVersions(update.version, chrome.runtime.getManifest().version) > 0) {
+        stack.append(h('div', { class: 'card' }, h('h2', {}, `Update verfügbar: ${update.version}`),
+          h('div', { class: 'muted' }, 'Eine neuere Version der Erweiterung liegt bereit. Auf der Seite „Apps“ laden, entpacken und unter chrome://extensions neu laden.'),
+          update.notes ? h('div', { class: 'muted', style: { marginTop: '6px', whiteSpace: 'pre-wrap' } }, update.notes) : null,
+          h('div', { style: { marginTop: '8px' } }, h('button', { class: 'btn', onclick: () => openWeb('/staff/apps.php').catch((e) => toast(errText(e), 'err')) }, 'Download-Seite öffnen'))));
+      }
+    } catch { /* ohne Hinweis weiter */ }
+
     if (avail) {
       let current = avail.myStatus;
       const holder = h('div');