Teil-Formulare clever nutzen

Die Möglichkeit, Teil-Formulare zu erstellen und einzubinden, hat zwei Vorteile. Einen offensichtlichen und einen weniger offensichtlichen.

Der offensichtliche Vorteil ist die Möglichkeit, wiederkehrende Abschnitte zu kapseln. Wenn ich erkenne, dass ein gewisser Bereich in mehreren Formularen vorkommt, dann verschiebe ich diesen Bereich in ein Teil-Formular und entferne ihn aus den entsprechenden Formularen. An der Leerstelle setze ich jeweils das Teil-Formular ein. Das spart Schreibarbeit und folgt dem guten Muster “Don’t Repeat Yourself”. Wenn ich das Teil-Formular ändere, dann wirkt sich das auf alle Formulare aus, die das Teil-Formular verwenden.

Weniger offensichtlich ist dies: Ein Teil-Formular kann als Interface dienen. Seine Feldwerte werden dazu durch einen Event-Handler im Formular gesetzt, beispielsweise durch das Exiting-Event eines zugehörenden Feldes oder das QuerySave-Event des Formulars. Dadurch, dass ein Formular ein Teil-Formular einbindet, codifiziert das Formular, dass es das Interface des Teil-Formluars implementiert – um java-ähnlich zu sprechen.

Teil-Formulare auflisten

Die Notes-Pogrammierung, die ich von meinen Vorgängern geerbt habe, ist voll von Teilmasken und schlecht dokumentiert. Wie erkenne ich, welche Teil-Formulare in einem Formular eingebunden sind? Anders formuliert: Wie erkenne ich, welche Interfaces ein Formluar implementiert? Mit den Bordmitteln des Designer kommt man leider nicht weiter. Das Notes-eigene XML und eine Transformation beenden die Not.

Zum Glück hat jedes (Teil-)Formular eine XML-Repräsentation in einem Dialekt namens dxl. Und der Designer kann eine XML-Transformation auf auswählbare Elemente anwenden. Fehlt nur die passende Transformation. Hier ist sie:

<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:dxl="http://www.lotus.com/dxl">

<xsl:output method="text" indent="yes"/>

<xsl:template match="/">
	<xsl:apply-templates/>
</xsl:template>

<xsl:template match="dxl:*">
	<xsl:apply-templates select="dxl:*"/>
</xsl:template>

<xsl:template match="dxl:subformref">
	<xsl:value-of select="@name"/>
</xsl:template>

</xsl:stylesheet>

Grafische Tools, wie der Designer eins ist, beschleunigen die Schaffung der Benutzeroberfläche enorm. Aber der gute alte Quelltext wird weiterhin seine Daseinberechtigung haben. Beruhigend.

Zw. 8 - 14 Zeichen lang
Start und Ende KEIN Sonderzeichen
Mind. 2 Sonderzeichen
Mind. 2 Großbuchstaben
Mind. 2 Kleinbuchstaben
Mind. 2 Ziffern

Das ist nicht schwer, oder? Die Kommentare im Java-Quelltext sind etwas ausführlicher als für mich üblich, weil ich hoffe, es allgemein unterhaltsam zu machen. LotusScript ist unkommentiert – quick’n’dirty.

Der gezeigte Java-Quelltext entstand, nachdem ich die Aufgabe in LotusScript erledigt hatte. Die Variante in Java gefällt mir, weil sie deutlich zeigt, welche Anforderungen erfüllt werden. Der Quelltext in Java ist viel länger – das kann man als Nachteil werten. Aber er ist flexibler – dem LotusScript-Code kann man wegen der Starrheit keinen Vorwurf machen, denn schließlich musste es fertig werden.

Im grossen und ganzen beruhen beide auf derselben Idee, man erkennt viele Ähnlichkeiten, beispielsweise Definition der Menge auszuwählender Zeichen, beispielsweise zufallsgeleitetes finden einer freien Position.

WordPress erlaubt es mir nicht, jar-Dateien hochzuladen. What a crap! Anyway, hier ist der Quelltext. Du willst diesen Code benutzen? Erzeuge ein PasswordGenerator-Objekt und rufe getPassword auf. Deadsimple.

Im folgenden die wichtigsten Klassen.

PasswordGenerator

package de.aysx.pwgen;

import java.util.Random;

import de.aysx.pwgen.common.Auffueller;
import de.aysx.pwgen.common.Bedingungserfueller;
import de.aysx.pwgen.impl.AuffuellerAlleZeichen;
import de.aysx.pwgen.impl.AuffuellerGross;
import de.aysx.pwgen.impl.AuffuellerKlein;
import de.aysx.pwgen.impl.AuffuellerSZ;
import de.aysx.pwgen.impl.AuffuellerZiffer;
import de.aysx.pwgen.impl.KeinSZamAnfang;
import de.aysx.pwgen.impl.KeinSZamEnde;

/**
 * Einstiegspunkt für das Verständnis des PasswordGenerator-Projekts.
 * Diese Klasse wird benutzt, um ein Passwort zu generieren.
 * 
 * Kontrolliert, wie das Passwort erzeugt wird.
 * Steuert die Erzeuger-Klassen, steckt sie passend zusammen.
 *
 */
public class PasswordGenerator {

    /**
     * Minimale Länge des Passworts.<br>
     * Wenn man es noch flexibler möchte, dann macht man aus diesem Wert eine
     * Variable. Für's erste ist es eine Konstante.
     * 
     */
    public static final int MIN = 8;
    
    /**
     * Maximale Länge des Passworts.<br>
     * s.a. MIN.
     */
    public static final int MAX = 14;

    /**
     * 
     * @return ein zufälliges Password, das den Anforderungen entspricht.
     */
    public String getPassword() 
    {
        int lange = zufallsLaenge(); // Eine Zahl zwischen MIN und MAX.
        int egal = 0; // Wird für die syntaktische Korrektheit benötigt.

        /* Diese Variable enthält die Zeichen des Passworts. Noch ist 
         * sie leer.
        */
        char[] c = new char[lange];
        
        /* Hier spiegelt sich deutlich die Anforderung wider, welche Zeichen 
         * enthalten sein sollen und wieviele jeweils.
         * SZ steht für "Sonderzeichen".
         */
        Auffueller fueller =
                new AuffuellerKlein     ( 2,
                new AuffuellerSZ        ( 2,
                new AuffuellerZiffer    ( 2,
                new AuffuellerGross     ( 2,
                /* Wenn das PW mehr als 8 Zeichen hat, dann wird der restliche
                         Freiraum mit beliebigen Zeichen aufgefüllt. Die 
                         Anzahl ist "egal", weil ein AuffuellerAlleZeichen
                         dafür sorgt, dass alle restlichen freien Positionen 
                         belegt werden. */
                new AuffuellerAlleZeichen ( egal, null )))));

        /* Ein weiterer Teil der Anforderung - deutlich sichtbar mit
         * wenig Phantasie.
         */
        Bedingungserfueller bed =
                new KeinSZamAnfang  (
                new KeinSZamEnde    (null));

        // Passwort erzeugen, Variable c verändern; Obacht: Output-Parameter.
        fueller.fuelle ( c );
        bed.pruefenKorrigierenWeitergeben ( c, 0, c.length - 1 );

        // Rückgabewert aufbereiten;
        String erg = "";
        for (int i = 0; i < c.length; i++) {
            erg += new Character(c[i]);
        }
        
        // Fertig. Der uninteressierte Leser kann hier aufhören.
        return erg;
    }

    /**
     * @return eine Zahl zwischen MIN und MAX;
     */
    private int zufallsLaenge() {
        int erg = 0;
        Random r = new Random();
        erg = MIN + r.nextInt(MAX - MIN + 1);
        return erg;
    }
}

Konstanten

/**
 * Konstanten im Projekt PasswordGenerator.
 */
public class Constants
{
    /* Auf Wunsch sind einige Zeichen nicht enthalten. */
    public static final String SONDERZEICHEN = "!§$%&/()=}][{-_.:,;<>"; 

    /* Kleinbuchstaben */
    public static final String KLEINBUCHSTABEN = "abcdefghijklmnopqrstuvwxyz"; 

    /* Grossbuchstaben */
    public static final String GROSSBUCHSTABEN = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    /* Ziffern */
    public static final String ZIFFERN = "0123456789";
	
}

Auffueller

package de.aysx.pwgen.common;

import java.util.Random;

/**
 * Fuellt ein Char[] mit der angegebenen Anzahl von Zeichen.<br>
 * Danach wird der nächste Auffueller aufgerufen, wenn einer vorhanden ist.<br>
 * <br>
 * Die unterschiedlichen konkreten Ausprägungen dieser Klasse leisten 
 * wesentlich eins: Sie stellen eine jeweils passende Menge von Zeichen zur
 * Verfügung, aus der mittels Zufallsgenerator eine bestimmte Anzahl ausgewählt
 * wird.<br>
 * Beispiel: AuffuellerGross ( 2, ...) kennt alle Grossbuchstaben und wählt
 * aus dieser Menge zwei Buchstaben aus.
 */
public abstract class Auffueller {

    public Auffueller(int zeichenAnzahl, Auffueller next) {
        setAnzahl(zeichenAnzahl);
        setNext(next);
    }

    /**
     * Aus welcher Zeichenklassen sollen Zeichen gezogen werden? Aus dieser!
     */
    public abstract String getZeichenklasse();

    /**
     * Wieviele Zeichen sollen gezogen werden? So viele!
     */
    public int getAnzahl() {
        return anzahl;
    }

    /** 
     * Diskutieren: Soll dieser Member immutable sein?
     * s.a. http://en.wikipedia.org/wiki/Immutable
     */
    public void setAnzahl(int i) {
        anzahl = i;
    }
    
    private int anzahl;

    /**
     * Ein Auffueller kann einen anderen Auffueller dekorieren, so dass zuerst
     * das eine getan wird und dann der nächste Auffueller das nächste tut usw.
     * bis zum Ende der Kette.
     * 
     * @return Den dekorierten Auffueller.
     */
    public Auffueller getNext() {
        return nextAuffueller;
    }

    /** 
     * TODO: Immutable?
     */
    public void setNext(Auffueller a) {
        nextAuffueller = a;
    }
    
    private Auffueller nextAuffueller;

    /**
     * TODO Beachten Konstraints, z.B. Laenge des Arrays >= getAnzahl, z.B.
     * Anzahl der freien Plätze im Array >= getAnzahl. Erstmal gehe ich davon
     * aus, dass schon alles gutgeht. Dieser Code ist noch provisorisch.<br>
     * 
     * @param c das zu fuellende Array
     * @return ein char[], das entsprechend diesem Auffueller und seinen
     *         dekorierten Auffuellern bearbeitet wurde.
     */
    public char[] fuelle ( char[] c )
    {
        for (int i = 0; i < getAnzahl(); i++) {
            c [ getLeerePosZufaellig ( c )] = getZufallschar ();
        }

        /* Wie Yoda ich spreche, weil oft zum Vorteil es ist in LotusScript
         * und abgefärbt das hat. http://de.wikipedia.org/wiki/Yoda_Conditions
         */
        if (null != getNext()) {
            getNext().fuelle(c);
        }

        return c;
    }

    /**
     * @return Ein Zeichen, das zufällig aus der Menge der hier bekannten
     * Zeichen ausgewählt wird.
     */
    public char getZufallschar ()
    {
        Random random = new Random ();
        int max = getZeichenklasse ().length ();
        int pos = random.nextInt ( max );
        char erg = getZeichenklasse ().charAt( pos );
        return erg;
    }

    /**
     * Im LotusScript findet sich eine andere Implmentierung und die
     * Idee zum folgenden Allgorithmus.
     *
     * @param c Das zu füllende Array.
     * @return Eine zufällig ausgewählte leere Stelle in c.
     */
    private int getLeerePosZufaellig ( char[] c )
    {
        int erg = 0;
        
        /* Anzahl Leerstelle ermitteln. */
        int anzahlLeer = 0;
        for ( int i = 0; i < c.length; i++ ){
            if ( 0 == c[i]){
                anzahlLeer ++;
            }
        }
        
        /* Mapping Leerstelle zu Index. */
        int[] auswahl = new int [ anzahlLeer ];
        int k = 0;
        for ( int i = 0; i < c.length; i++ ){
            if ( 0 == c[i]){
                auswahl [k] = i;
                k ++;
            }
        }
        
        /* Zufaellig auswaehlen und Zurueck-mapping. */
        Random r = new Random ();
        erg = r.nextInt ( anzahlLeer );
        return auswahl [erg];
    }
}

Bedingungserfueller

package de.aysx.pwgen.common;

/**
 * Prüft, ob ein Char[] einer bestimmten Bedingung genügt.<br>
 * Wenn es der Bedingung nicht genügt, dann werden Zeichen getauscht, so
 * dass die Bedingung erfüllt ist.<br>
 * Nachdem die Bedingung erfüllt ist, wird das zu prüfende Array an den
 * nächsten Bedingungsprüfer weitergegeben (Dekorator-Pattern).
 * 
 */
public abstract class Bedingungserfueller
{
    private Bedingungserfueller next;

    /**
     * @return Der nächste Bedingungserfüller. Darf null sein.
     */
    public Bedingungserfueller getNext ()
    {
            return next;
    }

    public void setNext ( Bedingungserfueller next )
    {
            this.next = next;
    }

    public Bedingungserfueller ( Bedingungserfueller next )
    {
            this.next = next;
    }

    /**
     * Diese Methode prüft, ob die jeweils zu implementierende Bedingung erfüllt
     * ist. Falls nicht, wird korrigiert. Und wenn es einen nächsten 
     * Bedingungserfüller gibt, dann wird er aufgerufen.
     * 
     * @param c das zu prüfende Array
     * @param vonPos Die Stelle, von der an das Array geprüft und verändert 
     * werden soll. Wenn ich z.B. einen Erste-Stelle-Prüfer habe, und der hat die erste
     * Stelle korrigiert, dann muss verhindert werden, dass die Korrektur verändert
     * wird. Das erreiche ich, indem der vonPos einen passenden Wert hat.
     * 
     * @param bisPos Die Stelle, bis zu der das Array geprüft und verändert
     * werden soll. Gegenstück zu vonPos.
     * 
     * @return ein korrigiertes Array.
     *
     * TODO Methode umbenennen, weil "Weitergeben" redundant ist.
     */
    public abstract char[] pruefenKorrigierenWeitergeben ( char[] c, int vonPos, int bisPos );
	
}

Die konkreten Implementierungen von Auffueller und Bedingserfueller finden sich in der jar-Datei.

Und nun zu etwas ganz anderem: Ein Password-Generator in LotusScript. Entstanden ist er nach einer Skizze an der Tafel. So sind einige Grobheiten enthalten, Beispiel die Variablen S, T, G, K, Z, die zugehörenden *unten und *oben und deren Initialisierung. Die Java-Implementierung hat davon “gelernt”. Änderungen werden an diesem Quelltext nicht mehr vorgenommen: Er funktioniert, ist ausreichend schnell und leserlich, so daß auch die Kollegen ihn warten können. Mission erfüllt.

'++LotusScript Development Environment:2:5:(Options):0:74
%REM
	Library RandomPassword
	Created 10.07.2014 by
	Description: Comments for Library
%END REM
Option Public
Option Declare


'++LotusScript Development Environment:2:5:(Forward):0:1
Declare Sub Initialize
Declare Function pickZufallUndEntferne ( stringArray As Variant ) As String
Declare Function ArrayToString (  stringArray As Variant ) As String
Declare Function findeLeerePosZufaellig ( stringArray As Variant ) As Integer
Declare Function berechnePassword As String

'++LotusScript Development Environment:2:5:(Declarations):0:10
Dim S As String
Dim Sunten As Integer
Dim Soben As Integer

Dim T As String
Dim Tunten As Integer
Dim Toben As Integer

Dim G As String
Dim Gunten As Integer
Dim Goben As Integer

Dim K As String
Dim Kunten As Integer
Dim Koben As Integer

Dim Z As String
Dim Zunten As Integer
Dim Zoben As Integer

Dim sonder (1 To 2 ) As String
Dim gkz (1 To 6 ) As String

Dim Laenge_min As Integer
Dim Laenge_max As Integer
Dim Laenge_akt As Integer

'++LotusScript Development Environment:2:2:Initialize:1:10
Sub Initialize
	' ---------------------------------------------------------------------------------------
	' init Konstanten
	' ---------------------------------------------------------------------------------------
	S = "!§$%&/()=*'_:;,.-<>"
	Sunten = 1
	Soben = Len ( S )
	
	T = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	Tunten = 1
	Toben = Len ( T )
	
	G = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	Gunten = 1
	Goben = Len ( G )
	
	K = "abcdefghijklmnopqrstuvwxyz"
	Kunten = 1
	Koben = Len ( K )
	
	Z = "0123456789"
	Zunten = 1
	Zoben = Len ( Z )
	
	Laenge_min = 8
	Laenge_max = 14
	Laenge_akt = ( Laenge_max - Laenge_min )*Rnd() + Laenge_min
	
	' ---------------------------------------------------------------------------------------
	' init Variablen
	' ---------------------------------------------------------------------------------------
	
	Dim i As Integer
	i = 0
	Dim tmp As Integer
	
	For i = 1 To 2
		tmp = ( Soben - Sunten )*Rnd() + Sunten
		sonder ( i ) =  Mid ( S, tmp, 1 )
	Next
	
	For i = 1 To 2
		tmp = ( Goben - Gunten )*Rnd() + Gunten
		gkz ( i ) =  Mid ( G, tmp, 1 )	
	Next
	
	For i = 3 To 4
		tmp = ( Koben - Kunten )*Rnd() + Kunten
		gkz ( i ) =  Mid ( K, tmp, 1 )	
	Next
	
	For i = 5 To 6
		tmp = ( Zoben - Zunten )*Rnd() + Zunten
		gkz ( i ) =  Mid ( Z, tmp, 1 )		
	Next
	
	Dim erg As String
	erg = ArrayToString ( sonder )
	erg = erg + ArrayToString ( gkz )
End Sub

'++LotusScript Development Environment:2:1:pickZufallUndEntferne:5:8
%REM
	Function pickZufallUndEntferne
	Description: Comments for Function
%END REM
Function pickZufallUndEntferne ( stringArray As Variant ) As String
	Dim max As Integer
	max = UBound( stringArray )
	
	Dim tmp As Integer
	tmp = ( max - 1 ) * Rnd() + 1
	
	Dim erg As String
	erg = stringArray ( tmp ) 
	
	While ( erg = "" )
		tmp = ( max - 1 ) * Rnd() + 1
		erg = stringArray ( tmp ) 
	Wend
	
	stringArray (tmp) = ""
	pickZufallUndEntferne = erg
End Function

'++LotusScript Development Environment:2:1:ArrayToString:2:8

Function ArrayToString (  stringArray As Variant ) As String
	Dim erg As String
	erg = ""
	ForAll x In stringArray
		erg = erg + x
	End ForAll
	ArrayToString = erg
End Function

'++LotusScript Development Environment:2:1:findeLeerePosZufaellig:5:8
%REM
	Function findeLeerePosZufaellig
	Description: Bedenke, dass es lange dauert in einem grossen 
        Array, das nur noch eine Leerstelle hat, die freie Stelle so zu "finden".
        Vorschlag, Skizze: Sei n Anzahl Leerstellen und es gebe ein 
        Mapping für 0 <= i <= n für den Index der Leerstelle. Berechne k als Zufallszahl 
        zwischen 0 und n-1 und ermittle durch das Mapping den gesuchten Index.
%END REM
Function findeLeerePosZufaellig ( stringArray As Variant ) As Integer
	Dim erg As Integer
	erg = 0
	
	Dim s As String
	s = stringArray ( erg )
	
 	Dim max As Integer
 	max = UBound( stringArray )
	
 	While ( s <> "" )
            erg = ( max - 1 ) * Rnd() + 1
 	    s = stringArray ( erg )
 	Wend
	
	 findeLeerePosZufaellig = erg
End Function

'++LotusScript Development Environment:2:1:berechnePassword:5:8
%REM
	Function berechnePassword
	Description: Comments for Function
%END REM
Function berechnePassword As String
	Call Initialize()
	Dim erg () As String
	ReDim erg ( Laenge_akt ) As String 
	
        ' Kein SZ am Anfang und Ende.
	erg (0) = pickZufallUndEntferne ( gkz )
	erg ( Laenge_akt-1 ) = pickZufallUndEntferne ( gkz )
	
	Dim rndPos As Integer
	
        ' Grossbuchstaben, Kleinbuchstaben und Ziffern verteilen.
	ForAll x In gkz
		If Not ( x = "" ) Then 
			rndPos = findeLeerePosZufaellig( erg )
			erg ( rndPos ) = x
		End If
	End ForAll
	
        ' Sonderzeichen verteilen.
	ForAll x In sonder
		rndPos = findeLeerePosZufaellig( erg )
		erg ( rndPos ) = x
	End ForAll
	
	' Nun enthaelt erg 8 nicht-leere Zeichen.
	' Die Leerstellen fuellen mit Zufallsstelle aus T.
	ForAll x In erg
		If ( x = "" ) Then
			rndPos = ( Toben - Tunten )*Rnd() + Tunten
			x = Mid ( T, rndPos, 1 )
		End If 
	End ForAll
	
	berechnePassword = ArrayToString( erg )
End Function

Im LotusScript hat man einen guten Überblick über den gesamten konkreten Algorithmus, in Java erkennt man nur Umrisse. Die Java-Klassen kann ich an anderer Stelle wiederverwenden a) falls so etwas wieder gebraucht wird – mit der Perspektive “nie” und b) falls ich mich daran erinnere, dass die genau passenden Klassen genau hier zu finden sind. Das LotusScript ist “nur” als ganzes wiederverwendbar. Nur weil es nicht objektorientiert ist, heisst das nicht, dass es schlecht ist. Just because you’re paranoid it don’t mean they’re not after you. Have a nice day.

Wer die Beschreibung liest und die Grafik mit den Pastell-Tönen studiert, merkt, dass nichts zur Bedienung so einer Tabelle geschrieben steht. Es geht so: Klicke auf das Maximieren-Symbol in einer Zeile, dann wird der zugehörende Abschnitt aufgeklappt. Das ist alles. Das ist alles?!? Wie klappe ich so einen Abschnitt wieder zu? Indem ich auf den Maximieren-Knopf eines anderen Abschnitts klicke. Das geht klar, solange die Abschnitte so klein sind wie auf der IBM-Seite. Im echten Leben sind die Abschnitte größer, also ist auch der Abstand der Maximieren-Symbole größer, und das ist nicht bequem zu bedienen. Grundübel: Mangel an Symmetrie, nur “auf”, kein “zu”. Einen Architekten, der eine derartige Tür einbaut, schickt man zum Teufel.

Zum Glück kann man eine Tabelle mit Registern erstellen. Ich finde, das ist ein mächtig cooles Feature von Notes. Es sorgt für Ordnung in der Benutzeroberfläche und es ist bequem zu bedienen.

If the document already has an item called itemName$, AppendItemValue does not replace it. Instead, it creates another item with the same name, and gives it the value you specify.

Und es gibt NotesDocument.GetFirstItem ( name$ ). Zitat aus der API-Doku:

However, the recommendation is that you avoid creating multiple items with the same name.

Die Bedienungsanleitung von GetFirstItem legt also nahe, AppendItemValue nicht zu nutzen. Seltsam, dass so eine Situation entstanden ist.

Für meine Aufgabe habe ich schließlich NotesItem.AppendToTextList ( value$ ) benutzt. Das zeigt eine Schieflage: Es gibt keine Möglichkeit, einen hinzugefügten Wert wieder zu entfernen.

Also habe ich zwei Programmierungen ergänzt: Zum einen AppendTextToItemsTextlist ( name$, wert$ ) und zum anderen RemoveFromTextList ( wert$ ), jeweils in den entsprechenden Wrapper-Klassen.