Rules engine
  1. Miscellaneous
  2. Variables

Index

src/stores/rulesets/rulesets.actions.ts

ACTION_CANCEL_REQUEST
Type : string
Default value : '[Rulesets] cancel request'
ACTION_CLEAR_ENTITIES
Type : string
Default value : '[Rulesets] clear entities'

Entity Actions
ACTION_FAIL_ENTITIES
Type : string
Default value : '[Rulesets] fail entities'
ACTION_RESET
Type : string
Default value : '[Rulesets] reset'
ACTION_SET
Type : string
Default value : '[Rulesets] set'

StateDetailsActions
ACTION_SET_ENTITIES
Type : string
Default value : '[Rulesets] set entities'
ACTION_SET_ENTITIES_FROM_API
Type : string
Default value : '[Rulesets] set entities from api'

Async Actions
ACTION_UPDATE
Type : string
Default value : '[Rulesets] update'
ACTION_UPSERT_ENTITIES
Type : string
Default value : '[Rulesets] upsert entities'
ACTION_UPSERT_ENTITIES_FROM_API
Type : string
Default value : '[Rulesets] upsert entities from api'
cancelRulesetsRequest
Default value : createAction(ACTION_CANCEL_REQUEST, props<AsyncRequest>())

Action to cancel a Request ID registered in the store. Can happen from effect based on a switchMap for instance
clearRulesetsEntities
Default value : createAction(ACTION_CLEAR_ENTITIES)

Action to empty the list of entities, keeping the global state
failRulesetsEntities
Default value : createAction(ACTION_FAIL_ENTITIES, props<FailAsyncStoreItemEntitiesActionPayload<any>>())

Action to update failureStatus for every RulesetsModel
resetRulesets
Default value : createAction(ACTION_RESET)

Action to reset the whole state, by returning it to initial state.
setRulesets
Default value : createAction(ACTION_SET, props<SetActionPayload<RulesetsStateDetails>>())

Action to clear the StateDetails of the store and replace it
setRulesetsEntities
Default value : createAction(ACTION_SET_ENTITIES, props<SetAsyncStoreItemEntitiesActionPayload<RulesetsModel>>())

Action to clear all rulesets and fill the store with the payload
setRulesetsEntitiesFromApi
Default value : createAction(ACTION_SET_ENTITIES_FROM_API, asyncProps<FromApiActionPayload<RulesetsModel[]>>())

Action to put the global status of the store in a pending state. Call SET action with the list of RulesetsModels received, when this action resolves. If the call fails, dispatch FAIL_ENTITIES action
updateRulesets
Default value : createAction(ACTION_UPDATE, props<UpdateActionPayload<RulesetsStateDetails>>())

Action to change a part or the whole object in the store.
upsertRulesetsEntities
Default value : createAction(ACTION_UPSERT_ENTITIES, props<SetAsyncStoreItemEntitiesActionPayload<RulesetsModel>>())

Action to update rulesets with known IDs, insert the new ones
upsertRulesetsEntitiesFromApi
Default value : createAction(ACTION_UPSERT_ENTITIES_FROM_API, asyncProps<FromApiActionPayload<RulesetsModel[]>>())

Action to put global status of the store in a pending state. Call UPSERT action with the list of RulesetsModels received, when this action resolves. If the call fails, dispatch FAIL_ENTITIES action

src/engine/operator/operators/array-based.operators.ts

allEqual
Type : Operator<SupportedSimpleTypes[], SupportedSimpleTypes>
Default value : { name: 'allEqual', // eslint-disable-next-line eqeqeq -- possibility of comparing string and number values evaluator: (array, value) => array.every((elementValue) => elementValue == value), validateLhs: Array.isArray, validateRhs: isSupportedSimpleTypes }

Check if every value of the variable equals a specific value
allGreater
Type : Operator<SupportedSimpleTypes[], number | string>
Default value : { name: 'allGreater', evaluator: (array, value) => array.every((elementValue) => numberValidator(elementValue) && +elementValue > +value), validateLhs: Array.isArray, validateRhs: numberValidator }

Check if every numerical value of the variable is greater than a specific value
allIn
Type : Operator<SupportedSimpleTypes[], SupportedSimpleTypes[]>
Default value : { name: 'allIn', evaluator: (array, value) => array.every((elementValue) => value.includes(elementValue)), validateLhs: Array.isArray, validateRhs: Array.isArray }

Check if every value of the variable is in a specific list
allLower
Type : Operator<number[], number | string>
Default value : { name: 'allLower', evaluator: (arrayNumber, number) => arrayNumber.every((elementNumber) => elementNumber < +number), validateLhs: Array.isArray, validateRhs: numberValidator }

Check if every numerical value of the variable is lower than a specific value
allMatch
Type : Operator<string[], string>
Default value : { name: 'allMatch', evaluator: (array, inputRegExp) => { const regExp = parseRegExp(inputRegExp); return array.every((elementValue) => regExp.test(elementValue)); }, validateLhs: Array.isArray, validateRhs: isString }

Check if every string value of the variable matches a specific pattern
allNotIn
Type : Operator<SupportedSimpleTypes[], SupportedSimpleTypes[]>
Default value : { name: 'allNotIn', evaluator: (array, value) => !array.some((elementValue) => value.includes(elementValue)), validateLhs: Array.isArray, validateRhs: Array.isArray }

Check if every value of the variable is not in a specific list
allRangeNumber
Type : Operator<number[], >
Default value : { name: 'allRangeNumber', evaluator: (rangeArray, [from, to]) => rangeArray.every((elementValue) => elementValue >= +from && elementValue <= +to), validateLhs: Array.isArray, validateRhs: isRangeNumber }

Check if every value of the variable is included in a specified range
arrayBasedOperators
Type : []
Default value : [ allEqual, allGreater, allIn, allLower, allMatch, allNotIn, allRangeNumber, arrayContains, lengthEquals, lengthNotEquals, lengthGreaterThan, lengthGreaterThanOrEquals, lengthLessThan, lengthLessThanOrEquals, notArrayContains, notStringContains, oneEquals, oneGreater, oneIn, oneLower, oneMatches, oneRangeNumber, stringContains ]

List of all default array operators
arrayContains
Type : Operator<SupportedSimpleTypes[], SupportedSimpleTypes>
Default value : { name: 'arrayContains', evaluator: (value, b) => value.includes(b), validateLhs: Array.isArray, validateRhs: isSupportedSimpleTypes }

Check if any of the variable's value is equal to a specific value
lengthEquals
Type : Operator<any[], number | string>
Default value : { name: 'lengthEquals', evaluator: (array, length) => array.length === Number(length), validateLhs: Array.isArray, validateRhs: numberValidator }

Check if the number of values of the variable is equal to a specific value
lengthGreaterThan
Type : Operator<any[], number | string>
Default value : { name: 'lengthGreaterThan', evaluator: (array, length) => array.length > +length, validateLhs: Array.isArray, validateRhs: numberValidator }

Check if the number of values of the variable is greater than a specific value
lengthGreaterThanOrEquals
Type : Operator<any[], number | string>
Default value : { name: 'lengthGreaterThanOrEquals', evaluator: (array, length) => array.length >= +length, validateLhs: Array.isArray, validateRhs: numberValidator }

Check if the number of values of the variable is greater or equal to a specific value
lengthLessThan
Type : Operator<any[], number | string>
Default value : { name: 'lengthLessThan', evaluator: (array, length) => array.length < +length, validateLhs: Array.isArray, validateRhs: numberValidator }

Check if the number of values of the variable is lower than a specific value
lengthLessThanOrEquals
Type : Operator<any[], number | string>
Default value : { name: 'lengthLessThanOrEquals', evaluator: (array, length) => array.length <= +length, validateLhs: Array.isArray, validateRhs: numberValidator }

Check if the number of values of the variable is lower or equal to a specific value
lengthNotEquals
Type : Operator<any[], number | string>
Default value : { name: 'lengthNotEquals', evaluator: (array, length) => array.length !== Number(length), validateLhs: Array.isArray, validateRhs: numberValidator }

Check if the number of values of the variable is different from a specific value
notArrayContains
Type : Operator<SupportedSimpleTypes[], SupportedSimpleTypes>
Default value : { name: 'notArrayContains', evaluator: (array, value) => !array.includes(value), validateLhs: Array.isArray, validateRhs: isSupportedSimpleTypes }

Check if every value of the variable is different from a specific value
notStringContains
Type : Operator<string, string>
Default value : { name: 'notStringContains', evaluator: (inputString, substring: any) => !inputString.includes(substring), validateLhs: isString, validateRhs: isString }

Check if the specified text value is not included in the text variable
oneEquals
Type : Operator<SupportedSimpleTypes[], SupportedSimpleTypes>
Default value : { name: 'oneEquals', // eslint-disable-next-line eqeqeq -- possibility of comparing string and number values evaluator: (array, value) => array.some((elementValue) => elementValue == value), validateLhs: Array.isArray, validateRhs: isSupportedSimpleTypes }

Check if at least one of the values of the variable equals a specific value
oneGreater
Type : Operator<number[], number | string>
Default value : { name: 'oneGreater', evaluator: (arrayNumber, number) => arrayNumber.some((elementValue) => elementValue > +number), validateLhs: Array.isArray, validateRhs: numberValidator }

Check if one of the values of the variable is greater than a specific value
oneIn
Type : Operator<SupportedSimpleTypes[], SupportedSimpleTypes[]>
Default value : { name: 'oneIn', evaluator: (firstArray, secondArray) => firstArray.some((elementValue) => secondArray.includes(elementValue)), validateLhs: Array.isArray, validateRhs: Array.isArray }

Check if at least one of the values of the variable is equal to one in a specified list
oneLower
Type : Operator<number[], number | string>
Default value : { name: 'oneLower', evaluator: (arrayNumber, number) => arrayNumber.some((elementValue) => elementValue < +number), validateLhs: Array.isArray, validateRhs: numberValidator }

Check if one of the values of the variable is lower than a specific value
oneMatches
Type : Operator<string[], string>
Default value : { name: 'oneMatches', evaluator: (arrayString, inputRegExp) => { const regExp = parseRegExp(inputRegExp); return arrayString.some((elementValue) => regExp.test(elementValue)); }, validateLhs: Array.isArray, validateRhs: isString }

Check if one of the values of the variable matches a specific pattern
oneRangeNumber
Type : Operator<number[], >
Default value : { name: 'oneRangeNumber', evaluator: (arrayNumber, [from, to]) => arrayNumber.some((elementValue) => elementValue >= +from && elementValue <= +to), validateLhs: Array.isArray, validateRhs: isRangeNumber }

Check if one of the values of the variable is included in a specified range
stringContains
Type : Operator<string, string>
Default value : { name: 'stringContains', evaluator: (inputString, substring) => inputString.includes(substring), validateLhs: isString, validateRhs: isString }

Check if the specified text value is included in the text variable

src/engine/operator/operators/basic.operators.ts

basicOperators
Type : []
Default value : [ equals, inArray, inString, isDefined, isUndefined, matchesPattern, notEquals, notInArray, notInString ]

List of all default basic operators
equals
Type : Operator
Default value : { name: 'equals', // eslint-disable-next-line eqeqeq -- possibility of comparing string and number values evaluator: (firstValue, secondValue) => firstValue == secondValue }

Check if a variable is equal to a specific value
inArray
Type : Operator<SupportedSimpleTypes, SupportedSimpleTypes[]>
Default value : { name: 'inArray', evaluator: (value, array) => array.includes(value), validateLhs: isSupportedSimpleTypes, validateRhs: Array.isArray }

Check if the variable's value is included in a specified list
inString
Type : Operator<string, string>
Default value : { name: 'inString', evaluator: (value, inputString) => inputString.includes(value), validateLhs: isString, validateRhs: isString }

Check if the text variable is part of the specified value
isDefined
Type : UnaryOperator<any>
Default value : { name: 'isDefined', evaluator: (input) => input !== undefined && input !== null }

Check if the variable and its value are defined
isUndefined
Type : UnaryOperator<any>
Default value : { name: 'isUndefined', evaluator: (input) => input === undefined || input === null }

Check if the variable and its value are undefined
matchesPattern
Type : Operator<string, string>
Default value : { name: 'matchesPattern', evaluator: (value, inputRegExp) => { const regExp = parseRegExp(inputRegExp); return regExp.test(value); }, validateLhs: isString, validateRhs: isString }

Check if the text variable matches the specified RegExp pattern
notEquals
Type : Operator
Default value : { name: 'notEquals', // eslint-disable-next-line eqeqeq -- possibility of comparing string and number values evaluator: (firstValue, secondValue) => firstValue != secondValue }

Check if a variable is different from a specific value
notInArray
Type : Operator<SupportedSimpleTypes, SupportedSimpleTypes[]>
Default value : { name: 'notInArray', evaluator: (value, array) => !array.includes(value), validateLhs: isSupportedSimpleTypes, validateRhs: Array.isArray }

Check if the variable's value is not included in the value list
notInString
Type : Operator<string, string>
Default value : { name: 'notInString', evaluator: (value, inputString) => !inputString.includes(value), validateLhs: isString, validateRhs: isString }

Check if the text variable is not part of the specified value

src/components/rules-engine/rule-key-value/rule-key-value-pres.component.ts

CLIPBOARD_FEATURE_LENGTH_THRESHOLD
Type : number
Default value : 80

Minimal length required to enable clipboard feature
NOTIFICATION_DURATION
Type : number
Default value : 1750

Duration of the notification for clipboard feature (in milliseconds)

src/engine/operator/operators/date-based.operators.ts

dateAfter
Type : Operator<Date, DateInput, DateInput>
Default value : { name: 'dateAfter', evaluator: (leftDate, rightDate) => { const firstDateTime = new Date(leftDate).setHours(0, 0, 0, 0); const secondDateTime = new Date(rightDate).setHours(0, 0, 0, 0); return firstDateTime > secondDateTime; }, validateLhs: isValidDateInput, validateRhs: isValidDateInput }

Check if a date variable is posterior than a specified date
dateBasedOperators
Type : []
Default value : [ inRangeDate, dateInNextMinutes, dateNotInNextMinutes, dateAfter, dateBefore, dateEquals, dateNotEquals ]
dateBefore
Type : Operator<Date, DateInput, DateInput>
Default value : { name: 'dateBefore', evaluator: (leftDate, rightDate) => { const firstDateTime = new Date(leftDate).setHours(0, 0, 0, 0); const secondDateTime = new Date(rightDate).setHours(0, 0, 0, 0); return firstDateTime < secondDateTime; }, validateLhs: isValidDateInput, validateRhs: isValidDateInput }

Check if a date variable is prior than a specified date
dateEquals
Type : Operator<Date, DateInput, DateInput>
Default value : { name: 'dateEquals', evaluator: (leftDate, rightDate) => { const firstDateIgnoringHours = new Date(leftDate).setHours(0, 0, 0, 0); const secondDateIgnoringHours = new Date(rightDate).setHours(0, 0, 0, 0); return firstDateIgnoringHours === secondDateIgnoringHours; }, validateLhs: isValidDateInput, validateRhs: isValidDateInput }

Check if a date variable is the same as a specified date
dateInNextMinutes
Type : Operator<Date, number, DateInput, string | number>
Default value : { name: 'dateInNextMinutes', evaluator: (leftDateInput, minutes, operatorFactValues) => { if (!operatorFactValues) { throw new Error('No operatorFactValues. Unable to retrieve the current time.'); } if (typeof operatorFactValues.o3rCurrentTime !== 'number') { throw new Error('o3rCurrentTime value is not a number'); } const currentTimeValue = operatorFactValues.o3rCurrentTime; return inRangeDate.evaluator(leftDateInput, [currentTimeValue, currentTimeValue + +minutes * 60_000]); }, factImplicitDependencies: ['o3rCurrentTime'], validateLhs: isValidDateInput, validateRhs: numberValidator }

Check if the value of the variable is in the next x minutes
dateNotEquals
Type : Operator<Date, DateInput, DateInput>
Default value : { name: 'dateNotEquals', evaluator: (leftDate, rightDate) => { const firstDateIgnoringHours = new Date(leftDate).setHours(0, 0, 0, 0); const secondDateIgnoringHours = new Date(rightDate).setHours(0, 0, 0, 0); return firstDateIgnoringHours !== secondDateIgnoringHours; }, validateLhs: isValidDateInput, validateRhs: isValidDateInput }

Check if a date variable is different from a specified date
dateNotInNextMinutes
Type : Operator<Date, number, DateInput, string | number>
Default value : { name: 'dateNotInNextMinutes', evaluator: (leftDateInput, minutes, operatorFactValues) => { if (!operatorFactValues) { throw new Error('No operatorFactValues. Unable to retrieve the current time.'); } if (typeof operatorFactValues.o3rCurrentTime !== 'number') { throw new Error('o3rCurrentTime value is not a number'); } const currentTimeValue = operatorFactValues.o3rCurrentTime; const now = new Date(currentTimeValue); const leftDate = new Date(leftDateInput); const targetDate = new Date(new Date(currentTimeValue).setMinutes(now.getMinutes() + +minutes)); return leftDate >= now && leftDate > targetDate; }, factImplicitDependencies: ['o3rCurrentTime'], validateLhs: isValidDateInput, validateRhs: numberValidator }

Check if the value of the variable is not in the next x minutes
inRangeDate
Type : Operator<Date, , DateInput>
Default value : { name: 'inRangeDate', evaluator: (date, [from, to]) => { const dateObject = new Date(date); return new Date(from) <= dateObject && new Date(to) >= dateObject; }, validateLhs: isValidDateInput, validateRhs: isValidDateRange }

Check if a date variable is in a specified date range

src/services/rules-engine.token.ts

DEFAULT_RULES_ENGINE_OPTIONS
Type : Readonly<RulesEngineServiceOptions>
Default value : { dryRun: false, debug: false } as const

Default Rules engine options
RULES_ENGINE_OPTIONS
Default value : new InjectionToken<boolean>('Rules Engine Options')

Determine if the action should be executed

src/components/rules-engine/shared/ruleset-history.helper.ts

getStatus
Default value : (rulesetExecution: RulesetExecutionErrorEvent | RulesetExecutionEvent, isActive: boolean): RulesetExecutionStatus => { if (rulesetExecution.type === 'RulesetExecutionError') { return 'Error'; } else if (rulesetExecution.outputActions?.length === 0) { return 'NoEffect'; } else if (isActive) { return 'Active'; } return 'Deactivated'; }

Compute the status of the execution depending on its execution event type, the output and whether the execution is still active
rulesetReportToHistory
Default value : (events: DebugEvent[], rulesetMap: Record<string, Ruleset>): RulesetExecutionDebug[] => { const availableRulesets = (events.filter((e) => e.type === 'AvailableRulesets').reverse()[0])?.availableRulesets || []; const lastActiveRulesets = (events.filter((e) => e.type === 'ActiveRulesets').reverse()[0])?.rulesets || []; return availableRulesets .filter((ruleset) => !!ruleset) .reduce<(RulesetExecutionEvent | RulesetExecutionErrorEvent)[]>((acc, ruleset) => { const rulesetExecutions = events .filter((e): e is RulesetExecutionEvent | RulesetExecutionErrorEvent => ((e.type === 'RulesetExecutionError' || e.type === 'RulesetExecution') && e.rulesetId === ruleset.id)); if (rulesetExecutions) { acc.push(...rulesetExecutions); } return acc; }, []) .sort((execA, execB) => execB.timestamp - execA.timestamp) .map((rulesetExecution) => { const rulesetInformation = rulesetMap[rulesetExecution.rulesetId]; const isActive = lastActiveRulesets.find((r) => r.id === rulesetExecution.rulesetId); return { ...rulesetExecution, status: getStatus(rulesetExecution, !!isActive), isActive: !!isActive, rulesetInformation, rulesEvaluations: (rulesetExecution.rulesEvaluations || []).sort((evalA, evalB) => (rulesetInformation?.rules.findIndex((r) => r.id === evalA.rule.id) || -1) - (rulesetInformation?.rules.findIndex((r) => r.id === evalB.rule.id) || -1) ) }; }); }

Transform the output of the debug reports into the model for the ruleset history debug panel

src/engine/operator/operators/number-based.operators.ts

greaterThan
Type : Operator<number, number, number | string, number | string>
Default value : { name: 'greaterThan', evaluator: (firstNumber, secondNumber) => firstNumber > secondNumber, validateLhs: numberValidator, validateRhs: numberValidator }

Check if the number variable is greater than a specific value
greaterThanOrEqual
Type : Operator<number, number, number | string, number | string>
Default value : { name: 'greaterThanOrEqual', evaluator: (firstNumber, secondNumber) => firstNumber >= secondNumber, validateLhs: numberValidator, validateRhs: numberValidator }

Check if the number variable is greater or equal to a specific value
lessOrEqual
Type : Operator<number, number, number | string, number | string>
Default value : { name: 'lessOrEqual', evaluator: (firstNumber, secondNumber) => firstNumber <= secondNumber, validateLhs: numberValidator, validateRhs: numberValidator }

Check if the number variable is lower or equal to a specific value
lessThan
Type : Operator<number, number, number | string, number | string>
Default value : { name: 'lessThan', evaluator: (firstNumber, secondNumber) => firstNumber < secondNumber, validateLhs: numberValidator, validateRhs: numberValidator }

Check if the number variable is lower than a specific value
numberBasedOperators
Type : []
Default value : [greaterThan, greaterThanOrEqual, lessThan, lessOrEqual]

List of all default number based operators

src/engine/operator/operators/time-based.operators.ts

inRangeTime
Type : Operator<string, >
Default value : { name: 'inRangeTime', evaluator: (currentTime, [from, to]) => { const parseTime = (timeStr: string) => { const [hours, minutes] = timeStr.split(':').map((value) => +value); return hours * 60 + minutes; }; const currentMinutes = parseTime(currentTime); const startMinutes = parseTime(from); const endMinutes = parseTime(to); return startMinutes <= endMinutes ? currentMinutes >= startMinutes && currentMinutes <= endMinutes : currentMinutes >= startMinutes || currentMinutes <= endMinutes; }, validateLhs: isValidTimeInput, validateRhs: isValidTimeRange }

Check if the time variable is between the specified start and end times.

This method also supports time ranges that cross midnight. For example, a range from "23:00" to "02:00" will be true for an input like "00:30".
timeBasedOperators
Type : []
Default value : [ inRangeTime ]

List of all default time-based operators

src/devkit/rules-engine-devkit.interface.ts

isRulesEngineMessage
Default value : (message: any): message is AvailableRulesEngineMessageContents => { return message && ( message.dataType === 'rulesEngineEvents' || message.dataType === 'requestMessages' || message.dataType === 'connect' ); }

src/engine/operator/operator.helpers.ts

isValidDate
Default value : (operatorInput: any): operatorInput is Date => { if (!operatorInput || typeof operatorInput.getTime !== 'function') { return false; } const getTimeResult = operatorInput.getTime(); return typeof getTimeResult === 'number' && !Number.isNaN(getTimeResult); }

Verifies if the parameter is a valid date for the operator (getTime function available returning a number)
isValidDateInput
Default value : (operatorInput: any): operatorInput is DateInput => { return operatorInput === 0 || (!!operatorInput && isValidDate(new Date(operatorInput))); }

Verifies if the parameter is a valid input for Date constructor (new Date returns a valid date)
isValidDateRange
Default value : (operatorInput: any): operatorInput is [DateInput, DateInput] => { return Array.isArray(operatorInput) && operatorInput.length === 2 && isValidDateInput(operatorInput[0]) && isValidDateInput(operatorInput[1]) && new Date(operatorInput[0]) <= new Date(operatorInput[1]); }

Verifies if the parameter is a valid date range
isValidTimeInput
Default value : (operatorInput: any): operatorInput is string => { if (!isString(operatorInput) || !/^\d{1,2}:\d{2}$/.test(operatorInput)) { return false; } const [hours, minutes] = operatorInput.split(':').map((value) => +value); return hours < 24 && minutes < 60; }

Verifies if the parameter is a valid time input
isValidTimeRange
Default value : (operatorInput: any): operatorInput is [string, string] => { return Array.isArray(operatorInput) && operatorInput.length === 2 && isValidTimeInput(operatorInput[0]) && isValidTimeInput(operatorInput[1]); }

Verifies if the parameter is a valid time range

src/stores/rulesets/rulesets.selectors.ts

isValidDate
Default value : (d: any) => !Number.isNaN(d) && d instanceof Date

Check if the given value is a valid date
selectActiveRuleSets
Default value : createSelector( selectRuleSetsInRange, (ruleSets) => ruleSets .filter((ruleSet: Ruleset) => (!ruleSet.linkedComponents?.or?.length)) .map((ruleSet: Ruleset) => ruleSet.id))

Returns the rulesets ids which are not onDemand and in the validity range
selectAllRulesets
Default value : createSelector(selectRulesetsState, selectAll)

Select the array of Rulesets
selectComponentsLinkedToRuleset
Default value : createSelector( selectRuleSetsInRange, (ruleSets) => ruleSets .reduce((acc: { or: { [key: string]: string[] } }, ruleSet: Ruleset) => { if (!ruleSet.linkedComponents?.or || ruleSet.linkedComponents.or.length === 0) { return acc; } if (ruleSet.linkedComponents?.or?.length) { ruleSet.linkedComponents.or.forEach((linkComp) => { linkComponentToRuleset(linkComp.name, linkComp.library, ruleSet.id, acc.or); }); return acc; } return acc; }, { or: {} }) )

Select the map of ruleSets to activate based on linked components
selectRulesetsEntities
Default value : createSelector(selectRulesetsState, selectEntities)

Select the dictionary of Rulesets entities
selectRulesetsIds
Default value : createSelector(selectRulesetsState, selectIds)

Select the array of Rulesets ids
selectRuleSetsInRange
Default value : createSelector( selectAllRulesets, (ruleSets) => ruleSets.filter((ruleSet: Ruleset) => { const validity = ruleSet.validityRange; if (!validity || (!validity.from && !validity.to)) { return true; } const from = validity.from && new Date(validity.from); const to = validity.to && new Date(validity.to); if ((to && !isValidDate(to)) || (from && !isValidDate(from))) { return false; } const time = Date.now(); if (to && from) { return from.getTime() <= time && to.getTime() >= time; } if (from) { return from.getTime() <= time; } return to && to.getTime() >= time; }) )

Returns the rulesets which are in the validity range, if provided
selectRulesetsState
Default value : createFeatureSelector<RulesetsState>(RULESETS_STORE_NAME)

Select Rulesets State
selectRulesetsStorePendingStatus
Default value : createSelector(selectRulesetsState, (state) => state.isPending || false)

Select the store pending status
selectRulesetsTotal
Default value : createSelector(selectRulesetsState, selectTotal)

Select the total Rulesets count
Default value : rulesetsAdapter.getSelectors()

src/engine/operator/operators/index.ts

operatorList
Type : []
Default value : [...arrayBasedOperators, ...basicOperators, ...numberBasedOperators, ...dateBasedOperators]

src/devkit/rules-engine-devtools.token.ts

OTTER_RULES_ENGINE_DEVTOOLS_DEFAULT_OPTIONS
Type : Readonly<RulesEngineDevtoolsServiceOptions>
Default value : { isActivatedOnBootstrap: false } as const
OTTER_RULES_ENGINE_DEVTOOLS_OPTIONS
Default value : new InjectionToken<RulesEngineDevtoolsServiceOptions>('Otter RulesEngine Devtools options')

src/stores/rulesets/rulesets.module.ts

RULESETS_REDUCER_TOKEN
Default value : new InjectionToken<ActionReducer<RulesetsState, Action>>('Feature Rulesets Reducer')

Token of the Rulesets reducer

src/stores/rulesets/rulesets.state.ts

RULESETS_STORE_NAME
Type : string
Default value : 'rulesets'

Name of the Rulesets Store

src/stores/rulesets/rulesets.sync.ts

rulesetsStorageDeserializer
Default value : (rawObject: any) => { if (!rawObject || !rawObject.ids) { return rulesetsInitialState; } const storeObject = rulesetsAdapter.getInitialState(rawObject); for (const id of rawObject.ids) { storeObject.entities[id] = rawObject.entities[id] as RulesetsModel; } return storeObject; }
rulesetsStorageSerializer
Default value : (state: RulesetsState) => { return asyncStoreItemAdapter.clearAsyncStoreItem(state); }
rulesetsStorageSync
Type : Serializer<RulesetsState>
Default value : { serialize: rulesetsStorageSerializer, deserialize: rulesetsStorageDeserializer }

results matching ""

    No results matching ""