Export und Import aus Primavera P6

Die dhtmlxGantt-Bibliothek ermöglicht das Exportieren von Daten aus dem Gantt-Diagramm nach Primavera P6. Sie können außerdem Daten aus Primavera P6 in Gantt importieren.

Hinweis

Der Dienst ist kostenlos, aber die Ausgabedatei enthält das Wasserzeichen der Bibliothek. Um ohne Wasserzeichen zu exportieren, benötigen Sie eine gültige Lizenz - das Exportergebnis wird während der gültigen Support-Periode (12 Monate für alle PRO-Lizenzen) ohne Wasserzeichen verfügbar sein.

Es gibt mehrere Exportdienste. Sie können sie lokal auf Ihrem Computer installieren und das Gantt-Diagramm lokal nach Primavera P6 exportieren. Beachten Sie, dass Exportdienste nicht im Gantt-Paket enthalten sind; lesen Sie den [entsprechenden Artikel], um die Nutzungsbedingungen jedes einzelnen Dienstes zu erfahren.

Einschränkungen des Online-Exportdienstes

Hinweis

Der Exportdienst hat Zeit- und Größenbeschränkungen für Anfragen.

Zeitlimits

Falls der Prozess länger als 20 Sekunden dauert, wird der Export abgebrochen und folgender Fehler tritt auf:

Error: Timeout trigger 20 seconds

Wenn mehrere Personen gleichzeitig Gantt exportieren, kann der Prozess länger dauern als üblich. Das ist jedoch unproblematisch, da die für einen bestimmten Benutzer aufgewendete Exportanforderung separat gezählt wird.

Begrenzung der Anfragengröße

Es gibt einen gemeinsamen API-Endpunkt https://export.dhtmlx.com/gantt, der alle Exportmethoden bedient (exportToPDF, exportToPNG, exportToMSProject, etc.). Maximale Anfragengröße ist 10 MB.

Es gibt zudem einen separaten API-Endpunkt https://export.dhtmlx.com/gantt/project, der speziell für die MSProject und Primavera P6 Export/Import-Dienste (exportToMSProject / importFromMSProject / exportToPrimaveraP6 / importFromPrimaveraP6 nur). Maximale Anfragengröße: 40 MB.

Verwendung von Export-Modulen

Hinweis

Wenn Sie große Diagramme exportieren müssen, können Sie ein Standalone-Exportmodul verwenden. Das Exportmodul ist kostenlos, wenn Sie Gantt unter einer der Lizenzen Commercial, Enterprise oder Ultimate erworben haben, oder Sie können das Modul auch separat kaufen.

Weitere Informationen zur Nutzung des Exportmoduls für MS Project lesen. Dieses Exportmodul bietet Export/Import-Funktionalität für MS Project und Primavera P6.

Export nach Primavera P6

Die Gantt-Komponente ermöglicht das Exportieren von Verknüpfungen, Aufgaben und Ressourcen nach Primavera P6.

Um Daten aus dem Gantt-Diagramm nach Primavera P6 zu exportieren, führen Sie Folgendes aus:

• Um die Export/Import-Funktionalität zu verwenden, aktivieren Sie das export_api-Plugin über die Plugins-Methode:

gantt.plugins({
    export_api: true
});

Dadurch können Sie entweder den Online-Exportdienst oder ein lokales Exportmodul verwenden.

Hinweis

Wenn Sie eine Gantt-Version älter als 8.0 verwenden, müssen Sie https://export.dhtmlx.com/gantt/api.js auf Ihrer Seite einbinden, um die Exportfunktionalität zu aktivieren, z.B.:

<script src="codebase/dhtmlxgantt.js"></script>
<script src="https://export.dhtmlx.com/gantt/api.js"></script>

• Rufen Sie die Methode exportToPrimaveraP6() auf, um Daten aus dem Gantt-Diagramm zu exportieren.

gantt.exportToPrimaveraP6();

Die Methode sendet eine Anfrage an den Remote-Service, der entweder eine XML-Projekt-Datei ausgibt oder eine URL zum Herunterladen einer generierten Datei zurückgibt.

Zugehöriges Beispiel: Export data : MS Project, PrimaveraP6, Excel & iCal

Beachten Sie, dass beim Export von Daten nach Primavera Sie für die Eigenschaft Summary des Projekts true zurückgeben müssen, damit diese Funktion korrekt funktioniert:

gantt.exportToPrimaveraP6({
  tasks: {
    Summary: function (task) {
      return !!gantt.hasChild(task.id);
    },
    CustomProperty: function (task) {
      return task.custom_property;
    },
    SlateId: function (task) {
      return task.id + "";
    },
  }
});

Zugehöriges Beispiel: Custom properties for WBS tasks (PrimaveraP6's Summary tasks)

Exporteinstellungen

Die Methode exportToPrimaveraP6() nimmt als Parameter ein Objekt mit mehreren Eigenschaften (alle Eigenschaften sind optional):

• name - (string) der Name der erhaltenen Datei ('gantt.xml' standardmäßig).

gantt.exportToPrimaveraP6({
    name:'custom.xml'
});

• auto_scheduling - (boolean) gibt den Planungsmodus für Aufgaben im exportierten Projekt an. true markiert Aufgaben als auto geplant, false markiert Aufgaben als manuell geplant (Standardzustand).

gantt.exportToPrimaveraP6({
    auto_scheduling: false
});

• skip_circular_links - (boolean) gibt an, ob zirkuläre Verknüpfungen entfernt werden sollen (true – werden entfernt (Standardmodus), false – werden nicht entfernt).

gantt.exportToPrimaveraP6({
    skip_circular_links: false
});

• project - (object) ermöglicht das Festlegen benutzerdefinierter Eigenschaften des exportierten Projekt-Objekts

gantt.exportToPrimaveraP6({
    project: {
        'Author': 'I am!',
        'MinutesPerDay': function () {
            return gantt.config.hours_per_day * 60;
        }
    }
});

Die Eigenschaften dieses Objekts entsprechen den entsprechenden Eigenschaften der Project entity. Die Liste der unterstützten Eigenschaften finden Sie hier. Die Eigenschaften können feste Werte oder Funktionen enthalten, die beim Aufruf des Exports ausgeführt werden.

• tasks - (object) ermöglicht das Festlegen benutzerdefinierter Eigenschaften für die exportierten Task-Einträge

gantt.exportToPrimaveraP6({
   tasks: {
        'StartVariance': function (task) {
           if (task.startVariance)
               return task.startVariance;
           else
               return 0;
        },
        'PercentWorkComplete': function (task) {
           return (task.progress + 0.1);
        },
        'Custom': function (task) {
           return 'Custom value';
        },
        'Custom 2': 'My Custom value'
    }
});

Die Eigenschaften dieses Objekts entsprechen den entsprechenden Eigenschaften der Task entity, hier finden Sie eine Liste der unterstützten Eigenschaften. Die Eigenschaften können feste Werte oder Funktionen enthalten, die für jeden Datensatz beim Export aufgerufen werden.

• data - (object) ermöglicht das Festlegen einer benutzerdefinierten Datenquelle, die in der Output-Gantt-Diagramm angezeigt wird.

Hinweis

Es wird erwartet, dass die Eigenschaften start_date und end_date im Format angegeben werden, das Datum und Uhrzeit enthält (%d-%m-%Y %H:%i).

const customData = {
    "data": [
        { "id": "10", "text": "Project #5", "start_date": "01-04-2025 00:00", 
            "duration": 3, "order": 10, "progress": 0.4, "open": true, 
            "end_date": "04-04-2025 00:00", "parent": 0 
        },
        { "id": "1", "text": "Task #67", "start_date": "02-04-2025 00:00", 
            "duration": 2, "order": 10, "progress": 0.6, "parent": "10", 
            "end_date": "04-04-2025 00:00" 
        },
        { "id": "2", "text": "Task #89", "start_date": "01-04-2025 00:00", 
            "duration": 2, "order": 20, "progress": 0.6, "parent": "10", 
            "end_date": "03-04-2025 00:00" 
        },
    ],
    "links": [
        { "id": 1, "source": 1, "target": 2, "type": "1" },
    ]
}

gantt.exportToPrimaveraP6({
    data: customData
});

Zugehöriges Beispiel: Gantt. Export benutzerdefinierter Daten

• callback - (function) Wenn Sie eine URL zum Herunterladen einer generierten XML-Datei erhalten möchten, kann die callback-Eigenschaft verwendet werden. Sie erhält ein JSON-Objekt mit der Eigenschaft url:

gantt.exportToPrimaveraP6({
    callback: function(res){
        alert(res.url);
    }
});

• resources - (array) ermöglicht das Exportieren der Liste von Ressourcen in eine Primavera P6-Datei

gantt.exportToPrimaveraP6({
    resources: [
        { "id": "1", "name": "John", "type": "work" },
        { "id": "2", "name": "Mike", "type": "work" },
        { "id": "3", "name": "Anna", "type": "work" }
    ]
});

Mögliche Ressourcentypen sind "work", "cost", "material". Zuweisungen von Ressourcen werden über die Eigenschaft ResourceAssignments der Aufgaben-Konfiguration festgelegt:

var users = [// resources
    { key: '0', label: "N/A" },
    { key: '1', label: "John" },
    { key: '2', label: "Mike" },
    { key: '3', label: "Anna" }
];

gantt.exportToPrimaveraP6({
    resources: users
        .filter(function(u){
            if(u.key === '0')//skip the default option 
                return false;
            return true;
        })
        .map(function(u){
            return {
                id: u.key,
                name: u.label,
                type: "work"
               };
          }),
    tasks: {
        ResourceAssignments: function(task){  
            return task.user;                   
        }                                       
    }
});

Die ResourceAssignments-Eigenschaft ist als Funktion definiert, die das Task-Objekt als Parameter entgegennimmt und entweder einen String/Number-Wert oder ein Array von Strings/Numbers zurückgibt:

tasks: {
    ResourceAssignments: function(task){
        return [task.user, task.office];
    }
}

Zugehöriges Beispiel: Export Gantt mit Ressourcen nach Primavera P6

Es ist möglich, den Parameter units für ResourceAssignments durch Zurückgabe des folgenden Objekts in der ResourceAssignments-Eigenschaft festzulegen:

{
    resource_id: "id",
    units: "units value"
}

• resource calendars

Standardmäßig hat jede Aufgabe einen Kalender. Wenn die Ressourcenkalender verwendet werden, müssen Sie -1 für eine Aufgabe in der CalendarUID-Eigenschaft während des Exports angeben (im Objekt tasks) . Dann verwendet die Aufgabe den Ressourcen-Kalender.

Beim Export von Resource Calendars ist es möglich, den Ressourcen-Kalender in einem Objekt des Arrays resources anzugeben:

gantt.exportToPrimaveraP6({
    resources: [
        {
            id: "10",
            name: "John",
            type: "work",
            calendar: gantt.config.resource_calendars[10]
        }
    ]
});    

• server - (string) der API-Endpunkt für die Anforderung. Kann mit der lokalen Installation des Exportdienstes verwendet werden. Der Standardwert ist https://export.dhtmlx.com/gantt.

gantt.exportToPrimaveraP6({
    server: "https://myapp.com/myexport/gantt"
});

Import aus Primavera P6

Um eine XML- oder XER-Datei zu konvertieren, senden Sie die folgende Anfrage an den Exportdienst:

• Request URL - https://export.dhtmlx.com/gantt
• Request Method - POST
• Content-Type - multipart/form-data

Die Request-Parameter sind:

• file - eine XER- oder XML-Datei von Primavera P6
• type - "primaveraP6-parse"
• data - (optional) ein JSON-String mit Einstellungen

Zum Beispiel:

<form action="https://export.dhtmlx.com/gantt" method="POST" 
    encType="multipart/form-data">
    <input type="file" name="file" />
    <input type="hidden" name="type" value="primaveraP6-parse"/>
    <button type="submit">Get</button>
</form>

Alternativ können Sie die client-side API verwenden, wie hier:

gantt.importFromPrimaveraP6({
    data: file,
    taskProperties: ["Notes", "Name"],
    callback: function (project) {
        if (project) {
            gantt.clearAll();
            if (project.config.duration_unit) {
                gantt.config.duration_unit = project.config.duration_unit;
            }                    
            gantt.parse(project.data);
        }
    }
});

Zugehöriges Beispiel: Import Primavera P6-Datei

Wobei file eine Instanz von File ist und entweder eine XML- oder XER-Project-Datei enthalten sollte.

Hinweis

gantt.importFromPrimaveraP6 erfordert Unterstützung der HTML5 File API.

Response

Die Antwort enthält JSON mit folgender Struktur:

{
    data: {},
    config: {},
    resources: [],
    worktime: {},
    calendars: []
}

• data - (object) ein Gantt data object. Jede Aufgabe besitzt folgende Eigenschaften: id, open, parent, progress, start_date, text, resource. Dates werden im Format "%Y-%m-%d %H:%i" als Strings angegeben.
• config - (object) ein Gantt Configuration-Objekt mit aus der Projektdatei stammenden Einstellungen.
• resources - (array) ein Array von Objekten (jeweils mit den Eigenschaften: (id: string, name: string, type: string, calendar: string)), das die Liste der Ressourcen aus der Projektdatei repräsentiert.
• worktime - (object) ein Objekt, das die Arbeitszeit-Einstellungen aus dem Projektkalender enthält. Es kann die folgenden Attribute enthalten:
  • id - (string | number) optional, die Kalender-ID
  • hours - (array) ein Array mit globalen Arbeitszeiten, setzt die Start- und Endzeiten der Aufgabe
  • dates - (array) ein Array von Daten, das Folgendes enthalten kann:
    • 7 Tage der Woche (von 0 - Sonntag bis 6 - Samstag), wobei 1/true für einen Arbeitstag steht und 0/false für einen Nicht-Arbeitstag
    • andere Datensätze sind Daten
• calendars - (array) ein Array mit Kalenderkonfigurationsobjekten zur Erstellung eines neuen Kalenders.
  • calendarConfig - (object) ein Kalender-Konfigurationsobjekt, das folgende Attribute enthalten kann:
    • id - (string | number) optional, die Kalender-ID
    • name - (string) der Kalendername
    • hours - (array) ein Array mit globalen Arbeitszeiten, setzt die Start- und Endzeiten der Aufgabe
    • dates - (array) ein Array von Daten, das Folgendes enthalten kann:
      • 7 Tage der Woche (von 0 - Sonntag bis 6 - Samstag), wobei 1/true für einen Arbeitstag steht und 0/false - ein Nicht-Arbeitstag
      • andere Datensätze sind Daten

Import-Einstellungen

Festlegung der Dauer-Einheit

Um eine erwartete Dauer-Einheit festzulegen, kann der durationUnit-String ("minute", "hour", "day", "week", "month", "year") auch an den Server gesendet werden.

<form action="https://export.dhtmlx.com/gantt" method="POST" 
    encType="multipart/form-data">
    <input type="file" name="file" />
    <input type="hidden" name="type" value="primaveraP6-parse"/>
    <input type="hidden" name="data" 
        value="{ "durationUnit": "hour" }" />
    <button type="submit">Get</button>
</form>

oder

gantt.importFromPrimaveraP6({
    data: file,
    durationUnit: "hour",
    callback: function(project){}
});

Abrufen von Eigenschaften des Projekts

Um Felder des Projekts abzurufen, kann die Eingabe projectProperties mit einem Array der benötigten Felder an den Server gesendet werden. Sie extrahiert beliebige Eigenschaften der Project entity in die config-Eigenschaft der Ausgabe. Hier ist die Liste der unterstützten Eigenschaften.

• projectProperties - gibt ein Array von Projekt-Eigenschaften an, die in die Antwort aufgenommen werden sollen.

<form action="https://export.dhtmlx.com/gantt" method="POST" 
    encType="multipart/form-data">
    <input type="file" name="file" />
    <input type="hidden" name="type" value="primaveraP6-parse"/>
    <input type="hidden" name="data" 
        value="{ "projectProperties": ["Author", "Title"] }" />
    <button type="submit">Get</button>
</form>

oder

gantt.importFromPrimaveraP6({
    data: file,
    durationUnit: "hour",
    projectProperties: ["Author", "Title"],
    callback: function(project){
        var config = project.config;
        alert(config.$custom_properties.Author);
    }
});

Abrufen von Aufgaben-Eigenschaften

Um Felder der Aufgaben abzurufen, kann die Eingabe taskProperties mit einem Array der benötigten Felder an den Server gesendet werden. Sie extrahiert beliebige Eigenschaften der Task entities. Hier ist die Liste der unterstützten Eigenschaften:

• taskProperties - geben Sie ein Array zusätzlicher Aufgaben-Eigenschaften an, die importiert werden sollen.

<form action="https://export.dhtmlx.com/gantt" method="POST" 
    encType="multipart/form-data">
    <input type="file" name="file" />
    <input type="hidden" name="type" value="primaveraP6-parse"/>
    <input type="hidden" name="data" 
        value="{ "taskProperties": ["Contact", "Priority"] }" />
    <button type="submit">Get</button>
</form>

oder

gantt.importFromPrimaveraP6({
    data: file,
    durationUnit: "hour",
    taskProperties: ["Contact", "Priority"],
    callback: function(project){
        var config = project.config;
        alert(config.$custom_properties.Author);
        gantt.parse(project.data);
    }
});
gantt.attachEvent("onTaskLoading", function(task) {
    if (task.$custom_data) {
        task.contact = task.$custom_data["Contact"];
        task.priority = task.$custom_data["priority"];
        delete task.$custom_data;
    }
    return true;
});

Abholen von Aufgabentypen

Die folgende Logik ermöglicht das Erhalten des Aufgabentyps: Aufgaben des Typs Project haben die Eigenschaft Summary: "1" und Aufgaben des Typs Milestone haben die Eigenschaft Milestone: "1". Wir müssen die Daten mit diesen Eigenschaften importieren und dann den Aufgabentyp basierend auf diesen Eigenschaften setzen.

Der Aufruf der Import-Funktion sieht wie folgt aus:

gantt.importFromPrimaveraP6({
    data: file,
    taskProperties: [
        "Summary", 
        "Milestone",
    ],
    callback: function (project) {
        if (project) {
            console.log(project)
            gantt.clearAll();
            if (project.config.duration_unit) {
                gantt.config.duration_unit = project.config.duration_unit;
            }
            console.log('import: ', project.data);
            gantt.parse(project.data);
        }
    }
});

Anschließend können Sie die Typen der Aufgaben anhand der erhaltenen Eigenschaften wie folgt konvertieren:

gantt.attachEvent("onTaskLoading", function (task) {
    if (task.$custom_data) {
        if (task.$custom_data.Summary == "1") {
            task.type = "project";
        }
        if (task.$custom_data.Milestone == "1") {
            task.type = "milestone";
        }
        // delete task.$custom_data;
    }
    return true;
});

Zugehöriges Beispiel: Gantt. Import Primavera P6-Dateien. Aufgabentyp aus Eigenschaften abrufen

Export/Import von Primavera P6 Aktivitätstypen

Primavera P6 verwendet Aufgabentypen, die sich von den im Gantt-Diagramm verwendeten Aufgabentypen und von MS Project unterscheiden. Um die Information über den ursprünglichen Primavera P6-Typ zu erhalten, verwenden Sie die Aufgaben-Eigenschaft ActivityType beim Import/Export von Dateien. Da ActivityType eine benutzerdefinierte Eigenschaft für Gantt ist, beeinflusst sie nicht den Aufgabentyp auf der Gantt-Seite.

Die Eigenschaft ActivityType unterstützt die vollständige Liste der Primavera P6-Aktivitätstypen. Der beim Import zurückgegebene Wert liegt in PascalCase vor, während beim Export sowohl die PascalCase- als auch die UPPER_SNAKE_CASE-Form akzeptiert werden:

Wert	Beschreibung
TaskDependent / TASK_DEPENDENT	Eine reguläre Aufgabe, die anhand ihrer Vorgänger-Aufgaben geplant wird
ResourceDependent / RESOURCE_DEPENDENT	Eine reguläre Aufgabe, die anhand des Ressourcenkalenders geplant wird (wird standardmäßig verwendet, wenn ActivityType nicht angegeben ist)
StartMilestone / START_MILESTONE	Ein Meilenstein, der den Beginn einer Aktivität markiert
FinishMilestone / FINISH_MILESTONE	Ein Meilenstein, der das Ende einer Aktivität markiert
WbsSummary / WBS_SUMMARY	Eine WBS-Zusammenfassungsaufgabe
LevelOfEffort / LEVEL_OF_EFFORT	Eine Aufgabe, deren Dauer von den Aktivitäten bestimmt wird, die sie unterstützt
Hammock / HAMMOCK	Eine Aufgabe, deren Dauer vom Beginn der ersten verknüpften Aktivität bis zum Ende der letzten reicht
StartFlag / START_FLAG	Eine Flag-Aktivität, die einen bestimmten Punkt am Anfang des Projekts markiert
FinishFlag / FINISH_FLAG	Eine Flag-Aktivität, die einen bestimmten Punkt am Ende des Projekts markiert

Unterstützung für Primavera P6 Meilenstein-Typen

Bemerkenswert ist, dass die oben aufgeführten Typen Start Milestone und Finish Milestone auf der Gantt-Seite keine separaten Entsprechungen haben. Die dhtmlxGantt-Bibliothek unterstützt nur einen einzigen Meilenstein-Aufgabentyp, der dem Typ Finish Milestone von Primavera P6 entspricht. Beim Import eines Primavera P6-Projekts in Gantt werden daher alle Meilensteine (unabhängig davon, ob es sich in der Quelldatei um Start- oder Finish-Meilensteine handelt) in Aufgaben vom Typ milestone umgewandelt.

Um die Information über den ursprünglichen Primavera P6-Meilenstein-Typ zu erhalten, verwenden Sie die Aufgaben-Eigenschaft ActivityType beim Import, indem Sie sie zum Array taskProperties hinzufügen. Die Eigenschaft wird im $custom_data-Objekt jeder Aufgabe zurückgegeben. Kopieren Sie sie daher im Ereignis onTaskLoading in die Aufgabe selbst:

gantt.importFromPrimaveraP6({
    data: file,
    taskProperties: ["ActivityType"],
    callback: function (project) {
        if (project) {
            gantt.clearAll();
            gantt.parse(project.data);
        }
    }
});

gantt.attachEvent("onTaskLoading", function (task) {
    if (task.$custom_data) {
        task.ActivityType = task.$custom_data.ActivityType;
    }
    return true;
});

Bei Meilensteinen speichert die Eigenschaft den ursprünglichen Primavera P6-Typ als String, z. B. "StartMilestone" oder "FinishMilestone". Da ActivityType den Aufgabentyp auf der Gantt-Seite nicht beeinflusst, behält die Aufgabe weiterhin den Typ milestone. Sie können diese Eigenschaft beispielsweise nutzen, um das Erscheinungsbild von Start- und Finish-Meilensteinen im Gantt-Diagramm anzupassen.

Um beim Export der Daten zurück nach Primavera P6 den ursprünglichen Aufgabentyp zu übernehmen, geben Sie ihn über die Eigenschaft ActivityType im Objekt tasks des Aufrufs exportToPrimaveraP6() zurück. Da ActivityType alle Primavera P6-Aktivitäten beschreibt und nicht nur Meilensteine, geben Sie auch für die übrigen Aufgabentypen einen Wert zurück:

gantt.exportToPrimaveraP6({
    tasks: {
        ActivityType: function (task) {
            if (task.type == "milestone") {
                return task.ActivityType == "StartMilestone" ? "START_MILESTONE" : "FINISH_MILESTONE";
            }
            if (task.type == "project") {
                return "WBS_SUMMARY";
            }
            return "TASK_DEPENDENT";
        }
    }
});

Auf diese Weise erhält die exportierte Datei denselben Typ Start Milestone / Finish Milestone wie die ursprüngliche Primavera P6-Datei, anstatt dass jeder Meilenstein standardmäßig als Finish Milestone exportiert wird.

Zugehöriges Beispiel: Gantt. Import und Export von Primavera P6-Dateien mit ActivityType zur Ermittlung von Start- und Finish-Meilensteinen

Hinzufügen und Anpassen von Kalendern

Beachten Sie, dass Kalender beim Import nicht automatisch hinzugefügt werden. Sie müssen sie mit der Methode addCalendar() hinzufügen. Danach sollten Sie die Kalendereinstellungen über die Methode setWorkTime() festlegen. Zum Beispiel:

gantt.importFromPrimaveraP6({
    data: file,
    taskProperties: ["Notes", "Name"],
    callback: function (project) {
        if (project) {
            // Einstellungen zum Hinzufügen von Kalendern
            project.calendars.forEach(function (calendar) {
                let addedCalendar;
                // Arbeitszeiteinstellungen für den globalen Kalender hinzufügen
                if (calendar.id == project.config.global_calendar_id) {
                    addedCalendar = gantt.getCalendar("global");
                }
                else {
                    // Gantt fügt keinen Kalender hinzu 
                    // wenn der `hours`-Parameter ein leeres Array ist
                    let calendarHours = calendar.hours;
                    if (!calendarHours.length) {
                        calendarHours = undefined
                    }
                    gantt.addCalendar({
                        id: calendar.id,
                        hours: calendarHours,
                        name: calendar.name
                    });

                    addedCalendar = gantt.getCalendar(calendar.id);
                }
                const worktimeDates = calendar.dates;
                for (let element in worktimeDates) {
                    const date = new Date(+element)
                    if (element < 10) {
                        addedCalendar.setWorkTime({ 
                            day: element, 
                            hours: worktimeDates[element] 
                        })
                    }
                    else {
                        addedCalendar.setWorkTime({ 
                            date: date, 
                            hours: worktimeDates[element] 
                        })
                    }
                }
            })
        }
    }
});

Zugehöriges Beispiel: Gantt. Kalendereinstellungen für Export/Import in MSProject und Primavera P6

Ressourcenkalender

Wenn es Ressourcenkalender gibt, müssen Sie diese über die Eigenschaft gantt.config.resource_calendars festlegen:

gantt.importFromPrimaveraP6({
    data: file,
    taskProperties: ["Notes", "Name"],
    callback: function (project) {
        if (project) {
            // Kalendereinstellungen
            project.calendars.forEach(function (calendar) {
                // Kalender hinzufügen und Arbeitszeiteinstellungen setzen
            })

            // Einstellungen für Ressourcenkalender
            gantt.config.resource_calendars = {}

            project.resources.forEach(function (resource) {
                if (resource.calendar) {
                    gantt.config.resource_calendars[resource.id] = resource.calendar;
                }
            })
        }
    }
});

Zugehöriges Beispiel: Gantt. Ressourcenkalender-Einstellungen für Export/Import in MSProject und Primavera P6

Ressourcen und Ressourcen-Zuweisungen

Wenn es Ressourcen in der Datei gibt, gelangen sie beim Import in das Array resources. Der Parameter calendar des Eigenschaftsobjekts resources gibt den Ressourcen-Kalender an:

{
    resources: [
        { id: 6, name: "John", type: "work", calendar: "8" },
        // weitere Ressourcen
    ]
}

Falls es Ressourcen-Zuweisungen gibt, werden sie im Array assignments importiert, wobei das Zuweisungsobjekt die Parameter resource_id: string und value: number enthält. Zum Beispiel:

{
    tasks: [
        {
            id: 5,
            text: "Interior office",
            type: "task",
            start_date: "03-04-2024 00:00",
            duration: 7,
            parent: "2",
            priority: 1
        },
        // weitere Aufgaben
    ],
    links: [],
    assignments: [
        { id: 1, task_id: 5, resource_id: 6, value: 3},
        // weitere Zuweisungen
    ],
    resources: [
        { id: 6, text: "John", unit: "hours/day" },
        { id: 7, text: "Mike", unit: "hours/day" },
        // weitere Ressourcen
    ]
}

Grenzen bei der Anfragengröße und Import großer Dateien

Es gibt zwei API-Endpunkte für die Primavera P6 Export/Import-Dienste:

• https://export.dhtmlx.com/gantt - der Standard-Endpunkt, der alle Exportmethoden bedient (exportToPDF, exportToPNG, exportToPrimaveraP6, etc.). Maximale Anfragengröße 10 MB.
• https://export.dhtmlx.com/gantt/project - der Endpunkt, der speziell für die MSProject und Primavera P6 Export/Import-Dienste (exportToMSProject / importFromMSProject / exportToPrimaveraP6 / importFromPrimaveraP6 nur). Maximale Anfragengröße: 40 MB.

Der Endpunkt kann durch die Eigenschaft server des Export-Konfigurationsobjekts festgelegt werden:

gantt.importFromPrimaveraP6({
    server: "https://export.dhtmlx.com/gantt",
    data: file,
    callback: function(project){
       // some logic
    }
}); 

Wenn kein Endpunkt angegeben wird, gilt standardmäßig https://export.dhtmlx.com/gantt. Der folgende Aufruf entspricht dem oben Gezeigten:

gantt.importFromPrimaveraP6({
    data: file,
    callback: function(project){
       // some logic
    }
});

Um große Projekte zu exportieren oder zu importieren, die die 4 MB-Grenze überschreiten, kann der zweite Endpunkt verwendet werden:

gantt.importFromPrimaveraP6({
    server: "https://export.dhtmlx.com/gantt/project",
    data: file,
    callback: function(project){
       // some logic
    }
}); 

Dieser Endpunkt ermöglicht das Senden von Anfragen bis zu 40 MB und unterstützt Primavera P6 Exporte und Importe. Er kann ausschließlich für Primavera P6-Exporte verwendet werden.

Andere Methoden, zum Beispiel gantt.exportToPDF({server:"https://export.dhtmlx.com/gantt/project"}), sollten dagegen einen Serverfehler zurückgeben.