ProjectModel

Constructs a new record from the supplied data config.

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
}

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

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

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

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

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.

Classes implement this method to provide custom cleanup logic before calling super.doDestroy(). The general pattern is as follows:

 class Foo extends Base {
     doDestroy() {
         // perform custom cleanup

         super.doDestroy();
     }
 }

This method is called by destroy which also prevents multiple calls from reaching doDestroy. Prior to calling doDestroy, isDestroying is set to true. Upon return, the object is fully destructed and isDestroyed is set to true.

Do not call this method directly. Instead call destroy.

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.

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

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