ProjectModel

Scheduler Pro Project model class - a central place for all data.

It holds and links the stores usually used by Scheduler Pro:

The project uses a scheduling engine to calculate dates, durations and such. It is also responsible for handling references between models, for example to link an event via an assignment to a resource. These operations are asynchronous, a fact that is hidden when working in the Scheduler Pro UI but which you must know about when performing operations on the data level.

When there is a change to data that requires something else to be recalculated, the project schedules a calculation (a commit) which happens moments later. It is also possible to trigger these calculations directly. This flow illustrates the process:

Something changes which requires the project to recalculate, for example adding a new task:

const [event] = project.eventStore.add({ startDate, endDate });

A recalculation is scheduled, thus:

event.duration; // <- Not yet calculated

Calculate now instead of waiting for the scheduled calculation

await project.commitAsync();

event.duration; // <- Now available

Please refer to this guide for more information.

Built-in CrudManager

Scheduler Pro's project has a CrudManager built-in. Using it is the recommended way of syncing data between Scheduler Pro and a backend. Example usage:

const scheduler = new SchedulerPro({
    project : {
        // Configure urls used by the built-in CrudManager
        transport : {
            load : {
                url : 'php/load.php'
            },
            sync : {
                url : 'php/sync.php'
            }
        }
    }
});

// Load data from the backend
scheduler.project.load()

URLs may also be specified using shortcut configs:

const scheduler = new SchedulerPro({
    project : {
        loadUrl : 'php/load.php'
        syncUrl : 'php/sync.php'
    }
});

scheduler.project.load()

For more information on CrudManager, see Schedulers docs on CrudManager. For a detailed description of the protocol used by CrudManager, see the Crud manager guide

You can access the current Project data changes anytime using the changes property.

Working with inline data

The project provides an inlineData getter/setter that can be used to manage data from all Project stores at once. Populating the stores this way can be useful if you do not want to use the CrudManager for server communication but instead load data using Axios or similar.

Getting data

const data = scheduler.project.inlineData;

// use the data in your application

You can read the inline data by console.log(scheduler.project.inlineData);:

{
    "calendars": [],
    "events": [
        {
            "id": 1,
            "startDate": "2020-03-23T07:00:00+05:00",
        },
        {
            "id": 2,
            "startDate": "2020-03-23T11:00:00+05:00",
        }
    ],
    "resources": [
        {
            "id": 1,
            "parentId": null,
            "name": "George",
            "eventColor": "blue",
        },
        {
            "id": 2,
            "parentId": null,
            "name": "Rob",
            "eventColor": "blue",
        }
    ],
    "assignments": [
        { id : 1, resource : 1, event : 1 },
        { id : 2, resource : 2, event : 1 },
        { id : 3, resource : 1, event : 2 },
    ],
    "dependencies": [
        {
            "id": 1,
            "type": 2,
            "cls": "",
            "lag": 0,
            "lagUnit": "day",
            "fromEvent": 1,
            "toEvent": 2,
            "active": true
        }
    ],
    "timeRanges": [],
    "resourceTimeRanges": [],
    "project": {
        "expanded": true,
        "hoursPerDay": 24,
        "daysPerWeek": 7
    }
}

The xxData properties are deprecated and will be removed in the future. Use xx instead. For example eventsData is deprecated, use events instead. For now, both naming schemes are included in the data object

Setting data

// Get data from server manually
const data = await axios.get('/project?id=12345');

// Feed it to the project
scheduler.project.inlineData = data;

It should have the following structure:

scheduler.project.loadInlineData = {
  resources: [
    {
      id   : 1,
      name : 'George',
      type : 'Operators',
    },
    {
      id   : 2,
      name : 'Rob',
      type : 'Operators',
    },
    {
      id   : 3,
      name : 'Mike',
      type : 'Main'
    },
  ],
  events: [
    {
      id           : 1,
      name         : 'Meeting',
      startDate    : '2020-03-23T07:00',
      duration     : 4,
      durationUnit : 'hour',
      percentDone  : 100,
    },
    {
      id           : 2,
      startDate    : '2020-03-23T11:00',
      name         : 'Get parts',
      durationUnit : 'hour',
      duration     : 3,
      percentDone  : 40,
    },
  ],
  assignment : [
      { id : 1, resource : 1, event : 1 },
      { id : 2, resource : 2, event : 1 },
      { id : 3, resource : 2, event : 2 },
      { id : 4, resource : 3, event : 2 },
  ],
  dependencies: [
    {
      id        : 1,
      fromEvent : 1,
      toEvent   : 2
    },
  ],
};

You can also use loadInlineData() function:

scheduler.project.loadInlineData({
   resources    : [],
   events       : [],
   dependencies : []
})

Either you can pass the response in this format directly:

{
     resource     : [],
     events       : [],
     dependencies : []
}

Or you can modify the response once received and pass it to the loadInlineData() function or assign it to inlineData.

Getting changed records

You can access the changes in the current Project dataset anytime using the changes property. It returns an object with all changes:

const changes = project.changes;

console.log(changes);

The changes object has the following structure:

{
  events : {
      updated : [{
          name : 'My task',
          id   : 12
      }]
  },
  assignments : {
      added : [{
          event      : 12,
          resource   : 7,
          units      : 100,
          $PhantomId : 'abc123'
      }]
    }
};

Monitoring data changes

While it is possible to listen for data changes on the projects individual stores, it is sometimes more convenient to have a centralized place to handle all data changes. By listening for the change event your code gets notified when data in any of the stores changes. Useful for example to keep an external data model up to date:

const scheduler = new SchedulerPro({
    project: {
        listeners : {
            change({ store, action, records }) {
                const { $name } = store.constructor;

                if (action === 'add') {
                    externalDataModel.add($name, records);
                }

                if (action === 'remove') {
                    externalDataModel.remove($name, records);
                }
            }
        }
    }
});

Processing the data loaded from the server

If you want to process the data received from the server after loading, you can use the beforeLoadApply or beforeSyncApply events:

const gantt = new Gantt({
    project: {
        listeners : {
            beforeLoadApply({ response }) {
                // do something with load-response object before data is fed to the stores
            }
        }
    }
});

Built-in StateTrackingManager

The project also has a built-in StateTrackingManager (STM for short), that handles undo/redo for the project stores (additional stores can also be added). By default, it is only used while editing tasks using the task editor, the editor updates tasks live and uses STM to rollback changes if canceled. But you can enable it to track all project store changes:

// Enable automatic transaction creation and start recording
project.stm.autoRecord = true;
project.stm.enable();

// Undo a transaction
project.stm.undo();

// Redo
project.stm.redo();

Check out the undoredo demo to see it in action.

Useful configs

Config	Description
calendar	The project calendar
hoursPerDay	Hours per day for duration conversion
silenceInitialCommit	Silence propagation on data load
maxCalendarRange	Max range for calendar iteration
enableProgressNotifications	Enable calculation progress events
delayCalculation	Postpone calculations for early paint

Fields

Fields belong to a Model class and define the Model data structure

addConstraintOnDateSet : Booleantrue

If this flag is set to true (default) when a start/end date is set on the event, a corresponding start-no-earlier/later-than constraint is added, automatically. This is done in order to keep the event "attached" to this date, according to the user intention.

Depending on your use case, you might want to disable this behaviour.
autoCalculatePercentDoneForParentTasks : Booleantrue

true to enable automatic % done calculation for summary tasks, false to disable it.
autoMergeAdjacentSegments : Booleantrue

When true (default) adjacent or overlapping event segments get merged automatically.
calendar : String/CalendarModelConfig/CalendarModel

The project calendar.
daysPerMonth : Number30

The number of days per month.

Please note: the value does not define the amount of working time per month for that purpose one should use calendars.

The value is used when converting the duration from one unit to another. So when user enters a duration of, for example, 1 month the system understands that it actually means 30 days (which is then converted to hours) and schedules accordingly.
daysPerWeek : Number7

The number of days per week.

Please note: the value does not define the amount of working time per week for that purpose one should use calendars.

The value is used when converting the duration from one unit to another. So when user enters a duration of, for example, 2 weeks the system understands that it actually means 14 days (which is then converted to hours) and schedules accordingly.
dependenciesCalendar : 'ToEvent'/'FromEvent'/'Project''ToEvent'
The source of the calendar for dependencies (the calendar used for taking dependencies lag into account). Possible values are:
- ToEvent - successor calendar will be used (default);
- FromEvent - predecessor calendar will be used;
- Project - the project calendar will be used.
hoursPerDay : Number24

The number of hours per day.

Please note: the value does not define the amount of working time per day for that purpose one should use calendars.

The value is used when converting the duration from one unit to another. So when user enters a duration of, for example, 5 days the system understands that it actually means 120 hours and schedules accordingly.
skipNonWorkingTimeInDurationWhenSchedulingManually : Booleanfalse

When true the project's manually scheduled tasks duration will include only working periods of time. When false such tasks will ignore working time calendars and treat all intervals as working.

IMPORTANT: Setting this to false also forcefully sets the skipNonWorkingTimeWhenSchedulingManually option to false.
skipNonWorkingTimeWhenSchedulingManually : Booleanfalse

When true the project's manually scheduled tasks will adjust their proposed start/end dates to skip non-working time.

See also skipNonWorkingTimeInDurationWhenSchedulingManually

Configs

Configs are options you supply in a configuration object when creating an instance of this class

listeners : Object

Events

The listener set for this object.

An object whose property names are the names of events to handle, or options which modifiy how the handlers are called.

See addListener for details about the options.

Listeners can be specified in target class config and they will be merged with any listeners specified in the instantiation config. Class listeners will be fired first:

class MyStore extends Store({
    static configurable = {
        listeners : {
            myCustomEvent() {
            },
            load : {
                prio : 10000,
                fn() { // this load listener handles things first }
            }
        }
    };
});

let store = new MyStore({
  listeners: {
    load: () => { // This load listener runs after the class's },
    ...
  }
});

Handlers as function name

Object event handlers may be specified as a function name. If a string is specified, it is the name of the function in the thisObj object.

If the string begins with up., this object's ownership hierarchy (if present) is scanned for an object which implements that function name:

new Popup({
    tbar : {
        items : {
            myCombo : {
                type      : 'combo',
                editable  : false,
                label     : 'Type',
                listeners : {
                    // Look in owner chain for this function name
                    change : 'up.onFilterChange'
                },
                items     : [
                    'Event',
                    'Task',
                    'Appointment'
                ]
            }
        }
    },
    items : {
        ...
    },
    onFilterChange({ value }) {
        // Handle event type selection here
    }
});

loadUrl : String
AbstractCrudManagerMixin
Convenience shortcut to set only the url to load from, when you do not need to supply any other config options in the load section of the transport config.

Using loadUrl:
```
{
    loadUrl : 'read.php
}
```
Equals the following transport config:
```
{
    transport : {
        load : {
            url : 'read.php'
        }
    }
}
```
When read at runtime, it will return the value from transport.load.url.

Has a corresponding runtime loadUrl property.
syncUrl : String
AbstractCrudManagerMixin
Convenience shortcut to set only the url to sync to, when you do not need to supply any other config options in the sync section of the transport config.

Using loadUrl:
```
{
    syncUrl : 'sync.php
}
```
Equals the following transport config:
```
{
    transport : {
        load : {
            url : 'sync.php'
        }
    }
}
```
When read at runtime, it will return the value from transport.sync.url.

Has a corresponding runtime syncUrl property.
useRawData : Boolean
ProjectModelCommon
By default, the stores of a project use the raw data objects passed to them as the data source for their records if data is loaded remotely (using an AjaxStore or a CrudManager). For data supplied inline, the data objects are instead by default cloned to avoid the original data object being modified by the store.

See useRawData for more information on the mechanics of this.

This can be explicitly controlled per store by setting the useRawData config on the store:
```
// Opt in for a single store
const project = new ProjectModel({
    eventStore : {
      useRawData : true
    },
    ...
});
```
Or you can control it for all the default stores in the project by setting this config on the project:
```
// Opt in for all stores in the project
const project = new ProjectModel({
   useRawData : true,
   ...
});
```
adjustDurationToDST : Booleanfalse
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
```
syncConflictResolution : 'local'/'remote'local

internal
AbstractCrudManagerMixin
Specifies the way to handle conflicts happening when applying sync responses to served stores, The conflicts could happen when remote coming changes interfere with local changes made after sending the request.

Supported values are:
- local local modifications are preserved and corresponding remote changes get rejected
- remote remote changes gets applied overriding the local modifications.
delayCalculation : Booleantrue

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.
enableProgressNotifications : Boolean

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.

Has a corresponding runtime enableProgressNotifications property.

maxCalendarRange : Number157680000000

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,
        ...
    }
});

preventSilencingOnIssueResolve : Booleantrue

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.
resetUndoRedoQueuesAfterLoad : Boolean

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

ADVANCED
ProjectModelCommon
Experimental hook that lets the app determine if a bound dataset needs syncing with the store or not, and if it does - which records that should be processed. Only called for stores that are configured with syncDataOnLoad: true (which is the default in the React, Angular and Vue wrappers).

This is an experimental API that might change in any release until it has been finalized.

The main use case for this is for frameworks that update all state on any state change (like React), to not have to reapply the full bound dataset each time (which becomes costly).

If the app has a cheap way of determining (for example using a timestamp) that the dataset has no changes, return false from this hook to prevent the store from syncing at all at that time.
```
shouldSyncDataOnLoad({ store, data }) {
  if (store === myEventStore && timestamp <= lastUpdateTimestamp) {
    // Prevent sync when the event store has not changed since last time
    // (pseudocode)
    return false;
  }
}
```
If the app knows that something has changed, return a Set with ids for the records that should be further processed by the sync logic.
```
shouldSyncDataOnLoad({ store, data }) {
  if (store === myEventStore && timestamp > lastUpdateTimestamp) {
    // Sync only these records (pseudocode)
    return new Set([6, 110, 586]);
  }
}
```
Parameters
- options : Object
  
  Options passed by the store to this hook
- store : Store
  
  Store about to be synced
- records : Model
  
  Records currently in the store
- data : Object[]
  
  Incoming data
Returns

Set/Boolean
:

Return false to prevent the store from syncing, or a set of record ids that need further processing (for records that has some kind of change, eg. an update, removal or addition)
Has a corresponding runtime shouldSyncDataOnLoad property.
silenceInitialCommit : Booleantrue
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,
        ...
    }
    ...
})
```
stm : StateTrackingManagerConfig/StateTrackingManager
ProjectModelMixin

Configuration options to provide to the STM manager

Has a corresponding runtime stm property.
timeZone : String/Number
ProjectModelTimeZoneMixin
Set to a IANA time zone (i.e. Europe/Stockholm) or a UTC offset in minutes (i.e. -120). This will convert all events, tasks and time ranges to the specified time zone or offset. It will also affect the displayed timeline's headers as well at the start and end date of it.

There is currently no built-in time zone support in JavaScript which means that the converted dates technically still are in the local system time zone, but adjusted to match the configured time zone.

DST

If a IANA time zone is provided, there will be support for DST. But if local system time zone has DST that will affect the time zone conversion at the exact hour when the local system time zone switches DST on and off.

For example:
1. The local system time zone is Europe/Stockholm (which is UTC+1 or UTC+2 when DST).
2. The date 2022-03-27T07:00:00Z (which is UTC) is converted to America/Chicago (which is UTC-6 or UTC-5 when DST).
3. The converted JS date will be created from 2022-03-27T02:00:00 which is exactly the hour when Europe/Stockholm adds an DST hour. This has the effect that the converted date shows up incorrectly as 2022-03-27T03:00 instead.
If a UTC offset is provided, there is no DST support at all.

Editing

If creating new records or editing existing record dates, the dates will be interpreted as in the selected time zone.

If you want to create new records with dates that either should be interpreted as local system time zone or from any other time zone, specify the timeZone field on the record.

Saving

When saving or syncing data, the dates will be restored to local system time and converted to JSON ISO formatted. When restoring, it adds or subtracts the time difference accordingly. For instance, if the current timezone is UTC and you're in UTC +3, 3 hours will be added to the time.

The store.toJSON() and model.toJSON() methods also restores the data. For example, eventStore.toJSON() will show the dates in local timezone.

Has a corresponding runtime timeZone property.
autoLoad : Booleanfalse
AbstractCrudManagerMixin

Specify true to automatically call load method on the next frame after creation.

Called on the next frame to allow a Scheduler (or similar) linked to a standalone CrudManager to register its stores before loading starts.
autoSync : Booleanfalse
AbstractCrudManagerMixin

true to automatically persist store changes after edits are made in any of the stores monitored. Please note that sync request will not be invoked immediately but only after autoSyncTimeout interval.
autoSyncTimeout : Number100
AbstractCrudManagerMixin

The timeout in milliseconds to wait before persisting changes to the server. Used when autoSync is set to true.
crudStores : Store[]/String[]/CrudManagerStoreDescriptor[]/StoreConfig
AbstractCrudManagerMixin

Sets the list of stores controlled by the CRUD manager.

When adding a store to the CrudManager, make sure the server response format is correct for load and sync requests. Learn more in the Working with data guide.

Store can be provided by itself, its id or as a store descriptor.

Has a corresponding runtime crudStores property.

encoder : Object

JsonEncoder

Configuration of the JSON encoder used by the Crud Manager.

requestData : Object

Static data to send with the data request.

new CrudManager({
    // add static "foo" property to all requests data
    encoder : {
        requestData : {
            foo : 'Bar'
        }
    },
    ...
});

The above snippet will result adding "foo" property to all requests data:

    {
        "requestId"   : 756,
        "type"        : "load",

        "foo"         : "Bar",

        "stores"      : [
            ...

forceSync : Boolean
AbstractCrudManagerMixin

Specify as true to force sync requests to be sent when calling sync(), even if there are no local changes. Useful in a polling scenario, to keep client up to date with the backend.

Has a corresponding runtime forceSync property.
ignoreRemoteChangesInSTM : Boolean
AbstractCrudManagerMixin

Set to true to make STM ignore changes coming from the backend. This will allow user to only undo redo local changes.

Has a corresponding runtime ignoreRemoteChangesInSTM property.
includeChildrenInRemoveRequest : Booleantrue
AbstractCrudManagerMixin
Set to false to only include the id of a removed parent node in the request to the backend (also affects programmatic calls to get changes etc.), and not the ids of its children.

Consider the following scenario, removing parent 1:
```
{
  id : 1,
  children : [
    { id : 11 },
    { id : 12 }
  ]
}
```
With includeChildrenInRemoveRequest : false, the backend will only receive the removal of id 1.

With includeChildrenInRemoveRequest : true (the default), the backend will receive the removal of id 1, 11 and 12.
phantomIdField : String$PhantomId
AbstractCrudManagerMixin

Field name to be used to transfer a phantom record identifier.
phantomParentIdField : String$PhantomParentId
AbstractCrudManagerMixin

Field name to be used to transfer a phantom parent record identifier.
resetIdsBeforeSync : Booleantrue
AbstractCrudManagerMixin

True to reset identifiers (defined by idField config) of phantom records before submitting them to the server.
skipSuccessProperty : Booleantrue
AbstractCrudManagerValidation

When true treats parsed responses without success property as successful. In this mode a parsed response is treated as invalid if it has explicitly set success : false.

storeIdProperty : String

AbstractCrudManagerMixin

Name of a store property to retrieve store identifiers from. Make sure you have an instance of a store to use it by id. Store identifier is used as a container name holding corresponding store data while transferring them to/from the server. By default, id property is used. And in case a container identifier has to differ this config can be used:

class CatStore extends Store {
    static configurable = {
        // store id is "meow" but for sending/receiving store data
        // we want to have "cats" container in JSON, so we create a new property "storeIdForCrud"
        id             : 'meow',
        storeIdForCrud : 'cats'
    }
});

// create an instance to use a store by id
new CatStore();

class MyCrudManager extends CrudManager {
    ...
    crudStores           : ['meow'],
    // crud manager will get store identifier from "storeIdForCrud" property
    storeIdProperty  : 'storeIdForCrud'
});

The storeIdProperty property can also be specified directly on a store:

class CatStore extends Store {
    static configurable = {
        // storeId is "meow" but for sending/receiving store data
        // we want to have "cats" container in JSON
        id              : 'meow',
        // so we create a new property "storeIdForCrud"..
        storeIdForCrud  : 'cats',
        // and point CrudManager to use it as the store identifier source
        storeIdProperty  : 'storeIdForCrud'
    }
});

class DogStore extends Store {
    static configurable = {
        // storeId is "dogs" and it will be used as a container name for the store data
        storeId : 'dogs',
        // id is set to get a store by identifier
        id      : 'dogs'
    }
});

// create an instance to use a store by id
new CatStore();
new DogStore();

class MyCrudManager extends CrudManager {
    ...
    crudStores : ['meow', 'dogs']
});

supportShortSyncResponse : Booleantrue
AbstractCrudManagerMixin

When true the Crud Manager does not require all updated and removed records to be mentioned in the sync response. In this case response should include only server side changes.

Please note that added records should still be mentioned in response to provide real identifier instead of the phantom one.
syncApplySequence : String[]
AbstractCrudManagerMixin
An array of store identifiers sets an alternative sync responses apply order. By default, the order in which sync responses are applied to the stores is the same as they registered in. But in case of some tricky dependencies between stores this order can be changed:
```
class MyCrudManager extends CrudManager {
    // register stores (will be loaded in this order: 'store1' then 'store2' and finally 'store3')
    crudStores : ['store1', 'store2', 'store3'],
    // but we apply changes from server to them in an opposite order
    syncApplySequence : ['store3', 'store2', 'store1']
});
```
Has a corresponding runtime syncApplySequence property.
trackProjectModelChanges : Booleantrue
ProjectCrudManager

If true, project changes API will also report project model changes: start/end date, calendar, effort, duration, etc.

Has a corresponding runtime trackProjectModelChanges property.
trackResponseType : Booleanfalse
AbstractCrudManagerMixin

When true forces the CRUD manager to process responses depending on their type attribute. So load request may be responded with sync response for example. Can be used for smart server logic allowing the server to decide when it's better to respond with a complete data set (load response) or it's enough to return just a delta (sync response).

transport : Object

AjaxTransport

Configuration of the AJAX requests used by Crud Manager to communicate with a server-side.

transport : {
    load : {
        url       : 'http://mycool-server.com/load.php',
        // HTTP request parameter used to pass serialized "load"-requests
        paramName : 'data',
        // pass extra HTTP request parameter
        params    : {
            foo : 'bar'
        }
    },
    sync : {
        url     : 'http://mycool-server.com/sync.php',
        // specify Content-Type for requests
        headers : {
            'Content-Type' : 'application/json'
        }
    }
}

Since the class uses Fetch API you can use any of the Request interface options:

transport : {
    load : {
        url         : 'http://mycool-server.com/load.php',
        // HTTP request parameter used to pass serialized "load"-requests
        paramName   : 'data',
        // pass few Fetch API options
        method      : 'GET',
        credentials : 'include',
        cache       : 'no-cache'
    },
    sync : {
        url         : 'http://mycool-server.com/sync.php',
        // specify Content-Type for requests
        headers     : {
            'Content-Type' : 'application/json'
        },
        credentials : 'include'
    }
}

An object where you can set the following possible properties:

load : Object

Load requests configuration:
url : String

URL to request for data loading.
method : String'GET'

HTTP method to be used for load requests.
paramName : String'data'

Name of the parameter that will contain a serialized load request. The value is mandatory for requests using GET method (default for load) so if the value is not provided data string is used as default. This value is optional for HTTP methods like POST and PUT, the request body will be used for data transferring in these cases.

params : Object

An object containing extra HTTP parameters to pass to the server when sending a load request.

transport : {
    load : {
        url       : 'http://mycool-server.com/load.php',
        // HTTP request parameter used to pass serialized "load"-requests
        paramName : 'data',
        // pass extra HTTP request parameter
        // so resulting URL will look like: http://mycool-server.com/load.php?userId=123456&data=...
        params    : {
            userId : '123456'
        }
    },
    ...
}

headers : Object<String, String>

An object containing headers to pass to each server request.

transport : {
    load : {
        url       : 'http://mycool-server.com/load.php',
        // HTTP request parameter used to pass serialized "load"-requests
        paramName : 'data',
        // specify Content-Type for "load" requests
        headers   : {
            'Content-Type' : 'application/json'
        }
    },
    ...
}

sync : Object

Sync requests (sync in further text) configuration:
url : String

URL to request for sync.
method : String'POST'

HTTP request method to be used for sync.
paramName : String

Name of the parameter in which sync data will be transferred. This value is optional for requests using methods like POST and PUT, the request body will be used for data transferring in this case (default for sync). And the value is mandatory for requests using GET method (if the value is not provided data string will be used as fallback).

params : Object

HTTP parameters to pass with an HTTP request handling sync.

transport : {
    sync : {
        url    : 'http://mycool-server.com/sync.php',
        // extra HTTP request parameter
        params : {
            userId : '123456'
        }
    },
    ...
}

headers : Object<String, String>

HTTP headers to pass with an HTTP request handling sync.

transport : {
    sync : {
        url     : 'http://mycool-server.com/sync.php',
        // specify Content-Type for "sync" requests
        headers : {
            'Content-Type' : 'application/json'
        }
    },
    ...
}

validateResponse : Booleantrue
AbstractCrudManagerValidation

This config validates the response structure for requests made by the Crud Manager. When true, the Crud Manager checks every parsed response structure for errors and if the response format is invalid, a warning is logged to the browser console.

The config is intended to help developers implementing backend integration.
writeAllFields : Booleanfalse
AbstractCrudManagerMixin

true to write all fields from the record to the server. If set to false it will only send the fields that were modified. Note that any fields that have persist set to false will still be ignored and fields having alwaysWrite set to true will always be included.
catchEventHandlerExceptions : Booleanfalse

ADVANCED
Events

By default, if an event handler throws an exception, the error propagates up the stack and the application state is undefined. Code which follows the event handler will not be executed.

Set this to true to catch exceptions thrown by this object's event handlers and continue processing the event. The exception will be rethrown on a zero millisecond timeout, so it will not destroy the stack.

Has a corresponding runtime catchEventHandlerExceptions property.
internalListeners : Object

internal
Events

Internal listeners, that cannot be removed by the user.
assignments : AssignmentModel[]/AssignmentModelConfig

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

Has a corresponding runtime assignments property.
calendars : CalendarModel[]/CalendarModelConfig

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

Has a corresponding runtime calendars property.
dependencies : DependencyModel[]/DependencyModelConfig

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

Has a corresponding runtime dependencies property.
events : EventModel[]/EventModelConfig

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

Has a corresponding runtime events property.
json : String
ProjectModelCommon
Project data as a JSON string, used to populate its stores.
```
const project = new ProjectModel({
    json : '{"events":[...],"resources":[...],...}'
}
```
The xxData properties are deprecated and will be removed in the future. Use xx instead. For example eventsData is deprecated, use events instead. For now, both naming schemes are included in the data object

Has a corresponding runtime json property.
resourceTimeRanges : ResourceTimeRangeModel[]/ResourceTimeRangeModelConfig

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

Has a corresponding runtime resourceTimeRanges property.
resources : ResourceModel[]/ResourceModelConfig

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

Has a corresponding runtime resources property.
timeRanges : TimeSpan[]/TimeSpanConfig

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

Has a corresponding runtime timeRanges property.

toJSONResultFormat : 'inlineData'/'model'

ProjectModelCommon

Specifies the output format of toJSON.

inlineData - Return all crud store data, plus this project fields (under the project key). For example:

{
    "project" : {
        "startDate"    : "2024-03-22",
        "endDate"      : "2024-04-22",
        "hoursPerDay"  : 8,
        "daysPerWeek"  : 5,
        "daysPerMonth" : 20
    },
    "events"             : [...],
    "resources"          : [...],
    "assignments"        : [...],
    "dependencies"       : [...],
    "resourceTimeRanges" : [...],
    "timeRanges"         : [...]
}

model - Return only the project fields. For example:

{
    "startDate"    : "2024-03-22",
    "endDate"      : "2024-04-22",
    "hoursPerDay"  : 8,
    "daysPerWeek"  : 5,
    "daysPerMonth" : 20
}

lazyLoad : Boolean/Object
LazyLoadCrudManager
If set to true, or a config object, this makes the CrudManager load records only when needed. When a record or a date range that is not already loaded is requested, a load request will be made to the specified URL. More more details about lazy loading, see the guide
Parameters
- lazyLoad : Object
  
  Lazy load config
- chunkSize : Number
  
  The number of records to be loaded before and after the requested index (only affects the ResourceStore).
- bufferUnit : DurationUnit
  
  Used together with bufferAmount to calculate the start and end dates of each load request. The value is added to the current visible start or end date. Defaults to the visible time span length (does not affect ResourceStore).
- bufferAmount : Number
  
  See bufferUnit
Has a corresponding runtime lazyLoad property.
pageSize : Number
LazyLoadCrudManager

The number of Resource records each page should contain, when using remotePaging
remotePaging : Boolean
LazyLoadCrudManager
If set to true, this makes the CrudManager load pages of data, instead of loading the complete dataset at once. The requests made to the loadUrl will contain params with info about the current dataset being requested:
- page - The resource page
- pageSize - The resource page size
- startDate - The start date of the calculated timespan
- endDate - The end date of the calculated timespan
For more details about paging, see the guide
requestData : Function

ASYNC
LazyLoadCrudManager
When the CrudManager/Project is configured with lazyLoad set to true, you can configure your own data fetching logic by implementing this function. Doing this will override the built-in fetching mechanism using the loadUrl.

When implementing this, it is expected that what is returned is an object fulfilling the contract of a regular CrudManager/Project load call.
Parameters
- params : LazyLoadCrudManagerRequestParams
  
  Object containing info of what data is requested
Returns

CrudManagerRequestResponse
assignmentsData : AssignmentModel[]

DEPRECATED

Deprecated:
6.3.0 Use assignments instead

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

The initial data, to fill the calendarManagerStore with. Should be an array of CalendarModel or its configuration objects.
dependenciesData : DependencyModel[]

DEPRECATED

Deprecated:
6.3.0 Use dependencies instead

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

DEPRECATED

Deprecated:
6.3.0 Use events instead

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

DEPRECATED
ProjectModelCommon

Deprecated:
6.3.0 This config will be removed when the eventsData, resourcesData etc. properties are removed in a future release.

Whether to include legacy data properties in the JSON / inlineData output. The legacy data properties are the xxData (eventsData, resourcesData etc.) properties that are deprecated and will be removed in the future.

Has a corresponding runtime includeLegacyDataProperties property.
resourceTimeRangesData : ResourceTimeRangeModel[]

DEPRECATED
ProjectModelMixin

Deprecated:
6.3.0 Use resourceTimeRanges instead

The initial data, to fill the resourceTimeRangeStore with. Should be an array of ResourceTimeRangeModel or it's configuration objects.
resourcesData : ResourceModel[]

DEPRECATED

Deprecated:
6.3.0 Use resources instead

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

DEPRECATED
ProjectModelMixin

Deprecated:
6.3.0 Use timeRanges instead

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

bubbleEvents : Object

Events

An object where property names with a truthy value indicate which events should bubble up the ownership hierarchy when triggered.

const container = new Container({
    items : [
       { type : 'text', bubbleEvents : { change : true }}
    ],

    listeners : {
        change() {
            // Will catch change event from the text field
        }
    }
});

callOnFunctions : Booleanfalse
Events
Set to true to call onXXX method names (e.g. onShow, onClick), as an easy way to listen for events.
```
const container = new Container({
    callOnFunctions : true

    onHide() {
         // Do something when the 'hide' event is fired
    }
});
```
Has a corresponding runtime callOnFunctions property.
assignmentModelClass : AssignmentModel

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

An AssignmentStore instance or a config object.

Has a corresponding runtime assignmentStore property.
assignmentStoreClass : AssignmentStore/Object

The constructor to create an assignment store instance with. Should be a class, subclassing the AssignmentStore
calendarManagerStore : CalendarManagerStore/CalendarManagerStoreConfig

A CalendarManagerStore instance or a config object.

Has a corresponding runtime calendarManagerStore property.
calendarManagerStoreClass : CalendarManagerStore/Object

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

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

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

A DependencyStore instance or a config object.

Has a corresponding runtime dependencyStore property.
dependencyStoreClass : DependencyStore/Object

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

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

An EventStore instance or a config object.

Has a corresponding runtime eventStore property.
eventStoreClass : EventStore/Object

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

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

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

A ResourceStore instance or a config object.

Has a corresponding runtime resourceStore property.
resourceStoreClass : ResourceStore/Object

The constructor to create a resource store instance with. Should be a class, subclassing the ResourceStore
resourceTimeRangeStore : ResourceTimeRangeStore/ResourceTimeRangeStoreConfig
ProjectModelMixin

A ResourceTimeRangeStore instance or a config object.

Has a corresponding runtime resourceTimeRangeStore property.
resourceTimeRangeStoreClass : ResourceTimeRangeStore/Object
ProjectModelMixin

The constructor to create a resource time range store instance with. Should be a class subclassing the ResourceTimeRangeStore
taskStore : EventStore/EventStoreConfig
PartOfProject

An EventStore instance or a config object.
timeRangeStore : Store/StoreConfig
ProjectModelMixin

A Store instance or a config object.

Has a corresponding runtime timeRangeStore property.
timeRangeStoreClass : TimeRangeStore/Object
ProjectModelMixin

The constructor to create a time range store instance with. Should be a class subclassing the TimeRangeStore

Properties

Properties are getters/setters or publicly accessible variables on this class

isAbstractCrudManagerMixin : Booleantrue

READONLY

static

ADVANCED
AbstractCrudManagerMixin

Identifies an object as an instance of AbstractCrudManagerMixin class, or subclass thereof.
isAbstractCrudManagerValidation : Booleantrue

READONLY

static

ADVANCED
AbstractCrudManagerValidation

Identifies an object as an instance of AbstractCrudManagerValidation class, or subclass thereof.
isAjaxTransport : Booleantrue

READONLY

static

ADVANCED
AjaxTransport

Identifies an object as an instance of AjaxTransport class, or subclass thereof.
isDelayable : Booleantrue

READONLY

static

ADVANCED
Delayable

Identifies an object as an instance of Delayable class, or subclass thereof.
isEvents : Booleantrue

READONLY

static

ADVANCED
Events

Identifies an object as an instance of Events class, or subclass thereof.
isJsonEncoder : Booleantrue

READONLY

static

ADVANCED
JsonEncoder

Identifies an object as an instance of JsonEncoder class, or subclass thereof.
isLazyLoadCrudManager : Booleantrue

READONLY

static

ADVANCED
LazyLoadCrudManager

Identifies an object as an instance of LazyLoadCrudManager class, or subclass thereof.
isPartOfProject : Booleantrue

READONLY

static

ADVANCED
PartOfProject

Identifies an object as an instance of PartOfProject class, or subclass thereof.
isProjectChangeHandlerMixin : Booleantrue

READONLY

static

ADVANCED
ProjectChangeHandlerMixin

Identifies an object as an instance of ProjectChangeHandlerMixin class, or subclass thereof.
isProjectCrudManager : Booleantrue

READONLY

static

ADVANCED
ProjectCrudManager

Identifies an object as an instance of ProjectCrudManager class, or subclass thereof.
isProjectModel : Booleantrue

READONLY

static

ADVANCED

Identifies an object as an instance of ProjectModel class, or subclass thereof.
isProjectModelCommon : Booleantrue

READONLY

static

ADVANCED
ProjectModelCommon

Identifies an object as an instance of ProjectModelCommon class, or subclass thereof.
isProjectModelTimeZoneMixin : Booleantrue

READONLY

static

ADVANCED
ProjectModelTimeZoneMixin

Identifies an object as an instance of ProjectModelTimeZoneMixin class, or subclass thereof.
isProjectRevisionHandlerMixin : Booleantrue

READONLY

static

ADVANCED
ProjectRevisionHandlerMixin

Identifies an object as an instance of ProjectRevisionHandlerMixin class, or subclass thereof.
delayable : Object.

internal

static
Delayable
This class property returns an object that specifies methods to wrap with configurable timer behaviors.

It is used like so:
```
 class Foo extends Base.mixin(Delayable) {
     static get delayable() {
         return {
             expensiveMethod : 500
         };
     }

     expensiveMethod() {
         this.things();
         this.moreThings();
         this.evenMoreThings();
     }
 }
```
With the above in place, consider:
```
 let instance = new Foo();

 instance.expensiveMethod();
```
Instead of the above code immediately calling the expensiveMethod(), it will start a timer that will invoke the method 500ms later. Because expensiveMethod() is an instance method, each instance of Foo will have its own timer.

NOTE: Only instance methods are currently supported (i.e., only non-static methods).

Options

The value of each key configures how the method will be scheduled. If the value is a number, it is promoted to a config object of type='buffer' as in the following:
```
 class Foo extends Base.mixin(Delayable) {
     static get delayable() {
         return {
             expensiveMethod : {
                 type  : 'buffer',
                 delay : 500
             }
         };
     }
 }
```
The type property of the config object must be one of three values. Other options can be provided depending on the type:
- buffer
  Other options:
  - delay (Number) : The number of milliseconds to wait before calling the underlying method. A value of 0 is equivalent to setting immediate: true.
  - immediate (Boolean) : Set to true to call immediately (effectively disabling the buffer).
- raf (short for "request animation frame")
- idle (short for "request idle callback") Not available on Safari
  Other options:
  - cancelOutstanding (Boolean) : Set to true to cancel any pending animation frame requests and schedule a new one on each call.
  - immediate (Boolean) : Set to true to call immediately.
- throttle
  Other options:
  - delay (Number) : The number of milliseconds to wait after each execution before another execution takes place. A value of 0 is equivalent to setting immediate: true.
  - immediate (Boolean) : Set to true to call immediately (effectively disabling the throttle).
While immediate: true can be specified at the class level, it is more typical to set it on the instance's method as described below.

Delayable Method API

Delayable methods have a consistent API to manage their scheduling. This API is added to the methods themselves.

For example:
```
 let instance = new Foo();

 instance.expensiveMethod();         // schedule a call in 500ms
 instance.expensiveMethod.isPending; // true
 instance.expensiveMethod.cancel();
 instance.expensiveMethod.flush();
 instance.expensiveMethod.now();

 instance.expensiveMethod.delay = 10;
 instance.expensiveMethod();         // schedule a call in 10ms
```
isPending (Boolean, readonly)

This boolean property will be true if a call has been scheduled, and false otherwise.

cancel()

Cancels a pending call if one has been scheduled. Otherwise this method does nothing.

flush()

Cancels the timer and causes the pending call to execute immediately. If there is no pending call, this method does nothing.

now()

Cancels the timer (if one is pending) and executes the method immediately. If there is no pending call, this method will still call the underlying method.

loadUrl : String
AbstractCrudManagerMixin
Convenience shortcut to set only the url to load from, when you do not need to supply any other config options in the load section of the transport config.

Using loadUrl:
```
{
    loadUrl : 'read.php
}
```
Equals the following transport config:
```
{
    transport : {
        load : {
            url : 'read.php'
        }
    }
}
```
When read at runtime, it will return the value from transport.load.url.

Has a corresponding loadUrl config.
syncUrl : String
AbstractCrudManagerMixin
Convenience shortcut to set only the url to sync to, when you do not need to supply any other config options in the sync section of the transport config.

Using loadUrl:
```
{
    syncUrl : 'sync.php
}
```
Equals the following transport config:
```
{
    transport : {
        load : {
            url : 'sync.php'
        }
    }
}
```
When read at runtime, it will return the value from transport.sync.url.

Has a corresponding syncUrl config.

segmentModelClass : EventSegmentModel

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
    }
})

crudStoresJSON : Object

internal
AbstractCrudManagerMixin

Returns the data from all CrudManager crudStores in a format that can be consumed by inlineData.
enableProgressNotifications : Boolean

Enables/disables the calculation progress notifications.

Has a corresponding enableProgressNotifications config.
shouldSyncDataOnLoad : Function

ADVANCED
ProjectModelCommon
Experimental hook that lets the app determine if a bound dataset needs syncing with the store or not, and if it does - which records that should be processed. Only called for stores that are configured with syncDataOnLoad: true (which is the default in the React, Angular and Vue wrappers).

This is an experimental API that might change in any release until it has been finalized.

The main use case for this is for frameworks that update all state on any state change (like React), to not have to reapply the full bound dataset each time (which becomes costly).

If the app has a cheap way of determining (for example using a timestamp) that the dataset has no changes, return false from this hook to prevent the store from syncing at all at that time.
```
shouldSyncDataOnLoad({ store, data }) {
  if (store === myEventStore && timestamp <= lastUpdateTimestamp) {
    // Prevent sync when the event store has not changed since last time
    // (pseudocode)
    return false;
  }
}
```
If the app knows that something has changed, return a Set with ids for the records that should be further processed by the sync logic.
```
shouldSyncDataOnLoad({ store, data }) {
  if (store === myEventStore && timestamp > lastUpdateTimestamp) {
    // Sync only these records (pseudocode)
    return new Set([6, 110, 586]);
  }
}
```
Has a corresponding shouldSyncDataOnLoad config.
stm : StateTrackingManager
ProjectModelMixin

State tracking manager instance the project relies on

Has a corresponding stm config.
timeZone : String/Number
ProjectModelTimeZoneMixin
Set to a IANA time zone (i.e. Europe/Stockholm) or a UTC offset in minutes (i.e. -120). This will convert all events, tasks and time ranges to the specified time zone or offset. It will also affect the displayed timeline's headers as well at the start and end date of it.

There is currently no built-in time zone support in JavaScript which means that the converted dates technically still are in the local system time zone, but adjusted to match the configured time zone.

DST

If a IANA time zone is provided, there will be support for DST. But if local system time zone has DST that will affect the time zone conversion at the exact hour when the local system time zone switches DST on and off.

For example:
1. The local system time zone is Europe/Stockholm (which is UTC+1 or UTC+2 when DST).
2. The date 2022-03-27T07:00:00Z (which is UTC) is converted to America/Chicago (which is UTC-6 or UTC-5 when DST).
3. The converted JS date will be created from 2022-03-27T02:00:00 which is exactly the hour when Europe/Stockholm adds an DST hour. This has the effect that the converted date shows up incorrectly as 2022-03-27T03:00 instead.
If a UTC offset is provided, there is no DST support at all.

Editing

If creating new records or editing existing record dates, the dates will be interpreted as in the selected time zone.

If you want to create new records with dates that either should be interpreted as local system time zone or from any other time zone, specify the timeZone field on the record.

Saving

When saving or syncing data, the dates will be restored to local system time and converted to JSON ISO formatted. When restoring, it adds or subtracts the time difference accordingly. For instance, if the current timezone is UTC and you're in UTC +3, 3 hours will be added to the time.

The store.toJSON() and model.toJSON() methods also restores the data. For example, eventStore.toJSON() will show the dates in local timezone.

Has a corresponding timeZone config.
crudRevision : Number

READONLY
AbstractCrudManagerMixin

The server revision stamp. The revision stamp is a number which should be incremented after each server-side change. This property reflects the current version of the data retrieved from the server and gets updated after each load and sync call.
crudStores : CrudManagerStoreDescriptor[]
AbstractCrudManagerMixin

A list of registered stores whose server communication will be collected into a single batch. Each store is represented by a store descriptor.

Has a corresponding crudStores config.
forceSync : Boolean
AbstractCrudManagerMixin

Specify as true to force sync requests to be sent when calling sync(), even if there are no local changes. Useful in a polling scenario, to keep client up to date with the backend.

Has a corresponding forceSync config.
ignoreRemoteChangesInSTM : Boolean
AbstractCrudManagerMixin

Set to true to make STM ignore changes coming from the backend. This will allow user to only undo redo local changes.

Has a corresponding ignoreRemoteChangesInSTM config.
isChangeTrackingSuspended : Boolean

READONLY
AbstractCrudManagerMixin

Returns true if changes tracking is suspended
isCrudManagerLoading : Boolean

READONLY
AbstractCrudManagerMixin

Returns true if the crud manager is currently loading data
isCrudManagerSyncing : Boolean

READONLY
AbstractCrudManagerMixin

Returns true if the crud manager is currently syncing data
requestId : Number

internal

READONLY
AbstractCrudManagerMixin

Generates unique request identifier.
syncApplySequence : CrudManagerStoreDescriptor[]
AbstractCrudManagerMixin

An array of stores presenting an alternative sync responses apply order. Each store is represented by a store descriptor.

Has a corresponding syncApplySequence config.
trackProjectModelChanges : Booleantrue
ProjectCrudManager

If true, project changes API will also report project model changes: start/end date, calendar, effort, duration, etc.

Has a corresponding trackProjectModelChanges config.
isProjectModel : Booleantrue

READONLY

ADVANCED

Identifies an object as an instance of ProjectModel class, or subclass thereof.
isProjectModelMixin : Booleantrue

READONLY

ADVANCED
ProjectModelMixin

Identifies an object as an instance of ProjectModelMixin class, or subclass thereof.
catchEventHandlerExceptions : Booleanfalse

ADVANCED
Events

By default, if an event handler throws an exception, the error propagates up the stack and the application state is undefined. Code which follows the event handler will not be executed.

Set this to true to catch exceptions thrown by this object's event handlers and continue processing the event. The exception will be rethrown on a zero millisecond timeout, so it will not destroy the stack.

Has a corresponding catchEventHandlerExceptions config.
assignments : AssignmentModel[]/AssignmentModelConfig[]

Get/set assignmentStore data.

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

Has a corresponding assignments config.
calendars : CalendarModel[]/CalendarModelConfig[]

Get/set calendarManagerStore data.

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

Has a corresponding calendars config.
dependencies : DependencyModel[]/DependencyModelConfig[]

Get/set dependencyStore data.

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

Has a corresponding dependencies config.
events : EventModel[]/EventModelConfig[]

Get/set eventStore data.

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

Has a corresponding events config.
inlineData : Object
ProjectModelCommon
Get or set data of project stores. The returned data is identical to what toJSON returns:
```
const data = scheduler.project.inlineData;

// data:
{
    project            : { ... },
    events             : [...],
    resources          : [...],
    dependencies       : [...],
    assignments        : [...],
    resourceTimeRanges : [...],
    timeRanges         : [...]
}


// Plug it back in later
scheduler.project.inlineData = data;
```
The xxData properties are deprecated and will be removed in the future. Use xx instead. For example eventsData is deprecated, use events instead. For now, both naming schemes are included in the data object.

To stop including the legacy data properties, set includeLegacyDataProperties to false.
json : String
ProjectModelCommon
Get or set project data (records from its stores) as a JSON string.

Get a JSON string:
```
const project = new ProjectModel({
    events       : [...],
    resources    : [...],
    assignments  : [...],
    dependencies : [...]
});

const jsonString = project.json;

// jsonString:
'{"events":[...],"resources":[...],...}'
```
Set a JSON string (to populate the project stores):
```
project.json = '{"events":[...],"resources":[...],...}'
```
The xxData properties are deprecated and will be removed in the future. Use xx instead. For example eventsData is deprecated, use events instead. For now, both naming schemes are included in the data object

Has a corresponding json config.
resourceTimeRanges : ResourceTimeRangeModel[]/ResourceTimeRangeModelConfig[]

Get/set resourceTimeRangeStore data.

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

Has a corresponding resourceTimeRanges config.
resources : ResourceModel[]/ResourceModelConfig[]

Get/set resourceStore data.

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

Has a corresponding resources config.
timeRanges : TimeSpan[]/TimeSpanConfig[]

Get/set timeRangeStore data.

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

Has a corresponding timeRanges config.
lazyLoad : Boolean/Object
LazyLoadCrudManager

If set to true, or a config object, this makes the CrudManager load records only when needed. When a record or a date range that is not already loaded is requested, a load request will be made to the specified URL. More more details about lazy loading, see the guide

Has a corresponding lazyLoad config.
includeLegacyDataProperties : Boolean

DEPRECATED
ProjectModelCommon

Deprecated:
6.3.0 This config will be removed when the eventsData, resourcesData etc. properties are removed in a future release.

Whether to include legacy data properties in the JSON / inlineData output. The legacy data properties are the xxData (eventsData, resourcesData etc.) properties that are deprecated and will be removed in the future.

Has a corresponding includeLegacyDataProperties config.
callOnFunctions : Booleanfalse
Events
Set to true to call onXXX method names (e.g. onShow, onClick), as an easy way to listen for events.
```
const container = new Container({
    callOnFunctions : true

    onHide() {
         // Do something when the 'hide' event is fired
    }
});
```
Has a corresponding callOnFunctions config.
assignmentStore : AssignmentStore

The store holding the assignment information.

See also AssignmentModel

Has a corresponding assignmentStore config.
calendarManagerStore : CalendarManagerStore

The store holding the calendar information.

See also CalendarModel

Has a corresponding calendarManagerStore config.

changes : Object

READONLY

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' }]
    },
    ...
}

dependencyStore : DependencyStore

The store holding the dependency information.

See also DependencyModel

Has a corresponding dependencyStore config.
eventStore : EventStore

The store holding the event information.

See also EventModel

Has a corresponding eventStore config.
resourceStore : ResourceStore

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

See also ResourceModel

Has a corresponding resourceStore config.
resourceTimeRangeStore : ResourceTimeRangeStore
ProjectModelMixin

The store holding the resource time ranges information.

See also ResourceTimeRangeModel

Has a corresponding resourceTimeRangeStore config.
timeRangeStore : Store
ProjectModelMixin

The store holding the time ranges information.

See also TimeSpan

Has a corresponding timeRangeStore config.

Functions

Functions are methods available for calling on the class

setupDelayableMethods( delayable, cls )

private

static
Delayable

This method initializes the delayable methods on this class.

commitAsync( )
: Promise

ASYNC
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
}
```
acceptChanges( )
AbstractCrudManagerMixin
Accepts all changes in all stores, resets the modification tracking:
- Clears change tracking for all records
- Clears added
- Clears modified
- Clears removed Leaves the store in an "unmodified" state.
addCrudStore( store, position, fromStore )
AbstractCrudManagerMixin
Adds a store to the collection.
```
// append stores to the end of collection
crudManager.addCrudStore([
    store1,
    // storeId
    'bar',
    // store descriptor
    {
        storeId : 'foo',
        store   : store3
    },
    {
        storeId         : 'bar',
        store           : store4,
        // to write all fields of modified records
        writeAllFields  : true
    }
]);
```
Note: Order in which stores are kept in the collection is very essential sometimes. Exactly in this order the loaded data will be put into each store.

When adding a store to the CrudManager, make sure the server response format is correct for load and sync requests. Learn more in the Working with data guide.
addStoreToApplySequence( store, position, fromStore )
AbstractCrudManagerMixin
Adds a store to the alternative sync responses apply sequence. By default, the order in which sync responses are applied to the stores is the same as they registered in. But this order can be changes either on construction step using syncApplySequence option or by calling this method.

Please note, that if the sequence was not initialized before this method call then you will have to do it yourself like this for example:
```
// alternative sequence was not set for this crud manager
// so let's fill it with existing stores keeping the same order
crudManager.addStoreToApplySequence(crudManager.crudStores);

// and now we can add our new store

// we will load its data last
crudManager.addCrudStore(someNewStore);
// but changes to it will be applied first
crudManager.addStoreToApplySequence(someNewStore, 0);
```
add registered stores to the sequence along with the store(s) you want to add
applyChangeset( changes, transformFn, phantomIdField$PhantomId, clearChangestrue )
AbstractCrudManagerMixin
Applies a set of changes, as an object keyed by store id, to the affected stores. This function is intended to use in apps that handle their own data syncing, it is not needed when using the CrudManager approach.

Example of a changeset:
```
project.applyChangeset({
    events : {
        added : [
            { id : 10, name : 'Event 10', startDate : '2022-06-07' }
        ],
        updated : [
            { id : 5, name : 'Changed' }
        ],
        removed : [
            { id : 1 }
        ]
    },
    resources : { ... },
    ...
});
```
Optionally accepts a transformFn to convert an incoming changeset to the expected format. See applyChangeset for more details.

Setting clearChanges param to false will result in restoring the changes on the store applied using the applyChangeset method. By default, it has been set to true to clear all the applied changes on the store.

For example, following will restore the changes on the store:
```
// Apply these changes using the applyChangeset method
project.applyChangeset({
    events : {
        added : [
            { id : 10, name : 'Event 10', startDate : '2022-06-07' }
        ],
        updated : [
            { id : 5, name : 'Changed' }
        ],
        removed : [
            { id : 1 }
        ]
    },
    resources : { ... },
    ...
}, null, '$PhantomId', false);
```
In SchedulerPro and Gantt, when autoSync is enabled, and client wants to apply changes without triggering a sync request, applyProjectChanges method should be used instead of this. It helps maintain current behavior while providing flexibility for scenarios where syncing is not required.
applyProjectChanges( changes )
: Promise

ASYNC
ProjectChangeHandlerMixin
Allows applying changes from one project to another. For method to produce correct results, projects should be isomorphic - they should use same models and store configuration, also data in source and target projects should be identical before changes to the source project are made and applied to the target project. This method is meant to apply changes in real time - as source project is changed, changes should be applied to the target project before it is changed. When changes are applied all changes are committed and project is recalculated, which means target project won't have any local changes after.

Usage:
```
// Collect changes from first project
const { changes } = projectA;

// Apply changes to second project
await projectB.applyProjectChanges(changes);
```
This method will override local fields with values from the changes object and commit changed fields. It will keep changes in the project, if they are not present in the changes object.

When autoSync is enabled, and client wants to apply changes without triggering a sync request, this method should be used instead of applyChangeset. It helps maintain current behavior while providing flexibility for scenarios where syncing is not required.
cancelRequest( requestPromise )
AjaxTransport

Cancels an ongoing request.

crudStoreHasChanges( storeId )

: Boolean

AbstractCrudManagerMixin

Returns true if any of registered stores (or some particular store) has non persisted changes.

// if we have any unsaved changes
if (crudManager.crudStoreHasChanges()) {
    // persist them
    crudManager.sync();
// otherwise
} else {
    alert("There are no unsaved changes...");
}

decode( responseText )
: Object

JsonEncoder

Decodes (parses) a JSON response string to an object. If parsing fails, it returns null. Supposed to be overridden in case data provided by server has to be transformed into format requested by the Crud Manager.
encode( requestData )
: String

JsonEncoder

Encodes a request object to JSON encoded string. If encoding fails (due to circular structure), it returns null. Supposed to be overridden in case data provided by the Crud Manager has to be transformed into format requested by server.
getCrudStore( storeId )
: Store

AbstractCrudManagerMixin

Returns a registered store.
getStoreDescriptor( storeId )
: CrudManagerStoreDescriptor

AbstractCrudManagerMixin

Returns a registered store descriptor.

load( options )

: Promise

ASYNC

AbstractCrudManagerMixin

Loads data to the stores registered in the crud manager. For example:

crudManager.load(
    // here are request parameters
    {
        store1 : { append : true, page : 3, smth : 'foo' },
        store2 : { page : 2, bar : '!!!' }
    }
).then(
    () => alert('OMG! It works!'),
    ({ response, cancelled }) => console.log(`Error: ${cancelled ? 'Cancelled' : response.message}`)
);

** Note: ** If there is an incomplete load request in progress then system will try to cancel it by calling cancelRequest.

loadCrudManagerData( response, options )
: Promise

ASYNC
AbstractCrudManagerMixin

Loads data to the Crud Manager
removeCrudStore( store )
AbstractCrudManagerMixin
Removes a store from collection. If the store was registered in alternative sync sequence list it will be removed from there as well.
```
// remove store having storeId equal to "foo"
crudManager.removeCrudStore("foo");

// remove store3
crudManager.removeCrudStore(store3);
```
removeStoreFromApplySequence( store )
AbstractCrudManagerMixin
Removes a store from the alternative sync sequence.
```
// remove store having storeId equal to "foo"
crudManager.removeStoreFromApplySequence("foo");
```
resumeAutoSync( doSynctrue )
AbstractCrudManagerMixin

Resumes automatic sync upon store changes. Will schedule a sync if the internal counter is 0.
resumeChangeTracking( skipChangeCheck )
AbstractCrudManagerMixin

Resumes hasChanges and noChanges events. By default, it will check for changes and if there are any, hasChanges or noChanges event will be triggered.
revertChanges( )
AbstractCrudManagerMixin

Reverts all changes in all stores and re-inserts any records that were removed locally. Any new uncommitted records will be removed.
sendRequest( request )
: Promise

ASYNC
AjaxTransport

Sends a Crud Manager request to the server.

Triggers: beforeSend
suspendAutoSync( )
AbstractCrudManagerMixin

Suspends automatic sync upon store changes. Can be called multiple times (it uses an internal counter).
suspendChangeTracking( )
AbstractCrudManagerMixin

Suspends hasChanges and noChanges events.
sync( )
: Promise

ASYNC
AbstractCrudManagerMixin
Persists changes made on the registered stores to the server and/or receives changes made on the backend. Usage:
```
// persist and run a callback on request completion
crud.sync().then(
    () => console.log("Changes saved..."),
    ({ response, cancelled }) => console.log(`Error: ${cancelled ? 'Cancelled' : response.message}`)
);
```
** Note: ** If there is an incomplete sync request in progress then system will queue the call and delay it until previous request completion. In this case syncDelayed event will be fired.

** Note: ** Please take a look at autoSync config. This option allows persisting changes automatically after any data modification.

** Note: ** By default a sync request is only sent if there are any local changes. To always send a request when calling this function, configure forceSync as true.
asap( fn, options )
: Function

internal
Delayable

Returns a function that when called will schedule a call to fn via queueMicrotask.
buffer( fn, options )
: Function

internal
Delayable

Wraps a function with another function that delays it specified amount of time, repeated calls to the wrapper resets delay.
cancelAnimationFrame( handle )

internal
Delayable

Relays to native cancelAnimationFrame and removes from tracking.
cancelIdleCallback( handle )

internal
Delayable

Relays to native cancelIdleCallback and removes from tracking.
cancelMicrotask( task )

internal
Delayable

Given the return value from a call to queueMicrotask, cancels the pending call. This method is provided for symmetry with other timer functions, such as setTimeout.
clearInterval( id )

internal
Delayable

clearInterval wrapper
clearTimeout( idOrName )

internal
Delayable

clearTimeout wrapper, either call with timeout id as normal clearTimeout or with timeout name (if you specified a name to setTimeout()) property to null.
createOnFrame( fn, args, thisObj, cancelOutstandingfalse )
: Function

Delayable

Creates a function which will execute once, on the next animation frame. However many time it is called in one event run, it will only be scheduled to run once.
decorateWrapFn( me, wrapFn, cancelFnclearTimeout )
: Function

private
Delayable

Decorates the supported wrapFn with additional methods and an isPending readonly property. These decorations are available to user code to help manage the scheduling behavior of the buffered function.
hasTimeout( name )

internal
Delayable

Check if a named timeout is active
makeInvoker( me, fn, wrapFn, options )
: Function

private
Delayable

Creates and returns a function that will call the user-supplied fn.
queueMicrotask( fn, args, options )
: Function

internal
Delayable

Equivalent to the native queueMicrotask, but will be cancelled automatically on destroy. When queueMicrotask is not available, the provided fn is called using Promise.resolve().then(fn), which behaves similarly.

Returns a function that when called will cancel the impending call. This function can also be viewed as a timer id that can be passed to cancelMicrotask
raf( fn, options )
: Function

internal
Delayable

Returns a function that when called will schedule a call to fn on the next animation frame.
requestAnimationFrame( fn, extraArgs, thisObj )
: Number

internal
Delayable

Relays to native requestAnimationFrame and adds to tracking to have call automatically canceled on destroy.
requestIdleCallback( fn, extraArgs, thisObj )
: Number

internal
Delayable

Relays to native requestIdleCallback and adds to tracking to have call automatically canceled on destroy.
setInterval( fn, delay, name )
: Number

internal
Delayable

Same as native setInterval, but will be cleared automatically on destroy
setTimeout( timeoutSpec )
: Number

internal
Delayable

Same as native setTimeout, but will be cleared automatically on destroy. If a propertyName is supplied it will be used to store the timeout id.
throttle( fn, options )

internal
Delayable

Create a "debounced" function which will call on the "leading edge" of a timer period. When first invoked will call immediately, but invocations after that inside its buffer period will be rejected, and one invocation will be made after the buffer period has expired.

This is useful for responding immediately to a first mousemove, but from then on, only calling the action function on a regular timer while the mouse continues to move.
addListener( config, thisObj, oldThisObj )
: Function

Events
Adds an event listener. This method accepts parameters in the following format:
```
 myObject.addListener({
     thisObj    : this,          // The this reference for the handlers
     eventname2 : 'functionName' // Resolved at invocation time using the thisObj,
     otherevent : {
         fn      : 'handlerFnName',
         once    : true          // Just this handler is auto-removed on fire
     },
     yetanother  : {
         fn      : 'yetAnotherHandler',
         args    : [ currentState1, currentState2 ] // Capture info to be passed to handler
     },
     prio        : 100           // Higher prio listeners are called before lower
 });
```
When listeners have a thisObj option, they are linked to the lifecycle of that object. When it is destroyed, those listeners are removed.

The config parameter allows supplying options for the listener(s), for available options see BryntumListenerConfig.

A simpler signature may be used when only adding a listener for one event and no extra options (such as once or delay) are required:
```
myObject.addListener('click', myController.handleClicks, myController);
```
The args in this simple case are eventName, handler and thisObj

By default, if an event handler throws an exception, the error propagates up the stack and the application state is undefined. Code which follows the event handler will not be executed. Set the catchEventHandlerExceptions config to true to catch exceptions thrown by this object's event handlers and allow the event to continue processing. The exception will be rethrown on a zero millisecond timeout,
attachAutoDetacher( )

private
Events

Internal function used to hook destroy() calls when using thisObj
await( eventName, options )
: Promise

private

ASYNC
Events
detachAutoDetacher( )

private
Events

Internal function used restore hooked destroy() calls when using thisObj
doDestroy( )

internal
Events

Auto detaches listeners registered from start, if set as detachable
findListener( eventName, listenerToFind, defaultThisObj )

internal
Events

Finds the index of a particular listener to the named event. Returns -1 if the passed function/thisObj listener is not present.
hasListener( eventName )
: Boolean

ADVANCED
Events

Returns true if any listener is registered for the specified eventName, or if null, for any event.
ion( )

internal
Events

Internal convenience method for adding an internal listener, that cannot be removed by the user.

Alias for on({ $internal : true, ... }). Only supports single argument form.
numListeners( eventName )
: Number

internal
Events

Returns the number of attached listener for the specified eventName, or if null, for any event.

on( config, thisObj, oldThisObj )

: Function

Events

Alias for addListener. Adds an event listener. This method accepts parameters in the following format:

 myObject.on({
     thisObj    : this,          // The this reference for the handlers
     eventname2 : 'functionName' // Resolved at invocation time using the thisObj,
     otherevent : {
         fn      : 'handlerFnName',
         once    : true          // Just this handler is auto-removed on fire
     },
     yetanother  : {
         fn      : 'yetAnotherHandler',
         args    : [ currentState1, currentState2 ] // Capture info to be passed to handler
     },
     prio        : 100           // Higher prio listeners are called before lower
 });

When listeners have a thisObj option, they are linked to the lifecycle of that object. When it is destroyed, those listeners are removed.

The config parameter allows supplying options for the listener(s), for available options see BryntumListenerConfig.

A simpler signature may be used when only adding a listener for one event and no extra options (such as once or delay) are required:

myObject.on('click', myController.handleClicks, myController);

The args in this simple case are eventName, handler and thisObj

onListen( eventName )

internal
Events

This method is called when the first listener for an event is added.
onUnlisten( eventName )

internal
Events

This method is called when the last listener for an event is removed.
once( )

private
Events

Internal function used to run a callback function after an event is triggered

relayAll( through, prefix, transformCasetrue )

ADVANCED

Events

Relays all events through another object that also implements Events mixin. Adds a prefix to the event name before relaying, for example add -> storeAdd

// Relay all events from store through grid, will make it possible to listen for store events prefixed on grid:
'storeLoad', 'storeChange', 'storeRemoveAll' etc.
store.relayAll(grid, 'store');

grid.on('storeLoad', () => console.log('Store loaded');

removeAllListeners( )
Events

Removes all listeners registered to this object by the application.
removeListener( config, thisObj, oldThisObj )
: Boolean

Events

Removes an event listener. Same API signature as addListener
resumeEvents( )
: Boolean

ADVANCED
Events

Resume event triggering after a call to suspendEvents(). If any triggered events were queued they will be triggered.
suspendEvents( queuefalse )

ADVANCED
Events

Prevents events from being triggered until resumeEvents() is called. Optionally queues events that are triggered while suspended. Multiple calls stack to require matching calls to resumeEvents() before actually resuming.
trigger( eventName, param )
: Boolean/Promise

ASYNC

ADVANCED
Events

Triggers an event, calling all registered listeners with the supplied arguments. Returning false from any listener makes function return false.

By default, if an event handler throws an exception, the error propagates up the stack and the application state is undefined. Code which follows the event handler will not be executed. Set the catchEventHandlerExceptions config to true to catch exceptions thrown by this object's event handlers and allow the event to continue processing. The exception will be rethrown on a zero millisecond timeout,
un( config, thisObj, oldThisObj )
: Boolean

Events

Shorthand for removeListener

loadInlineData( dataPackage )

: Promise

ASYNC

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.

Triggers: load

toJSON( )

: Object

ProjectModelCommon

Returns the data from the records of the projects stores, in a format that can be consumed by loadInlineData().

Used by JSON.stringify to correctly convert this record to json.

The output format is determined by the value of toJSONResultFormat, as follows:

inlineData - Returns all crud store data, plus the project fields (under the project key)
model - Returns only the project fields

const project = new ProjectModel({
    // Include both store data and project model fields in toJSON() result
    toJSONResultFormat     : 'inlineData',
    events             : [...],
    resources          : [...],
    assignments        : [...],
    dependencies       : [...],
    resourceTimeRanges : [...],
    timeRanges         : [...]
});

const json = project.toJSON();

// json:
{
    events             : [...],
    resources          : [...],
    assignments        : [...],
    dependencies       : [...],
    ...
    project                : {
        addConstraintOnDateSet : false,
        daysPerMonth           : 13
        daysPerWeek            : 3
        ...
    },
    ...
}

Output can be consumed by loadInlineData():

const json = project.toJSON();

// Plug it back in later
project.loadInlineData(json);

applyRevisions( revisions )
: Promise

ASYNC

ON-QUEUE
ProjectRevisionHandlerMixin

Applies an array of revisions to a local project
initRevisions( clientId, revisionIdbase )
ProjectRevisionHandlerMixin

Initializes revision feature on the project. Calling this API early is required for revisions to work.

queue( fn, handleReject )

ON-QUEUE

ProjectRevisionHandlerMixin

Use this method to organize project changes into transactions. Every queue call will create a sequential promise which cannot be interrupted by other queued functions. You can use async functions and await for any promises (including commitAsync) with one exception - you cannot await other queued calls and any other function/promise which awaits queued function. Otherwise, an unresolvable chain of promises will be created.

NOTE: Functions which call this method internally are marked with on-queue tag.

Examples:

// Invalid queue call which hangs promise chain
project.queue(async () => {
    const event = project.getEventStore().getById(1);
    await project.queue(() => {
        event.duration = 2;
        return project.commitAsync();
    })
})

// Valid queue call
project.queue(() => {
    const event = project.getEventStore().getById(1);

    // Consequent queue call will be chained after the current function in the next microtask.
    project.queue(() => {
        event.duration = 2;
        return project.commitAsync();
    })

    // Event duration is not yet changed - this condition is true
    if (event.duration !== 2) { }
})

Events

Events are triggered for certain actions in this class and can be listened for to react to those actions in your code

beforeDestroy
Events

Fires before an object is destroyed.
beforeLoad

PREVENTABLE
AbstractCrudManagerMixin

Fires before load request is sent. Return false to cancel load request.
beforeLoadApply

PREVENTABLE
AbstractCrudManagerMixin

Fires before loaded data get applied to the stores. Return false to prevent data applying. This event can be used for server data preprocessing. To achieve it user can modify the response object.
beforeResponseApply

PREVENTABLE
AbstractCrudManagerMixin

Fires before server response gets applied to the stores. Return false to prevent data applying. This event can be used for server data preprocessing. To achieve it user can modify the response object.

beforeSend

ASYNC

AjaxTransport

Fires before a request is sent to the server.

crudManager.on('beforeSend', function ({ params, type }) {
    // let's set "sync" request parameters
    if (type == 'sync') {
        // dynamically depending on "flag" value
        if (flag) {
            params.foo = 'bar';
        }
        else {
            params.foo = 'smth';
        }
    }
});

beforeSync

ASYNC

PREVENTABLE

AbstractCrudManagerMixin

Fires before sync request is sent. Return false to cancel sync request.

crudManager.on('beforesync', function() {
    // cannot persist changes before at least one record is added
    // to the `someStore` store
    if (!someStore.getCount()) return false;
});

beforeSyncApply

PREVENTABLE
AbstractCrudManagerMixin

Fires before sync response data get applied to the stores. Return false to prevent data applying. This event can be used for server data preprocessing. To achieve it user can modify the response object.
catchAll
Events

Fires when any other event is fired from the object.

Note: catchAll is fired for both public and private events. Please rely on the public events only.
change
ProjectModelMixin

Fired when data in any of the projects stores changes.

Basically a relayed version of each stores own change event, decorated with which store it originates from. See the store change event documentation for more information.
cycle

Fired when the Engine detects a computation cycle.

dataReady

Fired when the engine has finished its calculations and the results has been written back to the records.

scheduler.project.on({
    dataReady() {
       console.log('Calculations finished');
    }
});

scheduler.eventStore.first.duration = 10;

// At some point a bit later it will log 'Calculations finished'

destroy
Events

Fires when an object is destroyed.
emptyCalendar

Fired when the Engine detects a calendar misconfiguration when the calendar does not provide any working periods of time which makes the calendar usage impossible.

hasChanges

AbstractCrudManagerMixin

Fires when data in any of the registered data stores is changed.

    crudManager.on('hasChanges', function (crud) {
        // enable persist changes button when some store gets changed
        saveButton.enable();
    });

You can suspend this event with suspendChangeTracking API call.

load
AbstractCrudManagerMixin

Fires on successful load request completion after data gets loaded to the stores.
loadCanceled
AbstractCrudManagerMixin

Fired after load request was canceled by some beforeLoad listener or due to incomplete prior load request.
loadFail
AbstractCrudManagerMixin

Fires when a load request fails.
noChanges
AbstractCrudManagerMixin
Fires when registered stores get into state when they don't have any not persisted change. This happens after load or sync request completion. Or this may happen after a record update which turns its fields back to their original state.
```
crudManager.on('nochanges', function (crud) {
    // disable persist changes button when there is no changes
    saveButton.disable();
});
```
You can suspend this event with suspendChangeTracking API call.
progress

Fired during the Engine calculation if enableProgressNotifications config is true
requestDone
AbstractCrudManagerMixin

Fires on successful request completion after data gets applied to the stores.
requestFail
AbstractCrudManagerMixin

Fires when a request fails.
revisionNotification
ProjectRevisionHandlerMixin

This event triggers when a new revision is added to the project. It is used to notify the backend about the new revision.
schedulingConflict

Fired when the Engine detects a scheduling conflict.
sync
AbstractCrudManagerMixin

Fires on successful sync request completion.
syncCanceled
AbstractCrudManagerMixin

Fires after sync request was canceled by some beforeSync listener.
syncDelayed
AbstractCrudManagerMixin

Fires after sync request was delayed due to incomplete previous one.
syncFail
AbstractCrudManagerMixin

Fires when a sync request fails.

Event handlers

Event handlers are callbacks called as a result of certain actions in this class

onBeforeDestroy
Events

Called before an object is destroyed.
onBeforeLoad

PREVENTABLE
AbstractCrudManagerMixin

Called before load request is sent. Return false to cancel load request.
onBeforeLoadApply

PREVENTABLE
AbstractCrudManagerMixin

Called before loaded data get applied to the stores. Return false to prevent data applying. This event can be used for server data preprocessing. To achieve it user can modify the response object.
onBeforeResponseApply

PREVENTABLE
AbstractCrudManagerMixin

Called before server response gets applied to the stores. Return false to prevent data applying. This event can be used for server data preprocessing. To achieve it user can modify the response object.

onBeforeSend

ASYNC

AjaxTransport

Called before a request is sent to the server.

crudManager.on('beforeSend', function ({ params, type }) {
    // let's set "sync" request parameters
    if (type == 'sync') {
        // dynamically depending on "flag" value
        if (flag) {
            params.foo = 'bar';
        }
        else {
            params.foo = 'smth';
        }
    }
});

onBeforeSync

ASYNC

PREVENTABLE

AbstractCrudManagerMixin

Called before sync request is sent. Return false to cancel sync request.

crudManager.on('beforesync', function() {
    // cannot persist changes before at least one record is added
    // to the `someStore` store
    if (!someStore.getCount()) return false;
});

onBeforeSyncApply

PREVENTABLE
AbstractCrudManagerMixin

Called before sync response data get applied to the stores. Return false to prevent data applying. This event can be used for server data preprocessing. To achieve it user can modify the response object.
onCatchAll
Events

Called when any other event is called from the object.

Note: catchAll is called for both public and private events. Please rely on the public events only.
onChange
ProjectModelMixin

Called when data in any of the projects stores changes.

Basically a relayed version of each stores own change event, decorated with which store it originates from. See the store change event documentation for more information.
onCycle

Called when the Engine detects a computation cycle.

onDataReady

Called when the engine has finished its calculations and the results has been written back to the records.

scheduler.project.on({
    dataReady() {
       console.log('Calculations finished');
    }
});

scheduler.eventStore.first.duration = 10;

// At some point a bit later it will log 'Calculations finished'

onDestroy
Events

Called when an object is destroyed.
onEmptyCalendar

Called when the Engine detects a calendar misconfiguration when the calendar does not provide any working periods of time which makes the calendar usage impossible.

onHasChanges

AbstractCrudManagerMixin

Called when data in any of the registered data stores is changed.

    crudManager.on('hasChanges', function (crud) {
        // enable persist changes button when some store gets changed
        saveButton.enable();
    });

You can suspend this event with suspendChangeTracking API call.

onLoad
AbstractCrudManagerMixin

Called on successful load request completion after data gets loaded to the stores.
onLoadCanceled
AbstractCrudManagerMixin

Called after load request was canceled by some beforeLoad listener or due to incomplete prior load request.
onLoadFail
AbstractCrudManagerMixin

Called when a load request fails.
onNoChanges
AbstractCrudManagerMixin
Called when registered stores get into state when they don't have any not persisted change. This happens after load or sync request completion. Or this may happen after a record update which turns its fields back to their original state.
```
crudManager.on('nochanges', function (crud) {
    // disable persist changes button when there is no changes
    saveButton.disable();
});
```
You can suspend this event with suspendChangeTracking API call.
onProgress

Called during the Engine calculation if enableProgressNotifications config is true
onRequestDone
AbstractCrudManagerMixin

Called on successful request completion after data gets applied to the stores.
onRequestFail
AbstractCrudManagerMixin

Called when a request fails.
onRevisionNotification
ProjectRevisionHandlerMixin

This event triggers when a new revision is added to the project. It is used to notify the backend about the new revision.
onSchedulingConflict

Called when the Engine detects a scheduling conflict.
onSync
AbstractCrudManagerMixin

Called on successful sync request completion.
onSyncCanceled
AbstractCrudManagerMixin

Called after sync request was canceled by some beforeSync listener.
onSyncDelayed
AbstractCrudManagerMixin

Called after sync request was delayed due to incomplete previous one.
onSyncFail
AbstractCrudManagerMixin

Called when a sync request fails.

Source path

SchedulerPro/model/ProjectModel.js

ProjectModel

Built-in CrudManager

Working with inline data

Getting data

Setting data

Getting changed records

Monitoring data changes

Processing the data loaded from the server

Built-in StateTrackingManager

Useful configs

See also

Fields

Configs

Handlers as function name

Parameters

Returns

DST

Editing

Saving

Parameters

Parameters

Returns

Properties

Options

Delayable Method API

`isPending` (Boolean, readonly)

`cancel()`

`flush()`

`now()`

DST

Editing

Saving

Functions

Events

Event handlers

Source path

Inheritance tree2

Mixins6

Contents

ProjectModel

Built-in CrudManager

Working with inline data

Getting data

Setting data

Getting changed records

Monitoring data changes

Processing the data loaded from the server

Built-in StateTrackingManager

Useful configs

See also

Fields

Configs

Handlers as function name

Parameters

Returns

DST

Editing

Saving

Parameters

Parameters

Returns

Properties

Options

Delayable Method API

isPending (Boolean, readonly)

cancel()

flush()

now()

DST

Editing

Saving

Functions

Events

Event handlers

Source path

Inheritance tree2

Mixins6

Contents

`isPending` (Boolean, readonly)

`cancel()`

`flush()`

`now()`