Xtodo
Inhaltsverzeichnis
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.
=ToDos anlegen
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:
- Der Typ der Todo-Kategorie, hier also XU.
- 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.
- Der Login-Name als Wert, der dann in der Spalte Referenz angezeigt wird ($PVAL(vl,login)).
- 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.
Verlinkung ermöglichen
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) ~
Übersichtsseite
Auf der Übersichtsseite werden alle Aufgaben zu der Kategorie gelistet.
#tree_add u=root c=ToDo s="#page_fill d=xtodo_page_todo(XU)"
In der Prozedur #page_fill wird als Parameter d=xtodo_page_todo(XU) aufgerufen. Als Parameter des Kommandos xtodo_page_todo muss hier lediglich die Kategorie (XU) übergeben werden.
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.
Wir auf das Link-Symbol geklickt, dann xtodo_add mit dem Parameter link aufgerufen. Als zweiter Parameter ist der Typ der Kategorie zu übergeben, damit daraus das Command ermittelt werden kann. Die ersten beiden Stellen des Typs eines ToDos ist der Typ der Kategorie, so dass diese mit der Funktion $COPY() ermittelt werden können. An den Typ des ToDos kommt man mit der Funktion $PVAL; das Segment lautet grid, die Spalte ctype, und es ist die aktuell selektierte Zeile zu verwenden. Ein Hinweis noch dazu, dass hier der Parameter cmdn statt cmd gesetzt wird: Bei cmd würden die Funktionen bereits bei der Aufbau der Seite ersetzt werden, zu dem Zeitpunkt ist jedoch noch völlig unklar, was später die selektierte Zeile sein wird. Von daher dürfen die Funktionen erst ausgewertet werden, wenn auf das Link-Symbol geklickt wurde; eben dazu wird cmdn verwendet.
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.
