Redmine Dashboards

Dashboards

5.0 (0)·New installaties

Dashboards die je bouwt uit de opgeslagen queries die je al hebt — een raster met sleepbare KPI-tegels, tabellen en vijftien grafiektypen, geaggregeerd in SQL en beperkt tot wat de kijker mag zien.

$199 / één server

Meerdere servers: $399

Terugbetaling binnen 5 werkdagen12 maanden updatesBroncode inbegrepen

Een Redmine Charts-dashboard binnen Redmine 6: een KPI-tegel met 10.000 issues, een ring per project, staven per prioriteit, een statusring en een lijngrafiek met aangemaakte issues per maand. — Een live dashboard KPI-tegels, ringen, staaf- en lijngrafieken op één bord — elk cijfer in SQL geaggregeerd uit Redmines eigen, door rechten begrensde gegevens.

Widgettypen: 23
Grafiekvarianten: 15
Redmine: 4 · 5 · 6 · 7
Databases: MySQL, MariaDB, PostgreSQL
Core-patches: Geen

Bouwen met slepen en neerzetten

Een raster waarvan je tegels van formaat en plaats verandert en dat zichzelf opslaat terwijl je werkt. Schik KPI’s, grafieken en tabellen tot het bord vertelt wat het moet vertellen — zonder layoutbestand, zonder herladen.

Vijftien grafiektypen

Staaf, liggende staaf, gestapelde staaf, lijn, meerdere lijnen, vlak, taart, ring, radar, polair, meter, trechter, heatmap, treemap en voortgangsring — getekend met Apache ECharts, in licht en donker.

Je opgeslagen queries, in beeld

Richt een widget op een opgeslagen query en hij erft dat filter, inclusief aangepaste velden, volgers en subprojecten. Of maak van die query in één klik een compleet dashboard.

Geaggregeerd in SQL

GROUP BY, COUNT, SUM en AVG draaien in de database, dus honderdduizend issues worden geteld in plaats van geïnstantieerd. Resultaten worden gecachet per gebruiker, widget en actieve filters.

Toegesneden op de kijker

Elke leesactie begint bij Issue.visible(user), TimeEntry.visible(user) en Query.visible(user), zodat geen enkele grafiek een project kan optellen waar de lezer geen lid van is.

Filters, verversen en doorklikken

Eén filterbalk herschaalt het hele bord, een interval per dashboard houdt een scherm aan de muur actueel, en elke staaf, punt en cel leidt naar de issuelijst erachter.

Zie het draaien binnen Redmine

Elke schermafbeelding hier komt van een standaardinstallatie van Redmine 6 met het plugin in plugins/ gezet. De dashboards staan onder Redmines eigen kopbalk en menu’s, want daar draaien ze ook.

Een bord bouwen

Bewerkmodus op een dashboard: elke widget toont sleepgrepen en hoeken om te schalen, en de indeling wordt automatisch opgeslagen. — Bewerkmodus Zet de schakelaar Bewerken om en elke widget is te verslepen en te schalen. De indeling slaat zichzelf gaandeweg op.

Het venster Widget toevoegen: widgettype, databron, optionele opgeslagen query, maat en aggregatie, gekozen uit keuzelijsten. — Een widget toevoegen Kies een widgettype, een databron en eventueel een opgeslagen query, en daarna de maat en de aggregatie. Niemand schrijft SQL.

Widgets

De keuzelijst met widgettypen: vijftien ECharts-varianten, KPI en tabel, plus Markdown, notities, HTML, iframe, activiteitenfeed en recente issues. — 23 widgettypen Vijftien ECharts-varianten plus KPI, tabel en zes inhoudswidgets — Markdown, notities, HTML, iframe, activiteitenfeed en recente issues.

Het eigen menu van een widget geopend op een dashboard, met acties om te verversen, in te stellen en te verwijderen. — Widgetacties Elke widget laadt zelfstandig en heeft een eigen menu — ververs één grafiek zonder de rest van het bord opnieuw te laden.

Delen en wisselen

Het deelvenster van een dashboard met de zichtbaarheid privé, gedeeld en openbaar, en kiezers voor rollen, groepen en projecten. — Delen Houd een bord privé, deel het met bepaalde rollen, groepen of projecten, of open het voor elke ingelogde gebruiker — afgehandeld via Redmine-lidmaatschappen.

De dashboardwisselaar in de werkbalk met elk zichtbaar bord, en opties om een standaard in te stellen, als JSON te exporteren of een nieuw bord te maken. — Van bord wisselen De wisselaar in de werkbalk toont elk bord dat je mag zien. Zet er een vast als standaard, exporteer het als JSON of begin een nieuw bord.

De query is het rapport al

Niets hier vraagt je om je gegevens een tweede keer te beschrijven. Filter een issuelijst zoals je altijd doet, sla hem op, en die opgeslagen query wordt het bereik waarover een widget aggregeert — precies de relatie waarmee Redmine de lijst zelf tekent.

Eén opgeslagen query, drie wegen naar een dashboard
Stap	Wat je doet	Wat je krijgt
1. Query opslaan	De issuelijst filteren — aangepaste velden, volgers, subprojecten — en op Opslaan klikken	Een query met een naam, zichtbaar voor wie je hem deelde
2. Er een widget op richten	Die query kiezen in het widgetvenster	Databron en een verstandige standaardgroepering, voor je afgeleid
3. Of meteen het hele bord	Op «Vanuit query» klikken	Een dashboard met KPI-tegels en grafieken die eraan hangen, in één verzoek

Ingesteld met keuzelijsten, niet met SQL

Een widget is een bron, een dimensie, een maat en een aggregatie. Groepeer issues op status, prioriteit, tracker, toegewezene of elk datumveld in dagen, weken, maanden of jaren; tel ze, tel geschatte uren op of neem het gemiddelde van het percentage gereed. Niemand in het team schrijft SQL voor een grafiek — en omdat er geen SQL te schrijven valt, bestaat er ook geen query die voorbij de rechten van de lezer kan reiken.

Het venster Vanuit query: kies een opgeslagen Redmine-query om een dashboard met KPI’s en grafieken te genereren die aan de filters ervan hangen. — Vanuit een opgeslagen query Kies een opgeslagen query en krijg een kant-en-klaar bord met KPI’s en grafieken — status, prioriteit, toegewezene, trend en een tabel — gekoppeld aan de filters ervan.

Elke widget ingesteld vanuit één formulier

Elke widget, of het nu een KPI, een staaf of een ring is, stel je in met hetzelfde korte formulier: een titel en een type, een databron, eventueel een opgeslagen query voor de filters, een maat, en een groepering met Top-N. Verander het type en het formulier past zich aan.

Formulier Widget instellen voor een KPI: titel Totaal issues, databron Issues, opgeslagen query, maat Aantal issues, functie count. — KPI-tegel Eén getal: een maat en een aggregatie over een opgeslagen query.

Formulier Widget instellen voor een staafgrafiek: Issues per prioriteit, gegroepeerd op Prioriteit, Top N 20. — Staafgrafiek Groepeer op elke dimensie, zoals prioriteit, en kap de lange staart af met Top-N.

Formulier Widget instellen voor een ringgrafiek: Issues per status, gegroepeerd op Status. — Ringgrafiek Dezelfde velden met een ander type. Van grafiek wisselen laat je data-instellingen intact.

Instellingen van het plugin Redmine Charts: caching aan, cacheduur 300 seconden, standaardthema Licht, interval voor automatisch verversen 0. — Plugininstellingen Caching, cache-TTL, standaardthema en automatisch verversen, op Redmines eigen instellingenscherm.

Eén instellingenpagina voor beheerders

Onder Administratie › Plugins › Redmine Charts stel je caching van resultaten per gebruiker in, de cache-TTL (5–86400 seconden, standaard 300), het standaardthema licht of donker, en een standaardinterval voor automatisch verversen, waarbij 0 het uitzet. De pagina is Redmines eigen scherm voor plugininstellingen.

23 widgettypen, en ruimte voor die van jou

Elk type is metadata in een register, dus het configuratiescherm bouwt zichzelf op uit de declaratie van de widget in plaats van uit een handgeschreven formulier per grafiek.

De catalogus die meekomt
Familie	Typen	Ingesteld met
Grafieken	Staaf, liggende staaf, gestapelde staaf, lijn, meerdere lijnen, vlak, taart, ring, radar, polair, meter, trechter, heatmap, treemap, voortgangsring	Bron, dimensie, maat, aggregatie
KPI / getal	Eén geaggregeerd cijfer, met een eigen filter	count · sum · avg · min · max
Tabel	Een gepagineerd raster over dezelfde, door rechten begrensde gegevens	Kolomkiezer en filters
Inhoud	Markdown, notities, HTML, iframe, activiteitenfeed, recente issues	Vrije tekst, of een van Redmines eigen feeds

Getekend met Apache ECharts

Vijftien varianten, gemaakt voor licht en donker, opnieuw getekend bij schalen en ook op een wandscherm nog leesbaar. De bundle zit kant-en-klaar in het pakket, dus installeren vraagt geen Node en geen buildstap.

Elk segment klikt door

Klik op een staaf, een taartpunt of een heatmapcel en de Redmine-issuelijst opent, precies op die issues gefilterd. De cijfers blijven controleerbaar, want je kunt altijd op de regels erachter uitkomen.

Globale filters en automatisch verversen

Eén filterbalk herschaalt alle widgets van een bord tegelijk, en een ververstijd per dashboard houdt het scherm op de gang actueel. Nul zet verversen uit.

Sjablonen en blauwdrukken

Bewaar een bord als herbruikbaar sjabloon, dupliceer het per team, of exporteer het als JSON-blauwdruk en importeer het in een andere instantie — van test naar productie zonder het opnieuw te bouwen.

Eén plugin, een bord voor elk team

Een delivery lead, een supportdesk en één ontwikkelaar bouwden deze elk in een paar minuten, uit opgeslagen queries die ze al hadden.

Dashboard over de volle lengte: KPI, ringen, staven per prioriteit, maandtrend, werklast per toegewezene en een gepagineerde issuetabel. — Portfolio-overzicht KPI, ringen, trend, werklast per toegewezene en een gepagineerde issuetabel.

Dashboard Aan mij toegewezen issues met een KPI, een vlakgrafiek en een statusring. — Aan mij toegewezen issues Een persoonlijk bord met een vlakgrafiek en een statusring.

Dashboard Aangemaakte issues met een KPI, een ring per tracker en staven per prioriteit. — Aangemaakte issues Trackermix, verdeling per prioriteit en status in één oogopslag.

Supportdashboard: KPI-tegels voor het totaal aantal issues en de bestede tijd, een statusring, staven per prioriteit, subtracker en module, en een lijngrafiek met aangemaakte issues per maand. — Supportoverzicht Issues, bestede tijd, prioriteit, subtracker en werklast per module voor één supportperiode.

Supportdashboard over een heel jaar: KPI-tegels voor het totaal aantal issues en de bestede tijd, een statusring, staven per prioriteit, module en subtracker, en een lijngrafiek met aangemaakte issues per maand. — Het supportjaar in cijfers Aantal issues, bestede tijd en verdeling per prioriteit en module, met het verloop van maand tot maand.

Twee bronnen ingebouwd, en die van jou ernaast

Issues en bestede tijd komen met hun dimensies en maten al aangemeld, allebei achter Redmines eigen zichtbaarheidsbereiken. Een bron die een ander plugin toevoegt, krijgt exact dezelfde behandeling.

Bron	Dimensies	Maten
Issues	Status, prioriteit, tracker, project, toegewezene, auteur, categorie, versie, aangemaakt, bijgewerkt, einddatum	Aantal issues, geschatte uren, percentage gereed
Bestede tijd	Project, gebruiker, activiteit, datum	Uren, aantal registraties
Je eigen	Wat je aanmeldt	Wat je aanmeldt

Uitbreiden is aanmelden, niet patchen

Een databron is een klasse met een naam, zijn dimensies, zijn maten en een base_scope die op rechten filtert; een widgettype is een hash. Meld een van beide aan vanuit de init.rb van je eigen plugin met RedmineCharts.register_data_source of register_widget_type en het verschijnt meteen in het configuratiescherm — inclusief filtering, caching en doorklikken. Er wordt niets in dit plugin voor gewijzigd.

Niemand aggregeert wat hij niet mag lezen

Een dashboard is een snelle manier om een getal te laten weglekken, dus elke leesactie begint bij het bereik van de kijker in plaats van te eindigen met een controle daarop.

Eerst zichtbaarheid, dan groeperen

Issue.visible(user), TimeEntry.visible(user) en Query.visible(user) beperken de relatie voordat er ook maar één rij geteld is. Een totaal uit een project waar je geen lid van bent, kan in geen enkele widget opduiken, want die rijen zaten nooit in de verzameling.

Vier fijnmazige rechten

Dashboards bekijken, aanmaken, ze allemaal beheren en sjablonen beheren — elk per rol toe te kennen. En alles blijft uit tot iemand de module Dashboards voor dat project inschakelt.

Delen via lidmaatschappen

Geef een bord vrij aan gebruikers, groepen, rollen of hele projecten. Elk verzoek berekent viewable_by? en editable_by? opnieuw via Redmines eigen lidmaatschappen, en niet via een parallelle toegangslijst die uit de pas gaat lopen.

Er verlaat niets de server

De frontend praat alleen met de JSON-API van dit plugin op je eigen Redmine, via de sessie en het CSRF-token die er al zijn. Geen externe dienst, geen licentiecontrole op afstand, geen telemetrie.

Gebouwd voor een grote instantie

Honderdduizend issues tellen zou niet moeten betekenen dat je honderdduizend objecten laadt. Hier betekent het dat niet.

Wat er gebeurt als een bord wordt geopend
Onderwerp	Hoe het is opgelost
Aggregatie	GROUP BY, COUNT, SUM en AVG draaien in SQL — rijen worden nooit geïnstantieerd alleen om geteld te worden
Zeer brede dimensies	Top-N-vouwing houdt het antwoord klein als een dimensie duizenden waarden heeft
Herhaald bekijken	Resultaten gecachet per gebruiker, wijzigingsmoment van de widget en actieve filters via Rails.cache; de TTL is een instelling en Redis werkt zoals hij is
Eén trage widget	Widgets laden onafhankelijk, dus een zware query houdt nooit het hele bord op
Ontbrekende JS-bundle	Rails rendert de gegevens van elke widget serverzijdig als terugval, dus de pagina degradeert in plaats van leeg te blijven

Bewust overdraagbaar, niet toevallig

Ondersteuning voor meerdere versies en databases is ontworpen, niet achteraf gevonden — migraties, JSON-opslag en datumindeling zijn allemaal geschreven om de verschillen te overleven.

Onderwerp	Ondersteund	Hoe
Redmine	4.x, 5.x, 6.x, 7.x	Declareert requires_redmine version_or_higher 4.0.0, zonder core-overrides die kunnen verouderen
Rails	5.2 → 8.0	Migraties mikken op de basis 5.2 die elke release tot en met 8.0 begrijpt
Ruby	2.5+	Gelijk aan de minimumeis van Redmine 4
Databases	MySQL, MariaDB, PostgreSQL	JSON staat in gewone text-kolommen — overal identiek DDL — met een serializer die per Rails-versie de juiste vorm kiest
Groeperen op datum	Dag, week, maand, jaar	Groepeert op een overdraagbare CAST(col AS DATE) en vouwt daarna in Ruby tot periodes — geen leverancierspecifieke SQL
Migraties opnieuw draaien	Veilig	Defensief geschreven, dus een afgebroken upgrade kan opnieuw worden gedraaid

Vanaf dag één scriptbaar

Elk endpoint zit onder /redmine_charts/api, geeft JSON terug en handhaaft precies de rechten van de interface — een bord kan dus vanuit CI worden uitgerold of per team worden gegenereerd.

Methode	Pad	Wat het doet
GET	/dashboards	Elk dashboard dat de aanroeper mag zien
POST	/dashboards	Er een aanmaken
GET	/dashboards/:id	Een dashboard met zijn widgets ophalen
PATCH	/dashboards/:id	Naam, indeling of instellingen wijzigen
POST	/dashboards/:id/duplicate	Het klonen, widgets inbegrepen
GET	/dashboards/:id/export	Een JSON-blauwdruk exporteren
POST	/dashboards/import	Een bord maken uit een blauwdruk
POST	/dashboards/:id/widgets	Een widget toevoegen
GET	/widgets/:id/data	Geaggregeerde widgetgegevens, begrensd door rechten
GET	/meta/data_sources	Bronnen, dimensies, maten en de bruikbare opgeslagen queries

Wat er vandaag in zit, en wat er komt

De roadmap is bewust aanvullend — nieuwe databronnen, widgettypen en exportdiensten — dus niets ervan zal je vragen iets te migreren. Het staat er als roadmap, niet als feature, zodat je koopt op wat er vandaag in de doos zit.

Mogelijkheid	Status
Dashboards: aanmaken, dupliceren, als standaard instellen, exporteren en importeren	Beschikbaar
Schaalbaar raster met slepen en neerzetten en automatisch opslaan	Beschikbaar
KPI, tabel en de volledige set ECharts-grafieken	Beschikbaar
Visuele widgetconfiguratie zonder SQL	Beschikbaar
Hergebruik van opgeslagen queries en een bord genereren met één klik	Beschikbaar
Globale filters die het hele bord verversen	Beschikbaar
Doorklikken van grafiek naar issuelijst	Beschikbaar
SQL-aggregatie en caching per gebruiker, begrensd door rechten	Beschikbaar
Delen, sjablonen, lichte en donkere thema’s	Beschikbaar
Meerdere versies, meerdere databases, serverzijdige terugval	Beschikbaar
Export naar PDF, PNG en Excel	Gepland
Achtergrondtaken voor heel zware rapporten	Gepland
Live bijwerken via WebSocket	Gepland
Geplande momentopnamen, ook per e-mail	Gepland
Kiosk- / wandschermmodus	Gepland
AI-rapportbouwer in natuurlijke taal	Gepland
Widgets voor kalender, burndown en gantt-samenvatting	Gepland

Installeren in drie stappen

Vereist shell-toegang en de mogelijkheid rake-taken uit te voeren. Maak altijd een back-up voordat je een plug-in installeert.

Uitpakken in je pluginsmap

cd /path/to/redmine
# unzip the package from your email or download link
unzip redmine_charts-1.0.0.zip -d plugins/
bundle install

Migreren, sjablonen laden, herstarten

bundle exec rake redmine:plugins:migrate NAME=redmine_charts RAILS_ENV=production
# optional: the built-in dashboard templates
bundle exec rake redmine_charts:seed_templates RAILS_ENV=production
touch tmp/restart.txt

Inschakelen waar je het wilt

# Project → Settings → Modules → Charts & Dashboards
# then grant the dashboard permissions to the roles that need them
# a Dashboards entry appears in the top menu for anyone who holds one

Past het Redmine-corebestanden aan of overschrijft het ze?

Nee. Het meldt een projectmodule, rechten, menu-items en routes aan via de gedocumenteerde API Redmine::Plugin.register en voegt eigen controllers, modellen en migraties toe. Verwijderen betekent de pluginmap wissen en zijn migraties terugdraaien — er is niets in de core aangeraakt dat teruggezet moet worden.

Heb ik Node.js of een buildstap nodig om het te installeren?

Nee. Er zit een kant-en-klare frontendbundle in het pakket, dus het plugin werkt zodra de migraties gedraaid hebben en Redmine herstart is. Node heb je alleen nodig als je de React-broncode wilt aanpassen en zelf opnieuw bouwen; dat kan, maar het hoeft niet.

Werken mijn bestaande opgeslagen queries, ook de ingewikkelde?

Ja. De aggregatie bouwt op het bereik van de query zelf, precies de relatie waarmee Redmine de issuelijst tekent, dus filters die eigen joins nodig hebben — aangepaste velden, volgers, subprojecten — gaan onveranderd mee. Een query kiezen leidt bovendien de databron en een standaardgroepering af, waardoor de meeste widgets twee klikken kosten.

Kan iemand cijfers zien uit een project waar hij geen toegang toe heeft?

Nee. Elke aggregatie wordt gebouwd op Redmines eigen zichtbaarheidsbereiken voor de huidige gebruiker voordat er iets gegroepeerd wordt, en elk dashboard controleert daarbovenop bij elk verzoek opnieuw viewable_by?. Een issue buiten bereik maakt nooit deel uit van een telling, dus er is geen totaal dat kan weglekken.

Welke databases worden ondersteund?

MySQL, MariaDB en PostgreSQL, met identiek DDL op alle drie. JSON staat in gewone text-kolommen en groeperen op datum gebruikt een overdraagbare CAST(col AS DATE), die daarna in Ruby tot dagen, weken, maanden of jaren wordt gevouwen — er is dus geen leverancierspecifieke SQL en bij geen enkele functie een sterretje «alleen op PostgreSQL».

Op welke Redmine- en Rails-versies draait het?

Redmine 4, 5, 6 en 7, op Rails 5.2 tot en met 8.0 en Ruby 2.5 of nieuwer. De migraties mikken op de basis [5.2] die al die versies begrijpen en zijn defensief geschreven, dus een afgebroken upgrade kun je gewoon opnieuw draaien. En omdat er geen core-overrides zijn, kan er bij een Redmine-upgrade niets verouderen.

Kunnen we eigen databronnen of grafiektypen toevoegen?

Ja, vanuit een apart plugin en zonder hier iets te wijzigen. Erf van RedmineCharts::DataSource en roep register_data_source aan voor een nieuwe bron, of register_widget_type voor een nieuwe grafiek. Beide verschijnen meteen in het configuratiescherm en erven filtering, caching en doorklikken — precies zoals de twee ingebouwde bronnen zijn aangemeld.

Wat zit er bewust niet in versie 1.0?

Export naar PDF, PNG en Excel, achtergrondtaken voor heel zware rapporten, geplande momentopnamen per e-mail, live bijwerken via WebSocket en een kioskmodus zijn ontworpen maar niet gebouwd — zodat je koopt op wat er vandaag in de doos zit. Het is allemaal aanvullend: niets ervan zal je vragen een dashboard te migreren dat je al gebouwd hebt.