TimePhasedProjectModel

Constructs a new record from the supplied data config.

Overrides the project owned store identifiers calculation and launches rescheduling.

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.

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

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

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

Cancels an ongoing request.

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

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.

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.

Returns a registered store.

Returns a registered store descriptor.

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.

Loads data to the Crud Manager

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

Removes a store from the alternative sync sequence.

// remove store having storeId equal to "foo"
crudManager.removeStoreFromApplySequence("foo");

Resumes automatic sync upon store changes. Will schedule a sync if the internal counter is 0.

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

Sends a Crud Manager request to the server.

Triggers: beforeSend

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.

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.

Begin a batch, which stores changes and commits them when the batch ends. Prevents events from being fired during batch.

record.beginBatch();
record.name = 'Mr Smith';
record.team = 'Golden Knights';
record.endBatch();

Please note that you can also set multiple fields in a single call using set, which in many cases can replace using a batch:

record.set({
  name : 'Mr Smith',
  team : 'Golden Knights'
});

Clears tracked changes, used on commit. Does not revert changes.

Makes a copy of this model, assigning the specified id or a generated id and also allowing you to pass field values to the created copy. A copyOf property is set on the copy to reference the original record.

const record = new Model({ name : 'Super model', hairColor : 'Brown' });
const clone = record.copy({ name : 'Super model clone' });

End a batch, triggering events if data has changed.

Returns raw data from the encapsulated data object for the passed field name

Returns the unmodified value of the field, as in the value it had after the last commit. If the field has not been modified, the current value is returned.

Returns true if this Model currently has outstanding batched changes for the specified field name.

Returns true if this model has uncommitted changes for the provided field.

Removes this record from all stores (and in a tree structure, also from its parent if it has one).

Set value for the specified field. You can also use the generated setters if loading through a Store.

Setting a single field, supplying name and value:

record.set('name', 'Clark');

Setting multiple fields, supplying an object:

record.set({
    name : 'Clark',
    city : 'Metropolis'
});

NOTE: Do not modify fields using dataSource, as it is intended only for reading and writing from the raw data object. Fields should be modified using name as it is the public interface.

Triggers: idChange, update, change

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,

Removes all event listeners that were registered with the passed names.

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

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

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

Removes an event listener. Same API signature as addListener

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

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.

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,

Shorthand for removeListener

Get value for specified field name. You can also use the generated getters if loading through a Store. If model is currently in batch operation this will return updated batch values which are not applied to Model until endBatch() is called.

Get the data source used by specified field. Returns the fieldName if no data source specified.

Convenience function to get the definition for a field from class.

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

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

await project.loadInlineData({
    tasks : [
        { 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 : [
        { fromTask : 1, toTask : 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

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

Represent the record as a string, by default as a JSON string. Tries to use an abbreviated version of the object's data, using id + name/title/text/label/description. If no such field exists, the full data is used.

const record = new Model({ id : 1, name : 'Steve Rogers', alias : 'Captain America' });
console.log(record.toString()); // logs { "id" : 1, "name" : "Steve Rogers" }

Base implementation applies configuration.

Subclasses need only implement this if they have to initialize instance specific properties required by the class. Often a construct method is unnecessary. All initialization of incoming configuration properties can be done in a set propName implementation.

Sets configuration options this object with all the properties passed in the parameter object. Timing is taken care of. If the setter of one config is called first, and references the value of another config which has not yet been set, that config will be set just in time, and the new value will be used.

Changes the value of a numeric property of this object smoothly over the specified duration.

Provides a way of calling callbacks which may have been specified as the name of a function and optionally adds scope resolution.

For example, if the callback is specified as a string, then if it is prefixed with 'this.' then the function is resolved in this object. This is useful when configuring listeners at the class level.

If the callback name is prefixed with 'up.' then the ownership hierarchy is queried using the owner property until an object with the named function is present, then the named function is called upon that object.

If a named function is not found, an error is thrown. If the function should be only called when present, and may not be present, add a ? as a suffix.

Experimental helper function, extracts the currently used configs and wraps them as an app, downloading the resulting JS file.

This function is intended to simplify creating test cases for issue reporting on Bryntum's support forum.

Compares this Model instance to the passed instance. If they are of the same type, and all fields (except, obviously, id) are equal, this returns true.

Creates a proxy record (using native Proxy) linked to this record (the original). The proxy records shares most data with the original, except for its id (which is always generated), and ordering fields such as parentIndex and parentId etc.

Any change to the proxy record will be reflected on the original, and vice versa. A proxy record is not meant to be persisted, only the original record should be persisted. Thus, proxy records are not added to stores change tracking (added, modified and removed records).

Removing the original record removes all proxies.

Creating a proxy record allows a Store to seemingly contain the record multiple times, something that is otherwise not possible. It also allows a record to be used in both a tree store and in a flat store.

Provides a way of locating callbacks which may have been specified as the name of a function and optionally adds scope resolution.

For example, if the callback is specified as a string, then if it is prefixed with 'this.' then the function is resolved in this object. This is useful when configuring listeners at the class level.

If the callback name is prefixed with 'up.' then the ownership hierarchy is queried using the owner property until an object with the named function is present, then the named function is called upon that object.

This method returns true if this record has all expanded ancestors and is therefore eligible for inclusion in a UI.

Append a child record(s) to any current children.

Bubbles up from this node, calling the specified function with each node.

Bubbles up from this node, calling the specified function with each node, while the function returns true.

Removes all child nodes from this node.

Checks if this model contains another model as one of it's descendants

Converts a leaf node to a parent node, assigning an empty array as its children

Count visible (expanded)/all children for this node, optionally specifying for which store.

Insert a child record(s) before an existing child record.

Used by stores to assess the record's collapsed/expanded state in that store.

Remove a child record. Only direct children of this node can be removed, others are ignored.

Replaces all child nodes with the new node set.

Traverses all child nodes recursively calling the passed function on a target node before iterating the child nodes.

Traverses all child nodes recursively calling the passed function on child nodes of a target before calling it on the node.

Traverses child nodes recursively while fn returns true

Defines if the given project field should be manually editable in UI. You can override this method to provide your own logic.

Sets the project start date and commits the changes.

Applies an array of revisions to a local project

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

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

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 a task in time
taskStore.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
}

Returns a calendar of the project. If task has never been assigned a calendar a project's calendar will be returned.

Resume propagation. If propagation is resumed (calls may be nested which increments a suspension counter), then if a call to propagate was made during suspension, propagate is executed.

Sets the calendar of the project. Will cause the schedule to be updated - returns a Promise