TimePhasedEventModel

Constructs a new record from the supplied data config.

Assigns this event to the specified resource.

Note: The event must be part of an EventStore for this to work. If the EventStore uses single assignment (loaded using resourceId) existing assignments will always be removed.

Returns either the resource associated with this event (when called w/o resourceId) or resource with specified id.

Returns true if this event is assigned to a certain resource.

Reassigns an event from an old resource to a new resource

Unassigns this event from the specified resource

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.

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

By default, the method defines endDate, duration and fullDuration fields editable for leaf events only (in case the event is part of a tree store) and all other fields as editable.

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

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

Set value for the specified field(s), triggering engine calculations immediately. See Model#set() for arguments.

eventRecord.set('duration', 4);
// eventRecord.endDate is not yet calculated

await eventRecord.setAsync('duration', 4);
// eventRecord.endDate is calculated

Indicates whether the event can perform the provided duration conversion. The event might not be able to convert units on early stages of data loading when the project has not loaded its conversion rates yet. So the method by default checks that the project has loaded the rates needed for conversion.

Converts a duration value from one time unit to another. The method is a generator since it embeds into the Engine scheduling mechanics.

If given resource is assigned to this event, returns a AssignmentModel record. Otherwise, returns null

Returns the event calendar.

Returns the event ignoreResourceCalendar field value.

Merges the event segments. The method merges two provided event segments (and all the segment between them if any).

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

Sets the constraint type and (optionally) constraining date to the event.

Updates the duration (and optionally unit) of the event. Will cause the schedule to be updated - returns a Promise

Updates the effort (and optionally unit) of the event. Will cause the schedule to be updated - returns a Promise

Sets the end date of the event. Will cause the schedule to be updated - returns a Promise

Note, that the actually set end date may be adjusted, according to the calendar, by skipping the non-working time backward.

Sets the event ignoreResourceCalendar field value and triggers rescheduling.

Either activates or deactivates the task depending on the passed value. Will cause the schedule to be updated - returns a Promise

Sets segments field value.

Sets the start date of the event. Will cause the schedule to be updated - returns a Promise

Note, that the actually set start date may be adjusted, according to the calendar, by skipping the non-working time forward.

Splits the event into segments.

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.

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

In most cases no point in calling it directly.

// This will call `toJSON()`
const json = JSON.stringify(record);

If called manually, the resulting object is a clone of record.data + the data of any children:

const record = new Model({
    title    : 'Hello',
    children : [
        ...
    ]
});

const jsonObject = record.toJSON();

// jsonObject:
{
    title : 'Hello',
    children : [
        ...
    ]
}

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.

Triggers a download of this time span in ICS format (for import in Outlook etc.)

timeSpan.downloadAsICS({
     LOCATION : timeSpan.location
 });

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

Adds an exception date that should be skipped when generating occurrences for the timespan. The method adds an entry to the array kept in exceptionDates field.

Returns the occurrences of this event over the specified time range. If the first occurrence is in the time range *this* record is included in that position.

Does this recurring event have an exception on the passed date.

Returns true if this recurring timespan has any occurrences within the specified date range. More efficient than getOccurrencesForDateRange when you only need to check existence, since it short-circuits on the first match without materializing all occurrences.

Sets a recurrence for the timespan with a given frequency, interval, and end.

Iterates over the dates

Shift the dates for the date range by the passed amount and unit

Splits this event into two pieces at the desired position.