ProjectModel

Enables early rendering in SchedulerPro, by postponing calculations to after the first refresh.

Requires event data loaded to be pre-normalized to function as intended, since it will be used to render before engine has normalized the data. Given un-normalized data events will snap into place when calculations are finished.

The Gantt chart will be read-only until the initial calculations are finished.

Set to true to enable calculation progress notifications. When enabled the project fires progress event.

Note: Enabling progress notifications will impact calculation performance, since it needs to pause calculations to allow redrawing the UI.

Maximum range the project calendars can iterate. The value is defined in milliseconds and by default equals 5 years roughly.

new SchedulerPro({
    project : {
        // adjust calendar iteration limit to 10 years roughly:
        // 10 years expressed in ms
        maxCalendarRange : 10 * 365 * 24 * 3600000,
        ...
    }
});

Setting this to true (default) vetoes silenceInitialCommit effect by preventing silent changes accepting on initial data loading if some scheduling issue gets resolved during it.

Enabling this config allows an application to persist the data in a resolved state.

Set to true to reset the undo/redo queues of the internal StateTrackingManager after the Project has loaded. Defaults to false

Silences propagations caused by the project loading.

Applying the loaded data to the project occurs in two basic stages:

1. Data gets into the engine graph which triggers changes propagation
2. The changes caused by the propagation get written to related stores

Setting this flag to true makes the component perform step 2 silently without triggering events causing reactions on those changes (like sending changes back to the server if autoSync is enabled) and keeping stores in unmodified state.

This is safe if the loaded data is consistent so propagation doesn't really do any adjustments. By default the system treats the data as consistent so this option is true.

new SchedulerPro{
    project : {
        // We want scheduling engine to recalculate the data properly
        // so then we could save it back to the server
        silenceInitialCommit : false,
        ...
    }
    ...
})

Data use to fill the assignmentStore. Should be an array of AssignmentModels or its configuration objects.

Data use to fill the eventStore. Should be a CalendarModel array or its configuration objects.

Data use to fill the dependencyStore. Should be an array of DependencyModels or its configuration objects.

Data use to fill the eventStore. Should be an array of EventModels or its configuration objects.

Data use to fill the resourceStore. Should be an array of ResourceModels or its configuration objects.

Data use to fill the resourceTimeRangeStore. Should be an array of ResourceTimeRangeModels or its configuration objects.

Data use to fill the timeRangeStore. Should be an array of TimeSpans or its configuration objects.

The initial data, to fill the assignmentStore with. Should be an array of AssignmentModels or its configuration objects.

The initial data, to fill the calendarManagerStore with. Should be an array of CalendarModel or it's configuration objects.

The initial data, to fill the dependencyStore with. Should be an array of DependencyModels or its configuration objects.

The initial data, to fill the eventStore with. Should be an array of EventModels or its configuration objects.

The initial data, to fill the resourceStore with. Should be an array of ResourceModels or its configuration objects.

The constructor of the assignment model class, to be used in the project. Will be set as the modelClass property of the assignmentStore

An AssignmentStore instance or a config object.

The constructor to create an assignment store instance with. Should be a class, subclassing the AssignmentStore

A CalendarManagerStore instance or a config object.

The constructor to create a calendar store instance with. Should be a class, subclassing the CalendarManagerStore

The constructor of the calendar model class, to be used in the project. Will be set as the modelClass property of the calendarManagerStore

The constructor of the dependency model class, to be used in the project. Will be set as the modelClass property of the dependencyStore

A DependencyStore instance or a config object.

The constructor to create a dependency store instance with. Should be a class, subclassing the DependencyStore

The constructor of the event model class, to be used in the project. Will be set as the modelClass property of the eventStore

An EventStore instance or a config object.

The constructor to create an event store instance with. Should be a class, subclassing the EventStore

Class implementing resource allocation report used by resource histogram and resource utilization views for collecting resource allocation.

The constructor of the resource model class, to be used in the project. Will be set as the modelClass property of the resourceStore

A ResourceStore instance or a config object.

The constructor to create a resource store instance with. Should be a class, subclassing the ResourceStore

This config manages DST correction in the scheduling engine. It only has effect when DST transition hour is working time. Usually a DST transition occurs on a Sunday, so with non-working weekends the DST correction logic is not involved.

If true, it will add/remove one hour when calculating end date. For example: Assume weekends are working and on Sunday, 2020-10-25 at 03:00 clocks are set back 1 hour. Assume there is an event:

{
    startDate    : '2020-10-20',
    duration     : 10 * 24 + 1,
    durationUnit : 'hour'
}

It will end on 2020-10-30 01:00 (which is wrong) but duration will be reported correctly. Because of the DST transition the SchedulerPro project will add one more hour when calculating the end date.

Also this may occur when day with DST transition is working but there are non-working intervals between that day and event end date.

{
    calendar         : 1,
    calendars    : [
        {
            id           : 1,
            startDate    : '2020-10-26',
            endDate      : '2020-10-27',
            isWorking    : false
        }
    ],
    events       : [
        {
            id           : 1,
            startDate    : '2020-10-20',
            endDate      : '2020-10-30'
        },
        {
            id           : 2,
            startDate    : '2020-10-20',
            duration     : 10 * 24 + 1,
            durationUnit : 'hour'
        }
    ]
}

Event 1 duration will be incorrectly reported as 9 days * 24 hours, missing 1 extra hour added by DST transition. Event 2 end date will be calculated to 2020-10-30 01:00, adding one extra hour.

If false, the SchedulerPro project will not add DST correction which fixes the quirk mentioned above. Event 1 duration will be correctly reported as 9 days * 24 hours + 1 hour. Event 2 end date will be calculated to 2020-10-30.

Also, for those events days duration will be a floating point number due to extra (or missing) hour:

eventStore.getById(1).getDuration('day')  // 10.041666666666666
eventStore.getById(1).getDuration('hour') // 241

Enables/disables the calculation progress notifications.

Get/set assignmentStore data.

Always returns an array of AssignmentModels but also accepts an array of its configuration objects as input.

Get/set calendarManagerStore data.

Always returns a CalendarModel array but also accepts an array of its configuration objects as input.

Get/set dependencyStore data.

Always returns an array of DependencyModels but also accepts an array of its configuration objects as input.

Get/set eventStore data.

Always returns an array of EventModels but also accepts an array of its configuration objects as input.

Get/set resourceStore data.

Always returns an array of ResourceModels but also accepts an array of its configuration objects as input.

Get/set resourceTimeRangeStore data.

Always returns an array of ResourceTimeRangeModels but also accepts an array of its configuration objects as input.

Get/set timeRangeStore data.

Always returns an array of TimeSpans but also accepts an array of its configuration objects as input.

The store holding the assignment information.

See also AssignmentModel

The store holding the calendar information.

See also CalendarModel

Returns current Project changes as an object consisting of added/modified/removed arrays of records for every managed store. Returns null if no changes exist. Format:

{
    resources : {
        added    : [{ name : 'New guy' }],
        modified : [{ id : 2, name : 'Mike' }],
        removed  : [{ id : 3 }]
    },
    events : {
        modified : [{  id : 12, name : 'Cool task' }]
    },
    ...
}

The store holding the dependency information.

See also DependencyModel

The store holding the event information.

See also EventModel

The store holding the resources that can be assigned to the events in the event store.

See also ResourceModel

Class implementing an event segment. Can be used for customizing the class implementing segments:

// new class for a segment
class MySegment extends EventSegmentModel {
    static fields = [
       { name : 'responsiblePerson' }
    ];
}
new SchedulerPro({
    project : {
        // tell the project to use the new class for segments
        segmentModelClass : MySegment
    }
})

Project changes (CRUD operations to records in its stores) are automatically committed on a buffer to the underlying graph based calculation engine. The engine performs it calculations async.

By calling this function, the commit happens right away. And by awaiting it you are sure that project calculations are finished and that references between records are up to date.

The returned promise is resolved with an object. If that object has rejectedWith set, there has been a conflict and the calculation failed.

// Move an event in time
eventStore.first.shift(1);

// Trigger calculations directly and wait for them to finish
const result = await project.commitAsync();

if (result.rejectedWith) {
    // there was a conflict during the scheduling
}

Accepts a "data package" consisting of data for the projects stores, which is then loaded into the stores.

The package can hold data for EventStore, AssignmentStore, ResourceStore, DependencyStore and Calendar Manager. It uses the same format as when creating a project with inline data:

await project.loadInlineData({
    events : [
        { id : 1, name : 'Proof-read docs', startDate : '2017-01-02', endDate : '2017-01-09' },
        { id : 2, name : 'Release docs', startDate : '2017-01-09', endDate : '2017-01-10' }
    ],
    resources : [
        { id : 1, name : 'Arcady' },
        { id : 2, name : 'Don' }
    ],
    dependencies : [
        { fromEvent : 1, toEvent : 2 }
    ],
    assignments : [
         { 'event' : 1, 'resource' : 1 },
         { 'event' : 2, 'resource' : 2 }
     ]
     calendars    : [
         {
             id        : 111,
             name      : 'My cool calendar',
             intervals : [
                 {
                     recurrentStartDate : 'on Sat',
                     recurrentEndDate   : 'on Mon',
                     isWorking          : false
                 }
             ]
         }
     ]
});

After populating the stores it commits the project, starting its calculations. By awaiting loadInlineData() you can be sure that project calculations are finished.