DependencyStoreMixin
Mixin

This is a mixin, containing functionality related to managing dependencies.

It is consumed by the regular DependencyStore class and Scheduler Pros counterpart.

No results

Configs

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

allowedDependencyTypes : Number[]
An array of allowed dependency types. When set, only the specified dependency types can be created. Use values from DependencyModel.Type:
- 0 - StartToStart (SS)
- 1 - StartToEnd (SF)
- 2 - EndToStart (FS)
- 3 - EndToEnd (FF)
```
const scheduler = new Scheduler({
    project : {
        dependencyStore : {
            // Only allow Finish-to-Start and Start-to-Start dependencies
            allowedDependencyTypes : [DependencyModel.Type.EndToStart, DependencyModel.Type.EndToEnd]
        }
    }
});
```
When null (default), all dependency types are allowed.

This config affects:
- Drag-creating dependencies (invalid types will be rejected)
- The dependency editor type combo (only allowed types are shown)
- The Predecessors and Successors tabs in the Task Editor
loadPriority : Number

private

CrudManager must load stores in the correct order. Lowest first.
syncPriority : Number

private

CrudManager must sync stores in the correct order. Lowest first.

Properties

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

isDependencyStoreMixin : Booleantrue

READONLY

static

ADVANCED

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

isDependencyStoreMixin : Booleantrue

READONLY

ADVANCED

Identifies an object as an instance of DependencyStoreMixin class, or subclass thereof.
data : DependencyModelConfig
Applies a new dataset to the DependencyStore. Use it to plug externally fetched data into the store.

NOTE: References (fromEvent, toEvent) on the dependencies are determined async by a calculation engine. Thus they cannot be directly accessed after assigning the new dataset.

For example:
```
dependencyStore.data = [{ from, to }];
// dependencyStore.first.fromEvent is not yet available
```
To guarantee references are available, wait for calculations for finish:
```
dependencyStore.data = [{ from, to }];
await dependencyStore.project.commitAsync();
// dependencyStore.first.fromEvent is available
```
Alternatively use loadDataAsync() instead:
```
await dependencyStore.loadDataAsync([{ from, to }]);
// dependencyStore.first.fromEvent is available
```

Functions

Functions are methods available for calling on the class

getDependencyForSourceAndTargetEvents( sourceEvent, targetEvent )
: DependencyModel

Returns dependency model instance linking tasks with given ids. The dependency can be forward (from 1st task to 2nd) or backward (from 2nd to 1st).
getEventDependencies( event )
: DependencyModel[]

Returns all dependencies for a certain event (both incoming and outgoing)
getEventsLinkingDependency( sourceEvent, targetEvent )
: DependencyModel

Returns a dependency model instance linking given events if such dependency exists in the store. The dependency can be forward (from 1st event to 2nd) or backward (from 2nd to 1st).
getHighlightedDependencies( cls )
: DependencyBaseModel[]

Returns all dependencies highlighted with the given CSS class
isDependencyTypeAllowed( type )
: Boolean

Returns true if the specified dependency type is allowed according to the allowedDependencyTypes configuration.
isValidDependency( dependencyOrFromId, toId, type )
: Boolean

ASYNC

Validation method used to validate a dependency. Override and return true to indicate that an existing dependency between two tasks is valid. For a new dependency being created please see isValidDependencyToCreate.
isValidDependencyToCreate( fromId, toId, type )
: Boolean

ASYNC

Validation method used to validate a dependency while creating. Override and return true to indicate that a new dependency is valid to be created.

add( records, silent )

: DependencyModel[]

Add dependencies to the store.

NOTE: References (fromEvent, toEvent) on the dependencies are determined async by a calculation engine. Thus they cannot be directly accessed after using this function.

For example:

const [dependency] = dependencyStore.add({ from, to });
// dependency.fromEvent is not yet available

To guarantee references are set up, wait for calculations for finish:

const [dependency] = dependencyStore.add({ from, to });
await dependencyStore.project.commitAsync();
// dependency.fromEvent is available (assuming EventStore is loaded and so on)

Alternatively use addAsync() instead:

const [dependency] = await dependencyStore.addAsync({ from, to });
// dependency.fromEvent is available (assuming EventStore is loaded and so on)

addAsync( records, silent )
: DependencyModel[]

ASYNC
Add dependencies to the store and triggers calculations directly after. Await this function to have up to date references on the added dependencies.
```
const [dependency] = await dependencyStore.addAsync({ from, to });
// dependency.fromEvent is available (assuming EventStore is loaded and so on)
```
loadDataAsync( data )
: Promise

ASYNC
Applies a new dataset to the DependencyStore and triggers calculations directly after. Use it to plug externally fetched data into the store.
```
await dependencyStore.loadDataAsync([{ from, to }]);
// dependencyStore.first.fromEvent is available
```

Source path

Scheduler/data/mixin/DependencyStoreMixin.js

Inheritance tree1

DependencyStoreMixin

DependencyStoreMixin Mixin