Translated using Weblate (Ukrainian)

Currently translated at 45.1% (130 of 288 strings)

Translation: Homepage/Homepage
Translate-URL: https://hosted.weblate.org/projects/homepage/homepage/uk/

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -68,9 +68,20 @@ body:
     id: browser-logs
     attributes:
       label: Browser Logs
-      description: Please review and provide any relevant logs from the browser, if relevant
+      description: Please review and provide any logs from the browser, if relevant
   - type: textarea
     id: other
     attributes:
       label: Other
-      description: Any other relevant details. E.g. service version or API version, docker version, etc.
+      description: Please include output from your troubleshooting tests, if relevant. Include any other relevant details. E.g. service version or API version, docker version, etc.
+  - type: checkboxes
+    id: pre-flight
+    attributes:
+      label: Before submitting, I have made sure to
+      options:
+        - label: Check [the documentation](https://gethomepage.dev/)
+          required: true
+        - label: Follow [the troubleshooting guide](https://gethomepage.dev/en/more/troubleshooting/) (please include output above if applicable).
+          required: true
+        - label: Search [existing issues](https://github.com/benphelps/homepage/search?q=&type=issues) and [discussions](https://github.com/benphelps/homepage/search?q=&type=discussions).
+          required: true

.gitignore

@@ -41,3 +41,8 @@ next-env.d.ts
 
 # homepage
 /config
+
+# IDEs
+/.idea/
+
+

README.md

@@ -47,12 +47,12 @@
 - Service Integration
   - Sonarr, Radarr, Readarr, Prowlarr, Bazarr, Lidarr, Emby, Jellyfin, Tautulli (Plex)
   - Ombi, Overseerr, Jellyseerr, Jackett, NZBGet, SABnzbd, ruTorrent, Transmission, qBittorrent
-  - Portainer, Traefik, Speedtest Tracker, PiHole, AdGuard Home, Nginx Proxy Manager, Gotify, Syncthing Relay Server, Authentic, Proxmox
+  - Portainer, Traefik, Speedtest Tracker, PiHole, AdGuard Home, Nginx Proxy Manager, Gotify, Syncthing Relay Server, Authentik, Proxmox
 - Information Providers
   - Coin Market Cap, Mastodon
 - Information & Utility Widgets
   - System Stats (Disk, CPU, Memory)
-  - Weather via WeatherAPI.com or OpenWeatherMap
+  - Weather via [OpenWeatherMap](https://openweathermap.org/) or [Open-Meteo](https://open-meteo.com/)
   - Search Bar
 - Customizable
   - 21 theme colors with light and dark mode support
@@ -117,7 +117,7 @@ pnpm start
 
 ## Configuration
 
-Configuration files will be genereted and placed on the first request.
+Configuration files will be generated and placed on the first request.
 
 Configuration is done in the /config directory using .yaml files. Refer to each config for
 the specific configuration options.

next-i18next.config.js

@@ -98,20 +98,21 @@ module.exports = {
         );
 
         i18next.services.formatter.add("rate", (value, lng, options) => {
-          if (value === 0) return "0 Bps";
 
-          const bits = options.bits ? value : value / 8;
-          const k = 1024;
+          const k = options.binary ? 1024 : 1000;
+          const sizes = options.bits ? (options.binary ? BIBIT_UNITS : BIT_UNITS) : (options.binary ? BIBYTE_UNITS : BYTE_UNITS);
+
+          if (value === 0) return `0 ${sizes[0]}/s`;
+
           const dm = options.decimals ? options.decimals : 0;
-          const sizes = ["Bps", "KiBps", "MiBps", "GiBps", "TiBps", "PiBps", "EiBps", "ZiBps", "YiBps"];
 
-          const i = Math.floor(Math.log(bits) / Math.log(k));
+          const i = options.binary ? 2 : Math.floor(Math.log(value) / Math.log(k));
 
           const formatted = new Intl.NumberFormat(lng, { maximumFractionDigits: dm, minimumFractionDigits: dm }).format(
-            parseFloat(bits / k ** i)
+            parseFloat(value / k ** i)
           );
 
-          return `${formatted} ${sizes[i]}`;
+          return `${formatted} ${sizes[i]}/s`;
         });
 
         i18next.services.formatter.add("percent", (value, lng, options) =>

public/locales/ar/common.json

@@ -193,7 +193,8 @@
     "overseerr": {
         "pending": "Pending",
         "approved": "Approved",
-        "available": "Available"
+        "available": "Available",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Queries",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/bg/common.json

@@ -131,7 +131,8 @@
     "overseerr": {
         "pending": "Pending",
         "approved": "Approved",
-        "available": "Available"
+        "available": "Available",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Queries",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "leech": "Leech",
+        "seed": "Seed",
+        "download": "Download",
+        "upload": "Upload"
+    },
+    "tdarr": {
+        "saved": "Saved",
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/ca/common.json

@@ -3,10 +3,10 @@
         "missing_type": "Falta el tipus de widget: {{type}}",
         "api_error": "Error d'API",
         "status": "Estat",
-        "information": "Information",
+        "information": "Informació",
         "url": "URL",
-        "raw_error": "Raw Error",
-        "response_data": "Response Data"
+        "raw_error": "Error sense processar",
+        "response_data": "Dades de resposta"
     },
     "weather": {
         "allow": "Feu clic per permetre",
@@ -20,8 +20,8 @@
     "transmission": {
         "seed": "Llavors",
         "download": "Descàrrega",
-        "upload": "Càrrega",
-        "leech": "Companys"
+        "upload": "Pujada",
+        "leech": "Company"
     },
     "sonarr": {
         "wanted": "Volgut",
@@ -30,13 +30,13 @@
     },
     "speedtest": {
         "ping": "Ping",
-        "upload": "Càrrega",
+        "upload": "Pujada",
         "download": "Descàrrega"
     },
     "resources": {
         "total": "Total",
         "free": "Lliure",
-        "used": "Usat",
+        "used": "Utilitzat",
         "load": "Càrrega",
         "cpu": "CPU"
     },
@@ -47,13 +47,13 @@
         "cpu": "Processador",
         "offline": "Fora de línia",
         "error": "Error",
-        "unknown": "Unknown"
+        "unknown": "Desconegut"
     },
     "emby": {
         "playing": "Reproduint",
         "transcoding": "Transcodificant",
         "bitrate": "Taxa de bits",
-        "no_active": "Sense transmissions actives"
+        "no_active": "Sense reproduccions actives"
     },
     "tautulli": {
         "playing": "Reproduint",
@@ -73,14 +73,14 @@
     },
     "rutorrent": {
         "active": "Actiu",
-        "upload": "Càrrega",
+        "upload": "Pujada",
         "download": "Descàrrega"
     },
     "radarr": {
         "wanted": "Volgut",
         "queued": "En cua",
         "movies": "Pel·lícules",
-        "missing": "Missing"
+        "missing": "Faltant"
     },
     "readarr": {
         "wanted": "Volgut",
@@ -100,7 +100,8 @@
     "overseerr": {
         "pending": "Pendent",
         "approved": "Aprovat",
-        "available": "Disponible"
+        "available": "Disponible",
+        "processing": "Processant"
     },
     "pihole": {
         "queries": "Consultes",
@@ -162,8 +163,8 @@
     },
     "qbittorrent": {
         "download": "Descàrrega",
-        "upload": "Càrrega",
-        "leech": "Companys",
+        "upload": "Pujada",
+        "leech": "Company",
         "seed": "Llavors"
     },
     "mastodon": {
@@ -183,26 +184,26 @@
         "failedLoginsLast24H": "Errors d'inici de sessió (24h)"
     },
     "proxmox": {
-        "vms": "VMs",
+        "vms": "Màquines Virtuals",
         "mem": "Memòria",
         "cpu": "Processador",
         "lxc": "LXC"
     },
     "unifi": {
         "users": "Usuaris",
-        "uptime": "System Uptime",
-        "days": "Días",
+        "uptime": "Temps actiu",
+        "days": "Dies",
         "wan": "WAN",
-        "lan_users": "LAN Users",
-        "wlan_users": "WLAN Users",
-        "up": "UP",
-        "down": "DOWN",
+        "lan_users": "Usuaris LAN",
+        "wlan_users": "Usuaris WLAN",
+        "up": "ACTIU",
+        "down": "INACTIU",
         "wait": "Si us plau, espereu",
         "lan": "LAN",
         "wlan": "WLAN",
-        "devices": "Devices",
-        "lan_devices": "LAN Devices",
-        "wlan_devices": "WLAN Devices"
+        "devices": "Dispositius",
+        "lan_devices": "Dispositius LAN",
+        "wlan_devices": "Dispositius WLAN"
     },
     "plex": {
         "streams": "Transmissions actives",
@@ -215,119 +216,119 @@
         "wait": "Si us plau, espereu"
     },
     "changedetectionio": {
-        "totalObserved": "Total Observed",
-        "diffsDetected": "Diffs Detected"
+        "totalObserved": "Total d'observats",
+        "diffsDetected": "Diferències detectades"
     },
     "wmo": {
-        "66-day": "Freezing Rain",
-        "95-day": "Thunderstorm",
-        "95-night": "Thunderstorm",
-        "96-day": "Thunderstorm With Hail",
-        "0-day": "Sunny",
-        "0-night": "Clear",
-        "1-day": "Mainly Sunny",
-        "1-night": "Mainly Clear",
-        "2-day": "Partly Cloudy",
-        "2-night": "Partly Cloudy",
-        "3-day": "Cloudy",
-        "3-night": "Cloudy",
-        "45-day": "Foggy",
-        "45-night": "Foggy",
-        "48-day": "Foggy",
-        "48-night": "Foggy",
-        "51-day": "Light Drizzle",
-        "51-night": "Light Drizzle",
-        "53-day": "Drizzle",
-        "53-night": "Drizzle",
-        "55-day": "Heavy Drizzle",
-        "55-night": "Heavy Drizzle",
-        "56-day": "Light Freezing Drizzle",
-        "56-night": "Light Freezing Drizzle",
-        "65-night": "Heavy Rain",
-        "57-day": "Freezing Drizzle",
-        "57-night": "Freezing Drizzle",
-        "61-day": "Light Rain",
-        "61-night": "Light Rain",
-        "63-day": "Rain",
-        "63-night": "Rain",
-        "65-day": "Heavy Rain",
-        "66-night": "Freezing Rain",
-        "67-day": "Freezing Rain",
-        "67-night": "Freezing Rain",
-        "71-day": "Light Snow",
-        "71-night": "Light Snow",
-        "73-day": "Snow",
-        "73-night": "Snow",
-        "75-day": "Heavy Snow",
-        "75-night": "Heavy Snow",
-        "77-day": "Snow Grains",
-        "77-night": "Snow Grains",
-        "80-day": "Light Showers",
-        "80-night": "Light Showers",
-        "81-day": "Showers",
-        "81-night": "Showers",
-        "82-day": "Heavy Showers",
-        "82-night": "Heavy Showers",
-        "85-day": "Snow Showers",
-        "85-night": "Snow Showers",
-        "86-day": "Snow Showers",
-        "86-night": "Snow Showers",
-        "96-night": "Thunderstorm With Hail",
-        "99-day": "Thunderstorm With Hail",
-        "99-night": "Thunderstorm With Hail"
+        "66-day": "Pluja gelada",
+        "95-day": "Tempesta",
+        "95-night": "Tempesta",
+        "96-day": "Tempesta amb calamarsa",
+        "0-day": "Assolellat",
+        "0-night": "Cel clar",
+        "1-day": "Majorment assolellat",
+        "1-night": "Majorment clar",
+        "2-day": "Parcialment ennuvolat",
+        "2-night": "Parcialment ennuvolat",
+        "3-day": "Ennuvolat",
+        "3-night": "Ennuvolat",
+        "45-day": "Boirós",
+        "45-night": "Boirós",
+        "48-day": "Boirós",
+        "48-night": "Boirós",
+        "51-day": "Ruixats lleugers",
+        "51-night": "Ruixats lleugers",
+        "53-day": "Ruixat",
+        "53-night": "Ruxiat",
+        "55-day": "Ruixat intens",
+        "55-night": "Ruixat intens",
+        "56-day": "Lleuger ruixat gelat",
+        "56-night": "Lleuger ruixat gelat",
+        "65-night": "Pluja intensa",
+        "57-day": "Ruixat gelat",
+        "57-night": "Ruixat gelat",
+        "61-day": "Pluja lleugera",
+        "61-night": "Pluja lleugera",
+        "63-day": "Pluja",
+        "63-night": "Pluja",
+        "65-day": "Pluja intensa",
+        "66-night": "Pluja gelada",
+        "67-day": "Pluja gelada",
+        "67-night": "Pluja gelada",
+        "71-day": "Neu lleugera",
+        "71-night": "Neu lleugera",
+        "73-day": "Neu",
+        "73-night": "Neu",
+        "75-day": "Neu intensa",
+        "75-night": "Neu intensa",
+        "77-day": "Neu lleugera",
+        "77-night": "Neu lleugera",
+        "80-day": "Plovisqueig",
+        "80-night": "Plovisqueig",
+        "81-day": "Xàfecs",
+        "81-night": "Xàfecs",
+        "82-day": "Xàfecs intensos",
+        "82-night": "Xàfecs intensos",
+        "85-day": "Xàfecs de neu",
+        "85-night": "Xàfecs de neu",
+        "86-day": "Xàfecs de neu",
+        "86-night": "Xàfecs de neu",
+        "96-night": "Tempesta amb calamarsa",
+        "99-day": "Tempesta amb calamarsa",
+        "99-night": "Tempesta amb calamarsa"
     },
     "quicklaunch": {
-        "bookmark": "Bookmark",
-        "service": "Service"
+        "bookmark": "Marcador",
+        "service": "Servei"
     },
     "homebridge": {
-        "available_update": "System",
-        "updates": "Updates",
-        "update_available": "Update Available",
-        "up_to_date": "Up to Date",
+        "available_update": "Sistema",
+        "updates": "Actualitzacions",
+        "update_available": "Actualització disponible",
+        "up_to_date": "Actualitzat",
         "child_bridges": "Child Bridges",
         "child_bridges_status": "{{ok}}/{{total}}"
     },
     "autobrr": {
-        "approvedPushes": "Approved",
-        "rejectedPushes": "Rejected",
-        "filters": "Filters",
-        "indexers": "Indexers"
+        "approvedPushes": "Aprovat",
+        "rejectedPushes": "Rebutjat",
+        "filters": "Filtres",
+        "indexers": "Indexadors"
     },
     "watchtower": {
-        "containers_scanned": "Scanned",
-        "containers_updated": "Updated",
-        "containers_failed": "Failed"
+        "containers_scanned": "Escanejat",
+        "containers_updated": "Actualitzat",
+        "containers_failed": "Error"
     },
     "tubearchivist": {
-        "downloads": "Queue",
-        "videos": "Videos",
-        "channels": "Channels",
-        "playlists": "Playlists"
+        "downloads": "Cua",
+        "videos": "Vídeos",
+        "channels": "Canals",
+        "playlists": "Llistes de reproducció"
     },
     "truenas": {
-        "load": "System Load",
-        "uptime": "Uptime",
-        "alerts": "Alerts",
+        "load": "Càrrega del sistema",
+        "uptime": "Temps actiu",
+        "alerts": "Alertes",
         "time": "{{value, number(style: unit; unitDisplay: long;)}}"
     },
     "navidrome": {
-        "nothing_streaming": "No Active Streams",
-        "please_wait": "Please Wait"
+        "nothing_streaming": "Cap reproducció activa",
+        "please_wait": "Espereu si us plau"
     },
     "pyload": {
-        "speed": "Speed",
-        "active": "Active",
-        "queue": "Queue",
+        "speed": "Velocitat",
+        "active": "Actiu",
+        "queue": "Cua",
         "total": "Total"
     },
     "gluetun": {
-        "public_ip": "Public IP",
-        "region": "Region",
-        "country": "Country"
+        "public_ip": "IP Pública",
+        "region": "Regió",
+        "country": "País"
     },
     "hdhomerun": {
-        "channels": "Channels",
+        "channels": "Canals",
         "hd": "HD"
     },
     "ping": {
@@ -335,18 +336,72 @@
         "ping": "Ping"
     },
     "scrutiny": {
-        "passed": "Passed",
-        "failed": "Failed",
-        "unknown": "Unknown"
+        "passed": "Aprobat",
+        "failed": "Error",
+        "unknown": "Desconegut"
     },
     "paperlessngx": {
-        "inbox": "Inbox",
+        "inbox": "Safata d'entrada",
         "total": "Total"
     },
     "deluge": {
-        "seed": "Seed",
+        "seed": "Llavor",
+        "download": "Descàrrega",
+        "upload": "Pujada",
+        "leech": "Company"
+    },
+    "flood": {
+        "download": "Descarregar",
+        "upload": "Pujada",
+        "leech": "Company",
+        "seed": "Llavor"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
         "download": "Download",
         "upload": "Upload",
-        "leech": "Leech"
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/cs/common.json

@@ -147,7 +147,8 @@
     "overseerr": {
         "pending": "Čeká",
         "approved": "Schváleno",
-        "available": "Dostupný"
+        "available": "Dostupný",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Dotazy",
@@ -348,5 +349,59 @@
         "leech": "Leech",
         "seed": "Seed",
         "download": "Download"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/da/common.json

@@ -23,7 +23,8 @@
     "overseerr": {
         "pending": "Afventer",
         "approved": "Godkendt",
-        "available": "Tilgængelig"
+        "available": "Tilgængelig",
+        "processing": "Processing"
     },
     "adguard": {
         "queries": "Forespørgsler",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "leech": "Leech",
+        "download": "Download",
+        "upload": "Upload",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/de/common.json

@@ -6,7 +6,7 @@
         "url": "URL",
         "information": "Information",
         "raw_error": "Raw Error",
-        "response_data": "Response Data"
+        "response_data": "Empfangene Daten"
     },
     "search": {
         "placeholder": "Suche…"
@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "Ausstehend",
         "approved": "Genehmigt",
-        "available": "Verfügbar"
+        "available": "Verfügbar",
+        "processing": "Processing"
     },
     "sabnzbd": {
         "rate": "Geschwindigkeit",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "unread": "Unread",
+        "read": "Read"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/en/common.json

@@ -3,9 +3,11 @@
         "bytes": "{{value, bytes}}",
         "bits": "{{value, bytes(bits: true)}}",
         "bbytes": "{{value, bytes(binary: true)}}",
-        "bbits": "{{value, bytes(bits: true, binary: true)}}",
-        "byterate": "{{value, rate}}",
+        "bbits": "{{value, bytes(bits: true; binary: true)}}",
+        "byterate": "{{value, rate(bits: false)}}",
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
         "bitrate": "{{value, rate(bits: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}",
         "percent": "{{value, percent}}",
         "number": "{{value, number}}",
         "ms": "{{value, number}}"
@@ -70,6 +72,12 @@
         "bitrate": "Bitrate",
         "no_active": "No Active Streams"
     },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
     "changedetectionio": {
         "totalObserved": "Total Observed",
         "diffsDetected": "Diffs Detected"
@@ -80,6 +88,13 @@
         "bitrate": "Bitrate",
         "no_active": "No Active Streams"
     },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
     "nzbget": {
         "rate": "Rate",
         "remaining": "Remaining",
@@ -118,6 +133,12 @@
         "leech": "Leech",
         "seed": "Seed"
     },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
     "sonarr": {
         "wanted": "Wanted",
         "queued": "Queued",
@@ -155,6 +176,7 @@
     },
     "overseerr": {
         "pending": "Pending",
+        "processing": "Processing",
         "approved": "Approved",
         "available": "Available"
     },
@@ -179,6 +201,12 @@
         "stopped": "Stopped",
         "total": "Total"
     },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
     "traefik": {
         "routers": "Routers",
         "services": "Services",
@@ -227,6 +255,10 @@
         "status_count": "Posts",
         "domain_count": "Domains"
     },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
     "authentik": {
         "users": "Users",
         "loginsLast24H": "Logins (24h)",
@@ -313,7 +345,7 @@
         "child_bridges": "Child Bridges",
         "child_bridges_status": "{{ok}}/{{total}}"
     },
-    "watchtower":{
+    "watchtower": {
         "containers_scanned": "Scanned",
         "containers_updated": "Updated",
         "containers_failed": "Failed"
@@ -359,5 +391,26 @@
     "paperlessngx": {
         "inbox": "Inbox",
         "total": "Total"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/eo/common.json

@@ -0,0 +1,407 @@
+{
+    "widget": {
+        "missing_type": "Missing Widget Type: {{type}}",
+        "api_error": "API Error",
+        "information": "Informo",
+        "status": "Stato",
+        "url": "URL",
+        "raw_error": "Raw Error",
+        "response_data": "Response Data"
+    },
+    "weather": {
+        "current": "Aktuala loko",
+        "allow": "Click to allow",
+        "updating": "Updating",
+        "wait": "Please wait"
+    },
+    "search": {
+        "placeholder": "Serĉi…"
+    },
+    "resources": {
+        "cpu": "Ĉefprocesoro",
+        "total": "Totalo",
+        "free": "Libera",
+        "used": "Uzata",
+        "load": "Ŝarĝo"
+    },
+    "unifi": {
+        "users": "Uzantoj",
+        "uptime": "System Uptime",
+        "days": "Tagoj",
+        "wan": "WAN",
+        "lan": "LAN",
+        "wlan": "WLAN",
+        "devices": "Aparatoj",
+        "lan_devices": "LAN Devices",
+        "wlan_devices": "WLAN Devices",
+        "lan_users": "LAN Users",
+        "wlan_users": "WLAN Users",
+        "up": "UP",
+        "down": "DOWN",
+        "wait": "Please wait"
+    },
+    "docker": {
+        "rx": "RX",
+        "tx": "TX",
+        "mem": "Memoro",
+        "cpu": "Ĉefprocesoro",
+        "offline": "Offline",
+        "error": "Eraro",
+        "unknown": "Nekonata"
+    },
+    "ping": {
+        "error": "Eraro",
+        "ping": "Ping"
+    },
+    "emby": {
+        "playing": "Ludante",
+        "transcoding": "Transcoding",
+        "bitrate": "Bitrate",
+        "no_active": "No Active Streams"
+    },
+    "changedetectionio": {
+        "totalObserved": "Total Observed",
+        "diffsDetected": "Diffs Detected"
+    },
+    "tautulli": {
+        "playing": "Playing",
+        "transcoding": "Transcoding",
+        "bitrate": "Bitrate",
+        "no_active": "No Active Streams"
+    },
+    "nzbget": {
+        "rate": "Rate",
+        "remaining": "Remaining",
+        "downloaded": "Downloaded"
+    },
+    "plex": {
+        "streams": "Active Streams",
+        "movies": "Filmoj",
+        "tv": "Televidprogramoj"
+    },
+    "sabnzbd": {
+        "rate": "Rate",
+        "queue": "Queue",
+        "timeleft": "Time Left"
+    },
+    "rutorrent": {
+        "active": "Active",
+        "upload": "Alŝuto",
+        "download": "Elŝuto"
+    },
+    "transmission": {
+        "download": "Elŝuto",
+        "upload": "Alŝuto",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "qbittorrent": {
+        "download": "Elŝuto",
+        "upload": "Alŝuto",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "deluge": {
+        "download": "Elŝuto",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "sonarr": {
+        "wanted": "Wanted",
+        "queued": "Queued",
+        "series": "Serio"
+    },
+    "radarr": {
+        "wanted": "Wanted",
+        "missing": "Missing",
+        "queued": "Queued",
+        "movies": "Filmoj"
+    },
+    "lidarr": {
+        "wanted": "Wanted",
+        "queued": "Queued",
+        "albums": "Albumoj"
+    },
+    "readarr": {
+        "wanted": "Wanted",
+        "queued": "Queued",
+        "books": "Libroj"
+    },
+    "bazarr": {
+        "missingEpisodes": "Missing Episodes",
+        "missingMovies": "Missing Movies"
+    },
+    "ombi": {
+        "pending": "Pending",
+        "approved": "Aprobita",
+        "available": "Havebla"
+    },
+    "jellyseerr": {
+        "pending": "Pending",
+        "approved": "Aprobita",
+        "available": "Havebla"
+    },
+    "overseerr": {
+        "pending": "Pending",
+        "processing": "Processing",
+        "approved": "Aprobita",
+        "available": "Havebla"
+    },
+    "pihole": {
+        "queries": "Queries",
+        "blocked": "Blocked",
+        "gravity": "Gravity"
+    },
+    "adguard": {
+        "queries": "Queries",
+        "blocked": "Blokitaj",
+        "filtered": "Filtritaj",
+        "latency": "Latency"
+    },
+    "speedtest": {
+        "upload": "Upload",
+        "download": "Download",
+        "ping": "Ping"
+    },
+    "portainer": {
+        "running": "Running",
+        "stopped": "Stopped",
+        "total": "Totalo"
+    },
+    "traefik": {
+        "routers": "Routers",
+        "services": "Servoj",
+        "middleware": "Middleware"
+    },
+    "navidrome": {
+        "nothing_streaming": "No Active Streams",
+        "please_wait": "Please Wait"
+    },
+    "npm": {
+        "enabled": "Enabled",
+        "disabled": "Disabled",
+        "total": "Total"
+    },
+    "coinmarketcap": {
+        "configure": "Configure one or more crypto currencies to track",
+        "1hour": "1 horo",
+        "1day": "1 tago",
+        "7days": "7 tagoj",
+        "30days": "30 tagoj"
+    },
+    "gotify": {
+        "apps": "Applications",
+        "clients": "Klientoj",
+        "messages": "Mesaĝoj"
+    },
+    "prowlarr": {
+        "enableIndexers": "Indexers",
+        "numberOfGrabs": "Grabs",
+        "numberOfQueries": "Queries",
+        "numberOfFailGrabs": "Fail Grabs",
+        "numberOfFailQueries": "Fail Queries"
+    },
+    "jackett": {
+        "configured": "Configured",
+        "errored": "Errored"
+    },
+    "strelaysrv": {
+        "numActiveSessions": "Seancoj",
+        "numConnections": "Konektoj",
+        "dataRelayed": "Relayed",
+        "transferRate": "Rate"
+    },
+    "mastodon": {
+        "user_count": "Uzantoj",
+        "status_count": "Afiŝoj",
+        "domain_count": "Domains"
+    },
+    "authentik": {
+        "users": "Users",
+        "loginsLast24H": "Logins (24h)",
+        "failedLoginsLast24H": "Failed Logins (24h)"
+    },
+    "proxmox": {
+        "mem": "Memoro",
+        "cpu": "Ĉefprocesoro",
+        "lxc": "LXC",
+        "vms": "VMs"
+    },
+    "glances": {
+        "cpu": "Ĉefprocesoro",
+        "mem": "Memoro",
+        "wait": "Bonvolu atendi"
+    },
+    "quicklaunch": {
+        "bookmark": "Bookmark",
+        "service": "Servo"
+    },
+    "wmo": {
+        "0-day": "Suna",
+        "0-night": "Sennuba",
+        "1-day": "Mainly Sunny",
+        "1-night": "Mainly Clear",
+        "2-day": "Nubeta",
+        "2-night": "Nubeta",
+        "3-day": "Nuba",
+        "3-night": "Nuba",
+        "45-day": "Nebula",
+        "45-night": "Nebula",
+        "48-day": "Nebula",
+        "48-night": "Nebula",
+        "51-day": "Light Drizzle",
+        "51-night": "Light Drizzle",
+        "53-day": "Drizzle",
+        "53-night": "Drizzle",
+        "55-day": "Heavy Drizzle",
+        "55-night": "Heavy Drizzle",
+        "56-day": "Light Freezing Drizzle",
+        "56-night": "Light Freezing Drizzle",
+        "57-day": "Freezing Drizzle",
+        "57-night": "Freezing Drizzle",
+        "61-day": "Light Rain",
+        "61-night": "Light Rain",
+        "63-day": "Pluvo",
+        "63-night": "Pluvo",
+        "65-day": "Pluvego",
+        "65-night": "Pluvego",
+        "66-day": "Frosta pluvo",
+        "66-night": "Frosta pluvo",
+        "67-day": "Frosta pluvo",
+        "67-night": "Frosta pluvo",
+        "71-day": "Light Snow",
+        "71-night": "Light Snow",
+        "73-day": "Neĝo",
+        "73-night": "Neĝo",
+        "75-day": "Neĝego",
+        "75-night": "Neĝego",
+        "77-day": "Snow Grains",
+        "77-night": "Snow Grains",
+        "80-day": "Light Showers",
+        "80-night": "Light Showers",
+        "81-day": "Showers",
+        "81-night": "Showers",
+        "82-day": "Heavy Showers",
+        "82-night": "Heavy Showers",
+        "85-day": "Snow Showers",
+        "85-night": "Snow Showers",
+        "86-day": "Snow Showers",
+        "86-night": "Snow Showers",
+        "95-day": "Fulmotondro",
+        "95-night": "Fulmotondro",
+        "96-day": "Fulmotondro kun hajlo",
+        "96-night": "Fulmotondro kun hajlo",
+        "99-day": "Fulmotondro kun hajlo",
+        "99-night": "Fulmotondro kun hajlo"
+    },
+    "homebridge": {
+        "available_update": "Sistemo",
+        "updates": "Updates",
+        "update_available": "Update Available",
+        "up_to_date": "Up to Date",
+        "child_bridges": "Child Bridges",
+        "child_bridges_status": "{{ok}}/{{total}}"
+    },
+    "watchtower": {
+        "containers_scanned": "Scanned",
+        "containers_updated": "Updated",
+        "containers_failed": "Failed"
+    },
+    "autobrr": {
+        "approvedPushes": "Approved",
+        "rejectedPushes": "Rejected",
+        "filters": "Filtriloj",
+        "indexers": "Indexers"
+    },
+    "tubearchivist": {
+        "downloads": "Queue",
+        "videos": "Videos",
+        "channels": "Kanaloj",
+        "playlists": "Playlists"
+    },
+    "truenas": {
+        "load": "System Load",
+        "uptime": "Uptime",
+        "alerts": "Alerts",
+        "time": "{{value, number(style: unit; unitDisplay: long;)}}"
+    },
+    "pyload": {
+        "speed": "Speed",
+        "active": "Aktiva",
+        "queue": "Queue",
+        "total": "Total"
+    },
+    "gluetun": {
+        "public_ip": "Public IP",
+        "region": "Regiono",
+        "country": "Lando"
+    },
+    "hdhomerun": {
+        "channels": "Kanaloj",
+        "hd": "HD"
+    },
+    "scrutiny": {
+        "passed": "Passed",
+        "failed": "Failed",
+        "unknown": "Unknown"
+    },
+    "paperlessngx": {
+        "inbox": "Inbox",
+        "total": "Totalo"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
+    }
+}

public/locales/es/common.json

@@ -53,7 +53,7 @@
         "wanted": "Buscando",
         "queued": "En cola",
         "movies": "Películas",
-        "missing": "No Encontrado"
+        "missing": "Faltan"
     },
     "readarr": {
         "wanted": "Buscando",
@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "Pendiente",
         "approved": "Aprobado",
-        "available": "Disponible"
+        "available": "Disponible",
+        "processing": "Procesando"
     },
     "sabnzbd": {
         "rate": "Tasa",
@@ -138,7 +139,7 @@
     "transmission": {
         "download": "Bajada",
         "upload": "Subida",
-        "leech": "Compañeros",
+        "leech": "Leech",
         "seed": "Semillas"
     },
     "jackett": {
@@ -163,7 +164,7 @@
     "qbittorrent": {
         "download": "Bajada",
         "upload": "Subida",
-        "leech": "Compañeros",
+        "leech": "Leech",
         "seed": "Semillas"
     },
     "mastodon": {
@@ -348,5 +349,59 @@
         "upload": "Subida",
         "leech": "Leech",
         "seed": "Semilla"
+    },
+    "flood": {
+        "download": "Descargar",
+        "upload": "Subir",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Cola",
+        "processed": "Procesado",
+        "saved": "Guardado",
+        "errored": "Error"
+    },
+    "miniflux": {
+        "read": "Leer",
+        "unread": "Sin leer"
+    },
+    "nextdns": {
+        "wait": "Espere, por favor",
+        "no_devices": "No se reciben datos del dispositivo"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "AP conectados",
+        "activeUser": "Dispositivos activos",
+        "alerts": "Alertas",
+        "connectedGateway": "Pasarelas conectadas",
+        "connectedSwitches": "Interruptores conectados"
+    },
+    "downloadstation": {
+        "download": "Descargar",
+        "upload": "Subir",
+        "leech": "Sanguijuela",
+        "seed": "Semilla"
+    },
+    "mikrotik": {
+        "cpuLoad": "Carga de la CPU",
+        "memoryUsed": "Memoria utilizada",
+        "uptime": "Tiempo en funcionamiento",
+        "numberOfLeases": "Alquileres"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/fi/common.json

@@ -110,7 +110,8 @@
     "overseerr": {
         "pending": "Vireillä",
         "approved": "Hyväksytty",
-        "available": "Saatavilla"
+        "available": "Saatavilla",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Kyselyjä",
@@ -348,5 +349,59 @@
         "leech": "Leech",
         "seed": "Seed",
         "download": "Download"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedSwitches": "Connected switches",
+        "connectedGateway": "Connected gateways"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/fr/common.json

@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "En attente",
         "approved": "Demande",
-        "available": "Disponible"
+        "available": "Disponible",
+        "processing": "En traitement"
     },
     "sabnzbd": {
         "rate": "Débit",
@@ -348,5 +349,59 @@
         "upload": "Envoi",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Récep.",
+        "upload": "Envoi",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "À traiter",
+        "processed": "Traité",
+        "errored": "En erreur",
+        "saved": "Enregistré"
+    },
+    "miniflux": {
+        "read": "Lu",
+        "unread": "Non lu"
+    },
+    "nextdns": {
+        "wait": "Patientez...",
+        "no_devices": "Aucune donnée d'appareil reçue"
+    },
+    "common": {
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}",
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "APs connectées",
+        "activeUser": "Équipts actifs",
+        "alerts": "Alertes",
+        "connectedGateway": "Passerelles connectées",
+        "connectedSwitches": "Switches connectés"
+    },
+    "downloadstation": {
+        "download": "Récep.",
+        "upload": "Envoi",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "Charge CPU",
+        "memoryUsed": "Mém. Utilisée",
+        "uptime": "Disponibilité",
+        "numberOfLeases": "Baux"
+    },
+    "xteve": {
+        "streams_all": "Tous les flux",
+        "streams_active": "Flux actif",
+        "streams_xepg": "Canal XEPG"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/he/common.json

@@ -110,7 +110,8 @@
     "overseerr": {
         "pending": "ממתין",
         "approved": "מאושר",
-        "available": "זמין"
+        "available": "זמין",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "שאילתות",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/hi/common.json

@@ -150,7 +150,8 @@
     "overseerr": {
         "pending": "Pending",
         "approved": "Approved",
-        "available": "Available"
+        "available": "Available",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Queries",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/hr/common.json

@@ -23,7 +23,8 @@
     "overseerr": {
         "available": "Dostupno",
         "pending": "Predstoji",
-        "approved": "Odobreno"
+        "approved": "Odobreno",
+        "processing": "Obrada"
     },
     "pihole": {
         "queries": "Upiti",
@@ -344,9 +345,63 @@
         "total": "Ukupno"
     },
     "deluge": {
+        "download": "Preuzimanje",
+        "upload": "Prijenos",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "flood": {
+        "download": "Preuzimanje",
+        "upload": "Prijenos",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
         "download": "Download",
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/hu/common.json

@@ -110,7 +110,8 @@
     "overseerr": {
         "pending": "Függőben",
         "approved": "Engedélyezett",
-        "available": "Elérhető"
+        "available": "Elérhető",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Lekérdezések",
@@ -348,5 +349,59 @@
         "seed": "Seed",
         "upload": "Upload",
         "leech": "Leech"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedAp": "Connected APs",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/it/common.json

@@ -5,18 +5,18 @@
         "cpu": "CPU",
         "offline": "Offline",
         "rx": "RX",
-        "error": "Error",
-        "unknown": "Unknown"
+        "error": "Errore",
+        "unknown": "Sconosciuto"
     },
     "emby": {
         "playing": "In riproduzione",
-        "transcoding": "Transcoding",
+        "transcoding": "Transcodifica",
         "bitrate": "Bitrate",
         "no_active": "Nessuno Stream Attivo"
     },
     "tautulli": {
         "playing": "In riproduzione",
-        "transcoding": "Transcoding",
+        "transcoding": "Transcodifica",
         "bitrate": "Bitrate",
         "no_active": "Nessuno Stream Attivo"
     },
@@ -31,7 +31,7 @@
         "total": "Totali"
     },
     "traefik": {
-        "routers": "Routers",
+        "routers": "Router",
         "services": "Servizi",
         "middleware": "Middleware"
     },
@@ -40,9 +40,9 @@
         "api_error": "Errore API",
         "status": "Stato",
         "url": "URL",
-        "information": "Information",
+        "information": "Informazione",
         "raw_error": "Raw Error",
-        "response_data": "Response Data"
+        "response_data": "Dati risposta"
     },
     "search": {
         "placeholder": "Cerca…"
@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "In attesa",
         "approved": "Approvati",
-        "available": "Disponibili"
+        "available": "Disponibili",
+        "processing": "In lavorazione"
     },
     "sabnzbd": {
         "rate": "Rapporto",
@@ -125,13 +126,13 @@
     },
     "gotify": {
         "apps": "Applicazioni",
-        "clients": "Clients",
+        "clients": "Client",
         "messages": "Messaggi"
     },
     "prowlarr": {
         "enableIndexers": "Indicizzatori",
         "numberOfGrabs": "Grabs",
-        "numberOfQueries": "Queries",
+        "numberOfQueries": "Interrogazioni",
         "numberOfFailGrabs": "Grabs Falliti",
         "numberOfFailQueries": "Queries Fallite"
     },
@@ -152,10 +153,10 @@
     "lidarr": {
         "wanted": "Mancanti",
         "queued": "In coda",
-        "albums": "Albums"
+        "albums": "Album"
     },
     "adguard": {
-        "queries": "Queries",
+        "queries": "Interrogazioni",
         "blocked": "Bloccati",
         "filtered": "Filtrati",
         "latency": "Latenza"
@@ -303,12 +304,12 @@
         "downloads": "Coda",
         "videos": "Video",
         "channels": "Canali",
-        "playlists": "Playlists"
+        "playlists": "Playlist"
     },
     "truenas": {
         "load": "Carico di Sistema",
-        "uptime": "Uptime",
-        "alerts": "Alerts",
+        "uptime": "Tempo di attività",
+        "alerts": "Avvisi",
         "time": "{{value, number(style: unit; unitDisplay: long;)}}"
     },
     "navidrome": {
@@ -322,31 +323,85 @@
         "total": "Totale"
     },
     "gluetun": {
-        "public_ip": "Public IP",
-        "region": "Region",
-        "country": "Country"
+        "public_ip": "IP pubblico",
+        "region": "Località",
+        "country": "Stato"
     },
     "hdhomerun": {
-        "channels": "Channels",
+        "channels": "Canali",
         "hd": "HD"
     },
     "ping": {
-        "error": "Error",
+        "error": "Errore",
         "ping": "Ping"
     },
     "scrutiny": {
-        "passed": "Passed",
-        "failed": "Failed",
-        "unknown": "Unknown"
+        "passed": "Passati",
+        "failed": "Falliti",
+        "unknown": "Sconosciuto"
     },
     "paperlessngx": {
-        "inbox": "Inbox",
-        "total": "Total"
+        "inbox": "In arrivo",
+        "total": "Totali"
     },
     "deluge": {
         "download": "Download",
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "In coda",
+        "processed": "Elaborati",
+        "errored": "Errori",
+        "saved": "Salvati"
+    },
+    "miniflux": {
+        "unread": "Non letti",
+        "read": "Letti"
+    },
+    "nextdns": {
+        "wait": "Attendi",
+        "no_devices": "Nessun dato del dispositivo ricevuto"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "AP Connessi",
+        "activeUser": "Dispositivi attivi",
+        "alerts": "Allarmi",
+        "connectedGateway": "Gateway connessi",
+        "connectedSwitches": "Switch connessi"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "Carico della CPU",
+        "memoryUsed": "Memoria Utilizzata",
+        "uptime": "Tempo di attività",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/ms/common.json

@@ -126,10 +126,10 @@
         "missing_type": "Jenis Widget Hilang: {{type}}",
         "api_error": "Masalah API",
         "status": "Status",
-        "information": "Information",
+        "information": "Informasi",
         "url": "URL",
-        "raw_error": "Raw Error",
-        "response_data": "Response Data"
+        "raw_error": "Ralat Mentah",
+        "response_data": "Data Respon"
     },
     "weather": {
         "current": "Lokasi Sekarang",
@@ -151,8 +151,8 @@
         "mem": "MEM",
         "cpu": "CPU",
         "offline": "Luar talian",
-        "error": "Error",
-        "unknown": "Unknown"
+        "error": "Ralat",
+        "unknown": "Tidak Diketahui"
     },
     "changedetectionio": {
         "totalObserved": "Jumlah Diperhatikan",
@@ -220,7 +220,8 @@
     "overseerr": {
         "pending": "Tertangguh",
         "approved": "Lulus",
-        "available": "Sudah Ada"
+        "available": "Sudah Ada",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Permintaan",
@@ -322,31 +323,85 @@
         "total": "Jumlah"
     },
     "gluetun": {
-        "public_ip": "Public IP",
-        "region": "Region",
-        "country": "Country"
+        "public_ip": "IP Awam",
+        "region": "Rantau",
+        "country": "Negara"
     },
     "hdhomerun": {
-        "channels": "Channels",
+        "channels": "Saluran",
         "hd": "HD"
     },
     "ping": {
-        "error": "Error",
+        "error": "Ralat",
         "ping": "Ping"
     },
     "scrutiny": {
-        "passed": "Passed",
-        "failed": "Failed",
-        "unknown": "Unknown"
+        "passed": "Lulus",
+        "failed": "Gagal",
+        "unknown": "Tidak Diketahui"
     },
     "paperlessngx": {
-        "inbox": "Inbox",
-        "total": "Total"
+        "inbox": "Peti Masuk",
+        "total": "Jumlah"
     },
     "deluge": {
+        "download": "Muat Turun",
+        "upload": "Muat Naik",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "flood": {
         "download": "Download",
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/nb-NO/common.json

@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "Venter",
         "approved": "Godkjent",
-        "available": "Tilgjengelig"
+        "available": "Tilgjengelig",
+        "processing": "Processing"
     },
     "sabnzbd": {
         "rate": "Takt",
@@ -348,5 +349,59 @@
         "download": "Download",
         "upload": "Upload",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases",
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/nl/common.json

@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "Pending",
         "approved": "Approved",
-        "available": "Available"
+        "available": "Available",
+        "processing": "Processing"
     },
     "sabnzbd": {
         "rate": "Rate",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/pl/common.json

@@ -126,7 +126,8 @@
     "overseerr": {
         "pending": "Oczekiwane",
         "approved": "Zaakceptowane",
-        "available": "Dostępne"
+        "available": "Dostępne",
+        "processing": "Przetwarzane"
     },
     "pihole": {
         "queries": "Zapytania",
@@ -335,18 +336,72 @@
         "ping": "Ping"
     },
     "scrutiny": {
-        "passed": "Passed",
-        "failed": "Failed",
-        "unknown": "Unknown"
+        "passed": "Powodzenie",
+        "failed": "Niepowodzenie",
+        "unknown": "Nieznane"
     },
     "paperlessngx": {
-        "inbox": "Inbox",
-        "total": "Total"
+        "inbox": "Skrzynka odbiorcza",
+        "total": "W sumie"
     },
     "deluge": {
-        "download": "Download",
-        "upload": "Upload",
+        "download": "Pobieranie",
+        "upload": "Wysyłanie",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Pobieranie",
+        "upload": "Wysyłanie",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Kolejka",
+        "processed": "Przetworzone",
+        "errored": "Błędne",
+        "saved": "Zapisane"
+    },
+    "miniflux": {
+        "read": "Przeczytane",
+        "unread": "Nieprzeczytane"
+    },
+    "nextdns": {
+        "wait": "Proszę czekać",
+        "no_devices": "Nie otrzymano danych urządzenia"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedSwitches": "Połączone przełączniki",
+        "connectedAp": "Połączone punkty dostępowe",
+        "activeUser": "Aktywne urządzenia",
+        "alerts": "Alarmy",
+        "connectedGateway": "Połączone bramy"
+    },
+    "downloadstation": {
+        "download": "Pobieranie",
+        "upload": "Wysyłanie",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "Obciążenie procesora",
+        "memoryUsed": "Zuyżyta pamięć",
+        "uptime": "Czas działania",
+        "numberOfLeases": "Dzierżawy"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/pt-BR/common.json

@@ -128,7 +128,8 @@
     "overseerr": {
         "pending": "Pendente",
         "approved": "Aprovado",
-        "available": "Disponível"
+        "available": "Disponível",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Consultas",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/pt/common.json

@@ -2,11 +2,11 @@
     "widget": {
         "missing_type": "Widget ausente: {{type}}",
         "api_error": "Erro da API",
-        "status": "Status",
-        "information": "Information",
-        "url": "URL",
-        "raw_error": "Raw Error",
-        "response_data": "Response Data"
+        "status": "Estado",
+        "information": "Informação",
+        "url": "Endereço URL",
+        "raw_error": "Erro",
+        "response_data": "Dados da Resposta"
     },
     "search": {
         "placeholder": "Pesquisar…"
@@ -24,8 +24,8 @@
         "mem": "Mem",
         "cpu": "CPU",
         "offline": "Desligado",
-        "error": "Error",
-        "unknown": "Unknown"
+        "error": "Erro",
+        "unknown": "Desconhecido"
     },
     "emby": {
         "playing": "A reproduzir",
@@ -104,7 +104,9 @@
         "byterate": "{{value, bytes}}",
         "ms": "{{value, number}}",
         "bitrate": "{{value, bytes(bits: true)}}",
-        "percent": "{{value, percent}}"
+        "percent": "{{value, percent}}",
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
     },
     "weather": {
         "current": "Localização atual",
@@ -115,7 +117,8 @@
     "overseerr": {
         "pending": "Pendente",
         "approved": "Aprovado",
-        "available": "Disponível"
+        "available": "Disponível",
+        "processing": "Processing"
     },
     "sabnzbd": {
         "rate": "Taxa",
@@ -149,7 +152,7 @@
     "transmission": {
         "download": "Baixando",
         "upload": "Enviando",
-        "leech": "Sanguessugas",
+        "leech": "Leech",
         "seed": "Semeadores"
     },
     "jackett": {
@@ -200,55 +203,55 @@
         "vms": "VMs"
     },
     "unifi": {
-        "users": "Users",
-        "uptime": "System Uptime",
-        "days": "Days",
+        "users": "Utilizadores",
+        "uptime": "Tempo de Atividade do Sistema",
+        "days": "Dias",
         "wan": "WAN",
-        "lan_users": "LAN Users",
-        "wlan_users": "WLAN Users",
-        "up": "UP",
-        "down": "DOWN",
-        "wait": "Please wait",
+        "lan_users": "Utilizadores LAN",
+        "wlan_users": "Utilizadores WLAN",
+        "up": "Ligados",
+        "down": "Desligados",
+        "wait": "Por favor, aguarde",
         "lan": "LAN",
         "wlan": "WLAN",
-        "devices": "Devices",
-        "lan_devices": "LAN Devices",
-        "wlan_devices": "WLAN Devices"
+        "devices": "Dispositivos",
+        "lan_devices": "Dispositivos LAN",
+        "wlan_devices": "Dispositivos WLAN"
     },
     "plex": {
-        "streams": "Active Streams",
-        "movies": "Movies",
-        "tv": "TV Shows"
+        "streams": "Streams Ativas",
+        "movies": "Filmes",
+        "tv": "Series de TV"
     },
     "glances": {
         "cpu": "CPU",
         "mem": "MEM",
-        "wait": "Please wait"
+        "wait": "Por favor, aguarde"
     },
     "changedetectionio": {
-        "totalObserved": "Total Observed",
-        "diffsDetected": "Diffs Detected"
+        "totalObserved": "Total Observado",
+        "diffsDetected": "Diferenças Detetadas"
     },
     "wmo": {
-        "0-day": "Sunny",
-        "0-night": "Clear",
-        "1-day": "Mainly Sunny",
-        "1-night": "Mainly Clear",
-        "2-day": "Partly Cloudy",
-        "2-night": "Partly Cloudy",
-        "3-day": "Cloudy",
-        "3-night": "Cloudy",
+        "0-day": "Solarengo",
+        "0-night": "Limpo",
+        "1-day": "Maioritariamente ensolarado",
+        "1-night": "Maioritariamente Limpo",
+        "2-day": "Parcialmente Nublado",
+        "2-night": "Parcialmente nublado",
+        "3-day": "Nublado",
+        "3-night": "Nublado",
         "99-night": "Thunderstorm With Hail",
-        "45-day": "Foggy",
-        "45-night": "Foggy",
-        "48-day": "Foggy",
-        "48-night": "Foggy",
-        "51-day": "Light Drizzle",
-        "51-night": "Light Drizzle",
-        "53-day": "Drizzle",
-        "53-night": "Drizzle",
-        "55-day": "Heavy Drizzle",
-        "55-night": "Heavy Drizzle",
+        "45-day": "Nevoeiro",
+        "45-night": "Nevoeiro",
+        "48-day": "Nevoeiro",
+        "48-night": "Nevoeiro",
+        "51-day": "Aguaceiros",
+        "51-night": "Aguaceiros",
+        "53-day": "Chuvisco",
+        "53-night": "Chuvisco",
+        "55-day": "Aguaceiro Forte",
+        "55-night": "Aguaceiro Forte",
         "56-day": "Light Freezing Drizzle",
         "56-night": "Light Freezing Drizzle",
         "57-day": "Freezing Drizzle",
@@ -288,8 +291,8 @@
         "99-day": "Thunderstorm With Hail"
     },
     "quicklaunch": {
-        "bookmark": "Bookmark",
-        "service": "Service"
+        "bookmark": "Marcador",
+        "service": "Serviço"
     },
     "homebridge": {
         "available_update": "System",
@@ -342,7 +345,7 @@
         "hd": "HD"
     },
     "ping": {
-        "error": "Error",
+        "error": "Erro",
         "ping": "Ping"
     },
     "scrutiny": {
@@ -359,5 +362,55 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Descarregar",
+        "upload": "Carregar",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/ro/common.json

@@ -23,7 +23,8 @@
     "overseerr": {
         "pending": "În așteptare",
         "approved": "Aprobate",
-        "available": "Disponibile"
+        "available": "Disponibile",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Cereri",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "numberOfLeases": "Leases",
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/ru/common.json

@@ -6,7 +6,7 @@
         "information": "Информация",
         "url": "URL",
         "raw_error": "Raw Error",
-        "response_data": "Response Data"
+        "response_data": "Данные ответа"
     },
     "search": {
         "placeholder": "Поиск…"
@@ -16,7 +16,7 @@
         "free": "Свободно",
         "used": "Использовано",
         "load": "Загрузка",
-        "cpu": "CPU"
+        "cpu": "Процессор"
     },
     "docker": {
         "rx": "Rx",
@@ -24,14 +24,14 @@
         "mem": "Память",
         "cpu": "Процессор",
         "offline": "Не в сети",
-        "error": "Error",
-        "unknown": "Unknown"
+        "error": "Ошибка",
+        "unknown": "Неизвестный"
     },
     "emby": {
         "playing": "Воспроизведение",
         "transcoding": "Транскодирование",
         "bitrate": "Битрейт",
-        "no_active": "No Active Streams"
+        "no_active": "Нет активных потоков"
     },
     "tautulli": {
         "playing": "Воспроизведение",
@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "Pending",
         "approved": "Approved",
-        "available": "Available"
+        "available": "Available",
+        "processing": "Processing"
     },
     "sabnzbd": {
         "rate": "Rate",
@@ -197,7 +198,7 @@
         "wlan_users": "Пользователи WLAN",
         "up": "UP",
         "down": "DOWN",
-        "wait": "Please wait",
+        "wait": "Подождите",
         "lan": "LAN",
         "wlan": "WLAN",
         "devices": "Устройства",
@@ -215,8 +216,8 @@
         "wait": "Please wait"
     },
     "changedetectionio": {
-        "totalObserved": "Total Observed",
-        "diffsDetected": "Diffs Detected"
+        "totalObserved": "Всего наблюдаемых",
+        "diffsDetected": "Обнаружены различия"
     },
     "wmo": {
         "0-day": "Sunny",
@@ -331,8 +332,8 @@
         "hd": "HD"
     },
     "ping": {
-        "error": "Error",
-        "ping": "Ping"
+        "error": "Ошибка",
+        "ping": "Пинг"
     },
     "scrutiny": {
         "failed": "Failed",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "upload": "Upload",
+        "download": "Download",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedSwitches": "Connected switches",
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/sr/common.json

@@ -131,7 +131,8 @@
     "overseerr": {
         "pending": "Pending",
         "approved": "Approved",
-        "available": "Available"
+        "available": "Available",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Queries",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "seed": "Seed",
+        "upload": "Upload",
+        "leech": "Leech"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/sv/common.json

@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "Avvaktar",
         "approved": "Godkända",
-        "available": "Tillgänglig"
+        "available": "Tillgänglig",
+        "processing": "Processing"
     },
     "pihole": {
         "blocked": "Blockerad",
@@ -348,5 +349,59 @@
         "leech": "Leech",
         "upload": "Upload",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/te/common.json

@@ -122,7 +122,8 @@
     "overseerr": {
         "pending": "పెండింగ్",
         "approved": "ఆమోదించబడింది",
-        "available": "అందుబాటులో"
+        "available": "అందుబాటులో",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "ప్రశ్నలు",
@@ -348,5 +349,59 @@
         "download": "Download",
         "upload": "Upload",
         "leech": "Leech"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases",
+        "memoryUsed": "Memory Used"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/tr/common.json

@@ -131,7 +131,8 @@
     "overseerr": {
         "pending": "Bekliyor",
         "approved": "Onaylı",
-        "available": "Kullanılabilir"
+        "available": "Kullanılabilir",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Sorgular",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/uk/common.json

@@ -0,0 +1,407 @@
+{
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "alerts": "Оповіщення",
+        "connectedGateway": "Підключені шлюзи",
+        "connectedSwitches": "Підключені перемикачі",
+        "connectedAp": "Підключені точки доступу",
+        "activeUser": "Активні пристрої"
+    },
+    "sabnzbd": {
+        "rate": "Швидкість",
+        "queue": "Черга",
+        "timeleft": "Залишилось"
+    },
+    "rutorrent": {
+        "active": "Активний",
+        "upload": "Відправлення",
+        "download": "Завантаження"
+    },
+    "deluge": {
+        "download": "Завантаження",
+        "upload": "Відправлення",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "readarr": {
+        "wanted": "Розшукується",
+        "queued": "У черзі",
+        "books": "Книжки"
+    },
+    "wmo": {
+        "55-day": "Heavy Drizzle",
+        "55-night": "Heavy Drizzle",
+        "56-day": "Light Freezing Drizzle",
+        "56-night": "Light Freezing Drizzle",
+        "0-day": "Sunny",
+        "0-night": "Clear",
+        "1-day": "Mainly Sunny",
+        "1-night": "Mainly Clear",
+        "2-day": "Partly Cloudy",
+        "2-night": "Partly Cloudy",
+        "3-day": "Cloudy",
+        "3-night": "Cloudy",
+        "53-day": "Drizzle",
+        "45-day": "Foggy",
+        "45-night": "Foggy",
+        "48-day": "Foggy",
+        "48-night": "Foggy",
+        "51-day": "Light Drizzle",
+        "51-night": "Light Drizzle",
+        "53-night": "Drizzle",
+        "57-day": "Freezing Drizzle",
+        "57-night": "Freezing Drizzle",
+        "61-day": "Light Rain",
+        "61-night": "Light Rain",
+        "63-day": "Rain",
+        "63-night": "Rain",
+        "65-day": "Heavy Rain",
+        "65-night": "Heavy Rain",
+        "66-day": "Freezing Rain",
+        "66-night": "Freezing Rain",
+        "67-day": "Freezing Rain",
+        "67-night": "Freezing Rain",
+        "71-day": "Light Snow",
+        "71-night": "Light Snow",
+        "73-day": "Snow",
+        "73-night": "Snow",
+        "75-day": "Heavy Snow",
+        "75-night": "Heavy Snow",
+        "77-day": "Snow Grains",
+        "77-night": "Snow Grains",
+        "80-day": "Light Showers",
+        "80-night": "Light Showers",
+        "81-day": "Showers",
+        "82-day": "Heavy Showers",
+        "82-night": "Heavy Showers",
+        "81-night": "Showers",
+        "85-day": "Snow Showers",
+        "85-night": "Snow Showers",
+        "86-day": "Snow Showers",
+        "86-night": "Snow Showers",
+        "95-day": "Thunderstorm",
+        "95-night": "Thunderstorm",
+        "96-day": "Thunderstorm With Hail",
+        "96-night": "Thunderstorm With Hail",
+        "99-day": "Thunderstorm With Hail",
+        "99-night": "Thunderstorm With Hail"
+    },
+    "pyload": {
+        "speed": "Speed",
+        "active": "Active",
+        "queue": "Queue",
+        "total": "Total"
+    },
+    "gluetun": {
+        "country": "Country",
+        "public_ip": "Public IP",
+        "region": "Region"
+    },
+    "hdhomerun": {
+        "channels": "Channels",
+        "hd": "HD"
+    },
+    "widget": {
+        "missing_type": "Відсутній тип віджета: {{type}}",
+        "api_error": "Помилка API",
+        "information": "Інформація",
+        "status": "Стан",
+        "url": "URL",
+        "raw_error": "Помилка Raw",
+        "response_data": "Дані відповіді"
+    },
+    "weather": {
+        "current": "Поточне розташування",
+        "allow": "Натисніть, щоб дозволити",
+        "updating": "Оновлення",
+        "wait": "Будь ласка, зачекайте"
+    },
+    "search": {
+        "placeholder": "Пошук…"
+    },
+    "resources": {
+        "cpu": "CPU",
+        "total": "Всього",
+        "free": "Вільно",
+        "used": "Використано",
+        "load": "Навантаження"
+    },
+    "unifi": {
+        "users": "Користувачі",
+        "uptime": "Час роботи системи",
+        "days": "Днів",
+        "wan": "WAN",
+        "lan": "LAN",
+        "wlan": "WLAN",
+        "devices": "Пристрої",
+        "lan_devices": "LAN пристрої",
+        "wlan_devices": "WLAN пристрої",
+        "lan_users": "LAN користувачі",
+        "wlan_users": "WLAN користувачі",
+        "up": "Відправка",
+        "down": "Завантаження",
+        "wait": "Будь ласка, зачекайте"
+    },
+    "docker": {
+        "rx": "RX",
+        "tx": "TX",
+        "mem": "Пам'ять",
+        "cpu": "CPU",
+        "offline": "Офлайн",
+        "error": "Помилка",
+        "unknown": "Невідомий"
+    },
+    "ping": {
+        "error": "Помилка",
+        "ping": "Пінг"
+    },
+    "emby": {
+        "playing": "Відтворення",
+        "transcoding": "Перекодування",
+        "bitrate": "Бітрейт",
+        "no_active": "Немає активних потоків"
+    },
+    "flood": {
+        "download": "Завантаження",
+        "upload": "Відправлення",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "changedetectionio": {
+        "totalObserved": "Всього спостережень",
+        "diffsDetected": "Виявлено відмінності"
+    },
+    "tautulli": {
+        "playing": "Відтворення",
+        "transcoding": "Перекодування",
+        "bitrate": "Бітрейт",
+        "no_active": "Немає активних потоків"
+    },
+    "nzbget": {
+        "rate": "Швидкість",
+        "downloaded": "Завантажено",
+        "remaining": "Залишилося"
+    },
+    "plex": {
+        "streams": "Активні потоки",
+        "movies": "Фільми",
+        "tv": "TБ шоу"
+    },
+    "transmission": {
+        "download": "Завантаження",
+        "upload": "Відправлення",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "qbittorrent": {
+        "download": "Завантаження",
+        "upload": "Відправлення",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "downloadstation": {
+        "download": "Завантаження",
+        "upload": "Відправлення",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "sonarr": {
+        "wanted": "Розшукується",
+        "queued": "У черзі",
+        "series": "Серії"
+    },
+    "radarr": {
+        "wanted": "Розшукується",
+        "missing": "Відсутній",
+        "queued": "У черзі",
+        "movies": "Фільми"
+    },
+    "lidarr": {
+        "wanted": "Розшукується",
+        "queued": "У черзі",
+        "albums": "Альбоми"
+    },
+    "traefik": {
+        "middleware": "Middleware",
+        "routers": "Роутери",
+        "services": "Сервіси"
+    },
+    "navidrome": {
+        "nothing_streaming": "No Active Streams",
+        "please_wait": "Please Wait"
+    },
+    "bazarr": {
+        "missingEpisodes": "Відсутні епізоди",
+        "missingMovies": "Відсутні фільми"
+    },
+    "ombi": {
+        "pending": "В очікуванні",
+        "approved": "Затверджено",
+        "available": "Доступно"
+    },
+    "jellyseerr": {
+        "pending": "В очікуванні",
+        "approved": "Затверджено",
+        "available": "Доступно"
+    },
+    "overseerr": {
+        "pending": "В очікуванні",
+        "processing": "Обробка",
+        "approved": "Затверджено",
+        "available": "Доступно"
+    },
+    "pihole": {
+        "queries": "Запити",
+        "blocked": "Заблоковано",
+        "gravity": "Гравітація"
+    },
+    "adguard": {
+        "queries": "Запити",
+        "blocked": "Заблоковано",
+        "filtered": "Відфільтровано",
+        "latency": "Затримка"
+    },
+    "speedtest": {
+        "upload": "Відправлення",
+        "download": "Завантаження",
+        "ping": "Пінг"
+    },
+    "portainer": {
+        "running": "Запущено",
+        "stopped": "Зупинено",
+        "total": "Всього"
+    },
+    "tdarr": {
+        "queue": "Черга",
+        "processed": "Обробка",
+        "errored": "Помилка",
+        "saved": "Збережено"
+    },
+    "npm": {
+        "enabled": "Enabled",
+        "disabled": "Disabled",
+        "total": "Total"
+    },
+    "coinmarketcap": {
+        "configure": "Configure one or more crypto currencies to track",
+        "1hour": "1 Hour",
+        "1day": "1 Day",
+        "7days": "7 Days",
+        "30days": "30 Days"
+    },
+    "mastodon": {
+        "domain_count": "Domains",
+        "user_count": "Users",
+        "status_count": "Posts"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "gotify": {
+        "apps": "Applications",
+        "clients": "Clients",
+        "messages": "Messages"
+    },
+    "prowlarr": {
+        "enableIndexers": "Indexers",
+        "numberOfGrabs": "Grabs",
+        "numberOfQueries": "Queries",
+        "numberOfFailGrabs": "Fail Grabs",
+        "numberOfFailQueries": "Fail Queries"
+    },
+    "jackett": {
+        "configured": "Configured",
+        "errored": "Errored"
+    },
+    "strelaysrv": {
+        "numActiveSessions": "Sessions",
+        "numConnections": "Connections",
+        "dataRelayed": "Relayed",
+        "transferRate": "Rate"
+    },
+    "authentik": {
+        "users": "Users",
+        "loginsLast24H": "Logins (24h)",
+        "failedLoginsLast24H": "Failed Logins (24h)"
+    },
+    "proxmox": {
+        "mem": "MEM",
+        "cpu": "CPU",
+        "vms": "VMs",
+        "lxc": "LXC"
+    },
+    "glances": {
+        "cpu": "CPU",
+        "mem": "MEM",
+        "wait": "Please wait"
+    },
+    "quicklaunch": {
+        "bookmark": "Bookmark",
+        "service": "Service"
+    },
+    "homebridge": {
+        "available_update": "System",
+        "updates": "Updates",
+        "child_bridges_status": "{{ok}}/{{total}}",
+        "update_available": "Update Available",
+        "up_to_date": "Up to Date",
+        "child_bridges": "Child Bridges"
+    },
+    "watchtower": {
+        "containers_scanned": "Scanned",
+        "containers_updated": "Updated",
+        "containers_failed": "Failed"
+    },
+    "autobrr": {
+        "approvedPushes": "Approved",
+        "rejectedPushes": "Rejected",
+        "filters": "Filters",
+        "indexers": "Indexers"
+    },
+    "tubearchivist": {
+        "downloads": "Queue",
+        "videos": "Videos",
+        "channels": "Channels",
+        "playlists": "Playlists"
+    },
+    "truenas": {
+        "load": "System Load",
+        "uptime": "Uptime",
+        "alerts": "Alerts",
+        "time": "{{value, number(style: unit; unitDisplay: long;)}}"
+    },
+    "scrutiny": {
+        "passed": "Passed",
+        "failed": "Failed",
+        "unknown": "Unknown"
+    },
+    "paperlessngx": {
+        "inbox": "Inbox",
+        "total": "Total"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
+    }
+}

public/locales/vi/common.json

@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "Pending",
         "approved": "Đã duyệt",
-        "available": "Available"
+        "available": "Available",
+        "processing": "Processing"
     },
     "sabnzbd": {
         "rate": "Rate",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "seed": "Seed",
+        "leech": "Leech"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases",
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/yue/common.json

@@ -110,7 +110,8 @@
     "overseerr": {
         "pending": "待定",
         "approved": "批准",
-        "available": "可用"
+        "available": "可用",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "查詢",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/zh-CN/common.json

@@ -104,7 +104,8 @@
     "overseerr": {
         "pending": "待办",
         "approved": "已批准",
-        "available": "可用"
+        "available": "可用",
+        "processing": "Processing"
     },
     "sabnzbd": {
         "rate": "速率",
@@ -295,9 +296,9 @@
         "indexers": "Indexers"
     },
     "watchtower": {
-        "containers_scanned": "Scanned",
-        "containers_updated": "Updated",
-        "containers_failed": "Failed"
+        "containers_scanned": "以扫描",
+        "containers_updated": "以升级",
+        "containers_failed": "失败"
     },
     "tubearchivist": {
         "downloads": "Queue",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "leech": "Leech",
+        "download": "Download",
+        "upload": "Upload",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "saved": "Saved",
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

public/locales/zh-Hant/common.json

@@ -89,7 +89,8 @@
     "overseerr": {
         "pending": "Pending",
         "approved": "Approved",
-        "available": "Available"
+        "available": "Available",
+        "processing": "Processing"
     },
     "pihole": {
         "queries": "Queries",
@@ -348,5 +349,59 @@
         "upload": "Upload",
         "leech": "Leech",
         "seed": "Seed"
+    },
+    "flood": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "tdarr": {
+        "queue": "Queue",
+        "processed": "Processed",
+        "errored": "Errored",
+        "saved": "Saved"
+    },
+    "miniflux": {
+        "read": "Read",
+        "unread": "Unread"
+    },
+    "nextdns": {
+        "wait": "Please Wait",
+        "no_devices": "No Device Data Received"
+    },
+    "common": {
+        "bibyterate": "{{value, rate(bits: false; binary: true)}}",
+        "bibitrate": "{{value, rate(bits: true; binary: true)}}"
+    },
+    "omada": {
+        "connectedAp": "Connected APs",
+        "activeUser": "Active devices",
+        "alerts": "Alerts",
+        "connectedGateway": "Connected gateways",
+        "connectedSwitches": "Connected switches"
+    },
+    "downloadstation": {
+        "download": "Download",
+        "upload": "Upload",
+        "leech": "Leech",
+        "seed": "Seed"
+    },
+    "mikrotik": {
+        "cpuLoad": "CPU Load",
+        "memoryUsed": "Memory Used",
+        "uptime": "Uptime",
+        "numberOfLeases": "Leases"
+    },
+    "xteve": {
+        "streams_all": "All Streams",
+        "streams_active": "Active Streams",
+        "streams_xepg": "XEPG Channels"
+    },
+    "opnsense": {
+        "cpu": "CPU Load",
+        "memory": "Active Memory",
+        "wanUpload": "WAN Upload",
+        "wanDownload": "WAN Download"
     }
 }

src/components/quicklaunch.jsx

@@ -107,18 +107,19 @@ export default function QuickLaunch({servicesAndBookmarks, searchString, setSear
 
   function highlightText(text) {
     const parts = text.split(new RegExp(`(${searchString})`, 'gi'));
-    return <span>{parts.map(part => part.toLowerCase() === searchString.toLowerCase() ? <span className="bg-theme-300/10">{part}</span> : part)}</span>;
+    // eslint-disable-next-line react/no-array-index-key
+    return <span>{parts.map((part, i) => part.toLowerCase() === searchString.toLowerCase() ? <span key={`${searchString}_${i}`} className="bg-theme-300/10">{part}</span> : part)}</span>;
   }
 
   return (
     <div className={classNames(
-      "relative z-10 ease-in-out duration-300 transition-opacity",
+      "relative z-20 ease-in-out duration-300 transition-opacity",
       hidden && !isOpen && "hidden",
       !hidden && isOpen && "opacity-100",
       !isOpen && "opacity-0",
     )} role="dialog" aria-modal="true">
       <div className="fixed inset-0 bg-gray-500 bg-opacity-50" />
-      <div className="fixed inset-0 z-10 overflow-y-auto">
+      <div className="fixed inset-0 z-20 overflow-y-auto">
         <div className="flex min-h-full min-w-full items-start justify-center text-center">
           <dialog className="mt-[10%] min-w-[80%] max-w-[90%] md:min-w-[40%] rounded-md p-0 block font-medium text-theme-700 dark:text-theme-200 dark:hover:text-theme-300 shadow-md shadow-theme-900/10 dark:shadow-theme-900/20 bg-theme-50 dark:bg-theme-800">
             <input placeholder="Search" className={classNames(

src/components/resolvedicon.jsx

@@ -1,9 +1,9 @@
 import Image from "next/future/image";
 
-export default function ResolvedIcon({ icon }) {
+export default function ResolvedIcon({ icon, width = 32, height = 32 }) {
   // direct or relative URLs
   if (icon.startsWith("http") || icon.startsWith("/")) {
-    return <Image src={`${icon}`} width={32} height={32} alt="logo" />;
+    return <Image src={`${icon}`} width={width} height={height} alt="logo" />;
   }
 
   // mdi- prefixed, material design icons
@@ -12,8 +12,8 @@ export default function ResolvedIcon({ icon }) {
     return (
       <div
         style={{
-          width: 32,
-          height: 32,
+          width,
+          height,
           maxWidth: '100%',
           maxHeight: '100%',
           background: "linear-gradient(180deg, rgb(var(--color-logo-start)), rgb(var(--color-logo-stop)))",
@@ -29,8 +29,8 @@ export default function ResolvedIcon({ icon }) {
   return (
     <Image
       src={`https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons/png/${iconName}.png`}
-      width={32}
-      height={32}
+      width={width}
+      height={height}
       alt="logo"
     />
   );

src/components/version.jsx

@@ -8,9 +8,9 @@ import cachedFetch from "utils/proxy/cached-fetch";
 export default function Version() {
   const { t, i18n } = useTranslation();
 
-  const buildTime = process.env.NEXT_PUBLIC_BUILDTIME ?? new Date().toISOString();
-  const revision = process.env.NEXT_PUBLIC_REVISION ?? "dev";
-  const version = process.env.NEXT_PUBLIC_VERSION ?? "dev";
+  const buildTime = process.env.NEXT_PUBLIC_BUILDTIME?.length ? process.env.NEXT_PUBLIC_BUILDTIME : new Date().toISOString();
+  const revision = process.env.NEXT_PUBLIC_REVISION?.length ? process.env.NEXT_PUBLIC_REVISION : "dev";
+  const version = process.env.NEXT_PUBLIC_VERSION?.length ?  process.env.NEXT_PUBLIC_VERSION : "dev";
 
   const cachedFetcher = (resource) => cachedFetch(resource, 5).then((res) => res.json());
 

src/components/widgets/datetime/datetime.jsx

@@ -15,22 +15,21 @@ const textSizes = {
 export default function DateTime({ options }) {
   const { text_size: textSize, format } = options;
   const { i18n } = useTranslation();
-  const [date, setDate] = useState(new Date());
-
+  const [date, setDate] = useState("");
+  
   useEffect(() => {
+    const dateFormat = new Intl.DateTimeFormat(i18n.language, { ...format });
     const interval = setInterval(() => {
-      setDate(new Date());
+      setDate(dateFormat.format(new Date()));
     }, 1000);
     return () => clearInterval(interval);
-  }, [setDate]);
-
-  const dateFormat = new Intl.DateTimeFormat(i18n.language, { ...format });
+  }, [date, setDate, i18n.language, format]);
 
   return (
     <div className="flex flex-col justify-center first:ml-0 ml-4">
       <div className="flex flex-row items-center grow justify-end">
         <span className={`text-theme-800 dark:text-theme-200 ${textSizes[textSize || "lg"]}`}>
-          {dateFormat.format(date)}
+          {date}
         </span>
       </div>
     </div>

src/components/widgets/logo/logo.jsx

@@ -1,56 +1,62 @@
-export default function Logo() {
+import ResolvedIcon from "components/resolvedicon"
+
+export default function Logo({ options }) {
   return (
     <div className="w-12 h-12 flex flex-row items-center align-middle mr-3 self-center">
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        viewBox="0 0 1024 1024"
-        style={{
-          enableBackground: "new 0 0 1024 1024",
-        }}
-        xmlSpace="preserve"
-        className="w-full h-full"
-      >
-        <style>
-          {
-            ".st0{display:none}.st3{stroke-linecap:square}.st3,.st4{fill:none;stroke:#fff;stroke-miterlimit:10}.st6{display:inline;fill:#333}.st7{fill:#fff}"
-          }
-        </style>
-        <g id="Icon">
-          <path
-            d="M771.9 191c27.7 0 50.1 26.5 50.1 59.3v186.4l-100.2.3V250.3c0-32.8 22.4-59.3 50.1-59.3z"
-            style={{
-              fill: "rgba(var(--color-logo-start))",
-            }}
-          />
-          <linearGradient
-            id="homepage_logo_gradient"
-            gradientUnits="userSpaceOnUse"
-            x1={200.746}
-            y1={225.015}
-            x2={764.986}
-            y2={789.255}
-          >
-            <stop
-              offset={0}
+      {options.icon ?
+        <ResolvedIcon icon={options.icon} width={48} height={48} /> :
+        // fallback to homepage logo
+        <svg
+          xmlns="http://www.w3.org/2000/svg"
+          viewBox="0 0 1024 1024"
+          style={{
+            enableBackground: "new 0 0 1024 1024",
+          }}
+          xmlSpace="preserve"
+          className="w-full h-full"
+        >
+          <style>
+            {
+              ".st0{display:none}.st3{stroke-linecap:square}.st3,.st4{fill:none;stroke:#fff;stroke-miterlimit:10}.st6{display:inline;fill:#333}.st7{fill:#fff}"
+            }
+          </style>
+          <g id="Icon">
+            <path
+              d="M771.9 191c27.7 0 50.1 26.5 50.1 59.3v186.4l-100.2.3V250.3c0-32.8 22.4-59.3 50.1-59.3z"
               style={{
-                stopColor: "rgba(var(--color-logo-start))",
+                fill: "rgba(var(--color-logo-start))",
               }}
             />
-            <stop
-              offset={1}
+            <linearGradient
+              id="homepage_logo_gradient"
+              gradientUnits="userSpaceOnUse"
+              x1={200.746}
+              y1={225.015}
+              x2={764.986}
+              y2={789.255}
+            >
+              <stop
+                offset={0}
+                style={{
+                  stopColor: "rgba(var(--color-logo-start))",
+                }}
+              />
+              <stop
+                offset={1}
+                style={{
+                  stopColor: "rgba(var(--color-logo-stop))",
+                }}
+              />
+            </linearGradient>
+            <path
+              d="M721.8 250.3c0-32.7 22.4-59.3 50.1-59.3H253.1c-27.7 0-50.1 26.5-50.1 59.3v582.2l90.2-75.7-.1-130.3H375v61.8l88-73.8 258.8 217.9V250.6"
               style={{
-                stopColor: "rgba(var(--color-logo-stop))",
+                fill: "url(#homepage_logo_gradient)",
               }}
             />
-          </linearGradient>
-          <path
-            d="M721.8 250.3c0-32.7 22.4-59.3 50.1-59.3H253.1c-27.7 0-50.1 26.5-50.1 59.3v582.2l90.2-75.7-.1-130.3H375v61.8l88-73.8 258.8 217.9V250.6"
-            style={{
-              fill: "url(#homepage_logo_gradient)",
-            }}
-          />
-        </g>
-      </svg>
+          </g>
+        </svg>
+      }
     </div>
-  );
+  )
 }

src/components/widgets/openmeteo/icon.jsx

@@ -1,4 +1,4 @@
-import mapIcon from "utils/weather/owm-condition-map";
+import mapIcon from "utils/weather/openmeteo-condition-map";
 
 export default function Icon({ condition, timeOfDay }) {
   const IconComponent = mapIcon(condition, timeOfDay);

src/components/widgets/resources/memory.jsx

@@ -52,7 +52,7 @@ export default function Memory({ expanded }) {
       <div className="flex flex-col ml-3 text-left min-w-[85px]">
         <span className="text-theme-800 dark:text-theme-200 text-xs flex flex-row justify-between">
           <div className="pl-0.5">
-            {t("common.bytes", { value: data.memory.freeMemMb * 1024 * 1024, maximumFractionDigits: 0, binary: true })}
+            {t("common.bytes", { value: data.memory.freeMemMb * 1024 * 1024, maximumFractionDigits: 1, binary: true })}
           </div>
           <div className="pr-1">{t("resources.free")}</div>
         </span>
@@ -61,7 +61,7 @@ export default function Memory({ expanded }) {
             <div className="pl-0.5">
               {t("common.bytes", {
                 value: data.memory.totalMemMb * 1024 * 1024,
-                maximumFractionDigits: 0,
+                maximumFractionDigits: 1,
                 binary: true,
               })}
             </div>

src/pages/api/docker/stats/[...service].js

@@ -14,7 +14,8 @@ export default async function handler(req, res) {
   }
 
   try {
-    const docker = new Docker(getDockerArguments(containerServer));
+    const dockerArgs = getDockerArguments(containerServer);
+    const docker = new Docker(dockerArgs.conn);
     const containers = await docker.listContainers({
       all: true,
     });
@@ -31,18 +32,44 @@ export default async function handler(req, res) {
     const containerNames = containers.map((container) => container.Names[0].replace(/^\//, ""));
     const containerExists = containerNames.includes(containerName);
 
-    if (!containerExists) {
-      res.status(200).send({
-        error: "not found",
+    if (containerExists) {
+      const container = docker.getContainer(containerName);
+      const stats = await container.stats({ stream: false });
+
+      res.status(200).json({
+        stats,
       });
       return;
     }
 
-    const container = docker.getContainer(containerName);
-    const stats = await container.stats({ stream: false });
+    // Try with a service deployed in Docker Swarm, if enabled
+    if (dockerArgs.swarm) {
+      const tasks = await docker.listTasks({
+          filters: {
+            service: [containerName],
+            // A service can have several offline containers, so we only look for an active one.
+            "desired-state": ["running"],
+          },
+        })
+        .catch(() => []);
 
-    res.status(200).json({
-      stats,
+      // For now we are only interested in the first one (in case replicas > 1).
+      // TODO: Show the result for all replicas/containers?
+      const taskContainerId = tasks.at(0)?.Status?.ContainerStatus?.ContainerID;
+
+      if (taskContainerId) {
+        const container = docker.getContainer(taskContainerId);
+        const stats = await container.stats({ stream: false });
+
+        res.status(200).json({
+          stats,
+        });
+        return;
+      }
+    }
+
+    res.status(200).send({
+      error: "not found",
     });
   } catch {
     res.status(500).send({

src/pages/api/docker/status/[...service].js

@@ -13,7 +13,8 @@ export default async function handler(req, res) {
   }
 
   try {
-    const docker = new Docker(getDockerArguments(containerServer));
+    const dockerArgs = getDockerArguments(containerServer);
+    const docker = new Docker(dockerArgs.conn);
     const containers = await docker.listContainers({
       all: true,
     });
@@ -29,18 +30,43 @@ export default async function handler(req, res) {
     const containerNames = containers.map((container) => container.Names[0].replace(/^\//, ""));
     const containerExists = containerNames.includes(containerName);
 
-    if (!containerExists) {
-      return res.status(200).send({
-        error: "not found",
+    if (containerExists) {
+      const container = docker.getContainer(containerName);
+      const info = await container.inspect();
+
+      return res.status(200).json({
+        status: info.State.Status,
+        health: info.State.Health?.Status,
       });
     }
 
-    const container = docker.getContainer(containerName);
-    const info = await container.inspect();
+    if (dockerArgs.swarm) {
+      const tasks = await docker.listTasks({
+          filters: {
+            service: [containerName],
+            // A service can have several offline containers, we only look for an active one.
+            "desired-state": ["running"],
+          },
+        })
+        .catch(() => []);
 
-    return res.status(200).json({
-      status: info.State.Status,
-      health: info.State.Health?.Status
+      // For now we are only interested in the first one (in case replicas > 1).
+      // TODO: Show the result for all replicas/containers?
+      const taskContainerId = tasks.at(0)?.Status?.ContainerStatus?.ContainerID;
+
+      if (taskContainerId) {
+        const container = docker.getContainer(taskContainerId);
+        const info = await container.inspect();
+
+        return res.status(200).json({
+          status: info.State.Status,
+          health: info.State.Health?.Status,
+        });
+      }
+    }
+
+    return res.status(200).send({
+      error: "not found",
     });
   } catch {
     return res.status(500).send({

src/pages/api/ping.js

@@ -15,11 +15,18 @@ export default async function handler(req, res) {
         });
     }
     
-    const startTime = performance.now();
-    const [status] = await httpProxy(pingURL, {
+    let startTime = performance.now();
+    let [status] = await httpProxy(pingURL, {
       method: "HEAD"
     });
-    const endTime = performance.now();
+    let endTime = performance.now();
+    
+    if (status >= 400) {
+      // try one more time as a GET in case HEAD is rejected for whatever reason
+      startTime = performance.now();
+      [status] = await httpProxy(pingURL);
+      endTime = performance.now();
+    }
 
     return res.status(200).json({
       status,

src/pages/api/widgets/openmeteo.js

@@ -1,8 +1,9 @@
 import cachedFetch from "utils/proxy/cached-fetch";
 
 export default async function handler(req, res) {
-  const { latitude, longitude, units, cache } = req.query;
+  const { latitude, longitude, units, cache, timezone } = req.query;
   const degrees = units === "imperial" ? "fahrenheit" : "celsius";
-  const apiUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&daily=sunrise,sunset&current_weather=true&temperature_unit=${degrees}&timezone=auto`;
+  const timezeone = timezone ?? 'auto'
+  const apiUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&daily=sunrise,sunset&current_weather=true&temperature_unit=${degrees}&timezone=${timezeone}`;
   return res.send(await cachedFetch(apiUrl, cache));
 }

src/utils/config/docker.js

@@ -22,11 +22,14 @@ export default function getDockerArguments(server) {
 
   if (servers[server]) {
     if (servers[server].socket) {
-      return { socketPath: servers[server].socket };
+      return { conn: { socketPath: servers[server].socket }, swarm: !!servers[server].swarm };
     }
 
     if (servers[server].host) {
-      return { host: servers[server].host, port: servers[server].port || null };
+      return {
+        conn: { host: servers[server].host, port: servers[server].port || null },
+        swarm: !!servers[server].swarm,
+      };
     }
 
     return servers[server];

src/utils/config/service-helpers.js

@@ -44,7 +44,7 @@ export async function servicesFromDocker() {
 
   const serviceServers = await Promise.all(
     Object.keys(servers).map(async (serverName) => {
-      const docker = new Docker(getDockerArguments(serverName));
+      const docker = new Docker(getDockerArguments(serverName).conn);
       const containers = await docker.listContainers({
         all: true,
       });
@@ -118,6 +118,7 @@ export function cleanServiceGroups(groups) {
           container,
           currency, // coinmarketcap widget
           symbols,
+          defaultinterval
         } = cleanedService.widget;
 
         cleanedService.widget = {
@@ -129,6 +130,7 @@ export function cleanServiceGroups(groups) {
 
         if (currency) cleanedService.widget.currency = currency;
         if (symbols) cleanedService.widget.symbols = symbols;
+        if (defaultinterval) cleanedService.widget.defaultinterval = defaultinterval;
 
         if (type === "docker") {
           if (server) cleanedService.widget.server = server;

src/utils/proxy/handlers/credentialed.js

@@ -7,7 +7,7 @@ import widgets from "widgets/widgets";
 
 const logger = createLogger("credentialedProxyHandler");
 
-export default async function credentialedProxyHandler(req, res) {
+export default async function credentialedProxyHandler(req, res, map) {
   const { group, service, endpoint } = req.query;
 
   if (group && service) {
@@ -36,6 +36,8 @@ export default async function credentialedProxyHandler(req, res) {
         headers["X-API-Token"] = `${widget.key}`;
       } else if (widget.type === "tubearchivist") {
         headers.Authorization = `Token ${widget.key}`;
+      } else if (widget.type === "miniflux") {
+        headers["X-Auth-Token"] = `${widget.key}`;
       } else {
         headers["X-API-Key"] = `${widget.key}`;
       }
@@ -47,6 +49,8 @@ export default async function credentialedProxyHandler(req, res) {
         headers,
       });
 
+      let resultData = data;
+
       if (status === 204 || status === 304) {
         return res.status(status).end();
       }
@@ -59,8 +63,12 @@ export default async function credentialedProxyHandler(req, res) {
         return res.status(500).json({error: {message: "Invalid data", url, data}});
       }
 
+      if (status === 200 && map) {
+        resultData = map(data);
+      }
+
       if (contentType) res.setHeader("Content-Type", contentType);
-      return res.status(status).send(data);
+      return res.status(status).send(resultData);
     }
   }
 

src/utils/weather/openmeteo-condition-map.js

@@ -0,0 +1,211 @@
+import * as Icons from "react-icons/wi";
+
+// see https://open-meteo.com/en/docs
+
+const conditions = [
+  {
+    code: 1,
+    icon: {
+      day: Icons.WiDayCloudy,
+      night: Icons.WiNightAltCloudy,
+    },
+  },
+  {
+    code: 2,
+    icon: {
+      day: Icons.WiDayCloudy,
+      night: Icons.WiNightAltCloudy,
+    },
+  },
+  {
+    code: 3,
+    icon: {
+      day: Icons.WiDayCloudy,
+      night: Icons.WiNightAltCloudy,
+    },
+  },
+  {
+    code: 45,
+    icon: {
+      day: Icons.WiDayFog,
+      night: Icons.WiNightFog,
+    },
+  },
+  {
+    code: 48,
+    icon: {
+      day: Icons.WiDayFog,
+      night: Icons.WiNightFog,
+    },
+  },
+  {
+    code: 51,
+    icon: {
+      day: Icons.WiDaySprinkle,
+      night: Icons.WiNightAltSprinkle,
+    },
+  },
+  {
+    code: 53,
+    icon: {
+      day: Icons.WiDaySprinkle,
+      night: Icons.WiNightAltSprinkle,
+    },
+  },
+  {
+    code: 55,
+    icon: {
+      day: Icons.WiDaySprinkle,
+      night: Icons.WiNightAltSprinkle,
+    },
+  },
+  {
+    code: 56,
+    icon: {
+      day: Icons.WiDaySleet,
+      night: Icons.WiNightAltSleet,
+    },
+  },
+  {
+    code: 57,
+    icon: {
+      day: Icons.WiDaySleet,
+      night: Icons.WiNightAltSleet,
+    },
+  },
+  {
+    code: 61,
+    icon: {
+      day: Icons.WiDayShowers,
+      night: Icons.WiNightAltShowers,
+    },
+  },
+  {
+    code: 63,
+    icon: {
+      day: Icons.WiDayShowers,
+      night: Icons.WiNightAltShowers,
+    },
+  },
+  {
+    code: 65,
+    icon: {
+      day: Icons.WiDayShowers,
+      night: Icons.WiNightAltShowers,
+    },
+  },
+  {
+    code: 66,
+    icon: {
+      day: Icons.WiDaySleet,
+      night: Icons.WiNightAltSleet,
+    },
+  },
+  {
+    code: 67,
+    icon: {
+      day: Icons.WiDaySleet,
+      night: Icons.WiNightAltSleet,
+    },
+  },
+  {
+    code: 71,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 73,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 75,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 77,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 80,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 81,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 82,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 85,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 86,
+    icon: {
+      day: Icons.WiDaySnow,
+      night: Icons.WiNightAltSnow,
+    },
+  },
+  {
+    code: 95,
+    icon: {
+      day: Icons.WiDayThunderstorm,
+      night: Icons.WiNightAltThunderstorm,
+    },
+  },
+  {
+    code: 96,
+    icon: {
+      day: Icons.WiDayThunderstorm,
+      night: Icons.WiNightAltThunderstorm,
+    },
+  },
+  {
+    code: 99,
+    icon: {
+      day: Icons.WiDayThunderstorm,
+      night: Icons.WiNightAltThunderstorm,
+    },
+  },
+];
+
+export default function mapIcon(weatherStatusCode, timeOfDay) {
+  const mapping = conditions.find((condition) => condition.code === weatherStatusCode);
+
+  if (mapping) {
+    if (timeOfDay === "day") {
+      return mapping.icon.day;
+    }
+
+    if (timeOfDay === "night") {
+      return mapping.icon.night;
+    }
+  }
+
+  return Icons.WiDaySunny;
+}

src/widgets/coinmarketcap/component.jsx

@@ -17,11 +17,12 @@ export default function Component({ service }) {
     { label: t("coinmarketcap.30days"), value: "30d" },
   ];
 
-  const [dateRange, setDateRange] = useState(dateRangeOptions[0].value);
-
   const { widget } = service;
   const { symbols } = widget;
   const currencyCode = widget.currency ?? "USD";
+  const interval = widget.defaultinterval ?? dateRangeOptions[0].value;
+
+  const [dateRange, setDateRange] = useState(interval);
 
   const { data: statsData, error: statsError } = useWidgetAPI(widget, "v1/cryptocurrency/quotes/latest", {
     symbol: `${symbols.join(",")}`,

src/widgets/components.js

@@ -8,8 +8,10 @@ const components = {
   changedetectionio: dynamic(() => import("./changedetectionio/component")),
   coinmarketcap: dynamic(() => import("./coinmarketcap/component")),
   deluge: dynamic(() => import("./deluge/component")),
+  downloadstation: dynamic(() => import("./downloadstation/component")),
   docker: dynamic(() => import("./docker/component")),
   emby: dynamic(() => import("./emby/component")),
+  flood: dynamic(() => import("./flood/component")),
   gluetun: dynamic(() => import("./gluetun/component")),
   gotify: dynamic(() => import("./gotify/component")),
   hdhomerun: dynamic(() => import("./hdhomerun/component")),
@@ -19,10 +21,15 @@ const components = {
   jellyseerr: dynamic(() => import("./jellyseerr/component")),
   lidarr: dynamic(() => import("./lidarr/component")),
   mastodon: dynamic(() => import("./mastodon/component")),
+  miniflux: dynamic(() => import("./miniflux/component")),
+  mikrotik: dynamic(() => import("./mikrotik/component")),
   navidrome: dynamic(() => import("./navidrome/component")),
+  nextdns: dynamic(() => import("./nextdns/component")),
   npm: dynamic(() => import("./npm/component")),
   nzbget: dynamic(() => import("./nzbget/component")),
+  omada: dynamic(() => import("./omada/component")),
   ombi: dynamic(() => import("./ombi/component")),
+  opnsense: dynamic(() => import("./opnsense/component")),
   overseerr: dynamic(() => import("./overseerr/component")),
   paperlessngx: dynamic(() => import("./paperlessngx/component")),
   pihole: dynamic(() => import("./pihole/component")),
@@ -41,12 +48,14 @@ const components = {
   speedtest: dynamic(() => import("./speedtest/component")),
   strelaysrv: dynamic(() => import("./strelaysrv/component")),
   tautulli: dynamic(() => import("./tautulli/component")),
+  tdarr: dynamic(() => import("./tdarr/component")),
   traefik: dynamic(() => import("./traefik/component")),
   transmission: dynamic(() => import("./transmission/component")),
   tubearchivist: dynamic(() => import("./tubearchivist/component")),
   truenas: dynamic(() => import("./truenas/component")),
   unifi: dynamic(() => import("./unifi/component")),
   watchtower: dynamic(() => import("./watchtower/component")),
+  xteve: dynamic(() => import("./xteve/component")),
 };
 
 export default components;

src/widgets/deluge/proxy.js

@@ -13,8 +13,8 @@ const dataParams = [
 ];
 const loginMethod = "auth.login";
 
-async function sendRpc(url, method, params, username, password) {
-  const [status, contentType, data] = await sendJsonRpcRequest(url, method, params, username, password);
+async function sendRpc(url, method, params) {
+  const [status, contentType, data] = await sendJsonRpcRequest(url, method, params);
   const json = JSON.parse(data.toString());
   if (json?.error) {
     if (json.error.code === 1) {
@@ -26,8 +26,8 @@ async function sendRpc(url, method, params, username, password) {
   return [status, contentType, data];
 }
 
-function login(url, username, password) {
-  return sendRpc(url, loginMethod, [password], username, password);
+function login(url, password) {
+  return sendRpc(url, loginMethod, [password]);
 }
 
 export default async function delugeProxyHandler(req, res) {
@@ -48,15 +48,15 @@ export default async function delugeProxyHandler(req, res) {
   const api = widgets?.[widget.type]?.api
   const url = new URL(formatApiCall(api, { ...widget }));
 
-  let [status, contentType, data] = await sendRpc(url, dataMethod, dataParams, widget.username, widget.password);
+  let [status, contentType, data] = await sendRpc(url, dataMethod, dataParams);
   if (status === 403) {
-    [status, contentType, data] = await login(url, widget.username, widget.password);
+    [status, contentType, data] = await login(url, widget.password);
     if (status !== 200) {
       return res.status(status).end(data);
     }
 
     // eslint-disable-next-line no-unused-vars
-    [status, contentType, data] = await sendRpc(url, dataMethod, dataParams, widget.username, widget.password);
+    [status, contentType, data] = await sendRpc(url, dataMethod, dataParams);
   }
 
   return res.status(status).end(data);

src/widgets/docker/component.jsx

@@ -46,7 +46,9 @@ export default function Component({ service }) {
   return (
     <Container service={service}>
       <Block label="docker.cpu" value={t("common.percent", { value: calculateCPUPercent(statsData.stats) })} />
-      <Block label="docker.mem" value={t("common.bytes", { value: statsData.stats.memory_stats.usage })} />
+      {statsData.stats.memory_stats.usage && 
+        <Block label="docker.mem" value={t("common.bytes", { value: statsData.stats.memory_stats.usage })} />
+      }
       {network && (
         <>
           <Block label="docker.rx" value={t("common.bytes", { value: network.rx_bytes })} />

src/widgets/downloadstation/component.jsx

@@ -0,0 +1,41 @@
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+import useWidgetAPI from "utils/proxy/use-widget-api";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+  const { widget } = service;
+  const { data: listData, error: listError } = useWidgetAPI(widget, "list");
+
+  if (listError) {
+    return <Container error={listError} />;
+  }
+
+  const tasks = listData?.data?.tasks;
+  if (!tasks) {
+    return (
+      <Container service={service}>
+        <Block label="downloadstation.leech" />
+        <Block label="downloadstation.download" />
+        <Block label="downloadstation.seed" />
+        <Block label="downloadstation.upload" />
+      </Container>
+    );
+  }
+
+  const rateDl = tasks.reduce((acc, task) => acc + (task?.additional?.transfer?.speed_download ?? 0), 0);
+  const rateUl = tasks.reduce((acc, task) => acc + (task?.additional?.transfer?.speed_upload ?? 0), 0);
+  const completed = tasks.filter((task) => task?.additional?.transfer?.size_downloaded === task?.size)?.length || 0;
+  const leech = tasks.length - completed || 0;
+
+  return (
+    <Container service={service}>
+      <Block label="downloadstation.leech" value={t("common.number", { value: leech })} />
+      <Block label="downloadstation.download" value={t("common.bitrate", { value: rateDl })} />
+      <Block label="downloadstation.seed" value={t("common.number", { value: completed })} />
+      <Block label="downloadstation.upload" value={t("common.bitrate", { value: rateUl })} />
+    </Container>
+  );
+}

src/widgets/downloadstation/proxy.js

@@ -0,0 +1,70 @@
+import { formatApiCall } from "utils/proxy/api-helpers";
+import { httpProxy } from "utils/proxy/http";
+import createLogger from "utils/logger";
+import widgets from "widgets/widgets";
+import getServiceWidget from "utils/config/service-helpers";
+
+const logger = createLogger("downloadstationProxyHandler");
+const authApi = "{url}/webapi/auth.cgi?api=SYNO.API.Auth&version=2&method=login&account={username}&passwd={password}&session=DownloadStation&format=cookie"
+
+async function login(widget) {
+  const loginUrl = formatApiCall(authApi, widget);
+  const [status, contentType, data] = await httpProxy(loginUrl);
+  if (status !== 200) {
+    return [status, contentType, data];
+  }
+
+  const json = JSON.parse(data.toString());
+  if (json?.success !== true) {
+    // from https://global.download.synology.com/download/Document/Software/DeveloperGuide/Package/DownloadStation/All/enu/Synology_Download_Station_Web_API.pdf
+    /*
+      Code Description
+      400  No such account or incorrect password
+      401  Account disabled
+      402  Permission denied
+      403  2-step verification code required
+      404  Failed to authenticate 2-step verification code
+    */
+    let message = "Authentication failed.";
+    if (json?.error?.code >= 403) message += " 2FA enabled.";
+    logger.warn("Unable to login.  Code: %d", json?.error?.code);
+    return [401, "application/json", JSON.stringify({ code: json?.error?.code, message })];
+  }
+
+  return [status, contentType, data];
+}
+
+export default async function downloadstationProxyHandler(req, res) {
+  const { group, service, endpoint } = req.query;
+
+  if (!group || !service) {
+    return res.status(400).json({ error: "Invalid proxy service type" });
+  }
+
+  const widget = await getServiceWidget(group, service);
+  const api = widgets?.[widget.type]?.api;
+  if (!api) {
+    return res.status(403).json({ error: "Service does not support API calls" });
+  }
+
+  const url = formatApiCall(api, { endpoint, ...widget });
+  let [status, contentType, data] = await httpProxy(url);
+  if (status !== 200) {
+    logger.debug("Error %d calling endpoint %s", status, url);
+    return res.status(status, data);
+  }
+
+  const json = JSON.parse(data.toString());
+  if (json?.success !== true) {
+    logger.debug("Logging in to DownloadStation");
+    [status, contentType, data] = await login(widget);
+    if (status !== 200) {
+      return res.status(status).end(data)
+    }
+
+    [status, contentType, data] = await httpProxy(url);
+  }
+
+  if (contentType) res.setHeader("Content-Type", contentType);
+  return res.status(status).send(data);
+}

src/widgets/downloadstation/widget.js

@@ -0,0 +1,14 @@
+import downloadstationProxyHandler from "./proxy";
+
+const widget = {
+  api: "{url}/webapi/DownloadStation/task.cgi?api=SYNO.DownloadStation.Task&version=1&method={endpoint}",
+  proxyHandler: downloadstationProxyHandler,
+
+  mappings: {
+    "list": {
+      endpoint: "list&additional=transfer",
+    },
+  },
+};
+
+export default widget;

src/widgets/flood/component.jsx

@@ -0,0 +1,53 @@
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+import useWidgetAPI from "utils/proxy/use-widget-api";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+
+  const { data: torrentData, error: torrentError } = useWidgetAPI(widget, "torrents");
+
+  if (torrentError || !torrentData?.torrents) {
+    return <Container error={torrentError ?? {message: "No torrent data returned"}} />;
+  }
+
+  if (!torrentData || !torrentData.torrents) {
+    return (
+      <Container service={service}>
+        <Block label="flood.leech" />
+        <Block label="flood.download" />
+        <Block label="flood.seed" />
+        <Block label="flood.upload" />
+      </Container>
+    );
+  }
+
+  let rateDl = 0;
+  let rateUl = 0;
+  let completed = 0;
+  let leech = 0;
+
+  Object.values(torrentData.torrents).forEach(torrent => {
+    rateDl += torrent.downRate;
+    rateUl += torrent.upRate;
+    if(torrent.status.includes('complete')){
+      completed += 1;
+    }
+    if(torrent.status.includes('downloading')){
+      leech += 1;
+    }
+  })
+
+  return (
+    <Container service={service}>
+      <Block label="flood.leech" value={t("common.number", { value: leech })} />
+      <Block label="flood.download" value={t("common.bitrate", { value: rateDl })} />
+      <Block label="flood.seed" value={t("common.number", { value: completed })} />
+      <Block label="flood.upload" value={t("common.bitrate", { value: rateUl })} />
+    </Container>
+  );
+}

src/widgets/flood/proxy.js

@@ -0,0 +1,66 @@
+import { formatApiCall } from "utils/proxy/api-helpers";
+import { httpProxy } from "utils/proxy/http";
+import getServiceWidget from "utils/config/service-helpers";
+import createLogger from "utils/logger";
+
+const logger = createLogger("floodProxyHandler");
+
+async function login(widget) {
+  logger.debug("flood is rejecting the request, logging in.");
+  const loginUrl = new URL(`${widget.url}/api/auth/authenticate`).toString();
+
+  const loginParams = { 
+    method: "POST", 
+    headers: { "Content-Type": "application/json" }, 
+    body: null
+  };
+
+  if (widget.username && widget.password) {
+    loginParams.body = JSON.stringify({
+      "username": widget.username,
+      "password": widget.password
+    });
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  const [status, contentType, data] = await httpProxy(loginUrl, loginParams);
+  return [status, data];
+}
+
+export default async function floodProxyHandler(req, res) {
+  const { group, service, endpoint } = req.query;
+
+  if (!group || !service) {
+    logger.debug("Invalid or missing service '%s' or group '%s'", service, group);
+    return res.status(400).json({ error: "Invalid proxy service type" });
+  }
+
+  const widget = await getServiceWidget(group, service);
+
+  if (!widget) {
+    logger.debug("Invalid or missing widget for service '%s' in group '%s'", service, group);
+    return res.status(400).json({ error: "Invalid proxy service type" });
+  }
+
+  const url = new URL(formatApiCall("{url}/api/{endpoint}", { endpoint, ...widget }));
+  const params = { method: "GET", headers: {} };
+
+  let [status, contentType, data] = await httpProxy(url, params);
+  if (status === 401) {
+    [status, data] = await login(widget);
+
+    if (status !== 200) {
+      logger.error("HTTP %d logging in to flood.  Data: %s", status, data);
+      return res.status(status).end(data);
+    }
+
+    [status, contentType, data] = await httpProxy(url, params);
+  }
+
+  if (status !== 200) {
+    logger.error("HTTP %d getting data from flood.  Data: %s", status, data);
+  }
+
+  if (contentType) res.setHeader("Content-Type", contentType);
+  return res.status(status).send(data);
+}

src/widgets/flood/widget.js

@@ -0,0 +1,7 @@
+import floodProxyHandler from "./proxy";
+
+const widget = {
+  proxyHandler: floodProxyHandler,
+};
+
+export default widget;

src/widgets/homebridge/proxy.js

@@ -10,7 +10,7 @@ const proxyName = "homebridgeProxyHandler";
 const sessionTokenCacheKey = `${proxyName}__sessionToken`;
 const logger = createLogger(proxyName);
 
-async function login(widget) {
+async function login(widget, service) {
   const endpoint = "auth/login";
   const api = widgets?.[widget.type]?.api
   const loginUrl = new URL(formatApiCall(api, { endpoint, ...widget }));
@@ -26,7 +26,7 @@ async function login(widget) {
   try {
     const { access_token: accessToken, expires_in: expiresIn } = JSON.parse(data.toString());
   
-    cache.put(sessionTokenCacheKey, accessToken, (expiresIn * 1000) - 5 * 60 * 1000); // expiresIn (s) - 5m
+    cache.put(`${sessionTokenCacheKey}.${service}`, accessToken, (expiresIn * 1000) - 5 * 60 * 1000); // expiresIn (s) - 5m
     return { accessToken };
   } catch (e) {
     logger.error("Unable to login to Homebridge API: %s", e);
@@ -35,10 +35,11 @@ async function login(widget) {
   return { accessToken: false };
 }
 
-async function apiCall(widget, endpoint) {
+async function apiCall(widget, endpoint, service) {
+  const key = `${sessionTokenCacheKey}.${service}`;
   const headers = {
     "content-type": "application/json",
-    "Authorization": `Bearer ${cache.get(sessionTokenCacheKey)}`,
+    "Authorization": `Bearer ${cache.get(key)}`,
   }
 
   const url = new URL(formatApiCall(widgets[widget.type].api, { endpoint, ...widget }));
@@ -51,7 +52,7 @@ async function apiCall(widget, endpoint) {
 
   if (status === 401) {
     logger.debug("Homebridge API rejected the request, attempting to obtain new session token");
-    const { accessToken } = login(widget);
+    const { accessToken } = login(widget, service);
     headers.Authorization = `Bearer ${accessToken}`;
 
     // retry the request, now with the new session token
@@ -83,14 +84,14 @@ export default async function homebridgeProxyHandler(req, res) {
     return res.status(400).json({ error: "Invalid proxy service type" });
   }
 
-  if (!cache.get(sessionTokenCacheKey)) {
-    await login(widget);
+  if (!cache.get(`${sessionTokenCacheKey}.${service}`)) {
+    await login(widget, service);
   }
 
-  const { data: statusData } = await apiCall(widget, "status/homebridge");
-  const { data: versionData } = await apiCall(widget, "status/homebridge-version");
-  const { data: childBridgeData } = await apiCall(widget, "status/homebridge/child-bridges");
-  const { data: pluginsData } = await apiCall(widget, "plugins");
+  const { data: statusData } = await apiCall(widget, "status/homebridge", service);
+  const { data: versionData } = await apiCall(widget, "status/homebridge-version", service);
+  const { data: childBridgeData } = await apiCall(widget, "status/homebridge/child-bridges", service);
+  const { data: pluginsData } = await apiCall(widget, "plugins", service);
 
   return res.status(200).send({
       status: statusData?.status,

src/widgets/mikrotik/component.jsx

@@ -0,0 +1,43 @@
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+import useWidgetAPI from "utils/proxy/use-widget-api";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+
+  const { data: statsData, error: statsError } = useWidgetAPI(widget, "system");
+  const { data: leasesData, error: leasesError } = useWidgetAPI(widget, "leases");
+
+  if (statsError || leasesError) {
+    const finalError = statsError ?? leasesError;
+    return <Container error={ finalError } />;
+  }
+
+  if (!statsData || !leasesData) {
+    return (
+      <Container service={service}>
+        <Block label="mikrotik.uptime" />
+        <Block label="mikrotik.cpuLoad" />
+        <Block label="mikrotik.memoryUsed" />
+        <Block label="mikrotik.numberOfLeases" />
+      </Container>
+    );
+  }
+
+  const memoryUsed = 100 - (statsData['free-memory'] / statsData['total-memory'])*100
+
+  const numberOfLeases = leasesData.length
+
+  return (
+    <Container service={service}>
+      <Block label="mikrotik.uptime" value={ statsData.uptime } />
+      <Block label="mikrotik.cpuLoad" value={t("common.percent", { value: statsData['cpu-load'] })} />
+      <Block label="mikrotik.memoryUsed" value={t("common.percent", { value: memoryUsed })} />
+      <Block label="mikrotik.numberOfLeases" value={t("common.number", { value: numberOfLeases })} />
+    </Container>
+  );
+}

src/widgets/mikrotik/widget.js

@@ -0,0 +1,24 @@
+
+import genericProxyHandler from "utils/proxy/handlers/generic";
+
+const widget = {
+  api: "{url}/rest/{endpoint}",
+  proxyHandler: genericProxyHandler,
+
+  mappings: {
+    system: {
+      endpoint: "system/resource",
+      validate: [
+        "cpu-load",
+        "free-memory",
+        "total-memory",
+        "uptime"
+      ]
+    },
+    leases: {
+      endpoint: "ip/dhcp-server/lease",
+    }
+  },
+};
+
+export default widget;

src/widgets/miniflux/component.jsx

@@ -0,0 +1,33 @@
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+import useWidgetAPI from "utils/proxy/use-widget-api";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+
+  const { data: minifluxData, error: minifluxError } = useWidgetAPI(widget, "counters");
+
+  if (minifluxError) {
+    return <Container error={minifluxError} />;
+  }
+
+  if (!minifluxData) {
+    return (
+      <Container service={service}>
+        <Block label="miniflux.unread" />
+        <Block label="miniflux.read" />
+      </Container>
+    );
+  }
+
+  return (
+    <Container service={service}>
+      <Block label="miniflux.unread" value={t("common.number", { value: minifluxData.unread })} />
+      <Block label="miniflux.read" value={t("common.number", { value: minifluxData.read })} />
+    </Container>
+  );
+}

src/widgets/miniflux/widget.js

@@ -0,0 +1,19 @@
+import { asJson } from "utils/proxy/api-helpers";
+import credentialedProxyHandler from "utils/proxy/handlers/credentialed";
+
+const widget = {
+  api: "{url}/v1/{endpoint}",
+  proxyHandler: credentialedProxyHandler,
+  
+  mappings: {
+    counters: {
+      endpoint: "feeds/counters",
+      map: (data) => ({
+        read: Object.values(asJson(data).reads).reduce((acc, i) => acc + i, 0),
+        unread: Object.values(asJson(data).unreads).reduce((acc, i) => acc + i, 0)
+      }),
+    },
+  }
+};
+
+export default widget;

src/widgets/nextdns/component.jsx

@@ -0,0 +1,39 @@
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+import useWidgetAPI from "utils/proxy/use-widget-api";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+
+  const { data: nextdnsData, error: nextdnsError } = useWidgetAPI(widget, "analytics/status");
+
+  if (nextdnsError) {
+    return <Container error={nextdnsError} />;
+  }
+
+  if (!nextdnsData) {
+    return (
+      <Container service={service}>
+        <Block key="status" label="widget.status" value={t("nextdns.wait")} />
+      </Container>
+    );
+  }
+
+  if (!nextdnsData?.data?.length) {
+    return (
+      <Container service={service}>
+        <Block key="status" label="widget.status" value={t("nextdns.no_devices")} />
+      </Container>
+    );
+  }
+
+  return (
+    <Container service={service}>
+      {nextdnsData.data.map(d => <Block key={d.status} label={d.status} value={t("common.number", { value: d.queries })} />)}
+    </Container>
+  );
+}

src/widgets/nextdns/widget.js

@@ -0,0 +1,17 @@
+import credentialedProxyHandler from "utils/proxy/handlers/credentialed";
+
+const widget = {
+  api: "https://api.nextdns.io/profiles/{profile}/{endpoint}",
+  proxyHandler: credentialedProxyHandler,
+
+  mappings: {
+    "analytics/status": {
+      endpoint: "analytics/status",
+      validate: [
+        "data",
+      ]
+    },
+  },
+};
+
+export default widget;

src/widgets/npm/proxy.js

@@ -10,7 +10,7 @@ const proxyName = "npmProxyHandler";
 const tokenCacheKey = `${proxyName}__token`;
 const logger = createLogger(proxyName);
 
-async function login(loginUrl, username, password) {
+async function login(loginUrl, username, password, service) {
   const authResponse = await httpProxy(loginUrl, {
     method: "POST",
     body: JSON.stringify({ identity: username, secret: password }),
@@ -20,12 +20,18 @@ async function login(loginUrl, username, password) {
   });
 
   const status = authResponse[0];
-  const data = JSON.parse(Buffer.from(authResponse[2]).toString());
+  let data = authResponse[2];
 
-  if (status === 200) {
-    cache.put(tokenCacheKey, data.token);
+  try {
+    data = JSON.parse(Buffer.from(authResponse[2]).toString());
+    
+    if (status === 200) {
+      const expiration = new Date(data.expires) - Date.now();
+      cache.put(`${tokenCacheKey}.${service}`, data.token, expiration - (5 * 60 * 1000)); // expiration -5 minutes
+    }
+  } catch (e) {
+    logger.error(`Error ${status} logging into npm`, authResponse[2]);
   }
-
   return [status, data.token ?? data];
 }
 
@@ -47,12 +53,12 @@ export default async function npmProxyHandler(req, res) {
       let contentType;
       let data;
       
-      let token = cache.get(tokenCacheKey);
+      let token = cache.get(`${tokenCacheKey}.${service}`);
       if (!token) {
-        [status, token] = await login(loginUrl, widget.username, widget.password);
+        [status, token] = await login(loginUrl, widget.username, widget.password, service);
         if (status !== 200) {
-          logger.debug(`HTTTP ${status} logging into npm api: ${data}`);
-          return res.status(status).send(data);
+          logger.debug(`HTTTP ${status} logging into npm api: ${token}`);
+          return res.status(status).send(token);
         }
       }
 
@@ -66,8 +72,8 @@ export default async function npmProxyHandler(req, res) {
 
       if (status === 403) {
         logger.debug(`HTTTP ${status} retrieving data from npm api, logging in and trying again.`);
-        cache.del(tokenCacheKey);
-        [status, token] = await login(loginUrl, widget.username, widget.password);
+        cache.del(`${tokenCacheKey}.${service}`);
+        [status, token] = await login(loginUrl, widget.username, widget.password, service);
 
         if (status !== 200) {
           logger.debug(`HTTTP ${status} logging into npm api: ${data}`);

src/widgets/omada/component.jsx

@@ -0,0 +1,39 @@
+import { useTranslation } from "next-i18next";
+
+import useWidgetAPI from "../../utils/proxy/use-widget-api";
+import Container from "../../components/services/widget/container";
+import Block from "../../components/services/widget/block";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+
+  const { data: omadaData, error: omadaAPIError } = useWidgetAPI(widget, {
+    refreshInterval: 5000,
+  });
+
+  if (omadaAPIError) {
+    return <Container error={omadaAPIError} />;
+  }
+
+  if (!omadaData) {
+    return (
+      <Container service={service}>
+        <Block label="omada.connectedAp" />
+        <Block label="omada.activeUser" />
+        <Block label="omada.alerts" />
+      </Container>
+    );
+  }
+
+  return (
+    <Container service={service}>
+      <Block label="omada.connectedAp" value={t( "common.number", { value: omadaData.connectedAp})} />
+      <Block label="omada.activeUser" value={t( "common.number", { value: omadaData.activeUser })} />
+      <Block label="omada.alerts" value={t( "common.number", { value: omadaData.alerts })} />
+      { omadaData.connectedGateways > 0 && <Block label="omada.connectedGateway" value={t("common.number", { value: omadaData.connectedGateways})} /> }
+      { omadaData.connectedSwitches > 0 && <Block label="omada.connectedSwitches" value={t("common.number", { value: omadaData.connectedSwitches})} /> }
+    </Container>
+  );
+}

src/widgets/omada/proxy.js

@@ -0,0 +1,252 @@
+
+import { httpProxy } from "utils/proxy/http";
+import getServiceWidget from "utils/config/service-helpers";
+import createLogger from "utils/logger";
+
+const proxyName = "omadaProxyHandler";
+
+const logger = createLogger(proxyName);
+
+async function login(loginUrl, username, password, controllerVersionMajor) {
+  const params = {
+    username,
+    password
+  }
+
+  if (controllerVersionMajor === 3) {
+    params.method = "login";
+    params.params = {
+      name: username,
+      password
+    };
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  const [status, contentType, data] = await httpProxy(loginUrl, {
+    method: "POST",
+    body: JSON.stringify(params),
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  return [status, JSON.parse(data.toString())];
+}
+
+
+export default async function omadaProxyHandler(req, res) {
+  const { group, service } = req.query;
+
+  if (group && service) {
+    const widget = await getServiceWidget(group, service);
+
+    if (widget) {
+
+      const {url} = widget;
+
+      const controllerInfoURL = `${widget.url}/api/info`;
+
+      let [status, contentType, data] = await httpProxy(controllerInfoURL, {
+          headers: {
+            "Content-Type": "application/json",
+          },
+      });
+
+      if (status !== 200) {
+        logger.error("Unable to retrieve Omada controller info");
+        return res.status(status).json({error: {message: `HTTP Error ${status}`, url: controllerInfoURL, data}});
+      }
+
+      let cId;
+      let controllerVersion;
+
+      try {
+        cId = JSON.parse(data).result.omadacId;
+        controllerVersion = JSON.parse(data).result.controllerVer;
+      } catch (e) {
+        controllerVersion = "3.2.x"
+      }
+
+      const controllerVersionMajor = parseInt(controllerVersion.split('.')[0], 10)
+
+      if (![3,4,5].includes(controllerVersionMajor)) {
+        return res.status(500).json({error: {message: "Error determining controller version", data}});
+      }
+
+      let loginUrl;
+
+      switch (controllerVersionMajor) {
+        case 3:
+          loginUrl = `${widget.url}/api/user/login?ajax`;
+          break;
+        case 4:
+          loginUrl = `${widget.url}/api/v2/login`;
+          break;
+        case 5:
+          loginUrl = `${widget.url}/${cId}/api/v2/login`;
+          break;
+        default:
+          break;
+      }
+      
+      const [loginStatus, loginResponseData] = await login(loginUrl, widget.username, widget.password, controllerVersionMajor);
+
+      if (loginStatus !== 200 || loginResponseData.errorCode > 0) {
+        return res.status(status).json({error: {message: "Error logging in to Oamda controller", url: loginUrl, data: loginResponseData}});
+      }
+
+      const { token } = loginResponseData.result;
+      
+      let sitesUrl;
+      let body = {};
+      let params = { token };
+      let headers = { "Csrf-Token": token };
+      let method = "GET";
+
+      switch (controllerVersionMajor) {
+        case 3:
+          sitesUrl = `${widget.url}/web/v1/controller?ajax=&token=${token}`;
+          body = {
+            "method": "getUserSites",
+            "params": {
+              "userName": widget.username
+            }
+          };
+          method = "POST";
+          break;
+        case 4:
+          sitesUrl = `${widget.url}/api/v2/sites?token=${token}&currentPage=1&currentPageSize=1000`;          
+          break;
+        case 5:
+          sitesUrl = `${widget.url}/${cId}/api/v2/sites?token=${token}&currentPage=1&currentPageSize=1000`;
+          break;
+        default:
+          break;
+      }
+      
+      [status, contentType, data] = await httpProxy(sitesUrl, {
+        method,
+        params,
+        body: JSON.stringify(body),
+        headers,
+      });
+
+      const sitesResponseData = JSON.parse(data);
+
+      if (sitesResponseData.errorCode > 0) {
+        logger.debug(`HTTTP ${status} getting sites list: ${sitesResponseData.msg}`);
+        return res.status(status).json({error: {message: "Error getting sites list", url, data: sitesResponseData}});
+      }
+
+      const site = (controllerVersionMajor === 3) ? 
+        sitesResponseData.result.siteList.find(s => s.name === widget.site):
+        sitesResponseData.result.data.find(s => s.name === widget.site);
+
+      if (!site) {
+        return res.status(status).json({error: {message: `Site ${widget.site} is not found`, url, data}});
+      }
+
+      let siteResponseData;
+
+      let connectedAp;
+      let activeUser;
+      let connectedSwitches;
+      let connectedGateways;
+      let alerts;
+
+      if (controllerVersionMajor === 3) {
+        // Omada v3 controller requires switching site
+        const switchUrl = `${widget.url}/web/v1/controller?ajax=&token=${token}`;
+        method = "POST";
+        body = {
+          method: "switchSite",
+          params: {
+            siteName: site.siteName,
+            userName: widget.username
+          }
+        };
+        headers = { "Content-Type": "application/json" };
+        params = { token };
+
+        [status, contentType, data] = await httpProxy(switchUrl, {
+          method,
+          params,
+          body: JSON.stringify(body),
+          headers,
+        });
+
+        const switchResponseData = JSON.parse(data);
+        if (status !== 200 || switchResponseData.errorCode > 0) {
+          logger.error(`HTTP ${status} getting sites list: ${data}`);
+          return res.status(status).json({error: {message: "Error switching site", url: switchUrl, data}});
+        }
+        
+        const statsUrl = `${widget.url}/web/v1/controller?getGlobalStat=&token=${token}`;
+        [status, contentType, data] = await httpProxy(statsUrl, {
+          method,
+          params,
+          body: JSON.stringify({
+            "method": "getGlobalStat",
+          }),
+          headers
+        });
+
+        siteResponseData = JSON.parse(data);
+
+        if (status !== 200 || siteResponseData.errorCode > 0) {
+          return res.status(status).json({error: {message: "Error getting stats", url: statsUrl, data}});
+        }
+
+        connectedAp = siteResponseData.result.connectedAp;
+        activeUser = siteResponseData.result.activeUser;
+        alerts = siteResponseData.result.alerts;
+      } else if (controllerVersionMajor === 4 || controllerVersionMajor === 5) {
+        const siteName = (controllerVersionMajor === 5) ? site.id : site.key;
+        const siteStatsUrl = (controllerVersionMajor === 4) ? 
+          `${url}/api/v2/sites/${siteName}/dashboard/overviewDiagram?token=${token}&currentPage=1&currentPageSize=1000` :
+          `${url}/${cId}/api/v2/sites/${siteName}/dashboard/overviewDiagram?token=${token}&currentPage=1&currentPageSize=1000`;
+
+        [status, contentType, data] = await httpProxy(siteStatsUrl, {
+          headers: {
+            "Csrf-Token": token,
+          },
+        });
+
+        siteResponseData = JSON.parse(data);
+        
+        if (status !== 200 || siteResponseData.errorCode > 0) {
+          logger.debug(`HTTP ${status} getting stats for site ${widget.site} with message ${siteResponseData.msg}`);
+          return res.status(500).send(data);
+        }
+
+        const alertUrl = (controllerVersionMajor === 4) ? 
+          `${url}/api/v2/sites/${siteName}/alerts/num?token=${token}&currentPage=1&currentPageSize=1000` :
+          `${url}/${cId}/api/v2/sites/${siteName}/alerts/num?token=${token}&currentPage=1&currentPageSize=1000`;
+
+        // eslint-disable-next-line no-unused-vars
+        [status, contentType, data] = await httpProxy(alertUrl, {
+          headers: {
+            "Csrf-Token": token,
+          },
+        });
+        const alertResponseData = JSON.parse(data);
+
+        activeUser = siteResponseData.result.totalClientNum;
+        connectedAp = siteResponseData.result.connectedApNum;
+        connectedGateways = siteResponseData.result.connectedGatewayNum;
+        connectedSwitches = siteResponseData.result.connectedSwitchNum;
+        alerts = alertResponseData.result.alertNum;
+      }
+
+      return res.send(JSON.stringify({
+        connectedAp,
+        activeUser,
+        alerts,
+        connectedGateways,
+        connectedSwitches,
+      }));
+    }
+  }
+
+  return res.status(400).json({ error: "Invalid proxy service type" });
+}

src/widgets/omada/widget.js

@@ -0,0 +1,7 @@
+import omadaProxyHandler from "./proxy";
+
+const widget = {
+  proxyHandler: omadaProxyHandler,
+};
+
+export default widget;

src/widgets/opnsense/component.jsx

@@ -0,0 +1,48 @@
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+import useWidgetAPI from "utils/proxy/use-widget-api";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+
+  const { data: activityData, error: activityError } = useWidgetAPI(widget, "activity");
+  const { data: interfaceData, error: interfaceError } = useWidgetAPI(widget, "interface");
+
+  if (activityError || interfaceError) {
+    const finalError = activityError ?? interfaceError;
+    return <Container error={ finalError } />;
+  }
+
+  if (!activityData || !interfaceData) {
+    return (
+      <Container service={service}>
+        <Block label="opnsense.cpu" />
+        <Block label="opnsense.memory" />
+        <Block label="opnsense.wanUpload" />
+        <Block label="opnsense.wanDownload" />
+      </Container>
+    );
+  }
+
+
+  const cpuIdle = activityData.headers[2].match(/ ([0-9.]+)% idle/)[1];
+  const cpu = 100 - parseFloat(cpuIdle);
+  const memory = activityData.headers[3].match(/Mem: (.+) Active,/)[1];
+
+  const wanUpload = interfaceData.interfaces.wan['bytes transmitted'];
+  const wanDownload = interfaceData.interfaces.wan['bytes received'];
+
+  return (
+    <Container service={service}>
+      <Block label="opnsense.cpu" value={t("common.percent", { value: cpu.toFixed(2) })}  />
+      <Block label="opnsense.memory" value={memory} />
+      <Block label="opnsense.wanUpload" value={t("common.bytes", { value: wanUpload })} />
+      <Block label="opnsense.wanDownload" value={t("common.bytes", { value: wanDownload })} />
+
+    </Container>
+  );
+}

src/widgets/opnsense/widget.js

@@ -0,0 +1,24 @@
+
+import genericProxyHandler from "utils/proxy/handlers/generic";
+
+const widget = {
+  api: "{url}/api/{endpoint}",
+  proxyHandler: genericProxyHandler,
+
+  mappings: {
+    activity: {
+      endpoint: "diagnostics/activity/getActivity",
+      validate: [
+        "headers"
+      ]
+    },
+    interface: {
+      endpoint: "diagnostics/traffic/interface",
+      validate: [
+        "interfaces"
+      ]
+    }
+  },
+};
+
+export default widget;

src/widgets/overseerr/component.jsx

@@ -1,8 +1,11 @@
+import { useTranslation } from "next-i18next";
+
 import Container from "components/services/widget/container";
 import Block from "components/services/widget/block";
 import useWidgetAPI from "utils/proxy/use-widget-api";
 
 export default function Component({ service }) {
+  const { t } = useTranslation();
   const { widget } = service;
 
   const { data: statsData, error: statsError } = useWidgetAPI(widget, "request/count");
@@ -15,6 +18,7 @@ export default function Component({ service }) {
     return (
       <Container service={service}>
         <Block label="overseerr.pending" />
+        <Block label="overseerr.processing" />
         <Block label="overseerr.approved" />
         <Block label="overseerr.available" />
       </Container>
@@ -23,9 +27,10 @@ export default function Component({ service }) {
 
   return (
     <Container service={service}>
-      <Block label="overseerr.pending" value={statsData.pending} />
-      <Block label="overseerr.approved" value={statsData.approved} />
-      <Block label="overseerr.available" value={statsData.available} />
+      <Block label="overseerr.pending" value={t("common.number", { value: statsData.pending })} />
+      <Block label="overseerr.processing" value={t("common.number", { value: statsData.processing })} />
+      <Block label="overseerr.approved" value={t("common.number", { value: statsData.approved })} />
+      <Block label="overseerr.available" value={t("common.number", { value: statsData.available })} />
     </Container>
   );
 }

src/widgets/overseerr/widget.js

@@ -9,6 +9,7 @@ const widget = {
       endpoint: "request/count",
       validate: [
         "pending",
+        "processing",
         "approved",
         "available",
       ],

src/widgets/pihole/component.jsx

@@ -9,7 +9,7 @@ export default function Component({ service }) {
 
   const { widget } = service;
 
-  const { data: piholeData, error: piholeError } = useWidgetAPI(widget, "api.php");
+  const { data: piholeData, error: piholeError } = useWidgetAPI(widget, "summaryRaw");
 
   if (piholeError) {
     return <Container error={piholeError} />;
@@ -27,9 +27,9 @@ export default function Component({ service }) {
 
   return (
     <Container service={service}>
-      <Block label="pihole.queries" value={t("common.number", { value: piholeData.dns_queries_today })} />
-      <Block label="pihole.blocked" value={t("common.number", { value: piholeData.ads_blocked_today })} />
-      <Block label="pihole.gravity" value={t("common.number", { value: piholeData.domains_being_blocked })} />
+      <Block label="pihole.queries" value={t("common.number", { value: parseInt(piholeData.dns_queries_today, 10) })} />
+      <Block label="pihole.blocked" value={t("common.number", { value: parseInt(piholeData.ads_blocked_today, 10) })} />
+      <Block label="pihole.gravity" value={t("common.number", { value: parseInt(piholeData.domains_being_blocked, 10) })} />
     </Container>
   );
 }

src/widgets/pihole/widget.js

@@ -1,12 +1,12 @@
 import genericProxyHandler from "utils/proxy/handlers/generic";
 
 const widget = {
-  api: "{url}/admin/{endpoint}",
+  api: "{url}/admin/api.php?{endpoint}&auth={key}",
   proxyHandler: genericProxyHandler,
 
   mappings: {
-    "api.php": {
-      endpoint: "api.php",
+    "summaryRaw": {
+      endpoint: "summaryRaw",
       validate: [
         "dns_queries_today",
         "ads_blocked_today",

src/widgets/plex/proxy.js

@@ -58,6 +58,9 @@ async function fetchFromPlexAPI(endpoint, widget) {
 
 export default async function plexProxyHandler(req, res) {
   const widget = await getWidget(req);
+  
+  const { service } = req.query;
+
   if (!widget) {
     return res.status(400).json({ error: "Invalid proxy service type" });
   }
@@ -74,23 +77,24 @@ export default async function plexProxyHandler(req, res) {
     streams = apiData.MediaContainer._attributes.size;
   }
 
-  let libraries = cache.get(librariesCacheKey);
+  let libraries = cache.get(`${librariesCacheKey}.${service}`);
   if (libraries === null) {
     logger.debug("Getting libraries from Plex API");
     [status, apiData] = await fetchFromPlexAPI("/library/sections", widget);
     if (apiData && apiData.MediaContainer) {
-      libraries = apiData.MediaContainer.Directory;
-      cache.put(librariesCacheKey, libraries, 1000 * 60 * 60 * 6);
+      libraries = [].concat(apiData.MediaContainer.Directory);
+      cache.put(`${librariesCacheKey}.${service}`, libraries, 1000 * 60 * 60 * 6);
     }
   }
 
-  let movies = cache.get(moviesCacheKey);
-  let tv = cache.get(tvCacheKey);
+  let movies = cache.get(`${moviesCacheKey}.${service}`);
+  let tv = cache.get(`${tvCacheKey}.${service}`);
   if (movies === null || tv === null) {
     movies = 0;
     tv = 0;
     logger.debug("Getting movie + tv counts from Plex API");
-    libraries.filter(l => ["movie", "show"].includes(l._attributes.type)).forEach(async (library) => {
+    const movieTVLibraries = libraries.filter(l => ["movie", "show"].includes(l._attributes.type));
+    await Promise.all(movieTVLibraries.map(async (library) => {
       [status, apiData] = await fetchFromPlexAPI(`/library/sections/${library._attributes.key}/all`, widget);
       if (apiData && apiData.MediaContainer) {
         const size = parseInt(apiData.MediaContainer._attributes.size, 10);
@@ -100,9 +104,9 @@ export default async function plexProxyHandler(req, res) {
           tv += size;
         }
       }
-      cache.put(tvCacheKey, tv, 1000 * 60 * 10);
-      cache.put(moviesCacheKey, movies, 1000 * 60 * 10);
-    });
+    }));
+    cache.put(`${tvCacheKey}.${service}`, tv, 1000 * 60 * 10);
+    cache.put(`${moviesCacheKey}.${service}`, movies, 1000 * 60 * 10);
   }
   
   const data = {

src/widgets/prowlarr/component.jsx

@@ -1,8 +1,11 @@
+import { useTranslation } from "react-i18next";
+
 import Container from "components/services/widget/container";
 import Block from "components/services/widget/block";
 import useWidgetAPI from "utils/proxy/use-widget-api";
 
 export default function Component({ service }) {
+  const { t } = useTranslation();
   const { widget } = service;
 
   const { data: indexersData, error: indexersError } = useWidgetAPI(widget, "indexer");
@@ -40,11 +43,11 @@ export default function Component({ service }) {
 
   return (
     <Container service={service}>
-      <Block label="prowlarr.enableIndexers" value={indexers.length} />
-      <Block label="prowlarr.numberOfGrabs" value={numberOfGrabs} />
-      <Block label="prowlarr.numberOfQueries" value={numberOfQueries} />
-      <Block label="prowlarr.numberOfFailGrabs" value={numberOfFailedGrabs} />
-      <Block label="prowlarr.numberOfFailQueries" value={numberOfFailedQueries} />
+      <Block label="prowlarr.enableIndexers" value={t("common.number", { value: indexers.length })} />
+      <Block label="prowlarr.numberOfGrabs" value={t("common.number", { value: numberOfGrabs })} />
+      <Block label="prowlarr.numberOfQueries" value={t("common.number", { value: numberOfQueries })} />
+      <Block label="prowlarr.numberOfFailGrabs" value={t("common.number", { value: numberOfFailedGrabs })} />
+      <Block label="prowlarr.numberOfFailQueries" value={t("common.number", { value: numberOfFailedQueries })} />
     </Container>
   );
 }

src/widgets/pyload/proxy.js

@@ -11,7 +11,7 @@ const logger = createLogger(proxyName);
 const sessionCacheKey = `${proxyName}__sessionId`;
 const isNgCacheKey = `${proxyName}__isNg`;
 
-async function fetchFromPyloadAPI(url, sessionId, params) {
+async function fetchFromPyloadAPI(url, sessionId, params, service) {
   const options = {
     body: params
       ? Object.keys(params)
@@ -25,10 +25,10 @@ async function fetchFromPyloadAPI(url, sessionId, params) {
   };
 
   // see https://github.com/benphelps/homepage/issues/517
-  const isNg = cache.get(isNgCacheKey);
+  const isNg = cache.get(`${isNgCacheKey}.${service}`);
   if (isNg && !params) {
     delete options.body;
-    options.headers.Cookie = cache.get(sessionCacheKey);
+    options.headers.Cookie = cache.get(`${sessionCacheKey}.${service}`);
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -43,19 +43,19 @@ async function fetchFromPyloadAPI(url, sessionId, params) {
   return [status, returnData, responseHeaders];
 }
 
-async function login(loginUrl, username, password = '') {
-  const [status, sessionId, responseHeaders] = await fetchFromPyloadAPI(loginUrl, null, { username, password });
+async function login(loginUrl, service, username, password = '') {
+  const [status, sessionId, responseHeaders] = await fetchFromPyloadAPI(loginUrl, null, { username, password }, service);
   
   // this API actually returns status 200 even on login failure
   if (status !== 200 || sessionId === false) {
     logger.error(`HTTP ${status} logging into Pyload API, returned: ${JSON.stringify(sessionId)}`);
   } else if (responseHeaders['set-cookie']?.join().includes('pyload_session')) {
     // Support pyload-ng, see https://github.com/benphelps/homepage/issues/517
-    cache.put(isNgCacheKey, true);
+    cache.put(`${isNgCacheKey}.${service}`, true);
     const sessionCookie = responseHeaders['set-cookie'][0];
-    cache.put(sessionCacheKey, sessionCookie, 60 * 60 * 23 * 1000); // cache for 23h
+    cache.put(`${sessionCacheKey}.${service}`, sessionCookie, 60 * 60 * 23 * 1000); // cache for 23h
   } else {
-    cache.put(sessionCacheKey, sessionId);
+    cache.put(`${sessionCacheKey}.${service}`, sessionId);
   }
 
   return sessionId;
@@ -72,14 +72,14 @@ export default async function pyloadProxyHandler(req, res) {
         const url = new URL(formatApiCall(widgets[widget.type].api, { endpoint, ...widget }));
         const loginUrl = `${widget.url}/api/login`;
 
-        let sessionId = cache.get(sessionCacheKey) ?? await login(loginUrl, widget.username, widget.password);
-        let [status, data] = await fetchFromPyloadAPI(url, sessionId);
+        let sessionId = cache.get(`${sessionCacheKey}.${service}`) ?? await login(loginUrl, service, widget.username, widget.password);
+        let [status, data] = await fetchFromPyloadAPI(url, sessionId, null, service);
 
         if (status === 403 || status === 401) {
           logger.info('Failed to retrieve data from Pyload API, trying to login again...');
-          cache.del(sessionCacheKey);
-          sessionId = await login(loginUrl, widget.username, widget.password);
-          [status, data] = await fetchFromPyloadAPI(url, sessionId);
+          cache.del(`${sessionCacheKey}.${service}`);
+          sessionId = await login(loginUrl, service, widget.username, widget.password);
+          [status, data] = await fetchFromPyloadAPI(url, sessionId, null, service);
         }
 
         if (data?.error || status !== 200) {

src/widgets/qbittorrent/component.jsx

@@ -44,9 +44,9 @@ export default function Component({ service }) {
   return (
     <Container service={service}>
       <Block label="qbittorrent.leech" value={t("common.number", { value: leech })} />
-      <Block label="qbittorrent.download" value={t("common.bitrate", { value: rateDl })} />
+      <Block label="qbittorrent.download" value={t("common.bibyterate", { value: rateDl, decimals: 1 })} />
       <Block label="qbittorrent.seed" value={t("common.number", { value: completed })} />
-      <Block label="qbittorrent.upload" value={t("common.bitrate", { value: rateUl })} />
+      <Block label="qbittorrent.upload" value={t("common.bibyterate", { value: rateUl, decimals: 1 })} />
     </Container>
   );
 }

src/widgets/radarr/component.jsx

@@ -1,8 +1,11 @@
+import { useTranslation } from "next-i18next";
+
 import Container from "components/services/widget/container";
 import Block from "components/services/widget/block";
 import useWidgetAPI from "utils/proxy/use-widget-api";
 
 export default function Component({ service }) {
+  const { t } = useTranslation();
   const { widget } = service;
 
   const { data: moviesData, error: moviesError } = useWidgetAPI(widget, "movie");
@@ -26,10 +29,10 @@ export default function Component({ service }) {
 
   return (
     <Container service={service}>
-      <Block label="radarr.wanted" value={moviesData.wanted} />
-      <Block label="radarr.missing" value={moviesData.missing} />
-      <Block label="radarr.queued" value={queuedData.totalCount} />
-      <Block label="radarr.movies" value={moviesData.have} />
+      <Block label="radarr.wanted" value={t("common.number", { value: moviesData.wanted })} />
+      <Block label="radarr.missing" value={t("common.number", { value: moviesData.missing })} />
+      <Block label="radarr.queued" value={t("common.number", { value: queuedData.totalCount })} />
+      <Block label="radarr.movies" value={t("common.number", { value: moviesData.have })} />
     </Container>
   );
 }

src/widgets/scrutiny/component.jsx

@@ -2,16 +2,37 @@ import Container from "components/services/widget/container";
 import Block from "components/services/widget/block";
 import useWidgetAPI from "utils/proxy/use-widget-api";
 
+
+// @see https://github.com/AnalogJ/scrutiny/blob/d8d56f77f9e868127c4849dac74d65512db658e8/webapp/frontend/src/app/shared/device-status.pipe.ts
+const DeviceStatus = {
+  passed: 0,
+  failed_smart: 1,
+  failed_scrutiny: 2,
+  failed_both: 3,
+
+  isFailed(s){ return s > this.passed && s <= this.failed_both},
+  isUnknown(s){ return s < this.passed || s > this.failed_both}
+}
+
+// @see https://github.com/AnalogJ/scrutiny/blob/d8d56f77f9e868127c4849dac74d65512db658e8/webapp/frontend/src/app/core/config/app.config.ts
+const DeviceStatusThreshold = {
+  smart: 1,
+  scrutiny: 2,
+  both: 3
+}
+
 export default function Component({ service }) {
   const { widget } = service;
 
+  const { data: scrutinySettings, error: scrutinySettingsError } = useWidgetAPI(widget, "settings");
   const { data: scrutinyData, error: scrutinyError } = useWidgetAPI(widget, "summary");
 
-  if (scrutinyError) {
-    return <Container error={scrutinyError} />;
+  if (scrutinyError || scrutinySettingsError) {
+    const finalError = scrutinyError ?? scrutinySettingsError;
+    return <Container error={finalError} />;
   }
 
-  if (!scrutinyData) {
+  if (!scrutinyData || !scrutinySettings) {
     return (
       <Container service={service}>
         <Block label="scrutiny.passed" />
@@ -19,13 +40,14 @@ export default function Component({ service }) {
         <Block label="scrutiny.unknown" />
       </Container>
     );
-  }
+  } 
 
   const deviceIds = Object.values(scrutinyData.data.summary);
-  
-  const passed = deviceIds.filter(deviceId => deviceId.device.device_status === 0)?.length || 0;
-  const failed = deviceIds.filter(deviceId => deviceId.device.device_status > 0 && deviceId.device.device_status <= 3)?.length || 0;
-  const unknown = deviceIds.length - (passed + failed) || 0;
+  const statusThreshold = scrutinySettings.settings.metrics.status_threshold;
+
+  const failed = deviceIds.filter(deviceId => (DeviceStatus.isFailed(deviceId.device.device_status) && statusThreshold === DeviceStatusThreshold.both) || [statusThreshold, DeviceStatus.failed_both].includes(deviceId.device.device_status))?.length || 0;
+  const unknown = deviceIds.filter(deviceId => DeviceStatus.isUnknown(deviceId.device.device_status))?.length || 0;
+  const passed = deviceIds.length - (failed + unknown);
 
   return (
     <Container service={service}>
@@ -33,5 +55,8 @@ export default function Component({ service }) {
       <Block label="scrutiny.failed" value={failed} />
       <Block label="scrutiny.unknown" value={unknown} />
     </Container>
+    
   );
+  
 }
+

src/widgets/scrutiny/widget.js

@@ -11,6 +11,12 @@ const widget = {
         "data",
       ]
     },
+    settings: {
+      endpoint: "settings",
+      validate: [
+        "settings",
+      ]
+    }
   },
 };
 

src/widgets/sonarr/component.jsx

@@ -1,8 +1,11 @@
+import { useTranslation } from "next-i18next";
+
 import Container from "components/services/widget/container";
 import Block from "components/services/widget/block";
 import useWidgetAPI from "utils/proxy/use-widget-api";
 
 export default function Component({ service }) {
+  const { t } = useTranslation();
   const { widget } = service;
 
   const { data: wantedData, error: wantedError } = useWidgetAPI(widget, "wanted/missing");
@@ -26,9 +29,9 @@ export default function Component({ service }) {
 
   return (
     <Container service={service}>
-      <Block label="sonarr.wanted" value={wantedData.totalRecords} />
-      <Block label="sonarr.queued" value={queuedData.totalRecords} />
-      <Block label="sonarr.series" value={seriesData.total} />
+      <Block label="sonarr.wanted" value={t("common.number", { value: wantedData.totalRecords })} />
+      <Block label="sonarr.queued" value={t("common.number", { value: queuedData.totalRecords })} />
+      <Block label="sonarr.series" value={t("common.number", { value: seriesData.total })} />
     </Container>
   );
 }

src/widgets/speedtest/component.jsx

@@ -29,9 +29,9 @@ export default function Component({ service }) {
     <Container service={service}>
       <Block
         label="speedtest.download"
-        value={t("common.bitrate", { value: speedtestData.data.download * 1024 * 1024 })}
+        value={t("common.bitrate", { value: speedtestData.data.download * 1000 * 1000 })}
       />
-      <Block label="speedtest.upload" value={t("common.bitrate", { value: speedtestData.data.upload * 1024 * 1024 })} />
+      <Block label="speedtest.upload" value={t("common.bitrate", { value: speedtestData.data.upload * 1000 * 1000 })} />
       <Block
         label="speedtest.ping"
         value={t("common.ms", {

src/widgets/tdarr/component.jsx

@@ -0,0 +1,42 @@
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+import useWidgetAPI from "utils/proxy/use-widget-api";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+
+  const { data: tdarrData, error: tdarrError } = useWidgetAPI(widget);
+
+  if (tdarrError) {
+    return <Container error={tdarrError} />;
+  }
+
+  if (!tdarrData) {
+    return (
+      <Container service={service}>
+        <Block label="tdarr.queue" />
+        <Block label="tdarr.processed" />
+        <Block label="tdarr.errored" />
+        <Block label="tdarr.saved" />
+      </Container>
+    );
+  }
+
+  const queue = parseInt(tdarrData.table1Count, 10) + parseInt(tdarrData.table4Count, 10);
+  const processed = parseInt(tdarrData.table2Count, 10) + parseInt(tdarrData.table5Count, 10);
+  const errored = parseInt(tdarrData.table3Count, 10) + parseInt(tdarrData.table6Count, 10);
+  const saved = parseFloat(tdarrData.sizeDiff, 10) * 1000000000;
+
+  return (
+    <Container service={service}>
+      <Block label="tdarr.queue" value={t("common.number", { value: queue })} />
+      <Block label="tdarr.processed" value={t("common.number", { value: processed })} />
+      <Block label="tdarr.errored" value={t("common.number", { value: errored })} />
+      <Block label="tdarr.saved" value={t("common.bytes", { value: saved })} />    
+    </Container>
+  );
+}

src/widgets/tdarr/proxy.js

@@ -0,0 +1,48 @@
+import { httpProxy } from "utils/proxy/http";
+import { formatApiCall } from "utils/proxy/api-helpers";
+import getServiceWidget from "utils/config/service-helpers";
+import createLogger from "utils/logger";
+import widgets from "widgets/widgets";
+
+const proxyName = "tdarrProxyHandler";
+const logger = createLogger(proxyName);
+
+export default async function tdarrProxyHandler(req, res) {
+  const { group, service, endpoint } = req.query;
+
+  if (!group || !service) {
+    logger.debug("Invalid or missing service '%s' or group '%s'", service, group);
+    return res.status(400).json({ error: "Invalid proxy service type" });
+  }
+
+  const widget = await getServiceWidget(group, service);
+
+  if (!widget) {
+    logger.debug("Invalid or missing widget for service '%s' in group '%s'", service, group);
+    return res.status(400).json({ error: "Invalid proxy service type" });
+  }
+
+  const url = new URL(formatApiCall(widgets[widget.type].api, { endpoint, ...widget }));
+
+  const [status, contentType, data] = await httpProxy(url, {
+    method: "POST",
+    body: JSON.stringify({
+      "data": {
+        "collection": "StatisticsJSONDB",
+        "mode": "getById",
+        "docID": "statistics"
+      },
+    }),
+    headers: {
+      "content-type": "application/json",
+    },
+  });
+
+  if (status !== 200) {
+    logger.error("Error getting data from Tdarr: %d.  Data: %s", status, data);
+    return res.status(500).send({error: {message:"Error getting data from Tdarr", url, data}});
+  }
+
+  if (contentType) res.setHeader("Content-Type", contentType);
+  return res.status(status).send(data);
+}

src/widgets/tdarr/widget.js

@@ -0,0 +1,8 @@
+import tdarrProxyHandler from "./proxy";
+
+const widget = {
+  api: "{url}/api/v2/cruddb",
+  proxyHandler: tdarrProxyHandler,
+};
+
+export default widget;

src/widgets/transmission/proxy.js

@@ -25,12 +25,12 @@ export default async function transmissionProxyHandler(req, res) {
     return res.status(400).json({ error: "Invalid proxy service type" });
   }
 
-  let headers = cache.get(headerCacheKey);
+  let headers = cache.get(`${headerCacheKey}.${service}`);
   if (!headers) {
     headers = {
       "content-type": "application/json",
     }
-    cache.put(headerCacheKey, headers);
+    cache.put(`${headerCacheKey}.${service}`, headers);
   }
 
   const url = new URL(formatApiCall(widgets[widget.type].api, { endpoint, ...widget }));
@@ -55,7 +55,7 @@ export default async function transmissionProxyHandler(req, res) {
   if (status === 409) {
     logger.debug("Transmission is rejecting the request, but returning a CSRF token");
     headers[csrfHeaderName] = responseHeaders[csrfHeaderName];
-    cache.put(headerCacheKey, headers);
+    cache.put(`${headerCacheKey}.${service}`, headers);
 
     // retry the request, now with the CSRF token
     [status, contentType, data, responseHeaders] = await httpProxy(url, {

src/widgets/unifi/proxy.js

@@ -58,6 +58,7 @@ async function login(widget) {
 
 export default async function unifiProxyHandler(req, res) {
   const widget = await getWidget(req);
+  const { service } = req.query;
   if (!widget) {
     return res.status(400).json({ error: "Invalid proxy service type" });
   }
@@ -68,7 +69,7 @@ export default async function unifiProxyHandler(req, res) {
   }
 
   let [status, contentType, data, responseHeaders] = [];
-  let prefix = cache.get(prefixCacheKey);
+  let prefix = cache.get(`${prefixCacheKey}.${service}`);
   if (prefix === null) {
     // auto detect if we're talking to a UDM Pro, and cache the result so that we
     // don't make two requests each time data from Unifi is required
@@ -77,7 +78,7 @@ export default async function unifiProxyHandler(req, res) {
     if (responseHeaders?.["x-csrf-token"]) {
       prefix = udmpPrefix;
     }
-    cache.put(prefixCacheKey, prefix);
+    cache.put(`${prefixCacheKey}.${service}`, prefix);
   }
 
   widget.prefix = prefix;

src/widgets/widgets.js

@@ -5,7 +5,9 @@ import bazarr from "./bazarr/widget";
 import changedetectionio from "./changedetectionio/widget";
 import coinmarketcap from "./coinmarketcap/widget";
 import deluge from "./deluge/widget";
+import downloadstation from "./downloadstation/widget";
 import emby from "./emby/widget";
+import flood from "./flood/widget";
 import gluetun from "./gluetun/widget";
 import gotify from "./gotify/widget";
 import hdhomerun from "./hdhomerun/widget";
@@ -14,10 +16,15 @@ import jackett from "./jackett/widget";
 import jellyseerr from "./jellyseerr/widget";
 import lidarr from "./lidarr/widget";
 import mastodon from "./mastodon/widget";
+import miniflux from "./miniflux/widget";
+import mikrotik from "./mikrotik/widget";
 import navidrome from "./navidrome/widget";
+import nextdns from "./nextdns/widget";
 import npm from "./npm/widget";
 import nzbget from "./nzbget/widget";
+import omada from "./omada/widget";
 import ombi from "./ombi/widget";
+import opnsense from "./opnsense/widget";
 import overseerr from "./overseerr/widget";
 import paperlessngx from "./paperlessngx/widget";
 import pihole from "./pihole/widget";
@@ -36,12 +43,14 @@ import sonarr from "./sonarr/widget";
 import speedtest from "./speedtest/widget";
 import strelaysrv from "./strelaysrv/widget";
 import tautulli from "./tautulli/widget";
+import tdarr from "./tdarr/widget";
 import traefik from "./traefik/widget";
 import transmission from "./transmission/widget";
 import tubearchivist from "./tubearchivist/widget";
 import truenas from "./truenas/widget";
 import unifi from "./unifi/widget";
 import watchtower from './watchtower/widget'
+import xteve from './xteve/widget'
 
 const widgets = {
   adguard,
@@ -51,7 +60,10 @@ const widgets = {
   changedetectionio,
   coinmarketcap,
   deluge,
+  diskstation: downloadstation,
+  downloadstation,
   emby,
+  flood,
   gluetun,
   gotify,
   hdhomerun,
@@ -61,10 +73,15 @@ const widgets = {
   jellyseerr,
   lidarr,
   mastodon,
+  miniflux,
+  mikrotik,
   navidrome,
+  nextdns,
   npm,
   nzbget,
+  omada,
   ombi,
+  opnsense,
   overseerr,
   paperlessngx,
   pihole,
@@ -83,6 +100,7 @@ const widgets = {
   speedtest,
   strelaysrv,
   tautulli,
+  tdarr,
   traefik,
   transmission,
   tubearchivist,
@@ -90,6 +108,7 @@ const widgets = {
   unifi,
   unifi_console: unifi,
   watchtower,
+  xteve,
 };
 
 export default widgets;

src/widgets/xteve/component.jsx

@@ -0,0 +1,35 @@
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+import useWidgetAPI from "utils/proxy/use-widget-api";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+
+  const { data: xteveData, error: xteveError } = useWidgetAPI(widget, "api");
+
+  if (xteveError) {
+    return <Container error={xteveError} />;
+  }
+
+  if (!xteveData) {
+    return (
+      <Container service={service}>
+        <Block label="xteve.streams_all" />
+        <Block label="xteve.streams_active " />
+        <Block label="xteve.streams_xepg" />
+      </Container>
+    );
+  }
+
+  return (
+    <Container service={service}>
+      <Block label="xteve.streams_all" value={t("common.number", { value: xteveData["streams.all"] ?? 0 })} />
+      <Block label="xteve.streams_active" value={t("common.number", { value: xteveData["streams.active"] ?? 0 })} />
+      <Block label="xteve.streams_xepg" value={t("common.number", { value: xteveData["streams.xepg"] ?? 0 })} />
+    </Container>
+  );
+}

src/widgets/xteve/proxy.js

@@ -0,0 +1,63 @@
+import { formatApiCall } from "utils/proxy/api-helpers";
+import { httpProxy } from "utils/proxy/http";
+import createLogger from "utils/logger";
+import widgets from "widgets/widgets";
+import getServiceWidget from "utils/config/service-helpers";
+
+const logger = createLogger("xteveProxyHandler");
+
+export default async function xteveProxyHandler(req, res) {
+  const { group, service, endpoint } = req.query;
+
+  if (!group || !service) {
+    return res.status(400).json({ error: "Invalid proxy service type" });
+  }
+
+  const widget = await getServiceWidget(group, service);
+  const api = widgets?.[widget.type]?.api;
+  if (!api) {
+    return res.status(403).json({ error: "Service does not support API calls" });
+  }
+
+  const url = formatApiCall(api, { endpoint, ...widget });
+  const method = "POST";
+  const payload = { cmd: "status" };
+
+  if (widget.username && widget.password) {
+    // eslint-disable-next-line no-unused-vars
+     const [status, contentType, data] = await httpProxy(url, {
+      method,
+      body: JSON.stringify({
+        cmd: "login",
+        username: widget.username,
+        password: widget.password,
+      })
+    });
+
+    if (status !== 200) {
+      logger.debug("Error logging into xteve", status, url);
+      return res.status(status).json({error: {message: `HTTP Error ${status} logging into xteve`, url, data}});
+    }
+
+    const json = JSON.parse(data.toString());
+
+    if (json?.status !== true) {
+      return res.status(401).json({error: {message: "Authentication failed", url, data}});
+    }
+
+    payload.token = json.token;
+  }
+
+  const [status, contentType, data] = await httpProxy(url, {
+    method,
+    body: JSON.stringify(payload)
+  });
+
+  if (status !== 200) {
+    logger.debug("Error %d calling xteve endpoint %s", status, url);
+    return res.status(status).json({error: {message: `HTTP Error ${status}`, url, data}});
+  }
+
+  if (contentType) res.setHeader("Content-Type", contentType);
+  return res.status(status).send(data);
+}

src/widgets/xteve/widget.js

@@ -0,0 +1,14 @@
+import xteveProxyHandler from "./proxy";
+
+const widget = {
+  api: "{url}/{endpoint}",
+  proxyHandler: xteveProxyHandler,
+
+  mappings: {
+    "api": {
+      endpoint: "api/",
+    },
+  },
+};
+
+export default widget;