Package com.orchestranetworks.addon.dqid
package com.orchestranetworks.addon.dqid
Provides classes and interfaces to define, publish and execute indicators.
Indicator creation - A basic example
To add a custom indicator, its definition must first be created. Since {addon.label} v1.5.2, you can declare an indicator definition and its execution in the same class by extending the DefaultDECIndicator or DefaultWorkflowIndicator class. For example:
public final class TestDefaultDECIndicator extends DefaultDECIndicator
{
private static final String NUMBER_OF_RECORDS_PARAM = "numberOfRecords";
private static final String LAST_MODIFICATION_TIME_PARAM = "lastModificationTime";
public String getCode()
{
return "TestDefaultDECIndicator"; // the code must be unique
}
public DECType getDECType()
{
return DECType.TABLE;
}
public Set<FrequencyType> getPossibleComputationFrequencies()
{
Set<FrequencyType> frequencyTypes = new HashSet<FrequencyType>();
frequencyTypes.add(FrequencyType.ON_DEMAND);
return frequencyTypes;
}
public List<ParameterDefinition> getOutputParametersDefinition()
{
List<ParameterDefinition> outputs = new ArrayList<ParameterDefinition>();
UserMessageString nbOfRecordsMsg = UserMessage.createInfo("Number of records");
outputs.add(new ParameterDefinition(NUMBER_OF_RECORDS_PARAM, SchemaTypeName.XS_INT, nbOfRecordsMsg, nbOfRecordsMsg));
UserMessageString lastModificationTimeMsg = UserMessage.createInfo("Last modification time");
outputs.add(new ParameterDefinition(LAST_MODIFICATION_TIME_PARAM, SchemaTypeName.XS_DATETIME, lastModificationTimeMsg, lastModificationTimeMsg));
return outputs;
}
public BigDataDefinition getBigDataDefinition()
{
BigDataDefinition bigDataDefinition = new BigDataDefinition();
bigDataDefinition.addPathAssociation(BigDataDefinition.NbRecordsTable, NUMBER_OF_RECORDS_PARAM);
bigDataDefinition.addPathAssociation(BigDataDefinition.LastUpdateDate, LAST_MODIFICATION_TIME_PARAM);
return bigDataDefinition;
}
// since v2.0.0, it is recommended to declare FlatDataDefinition instead of BigDataDefinition
public FlatDataDefinition getFlatDataDefinition()
{
FlatDataDefinition flatDataDefinition = new FlatDataDefinition();
flatDataDefinition.addPathAssociation(FlatDataDefinition.Integer1, NUMBER_OF_RECORDS_PARAM);
flatDataDefinition.addPathAssociation(FlatDataDefinition.Datetime1, LAST_MODIFICATION_TIME_PARAM);
return flatDataDefinition;
}
public IndicatorReport execute(DECIndicatorExecutionContext executionContext) throws DQIdException
{
IndicatorReport report = new IndicatorReport();
// sequence: 1, order: 1
Integer number = Integer.valueOf(100);
IndicatorValue numberOfRecordsValue = new IntegerValue(number, 1, 1); // built-in IndicatorValue
// deprecated since v2.0.0
// numberOfRecordsValue.setBigDataReportField(BigDataDefinition.NbRecordsTable, number);
numberOfRecordsValue.setFlatDataFieldValue(FlatDataDefinition.Integer1, number);
report.addValue(numberOfRecordsValue);
// sequence: 1, order: 2
Date date = new Date();
IndicatorValue modificationTimeValue = new IndicatorTestValue(date, 1, 2); // custom IndicatorValue
// deprecated since v2.0.0
// modificationTimeValue.setBigDataReportField(BigDataDefinition.LastUpdateDate, date);
modificationTimeValue.setFlatDataFieldValue(FlatDataDefinition.Datetime1, date);
report.addValue(modificationTimeValue);
return report;
}
}
Next, you can create a custom indicator value to store execution results if necessary. For example:
public final class IndicatorTestValue extends IndicatorValue
{
private final Date date;
public IndicatorTestValue(Date date, int sequence, int order)
{
super(sequence, order);
this.date = date;
}
public String formatDataType()
{
return Date.class.getSimpleName();
}
public String formatValue()
{
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return df.format(this.date);
}
public Object getValue()
{
return this.date;
}
}
Finally, the indicator must be registered with the add-on in order to be available in the configuration:
IndicatorDefinitionCatalog.add(new TestDefaultDECIndicator());
By extending the default indicator classes, you can also apply multiple implementations on the same definition. For example, declare an abstract indicator definition as the following:
public abstract class AbstractNumberOfRecordsIndicator extends DefaultDECIndicator
{
protected static final String NUMBER_OF_RECORDS_OUTPUT_PARAM = "numberOfRecords";
public DECType getDECType()
{
return DECType.TABLE;
}
public Set<FrequencyType> getPossibleComputationFrequencies()
{
Set<FrequencyType> frequencyTypes = new HashSet<FrequencyType>();
frequencyTypes.add(FrequencyType.ON_DEMAND);
return frequencyTypes;
}
public List<ParameterDefinition> getOutputParametersDefinition()
{
List<ParameterDefinition> outputs = new ArrayList<ParameterDefinition>();
UserMessageString nbOfRecordsMsg = UserMessage.createInfo("Number of records");
outputs.add(new ParameterDefinition(NUMBER_OF_RECORDS_OUTPUT_PARAM, SchemaTypeName.XS_INT, nbOfRecordsMsg, nbOfRecordsMsg));
return outputs;
}
public BigDataDefinition getBigDataDefinition()
{
BigDataDefinition bigDataDefinition = new BigDataDefinition();
bigDataDefinition.addPathAssociation(BigDataDefinition.NbRecordsTable, NUMBER_OF_RECORDS_OUTPUT_PARAM);
return bigDataDefinition;
}
// since v2.0.0, it is recommended to declare FlatDataDefinition instead of BigDataDefinition
public FlatDataDefinition getFlatDataDefinition()
{
FlatDataDefinition flatDataDefinition = new FlatDataDefinition();
flatDataDefinition.addPathAssociation(FlatDataDefinition.Integer1, NUMBER_OF_RECORDS_OUTPUT_PARAM);
return flatDataDefinition;
}
}
Then extend the above class to handle the business in different scenarios:
public final class NumberOfRecordsWithErrorsIndicator extends AbstractNumberOfRecordsIndicator
{
public String getCode()
{
return "NumberOfRecordsWithErrors";
}
public IndicatorReport execute(DECIndicatorExecutionContext executionContext) throws DQIdException
{
IndicatorReport report = new IndicatorReport();
Integer number = Integer.valueOf(50);
IndicatorValue numberOfRecordsValue = new IntegerValue(number, 1, 1);
// deprecated since v2.0.0
// numberOfRecordsValue.setBigDataReportField(BigDataDefinition.NbRecordsTable, number);
numberOfRecordsValue.setFlatDataFieldValue(FlatDataDefinition.Integer1, number);
report.addValue(numberOfRecordsValue);
return report;
}
}
public final class NumberOfRecordsWithWarningsIndicator extends AbstractNumberOfRecordsIndicator
{
public String getCode()
{
return "NumberOfRecordsWithWarnings";
}
public IndicatorReport execute(DECIndicatorExecutionContext executionContext)
throws DQIdException
{
IndicatorReport report = new IndicatorReport();
Integer number = Integer.valueOf(80);
IndicatorValue numberOfRecordsValue = new IntegerValue(number, 1, 1);
// deprecated since v2.0.0
// numberOfRecordsValue.setBigDataReportField(BigDataDefinition.NbRecordsTable, number);
numberOfRecordsValue.setFlatDataFieldValue(FlatDataDefinition.Integer1, number);
report.addValue(numberOfRecordsValue);
return report;
}
}
Indicator creation - A full-featured example
The following example covers in-depth all properties of an IndicatorDefinition instance:
public final class IndicatorDurationDefinition implements IndicatorDefinition
{
private static final String TIME_PARAM = "TimeOutput";
private static final String DURATION_PARAM = "DurationOutput";
public IndicatorDurationDefinition()
{
}
public String getCode()
{
return "Indicator-Duration";
}
public UserMessage getLabel()
{
return UserMessage.createInfo("Time duration in interval format");
}
public UserMessage getDashboardLabel()
{
return UserMessage.createInfo("Time duration");
}
public UserMessage getDescription()
{
return UserMessage.createInfo("This indicator checks if the value of a Datetime field is within a specified time range "
+ "and displays the time range from that time to the execution time in interval format.");
}
public Indicator getImplementation()
{
return new IndicatorDurationImpl(); // this implementation class is defined below
}
public DECType getDECType()
{
return DECType.FIELD;
}
public DECSubType getDECSubType()
{
// return null if the indicator doesn't have any D.E.C. sub-types
return FieldDECSubType.DATE; // this indicator can only be configured and executed on fields with the Date type
}
public List<ParameterDefinition> getInputParametersDefinition()
{
// return null if the indicator doesn't have any input parameters
List<ParameterDefinition> inputs = new ArrayList<ParameterDefinition>();
// numeric input
UserMessage maxNbOfOutcomesLabel = UserMessage.createInfo("Maximum number of outcomes");
UserMessage maxNbOfOutcomesDescription = UserMessage.createInfo("The maximum of outcomes (also the Big data records) for an execution.");
ParameterDefinition maxNumberOfOutputs = new ParameterDefinition(
"maxNumberOfOutcomesInput",
SchemaTypeName.XS_INTEGER,
maxNbOfOutcomesLabel,
maxNbOfOutcomesDescription,
String.valueOf(1));
// optional constraint for an input parameter
ParameterConstraint parameterConstraint = new ParameterConstraint();
parameterConstraint.setUnboundedSupported(true);
maxNumberOfOutputs.setParameterConstraint(parameterConstraint);
inputs.add(maxNumberOfOutputs);
// datetime inputs
UserMessage fromTimeLabel = UserMessage.createInfo("From");
UserMessage fromTimeDescription = UserMessage.createInfo("The start time of the time range. Only considered if the configured periodicity is 'None'.");
ParameterDefinition fromDate = new ParameterDefinition(
"fromTimeInput",
SchemaTypeName.XS_DATETIME,
fromTimeLabel,
fromTimeDescription);
inputs.add(fromDate);
UserMessage toDateLabel = UserMessage.createInfo("To");
UserMessage toDateDescription = UserMessage.createInfo("The end time of the time range. Only considered if the configured periodicity is 'None'.");
ParameterDefinition toDate = new ParameterDefinition(
"toTimeInput",
SchemaTypeName.XS_DATETIME,
toDateLabel,
toDateDescription);
inputs.add(toDate);
// enumeration input with interval formats
UserMessage intervalFormatLabel = UserMessage.createInfo("Interval format");
UserMessage intervalFormatDescription = UserMessage.createInfo("The interval format for the 'Duration' output.");
Set<PredefinedValue> formats = new HashSet<PredefinedValue>();
formats.add(new PredefinedValue(IntervalType.DAY_HOUR.getCode(), IntervalType.DAY_HOUR.getLabel()));
formats.add(new PredefinedValue(IntervalType.DAY_HOUR_MINUTE.getCode(), IntervalType.DAY_HOUR_MINUTE.getLabel()));
PredefinedValue defaultFormat = new PredefinedValue(IntervalType.DAY_HOUR.getCode()); // default selected option of the list
ListConstraint listConstraint = new ListConstraint(formats, Collections.singleton(defaultFormat));
ParameterDefinition intervalFormat = new ParameterDefinition(
"intervalFormatInput",
SchemaTypeName.XS_STRING,
intervalFormatLabel,
intervalFormatDescription,
listConstraint,
HTMLComponent.DROPDOWNBOX_COMPONENT); // HTML type for the input
inputs.add(intervalFormat);
return Collections.unmodifiableList(inputs);
}
public List<ParameterDefinition> getOutputParametersDefinition()
{
List<ParameterDefinition> parameterDefinitions = new ArrayList<ParameterDefinition>();
UserMessage timeLabel = UserMessage.createInfo("Time in range");
UserMessage timeDescription = UserMessage.createInfo("Displays the datetime value within the time range.");
ParameterDefinition timeOutput = new ParameterDefinition(
IndicatorDurationDefinition.TIME_PARAM,
SchemaTypeName.XS_DATETIME,
timeLabel,
timeDescription);
parameterDefinitions.add(timeOutput);
UserMessage durationLabel = UserMessage.createInfo("Time duration in interval");
UserMessage durationDescription = UserMessage.createInfo("Displays the time range from a certain time to the execution time in interval format.");
ParameterDefinition durationOutput = new ParameterDefinition(
IndicatorDurationDefinition.DURATION_PARAM,
SchemaTypeNameExtension.INTERVAL,
durationLabel,
durationDescription);
parameterDefinitions.add(durationOutput);
return parameterDefinitions;
}
public BigDataDefinition getBigDataDefinition()
{
BigDataDefinition bigDataDefinition = new BigDataDefinition();
bigDataDefinition.addPathAssociation(BigDataDefinition.OverseeDateValue, IndicatorDurationDefinition.TIME_PARAM);
bigDataDefinition.addPathAssociation(BigDataDefinition.LifeTimeOfDataspace, IndicatorDurationDefinition.DURATION_PARAM);
return bigDataDefinition;
}
// since v2.0.0, it is recommended to declare FlatDataDefinition instead of BigDataDefinition
public FlatDataDefinition getFlatDataDefinition()
{
FlatDataDefinition flatDataDefinition = new FlatDataDefinition();
flatDataDefinition.addPathAssociation(FlatDataDefinition.Datetime1, IndicatorDurationDefinition.TIME_PARAM);
flatDataDefinition.addPathAssociation(FlatDataDefinition.Interval1, IndicatorDurationDefinition.DURATION_PARAM);
return flatDataDefinition;
}
public Set<FrequencyType> getPossibleComputationFrequencies()
{
// supports both the on-demand and the real-time computations
Set<FrequencyType> frequencyTypes = new HashSet<FrequencyType>();
frequencyTypes.add(FrequencyType.ON_DEMAND);
frequencyTypes.add(FrequencyType.REAL_TIME);
return frequencyTypes;
}
public Set<ProbeType> getPossibleProbes()
{
// returns null if the indicator runs on-demand
return Collections.singleton(ProbeType.TRIGGER); // supports probes for a real-time indicator
}
public WatchdogInformation getWatchdogInformation()
{
// return null if the indicator doesn't have any periodicities or thresholds
WatchdogInformation information = new WatchdogInformation();
Set<PeriodicityType> possiblePeriodicities = new HashSet<PeriodicityType>();
possiblePeriodicities.add(PeriodicityType.DAILY);
possiblePeriodicities.add(PeriodicityType.TOLERANCE); // TOLERANCE or 'None' means using the configured time range
information.setPossiblePeriodicityOfControl(Collections.unmodifiableSet(possiblePeriodicities));
return information;
}
public UserMessage getStorageProcedureInformation()
{
return UserMessage.createInfo("Any results are stored.");
}
// deprecated since v2.0.0
public boolean hasManyOutcomesStoredInBigDataTable()
{
return true; // has multiple outcomes because there may be many datetime values within a time ranges
}
public boolean hasManyOutcomesStoredInReportingTable()
{
return true; // has multiple outcomes because there may be many datetime values within a time ranges
}
public LinkedRecordDefinition getLinkedRecordDefinition()
{
// return null if the indicator doesn't store any records
LinkedRecordDefinition linkedRecordDefinition = new LinkedRecordDefinition(UserMessage.createInfo("Records with time duration greater than one day will be stored"));
UserMessage label = UserMessage.createInfo("Duration greater than one day.");
UserMessage description = UserMessage.createInfo("Records with time duration greater than one day will be stored.");
linkedRecordDefinition.addOption(new ParameterDefinition(
"DurationLinkedRecordOption",
SchemaTypeName.XS_BOOLEAN,
label,
description,
Boolean.TRUE.toString()));
return linkedRecordDefinition;
}
}
Next, the definition of the indicator value to be stored must be created. For example:
public final class IndicatorTestValue extends IndicatorValue
{
private final Date date;
public IndicatorTestValue(Date date, int sequence, int order)
{
super(sequence, order);
this.date = date;
}
public String formatDataType()
{
return Date.class.getSimpleName();
}
public String formatValue()
{
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return df.format(this.date);
}
public Object getValue()
{
return this.date;
}
}
To execute the indicator, the definition of the implementation must first be created. The following example illustrates how to get and handle indicator configuration properties:
public class IndicatorDurationImpl extends DECIndicator
{
private static final int TIME_OF_A_DAY = 1000 * 60 * 60 * 24;
public IndicatorReport execute(DECIndicatorExecutionContext executionContext) throws DQIdException
{
IndicatorDefinitionContext definitionContext = this.getIndicatorDefinitionContext();
// input parameter values
String maxNbOfOutcomeValue = definitionContext.getBespokeParameterValue("maxNumberOfOutcomesInput");
String fromTimeValue = definitionContext.getBespokeParameterValue("fromTimeInput");
String toTimeValue = definitionContext.getBespokeParameterValue("toTimeInput");
String intervalFormatValue = definitionContext.getBespokeParameterValue("intervalFormatInput");
String linkedRecordOption = definitionContext.getLinkedRecordInformation().getOption("DurationLinkedRecordOption");
int maxNbOfOutcomes;
try
{
maxNbOfOutcomes = Integer.parseInt(maxNbOfOutcomeValue);
}
catch (NumberFormatException ex)
{
throw new DQIdException(UserMessage.createError("Invalid maximum number of outcomes."));
}
// periodicity
Watchdog watchdog = definitionContext.getWatchdog();
PeriodicityType periodicityType = watchdog == null ? null : watchdog.getPeriodicityOfControl();
Date fromTime = null;
Date toTime = null;
// if the periodicity is 'None'
if (periodicityType.isTolerance())
{
if (fromTimeValue == null || toTimeValue == null)
{
throw new DQIdException(UserMessage.createError("Invalid time."));
}
fromTime = FormatDataPolicy.parseDate(SchemaTypeName.XS_DATETIME, fromTimeValue);
toTime = FormatDataPolicy.parseDate(SchemaTypeName.XS_DATETIME, toTimeValue);
}
else
{
// other cases to check if a date value is within the periodicity
}
if (fromTime == null || toTime == null)
{
throw new DQIdException(UserMessage.createError("Invalid time."));
}
if (toTime.before(fromTime))
{
throw new DQIdException(UserMessage.createError("From time cannot be before to time."));
}
AdaptationTable table = executionContext.getExecutionEnvironment().getTable();
Path fieldPath = definitionContext.getField();
Date executionTime = new Date();
IntervalType intervalType = IntervalType.DAY_HOUR_MINUTE.getCode().equals(intervalFormatValue) ? IntervalType.DAY_HOUR_MINUTE : IntervalType.DAY_HOUR;
boolean saveLastValueOnlyInReporting = definitionContext.saveLastValueOnlyInFlatDataTable();
boolean storeAll = !Boolean.getBoolean(linkedRecordOption);
IndicatorReport indicatorReport;
if (executionContext.isOnDemand()) // on-demand execution
{
indicatorReport = this.executeOnDemand(
executionContext,
table,
fieldPath,
fromTime,
toTime,
executionTime,
intervalType,
maxNbOfOutcomes,
saveLastValueOnlyInReporting,
storeAll);
}
else // real-time execution
{
String currentRecordXPath = executionContext.getCurrentRecordXPathPredicate();
indicatorReport = this.executeRealtime(
executionContext,
table,
fieldPath,
currentRecordXPath,
fromTime,
toTime,
executionTime,
intervalType,
maxNbOfOutcomes,
saveLastValueOnlyInReporting,
storeAll);
}
if (indicatorReport == null)
{
return null;
}
// indicates that the watchdog is used as an alert to save the indicator report
indicatorReport.setAlertRaisedByWatchdog(true);
return indicatorReport;
}
private IndicatorReport executeOnDemand(
DECIndicatorExecutionContext executionContext,
AdaptationTable table,
Path fieldPath,
Date fromTime,
Date toTime,
Date executionTime,
IntervalType intervalType,
int maxNbOfOutcomes,
boolean saveLastValueOnlyInReporting,
boolean storeAll) throws DQIdException
{
IndicatorReport indicatorReport = new IndicatorReport();
int sequence = 1; // sequence always starts with 1
RequestResult requestResult = table.createRequest().execute();
try
{
Adaptation record = null;
while ((record = requestResult.nextAdaptation()) != null)
{
Date datetime = record.getDate(fieldPath);
if (datetime.before(fromTime) || datetime.after(toTime) || datetime.after(executionTime))
{
continue;
}
if (sequence > maxNbOfOutcomes)
{
break;
}
this.addIndicatorValues(
executionContext,
indicatorReport,
datetime,
executionTime,
intervalType,
sequence,
saveLastValueOnlyInReporting,
record.toXPathPredicateString(),
storeAll);
sequence++;
}
}
finally
{
requestResult.close();
}
return indicatorReport;
}
private IndicatorReport executeRealtime(
DECIndicatorExecutionContext executionContext,
AdaptationTable table,
Path fieldPath,
String currentRecordXPath,
Date fromTime,
Date toTime,
Date executionTime,
IntervalType intervalType,
int maxNbOfOutcomes,
boolean saveLastValueOnlyInReporting,
boolean storeAll) throws DQIdException
{
if (maxNbOfOutcomes <= 0 || AddonStringUtils.isEmpty(currentRecordXPath))
{
return null;
}
RequestResult requestResult = table.createRequestResult(currentRecordXPath);
try
{
Adaptation record = requestResult.nextAdaptation();
if (record == null)
{
return null;
}
Date datetime = record.getDate(fieldPath);
if (datetime.before(fromTime) || datetime.after(toTime) || datetime.after(executionTime))
{
return null;
}
IndicatorReport indicatorReport = new IndicatorReport();
this.addIndicatorValues(
executionContext,
indicatorReport,
datetime,
executionTime,
intervalType,
1,
saveLastValueOnlyInReporting,
record.toXPathPredicateString(),
storeAll);
return indicatorReport;
}
finally
{
requestResult.close();
}
}
private void addIndicatorValues(
DECIndicatorExecutionContext executionContext,
IndicatorReport indicatorReport,
Date datetime,
Date executionTime,
IntervalType intervalType,
int sequence,
boolean saveLastValueOnlyInReporting,
String recordPredicate,
boolean storeAll) throws DQIdException
{
// indicator values
IndicatorValue datetimeValue = new IndicatorTestValue(datetime, sequence, 1); // IndicatorTestValue was defined before
// deprecated since v2.0.0
// datetimeValue.setBigDataReportField(BigDataDefinition.OverseeDateValue, datetimeValue);
datetimeValue.setFlatDataFieldValue(FlatDataDefinition.Datetime1, datetimeValue);
indicatorReport.addValue(datetimeValue);
long duration = executionTime.getTime() - datetime.getTime();
// IntervalValue is an available implementation class of IndicatorValue
IndicatorValue intervalValue = new IntervalValue(BigDecimal.valueOf(duration), sequence, 2, intervalType);
// deprecated since v2.0.0
// datetimeValue.setBigDataReportField(BigDataDefinition.LifeTimeOfDataspace, BigDecimal.valueOf(duration));
datetimeValue.setFlatDataFieldValue(FlatDataDefinition.Interval1, BigDecimal.valueOf(duration));
indicatorReport.addValue(intervalValue);
// handle saving last value in the Flat data table
if (saveLastValueOnlyInReporting)
{
// deprecated since v2.0.0
// indicatorReport.setPrimaryKeyOfPreviousBigDataReportBySequence(sequence, this.getPrimaryKeyOrNullOfExistingIndicatorReportInBigDataTable(executionContext, sequence));
indicatorReport.setPrimaryKeyOfPreviousReportingRecordBySequence(sequence, this.getFlatDataAccessor().getPrimaryKeyOrNullOfLatestRecord(executionContext, sequence));
}
// linked record - check if duration is greater than a day
if (!storeAll && duration <= TIME_OF_A_DAY)
{
return;
}
LinkedRecord linkedRecord = new LinkedRecord();
linkedRecord.addRelevantRecordPredicate(recordPredicate);
indicatorReport.addLinkedRecord(sequence, linkedRecord);
}
}
Finally, the indicator must be registered with the add-on in order to be available in the configuration:
IndicatorDefinitionCatalog.add(new IndicatorDurationDefinition());
-
ClassDescriptionDefines fields in the
Big data reporttable - Insight - Reporting data set.Deprecated.Represents a decimal outcome ofIndicatorReport.Represents a boolean outcome ofIndicatorReport.Represents a Data Element Concept.Represents a date outcome ofIndicatorReport.This abstract class must be extended to define the behavior of an indicator running on aData Element Concept.Execution context for a Data Element Concept.The on-demand context for a data element concept.The on-probe context for a data element concept.The execution environment for a Data Element Concept.Provides default implementations for optional properties of anIndicatorDefinition, and allows users to define the behavior of aDECIndicator.Provides default implementations for optional properties of anIndicatorDefinition, and offers the ability to define the behavior of aWorkflowIndicator.Retrieves specific data in theFlat datatable or theBig datatable fromIndicatorExecutionContext.Contains definitions of the fields in theFlat data reporttable - Insight - Reporting data set.Defines a value set in either theBig datatable or theFlat datatable.Provides additional information for aParameterDefinition, which is used for chart generation.This abstract class must be extended to define the behavior of an indicator.Offers accessors to the configuration.Defines an indicator.
Guides and inputs the indicator declaration in the user interface.Provides a catalog to register indicators.Represents the configuration of anIndicatorDefinition.The execution context of the indicator.Execution environment of the indicator.The Java Bean container anIndicator's outcomes.Retrieves specific data in theIndicator reporttable and theIndicator valuetable fromIndicatorExecutionContext.The definitions of the fields in theIndicator reporttable -Insight - Reportingdata set.Global execution result of all indicators.Defines the storage of results.The factory class ofIndicatorStorage.Defines an atomic outcome ofIndicatorReport.The definitions of the fields in theIndicator valuetable -Insight - Reportingdata set.Represents an integer outcome ofIndicatorReport.Represents an interval outcome of indicator execution.The relevant records that affect an indicator result.Declares the rule that defines what kind of records affecting an indicator result.Retrieves the rule that defines what kinds of records affecting an indicator result.Definition of a constraint for a multiple occurred parameter or enumeration.The definition of a constraint for the value of a parameter.The definition of anIndicatorinput or output parameter.Represents a percentage outcome of indicator execution.To define a value with a string label or a localized label.Declares associations between output parameters and reporting fields in theFlat data reporttable or theBig data reporttable of Insight - Reporting data sets.Offers accessors to the reporting.Represents a string outcome ofIndicatorReport.Represents the configured Watchdog for theIndicator.The definition of a watchdog for anIndicator.This abstract class must be extended to define the behavior of an indicator run on a workflow.The on-demand context for a workflow.The execution environment for a workflow.