Redmine-Reihe 2 von 3: Redmine für Administratoren

Willkommen zum dreiteiligen Workshop: Redmine 4. In diesem zweiten Teil geht es um “Redmine für Administratoren”.

Das Video erklärt einige grundsätzliche Informationen auf der administrativen Seite im Backend von Redmine.

Redmine für Administratoren

Folgende Dinge werden erklärt:

  • Adminkonto bearbeiten
  • Projekte erstellen, konfigurieren und verwalten
  • Benutzerverwaltung
  • Gruppenverwaltung
  • Rollen und Rechte
  • Trackerverwaltung
  • Ticket-Status-Verwaltung
  • Workflow
  • Benutzerdefinierte Felder
  • Aufzählungen
  • Redmine konfigurieren

Hier geht es zum Video.

Hier geht es zur Playlist.

Hier geht es zu Redmine installieren.

Redmine-Reihe 1 von 3: Redmine 4 installieren (auf FreeBSD 13)

Willkommen zum dreiteiligen Workshop: Redmine 4. Ich habe mir überlegt, ich mache einen kleinen Redmine-Einsteigerkurs. Dieser geht über drei Kapitel:

  • Redmine 4 installieren (in meinem Fall auf FreeBSD 13)
  • Redmine 4 für Administratoren (GUI)
  • Redmine 4 für Benutzer (GUI)
Redmine - Installation
Redmine – Installation

In diesem Video und Blog-Artikel geht es darum, wie man Redmine einfach installieren kann. Ich setze dafür folgendes voraus:

  • Du hast ein lauffähiges und vollständig gepatchtes FreeBSD 13 (oder neuer)
  • Du hast einen lauffähigen PostgreSQL-Server (wie das geht, erfährst du hier und hier)
  • Nameservereinträge sind bereits vorhanden (in meinem Fall heißt mein Host redmine.gug-it.gg, welchen ich hier auch in der Beschreibung überall nutze. Das musst du natürlich anpassen!)

So wird es gemacht

Erstelle einen Datenbankbenutzer. Wie das bei deiner PostgreSQL-Version geht, entnimmst du den Manuals. Achte darauf, dem Benutzer ein verschlüsseltes Kennwort zu geben. Ich habe noch ein (uraltes) PostgreSQL 9.5 auf meiner Testmaschine laufen (du solltest hoffentlich was neueres haben), und da geht es so:

createuser -E -P redmine

Dann erstellst du noch die Datenbank, was bei mir so geht:

createdb -E unicode -O redmine redmine

und vergisst natürlich nicht den Eintrag in der pg_hba.conf

host redmine redmine 192.168.0.168/24 password

Denke daran, Datenbanknamen, Datenbankbenutzer und IP anzupassen!

Ich nutze Apache in der Version 2.4. Wenn du was anderes benutzt, dann musst du leider schauen, wie du es ans Rennen bekommst. Ich installiere also alle benötigten Pakete:

pkg install redmine4 apache24 ap24-mod_fastcgi fcgi-devkit postgresql14-client

In der httpd.conf (/usr/local/etc/apache24) setzt du, wenn du es noch nicht getan hast, den Servernamen sowie die E-Mail-Adresse (wobei die auch im VHost eingerichtet wird). Weiterhin entfernst du bei den Zeilen:

LoadModule rewrite_module libexec/apache24/mod_rewrite.so
LoadModule fastcgi_module libexec/apache24/mod_fastcgi.so
Include etc/apache24/extra/httpd-vhosts.conf

die Raute (#) vorne, so dass die Zeilen genutzt werden innerhalb der Konfiguation. Und der aufmerksame Leser weiß es: ich nutze hier jetzt im Beispiel kein SSL! Bitte mache das, und mache das auf jeden Fall, wenn Redmine im Internet hängt! Das wäre jetzt einfach nur zu aufwendig für das Tutorial.

Server-Kram liegt bei mir unter /server. Web-Kram dementsprechend unter /server/web/<sld>/<t(hird)ld>. Passe die Konfiguration bei dir an. Dementsprechend richte ich das Verzeichnis folgendermaßen ein:

mkdir -p /server/web/gug-it && chown -R www:www /server/web/gug-it
ln -s /usr/local/www/redmine /server/web/gug-it/

Dann bearbeite ich die Datei /usr/local/etc/apache24/extra/httpd-vhosts.conf (du hoffentlich /usr/local/etc/apache24/extra/httpd-ssl.conf). Da füge ich folgenden Eintrag hinzu:

<VirtualHost *:80>
        ServerName redmine.gug-it.gg
        ServerAdmin thorsten@tgeppert.de

        DocumentRoot "/server/web/gug-it/redmine/public"

        FastCgiServer /server/web/gug-it/redmine/public/dispatch.fcgi -idle-timeout 120 -initial-env RAILS_ENV=production -initial-env PATH=/usr/local/bin -processes 2

        <Directory /server/web/gug-it/redmine/public>
                AddHandler fastcgi-script fcgi
                Require all granted
                AllowOverride all
                Options +FollowSymLinks +ExecCGI
                RewriteEngine On
                RewriteCond %{REQUEST_FILENAME} !-f
                RewriteRule ^(.*)$ dispatch.fcgi
        </Directory>

        ErrorLog "/var/log/redmine.gug-it.gg-error_log"
        CustomLog "/var/log/redmine.gug-it.gg-access_log" common
</VirtualHost>

Dann kopiere ich noch die dispatch.fcgi (wir nutzen FastCGI) an die richtige Stelle und mache sie ausführbar:

cp /usr/local/www/redmine/public/dispatch.fcgi.example /usr/local/www/redmine/public/dispatch.fcgi
chmod +x /usr/local/www/redmine/public/dispatch.fcgi

Jetzt geht es an die Netzwerkkonfiguration. Die Daten dazu liegen dir hoffentlich vor.

cp /usr/local/www/redmine/config/database.yml.sample /usr/local/www/redmine/config/database.yml

Die bearbeiten wir dann mit dem Editor unserer Wahl und geben die richtigen Daten ein:

production:
  adapter: postgresql
  database: redmine
  host: thorsten.jails.gug-it.gg
  username: redmine
  password: "redmine"
  # Use "utf8" instead of "utfmb4" for MySQL prior to 5.7.7
  encoding: utf8

Nicht vergessen, ich nutze PostgreSQL. Wenn du MySQL oder anderes nutzt, musst du das natürlich beachten! Mein Datenbankserver liegt auf “thorsten.jails.gug-it.gg”.

Als nächstes müssen wir noch ein paar Module zu unserem Redmine hinzufügen. Wir erstellen im Verzeichnis /usr/local/www/redmine die Datei Gemfile.local mit folgendem Inhalt:

gem 'pg'
gem 'fcgi'

und führen dann folgende Befehle aus:

bundle install
rake generate_secret_token
setenv RAILS_ENV production
rake db:migrate
rake redmine:load_default_data

Um Dateiuploads durchführen zu können, müssen wir noch die Datei configuration.yml anlegen. Dazu kopieren wir die Example-Datei einfach:

cp /usr/local/www/redmine/config/configuration.yml.example /usr/local/www/redmine/config/configuration.yml

und setzen dort den attachments_storage_path auf ein sinnvolles Verzeichnis, in meinem Fall “/server/files/redmine”. Ich lege das Verzeichnis an:

mkdir -p /server/files/redmine
chown -R www:www /server/files/redmine

und trage dann in usr/local/www/redmine/config/configuration.yml folgendes ein:

attachments_storage_path: /server/files/redmin

Ich lasse an dieser Stelle die E-Mail-Konfiguration mal aus, weil das recht spezifisch ist. Kommt ganz darauf an, was du brauchst, aber schau dir die Konfigurationsdatei einmal an und du wirst schnell verstehen, wie das funktioniert.

Wenn wir dann Apache starten (oder neustarten), können wir auf Redmine zugreifen. Die Standardzugangsdaten lauten:

Benutzername: admin, Kennwort: admin

Du wirst direkt aufgefordert, dein Kennwort zu ändern. Jetzt kannst du direkt loslegen.

Hier geht es zum Video.

Hier geht es zur Playlist.

Hier geht es zu Redmine für Administratoren.

Warum ich Redmine mittlerweile sehr gerne benutze

Es ist tatsächlich so, dass ich nie wirklich Software eingesetzt habe, um meine Projekte zu managen. Dabei ging es teils um Projekte, die groß waren, an denen bis zu fünf Personen gearbeitet haben und die über Jahr hinweg liefen.

Das KooKooK-Projekt in Redmine
Das KooKooK-Projekt in Redmine

Ich hatte immer alles im Blick, ich hatte maximal einen selbstgeschriebenen Bug-Tracker im Einsatz und Aufgaben haben wir analog auf Karten verteilt oder mündlich kommuniziert. Komischerweise und im Gegenzug zu vielen anderen, war das nie problematisch. Aufgaben wurden erledigt, Übersicht über Bugs und Features hatten wir und es lief, wie es laufen sollte.

Doch bin ich seit vier Jahren dazu übergegangen, ein Projektmanagementprogramm einzusetzen. Ich hatte damals viel überlegt, recherchiert, was ich so brauche und wurde bei CGM dazu gezwungen, Jira zu benutzen, was ich zwar schon kannte, aber immer (für mich) unübersichtlich hielt, mit einem dazu geschalteten Confluence, was aber nie vernünftig gepflegt wurde.

Ich stieß dann, eines Tages, auf Redmine. Ich sah mir Videos an und wagte mich an die Installation auf FreeBSD. Mit viel Geschrei bekam ich es auch installiert und ich war: begeistert. Genau so habe ich mir ein Tool für mich vorgestellt. Zu Beginn war es ein wenig unübersichtlich, aber man kommt innerhalb weniger Tage rein und dann wird es von unübersichtlich zu übersichtlich.

Redmine bringt etliches mit. Was es nicht mitbringt, lässt sich zumeist als Plug-In herunterladen und installieren. Mit dabei sind eine multiple Projektverwaltung (man kann mehrere Projekte anlegen und mit Unterprojekten gliedern), ein Ticketsystem (was meiner Meinung aber eher für intern ist und nicht für die Kommunikation mit externen Kunden, wo ich OTRS für besser geeignet halte), Aufwandmanagement (man kann für Tickets, die übrigens auch verknüpfte Tickets haben dürfen, Zeiten schätzen und Aufwände buchen, wodurch dann Abrechnungen beim Kunden zum Kinderspiel werden), ein GANTT-Diagramm (Tickets können terminiert werden), Foren, ein Wiki, eine Roadmap mit Versionierung, Repository-Einbindung (es ist problemfrei möglich, vorhandene Git und SubVersion-Repos einzubinden und sogar innerhalb von bspw. Tickets auf Commits zu verweisen), Dokumente, Dateien, News und ein Rechte-Rollen-Management.

Das GitHub-Repository in Redmine eingebunden
Das GitHub-Repository in Redmine eingebunden

Als unterliegende Plattform benutze ich zurzeit ein FreeBSD 13 mit einer PostgreSQL-Datenbank. Redmine selbst ist in Ruby (Ruby on Rails) geschrieben.

Als einziges Plugin benutze ich einen visuellen Editor, da ich Redmine auch mit Menschen benutze, die sich nicht in irgendeine Markup-Sprache einarbeiten möchten. Somit ist es einfach, überall mit Überschriften, Listen oder Bildern zu arbeiten.

Redmine erleichtert meinen Alltag ungemein. Aufgaben und Ideen werfe ich direkt ins Ticketsystem, Dokumentieren erledige ich im Wiki. Wichtige Dateien kann man überall anhägen (in Tickets sowie in Wikieinträgen und überall sonst), wobei es für allgemeinen Kram auch eine Dateienverwaltung gibt.

Aktivitätsübersicht in Redmine
Aktivitätsübersicht in Redmine

Was Redmine nicht hat ist die Einbindung von Microsoft Office, so wie man es beispielsweise von Confluence kennt. Ich kann nicht direkt eine Excel-Datei bearbeiten. Hier müsste man sie herunterladen, bearbeiten, hochladen. Dafür ist das System nicht ausgelegt.

Redmine ist kostenlos, OpenSource und läuft letztlich auf allen unixoiden Plattformen. Es unterstützt unterschiedliche Datenbanken und es gibt sogar kommerziellen Support (EasyRedmine), wenn man ihn benötigt.

Alle in allem kann ich sagen: Wenn ihr auf der Suche nach einem Projektmanagementprogramm seid, dann probiert Redmine einfach einmal aus.

Mein neues (und erstes) Live-Projekt: KooKooK

Da ich jetzt ja mit YouTube begonnen und aufgrund meiner jetzigen Situation ein wenig Zeit habe, habe ich mir überlegt, an einem neuen privaten Projekt zu arbeiten, um nicht aus der Übung zu kommen. Und genau deswegen dachte ich: warum nicht aufzeichnen und auf YouTube veröffentlichen?

KooKooK.org
KooKooK.org

Genau das möchte ich jetzt mit KooKooK versuchen. Es hat mehrere Hintergründe. Ein Ziel ist es auf jeden Fall, mein Portfolio weiter auszubauen, denn ich bin ja auf Jobsuche. Dann dachte ich mir, ich kann sicher noch einiges dazulernen und du vielleicht auch.

Dabei gibt es aber folgende Vorstellung meinerseits. Ich werde die Videos nicht scripten. Ich werde einfach loslegen, Fehler bleiben drin, damit wir was daraus lernen, Versprecher ebenso und alles, was so schief geht. Weiterhin möchte ich mich bei den Videos aber auch nicht nur auf das Coding konzentrieren. Ich möchte euch bei allen Dingen mitnehmen. Natürlich wird ein großer Teil die Programmierung sein, aber ich zeige euch auch, was ich als Projektverwaltung benutze, wir richten die Website ein, scribbeln, malen/zeichnen und machen all das, was man ebenso macht, um eine kleine Software zu entwickeln.

Worum soll es gehen? Ich habe lange überlegt. Soll ich was mit Datenbanken machen? Soll ich was mit Netzwerkprogrammierung machen? Soll ich Websitekram machen? Soll ich ein Spiel programmieren? Die Antwort war einfach: Ja. Mein Ziel ist es, einen grafischen Chat zu entwickeln, der mit Avataren in einer künstlichen Welt funktioniert. Da haben wir Spieleentwicklung, Netzwerkentwicklung, Datenbankentwicklung, Protokollentwicklung, eine Website soll es auch geben, es wird spannend. Und da ich mir vor vielen Jahren bereits die Domain KooKooK.org gesichert habe, wird das Projekt jetzt einfach mal so heißen.

Welche Tools eingesetzt werden, kann ich jetzt noch nicht sagen. Es wird auf jeden Fall C++-lastig, wahrscheinlich Qt, weil ich auch mobile Plattformen wie iPhoneOS, iOS und Android unterstützen möchte. Den Code werde ich auf GitHub lagern, so dass ihr mit daran entwickeln könnt.

Und jetzt geht es los. Ich wünsche euch und auch mir viel Spaß dabei.

Hier geht es zur Playlist.

Und hier zum ersten Video.

Hier geht es zur Website.

Hier geht es zum GitHub-Repository.

Hier geht es zum Redmine-Projekt.

Portierung eines Delphi-7-Projekts nach FreePascal und Lazarus

Hach, alte Software. Alte, gewachsene Software. Alte, gewachsene, ungepflegte Software. Ja. Wer kennt es nicht? Da gibt es ein Projekt, das hat bestimmt gut fünfundzwanzig Jahre auf dem Buckel und wurde, bis zuletzt, noch mit Delphi 7 “gepflegt”. Von gepflegt kann eigentlich nicht die Rede sein, doch wurden noch minimale Erweiterungen und, allem voran, Verschlimmbesserungen gemacht. Jeglicher Unsinn. Was aber versäumt wurde war, das Projekt, was bei hunderten von Kunden eingesetzt wird, auf eine aktuelle Plattform zu migrieren, damit eine vernünftige und saubere Weiterentwicklung überhaupt noch möglich ist.

Lazarus-IDE

Da komme ich ins Spiel. Problemlöser, Beruhiger … ja, einfach der, der das schlimme Los zog. Ich war zur falschen Zeit am falschen Ort.

Es war so, dass die Weiterentwicklung mit Delphi 7 in der Form nicht mehr möglich war. Die letzte Windowsbetriebssystemversion, auf der Delphi 7 wohl annehmbar lief, war Windows 7, welches ja bereits 2020 abgekündigt war. Ich habe Delphi 7 auf Windows 7 ausprobiert. Es war die Hölle. Stabilität war faktisch nicht vorhanden. Abgesehen von der unsinnigen Weiterentwicklung auf einer uralten, veralteten Plattform mit einem nicht unterstützten Betriebssystem war das Problem, dass Delphi 7 andauernd Fehler warf, stehen blieb, abstürzte. Abgesehen davon gab es in dem Projekt – teils absolut unnötige – Abhängigkeiten, die mitunter zwanzig (20!) Jahre alt waren.

Ich sah drei Möglichkeiten: 1. Ich kündige. Tja, Frau, Kinder und Haus …, also 2. Migration zu Delphi in einer aktuellen Version oder 3., und da war ich mir absolut nicht sicher, wie klug das war, Migration auf eine freie Plattform mittels FreePascal und Lazarus. Der Titel verrät, wofür wir uns entschieden.

Delphi in einer aktuellen Version war meinem Chef nicht nur zu teuer (?!), der Migrationsaufwand aufgrund des alten Codes und der noch schlimmeren Abhängigkeiten, wäre, so dachte ich, mindestens genau so groß gewesen, wie die Migration auf eine andere Plattform. Natürlich bin ich recht naiv an die Sache herangegangen, hatte ich doch wenig Erfahrung mit FreePascal und Lazarus, abgesehen von meinem Spieltrieb, den ich daran ab und zu mal auslebte. Aber was wusste ich? Ich fand, aufgrund meiner Tests, dass die Plattform stabil genug war und ist. Ich spiele gerne mit Technologien und ich habe mir Lazarus und FreePascal über Jahre hinweg angesehen. Die anfänglichen Probleme von vor einer Dekade waren behoben, FreePascal lief eigentlich schon immer ganz gut und Lazarus mauserte sich zu einer stabilen IDE. Ich schlug meinem Chef diese Lösung vor und ich denke, das Hauptargument war “kostenlos”. Ob er den Rest hörte, weiß ich nicht.

Also machte ich mich daran, mich tiefergehend mit FreePascal und Lazarus zu beschäftigen, Blog- und Forenartikel dazu zu lesen und ein oder zwei kleine Testprojekte damit zu schreiben, um das System und die Probleme kennenzulernen. Pascal lag bei mir bereits gut zwanzig Jahre weit weg und ich hatte das nur in zwei kleinen Projekten in meiner alten Firma eingesetzt. Ich kam immer mehr rein.

Dann schnappte ich mir eine virtuelle Maschine, warf ein Windows 7 an, schauderte mich als alter FreeBSD– und Mac-User, installierte Delphi 7 und TortoiseSVN, checkte das alte Projekt aus und installierte alle Abhängigkeiten, die mir die gut zwanzig Jahre alte Doku des Projekts preisgab. Diese elende Abhängigkeitenhölle. Abhängigkeiten, um eine “hübschere” Toolbar hinzukriegen, oder Abhängigkeiten, um eine Pfadauswahl zu implementieren. Die alten Programmierer lebten faktisch die Abhängigkeitshölle und genossen sicher, dass eines Tages ein kleiner Programmierer den Quatsch ausbaden müsse.

Nachdem ich guten Gewissens alle mir bekannten Abhängigkeiten mit teils Windows 3.11-Installationsprogrammen installiert hatte (und hey, dass das Zeug noch lief … man kann von Microsoft ja halten, was man will, aber ich war schon beeindruckt), lud ich das Projekt. Das bedeutet, ich versuchte, es zu laden. Ich weiß nicht, wie die alten Programmierer das zusammengebastelt hatten, aber man musste tatsächlich noch Projekteinstellungen an seine individuelle Entwicklungsumgebung anpassen. Normal? Nein. Stell dir mal vor: du checkst ein Projekt aus, auf irgendeinem Computer, und du musst dann noch die Projektdatei an deine Pfade usw. anpassen, weil dort der Benutzername drin steht. Das geht doch nicht! Und es war einiges und es dauerte noch viel länger, bis ich aufgrund der kargen Doku das Ding mal soweit hatte, dass nicht mehr gemeckert wurde. Ich sage das jetzt mal so: bitte, bitte, bitte, dokumentiert nicht das Offensichtliche (function SchreibeVornamen() // Diese Funktion schreibt den Vornamen…), sondern das, was eben nicht offensichtlich ist. In diesem Projekt wurde, und das mit einer solchen Begeisterung und einem solchen Arbeitsaufwand, nur das Offensichtliche dokumentiert.

Gut, es lud jetzt, es kompilierte. Naja, ab und an. Mal klickte ich auf “Play”, dann kompilierte es, mal auch nicht (ohne Code-Änderung), mal startete es, mal nicht, mal hing es sich auf und dann hing sich ganz Delphi auf. Es war nicht tragbar und wieder einmal wunderte es mich, wie man früher so arbeiten konnte (ich konnte das noch nie).

Nach dem Spruch “Man kann nicht alles haben.” durchwühlte ich den Code. Ich durchwühlte ihn nach den ganzen Abhängigkeiten, die ich ja unter FreePascal und Lazarus nicht mehr zur Verfügung haben sollte. Ich fand viele Stellen, die man einfach nicht brauchte oder für die Lazarus eigene Komponenten mitbrachte. Ich begann, auszuklammern und zu schauen, was noch lief oder was einfach nur sinnlos darin war. Ich fand so einiges. Als ich nach einigen Tagen der Pein dachte, fertig zu sein, dachte ich mir: Jetzt ist der Zeitpunkt da, an dem ich versuche, die Spaghetti … erm, den Code in Lazarus zu importieren.

Lazarus bietet einen Import von Delphi-Projekten an. Danke, liebe Lazarusentwickler. Der Dank ist ernstgemeint, denn der Import funktioniert gut. Nicht sehr gut, aber gut. Während des Imports zeigt das System bereits mögliche Probleme an, fehlende Units und so kann man sich, Notizen machend, schon einmal darauf einstellen, dass ein einfacher Import wohl sicher nicht den Segen bringt, den man so dringend bräuchte. Ich importierte, notierte, importierte erneut, notierte wieder. Sprang mit meinen Notizen wieder zurück zu Delphi und versuchte, weitere Probleme zu beheben oder zumindest zu minimieren. Commit, Checkout, Import, Notizen.

Irgendwann war ich dann soweit, dass der Import gut durchlief. Das hatte aber auch Tage gedauert. Ich war aber sehr stolz auf mich. Dann klickte ich auf “Kompilieren”. Ich musste noch einige Units entfernen, einige Funktionen und Prozeduren ausklammern, einigen Code umschreiben, aber irgendwann, recht schnell, wenn ich mich recht erinnere, kompilierte das Projekt dann durch. Nachdem ich auch Firebird inklusive Abhängigkeiten am Rennen hatte, haute es mich aus den Socken: Das Ding startete. Es startete. Es kam … tatatataaaa … die Login-Maske. Zumindeste schätzte ich, dass sie es wäre, denn sie war noch leer. Ich schloss den Tag trotzdem als erfolgreich ab. Ich fand dann recht schnell heraus, dass ich teilweise Ressourcen-Dateien ausgeklammert hatte und als ich sie wieder einklammerte und die Endung .dfm in .lfm umschrieb, die Masken (fast) 1:1 so aussahen, wie in Delphi. Ich arbeitete mich langsam vor, Maske für Maske für Maske. Ich wusste, es würde ein langer Weg werden, der noch weitere Stolpersteine haben sollte.

Einer dieser Stolpersteine war tatsächlich, dass einige Masken/Dialoge in Delphi binär und nicht in Textform abgespeichert waren. Komischerweise waren das von gut fünfzig Dialogen fünf oder sechs. Das Problem ist einfach zu lösen. In Delphi 7 öffnet man den Dialog und speichert ihn als Text, so dass man ihn in Lazarus benutzen kann. Dialoge, die per Text beschrieben werden, haben gegenüber den binären Dialogen den entscheidenden Vorteil, dass man sie mit jedem beliebigen Editor öffnen und bearbeiten kann, während sie auch mal aus Inkompatibilität eben nicht mit Lazarus GUI-Editor laden.

Es war eine Menge Tipperei, Ausklammerei, Umschreiben von Code, Entfernen von altem Code und Schreiben von neuem Code. Vor allem einiges an der Datenbankschnittstelle musste geändert werden, da wohl IB nicht hunderprozentig wie IBX funktioniert, vor allem im Transaktionsbereich.

Ich war dann aber sehr stolz, als die gesamte Basis der Software lief und fast so aussah und sich verhielt, wie sie es davor bei Delphi auch tat. Dann kam aber der Teil, der mir am meisten Bauchschmerzen bereitete. Im alten Projekt wurde QuickReport benutzt, um Reports zu generieren, das Drucken zu übernehmen und PDFs zu erzeugen. Gibt es QuickReport nicht mal mehr für ein aktuelles Delphi und ist die alte Version anscheinend nur mit Gefrickel und neueren Delphi-Versionen zum Laufen zu überreden, gibt es das Projekt gar nicht für Lazarus. Das bedeutet: Keine Reports, kein Drucken, kein PDF-Export.

Ich sah mir dann drei oder vier verschiedene kostenlose Report-Generatoren an, die sich über den Lazarus-Online-Packager installieren liessen. Alles unfertig. Der einzige Report-Generator, den ich halbwegs brauchbar fand und finde, heißt FortesReport. Dieser ist sehr nah an QuickReport und lässt sich ähnlich bedienen. Man baut die Reports mit dem Lazarus-GUI-Builder zusammen und kann sie dann aufrufen und mit Daten füllen. Ein Problem gibt es aber an FortesReport, welches nicht zu unterschätzen ist: Die Dokumentation. Diese gibt es nämlich nicht.

Wer mich kennt weiß, ich bin faul. Jemand meinte mal zu mir, alle Programmierer sind faul. Also überlegte ich nach einem Weg, wie ich das QuickReport-Zeugs zum FortesReport-Zeugs konvertiert bekomme. Und während ich so nachdachte, googlte ich und fand jemanden, der das selbe Problem hatte. Ich war nicht alleine auf dieser Welt. DACConv heißt das Programm. Die Software macht nicht viel mehr, als in den Pascal-Dateien und in den LFM-Dateien Klassennamen und Variablennamen anhand bestimmter mitgelieferter Schemata auszutauschen. Abgesehen von der echt schlechten Bedienung der Software macht sie ihren Job aber fein. Nur leider bleibt Handarbeit nicht erspart, denn teils müssen Bänder umgebaut werden, teils müssen Objekte entfernt werden, die einfach von FortesReport nicht unterstützt werden. Aber es geht allemal schneller, sehr viel schneller, als die Reports vollständig von Hand neuzubauen.

Ist das alles geschafft, kann man stolz auf sich sein. Das Projekt lässt sich reproduzierbar kompilieren und läuft und auch die Reports sehen aus, wie im Original.

Ist das alles also einfach gewesen? Nein. Man benötigt bereits einiges an Erfahrung, viel Sitzfleisch und, am Wichtigsten: Nerven wie Drahtseile.

Was ich allerdings sagen muss: Lazarus und FreePascal sind sehr stabil und sehr brauchbar, das hätte ich so nicht gedacht. In all der Zeit ist mir Lazarus vielleicht vier oder fünf Mal abgestürzt, und es war nicht einmal schlimm, da keine Daten dadurch beeinträchtigt wurden. Sie sollten noch ein wenig an der Stabilität feilen, aber ich könnte mir vorstellen, damit noch einmal zu arbeiten. Vielleicht nicht an einem großen Projekt, aber an kleinen Tools.