Xtodo

xtodo - Aufgabenliste

Die Aufgabenliste ist eine Möglichkeit, in verschiedenen Kommandos Aufgabenlisten hinzuzufügen. Der User hat dann die Möglichkeit, alle "seine" Aufgaben (die Aufgaben der Gruppen, in denen er explizit oder implizit Mitglied ist) in der zentralen Liste xtodo einzusehen.

Die Stärke von xtodo besteht darin, dass mit wenigen Codezeilen die Aufgabenliste beliebigen Seiten hinzugefügt werden kann.

xtodo

Mit dem Kommando xtodo wird die zentrale Aufgabenliste aufgerufen.

Mit den Standard-Tabellen gibt es lediglich eine einzige Aufgabe: Das Passwort des Users example zu ändern. Diese Aufgabe reicht jedoch, um die Spalten dieses Grids erläutern zu können.

• In der Spalte ID ist- gekürzt - die ID des Datensatzes enthalten und kann dort kopiert werden. Das brauchen vor allem Entwickler für die Fehlersuche.
• Der Typ der Aufgabe ist Passwort ändern. Nach Möglichkeit werden alle Typen so definiert, dass kein Text mehr erforderlich ist - dann entsteht dort auch kein Übersetzungsproblem.
• Es folgt die Spalte mit dem Link-Symbol. Mit einem Mausklick auf dieses Symbol springt man direkt zu der Aufgabe, hier im Beispiel in die User-Verwaltung zum User example.
• In der Spalte Referenz wird ein Wert angezeigt, der die zu erledigende Aufgabe konkretisiert - hier im Beispiel der Benutzername. Zusätzlich kann auch noch ein Hint-Text übergeben, hier der vollständige Name des Benutzers.
• Die Deadline ist das Datum, bis zu dem die Aufgabe erledigt werden sollte - und das ist hier bereits abgelaufen (das Ändern des Passwortes sollte also schleunigst nachgeholt werden...)
• In der Spalte Text kann die Aufgabe konkretisiert werden. Im Idealfall ist das gar nicht erforderlich, weil der Typ selbsterklärend ist.
• Der Status ist hier todo, die Aufgabe ist also noch zu erledigen.
• Zuletzt werden die Gruppen angezeigt, denen die Aufgabe zugeordnet ist. Dass die Aufgabe auch der Gruppe User zugeordnet ist, ist hier eher etwas "Beispiel", weil sich ohne Admin-Rechte in der User-Verwaltung keine Passwörter ändern lassen.

xtodo_config

Wenn das Todo-System einem neuen Kommando hinzugefügt werden soll, dann muss das in xtodo_config entsprechend konfiguriert werden.

Kategorie

Die Kategorie entspricht meist dem Kommando, dem die Aufgabenliste hinzugefügt werden soll. Dafür muss zunächst der Type benannt werden und zwar mit einem Kürzel aus zwei Zeichen. Wir wollen hier die Aufgabenliste für die Userverwaltung xuser hinzufügen und verwenden pragmatisch das Kürzel XU. Der Wert in Sort dient vor allem der Sortierung hier im Baum.

Von Bedeutung ist noch der Wert in Command. Dies ist das Kommando, das ausgeführt wird, wenn der Anwender auf das Link-Symbol klickt. Üblicherweise wird hier in einem neuen Tab das Kommando ausgeführt und als Parameter mittels der Funktion $PAGE(link) die ID des betreffenden Datensatzes übergeben.

Zum kopieren:

#tab_new   c=xuser   cmd=xuser($PAGE(link))

(Es muss dann lediglich an den beiden Stellen xuser durch den eigenen Kommandonamen ersetzt werden)

Typ

Der Typ ist der Typ der Aufgabe. Dieser hat zunächst ein vierstelliges Kürzel, wobei die ersten beiden Stellen dem Kürzel der Kategorie entsprechen müssen. Hier im Beispiel: XU kommt von der Kategorie und CP steht für change password.

Im Namen können auch Funktionen verwendet werden. Meist wird das die Funktion $T() sein, um den Namen übersetzen zu können. Das ist auch der Grund, weswegen man umfangreich Typen anlegen sollte, statt auf das Freitextfeld Text zu vertrauen.

Gruppen

Die Kategorie können verschiedenen Usergruppen zugeordnet werden, nun denen kann später die Aufgabe zugewiesen werden.

Integration in ein Kommando

Um das ToDo-System in ein Kommando zu integrieren, muss zunächst einmal eine entsprechende Kategorie angelegt werden, das wurde eben beschrieben.

Der nächste Schritt ist das Hinzufügen einer entsprechenden Page-Kategorie für xuser_page_user, was implizit durch xtodo_page_add passiert:

#exec   cmd="xtodo_page_add(XU,$PVAL(vl,user_user_id),$PVAL(vl,login),$PVAL(vl,shortname)$CHR(crlf)$PVAL(vl,firstname) $PVAL(vl,lastname))"

Das sieht dann im Formular wie folgt aus:

Hier können dann neue Todos hinzugefügt werden, deren Typ ausgewählt, bei Bedarf ergänzender Text hinzugefügt werden, der Status gesetzt und die Aufgabe den dem Typ hinzugefügten Gruppen zugewiesen werden. Mit Mausklick auf die Symbole schaltet man den erledigt-Status weiter (leer, ToDo, erledigt, verworfen).

Die Codezeile, die hier zu verwenden ist, sieht etwas komplex aus, ist bei näherer Betrachtung eigentlich harmlos bis auf den etwas umfangreicheren Hint-Text. Das Kommando lautet xtodo_page_add und hat die folgenden vier Parameter:

1. Der Typ der Todo-Kategorie, hier also XU.
2. Die Referenz-ID, das ist hier die ID des Users, und die ziehen wir aus der Page ($PVAL(vl,user_user_id)). Die Referenz-ID wird benötigt, um direkt zum betreffenden Datensatz springen zu können.
3. Der Login-Name als Wert, der dann in der Spalte Referenz angezeigt wird ($PVAL(vl,login)).
4. Und schließlich der Hint-Text, der über der Referenz angezeigt wird. Hier nehmen wir die Spalte shortname und in der zweiten Zeile (Zeilenumbruch mit $CHR(crlf)) die Spalten firstname und lastname. (Also vollständig $PVAL(vl,shortname)$CHR(crlf)$PVAL(vl,firstname) $PVAL(vl,lastname).) Wird kein Hint-Text angegeben, wird auch keiner angezeigt.

Und da zwischen Vor- und Nachname ein Leerzeichen steht, kommt der ganze Parameter cmd in doppelte Anführungszeichen.

Ist das nun schon alles? Nicht ganz: Wenn wir hier xuser mit einer ID als Parameter aufrufen, muss darauf entsprechend reagiert werden. Dazu wird zunächst in xuser die ID (also der erste CommandParameter, 0-relativ mit dem Index 0) in eine Variable geschrieben:

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

Und beim Aufbau des Trees in xuser_flt muss dann diese Variable berücksichtigt werden:

~ $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)

~

Tabellen

create table todo_todo (
  todo_todo_id varchar(40) not null primary key,
  ctype char(4) not null,
  ref varchar(40),
  ref_text vachar(40),
  ref_hint varchar(200),
  deadline date,
  ctext varchar(200),
  status int,
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)
);

create table todo_todo2group (
  todo_todo2group_id varchar(40) not null primary key,
  todo_todo_id varchar(40) not null,
  user_group_id varchar2(40) not null,
  active char(1),
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)
);

create table todo_type (
  todo_type_id varchar(40) not null primary key,
  ctype char(4) not null unique,
  name varchar(40),
  csort int,
  status int,
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)
);

create table todo_type2group (
  todo_type2group_id varchar(40) not null primary key,
  ctype char(2) not null,
  grp_short  varchar(4) not null,
  user_group_id varchar(40) not null,
  status int,   
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)
);

create table todo_type_category (
  todo_type_category_id varchar(40) not null primary key,
  ctype char(2) not null unique,
  name varchar(40),
  ccommand varchar(200),
  csort int,
  status int,
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)
);

Code

xtodo

#rights  n=frm   r_user=w
#frm  y=page  c="xtodo"  

#page
#prim  as=Y  
#cat  as=Y      c=ToDo

#sql2   select ctype as ckey, name as cvalue from todo_type 

#grd_seg   frc=0   fcc=1   clt=ss   n=grid   ro=Y
#grd_col   f=todo_todo_id   c1=ID   y=guid   w=30   ro=Y
#grd_col   f=ctype   c1=$T(type)   y=lookup   ld=sql2   w=250   wst=250   ro=Y
#grd_col   f=ref     w=30  y=link   ro=Y   cmdn=xtodo_add(link,$COPY($PVAL(grid,ctype,sel),1,2))
#grd_col   f=ref_text   h=ref_hint   c1=$T(reference)   w=150   ro=Y   
#grd_col   f=deadline   c1="Deadline"   y=date     w=90  
#grd_col   f=ctext   c1=Text   w=200   wst=200   
#grd_col   f=status   c1="Status"   y=lookup   ld=todo_status    w=90   ro=Y   
#grd_col   f=grp_short   c1=$T(groups)   w=150   wst=150
#sql select t.*, y.grp_short 
#sql from todo_todo t
#sql   inner join todo_todo2group z on z.todo_todo_id = t.todo_todo_id and z.active = 'A'
#sql   inner join user_group g1 on g1.user_group_id = z.user_group_id
#sql   inner join user_group g2 on g2.path like g1.path || '%'   and g2.status = 1
#sql   inner join user_user2group z2 on z2.user_group_id = g2.user_group_id and z2.user_user_id = :kid
#sql   inner join todo_type2group y on y.user_group_id = z.user_group_id and t.ctype like y.ctype || '%'
#sql where t.status < 7
#sql order by t.deadline, t.todo_todo_id
#grd_data   q=join   t=todo_todo   kid=$RIGHTUSERID()

#page_ready

Wir haben hier einen der seltenen Fälle, dass wir keinen Tree verwenden, sondern der Typ unseres Formulars x=page ist. Somit haben wir auch kein Filter-Statement, sondern bauen gleich die Page auf. Das bedingt auch, dass wir nach dem Aufbau der Page die Prozedur #page_ready aufrufen. "Normalerweise" ist das nicht erforderlich, da diese Prozedur implizit von #page_fill aufgerufen wird. Eben diese verwenden wir hier aber nicht.

Wir haben hier nur ein Grid-Segment. Das dazugehörende SQL-Statement holt sich alle Einträge in der Tabelle todo_todo, die den Gruppen zugeordnet sind, in denen der User explizit oder implizit Mitglied ist. Damit das auch mit der impliziten Mitgliedschaft funktioniert, muss hier zweimal die Tabelle user_group hinzugefügt werden.

Ein ToDo kann mehr als einer Gruppe zugeordnet sein. Die Gruppennamen kommen aus der Abfrage als einzelne Zeilen, sollen im Grid jedoch durch Kommata getrennt in einer Zeile dargestellt werden. Deswegen wird die Datenquelle auf q=join gesetzt. Gruppiert werden die Zeilen nach der Schlüsselspalte, die hier aus t_todo_todo abgeleitet wird.

Für die Spalte Typ wird hier eine Nachschlageliste verwendet, die mit einem SQL-Statement gefüllt wird. Zur Abwechslung wird hier mal Special verwendet, sondern das Statement mit #sql2 definiert und die Datenquelle auf ld=sql2 gesetzt.

xtodo_add

~ $ICP(0,todo)
#var_set   n=todo_todo_id   z=$GUID()
#grd_add   i=todo_add   f_ref=$VAR(todo_id)   f_ref_text=$VAR(todo_text)   f_ref_hint=$VAR(todo_hint)   f_status=1 

~ $ICP(0,link)
#sql   select ccommand from todo_type_category where ctype = :ktype
#sql_openval   ktype=$CP(1)   f_ccommand=1

#exec   cmd=$VAL(1)

~~

Das Kommando xtodo_add wird für zwei Zwecke verwendet, die durch den Parameter unterschieden werden. Mit dem Parameter todo werden ein weiteres Todo eingefügt, also dem Grid i=todo_add eine weitere Zeile hinzugefügt. Warum davor in die Variable todo_todo_id eine GUID gepackt werden, klären wir bei xtodo_page_add. Der hinzugefügten Zeile werden einige Werte zugewiesen, die aus Variablen kommen.

Wird auf der Seite xtodo auf das Link-Symbol geklickt, wird xtodo_add mit dem Parameter link aufgerufen, als zweiter Parameter wird der Typ des ToDos mitgegeben. Mit diesem wird mit einem SQL-Befehl das Kommando ermittelt und dieses aufgerufen.