Arbeitszeiterfassung

Standardmäßig misst dhtmlxGantt die Aufgabendauer in Kalenderzeit, was bedeutet, dass Wochenenden und Feiertage in die Gesamtdauer einbezogen werden.

Wenn Sie möchten, dass die Aufgabendauer nur auf Arbeitszeit basiert, können Sie die Option work_time verwenden:

Aktivieren Sie die Arbeitszeiterfassung für Aufgabendauern

gantt.config.work_time = true;  // schließt Nicht-Arbeitszeit aus den Berechnungen aus gantt.config.skip_off_time = true;    // verbirgt Nicht-Arbeitszeit im Diagramm 
gantt.init("gantt_here");

Beachten Sie, dass die Konfigurationsoption skip_off_time nur in der PRO-Version verfügbar ist.

Related sample:  Duration includes only working days

Ab Version 6.3 unterstützt dhtmlxGantt die Angabe von Aufgabendauern in Dezimalformaten wie "2.5 days", "0.5 hours" oder "3.75 hours" mithilfe des Duration Formatter Moduls.

Es ist wichtig zu beachten, dass Gantt intern Aufgabendauern als Ganzzahlen speichert. Das Modul hilft dabei, vom Benutzer eingegebene Dezimalwerte in das in Gantt gespeicherte Format zu konvertieren (z.B. wird "1.5 hours" zu 90 Minuten) und umgekehrt, gespeicherte Werte zurück in ein lesbares Format zu konvertieren (z.B. werden 12 Stunden zu "0.5 days").

Verwendung des Dezimalformats

Um Aufgabendauern im Dezimalformat anzuzeigen, befolgen Sie diese Schritte:

• Setzen Sie duration_unit auf "minute".

gantt.config.work_time = true;
gantt.config.duration_unit = "minute";

Stellen Sie sicher, dass Aufgabendauern in kleineren Einheiten als im angezeigten Dezimalformat gespeichert werden. Zum Beispiel: - Um Benutzern zu erlauben, Dauern als Bruchteile einer Stunde anzugeben (z.B. "0.5 hours"), setzen Sie duration_unit auf "minute". - Um Benutzern zu erlauben, Dauern als Bruchteile eines Tages anzugeben, setzen Sie duration_unit auf "hour". In diesem Fall funktioniert "0.5 day", aber "0.5 hour" wird auf 1 Stunde gerundet, da Dauern als ganze Stunden gespeichert werden.

Zum Beispiel:

// 15-Minuten-Zeitschritte, erfordert "minute" als Dauereinheit
gantt.config.time_step = 15;
gantt.config.round_dnd_dates = false;

oder

// 1-Stunden-Zeitschritte, geeignet, wenn die Dauereinheit "hour" ist
gantt.config.time_step = 60;
gantt.config.round_dnd_dates = false;

• Erstellen Sie ein formatter Objekt, um das Formatieren der Aufgabendauer zu handhaben:

// Formatieren der Dauer
var formatter = gantt.ext.formatters.durationFormatter({
    enter: "day", 
    store: "minute", // duration_unit
    format: "day",
    hoursPerDay: 8,
    hoursPerWeek: 40,
    daysPerMonth: 30
});

• Fügen Sie das formatter Objekt zur "Duration"-Spalte hinzu, indem Sie eine Template-Funktion im columns Parameter definieren:

gantt.config.columns = [
    {name: "text", tree: true, width: 170, resize: true, editor: textEditor},
    {name: "start_date", align: "center", resize: true, editor: dateEditor},
    {name: "duration", label:"Duration", resize: true, align: "center", 
        template: function(task) {             return formatter.format(task.duration);         }, width: 100},
    {name: "add", width: 44}
];

• Verwenden Sie das formatter Objekt im Lightbox-Abschnitt, indem Sie die formatter Eigenschaft für das time Kontrollfeld festlegen:

gantt.config.lightbox.sections = [
    {name: "description", height: 70, map_to: "text", type: "textarea", focus: true},
    {name: "time", type: "duration", map_to: "auto", formatter: formatter}
];

• Wenn Inline-Bearbeitung im Grid aktiviert ist, fügen Sie das formatter Objekt zum durationEditor Objekt hinzu:

var durationEditor = {
    type: "duration", 
    map_to: "duration", 
    formatter: formatter,     min:0, max:1000
    };
gantt.config.columns = [
    {name: "text", tree: true, width: 170, resize: true},
    {name: "start_date", align: "center", resize: true},
    {name: "duration", label:"Duration", resize: true, align: "center", 
        template: function(task) {
            return formatter.format(task.duration);
    }, editor: durationEditor, width: 100},     {name: "add", width: 44}
];

Einstellen der Arbeitszeit

Standardmäßig ist die Arbeitszeit definiert als:

• Arbeitstage: Montag bis Freitag.
• Arbeitsstunden: 8:00–12:00, 13:00–17:00.

Um diese Einstellungen anzupassen, verwenden Sie die Methode setWorkTime:

Anpassen der Arbeitszeit

// Arbeitsstunden für Wochentage festlegen
gantt.setWorkTime({ hours:["9:00-18:00"] });
 
// Freitage als freie Tage markieren
gantt.setWorkTime({ day:5, hours:false });
 
// Spezifische Stunden für Freitage und Samstage festlegen
gantt.setWorkTime({day : 5, hours : ["8:00-12:00"]});
gantt.setWorkTime({day : 6, hours : ["8:00-12:00"]});
 
// Ein bestimmtes Datum als Arbeitstag festlegen
gantt.setWorkTime({date : new Date(2019, 2, 31)});
 
// Ein bestimmtes Datum als freien Tag festlegen
gantt.setWorkTime({date:new Date(2019,0,1), hours:false})

Related sample:  Custom working days and time

Arbeitszeiten für Nachtschichten festlegen

Stellen Sie sicher, dass das hours Attribut in setWorkTime in aufsteigender Reihenfolge ist. Andernfalls werden einige Intervalle ignoriert. Zum Beispiel:

// Diese Einstellungen funktionieren nicht wie erwartet
gantt.setWorkTime({day : 5, hours : ["16:00-18:00", "14:00-15:00",  "08:00-10:00"]});
gantt.setWorkTime({day : 5, hours : ["16:00-18:00", "00:00-04:00",  "05:00-06:00"]});

Für Nachtschichten teilen Sie die Stunden auf zwei Tage auf:

gantt.setWorkTime({day : 5, hours : ["16:00-18:00"]});
gantt.setWorkTime({day : 6, hours : ["00:00-04:00",  "05:00-06:00"]});

Arbeitszeitregeln konfigurieren

Sie können verschiedene Arbeitszeitregeln für bestimmte Zeiträume mit dem customWeeks Attribut in setWorkTime definieren. Zum Beispiel, um unterschiedliche Stunden für die Wintermonate festzulegen:

// Arbeitszeiten für Wintermonate anpassen
gantt.setWorkTime({
    customWeeks: {
        winter: {
            from: new Date(2018, 11, 1), // 1. Dezember 2018
            to: new Date(2019, 2, 1), // 1. März 00:00, 2019
            hours: ["9:00-13:00", "14:00-16:00"],
            days: [ 1, 1, 1, 1, 0, 0, 0]
        }
    }
});

Wenn Sie Arbeitszeiten mit Minuten angeben müssen (z.B. "8:15-12:45"), setzen Sie duration_unit auf "minute".

Arbeitszeiten mit Minutenpräzision anpassen

gantt.config.duration_unit = "minute";
 
// Arbeitszeiten mit Minutenpräzision festlegen
gantt.setWorkTime({hours:["8:15-12:45"]});

gantt.setWorkTime({hours:[9, 18]})

Aktualisieren einer Arbeitszeitregel

Wenn Sie die Methode für dasselbe Datum mehrmals aufrufen, ersetzt die zuletzt festgelegte Arbeitszeitregel die vorherige. Um eine bestehende Regel anzupassen oder zu entfernen, können Sie die Methode gantt.setWorkTime() mit einer neuen Konfiguration verwenden:

gantt.setWorkTime({hours:["8:00-12:00"]});
gantt.setWorkTime({hours:["13:00-17:00"]});
// Die resultierende Arbeitszeit wird 13:00-17:00 sein,
// nicht eine Kombination der beiden Befehle.

Arbeitszeit entfernen

Um eine Arbeitszeiteinstellung zu entfernen, können Sie die Methode gantt.unsetWorkTime() verwenden:

// Setzt die Arbeitszeit für Arbeitstage auf ["8:00-12:00"]
gantt.setWorkTime({hours:["8:00-12:00"]});
// Entfernt die Arbeitszeit
gantt.unsetWorkTime({hours:["8:00-12:00"]});

Arbeitszeit überprüfen

Um festzustellen, ob ein bestimmtes Datum in die Arbeitszeit fällt, verwenden Sie die Methode gantt.isWorkTime():

// Markiert den 1. Januar 2019 als freien Tag
gantt.setWorkTime({date:new Date(2019,0,1), hours:false});
gantt.isWorkTime(new Date(2019,0,1)) // -> false   
// Setzt den 15. März 2019 als Arbeitstag von 9:00 bis 18:00
gantt.setWorkTime({date : new Date(2019, 2, 15), hours:["8:00-17:00"]});
gantt.isWorkTime(new Date(2019, 2, 15,10,0), "hour"); // -> true  gantt.isWorkTime(new Date(2019, 2, 15,8,0), "hour"); // -> false

Related sample:  Correct task position on drag

Arbeitszeit abrufen

Um die Arbeitsstunden für ein bestimmtes Datum zu erhalten, können Sie die Methode gantt.getWorkHours() verwenden:

gantt.getWorkHours(new Date(2019,3,30))// -> ["8:00-17:00"]

Wenn Sie den nächsten Arbeitstag zu einem bestimmten Datum benötigen, verwenden Sie die Methode gantt.getClosestWorkTime():

gantt.getClosestWorkTime(new Date(2019,3,30));

Wiederkehrende Arbeitszeit festlegen

Manchmal möchten Sie Arbeitszeiten definieren, die sich an bestimmten Tagen wiederholen, wie z.B. den letzten Freitag jedes Monats zu einem kurzen Tag machen oder den 25. Dezember als Feiertag markieren. Derzeit bietet dhtmlxGantt keine integrierten Optionen dafür. Es ermöglicht Ihnen:

• Arbeitszeiten für bestimmte Wochentage festzulegen (z.B. Montag, Dienstag, usw.)
• Arbeitszeiten für bestimmte Daten zu definieren (z.B. 4. Juni 2020)
• Arbeitszeiten für einen Datumsbereich zu überschreiben (z.B. 1. Juni 2020 - 1. September 2020)

Für Ausnahmen von diesen Regeln müssen Sie die relevanten Daten manuell identifizieren und die Einstellungen individuell anwenden.

Zum Beispiel, wenn ein Projekt fünf Jahre umfasst und Sie möchten, dass der 1. Januar immer ein freier Tag ist, können Sie es so festlegen:

gantt.setWorkTime({hours:false, date: new Date(2021, 0, 1)});
gantt.setWorkTime({hours:false, date: new Date(2022, 0, 1)});
gantt.setWorkTime({hours:false, date: new Date(2023, 0, 1)});
gantt.setWorkTime({hours:false, date: new Date(2024, 0, 1)});
gantt.setWorkTime({hours:false, date: new Date(2025, 0, 1)});

Um den letzten Freitag jedes Monats zu einem kurzen Tag zu machen, können Sie den folgenden Code verwenden:

function lastFridayOfMonth(date) { 
    var lastDay = new Date(date.getFullYear(), date.getMonth() + 1, 0);
    if (lastDay.getDay() < 5) {
        lastDay.setDate(lastDay.getDate() - 7);
    }
    lastDay.setDate(lastDay.getDate() - (lastDay.getDay() - 5));
    return lastDay;
}
 
var projectStart = new Date(2020, 5, 1);
var projectEnd = new Date(2025, 5, 1);
var currentDate = new Date(projectStart);
 
while (currentDate.valueOf() <= projectEnd.valueOf()) {
   var lastFriday = lastFridayOfMonth(currentDate);
   gantt.setWorkTime({hours:["8:00-12:00", "13:00-15:00"], date: lastFriday});
   currentDate = gantt.date.add(currentDate, 1, "month");
}

Nicht-Arbeitszeiten hervorheben

Um Nicht-Arbeitszeiten im Diagramm visuell hervorzuheben, können Sie das Template gantt.templates.timeline_cell_class verwenden:

gantt.templates.timeline_cell_class = function(task, date){
    if (!gantt.isWorkTime({task:task, date: date}))
        return "week_end";
    return "";
};

Related sample:  Custom working days and time

Weitere Details finden Sie im Artikel highlighting time slots.

Zusätzlich zu den globalen Arbeitszeiteinstellungen unterstützt Gantt mehrere Arbeitszeitkalender, die einzelnen Aufgaben oder Aufgabengruppen zugewiesen werden können.

Erstellen eines Arbeitskalenders

Sie können einen neuen Kalender mit der Methode gantt.createCalendar() erstellen. Diese Methode bietet zwei Optionen:

• Ohne Parameter erstellt sie einen Vollzeitkalender (24 Stunden pro Tag, 7 Tage pro Woche):

var calendar = gantt.createCalendar();

• Um einen bestehenden Kalender als Basis zu verwenden, übergeben Sie ihn als Parameter:

var newCalendar = gantt.createCalendar(calendar);

Sobald erstellt, ist der Kalender von Gantt getrennt und hat keine Auswirkungen, bis er hinzugefügt wird.

Hinzufügen eines Kalenders zu Gantt

Nachdem Sie einen Kalender erstellt haben, fügen Sie ihn mit der Methode gantt.addCalendar() zu Gantt hinzu. Sie können:

• Eine bestehende Kalenderkonfiguration hinzufügen:

var calendarId = gantt.addCalendar(calendar);

• Eine neue Kalenderkonfiguration definieren, einschließlich ihrer ID und eines worktime Objekts mit Arbeitstagen und -stunden:

var calendarId = gantt.addCalendar({
    id: "custom", // optional
    worktime: {
        hours: ["8:00-17:00"],
        days: [1, 1, 1, 1, 1, 1, 1]
    }
});

Unterschiedliche Arbeitszeiten für bestimmte Zeiträume

Ab Version 7.1 können Sie unterschiedliche Arbeitszeiten für bestimmte Zeiträume innerhalb eines Kalenders festlegen. Zum Beispiel können Sie einen separaten Zeitplan für die Wintermonate mit der Eigenschaft customWeeks in der Methode addCalendar definieren:

var calendarId = gantt.addCalendar({
    id: "global", // optional
    worktime: {
        hours: ["8:00-17:00"],
        days: [1, 1, 1, 1, 1, 1, 1],
        customWeeks: {
            winter: {
                from: new Date(2018, 11, 1), // 1. Dezember 2018
                to: new Date(2019, 2, 1), // 1. März 2019
                hours: ["9:00-13:00", "14:00-16:00"],
                days: [1, 1, 1, 1, 0, 0, 0]
            }
        }
    },
});

Related sample:  Different worktimes for different time periods

Arbeitszeiten ändern

Um die Arbeitszeiten für bestimmte Tage in einem Kalender zu aktualisieren, verwenden Sie die Methode setWorkTime():

var calendar = gantt.getCalendar("custom");
calendar.setWorkTime({day: 6, hours: ["8:00-12:00"]});
calendar.setWorkTime({date: new Date(2021, 0, 1), hours: ["8:00-12:00"]});

Kalender abrufen

Sie können Kalenderobjekte zur weiteren Verwendung abrufen. Hier sind die verfügbaren Optionen:

Zugriff auf den globalen Gantt-Kalender

Um den globalen Gantt-Kalender abzurufen, verwenden Sie die Methode gantt.getCalendar():

var calendar = gantt.getCalendar(id);

Der standardmäßige globale Kalender kann mit der vordefinierten ID "global" abgerufen werden:

var globalSettings = gantt.getCalendar("global");

Dieser Kalender ist der Standard für Aufgaben, es sei denn, ein anderer Kalender wird angegeben.

Zugriff auf den Kalender einer Aufgabe

Um den Kalender abzurufen, der einer bestimmten Aufgabe zugewiesen ist, verwenden Sie die Methode gantt.getTaskCalendar(), indem Sie das Aufgabenobjekt übergeben:

var task = gantt.getTask(taskId);
 
var calendar = gantt.getTaskCalendar(task);
 
if (calendar.isWorkTime(date)) {
    alert("TaskWorkTime");
}

Related sample:  Task level calendars

Wenn die Arbeitszeit in der Gantt-Konfiguration deaktiviert ist, gibt die Methode einen 24/7-Arbeitszeitkalender zurück.

Verwendung globaler Methoden für Kalender

Gantt bietet globale Methoden, um Aufgabendauern zu berechnen oder Daten zu überprüfen, ohne direkt auf den Kalender einer Aufgabe zuzugreifen:

• gantt.isWorkTime:

if (gantt.isWorkTime({date: date, task: task})) {
    alert("work time of a task" + task.text);
}

Entspricht:

var calendar = gantt.getTaskCalendar(task);
if (calendar.isWorkTime({date: date})) {
    alert("work time of a task" + task.text);
}

• gantt.calculateEndDate:

var end_date = gantt.calculateEndDate({start_date: date, duration: duration, task: task});
 
// oder
var end_date = gantt.calculateEndDate(task);

• gantt.calculateDuration:

var duration = gantt.calculateDuration({start_date: start, end_date: end, task: task});
 
// oder
var duration = gantt.calculateDuration(task);

• gantt.getClosestWorkTime:

var closestTime = gantt.getClosestWorkTime({date: date, task: task});

Abrufen aller Gantt-Kalender

Um alle zu Gantt hinzugefügten Kalender (global und aufgabenbezogen) abzurufen, verwenden Sie die Methode gantt.getCalendars():

var calendars = gantt.getCalendars();

Diese Methode gibt ein Array von Kalenderobjekten zurück.

Kalender entfernen

Wenn ein Kalender nicht mehr benötigt wird, können Sie ihn mit der Methode gantt.deleteCalendar() entfernen. Übergeben Sie einfach die Kalender-ID:

// Hinzufügen eines Kalenders
gantt.addCalendar({
    id: "custom",
    worktime: {
        hours: ["8:00-17:00"],
        days: [1, 1, 1, 1, 1, 1, 1]
    }
});
 
// Löschen des Kalenders
gantt.deleteCalendar("custom");

Um einen Kalender einer Aufgabe zuzuweisen, fügen Sie zuerst den Kalender mit seiner ID und seinen Arbeitseinstellungen hinzu:

gantt.addCalendar({
    id: "custom", // optional
    worktime: {
        hours: ["8:00-17:00"],
        days: [1, 1, 1, 1, 1, 1, 1]
    }
});

Setzen Sie dann die Kalender-ID im "calendar_id" Attribut des Aufgabenobjekts:

{ 
  "id": 2, "calendar_id": "custom", "text": "Task #1", "start_date": "02-04-2019", 
  "duration": "8", "parent": "1", "progress": 0.5, "open": true
}

Falls erforderlich, können Sie den Namen der Aufgaben-Eigenschaft ändern, die den Kalender verknüpft, indem Sie die Option gantt.config.calendar_property verwenden:

gantt.config.calendar_property = "property_name";

Related sample:  Task level calendars

Sie können spezifische Arbeitskalender Aufgaben zuweisen, die bestimmte Ressourcen benötigen, wie Personen oder Ausrüstung. Beispielsweise möchten Sie möglicherweise, dass Aufgaben individuellen Kalendern folgen, basierend auf dem Benutzer, dem sie zugewiesen sind. So funktioniert es:

• Richten Sie zuerst eine Eigenschaft im Aufgabenobjekt ein, um eine Ressourcen-ID zu speichern, indem Sie die Konfigurationsattribut resource_property verwenden. Im folgenden Beispiel wird die Eigenschaft user verwendet, um Benutzer-IDs zu speichern:

gantt.config.resource_property = "user";

• Verwenden Sie dann die Konfigurationsoption resource_calendars, um Kalender für jeden Benutzer zu definieren. Diese Kalender werden in einem Objekt gruppiert.

gantt.config.resource_calendars = {
    1 : gantt.addCalendar({
        worktime: {
            days: [0, 1, 1, 1, 1, 1, 0]
        }
    }),
    2 : gantt.addCalendar({
        worktime: {
            days: [1, 0, 0, 0, 0, 0, 1]
        }   
    }),
    3 : gantt.addCalendar({
        worktime: {
            days: [0, 1, 1, 1, 0, 1, 1]
        }
    })
};

Dieses Objekt enthält Schlüssel-Wert-Paare, wobei der Schlüssel die Ressourcen-ID ist und der Wert die Kalender-ID, die von der Methode addCalendar zurückgegeben wird.

• Fügen Sie schließlich das user Attribut in Aufgabenobjekte ein. Verwenden Sie den Schlüssel aus dem Kalenderobjekt, das in der Konfigurationsoption resource_calendars erstellt wurde, als Wert für dieses Attribut:

{ "id":1, "user":"1", "text":"Project #2", "start_date":"01-04-2019", "duration":"5" },
{ "id":2, "user":"0", "text":"Task #1", "start_date":"02-04-2019", "duration":"2" },
{ "id":3, "user":"2", "text":"Task #2", "start_date":"11-04-2019", "duration":"4" },
{ "id":4, "user":"3", "text":"Task #3", "start_date":"13-04-2019", "duration":"3" },
{ "id":5, "user":"0", "text":"Task #1.1", "start_date":"02-04-2019", "duration":"7" },
{ "id":6, "user":"1", "text":"Task #1.2", "start_date":"03-04-2019", "duration":"7" }

Related sample:  Resource level calendars

Mehrere Kalender zusammenführen

Ab Version 7.0 können Sie mehrere Kalender zu einem zusammenführen. Beispielsweise, wenn zwei Ressourcen mit unterschiedlichen Arbeitszeiten derselben Aufgabe zugewiesen sind, können deren Arbeitszeiten zu einem einzigen Kalender kombiniert werden. Zum Beispiel, wenn eine Ressource von 9:00 bis 15:00 arbeitet und eine andere von 12:00 bis 17:00, deckt der zusammengeführte Kalender 12:00 bis 15:00 ab.

Um diese Funktion automatisch zu aktivieren, setzen Sie die Konfiguration dynamic_resource_calendars auf true:

gantt.config.dynamic_resource_calendars = true;

Related sample:  Merge work Calendars of different resources

Alternativ können Sie Kalender manuell mit der Methode mergeCalendars zusammenführen:

const johnCalendarId = gantt.addCalendar({
    worktime: {
        hours: ["0:00-24:00"],
        days: [0, 1, 1, 1, 1, 1, 0]
    }
});
const mikeCalendarId = gantt.addCalendar({
    worktime: {
        hours: ["8:00-12:00", "13:00-17:00"],
        days: [0, 1, 1, 1, 1, 1, 0]
    }
});
 
const joinedCalendar = gantt.mergeCalendars(
    gantt.getCalendar(mikeCalendarId),
    gantt.getCalendar(johnCalendarId)
);

Details zur Zusammenführung von Arbeitszeiten finden Sie im Artikel mergeCalendars().

Sie können auch einem Projekt einen Arbeitskalender zuweisen, sodass Aufgaben den Kalender ihres übergeordneten Projekts erben. So funktioniert es:

• Wenn einem Teilprojekt ein Kalender zugewiesen ist, folgen alle seine Aufgaben diesem Kalender, es sei denn, eine Aufgabe hat ihren eigenen Kalender zugewiesen.
• Wenn eine Aufgabe ihren eigenen Kalender hat, verwendet sie diesen anstelle des Projektkalenders.

Um diese Funktion zu aktivieren, setzen Sie die Konfigurationsoption inherit_calendar auf true. Standardmäßig ist diese Option deaktiviert.

gantt.config.inherit_calendar = true;

• Wenn auf true gesetzt, erben Aufgaben ohne spezifischen Kalender den Kalender ihres übergeordneten Projekts (das möglicherweise auch von seinem übergeordneten Projekt erbt).
• Wenn auf false gesetzt, verwenden Aufgaben ohne spezifischen Kalender den globalen Kalender.

Im folgenden Beispiel erben Aufgaben standardmäßig Kalender von ihren übergeordneten Projekten. Wenn jedoch einer Aufgabe ein eigener Kalender zugewiesen ist, verwendet sie diesen stattdessen. Zum Beispiel verwenden die Aufgaben #2.2 und #3 die "Vollwoche"-Kalender anstelle des Kalenders ihres übergeordneten Projekts:

Related sample:  Project level calendars

Ab Version 7.0 erkennt Gantt automatisch Änderungen am Kalender einer Aufgabe und berechnet den Zeitplan der Aufgabe neu.

Wenn nötig, können Sie jedoch den Zeitplan der Aufgabe manuell aktualisieren, wenn sich ihr Kalender ändert. Beispielsweise möchten Sie den Zeitplan aktualisieren, wenn ein Kalender über die Lightbox geändert wird:

function updateTaskTiming(task) {
  task.start_date = gantt.getClosestWorkTime({
     dir: "future",
     date: task.start_date,
     unit: gantt.config.duration_unit,
     task: task
  });
  task.end_date = gantt.calculateEndDate(task);
}
 
gantt.attachEvent("onLightboxSave", function(id, task, is_new){
  updateTaskTiming(task);
  return true;
});

Alternativ können Sie eine Neuberechnung für alle Aufgaben definieren, wenn dies erforderlich ist:

gantt.batchUpdate(function(){
  gantt.eachTask(function(task){
    task.start_date = gantt.getClosestWorkTime({
      dir: "future",
      date: task.start_date,
      unit: gantt.config.duration_unit,
      task: task
    });
    task.end_date = gantt.calculateEndDate(task);
    gantt.updateTask(task.id);
  });
});