Aufgaben und Notizen

Daten zur Aufgabenerstellung abfragen

var data = await dms.TasksAndNotices.LoadTaskCreationItems();

Es wird eine Struktur geladen, welche für die Aufgabenerstellung notwendige Daten enthält.

Die Benutzer an den Aufgabenfunktionen werden in der Regel mit einer DMS-Id angegeben, anstelle der Xid aus dem STP UserManagement.

Aufgaben abfragen

Für Benutzer/Gruppen

var loadType = LoadTasksModus.Mine;
var taskIds = await dms.TasksAndNotices.LoadTaskIds(loadType);
var tasks = await dms.TasksAndNotices.LoadTasksByIds(taskIds);

Es liefert eine Liste von TaskReadDto mit den für den Anwender aktiven Aufgaben. Über den Modus können auch andere Listen abgefragt werden. Soll zum Beispiel die Vertretung für einen Kollegen übernommen werden:

var taskIds = await dms.TasksAndNotices.LoadTaskIds(LoadTasksModus.InBehalfOf, userOrGroupId);

Somit erhält man die offenen Aufgaben für den zu vertretenden Benutzer/Gruppe.

Über einen zusätzlichen, optionalen Parameter können auch die erledigten Aufgaben mit geladen werden. Allerdings können hier sehr große Ergebnismengen auftreten. Daher ist diese Möglichkeit mit Vorsicht zu genießen.

var allTaskIds = await dms.TasksAndNotices.LoadTaskIds(LoadTasksModus.Mine, null, true);

Für Dokument, Akte/Register

Es können Aufgaben auch umgekehrt nach Bezug zu Dokument ermittelt werden.

var includeFinished = true;
var documentTaskIds = await dms.TasksAndNotices.LoadTaskIdsForDocument(documentId, includeFinished);

Hiermit werden alle Aufgaben für ein Dokument ermittelt.

Verwendet man den folgenden Aufruf …

var includeFinished = true;
int? trayId = null;
var containerId = new Guid(...);
var documentTaskIds = await dms.TasksAndNotices.LoadTaskIdsForContainerRegister(containerId, trayId, includeFinished);

… werden alle Aufgaben aller Dokumente in der Akte/dem Ordner abgefragt. Alternativ kann man den Aufruf auch auf ein bestimmtes Register (Unterregister werden NICHT mit einbezogen) eingrenzen.

Aufgabe erstellen

Eine Aufgabe wird über einen Creator zusammengestellt.

var creator = TaskCreator.RegularTaskForUser(documentId);
creator.SetText("Aufgabentext");
creator.AddUser(userId);

Mit diesem Creator kann die Api dann die Aufgabe erstellen.

var success = await dms.TasksAndNotices.CreateTask(creator);

Arbeiten mit Aufgaben

Daten ändern

Die Daten einer Aufgabe können sich im Laufe der Zeit ändern (solange sie nicht erledigt ist). Es können allerdings nicht alle Daten verändert werden.

var modifications = new ModifyTaskModel();
modifications.Reminder = tomorrow;
var modifiedTask = await dms.TasksAndNotices.ModifyTask(task.Id, modifications);

Mit Hilfe des ModifyTaskModel kann eine bestehende Aufgabe verändert werden. Alle Eigenschaften sind Nullable. Nur die gesetzten Werte werden an dem durch die Id definierten Task verändert.

Aufgabe kommentieren

var commentPlain = "Ein Kommentar";
var commentRtf = "{\rtf1\ansi\...}";
var result = await dms.TasksAndNotices.AddCommentToTask(task.Id, commentRtf, commentPlain);

Es wird an den Aufgabentext der Kommentar angehängt. Abgetrennt durch eine Zeile “Kommentar von {user} am {datum}”.

Aufgabe beantworten

TaskReadDto taskDto = ...
var manager = await dms.TasksAndNotices.GetTaskManager(taskDto);
var creator = TaskCreator.Answer(taskDto);
creator.SetText("Rückfrage ...");
await manager.AnswerTask(creator);

Bei einer Beantwortung einer Aufgabe wird die aktuelle Aufgabe auf ‘Erledigt’ gesetzt und eine neue Aufgabe erstellt, welche an den Absender der aktuellen Aufgabe geht. Diese Funktion kann nicht mit Listenschritten aufgerufen werden!

Aufgabe weiterleiten

Sind sie nicht der richtige Bearbeiter für die Aufgaben, kann diese auch an einen anderen Bearbeiter weitergeleitet werden. Die Aufgabe bleibt dabei unverändert, es wird lediglich der Bearbeiter geändert.

TaskReadDto taskDto = ...
var manager = await dms.TasksAndNotices.GetTaskManager(taskDto);
var forwarder = manager.CreateForwarder();
forwarder.ToUser(userId);     //userId is long.ToGuid.
or
forwarder.ToGroup(groupId);   //groupId is long.ToGuid.
await manager.ForwardTask(forwarder);

Aufgabe erledigen

TaskReadDto taskDto = ...
var manager = await dms.TasksAndNotices.GetTaskManager(taskDto);
await manager.FinishTask();

Notizen für ein Dokument abfragen

var notices = await dms.TasksAndNotices.LoadNoticesForDocument(documentId);

Hiermit erhält man eine Liste mit den am Dokument gesetzten Notizen.

Notiz erstellen

Um eine Notiz zu erstellen wird wieder der TaskCreator verwendet.

var creator = TaskCreator.Note(documentId);
creator.SetText("Text der Notiz");
var success = await dms.TasksAndNotices.CreateTask(creator);

Aufgabenlisten

Starten

Um eine Aufgabenliste zu starten, benötigt man deren Definition. Diese kann man über folgenden Befehl laden.

var taskListDefinitions = await dms.TasksAndNotices.LoadTaskLists();

Wichtig: Seit Version 2021.11.22.45 werden die Daten bei LoadTaskLists nur einmalig vom Server geladen und ab da in einem Api-Internen Cache gehalten.

Das Ergebnis dieser Methode ist eine hierarchische Struktur, welche der aus dem Verwaltungsdialog in den Kanzleieinstellungen entspricht:

Um darin die Aufgabenlistendefinition zu einer bestimmten ID zu finden, kann der folgende Befehl verwendet werden:

var taskListInfo = await dms.TasksAndNotices.FindInfoInCategorie(taskListDefinitions, taskListId);

Um eine Liste zu starten geht man analog zu einer Einzelaufgabe vor. Zuerst benötigt man einen Creator, welcher dann ggf. konfiguriert wird.

var creator = new TaskListCreator(taskListInfo, documentId);
creator.SetFirstUser(userId);

var success = await dms.TasksAndNotices.StartTaskList(creator);

Nachdem eine Aufgabenliste gestartet wurde, kann man auf den dadurch erstellten Einzelaufgaben verschiedene Aktionen ausführen. Das hängt auch von der Art der Aufgabenliste ab.

Checkliste

Einträge eine Checkliste werden direkt beim Start alle angelegt und können in beliebiger Reihenfolge abgehakt werden. Der Checklisteneintrag wird dazu mit der Methode dms.TasksAndNotices.FinishTaskListStep(finisher) “erledigt” und ggf. mit einem Kommentar versehen.

Die anderen Aufgabenlisten

Es gibt noch 3 weitere Aufgabenlistentypen, welche allerdings nicht ganz so einfach zu behandeln sind.

Aufgabenschritt erledigen

Hierfür wird ein TaskListStepFinisher benötigt. Dieser wird benötigt, weil hier viele Möglichkeiten existieren.

var finisher = await dms.TasksAndNotices.GetFinisherForTaskListStep(taskId, taskListInfo);

Die taskListInfo muss zur angegebenen Aufgabe passen. In der Datenstruktur, welche als Ergebnis von GetActiveTasks() geliefert wird, ist die Id der Aufgabe, sowie die der Aufgabenliste enthalten. Passen diese nicht zueinander, wird eine Exception geworfen.

Am Finisher kann man nun den Bearbeiter des nächsten Listenschritts ändern, oder bei freien Aufgabenlisten auch den nächsten Schritt auswählen.

finisher.MoveToStep(5);
finisher.SetUser(userId);

Abschließend übergibt man den Finisher der Methode um den dazu passenden Aufgabenschritt abzuschließen:

var success = await dms.TasksAndNotices.FinishTaskListStep(finisher);

Aufgabenliste abbrechen

Um die Abarbeitung einer Liste am aktiven Schritt abzubrechen, wird folgendes aufgerufen:

var success = await dms.TasksAndNotices.AbortTaskList(taskId);

ModifyTaskModel

Im folgenden sind wird der Aufbau der ModifyTaskModel Klasse beschrieben. Alle Eigenschaften sind Nullable. Wird ein Wert gesetzt wird dieser an der zu ändernden Aufgabe geändert. Bleibt er null, dann behält die Aufgaben den Wert.

Die Spalte Berechtigung in der Tabelle gibt an, wer den Wert ändern darf.

UserDto

TaskReadDto