Tutorial: RAD Server-Client-Anwendung für die Verwaltung von RAD Server-Benutzern

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Tutorials zu Datenbanken und LiveBindings


In diesem Tutorial wird die Verwaltung von beim EMS-Server registrierten EMS-Benutzern gezeigt.

Es wird eine einfache EMS-Client-Anwendung für die Registrierung neuer EMS-Benutzer und die Anmeldung beim EMS-Server mit einem bestehenden EMS-Benutzer erstellt. Anhand der Client-Anwendung für die Verwaltung von EMS-Benutzern können EMS-Benutzerinformationen abgerufen, aktualisiert und gelöscht werden.

In diesem Tutorial wird Folgendes durchgeführt:

  • Verwenden der TBackendAuth-Komponente zum Authentifizieren Ihrer EMS-Client-Anwendung beim EMS-Server.
  • Verwenden der TBackendQuery-Komponente zum Abrufen der EMS-Benutzer vom EMS-Server.
  • Verwenden der TBackendUsers-Komponente zum Verwalten (Erstellen, Aktualisieren und Löschen) der EMS-Benutzer auf dem EMS-Server.

Erstellen der EMS-Client-Anwendung

  1. Erstellen Sie eine neue leere geräteübergreifende Anwendung (Delphi oder C++), indem Sie Folgendes auswählen:
    • Datei > Neu > Geräteübergreifende Anwendung - Delphi
    • Datei > Neu > Geräteübergreifende Anwendung - C++Builder > Leere Anwendung
  2. Ziehen Sie eine neue TTabControl-Komponente auf das TForm.
  3. Fügen Sie dem TTabControl ein neues TTabItem-Element hinzu.
    • Klicken Sie mit der rechten Maustaste auf die TTabControl-Komponente | TTabItem hinzufügen.
  4. Ändern Sie im Objektinspektor die folgenden TTabItem-Eigenschaften:
  5. Ändern Sie die Eigenschaft caption des Formulars in EMS Users Management.
  6. Ändern Sie die Eigenschaft title der Anwendung in EMS Users Management.
    • Für Delphi:
     Application.Title := 'EMS Users Management';
    
    • Für C++:
    Application->Title = "EMS Users Management";
    
  7. Ziehen Sie eine TEMSProvider-Komponente auf das TForm.
  8. Konfigurieren Sie im Objektinspektor die EMS-Server-Parameter wie folgt:
    • URLhost: localhost
    • URLPort: 8080
  9. Klicken Sie auf die Schaltfläche Verbindung testen. Wenn die Verbindung erfolgreich hergestellt werden konnte, wird eine Meldung mit der aktuellen Version des EMS-Servers angezeigt.

Anmelden eines bestehenden EMS-Benutzers beim EMS-Server

Verwenden Sie die Komponente TBackendAuth für die Anmeldung beim EMS-Server. Dazu benötigen Sie den Namen und das Passwort eines bestehenden EMS-Benutzers.

  1. Fügen Sie LogInTab eine neue TLayout-Komponente hinzu, und ändern Sie deren Name in LayoutLogIn.
  2. Fügen Sie dem Formular eine TBackendAuth-Komponente hinzu, und ändern Sie deren Eigenschaft Name in BackendAuthLogin.
  3. Öffnen Sie den LiveBindings-Designer zum Erstellen von bearbeitbaren Komponenten für den Benutzernamen und das Passwort, und verknüpfen Sie sie mit der TBackendAuth-Komponente:
    • Klicken Sie mit der rechten Maustaste auf das Feld UserName von BackendAuthLogin | Mit neuem Steuerelement verknüpfen | wählen Sie TEdit | klicken Sie auf "OK".
    • Klicken Sie mit der rechten Maustaste auf das Feld Password von BackendAuthLogin | Mit neuem Steuerelement verknüpfen | wählen Sie TEdit | klicken Sie auf "OK".
  4. Verschieben Sie in der Strukturansicht die Komponenten EditUserName und EditPassword in die Komponente LayoutLogin.
  5. Fügen Sie LayoutLogin eine TButton-Komponente hinzu, und ändern Sie deren Eigenschaft Name in LogIn.
  6. Doppelklicken Sie auf die LogIn-Schaltfläche, um das Ereignis OnClick zu erstellen.
  7. Implementieren Sie die Ereignisbehandlungsroutine für das Ereignis OnClick der LogIn-Schaltfläche, um die Anmeldung eines EMS-Benutzers beim EMS-Server zu ermöglichen.
    • Für Delphi:
    procedure TForm1.LogInClick(Sender: TObject);
    begin
      try
        BackendAuthLogin.LogIn;
      Except
        on E: Exception do
        begin
          ShowMessage('Connection to EMS Server failed');
        end;
      end;
    
    end;
    
    • Für C++:
    void __fastcall TForm1::LogInClick(TObject *Sender) {
        try {
            BackendAuthLogin->Login();
        } catch (System::Sysutils::Exception &e) {
            ShowMessage("Connection to EMS Server failed");
        }
    }
    

Abmelden vom EMS-Server

Verwenden Sie die Komponente TBackendAuth für die Abmeldung eines EMS-Benutzers vom EMS-Server. Wenn der EMS-Benutzer ordnungsgemäß beim EMS-Server angemeldet ist, ist LayoutLogin ausgeblendet.

  1. Fügen Sie LogInTab eine TLayout-Komponente hinzu, und ändern Sie deren Eigenschaft Name in LayoutLogOut.
  2. Fügen Sie LayoutLogOut eine TButton-Komponente hinzu, und ändern Sie die Eigenschaft Name in LogOut.
  3. Doppelklicken Sie auf die LogOut-Schaltfläche, um das Ereignis OnClick zu erstellen.
  4. Implementieren Sie die Ereignisbehandlungsroutine, indem Sie den folgenden Code hinzufügen:
    • Für Delphi:
    procedure TForm1.LogOutClick(Sender: TObject);
    begin
          BackendAuthLogin.Logout;
    end;
    
    • Für C++:
    void __fastcall TForm1::LogOutClick(TObject *Sender) {
        BackendAuthLogin->Logout();
    }
    
  5. Erstellen Sie eine Methode zum Anzeigen oder Ausblenden der LogIn- und LogOut-Layouts, je nach dem Anmeldestatus des EMS-Benutzers:
    • Erstellen Sie im private-Abschnitt des Codes die Methode ShowLogin:
    • Für Delphi:
    private
        procedure ShowLogin;
    
    • Für C++:
    private:    // User declarations
       void __fastcall ShowLogin();
    
    Tipp: Drücken Sie STRG+UMSCHALT+C, um den Code automatisch zu vervollständigen.
    • Fügen Sie der ShowLogin-Methode den folgenden Code hinzu:
    • Für Delphi:
    procedure TForm1.ShowLogin;
    begin
      LayoutLogOut.Position := LayoutLogIn.Position;
      LayoutLogIn.Visible := not BackendAuthLogin.LoggedIn;
      LayoutLogOut.Visible := BackendAuthLogin.LoggedIn;
    end;
    
    • Für C++:
    void __fastcall TForm1::ShowLogin() {
        LayoutLogOut->Position = LayoutLogIn->Position;
        LayoutLogIn->Visible =  !BackendAuthLogin->LoggedIn;
        LayoutLogOut->Visible = BackendAuthLogin->LoggedIn;
    }
    
  6. Rufen Sie im Ereignis OnCreate des Formulars die Methode ShowLogin auf, indem Sie den folgenden Code hinzufügen:
    • Für Delphi:
    procedure TForm1.FormCreate(Sender: TObject);
    begin
          ShowLogin;
    end;
    
    • Für C++:
    void __fastcall TForm1::FormCreate(TObject *Sender) {
        ShowLogin();
    }
    
  7. Fügen Sie der LayoutLogOut-Komponente des Formulars zwei TLabel-Komponenten hinzu:
    • Ändern Sie die Eigenschaft Text von Label1 in User Name.
    • Ändern Sie die Eigenschaft Name von Label2 in LoggedUser.
    • Verknüpfen Sie im LiveBindings-Designer das Feld UserName der BackendAuthLogin-Komponente mit der Beschriftung LoggedUser.
  8. Erstellen Sie die Ereignisse OnLoggedIn und OnLoggedOut der BackendAuthLogin-Komponente Ihres Formulars:
    • Öffnen Sie im Objektinspektor die Registerkarte "Ereignisse", und doppelklicken Sie auf die Ereignisse OnLoggedIn und OnLoggedOut.
    • Fügen Sie den folgenden Code hinzu, um die Ereignisse zu implementieren:
    • Für Delphi:
    procedure TForm1.BackendAuthLoginLoggedIn(Sender: TObject);
    begin
      ShowLogin;
    end;
    
    procedure TForm1.BackendAuthLoginLoggedOut(Sender: TObject);
    begin
      BackendAuthLogin.ClearFieldValues;
      ShowLogin;
    end;
    
    • Für C++:
    void __fastcall TForm1::BackendAuthLoginLoggedIn(TObject *Sender) {
        ShowLogin();
    }
    // ---------------------------------------------------------------------------
    
    void __fastcall TForm1::BackendAuthLoginLoggedOut(TObject *Sender) {
        BackendAuthLogin->ClearFieldValues();
        ShowLogin();
    }
    

LoginTab.png LoginTabLoggedUser.png

Registrieren eines neuen EMS-Benutzers beim EMS-Server

Die Anwendung verfügt über eine eigene Registerkarte für die Registrierung eines neuen EMS-Benutzers beim EMS-Server. Diese Registerkarte hat den Namen Signup Tab.

  1. Klicken Sie in der Strukturansicht mit der rechten Maustaste auf das TabControl | TTabItem hinzufügen.
  2. Ändern Sie im Objektinspektor die folgenden TTabItem-Eigenschaften:
  3. Fügen Sie dem Formular eine TBackendAuth-Komponente hinzu, und ändern Sie deren Eigenschaft Name in BackendAuthSignup. Mit BackendAuthSignup registrieren Sie einen neuen EMS-Benutzer beim EMS-Server.
  4. Öffnen Sie den LiveBindings-Designer:
    • Klicken Sie mit der rechten Maustaste auf das Feld UserName von BackendAuthSignup | Mit neuem Steuerelement verknüpfen | wählen Sie TEdit | klicken Sie auf "OK".
    • Klicken Sie mit der rechten Maustaste auf das Feld Password von BackendAuthSignup | Mit neuem Steuerelement verknüpfen | wählen Sie TEdit | klicken Sie auf "OK".
  5. Verschieben Sie in der Strukturansicht die Komponenten EditUserName2 und EditPassword2 in die Komponente SignUpTab.
  6. Fügen Sie den neuen EMS-Benutzern, die von der EMS-Client-Anwendung erstellt werden, benutzerdefinierte Details hinzu. Wählen Sie in der Strukturansicht die Komponente BackendAuthSignup aus.
    • Klicken Sie im Objektinspektor auf die Ellipse [...] der Eigenschaft UserDetails von BackendAuthSignup, und fügen Sie einen neuen Eintrag hinzu.
    • Ändern Sie im Objektinspektor die Eigenschaft Name des neuen Eintrags in email.
  7. Verknüpfen Sie im LiveBindings-Designer das Benutzerdetail email mit einem neuen TEdit-Steuerelement.
  8. Verschieben Sie in der Strukturansicht die Komponente EditUserDetailemail in die Komponente SignUpTab.
  9. Fügen Sie SignUpTab eine neue TButton-Komponente hinzu:
    • Ändern Sie die Eigenschaft Name in SignUp.
    • Erstellen Sie das Ereignis OnClick der SignUp-Schaltfläche, indem Sie auf die Schaltfläche doppelklicken.
    • Implementieren Sie die Ereignisbehandlungsroutine für das Ereignis OnClick der SignUp-Schaltfläche, indem Sie den folgenden Code hinzufügen:
    • Für Delphi:
    procedure TForm1.SignUpClick(Sender: TObject);
    begin
        BackendAuthSignup.Signup;
    end;
    
    • Für C++:
    void __fastcall TForm1::SignUpClick(TObject *Sender) {
        BackendAuthSignup->Signup();
    }
    
  10. Die Registerkarte SignUpTab ist nur sichtbar, wenn sich ein EMS-Benutzer beim EMS-Server angemeldet hat. Fügen Sie dazu der Methode ShowLogin den folgenden Code hinzu:
    • Für Delphi:
    procedure TForm1.ShowLogin;
    begin
    // previous code goes here
      SignUpTab.Visible := BackendAuthLogin.LoggedIn;
    end;
    
    • Für C++:
    void __fastcall TForm1::ShowLogin() {
        //previous code goes here
        SignUpTab->Visible = BackendAuthLogin->LoggedIn;
    }
    
  11. Öffnen Sie im Objektinspektor die Registerkarte "Ereignisse", und doppelklicken Sie auf das Ereignis OnSignedUp.
  12. Implementieren Sie die Ereignisbehandlungsroutine für das Ereignis OnSignedUp der BackendAuthSignup-Komponente, indem Sie den folgenden Code hinzufügen:
    • Für Delphi:
    procedure TForm1.BackendAuthSignupSignedUp(Sender: TObject);
    begin
      EditUserName2.Text:= '';
      EditPassword2.Text:='';
      EditUserDetailemail.Text:= '';
    end;
    
    • Für C++:
    void __fastcall TForm1::BackendAuthSignupSignedUp(TObject *Sender) {
        EditUserName2->Text = "";
        EditPassword2->Text = "";
        EditUserDetailemail->Text = "";
    }
    

SignupTab.png

Abrufen der EMS-Benutzerliste vom EMS-Server

Die EMS-Client-Anwendung ruft die aktuelle Liste der EMS-Benutzer vom EMS-Server ab.

  1. Legen Sie eine TBackendQuery-Komponente auf dem Formular ab.
  2. Wählen Sie im Objektinspektor den Eintrag Users als Eigenschaft BackendService von TBackendQuery aus.
  3. Fügen Sie LogIntTab eine TLayout-Komponente hinzu, und ändern Sie Name in LayoutUsers.
  4. Ziehen Sie eine TListView-Komponente auf LayoutUsers. Erweitern Sie im Objektinspektor die Eigenschaft ItemAppearance, und wählen Sie ImageListItemBottomDetail als ItemAppearance aus.
  5. Fügen Sie LayoutUsers eine neue TButton-Komponente hinzu, und ändern Sie Name in GetUsers. Mit der Schaltfläche GetUsers wird die BackendQuery ausgeführt.
  6. Erstellen Sie das Ereignis OnClick für die Schaltfläche GetUsers, und implementieren Sie deren Ereignisbehandlungsroutine, indem Sie den folgenden Code hinzufügen:
    • Für Delphi:
    procedure TForm1.GetUsersClick(Sender: TObject);
    begin
      BackendQuery1.ClearResult;
      BackendQuery1.Execute;
      UpdateListUsers(BackendQuery1.JSONResult);
    end;
    
    • Für C++:
    void __fastcall TForm1::GetUsersClick(TObject *Sender) {
        BackendQuery1->ClearResult();
        BackendQuery1->Execute();
        UpdateListUsers(BackendQuery1->JSONResult);
    }
    
  7. Erstellen und implementieren Sie die Methode UpdateListUsers.
    • Deklarieren Sie die Methode im private-Abschnitt des Codes:
    • Für Delphi:
    procedure UpdateListUsers(AUsers: TJSONArray);
    
    • Für C++:
    private:    // User declarations
        //previous code goes here
        void __fastcall UpdateListUsers(TJSONArray *AUsers);
    
    • Fügen Sie den folgenden Code hinzu, um die Methode zu implementieren:
    • Für Delphi:
    procedure TForm1.UpdateListUsers(AUsers: TJSONArray);
    var
      I: Integer;
      LUser: TJSONValue;
      LUsername: String;
      _id: String;
      item: TListViewItem;
    begin
      ListView1.ClearItems;
      ListView1.Visible := true;
      for I := 0 to AUsers.Count - 1 do
      begin
        item := ListView1.Items.Add;
        LUser := AUsers.Items[I];
        LUsername := LUser.GetValue<string>('username');
        _id := LUser.GetValue<string>('_id');
        item.text := LUsername;
        item.Detail := _id;
      end;
    end;
    
    • Für C++:
    void __fastcall TForm1::UpdateListUsers(TJSONArray *AUsers) {
        Integer I;
        TJSONValue *LUser;
        String LUsername;
        String _id;
        TListViewItem *item;
    
        ListView1->ClearItems();
        ListView1->Visible = true;
        for (I = 0; I < AUsers->Count; I++) {
            item = ListView1->Items->Add();
            LUser = AUsers->Items[I];
            LUsername = static_cast<TJSONObject*>(LUser)->Get("username")->JsonValue->Value();
            _id = static_cast<TJSONObject*>(LUser)->Get("_id")->JsonValue->Value();
            item->Text = LUsername;
            item->Detail = _id;
        }
    }
    
  8. Zeigen Sie LayoutUsers nur an, wenn ein EMS-Benutzer ordnungsgemäß beim EMS-Server angemeldet ist. Erstellen und implementieren Sie die Methode ShowUsersLayout:
    • Deklarieren Sie die Methode im private-Abschnitt des Codes:
    • Für Delphi:
      private
        // Previous code goes here
        Procedure ShowUsersLayout;
    
    • Für C++:
    private:    // User declarations
        //previous code goes here
        void __fastcall ShowUsersLayout();
    
    • Fügen Sie den folgenden Code hinzu, um die Methode ShowUsersLayout zu implementieren:
    • Für Delphi:
    procedure TForm1.ShowUsersLayout;
    begin
      LayoutUsers.Visible := BackendAuthLogin.LoggedIn;
      ListView1.Visible := false;
    end;
    
    • Für C++:
    void __fastcall TForm1::ShowUsersLayout() {
        LayoutUsers->Visible = BackendAuthLogin->LoggedIn;
        ListView1->Visible = false;
    }
    
  9. Rufen Sie die Methode ShowUsersLayout in den Ereignisbehandlungsroutinen OnLoggedIn, OnLoggedOut und OnCreate auf.
  10. Rufen Sie die Methode GetUsers in der Ereignisbehandlungsroutine OnSignedUp auf:
    • Für Delphi:
    procedure TForm1.BackendAuthSignupSignedUp(Sender: TObject);
    begin
        //Previous code goes here
        GetUsersClick(nil);
    end;
    
    • Für C++:
    void __fastcall TForm1::BackendAuthSignupSignedUp(TObject *Sender) {
        //previous code goes here
        GetUsersClick(NULL);
    }
    

EMSUsersList.png

Aktualisieren des auf dem EMS-Server gespeicherten Passworts des EMS-Benutzers

Mit der EMS-Client-Anwendung können Sie das Passwort des EMS-Benutzers aktualisieren, das auf dem EMS-Server gespeichert ist.

  1. Legen Sie eine TBackendUsers-Komponente auf dem Formular ab.
  2. Fügen Sie LayoutUsers die folgenden Komponenten hinzu, und ändern Sie die zugehörige Eigenschaft Name:
  3. Erstellen Sie das Ereignis OnClick für die Schaltfläche UpdatePassword, und implementieren Sie deren Ereignisbehandlungsroutine, indem Sie den folgenden Code hinzufügen:
    • Für Delphi:
    procedure TForm1.UpdatePasswordClick(Sender: TObject);
    var
      LEditedUser: TJSONObject;
      LUpdatedAt: TBackendEntityValue;
    begin
    
      try
       if ListView1.Selected <> nil then
       begin
         LEditedUser := TJSONObject.Create;
         LEditedUser.AddPair('password',editedPassword.Text);
         BackendUsers1.Users.UpdateUser(TListViewItem(ListView1.Selected).Detail,LEditedUser,LUpdatedAt);
         editedPassword.Text:='';
       end;
      finally
        LEditedUser.Free;
      end;
    end;
    
    • Für C++:
    void __fastcall TForm4::UpdatePasswordClick(TObject *Sender) {
        TJSONObject *LEditedUser = 0;
        TBackendEntityValue LUpdatedAt;
        try {
            if (ListView1->Selected != NULL) {
                LEditedUser = new TJSONObject;
                LEditedUser->AddPair("password", editedPassword->Text);
                BackendUsers1->Users->UpdateUser(((TListViewItem*)(ListView1->Selected))->Detail,LEditedUser, LUpdatedAt);
                editedPassword->Text = "";
            }
            }
        __finally {
            delete LEditedUser;
        }
    }
    
  4. Erstellen und implementieren Sie die Methode ShowUsersButtons, um die Felder zum Aktualisieren des in der Liste ausgewählten EMS-Benutzers anzuzeigen:
    • Deklarieren Sie die Methode im private-Abschnitt des Codes:
    • Für Delphi:
      private
        // Previous code goes here
        Procedure ShowUserButtons;
    
    • Für C++:
    private:    // User declarations
        //Previous code goes here
        void __fastcall ShowUserButtons();
    
    • Fügen Sie den folgenden Code hinzu, um die Methode ShowUsersButtons zu implementieren:
    • Für Delphi:
    procedure TForm1.ShowUserButtons;
    begin
      NewPassword.Visible:= true;
      editedPassword.Visible:=true;
      UpdatePassword.Visible := true;
    end;
    
    • Für C++:
    void __fastcall TForm1::ShowUserButtons() {
        NewPassword->Visible = true;
        editedPassword->Visible = true;
        UpdatePassword->Visible = true;
    }
    
  5. Fügen Sie der Implementierung der Methode ShowUsersLayout den folgenden Code hinzu:
    • Für Delphi:
    procedure TForm1.ShowUsersLayout;
    begin
      //Previous code goes here
      NewPassword.Visible:= false;
      editedPassword.Visible:=false;
      UpdatePassword.Visible := false;
    end;
    
    • Für C++:
    void __fastcall TForm1::ShowUsersLayout() {
        //Previous code goes here
        NewPassword->Visible = false;
        editedPassword->Visible = false;
        UpdatePassword->Visible = false;
    }
    
  6. Rufen Sie die Methode ShowUsersButtons am Ende der Methode UpdateListUsers auf.

Löschen der EMS-Benutzer vom EMS-Server

Die EMS-Client-Anwendung löscht einen ausgewählten EMS-Benutzer vom EMS-Server.

  1. Fügen Sie LayoutUsers eine neue TButton-Komponente hinzu, und ändern Sie deren Name in DeleteUser.
  2. Erstellen Sie das Ereignis OnClick für die Schaltfläche DeleteUser, und implementieren Sie deren Ereignisbehandlungsroutine, indem Sie den folgenden Code hinzufügen:
    • Für Delphi:
    procedure TForm1.DeleteUserClick(Sender: TObject);
    begin
     if ListView1.Selected <> nil then
      begin
        BackendUsers1.Users.DeleteUser(TListViewItem(ListView1.Selected).Detail);
      end;
      GetUsersClick(nil);
    end;
    
    • Für C++:
    void __fastcall TForm1::DeleteUserClick(TObject *Sender) {
        if (ListView1->Selected != NULL) {
            BackendUsers1->Users->DeleteUser(((TListViewItem*)(ListView1->Selected))->Detail);
        }
        GetUsersClick(NULL);
    }
    
  3. Fügen Sie den folgenden Code hinzu, um die Methode ShowUsersButtons zu implementieren:
    • Für Delphi:
    procedure TForm1.ShowUserButtons;
    begin
      //previous code goes here
      UpdatePassword.Visible := true;
    end;
    
    • Für C++:
    void __fastcall TForm1::ShowUserButtons() {
        DeleteUser->Visible = true;
    }
    
  4. Fügen Sie der Implementierung der Methode ShowUsersLayout den folgenden Code hinzu:
    • Für Delphi:
    procedure TForm1.ShowUsersLayout;
    begin
      //Previous code goes here
      DeleteUser.Visible := false;
    end;
    
    • Für C++:
    void __fastcall TForm1::ShowUsersLayout() {
        //Previous code goes here
        DeleteUser->Visible = false;
    }
    

Ausführen der Anwendung

Sie können die Anwendung nun ausführen und die EMS-Benutzer Ihres EMS-Servers verwalten. Für die Anmeldung benötigen Sie einen bestehenden EMS-Benutzer.

Drücken Sie F9, oder wählen Sie Start > Start, um die Anwendung auszuführen.

EMSManagementRunningApp.png

Siehe auch