Xuser

xuser - Benutzerverwaltung

Das Kommando xuser dient zur Bearbeitung der Benutzer und der Benutzergruppe. Über die Benutzergruppen erfolgt die Rechtevergabe.

Benutzer

Unter dem Baumeintrag Benutzer werden die einzelnen Benutzer aufgelistet, deren Daten auf der entsprechenden Seite dann bearbeitet werden können.

In der Kategorie Benutzer werden die Stammdaten zum Benutzer angezeigt. Technisch relevant sind die ID und der Login-Name, während Kurz-, Vor- und Nachname keine technische Bedeutung haben. Üblicherweise wird der Passwort-Hash nicht direkt bearbeitet, sondern eine Neues Passwort im gleichnamigen Feld eingegeben, womit der Passwort-Hash generiert wird. In UseriD können die IDs auf vorherigen oder parallelen System eingegeben werden, in LDAP eine LDAP-ID.

In Explizite Gruppenzugehörigkeiten dieses Benutzers ist eine Liste der Benutzergruppen zu finden, in denen der Benutzer direkt enthalten ist. Der Benutzer ist dann auch implizit in allen diesen Gruppen übergeordneten Gruppen enthalten.

Schließlich können noch zu jedem User ToDos gespeichert werden.

Alphabetische Benutzergruppierung

Bei einer großen Zahl von Benutzern mag der Wunsch aufkommen, diese nach dem Anfangsbuchstaben ihres Login-Namens zu gruppieren.

Dazu wird in xuser_flt das Sub-Kommando xuser_open mit dem Parameter userc statt dem Parameter user aufgerufen.

#tree_add u=root   c=$T(User)   s="#page_fill  d=xuser_page_users"    o=xuser_open(userc)

Benutzergruppen

Benutzrerechte werden über Benutzergruppen zugewiesen. Diese Benutzergruppen sind in BAF hierarchisch organisiert. Hier im Beispiel ist die Gruppe user.admin eine Untergruppe der Gruppe user. Benutzer der Gruppe user.admin sind implizit auch Mitglied der Gruppe user, umgekehrt gilt das jedoch nicht.

Die hierarchische Organisation der Gruppen erfolgt über die Eigenschaft Path, diese stellt auch den Namen der Gruppe dar. In GroupID können die IDs aus vorherigen Systemen gespeichert werden, in LDAP die Gruppen-GUID in einem ActiveDirectory.

Hier im Beispiel ist der Benutzer example direkt, also explizit Mitglied der Gruppe. Dagegen ist der User admin implizit Mitglied der Gruppe, weil er explizit Mitglied einer Untergruppe ist.

Individualgruppen

Benutzerrechte können in BAF nur über Gruppen zugewiesen werden. Damit auch einem einzelnen Benutzer gezielt Rechte eingeräumt werden können, gibt es so genannte Individualgruppen. Diese enthalten im Regelfall nur einen einzigen Benutzer. Es ist aber möglich, weitere Benutzer aufzunehmen, zum Beispiel, um ihnen für eine Urlaubsvertretung entsprechende Rechte einzuräumen.

Um die Individualgruppen anzulegen, gehen Sie auf die entsprechende Seite und klicken auf den Button Individualgruppen aktualisieren. Beachten Sie, dass dabei nur neue Individualgruppen angelegt werden, aber nicht die Pfade von bestehenden geändert werden (weil die im Code referenziert sein könnten).

Tabellen

create table user_user(
  user_user_id varchar(40) not null primary key,
  login varchar(40) not null unique,
  password varchar(140) not null,
  shortname varchar(12),
  firstname varchar(40),
  lastname varchar(40),
  userid varchar(20),
  ldap varchar(40),
  email varchar(80),
  status int,
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)    
);

create table user_group(
  user_group_id varchar(40) not null primary key,
  type char(1) not null,
  path varchar(400) not null unique,
  groupid varchar(20),
  ldap varchar(40),
  user_user_id varchar(40),
  status int,
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)   
);

Die Tabelle user_user2group speichert, welcher Benutzer in welcher Gruppe explizit Mitglied ist.

create table user_user2group(
  user_user2group_id varchar(40) not null primary key,
  user_user_id varchar(40) not null,
  user_group_id varchar(40) not null,
  status int,
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)  
);

Code

xuser

#rights  n=frm   r_user=r  r_user.admin=w
#rights  n=admin   r_user.admin=w
#frm  y=treepage  c=xuser   flt=xuser_flt   w=300 

#btn  y=save   s=#save  se=c
#btn  y=cancel   s=#cancel  se=cp
#btn  y=back   s=#treeback  se=b
#btn  y=backback   s=#treebackback  se=b
#btn   c=$T(Refresh)   se=b   s=#filter   w=100

#var_set   n=link   z=$CP(0)

#filter

xuser ist vor allem die Formulardefinition und als solche ziemlich Standard. User haben Leserechte, Administratoren Schreibrechte. Wenn das Kommando mit Parameter aufgerufen wird, dann enthält dieser die User-ID, um gleich den entsprechenden User aufzurufen (zum Beispiel aus xtodo heraus). Zu diesem Zweck wird die erst mal in der Variablen link gespeichert.

xuser_add

~ $ICP(0,user)
#tree_add u=sel   c=$T(new_user)   t=user_user    s="#page_fill  d=xuser_page_user"   si=Y

~ $ICP(0,change_password)
#page_val   i=vl   col=1   row=3   z=$HASH($PVAL(vl,1,2),SHA512)

~ $ICP(0,group)
#tree_add u=sel   c=$T(new_group)   c1=path   t=user_group    s="#page_fill  d=xuser_page_group"   si=Y   f_type=G   f_user_group_id=

~ $ICP(0,user_in_group)
#grd_add   i=user_ex     f_user_group_id=$PVAL(vl,1,0)   f_status=1

~ $ICP(0,group_in_user)
#grd_add   i=group_ex     f_user_user_id=$PVAL(vl,1,0)   f_status=1

~ $ICP(0,upsert_igs)
#sql select u.user_user_id, u.login
#sql   from user_user u
#sql     left outer join user_group g on g.type = 'I' and g.user_user_id = u.user_user_id
#sql   where u.status = 1 and g.user_group_id is null
#opensql   n=igs   er=xuser_add_line(igs_ins)

~~

Das Kommando xuser_add fasst verschiedene kleine Routinen zusammen, nicht immer handelt es sich im strengen Sinn um Add-Operationen. Um die Aufrufe zu unterscheiden, wird der erste Parameter (Index 0) verwendet.

Bei den Parametern user, group, user_in_group und group_in_user werden dem entsprechenden Baum oder Grid-Segment ein Eintrag hinzugefügt.

Mit dem Parameter change_password aufgerufen wird die Eingabe aus der dritten Zeile (Index 2) gehasht und in die vierte Zeile (Index 3) geschrieben.

Sollen die Individualgruppen aktualisiert werden, so wird der Parameter upsert_igs verwendet. Mit dem SELECT-Statement werden User gesucht, für die es noch keine Individualgruppe gibt (die auf diesen User referenziert). Für alle diese User wird das Kommando xuser_add_line aufgerufen

xuser_add_line

~ $ICP(0,igs_ins)
#upsert  y=i   t=user_group   f_user_group_id=$GUID()   f_type=I   f_path="ig.$DATA(igs,login)"   f_user_user_id=$DATA(igs,user_user_id)   f_status=1

~~

Wird bei der Aktualisierung der Individualgruppe von xuser_add(upsert_igs) aufgerufen und legt einfach nur einen entsprechenden Datensatz in user_group an. Das Feld type wird auf I gesetzt, dadurch ist es eine Individualgruppe.

xuser_flt

#tree_clear

~ $NEMPTY($VAR(link))
#sql   select user_user_id, login, shortname from user_user where user_user_id = :kid
#tree_node  u=root    t=user_user    c1=login   c2=shortname    s="#page_fill  d=xuser_page_user"  
#tree_fillsql  fi=Y   kid=$VAR(link)

#tree_add u=root   c=$T(Groups)   s="#page_fill  d=xuser_page_groups(G)"    o=xuser_open(g)
#tree_add u=root   c=$T(Individual_groups)   s="#page_fill  d=xuser_page_groups(I)"    o=xuser_open(ig)

~
#tree_add u=root   c=ToDo   s="#page_fill  d=xtodo_page_todo(XU)"
#tree_add u=root   c=$T(User)   s="#page_fill  d=xuser_page_users"    o=xuser_open(user)
#tree_add u=root   c=$T(Groups)   s="#page_fill  d=xuser_page_groups(G)"    o=xuser_open(g)
#tree_add u=root   c=$T(Individual_groups)   s="#page_fill  d=xuser_page_groups(I)"    o=xuser_open(ig)

~~

Wenn die Variable link nicht leer ist, dann werden die Daten des Users anhand der ID ermittelt.

Andernfalls werden lediglich die vier Top-Einträge des Baums geschrieben, User und Gruppen werden dann beim Öffnen der Nodes dynamisch nachgeladen.

xuser_open

~ $ICP(0,user)
#sql   select user_user_id, login, shortname from user_user order by login
#tree_node  u=exp    t=user_user    c1=login   c2=shortname    s="#page_fill  d=xuser_page_user"
#filltreesql

~ $ICP(0,userc)
#sql select upper(substr(login, 1, 1)) as lc, user_user_id, login, shortname   from user_user   order by login
#tree_node  u=exp    k=lc    c1=lc   nc=Y      s="#page_fill  d=xuser_page_users"
#tree_node  u=last    t=user_user    c1=login   c2=shortname      s="#page_fill  d=xuser_page_user"
#filltreesql

~ $ICP(0,g)
#sql select g.* from user_group g  where g.type = 'G'  order by path
#tree_node  u=exp    t=user_group    c1=path     s="#page_fill  d=xuser_page_group"
#filltreepath   t=user_group   pn=path

~ $ICP(0,ig)
#sql select g.user_group_id, g.path, u.firstname || ' ' || u.lastname as user from user_group g
#sql     left outer join user_user u on u.user_user_id = g.user_user_id     where g.type = 'I'
#tree_node  u=exp    t=user_group    c1=path   c2=user  s="#page_fill  d=xuser_page_group(I)"
#filltreesql

~ $ICP(0,igc)
#sql select upper(substr(u.login, 1, 1)) as lc, g.user_group_id, g.path, u.firstname || ' ' || u.lastname as user from user_group g
#sql     left outer join user_user u on u.user_user_id = g.user_user_id     where g.type = 'I'
#tree_node  u=exp    k=lc    c1=lc   nc=Y      s="#page_fill  d=xuser_page_groups(IC)"  
#tree_node  u=last     t=user_group    c1=path   c2=user  s="#page_fill  d=xuser_page_group(I)"
#filltreesql

~~

Je nach Parameter werden die User, die Gruppen (g) oder die Individualgruppen (ig) geöffnet. Es werden den sehr "geradeaus" die entsprechenden Datensätze angezeigt.

Erwähnung verdienen die Parameter userc und igc. Bei einer großen Anzahl von Usern wird der Baum schnell unübersichtlich. Mit diesen Parametern werden die Datensätze nach dem ersten Buchstaben der Benutzernamens gruppiert, siehe Screenshot oben auf der Seite.