ProjectModelMixin
Mixin

Mixin that holds configuration shared between projects in Scheduler and Scheduler Pro.

No results

Configs

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

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,
   ...
});
```
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.
stm : StateTrackingManagerConfig/StateTrackingManager

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.
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.

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
}

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

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.
timeRangesData : TimeSpan[]

DEPRECATED

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.
resourceTimeRangeStore : ResourceTimeRangeStore/ResourceTimeRangeStoreConfig

A ResourceTimeRangeStore instance or a config object.

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

The constructor to create a resource time range store instance with. Should be a class subclassing the ResourceTimeRangeStore
timeRangeStore : Store/StoreConfig

A Store instance or a config object.

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

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

isProjectModelCommon : Booleantrue

READONLY

static

ADVANCED
ProjectModelCommon

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

READONLY

static

ADVANCED

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

READONLY

static

ADVANCED
ProjectModelTimeZoneMixin

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

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

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.
isProjectModelMixin : Booleantrue

READONLY

ADVANCED

Identifies an object as an instance of ProjectModelMixin class, or subclass thereof.
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.
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.
resourceTimeRangeStore : ResourceTimeRangeStore

The store holding the resource time ranges information.

See also ResourceTimeRangeModel

Has a corresponding resourceTimeRangeStore config.
timeRangeStore : Store

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

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

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, TimeRangeStore and ResourceTimeRangeStore. 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 }
     ],
    resourceTimeRanges : [
        { id : 1, name : 'Resource range', resourceId : 1, startDate : '2017-01-08', endDate : '2017-01-10' }
    ],
    timeRanges : [
         { id : 1, startDate : '2017-01-26', name : 'Cool line' }
    ]
});

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

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

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

Events

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

change

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.

Event handlers

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

onChange

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.

ProjectModelMixin
Mixin

Configs

Parameters

Returns

DST

Editing

Saving

Properties

DST

Editing

Saving

Functions

Events

Event handlers

Source path

Inheritance tree1

Mixins2

Contents

ProjectModelMixin Mixin

Configs

Parameters

Returns

DST

Editing

Saving

Properties

DST

Editing

Saving

Functions

Events

Event handlers

Source path

Inheritance tree1

Mixins2

Contents

ProjectModelMixin
Mixin