Auch in Installationen, für die das eingebaute Authentifizierungsschema "Application Express" verwendet wird, ist es oft erwünscht, dass die Endbenutzer ihr Kennwort selbstständig ändern können. Hier erfahren Sie, wie dies ermöglicht werden kann. Ziel ist es, eine Anwendungsseite zu erstellen, die in etwa wie in Abbildung 1 aussieht und beliebig in Applikationen eingebaut werden kann.

Abbildung 1: Dialog zum Ändern des Passworts für den Endbenutzer

Erstellen Sie im Application Builder eine neue Seite oder navigieren Sie zu der Seite, die das Formular zur Kennwortänderung erhalten soll. Das Beispiel verwendet Seite 4 - sie können natürlich eine beliebige Seite verwenden.

Region und Elemente (Items)

Navigieren in der Seitenbearbeitung im linken Bereich zu den Regionen und erstellen Sie eine neue HTML-Region mit dem Namen Kennwort ändern. Akzeptieren Sie dabei die vorgeschlagenen Default-Werte.

Erstellen Sie danach vier Texteingabefelder in der neuen Region: P4_CURR_USER, P4_PW, P4_NEW_PW und P4_NEW_PW2 (Die Variante Mehrere Elemente mit tabellarischer Form erstellen ist hierbei sehr hilfreich). Nun passen Sie die erstellten Elemente an, indem Sie in der Seitenbearbeitung auf diese klicken und so ins Menü Seitenelement bearbeiten geführt werden. Nehmen Sie folgende Änderungen vor:

• Stellen Sie die Eigenschaft Schreibgeschützt beim Element P4_CURR_USER auf immer.
• Stellen Sie die Elemente P4_PW und P4_NEW_PW auf den Anzeigetyp Kennwort um.
• Stellen Sie das Element P4_NEW_PW2 auf den Typ Kennwort (wird nach Drücken der EINGABETASTE weitergeleitet) um.
• Und wenn Sie möchten: Richten Sie den Label aller Elemente links aus (Label: Horizontale/vertikale Ausrichtung).

Schaltfläche

Erstellen Sie als nächstes eine Schaltfläche in derselben Region (Abbildung 2)

Abbildung 2: Schaltfläche hinzufügen

Akzeptieren Sie als Schaltflächenposition Schaltfläche in einer Regionsposition erstellen. Als Name der Schaltfläche wählen Sie Anwenden (APPLY_CHANGES). Akzeptieren Sie das Label Anwenden, den Schaltfächentyp und die Aktion Seite weiterleiten und an URL umleiten. Klicken Sie auf den folgenden Seiten stets auf Weiter und erstellen Sie schließlich die Schaltfläche.

Ladeprozeß

Nun geht es daran, den Namen des aktuell angemeldeten Benutzers beim Laden der Seite in das Eingabefeld P4_CURR_USER einzutragen. Erstellen Sie dazu einen neuen onLoad-Prozeß:

Wählen Sie den Prozesstyp PL/SQL, benennen Sie den Prozess mit UserNameLaden und wählen Sie den Punkt Beim Laden - Vor Regionen. Geben Sie dann folgenden PL/SQL-Code ein:

DECLARE 
  w_name varchar2(30);
  w_userid number;
BEGIN
  w_userid := APEX_UTIL.GET_CURRENT_USER_ID;
  w_name := APEX_UTIL.GET_USERNAME(w_userid);
  :P4_CURR_USER := w_name;
END;

Testen Sie die Seite nun - bis hierhin sieht es ganz gut aus: der Name des angemeldeten Benutzers wird angezeigt und die Eingaben in den drei Kennwort-Feldern werden als Sternchen angezeigt - allerdings fehlen noch die Komponenten, die Sie für die Verarbeitung brauchen.

Validierungen

Als erstes wird sichergestellt, dass in alle Felder Eingaben gemacht werden. Erstellen Sie dazu Validierungen. Wählen Sie dort die Variante Mehrere NOT NULL-Validierungen erstellen, markieren Sie alle Elemente und erstellen Sie so die Validierungen.

Abbildung 3: NOT NULL Validierungen erstellen

Als nächstes erstellen Sie eine Validierung, die das aktuelle Passwort des Benutzers prüft. Wählen Sie dafür Validierung auf Elementebene für das Element P4_PW, als Methode PL/SQL und dort Funktion, die Fehlertext zurückgibt. Hinterlegen Sie folgenden Code für die Validierungsfunktion:

declare 
  val_b boolean;
BEGIN
  val_b := APEX_UTIL.IS_LOGIN_PASSWORD_VALID (:P4_CURR_USER, :P4_PW);
  if not val_b then 
    return ('Das Passwort ist nicht gültig.');
  else 
    return null;
  end if;
END;

Als nächstes muss sichergestellt werden, dass das neue Passwort mit seiner Wiederholung übereinstimmt. Erstellen Sie dafür wiederum eine Validierung auf Elementebene zum Element P4_NEW_PW2. Auch dies ist eine PL/SQL-Funktion, die Fehlertext zurückgibt:

DECLARE 
  w_fehler varchar2(200) := 'Das Kennwort stimmt nicht<br/> mit der Wiederholung überein.';
BEGIN
  if :P4_NEW_PW != :P4_NEW_PW2 then
    return w_fehler;
  else 
    return null;
  end if;
END;

Als letzte Validierung wid nun eine Prüfung erstellt, mit der das neue Kennwort gegen die Kriterien geprüft wird, die auf Administrationsebene definiert wurden. Dies ist wieder eine Validierung auf Elementebene und zwar bezogen auf P4_NEW_PW. Auch diese Validierung ist eine Funktion, die einen Fehlertext zurückgibt.

DECLARE
  l_username                    varchar2(30);
  l_password                    varchar2(30);
  l_old_password                varchar2(30);
  l_workspace_name              varchar2(30);
  l_min_length_err              boolean;
  l_new_differs_by_err          boolean;
  l_one_alpha_err               boolean;
  l_one_numeric_err             boolean;
  l_one_punctuation_err         boolean;
  l_one_upper_err               boolean;
  l_one_lower_err               boolean;
  l_not_like_username_err       boolean;
  l_not_like_workspace_name_err boolean;
  l_not_like_words_err          boolean;
BEGIN
  l_username := :P4_CURR_USER;
  l_password := :P4_NEW_PW;
  l_old_password := :P4_PW;
  l_workspace_name := APEX_UTIL.GET_DEFAULT_SCHEMA;

  APEX_UTIL.STRONG_PASSWORD_CHECK(
    p_username                    => l_username,
    p_password                    => l_password,
    p_old_password                => l_old_password,
    p_workspace_name              => l_workspace_name,
    p_use_strong_rules            => false,
    p_min_length_err              => l_min_length_err,
    p_new_differs_by_err          => l_new_differs_by_err,
    p_one_alpha_err               => l_one_alpha_err,
    p_one_numeric_err             => l_one_numeric_err,
    p_one_punctuation_err         => l_one_punctuation_err,
    p_one_upper_err               => l_one_upper_err,
    p_one_lower_err               => l_one_lower_err,
    p_not_like_username_err       => l_not_like_username_err,
    p_not_like_workspace_name_err => l_not_like_workspace_name_err,
    p_not_like_words_err          => l_not_like_words_err
  );

  IF l_min_length_err THEN 
      return('Kennwort ist zu kurz');
  END IF;

  IF l_new_differs_by_err THEN 
       return('Kennwort muss sich vom alten Kennwort unterscheiden');
  END IF;

  IF l_one_alpha_err THEN 
       return('Kennwort muss wenigstens einen Buchstaben enthalten');
  END IF;

  IF l_one_numeric_err THEN 
       return('Kennwort muss wenigstens eine Ziffer enthalten');
  END IF;

  IF l_one_punctuation_err THEN 
       return('Kennwort muss wenigstens ein Sonderzeichen enthalten');
  END IF;

  IF l_one_lower_err THEN
      return('Kennwort muss wenigstens einen Kleinbuchstaben enthalten');
  END IF;

  IF l_one_upper_err THEN
      return('Kennwort muss wenigstens einen Grossbuchstaben enthalten');
  END IF;

  IF l_not_like_username_err THEN
      return('Kennwort darf nicht den Benutzernamen enthalten');
  END IF;

  IF l_not_like_workspace_name_err THEN
      return('Kennwort darf nicht den Workspace-Namen enthalten');
  END IF;

  IF l_not_like_words_err THEN
      return('Kennwort enthält unerlaubten Begriff');
  END IF;

  -- bis hier alles ok, dann 
  return null;
END;

Erstellen Sie die Validierung - diese Lösung ist recht flexibel, da nun für das neue Passwort die Regeln greifen, welche der APEX Administrator zentral für den Server festgelegt hat.

Verarbeitungsprozeß

Abbildung 4: Verarbeitungsprozeß und abschließende Verzweigung erstellen

Erstellen Sie nun einen onSubmit-Prozess, welcher das Passwort tatsächlich ändert (bis hierhin wurde lediglich validiert). Als Ausführungspunkt wählen Sie also Bei Weiterleitung - Nach Berechnungen und Validierungen aus. Der PL/SQL-Code ist recht simpel:

BEGIN
  APEX_UTIL.CHANGE_CURRENT_USER_PW (:P4_NEW_PW);
END;

Hinterlegen Sie Kennwort wurde geändert oder einen ähnlichen Text als Erfolgsmeldung - als Fehlermeldung bietet sich #SQLERRM# an. Zum Abschluß muss nun nur noch eine Verzweigung erstellt werden ...

Verzweigung

Erstellen Sie also eine neue Verzweigung - das Ziel hängt von Ihrer Anwendung ab. Wichtig ist, dass Sie den Cache Inhalt löschen und die Erfolgsmeldung über Prozess einbeziehen.

Fertig. Nun kann der Endbenutzer mit dieser Seite sein Passwort ändern. Die Kür ist es nun, die Seite einzeln zu exportieren und dann in anderen Anwendungen wiederzuverwenden ...

Zurück zur Community-Seite

Bruno Unberath ist seit 1991 Anwendungsentwickler bei der Nürnberger Versicherungsgruppe. Nach etlichen Jahren Großrechnererfahrung, verlagerte sich sein Tätigkeitsschwerpunkt in das J2EE- und Oracle-Umfeld. Zur Zeit betreut er die Oracle-Belange in einem großen Projekt; er beschäftigt sich auch mit Datenbank-basierten Anwendungen - insbesondere APEX."