Available only in PRO Edition

Ressourcenmanagement

Gantt bietet integrierte Ressourcenansichten, um die Ressourcenauslastung zu visualisieren. Es bietet auch Werkzeuge, um Projekte nach Ressourcen aufzuteilen, um Arbeitslasten auszugleichen, sowie aufgaben- und ressourcenspezifische Arbeitszeitkalender.

Ressourcenansicht-Panel

dhtmlxGantt bietet zwei vordefinierte Layoutansichten zur Anzeige der Ressourcenauslastung: das Ressourcenauslastungsdiagramm und das Ressourcenhistogramm.

Ressourcenauslastungsdiagramm

Diese Ansicht umfasst zwei Komponenten: "resourceGrid" für das Raster und "resourceTimeline" für die Zeitleiste.

gantt.config.layout = {
    css: "gantt_container",
    rows: [
      {
        // Layout für Standard-Raster und Zeitleiste
        cols: [
          {view: "grid", group:"grids", scrollY: "scrollVer"},
          {resizer: true, width: 1},
          {view: "timeline", scrollX: "scrollHor", scrollY: "scrollVer"},
          {view: "scrollbar", id: "scrollVer", group:"vertical"}
        ],
        gravity:2
      },
      { resizer: true, width: 1},
      {
        // Layout für Raster und Zeitleiste des Ressourcenpanels
        config: resourceConfig, // Konfiguration für Raster und Zeitleiste
        cols: [
          {view: "resourceGrid", group:"grids", width: 435, scrollY:"resourceVScroll"},
          {resizer: true, width: 1},
          {view: "resourceTimeline", scrollX: "scrollHor", scrollY:"resourceVScroll"},
          {view: "scrollbar", id: "resourceVScroll", group:"vertical"}
        ],
        gravity:1
       },
       {view: "scrollbar", id: "scrollHor"}
    ]
};

Related sample:  Resource load diagram

Nach der Einrichtung verhält sich resourceGrid wie die Standard-Rasteransicht, ist aber schreibgeschützt. resourceTimeline übernimmt die Skalierungskonfiguration von der Standard-Zeitleiste und hat zwei Ebenen:

• Hintergrundzeilen, die den task_row_class und timeline_cell_class Vorlagen folgen. Diese Vorlagen können auf Layout-Ebene angepasst werden.
• Ressourcenschicht, einzigartig für resourceTimeline, die Blöcke in Zellen anzeigt, in denen Ressourcen Aufgaben zugewiesen sind. Sie können die resource_cell_class und resource_cell_value Vorlagen verwenden, um den Blockstil und -inhalt zu definieren:

gantt.templates.resource_cell_value = function(start_date, end_date, resource, tasks,
    assignments){
    var html = "<div>" +  tasks.length * 8 + "h</div>";
    return html;
};

Related sample:  Templates of the Resource diagram

Ressourcenhistogramm

Diese Layoutansicht verwendet "resourceGrid" für das Raster und "resourceHistogram" für die Zeitleiste, um die Ressourcenauslastung anzuzeigen.

gantt.config.layout = {
    css: "gantt_container",
    rows: [
        {
            // Layout für Standard-Raster und Zeitleiste
            gravity: 2,
            cols: [
                {view: "grid", group:"grids", scrollY: "scrollVer"},
                {resizer: true, width: 1},
                {view: "timeline", scrollX: "scrollHor", scrollY: "scrollVer"},
                {view: "scrollbar", id: "scrollVer", group:"vertical"}
            ]
        },
        { resizer: true, width: 1, next: "resources"},
        {
            // Layout für Raster und Zeitleiste des Ressourcenpanels
            gravity:1,
            id: "resources",
            config: resourceConfig, // Konfiguration für Raster und Zeitleiste
            templates: resourceTemplates, // Vorlagen für Raster und Zeitleiste
            cols: [
                { view: "resourceGrid", group:"grids", scrollY: "resourceVScroll" },
                { resizer: true, width: 1},
                { view: "resourceHistogram", capacity:24, scrollX: "scrollHor", 
                    scrollY: "resourceVScroll"},
                { view: "scrollbar", id: "resourceVScroll", group:"vertical"}
            ]
        },
        {view: "scrollbar", id: "scrollHor"}
    ]
};

Related sample:  Resource histogram

Genau wie im Ressourcenauslastungsdiagramm ist resourceGrid ähnlich der Standard-Rasteransicht, aber schreibgeschützt. resourceHistogram fügt mehrere zusätzliche Vorlagen hinzu:

• histogram_cell_class - definiert die CSS-Klasse für eine Zelle im Ressourcenpanel.

gantt.templates.histogram_cell_class=function(start_date,end_date,resource,tasks,
    assignments){
    return "";
};

• histogram_cell_label - gibt das Label an, das in einer Zelle angezeigt wird.

gantt.templates.histogram_cell_label=function(start_date,end_date,resource,tasks,
    assignments){
    return tasks.length * 8;
};

• histogram_cell_allocated - bestimmt die Höhe des gefüllten Bereichs im Histogramm. Werte können von 0 bis maxCapacity reichen.

gantt.templates.histogram_cell_allocated=function(start_date,end_date,resource,tasks,
    assignments){
    return tasks.length * 8;
};

• histogram_cell_capacity - definiert die Höhe der Linie, die die Ressourcenkapazität darstellt. Werte können von -1 bis maxCapacity reichen. Negative Werte rendern die Linie nicht.

gantt.templates.histogram_cell_capacity=function(start_date,end_date,resource,tasks,
    assignments){
    return 24;
};

Verständnis von maxCapacity

In einem Histogramm stellt maxCapacity die Höhe der Y-Skala für jede Zeile dar. Wenn maxCapacity beispielsweise auf 24 gesetzt ist, definiert es den höchsten Punkt der Zeile.

Standardmäßig ist maxCapacity auf 24 für alle Ressourcen eingestellt. Wenn Sie einen Wert größer als 24 in der histogram_cell_capacity Vorlage zurückgeben, funktionieren die Berechnungen weiterhin, aber die Zellen im Ressourcenpanel werden möglicherweise nicht wie erwartet angezeigt.

Sie können maxCapacity global für das Histogramm oder individuell für jede Ressource anpassen. So geht's:

Related sample:  Konfiguration von maxCapacity

maxCapacity kann auf Histogramm-Ebene festgelegt werden:

{ view: "resourceHistogram", capacity:24, scrollX: "scrollHor", 
    scrollY: "resourceVScroll"}

Oder für spezifische Ressourcen:

resourcesStore.parse([
    {id: 1, text: "John", capacity:8},
    {id: 2, text: "Mike", capacity:4},
    {id: 3, text: "Anna", capacity:8},
    {id: 4, text: "Bill", capacity:8},
    {id: 5, text: "Floe", capacity:8}
]);

Verwaltung des Ressourcenansicht-Panels

Standardmäßig sind beide Ansichten ("resourceGrid" und "resourceTimeline" oder "resourceGrid" und "resourceHistogram") mit einem Datenspeicher verbunden, der in der Option gantt.config.resource_store angegeben ist.

Automatische Erstellung eines Datenspeichers

Ab Version 8.0 erstellt Gantt automatisch einen Datenspeicher für Ressourcen während der Initialisierung. Dieser Speicher ist bereit, wenn "onGanttReady" ausgelöst wird. Um darauf zuzugreifen, verwenden Sie die Methode gantt.getDatastore(gantt.config.resource_store).

Wenn zusätzliche Konfigurationen für den Ressourcenspeicher erforderlich sind, können Sie die Option gantt.config.resources verwenden:

gantt.config.resources = {
    resource_store: {
        type: "treeDataStore",
        fetchTasks: true,
        initItem: function(item) {
            item.parent = item.parent || gantt.config.root_id;
            item[gantt.config.resource_property] = item.parent;
            item.open = true;
            return item;
        }
    },
}

Diese Einstellungen werden verwendet, um den Standard-Ressourcendatenspeicher zu erstellen. Wenn bereits ein benutzerdefinierter Speicher definiert ist, wird Gantt diesen stattdessen verwenden.

Um Ressourcen zu laden, können Sie sie in gantt.parse()/gantt.load() wie hier beschrieben einbinden oder den Speicher direkt mit datastore.parse() füllen:

gantt.attachEvent("onGanttReady", function(){
    const store = gantt.getDatastore(gantt.config.resource_store);
    store.parse([
       {id: 6, text: "John"},
       {id: 7, text: "Mike"},
       {id: 8, text: "Anna"},
       {id: 9, text: "Bill"},
    ])
});

Die Lightbox-Ressourcensteuerung wird automatisch mit der Ressourcenliste verbunden:

gantt.config.lightbox = {
    sections: [
        ...,
        { name: "resources", type: "resources", map_to: "auto", default_value: 8}
    ]
};

Manuelle Erstellung eines Datenspeichers

Sie können den Datenspeicher auch manuell mit der Methode createDatastore erstellen:

var resourcesStore = gantt.createDatastore({
  name: gantt.config.resource_store,
  // Verwenden Sie treeDatastore, wenn Sie hierarchische Ressourcen haben (z. B. Arbeiter/Abteilungen), 
  // überspringen Sie den "type", wenn Sie eine flache Struktur haben
  type: "treeDatastore", 
  initItem: function (item) {
    item.parent = item.parent || gantt.config.root_id;
    item[gantt.config.resource_property] = item.parent;
    item.open = true;
    return item;
  }
});

Um den Datenspeicher zu füllen, verwenden Sie die Methode datastore.parse:

resourcesStore.parse([
    {id: 1, text: "QA", parent:null},
    {id: 2, text: "Entwicklung", parent:null},
    {id: 3, text: "Vertrieb", parent:null},
    {id: 4, text: "Sonstige", parent:null},
    {id: 5, text: "Nicht zugewiesen", parent:4},
    {id: 6, text: "John", parent:1},
    {id: 7, text: "Mike", parent:2},
    {id: 8, text: "Anna", parent:2},
    {id: 9, text: "Bill", parent:3},
    {id: 10, text: "Floe", parent:3}
]);

Um Ressourcen in der Lightbox zu verwenden, ziehen Sie in Betracht, sie über die Methode serverList im onParse-Ereignis des Datenspeichers einzurichten:

resourcesStore.attachEvent("onParse", function(){
  var people = [];
  resourcesStore.eachItem(function(res){
    if(!resourcesStore.hasChild(res.id)){
        var copy = gantt.copy(res);
        copy.key = res.id;
        copy.label = res.text;
        people.push(copy);
    }
  });
  gantt.updateCollection("resourceOptions", people);
});

Erweiterung des Ressourcenpanels

Sie können das Ressourcenpanel so einrichten, dass alle Aufgaben angezeigt werden, die mit einer bestimmten Ressource verknüpft sind, indem Sie die fetchTasks-Eigenschaft bei der Initialisierung des Datenspeichers aktivieren:

gantt.config.resources = {
    resource_store: {
        type: "treeDataStore",
        fetchTasks: true,         initItem: function (item) {
            item.parent = item.parent || gantt.config.root_id;
            item[gantt.config.resource_property] = item.parent;
            if (!item.parent) {
                item.open = true;
            } else {
                item.open = false;
            }
            return item;
        }
    },
};

Alternativ:

gantt.$resourcesStore = gantt.createDatastore({
    name: gantt.config.resource_store,
    type: "treeDatastore",
    fetchTasks: true,     initItem: function (item) {
        item.parent = item.parent || gantt.config.root_id;
        item[gantt.config.resource_property] = item.parent;
        if (!item.parent) {
            item.open = true;
        } else {
            item.open = false;
        }
        return item;
    }
});

Related sample:  Show all assigned tasks in the resource panel

Wenn fetchTasks auf true gesetzt ist, zeigt Gantt alle Aufgaben, die mit einer bestimmten Ressource verknüpft sind, im Ressourcenansicht-Panel an. Diese Funktion funktioniert sowohl mit den Ressourcen-Diagramm- als auch Ressourcen-Histogramm-Layouts.

Um schnell alle mit einer Ressource verbundenen Aufgaben abzurufen, können Sie die folgende Kurzform verwenden:

gantt.getResourceAssignments("6");

---

Zuweisen von Ressourcen

Verknüpfen von Ressourcen mit Aufgaben

Die Verbindung zwischen Aufgaben und Ressourcen wird durch die Konfigurationsoption resource_property definiert:

gantt.config.resource_property = "user_id";
// task.user_id <-> resource.id

Sie können Ressourcen auf verschiedene Arten über Eigenschaften des Aufgabenobjekts zuweisen:

• Zuweisung einer einzelnen Ressource zu einer Aufgabe:

{
    id: 1, text: "Aufgabe #1", start_date: "02-04-2018", duration: 8, progress: 0.6, 
    user_id: 5 // 5 ist die ID der Ressource 
}

• Zuweisung mehrerer Ressourcen zu einer Aufgabe:

{
    id: 1, text: "Aufgabe #1", start_date: "02-04-2018", duration: 8, progress: 0.6, 
    users: [2, 3] // 2 und 3 sind die IDs der Ressourcen
}

Dieses Format kann auch mit der benutzerdefinierten Mehrfachauswahlsteuerung verwendet werden.

• Zuweisung mehrerer Ressourcen mit spezifischen Mengen:

{
    id: 1, text: "Aufgabe #1", start_date: "02-04-2018", duration: 8, progress: 0.6,
    users: [{resource_id: 2, value: 8}, {resource_id: 3, value: 4}]  
}

Hier wird der Aufgabe #1 die Ressource mit ID=2 in einer Menge von 8 Einheiten und die Ressource mit ID=3 in einer Menge von 4 Einheiten zugewiesen. Dieses Format wird von der Lightbox unterstützt.

Ab Version 8.0 können Ressourcen-Zuweisungen auch als separate Liste geladen werden. Gantt wird diese automatisch mit Aufgaben verknüpfen:

gantt.parse({
    tasks: [...],
    links: [...],
    resources: [...],
    assignments: [{id: 1, resource_id: 2, task_id: 5, value: 8}, ...]
});

Details zu Datenformaten sind hier verfügbar.

Beim Senden von Daten an den Server konvertiert der DataProcessor die Werte dieser Eigenschaften in JSON. Um die serverseitige Verarbeitung zu vereinfachen, sollten Sie den "REST_JSON" DataProcessor-Modus in Betracht ziehen.

Wenn Sie Ressourcen-Zuweisungen getrennt von Aufgaben speichern möchten, aktivieren Sie die folgenden Einstellungen:

gantt.config.resources = {
    dataprocessor_assignments: true,
    dataprocessor_resources: true,
};

Weitere Details finden Sie in einem dedizierten Artikel.

---

Festlegen der Zeit für Ressourcen-Zuweisungen

Standardmäßig wird eine Ressource für die gesamte Dauer einer Aufgabe zugewiesen. Ab Version 7.1 können dem Ressourcen-Zuweisungsobjekt zusätzliche Parameter hinzugefügt werden, um bestimmte Daten für die Zuweisung innerhalb der Aufgabe zu definieren.

Die zusätzlichen Eigenschaften umfassen:

• id - (string|number) die ID der Zuweisung
• start_date - (Date|string) das Startdatum der Zuweisung
• end_date - (Date|string) das Enddatum der Zuweisung
• delay - (number) die Verzögerung zwischen dem Aufgabenstart und dem Zuweisungsstart
• duration - (number) die Dauer der Zuweisung
• mode - (string) der Zeitberechnungsmodus: "default" | "fixedDates" | "fixedDuration"

Beispiel:

{
    id: 5, text: "Innenausbau Büro", type: "task", start_date: "03-04-2019 00:00",
    duration: 7, parent: "2", progress: 0.6, priority: 1,
    users: [{
        resource_id: "3",
        value: 8,
        delay: 1     },{
        resource_id: "6",
        value: 3,
        start_date: "03-04-2019 00:00",         end_date: "05-04-2019 00:00",         mode: "fixedDates"     },{
        resource_id: "7",
        value: 3,
        delay: 1,         duration: 2,         mode: "fixedDuration"     }]
}

Related sample:  Assign resource values to specific days

1. Die Start- und Enddaten von Ressourcen-Zuweisungen werden im Ressourcenhistogramm und -diagramm angezeigt.

2. Eine optionale id-Eigenschaft kann dem Zuweisungsobjekt hinzugefügt werden:

{
    id: 1, text: "Aufgabe #1", start_date: "02-04-2018", duration: 8, progress: 0.6,
    users: [{
        id: 5, 
        resource_id: 2, value: 8, 
        delay: 1
    }]
}

Dieses Zuweisungsobjekt kann über seine ID mithilfe der Gantt-API abgerufen werden:

var assignment = gantt.getDatastore("resourceAssignments").getItem(5);

1. Das Verhalten anderer Eigenschaften hängt vom Wert der mode-Eigenschaft ab:

• Standardmodus

Wenn der mode nicht angegeben oder auf "default" gesetzt ist, basieren die Start- und Enddaten der Zuweisung auf den Daten der Aufgabe. Eine delay kann hinzugefügt werden, um das Startdatum relativ zum Startdatum der Aufgabe anzupassen.

• FixedDuration-Modus

In diesem Modus wird das Enddatum der Zuweisung basierend auf ihrer Dauer berechnet, während das Startdatum weiterhin an das Startdatum der Aufgabe mit einer optionalen Verzögerung gebunden ist.

• FixedDates-Modus

Dieser Modus behält die angegebenen Start- und Enddaten der Zuweisung bei, unabhängig von Änderungen an der Aufgabe.

---

Abrufen der zugewiesenen Aufgaben für eine Ressource

Um alle Aufgaben zu erhalten, die mit einer bestimmten Ressource verknüpft sind, verwenden Sie die folgende Methode:

gantt.getResourceAssignments("6");

Dies gibt ein Array von Objekten zurück, die Details zu jeder der Ressource zugewiesenen Aufgabe enthalten:

[ 
    {task_id: 5, resource_id: "6", value: 5, delay: 0, duration: 7, 
        start_date: "03-04-2019 00:00", end_date: "12-04-2019 00:00", 
        id: 1617258553240, mode: "default"},
    {task_id: 18, resource_id: "6", value: 2, delay: 0, duration: 2, 
        start_date: "05-04-2019 00:00", end_date: "09-04-2019 00:00", 
        id: 1617258553250, mode: "default"},
    {task_id: 19, resource_id: "6", value: 3, delay: 0, duration: 4, 
        start_date: "09-04-2019 00:00", end_date: "13-04-2019 00:00", 
        id: 1617258553251, mode: "default"},
    {task_id: 21, resource_id: "6", value: 5, delay: 0, duration: 4, 
        start_date: "03-04-2019 00:00", end_date: "09-04-2019 00:00", 
        id: 1617258553254, mode: "default"}
]

Abrufen von Ressourcen-Zuweisungen für eine Aufgabe

Um Ressourcen-Zuweisungen für eine bestimmte Aufgabe abzurufen, verwenden Sie:

gantt.getTaskAssignments(5);

Diese Methode gibt ein Array von Objekten zurück, die Zuweisungsdetails enthalten, ähnlich der Ausgabe von gantt.getResourceAssignments.

Einrichten von Verbindungen mit der Lightbox

Sie können Ressourcen direkt aus der integrierten Lightbox jeder Aufgabeneigenschaft zuweisen.

gantt.serverList("people", [
    {key: 1, label: "John"},
    {key: 2, label: "Mike"},
    {key: 3, label: "Anna"},
    {key: 4, label: "Bill"},
    {key: 7, label: "Floe"}
]);
 
gantt.locale.labels.section_owner = "Besitzer";
 
gantt.config.lightbox.sections = [
  {name:"description", height:38, map_to:"text", type:"textarea", focus:true},
  {name:"owner", map_to:"owner_id", type:"select", options:gantt.serverList("people")},
  {name:"time", type:"duration", map_to: "auto"}
];

Weitere Informationen zur Konfiguration der Ressourcensteuerung in der Lightbox finden Sie im Artikel Ressourcensteuerung.

Dynamisches Laden von Sammlungen

Serverlistensammlungen können geladen und aktualisiert werden, auch nachdem Gantt initialisiert wurde:

// Initialisieren der Lightbox mit einer leeren Sammlung 
gantt.locale.labels.section_owner = "Besitzer";
 
gantt.config.lightbox.sections = [
  {name:"description", height:38, map_to:"text", type:"textarea", focus:true},
  {name:"owner", map_to:"owner_id", type:"select", options:gantt.serverList("people")},
  {name:"time", type:"duration", map_to: "auto"}
];
 
// Optionen dynamisch laden
gantt.updateCollection("people", [
    {key: 1, label: "John"},
    {key: 2, label: "Mike"},
    {key: 3, label: "Anna"},
    {key: 4, label: "Bill"},
    {key: 7, label: "Floe"}
]);

Related sample:  Assigning owners to tasks

Wenn Ressourcen mithilfe der serverList-Sammlung definiert sind, können sie zusammen mit anderen Daten geladen werden. Andernfalls müssen sie manuell geladen werden.

Für weitere Details zur Konfiguration der Lightbox-Ressourcensteuerung, siehe den Artikel Ressourcensteuerung.

---

Laden von Ressourcen und Zuweisungen

Ab Version 8.0 können Ressourcen und ihre Zuweisungen in Gantt mit den Methoden gantt.parse() oder gantt.load() geladen werden:

gantt.parse({
    tasks: [
        ...,
        {
            id: 5,
            text: "Innenausbau Büro",
            type: "task",
            start_date: "03-04-2024 00:00",
            duration: 7,
            parent: "2",
            owner: [
                {
                    resource_id: "6",
                    value: 3,
                    start_date: "03-04-2024 00:00",
                    end_date: "05-04-2024 00:00",
                }
            ]
        },
        ...
    ],
    links: [],
    resources: [
        {id: 6, text: "John", unit: "hours/day" },
        {id: 7, text: "Mike", unit: "hours/day" },
        {id: 8, text: "Anna", unit: "hours/day" },
        {id: 9, text: "Bill", unit: "hours/day" },
        {id: 10, text: "Floe", unit: "hours/day" }
    ]
});

Zuweisungen können auch separat von Aufgaben bereitgestellt werden:

gantt.parse({
    tasks: [
        ...,
        {
            id: 5,
            text: "Innenausbau Büro",
            type: "task",
            start_date: "03-04-2024 00:00",
            duration: 7,
            parent: "2",
            priority: 1
        },
        ...
    ],
    links: [],
    assignments: [
        {
            id: 1, task_id: 5, resource_id: 6, value: 3,
            start_date: "03-04-2024 00:00", 
            end_date: "05-04-2024 00:00"
        }
    ],
    resources: [
        {id: 6, text: "John", unit: "hours/day" },
        {id: 7, text: "Mike", unit: "hours/day" },
        {id: 8, text: "Anna", unit: "hours/day" },
        {id: 9, text: "Bill", unit: "hours/day" },
        {id: 10, text: "Floe", unit: "hours/day" }
    ]
});

---

Verwaltung von Ressourcen-Zuweisungen

Parsen von Ressourcen-Zuweisungen

Ab Version 7.1 können Ressourcen-Zuweisungen als Objekte im Datenspeicher behandelt werden. Die Eigenschaft process_resource_assignments ermöglicht das Parsen von Ressourcen-Eigenschaften von Aufgaben in interne Ressourcen-Zuweisungsobjekte, was die Verwaltung über das DataStore-Objekt erleichtert.

Diese Funktion ist besonders nützlich, um spezifische Dauer- und Zeiteinstellungen für Ressourcen festzulegen, z. B. beim Aufbau eines Ressourcen-Diagramms oder Histogramms. Das Aktivieren dieser Funktionalität kann jedoch die Leistung bei großen Projekten beeinträchtigen. Wenn keine Zeit- oder Dauereinstellungen benötigt werden, können Sie das Parsen deaktivieren:

gantt.config.process_resource_assignments = false;

Wenn deaktiviert, ist der gantt.getDatastore("resourceAssignments") Datenspeicher nicht verfügbar, und Zuweisungsobjekte haben keine dynamischen Eigenschaften. Das Ressourcen-Diagramm und -Histogramm gehen davon aus, dass Ressourcen für die gesamte Aufgabendauer zugewiesen sind.

Aktualisieren von Ressourcen-Zuweisungen

Ressourcen-Zuweisungen werden in einem Datenspeicher gespeichert, der automatisch erstellt wird. Standardmäßig werden Änderungen an einer Aufgabenressourceneigenschaft (z. B. task.users) automatisch im Datenspeicher reflektiert.

task[gantt.config.resource_property] = [
    {
        resource_id: "6",
        value: 3,
        start_date: "03-04-2019 00:00",
        end_date: "05-04-2019 00:00",
    }
];
gantt.updateTask(taskId);

Wenn Zuweisungen über die Datenspeicher-API aktualisiert werden, können Sie sie mit gantt.updateTaskAssignments() zurück zum Aufgabenobjekt synchronisieren:

var assignmentStore = gantt.getDatastore(gantt.config.resource_assignment_store);
 
assignmentStore.addItem({
    resource_id: 5,
    task_id: 2,
    value: 4
});
assignmentStore.removeItem(assignment.id);
assignmentStore.updateItem(assignment.id);
 
// Änderungen zurück zum Aufgabenobjekt synchronisieren
gantt.updateTaskAssignments(taskId);

---

Anzeige von Aufgabenressourcen

Um einen Ressourcennamen als Teil einer Aufgabenbeschreibung oder eines Rasterzellenlabels anzuzeigen, kann eine Hilfsfunktion verwendet werden, um IDs in Labels umzuwandeln:

function byId(list, id) {
    for (var i = 0; i < list.length; i++) {
        if (list[i].key == id)
            return list[i].label || "";
    }
    return "";
}

Diese Funktion kann dann in Vorlagen verwendet werden:

gantt.config.columns = [
    {name: "owner", width: 80, align: "center", template: function (item) {
        return byId(gantt.serverList('people'), item.owner_id)}},
    {name: "text", label: "Aufgabenname", tree: true, width: '*'},
    {name: "add", width: 40}
];
 
gantt.templates.rightside_text = function(start, end, task){
    return byId(gantt.serverList('people'), task.owner_id);
};

Related sample:  Assigning owners to tasks

---

Bearbeitbares Ressourcen-Diagramm

Um Ressourcen-Zuweisungen im Ressourcen-Diagramm bearbeitbar zu machen, aktivieren Sie die folgende Konfiguration:

gantt.config.resources = {
    editable_resource_diagram: true
};

Related sample:  Assign resource values to specific days

Wenn aktiviert, verwendet Gantt integrierte Vorlagen für bearbeitbare Diagramme, die bei Bedarf überschrieben werden können. Standardvorlagen sind im gantt.ext.resources Objekt verfügbar.

---

Benutzerdefinierte Styling für Ressourcen

Für benutzerdefinierte Styles können Sie Vorlagen wie folgende verwenden:

• gantt.templates.grid_row_class für CSS von Rasterzeilen
• gantt.templates.task_row_class für Hintergrundzeilen der Zeitleiste
• gantt.templates.task_class für Aufgabenbalkenelemente

Styles können auch dynamisch mit Ressourcendaten geladen oder für jede Ressource vordefiniert werden. Weitere Informationen finden Sie in diesem Leitfaden.

Related sample:  Assigning owners to tasks

---

Ressourcenkalender

Benutzerdefinierte Arbeitszeitkalender können spezifischen Ressourcen zugewiesen werden. Diese Kalender sind über eine Eins-zu-Eins-Zuordnung mit Aufgaben verknüpft:

// Kalender Ressourcen zuweisen
gantt.config.resource_property = "resource_id";
 
gantt.config.resource_calendars = {
    "resource1" : "calendarId1",
    "resource2" : "calendarId2",
    "resource3" : "calendarId3"
};

Wenn sich eine Ressourceneigenschaft ändert, werden Aufgaben mit dem neuen Kalender neu berechnet. Weitere Details finden Sie im Artikel Arbeitszeit.

---

Ausgleich der Ressourcenauslastung

Die Gruppierungserweiterung ermöglicht es, Projekte nach Ressourceneigenschaften aufzuschlüsseln, was hilfreich ist, um Ressourcenauslastungen auszugleichen.

Related sample:  Break down by resources

Weitere Informationen zur Gruppierung von Aufgaben finden Sie im verwandten Artikel.

Gruppierung von Aufgaben nach mehreren Ressourcen

Wenn mehrere Ressourcen einer Aufgabe zugewiesen sind, werden diese Aufgaben nach ihren zugewiesenen Ressourcen gruppiert. Das bedeutet, dass eine Aufgabe, die mit zwei Personen verknüpft ist, nicht zweimal für jede Person erscheint. Stattdessen wird sie einmal angezeigt, wobei beide Personen als zugewiesen angezeigt werden. Aufgaben innerhalb dieser Gruppen werden basierend auf ihren Startdaten angeordnet.

Related sample:  Group by multiple resources

• Wenn der Datensatz Aufgaben mit mehreren Ressourcen enthält, wird Gantt diese Aufgaben automatisch entsprechend gruppieren.
• Für Aufgaben ohne zugewiesene Ressourcen generiert Gantt eine Standardgruppe namens "Nicht zugewiesen". Wenn eine solche Gruppe bereits in den Daten vorhanden ist, die an die groupBy() Methode übergeben werden, sollte sie die default:true Konfiguration enthalten, um die automatische Erstellung einer weiteren Gruppe zu vermeiden.

Zurück nach oben