You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1207 lines
54 KiB
1207 lines
54 KiB
/* Copyright 2005-2015 Alfresco Software, Ltd.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
'use strict';
|
|
|
|
var extScope;
|
|
|
|
angular.module('flowableModeler')
|
|
.controller('DecisionTableEditorController', ['$rootScope', '$scope', '$q', '$translate', '$http', '$timeout', '$location', '$modal', '$route', '$routeParams', 'DecisionTableService',
|
|
'UtilityService', 'uiGridConstants', 'appResourceRoot', 'hotRegisterer',
|
|
function ($rootScope, $scope, $q, $translate, $http, $timeout, $location, $modal, $route, $routeParams, DecisionTableService,
|
|
UtilityService, uiGridConstants, appResourceRoot, hotRegisterer) {
|
|
|
|
extScope = $scope;
|
|
|
|
$rootScope.decisionTableChanges = false;
|
|
|
|
var hotDecisionTableEditorInstance;
|
|
var hitPolicies = ['FIRST', 'ANY', 'UNIQUE', 'PRIORITY', 'RULE ORDER', 'OUTPUT ORDER', 'COLLECT'];
|
|
var stringOperators = ['==', '!=', 'IS IN', 'IS NOT IN'];
|
|
var numberOperators = ['==', '!=', '<', '>', '>=', '<=', 'IS IN', 'IS NOT IN'];
|
|
var booleanOperators = ['==', '!='];
|
|
var dateOperators = ['==', '!=', '<', '>', '>=', '<=', 'IS IN', 'IS NOT IN'];
|
|
var collectionOperators = ['ANY OF', 'NONE OF', 'ALL OF', 'NOT ALL OF', '==', '!='];
|
|
var allOperators = ['==', '!=', '<', '>', '>=', '<=', 'ANY OF', 'NONE OF', 'ALL OF', 'NOT ALL OF', 'IS IN', 'IS NOT IN'];
|
|
var collectOperators = {
|
|
'SUM': '+',
|
|
'MIN': '<',
|
|
'MAX': '>',
|
|
'COUNT': '#'
|
|
};
|
|
|
|
var columnIdCounter = 0;
|
|
var hitPolicyHeaderElement;
|
|
var dateFormat = 'YYYY-MM-DD';
|
|
|
|
// Export name to grid's scope
|
|
$scope.appResourceRoot = appResourceRoot;
|
|
|
|
// Model init
|
|
$scope.status = {loading: true};
|
|
$scope.model = {
|
|
rulesData: [],
|
|
columnDefs: [],
|
|
columnVariableIdMap: {},
|
|
startOutputExpression: 0,
|
|
selectedRow: undefined,
|
|
availableInputVariableTypes: ['string', 'number', 'boolean', 'date', 'collection'],
|
|
availableOutputVariableTypes: ['string', 'number', 'boolean', 'date']
|
|
};
|
|
|
|
// Hot Model init
|
|
$scope.model.hotSettings = {
|
|
contextMenu: {
|
|
items: {
|
|
"insert_row_above": {
|
|
name: 'Insert rule above',
|
|
callback: function (key, options) {
|
|
if (hotDecisionTableEditorInstance.getSelected()) {
|
|
$scope.addRule(hotDecisionTableEditorInstance.getSelected()[0]);
|
|
}
|
|
}
|
|
},
|
|
"insert_row_below": {
|
|
name: 'Add rule below',
|
|
callback: function (key, options) {
|
|
if (hotDecisionTableEditorInstance.getSelected()) {
|
|
$scope.addRule(hotDecisionTableEditorInstance.getSelected()[0] + 1);
|
|
}
|
|
}
|
|
},
|
|
"clear_row": {
|
|
name: 'Clear rule',
|
|
callback: function (key, options) {
|
|
if (hotDecisionTableEditorInstance.getSelected()) {
|
|
$scope.clearRule(hotDecisionTableEditorInstance.getSelected()[0]);
|
|
}
|
|
}
|
|
},
|
|
"remove_row": {
|
|
name: 'Remove this rule',
|
|
disabled: function () {
|
|
// if only 1 rule disable
|
|
if (hotDecisionTableEditorInstance.getSelected()) {
|
|
return $scope.model.rulesData.length < 2;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
"hsep1": "---------",
|
|
"move_rule_up": {
|
|
name: 'Move rule up',
|
|
disabled: function () {
|
|
if (hotDecisionTableEditorInstance.getSelected()) {
|
|
return hotDecisionTableEditorInstance.getSelected()[0] === 0;
|
|
}
|
|
},
|
|
callback: function (key, options) {
|
|
$scope.moveRuleUpwards();
|
|
}
|
|
},
|
|
"move_rule_down": {
|
|
name: 'Move rule down',
|
|
disabled: function () {
|
|
if (hotDecisionTableEditorInstance.getSelected()) {
|
|
return hotDecisionTableEditorInstance.getSelected()[0] + 1 === $scope.model.rulesData.length;
|
|
}
|
|
},
|
|
callback: function (key, options) {
|
|
$scope.moveRuleDownwards();
|
|
}
|
|
},
|
|
"hsep2": "---------",
|
|
"add_input": {
|
|
name: 'Add input',
|
|
callback: function (key, options) {
|
|
if (hotDecisionTableEditorInstance.getSelected()) {
|
|
$scope.openInputExpressionEditor(hotDecisionTableEditorInstance.getSelected()[1], true);
|
|
}
|
|
}
|
|
},
|
|
"add_output": {
|
|
name: 'Add output',
|
|
callback: function (key, options) {
|
|
if (hotDecisionTableEditorInstance.getSelected()) {
|
|
if (hotDecisionTableEditorInstance.getSelected()[1] < $scope.model.startOutputExpression) {
|
|
$scope.openOutputExpressionEditor($scope.currentDecisionTable.outputExpressions.length, true);
|
|
} else {
|
|
$scope.openOutputExpressionEditor((hotDecisionTableEditorInstance.getSelected()[1] - $scope.model.startOutputExpression), true);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"hsep3": "---------",
|
|
"undo": {
|
|
name: 'Undo'
|
|
},
|
|
"redo": {
|
|
name: 'Redo'
|
|
}
|
|
}
|
|
},
|
|
manualColumnResize: false,
|
|
stretchH: 'all',
|
|
outsideClickDeselects: false,
|
|
viewportColumnRenderingOffset: $scope.model.columnDefs.length + 10
|
|
};
|
|
|
|
|
|
$scope.hitPolicies = [];
|
|
hitPolicies.forEach(function (id) {
|
|
$scope.hitPolicies.push({
|
|
id: id,
|
|
label: 'DECISION-TABLE.HIT-POLICIES.' + id
|
|
});
|
|
});
|
|
|
|
$scope.collectOperators = [];
|
|
Object.keys(collectOperators).forEach(function (key) {
|
|
$scope.collectOperators.push({
|
|
id: key,
|
|
label: 'DECISION-TABLE.COLLECT-OPERATORS.' + key
|
|
});
|
|
});
|
|
|
|
$scope.addRule = function (rowNumber) {
|
|
if (rowNumber !== undefined) {
|
|
$scope.model.rulesData.splice(rowNumber, 0, createDefaultRow());
|
|
} else {
|
|
$scope.model.rulesData.push(createDefaultRow());
|
|
}
|
|
if (hotDecisionTableEditorInstance) {
|
|
hotDecisionTableEditorInstance.render();
|
|
}
|
|
};
|
|
|
|
$scope.removeRule = function () {
|
|
$scope.model.rulesData.splice($scope.model.selectedRow, 1);
|
|
};
|
|
|
|
$scope.clearRule = function (rowNumber) {
|
|
if (rowNumber === undefined) {
|
|
return;
|
|
}
|
|
$scope.model.rulesData[rowNumber] = createDefaultRow();
|
|
if (hotDecisionTableEditorInstance) {
|
|
hotDecisionTableEditorInstance.render();
|
|
}
|
|
};
|
|
|
|
$scope.moveRuleUpwards = function () {
|
|
$scope.model.rulesData.splice($scope.model.selectedRow - 1, 0, $scope.model.rulesData.splice($scope.model.selectedRow, 1)[0]);
|
|
if (hotDecisionTableEditorInstance) {
|
|
hotDecisionTableEditorInstance.render();
|
|
}
|
|
};
|
|
|
|
$scope.moveRuleDownwards = function () {
|
|
$scope.model.rulesData.splice($scope.model.selectedRow + 1, 0, $scope.model.rulesData.splice($scope.model.selectedRow, 1)[0]);
|
|
if (hotDecisionTableEditorInstance) {
|
|
hotDecisionTableEditorInstance.render();
|
|
}
|
|
};
|
|
|
|
$scope.doAfterGetColHeader = function (col, TH) {
|
|
if ($scope.model.columnDefs[col] && $scope.model.columnDefs[col].expressionType === 'input-operator') {
|
|
TH.className += "input-operator-header";
|
|
} else if ($scope.model.columnDefs[col] && $scope.model.columnDefs[col].expressionType === 'input-expression') {
|
|
TH.className += "input-expression-header";
|
|
if ($scope.model.startOutputExpression - 1 === col) {
|
|
TH.className += " last";
|
|
}
|
|
} else if ($scope.model.columnDefs[col] && $scope.model.columnDefs[col].expressionType === 'output') {
|
|
TH.className += "output-header";
|
|
if ($scope.model.startOutputExpression === col) {
|
|
TH.className += " first";
|
|
}
|
|
}
|
|
};
|
|
|
|
$scope.doAfterModifyColWidth = function (width, col) {
|
|
if ($scope.model.columnDefs[col] && $scope.model.columnDefs[col].width) {
|
|
var settingsWidth = $scope.model.columnDefs[col].width;
|
|
if (settingsWidth > width) {
|
|
return settingsWidth;
|
|
}
|
|
}
|
|
return width;
|
|
};
|
|
|
|
$scope.doAfterOnCellMouseDown = function (event, coords, TD) {
|
|
// clicked hit policy indicator
|
|
if (coords.row === 0 && coords.col === 0 && TD.className === '') {
|
|
$scope.openHitPolicyEditor();
|
|
} else {
|
|
if (coords && coords.row !== undefined) {
|
|
$timeout(function () {
|
|
$scope.model.selectedRow = coords.row;
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
$scope.doAfterScroll = function () {
|
|
if (hotDecisionTableEditorInstance) {
|
|
hotDecisionTableEditorInstance.render();
|
|
}
|
|
};
|
|
|
|
$scope.doAfterRender = function (isForced) {
|
|
|
|
if (hitPolicyHeaderElement) {
|
|
var element = document.querySelector("thead > tr > th:first-of-type");
|
|
if (element) {
|
|
var firstChild = element.firstChild;
|
|
element.className = 'hit-policy-container';
|
|
element.replaceChild(hitPolicyHeaderElement[0], firstChild);
|
|
}
|
|
}
|
|
|
|
if (hotDecisionTableEditorInstance === undefined) {
|
|
$timeout(function () {
|
|
hotDecisionTableEditorInstance = hotRegisterer.getInstance('decision-table-editor');
|
|
hotDecisionTableEditorInstance.validateCells();
|
|
});
|
|
} else {
|
|
hotDecisionTableEditorInstance.validateCells();
|
|
}
|
|
};
|
|
|
|
$scope.dumpData = function () {
|
|
console.log($scope.currentDecisionTable);
|
|
console.log($scope.model.rulesData);
|
|
console.log($scope.model.columnDefs);
|
|
};
|
|
|
|
$scope.doAfterValidate = function (isValid, value, row, prop, source) {
|
|
if (isCorrespondingCollectionOperator(row, prop)) {
|
|
return true;
|
|
} else if (isCustomExpression(value) || isDashValue(value)) {
|
|
disableCorrespondingOperatorCell(row, prop);
|
|
return true;
|
|
} else {
|
|
enableCorrespondingOperatorCell(row, prop);
|
|
}
|
|
};
|
|
|
|
// dummy validator for text fields in order to trigger the post validation hook
|
|
var textValidator = function(value, callback) {
|
|
callback(true);
|
|
};
|
|
|
|
var isCustomExpression = function (val) {
|
|
return !!(val != null
|
|
&& (String(val).startsWith('${') || String(val).startsWith('#{')));
|
|
};
|
|
|
|
var isDashValue = function (val) {
|
|
return !!(val != null && "-" === val);
|
|
};
|
|
|
|
var isCorrespondingCollectionOperator = function (row, prop) {
|
|
var operatorCol = getCorrespondingOperatorCell(row, prop);
|
|
var operatorCellMeta = hotDecisionTableEditorInstance.getCellMeta(row, operatorCol);
|
|
|
|
var isCollectionOperator = false;
|
|
if (isOperatorCell(operatorCellMeta)) {
|
|
var operatorValue = hotDecisionTableEditorInstance.getDataAtCell(row, operatorCol);
|
|
if (operatorValue === "IN" || operatorValue === "NOT IN" || operatorValue === "ANY" || operatorValue === "NOT ANY") {
|
|
isCollectionOperator = true;
|
|
}
|
|
}
|
|
return isCollectionOperator;
|
|
};
|
|
|
|
var disableCorrespondingOperatorCell = function (row, prop) {
|
|
var operatorCol = getCorrespondingOperatorCell(row, prop);
|
|
var operatorCellMeta = hotDecisionTableEditorInstance.getCellMeta(row, operatorCol);
|
|
|
|
if (!isOperatorCell(operatorCellMeta)) {
|
|
return;
|
|
}
|
|
|
|
if (operatorCellMeta.className != null && operatorCellMeta.className.indexOf('custom-expression-operator') !== -1) {
|
|
return;
|
|
}
|
|
|
|
var currentEditor = hotDecisionTableEditorInstance.getCellEditor(row, operatorCol);
|
|
|
|
hotDecisionTableEditorInstance.setCellMeta(row, operatorCol, 'className', operatorCellMeta.className + ' custom-expression-operator');
|
|
hotDecisionTableEditorInstance.setCellMeta(row, operatorCol, 'originalEditor', currentEditor);
|
|
hotDecisionTableEditorInstance.setCellMeta(row, operatorCol, 'editor', false);
|
|
hotDecisionTableEditorInstance.setDataAtCell(row, operatorCol, null);
|
|
};
|
|
|
|
var enableCorrespondingOperatorCell = function (row, prop) {
|
|
var operatorCol = getCorrespondingOperatorCell(row, prop);
|
|
var operatorCellMeta = hotDecisionTableEditorInstance.getCellMeta(row, operatorCol);
|
|
|
|
if (!isOperatorCell(operatorCellMeta)) {
|
|
return;
|
|
}
|
|
|
|
if (operatorCellMeta == null || operatorCellMeta.className == null || operatorCellMeta.className.indexOf('custom-expression-operator') == -1) {
|
|
return;
|
|
}
|
|
|
|
operatorCellMeta.className = operatorCellMeta.className.replace('custom-expression-operator', '');
|
|
hotDecisionTableEditorInstance.setCellMeta(row, operatorCol, 'className', operatorCellMeta.className);
|
|
hotDecisionTableEditorInstance.setCellMeta(row, operatorCol, 'editor', operatorCellMeta.originalEditor);
|
|
hotDecisionTableEditorInstance.setDataAtCell(row, operatorCol, '==');
|
|
};
|
|
|
|
var getCorrespondingOperatorCell = function (row, prop) {
|
|
var currentCol = hotDecisionTableEditorInstance.propToCol(prop);
|
|
if (currentCol < 1) {
|
|
return;
|
|
}
|
|
var operatorCol = currentCol - 1;
|
|
return operatorCol;
|
|
};
|
|
|
|
var isOperatorCell = function (cellMeta) {
|
|
return !(cellMeta == null || cellMeta.prop == null || typeof cellMeta.prop !== 'string'|| cellMeta.prop.endsWith("_operator") === false);
|
|
};
|
|
|
|
var createNewInputExpression = function (inputExpression) {
|
|
var newInputExpression;
|
|
if (inputExpression) {
|
|
newInputExpression = {
|
|
id: _generateColumnId(),
|
|
label: inputExpression.label,
|
|
variableId: inputExpression.variableId,
|
|
type: inputExpression.type,
|
|
newVariable: inputExpression.newVariable,
|
|
entries: inputExpression.entries
|
|
};
|
|
|
|
} else {
|
|
newInputExpression = {
|
|
id: _generateColumnId(),
|
|
label: null,
|
|
variableId: null,
|
|
type: null,
|
|
newVariable: null,
|
|
entries: null
|
|
};
|
|
}
|
|
return newInputExpression;
|
|
};
|
|
|
|
var createNewOutputExpression = function (outputExpression) {
|
|
var newOutputExpression;
|
|
if (outputExpression) {
|
|
newOutputExpression = {
|
|
id: _generateColumnId(),
|
|
label: outputExpression.label,
|
|
variableId: outputExpression.variableId,
|
|
type: outputExpression.type,
|
|
newVariable: outputExpression.newVariable,
|
|
entries: outputExpression.entries
|
|
};
|
|
|
|
} else {
|
|
newOutputExpression = {
|
|
id: _generateColumnId(),
|
|
label: null,
|
|
variableId: null,
|
|
type: null,
|
|
newVariable: null,
|
|
entries: null
|
|
};
|
|
}
|
|
return newOutputExpression;
|
|
};
|
|
|
|
$scope.addNewInputExpression = function (inputExpression, insertPos) {
|
|
var newInputExpression = createNewInputExpression(inputExpression);
|
|
|
|
// insert expression at position or just add
|
|
if (insertPos !== undefined && insertPos !== -1) {
|
|
$scope.currentDecisionTable.inputExpressions.splice(insertPos, 0, newInputExpression);
|
|
} else {
|
|
$scope.currentDecisionTable.inputExpressions.push(newInputExpression);
|
|
}
|
|
|
|
// update data model with initial values
|
|
$scope.model.rulesData.forEach(function (rowData) {
|
|
rowData[newInputExpression.id + '_expression'] = '-';
|
|
});
|
|
|
|
// update column definitions off the source model
|
|
$scope.evaluateDecisionHeaders($scope.currentDecisionTable);
|
|
};
|
|
|
|
$scope.addNewOutputExpression = function (outputExpression, insertPos) {
|
|
var newOutputExpression = createNewOutputExpression(outputExpression);
|
|
|
|
// insert expression at position or just add
|
|
if (insertPos !== undefined && insertPos !== -1) {
|
|
$scope.currentDecisionTable.outputExpressions.splice(insertPos, 0, newOutputExpression);
|
|
} else {
|
|
$scope.currentDecisionTable.outputExpressions.push(newOutputExpression);
|
|
}
|
|
|
|
// update column definitions off the source model
|
|
$scope.evaluateDecisionHeaders($scope.currentDecisionTable);
|
|
};
|
|
|
|
$scope.removeInputExpression = function (expressionPos) {
|
|
var removedElements = $scope.currentDecisionTable.inputExpressions.splice(expressionPos, 1);
|
|
removePropertyFromGrid(removedElements[0].id, 'input');
|
|
$scope.evaluateDecisionHeaders($scope.currentDecisionTable);
|
|
};
|
|
|
|
var removePropertyFromGrid = function (key, type) {
|
|
if ($scope.model.rulesData) {
|
|
$scope.model.rulesData.forEach(function (rowData) {
|
|
if (type === 'input') {
|
|
delete rowData[key + '_operator'];
|
|
delete rowData[key + '_expression'];
|
|
} else if (type === 'output') {
|
|
delete rowData[key];
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
$scope.removeOutputExpression = function (expressionPos) {
|
|
var removedElements = $scope.currentDecisionTable.outputExpressions.splice(expressionPos, 1);
|
|
removePropertyFromGrid(removedElements[0].id, 'output');
|
|
$scope.evaluateDecisionHeaders($scope.currentDecisionTable);
|
|
};
|
|
|
|
$scope.openInputExpressionEditor = function (expressionPos, newExpression) {
|
|
var editTemplate = 'views/popup/decision-table-edit-input-expression.html';
|
|
|
|
$scope.model.newExpression = !!newExpression;
|
|
|
|
if (!$scope.model.newExpression) {
|
|
$scope.model.selectedExpression = $scope.currentDecisionTable.inputExpressions[expressionPos];
|
|
} else {
|
|
if (expressionPos >= $scope.model.startOutputExpression) {
|
|
$scope.model.selectedColumn = $scope.model.startOutputExpression - 1;
|
|
} else {
|
|
$scope.model.selectedColumn = Math.floor(expressionPos / 2);
|
|
}
|
|
}
|
|
|
|
_internalCreateModal({
|
|
template: editTemplate,
|
|
scope: $scope
|
|
}, $modal, $scope);
|
|
};
|
|
|
|
$scope.openOutputExpressionEditor = function (expressionPos, newExpression) {
|
|
var editTemplate = 'views/popup/decision-table-edit-output-expression.html';
|
|
|
|
$scope.model.newExpression = !!newExpression;
|
|
$scope.model.hitPolicy = $scope.currentDecisionTable.hitIndicator;
|
|
$scope.model.selectedColumn = expressionPos;
|
|
|
|
|
|
if (!$scope.model.newExpression) {
|
|
$scope.model.selectedExpression = $scope.currentDecisionTable.outputExpressions[expressionPos];
|
|
}
|
|
|
|
_internalCreateModal({
|
|
template: editTemplate,
|
|
scope: $scope
|
|
}, $modal, $scope);
|
|
};
|
|
|
|
$scope.openHitPolicyEditor = function () {
|
|
var editTemplate = 'views/popup/decision-table-edit-hit-policy.html';
|
|
|
|
$scope.model.hitPolicy = $scope.currentDecisionTable.hitIndicator;
|
|
$scope.model.collectOperator = $scope.currentDecisionTable.collectOperator;
|
|
|
|
_internalCreateModal({
|
|
template: editTemplate,
|
|
scope: $scope
|
|
}, $modal, $scope);
|
|
};
|
|
|
|
var _loadDecisionTableDefinition = function (modelId) {
|
|
DecisionTableService.fetchDecisionTableDetails(modelId).then(function (decisionTable) {
|
|
|
|
$rootScope.currentDecisionTable = decisionTable.decisionTableDefinition;
|
|
$rootScope.currentDecisionTable.id = decisionTable.id;
|
|
$rootScope.currentDecisionTable.key = decisionTable.decisionTableDefinition.key;
|
|
$rootScope.currentDecisionTable.name = decisionTable.name;
|
|
$rootScope.currentDecisionTable.description = decisionTable.description;
|
|
|
|
$scope.model.lastUpdatedBy = decisionTable.lastUpdatedBy;
|
|
$scope.model.createdBy = decisionTable.createdBy;
|
|
|
|
// decision table model to used in save dialog
|
|
$rootScope.currentDecisionTableModel = {
|
|
id: decisionTable.id,
|
|
name: decisionTable.name,
|
|
key: decisionTable.key,
|
|
description: decisionTable.description
|
|
};
|
|
|
|
if (!$rootScope.currentDecisionTable.hitIndicator) {
|
|
$rootScope.currentDecisionTable.hitIndicator = hitPolicies[0];
|
|
}
|
|
|
|
var hitPolicyHeaderString = '<div class="hit-policy-header"><a onclick="triggerHitPolicyEditor()">' + $rootScope.currentDecisionTable.hitIndicator.substring(0, 1);
|
|
if ($rootScope.currentDecisionTable.collectOperator) {
|
|
hitPolicyHeaderString += collectOperators[$rootScope.currentDecisionTable.collectOperator];
|
|
}
|
|
hitPolicyHeaderString += '</a></div>';
|
|
hitPolicyHeaderElement = angular.element(hitPolicyHeaderString);
|
|
|
|
evaluateDecisionTableGrid($rootScope.currentDecisionTable);
|
|
|
|
$timeout(function () {
|
|
// Flip switch in timeout to start watching all decision-related models
|
|
// after next digest cycle, to prevent first false-positive
|
|
$scope.status.loading = false;
|
|
$rootScope.decisionTableChanges = false;
|
|
});
|
|
|
|
});
|
|
};
|
|
|
|
var composeInputOperatorColumnDefinition = function (inputExpression) {
|
|
var expressionPosition = $scope.currentDecisionTable.inputExpressions.indexOf(inputExpression);
|
|
|
|
var columnDefinition = {
|
|
data: inputExpression.id + '_operator',
|
|
expressionType: 'input-operator',
|
|
expression: inputExpression,
|
|
width: '70',
|
|
className: 'input-operator-cell',
|
|
type: 'dropdown',
|
|
source: getOperatorsForColumnType(inputExpression.type)
|
|
};
|
|
|
|
if ($scope.currentDecisionTable.inputExpressions.length !== 1) {
|
|
columnDefinition.title = '<div class="header-remove-expression">' +
|
|
'<a onclick="triggerRemoveExpression(\'input\',' + expressionPosition + ',true)"><span class="glyphicon glyphicon-minus-sign"></span></a>' +
|
|
'</div>';
|
|
}
|
|
|
|
return columnDefinition;
|
|
};
|
|
|
|
var getOperatorsForColumnType = function (type) {
|
|
switch (type) {
|
|
case 'number':
|
|
return numberOperators;
|
|
case 'date':
|
|
return dateOperators;
|
|
case 'boolean':
|
|
return booleanOperators;
|
|
case 'string':
|
|
return stringOperators;
|
|
case 'collection':
|
|
return collectionOperators;
|
|
default:
|
|
return allOperators;
|
|
}
|
|
};
|
|
|
|
var composeInputExpressionColumnDefinition = function (inputExpression) {
|
|
var expressionPosition = $scope.currentDecisionTable.inputExpressions.indexOf(inputExpression);
|
|
|
|
var type;
|
|
switch (inputExpression.type) {
|
|
case 'date':
|
|
type = 'date';
|
|
break;
|
|
case 'number':
|
|
type = 'numeric';
|
|
break;
|
|
case 'boolean':
|
|
type = 'dropdown';
|
|
break;
|
|
default:
|
|
type = 'text';
|
|
}
|
|
|
|
var columnDefinition = {
|
|
data: inputExpression.id + '_expression',
|
|
type: type,
|
|
title: '<div class="input-header">' +
|
|
'<a onclick="triggerExpressionEditor(\'input\',' + expressionPosition + ',false)"><span class="header-label">' + (inputExpression.label ? inputExpression.label : "New Input") + '</span></a>' +
|
|
'<br><span class="header-variable">' + (inputExpression.variableId ? inputExpression.variableId : "none") + '</span>' +
|
|
'<br/><span class="header-variable-type">' + (inputExpression.type ? inputExpression.type : "") + '</brspan>' +
|
|
'</div>' +
|
|
'<div class="header-add-new-expression">' +
|
|
'<a onclick="triggerExpressionEditor(\'input\',' + expressionPosition + ',true)"><span class="glyphicon glyphicon-plus-sign"></span></a>' +
|
|
'</div>',
|
|
expressionType: 'input-expression',
|
|
expression: inputExpression,
|
|
className: 'htCenter',
|
|
width: '200'
|
|
};
|
|
|
|
if (inputExpression.entries && inputExpression.entries.length > 0) {
|
|
var entriesOptionValues = inputExpression.entries.slice(0, inputExpression.entries.length);
|
|
entriesOptionValues.push('-');
|
|
|
|
columnDefinition.type = 'dropdown';
|
|
columnDefinition.strict = true;
|
|
columnDefinition.source = entriesOptionValues;
|
|
|
|
columnDefinition.title = '<div class="input-header">' +
|
|
'<a onclick="triggerExpressionEditor(\'input\',' + expressionPosition + ',false)"><span class="header-label">' + (inputExpression.label ? inputExpression.label : "New Input") + '</span></a>' +
|
|
'<br><span class="header-variable">' + (inputExpression.variableId ? inputExpression.variableId : "none") + '</span>' +
|
|
'<br/><span class="header-variable-type">' + (inputExpression.type ? inputExpression.type : "") + '</span>' +
|
|
'<br><span class="header-entries">[' + inputExpression.entries.join() + ']</span>' +
|
|
'</div>' +
|
|
'<div class="header-add-new-expression">' +
|
|
'<a onclick="triggerExpressionEditor(\'input\',' + expressionPosition + ',true)"><span class="glyphicon glyphicon-plus-sign"></span></a>' +
|
|
'</div>';
|
|
} else if (type === 'text') {
|
|
columnDefinition.validator = textValidator;
|
|
}
|
|
|
|
if (type === 'date') {
|
|
columnDefinition.dateFormat = dateFormat;
|
|
columnDefinition.validator = function (value, callback) {
|
|
if (value === '-') {
|
|
callback(true);
|
|
} else {
|
|
Handsontable.DateValidator.call(this, value, callback);
|
|
}
|
|
}
|
|
|
|
} else if (type === 'dropdown') {
|
|
columnDefinition.source = ['true', 'false', '-'];
|
|
}
|
|
|
|
if (type !== 'text') {
|
|
columnDefinition.allowEmpty = false;
|
|
}
|
|
|
|
return columnDefinition;
|
|
};
|
|
|
|
var composeOutputColumnDefinition = function (outputExpression) {
|
|
var expressionPosition = $scope.currentDecisionTable.outputExpressions.indexOf(outputExpression);
|
|
|
|
var type;
|
|
switch (outputExpression.type) {
|
|
case 'date':
|
|
type = 'date';
|
|
break;
|
|
case 'number':
|
|
type = 'numeric';
|
|
break;
|
|
case 'boolean':
|
|
type = 'dropdown';
|
|
break;
|
|
default:
|
|
type = 'text';
|
|
}
|
|
|
|
var title = '';
|
|
var columnDefinition = {
|
|
data: outputExpression.id,
|
|
type: type,
|
|
expressionType: 'output',
|
|
expression: outputExpression,
|
|
className: 'htCenter',
|
|
width: '270'
|
|
};
|
|
|
|
if ($scope.currentDecisionTable.outputExpressions.length !== 1) {
|
|
title = '<div class="header-remove-expression">' +
|
|
'<a onclick="triggerRemoveExpression(\'output\',' + expressionPosition + ',true)"><span class="glyphicon glyphicon-minus-sign"></span></a>' +
|
|
'</div>';
|
|
}
|
|
|
|
if (outputExpression.entries && outputExpression.entries.length > 0) {
|
|
var entriesOptionValues = outputExpression.entries.slice(0, outputExpression.entries.length);
|
|
columnDefinition.type = 'dropdown';
|
|
columnDefinition.source = entriesOptionValues;
|
|
columnDefinition.strict = true;
|
|
|
|
title += '<div class="output-header">' +
|
|
'<a onclick="triggerExpressionEditor(\'output\',' + expressionPosition + ',false)"><span class="header-label">' + (outputExpression.label ? outputExpression.label : "New Output") + '</span></a>' +
|
|
'<br><span class="header-variable">' + (outputExpression.variableId ? outputExpression.variableId : "none") + '</span>' +
|
|
'<br/><span class="header-variable-type">' + (outputExpression.type ? outputExpression.type : "") + '</span>' +
|
|
'<br><span class="header-entries">[' + outputExpression.entries.join() + ']</span>' +
|
|
'</div>' +
|
|
'<div class="header-add-new-expression">' +
|
|
'<a onclick="triggerExpressionEditor(\'output\',' + expressionPosition + ',true)"><span class="glyphicon glyphicon-plus-sign"></span></a>' +
|
|
'</div>';
|
|
|
|
} else {
|
|
title += '<div class="output-header">' +
|
|
'<a onclick="triggerExpressionEditor(\'output\',' + expressionPosition + ',false)"><span class="header-label">' + (outputExpression.label ? outputExpression.label : "New Output") + '</span></a>' +
|
|
'<br><span class="header-variable">' + (outputExpression.variableId ? outputExpression.variableId : "none") + '</span>' +
|
|
'<br/><span class="header-variable-type">' + (outputExpression.type ? outputExpression.type : "") + '</span>' +
|
|
'</div>' +
|
|
'<div class="header-add-new-expression">' +
|
|
'<a onclick="triggerExpressionEditor(\'output\',' + expressionPosition + ',true)"><span class="glyphicon glyphicon-plus-sign"></span></a>' +
|
|
'</div>';
|
|
}
|
|
|
|
if (type === 'date') {
|
|
columnDefinition.dateFormat = dateFormat;
|
|
} else if (type === 'dropdown') {
|
|
columnDefinition.source = ['true', 'false', '-'];
|
|
}
|
|
|
|
columnDefinition.title = title;
|
|
|
|
return columnDefinition;
|
|
};
|
|
|
|
$scope.evaluateDecisionHeaders = function (decisionTable) {
|
|
|
|
var element = document.querySelector("thead > tr > th:first-of-type > div > a");
|
|
if (element) {
|
|
if (decisionTable.collectOperator) {
|
|
element.innerHTML = decisionTable.hitIndicator.substring(0, 1) + collectOperators[decisionTable.collectOperator];
|
|
} else {
|
|
element.innerHTML = decisionTable.hitIndicator.substring(0, 1);
|
|
}
|
|
}
|
|
|
|
var columnDefinitions = [];
|
|
var inputExpressionCounter = 0;
|
|
if (decisionTable.inputExpressions && decisionTable.inputExpressions.length > 0) {
|
|
decisionTable.inputExpressions.forEach(function (inputExpression) {
|
|
var inputOperatorColumnDefinition = composeInputOperatorColumnDefinition(inputExpression);
|
|
columnDefinitions.push(inputOperatorColumnDefinition);
|
|
setGridValues(inputOperatorColumnDefinition.data, inputOperatorColumnDefinition.expressionType);
|
|
|
|
var inputExpressionColumnDefinition = composeInputExpressionColumnDefinition(inputExpression);
|
|
columnDefinitions.push(inputExpressionColumnDefinition);
|
|
setGridValues(inputExpressionColumnDefinition.data, inputExpressionColumnDefinition.expressionType);
|
|
|
|
inputExpressionCounter += 2;
|
|
});
|
|
|
|
} else { // create default input expression
|
|
decisionTable.inputExpressions = [];
|
|
var inputExpression = createNewInputExpression();
|
|
decisionTable.inputExpressions.push(inputExpression);
|
|
columnDefinitions.push(composeInputOperatorColumnDefinition(inputExpression));
|
|
columnDefinitions.push(composeInputExpressionColumnDefinition(inputExpression));
|
|
inputExpressionCounter += 2;
|
|
}
|
|
|
|
columnDefinitions[inputExpressionCounter - 1].className += ' last';
|
|
$scope.model.startOutputExpression = inputExpressionCounter;
|
|
|
|
if (decisionTable.outputExpressions && decisionTable.outputExpressions.length > 0) {
|
|
decisionTable.outputExpressions.forEach(function (outputExpression) {
|
|
columnDefinitions.push(composeOutputColumnDefinition(outputExpression));
|
|
});
|
|
|
|
} else { // create default output expression
|
|
decisionTable.outputExpressions = [];
|
|
var outputExpression = createNewOutputExpression();
|
|
decisionTable.outputExpressions.push(outputExpression);
|
|
columnDefinitions.push(composeOutputColumnDefinition(outputExpression));
|
|
}
|
|
|
|
columnDefinitions[inputExpressionCounter].className += ' first';
|
|
|
|
// timeout needed for trigger hot update when removing column defs
|
|
$scope.model.columnDefs = columnDefinitions;
|
|
$timeout(function () {
|
|
if (hotDecisionTableEditorInstance) {
|
|
hotDecisionTableEditorInstance.render();
|
|
}
|
|
});
|
|
};
|
|
|
|
var setGridValues = function (key, type) {
|
|
if ($scope.model.rulesData) {
|
|
$scope.model.rulesData.forEach(function (rowData) {
|
|
if (type === 'input-operator') {
|
|
if (!(key in rowData) || rowData[key] === '') {
|
|
rowData[key] = '==';
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
var createDefaultRow = function () {
|
|
var defaultRow = {};
|
|
$scope.model.columnDefs.forEach(function (columnDefinition) {
|
|
if (columnDefinition.expressionType === 'input-operator') {
|
|
defaultRow[columnDefinition.data] = '==';
|
|
}
|
|
else if (columnDefinition.expressionType === 'input-expression') {
|
|
defaultRow[columnDefinition.data] = '-';
|
|
}
|
|
else if (columnDefinition.expressionType === 'output') {
|
|
defaultRow[columnDefinition.data] = '';
|
|
}
|
|
});
|
|
|
|
return defaultRow;
|
|
};
|
|
|
|
var evaluateDecisionGrid = function (decisionTable) {
|
|
var tmpRuleGrid = [];
|
|
|
|
// rows
|
|
if (decisionTable.rules && decisionTable.rules.length > 0) {
|
|
decisionTable.rules.forEach(function (rule) {
|
|
|
|
// rule data
|
|
var tmpRowValues = {};
|
|
for (var i = 0; i < Object.keys(rule).length; i++) {
|
|
var id = Object.keys(rule)[i];
|
|
|
|
$scope.model.columnDefs.forEach(function (columnDef) {
|
|
// set counter to max value
|
|
var expressionId = 0;
|
|
try {
|
|
expressionId = parseInt(columnDef.expression.id);
|
|
} catch (e) {
|
|
}
|
|
if (expressionId > columnIdCounter) {
|
|
columnIdCounter = expressionId;
|
|
}
|
|
});
|
|
|
|
// collection operators backwards compatibility
|
|
// var cellValue = regressionTransformation(id, rule[id]);
|
|
|
|
tmpRowValues[id] = rule[id];
|
|
}
|
|
|
|
tmpRuleGrid.push(tmpRowValues);
|
|
});
|
|
} else {
|
|
// initialize default values
|
|
tmpRuleGrid.push(createDefaultRow());
|
|
}
|
|
// $rootScope.currentDecisionTableRules = tmpRuleGrid;
|
|
$scope.model.rulesData = tmpRuleGrid;
|
|
};
|
|
|
|
var evaluateDecisionTableGrid = function (decisionTable) {
|
|
$scope.evaluateDecisionHeaders(decisionTable);
|
|
evaluateDecisionGrid(decisionTable);
|
|
};
|
|
|
|
|
|
// fetch table from service and populate model
|
|
_loadDecisionTableDefinition($routeParams.modelId);
|
|
|
|
var _generateColumnId = function () {
|
|
columnIdCounter++;
|
|
return "" + columnIdCounter;
|
|
};
|
|
|
|
}]);
|
|
|
|
angular.module('flowableModeler')
|
|
.controller('DecisionTableInputConditionEditorCtlr', ['$rootScope', '$scope', 'hotRegisterer', '$timeout', function ($rootScope, $scope, hotRegisterer, $timeout) {
|
|
|
|
var getEntriesValues = function (entriesArrayOfArrays) {
|
|
var newEntriesArray = [];
|
|
// remove last value
|
|
entriesArrayOfArrays.pop();
|
|
|
|
entriesArrayOfArrays.forEach(function (entriesArray) {
|
|
newEntriesArray.push(entriesArray[0]);
|
|
});
|
|
|
|
return newEntriesArray;
|
|
};
|
|
|
|
var createEntriesValues = function (entriesArray) {
|
|
var localCopy = entriesArray.slice(0);
|
|
var entriesArrayOfArrays = [];
|
|
while (localCopy.length) {
|
|
entriesArrayOfArrays.push(localCopy.splice(0, 1));
|
|
}
|
|
|
|
return entriesArrayOfArrays;
|
|
};
|
|
|
|
var deleteRowRenderer = function (instance, td, row) {
|
|
td.innerHTML = '';
|
|
td.className = 'remove_container';
|
|
|
|
if ((row + 1) != $scope.popup.selectedExpressionInputValues.length) {
|
|
var div = document.createElement('div');
|
|
div.onclick = function () {
|
|
return instance.alter("remove_row", row);
|
|
};
|
|
div.className = 'btn';
|
|
div.appendChild(document.createTextNode('x'));
|
|
td.appendChild(div);
|
|
}
|
|
return td;
|
|
};
|
|
|
|
// condition input options
|
|
if ($scope.model.newExpression === false) {
|
|
$scope.popup = {
|
|
selectedExpressionLabel: $scope.model.selectedExpression.label ? $scope.model.selectedExpression.label : '',
|
|
selectedExpressionVariableId: $scope.model.selectedExpression.variableId,
|
|
selectedExpressionVariableType: $scope.model.selectedExpression.type ? $scope.model.selectedExpression.type : $scope.model.availableInputVariableTypes[0],
|
|
selectedExpressionInputValues: $scope.model.selectedExpression.entries && $scope.model.selectedExpression.entries.length > 0 ? createEntriesValues($scope.model.selectedExpression.entries) : [['']],
|
|
columnDefs: [
|
|
{
|
|
width: '300'
|
|
},
|
|
{
|
|
width: '40',
|
|
readOnly: true,
|
|
renderer: deleteRowRenderer
|
|
}
|
|
],
|
|
hotSettings: {
|
|
stretchH: 'none'
|
|
}
|
|
};
|
|
} else {
|
|
$scope.popup = {
|
|
selectedExpressionLabel: '',
|
|
selectedExpressionVariableId: '',
|
|
selectedExpressionVariableType: $scope.model.availableInputVariableTypes[0],
|
|
selectedExpressionInputValues: [['']],
|
|
columnDefs: [
|
|
{
|
|
width: '300'
|
|
|
|
},
|
|
{
|
|
renderer: deleteRowRenderer,
|
|
readOnly: true,
|
|
width: '40'
|
|
}
|
|
],
|
|
hotSettings: {
|
|
stretchH: 'none'
|
|
}
|
|
};
|
|
}
|
|
|
|
$scope.save = function () {
|
|
if ($scope.model.newExpression) {
|
|
var newInputExpression = {
|
|
variableId: $scope.popup.selectedExpressionVariableId,
|
|
type: $scope.popup.selectedExpressionVariableType,
|
|
label: $scope.popup.selectedExpressionLabel,
|
|
entries: $scope.popup.selectedExpressionVariableType !== 'collection' ? getEntriesValues($scope.popup.selectedExpressionInputValues) : []
|
|
};
|
|
|
|
$scope.addNewInputExpression(newInputExpression, $scope.model.selectedColumn + 1);
|
|
|
|
} else {
|
|
$scope.model.selectedExpression.variableId = $scope.popup.selectedExpressionVariableId;
|
|
$scope.model.selectedExpression.type = $scope.popup.selectedExpressionVariableType;
|
|
$scope.model.selectedExpression.label = $scope.popup.selectedExpressionLabel;
|
|
$scope.model.selectedExpression.entries = $scope.popup.selectedExpressionVariableType !== 'collection' ? getEntriesValues($scope.popup.selectedExpressionInputValues) : [];
|
|
$scope.evaluateDecisionHeaders($scope.currentDecisionTable);
|
|
}
|
|
|
|
$scope.close();
|
|
};
|
|
|
|
$scope.setExpressionVariableType = function (variableType) {
|
|
$scope.popup.selectedExpressionVariable = null;
|
|
$scope.popup.selectedExpressionVariableType = variableType;
|
|
};
|
|
|
|
$scope.setNewVariable = function (value) {
|
|
$scope.popup.selectedExpressionNewVariable = value;
|
|
if (value) {
|
|
$scope.setExpressionVariableType('variable');
|
|
}
|
|
};
|
|
|
|
$scope.close = function () {
|
|
$scope.$hide();
|
|
};
|
|
|
|
// Cancel button handler
|
|
$scope.cancel = function () {
|
|
$scope.close();
|
|
};
|
|
}]);
|
|
|
|
angular.module('flowableModeler')
|
|
.controller('DecisionTableConclusionEditorCtrl', ['$rootScope', '$scope', '$q', '$translate', 'hotRegisterer', function ($rootScope, $scope, $q, $translate, hotRegisterer) {
|
|
|
|
var hotInstance;
|
|
var getEntriesValues = function (entriesArrayOfArrays) {
|
|
var newEntriesArray = [];
|
|
// remove last value
|
|
entriesArrayOfArrays.pop();
|
|
|
|
entriesArrayOfArrays.forEach(function (entriesArray) {
|
|
newEntriesArray.push(entriesArray[0]);
|
|
});
|
|
|
|
return newEntriesArray;
|
|
};
|
|
|
|
var createEntriesValues = function (entriesArray) {
|
|
var localCopy = entriesArray.slice(0);
|
|
var entriesArrayOfArrays = [];
|
|
while (localCopy.length) {
|
|
entriesArrayOfArrays.push(localCopy.splice(0, 1));
|
|
}
|
|
|
|
return entriesArrayOfArrays;
|
|
};
|
|
|
|
var deleteRowRenderer = function (instance, td, row) {
|
|
td.innerHTML = '';
|
|
td.className = 'remove_container';
|
|
|
|
if ((row + 1) != $scope.popup.selectedExpressionOutputValues.length) {
|
|
var div = document.createElement('div');
|
|
div.onclick = function () {
|
|
return instance.alter("remove_row", row);
|
|
};
|
|
div.className = 'btn';
|
|
div.appendChild(document.createTextNode('x'));
|
|
td.appendChild(div);
|
|
}
|
|
return td;
|
|
};
|
|
|
|
$scope.doAfterRender = function () {
|
|
hotInstance = hotRegisterer.getInstance('decision-table-allowed-values');
|
|
};
|
|
|
|
if ($scope.model.newExpression === false) {
|
|
$scope.popup = {
|
|
selectedExpressionLabel: $scope.model.selectedExpression.label ? $scope.model.selectedExpression.label : '',
|
|
selectedExpressionNewVariableId: $scope.model.selectedExpression.variableId,
|
|
selectedExpressionNewVariableType: $scope.model.selectedExpression.type ? $scope.model.selectedExpression.type : $scope.model.availableOutputVariableTypes[0],
|
|
selectedExpressionOutputValues: $scope.model.selectedExpression.entries && $scope.model.selectedExpression.entries.length > 0 ? createEntriesValues($scope.model.selectedExpression.entries) : [['']],
|
|
currentHitPolicy: $scope.model.hitPolicy,
|
|
columnDefs: [
|
|
{
|
|
width: '250'
|
|
},
|
|
{
|
|
width: '40',
|
|
readOnly: true,
|
|
renderer: deleteRowRenderer
|
|
}
|
|
],
|
|
hotSettings: {
|
|
currentColClassName: 'currentCol',
|
|
stretchH: 'none'
|
|
}
|
|
};
|
|
} else {
|
|
$scope.popup = {
|
|
selectedExpressionLabel: '',
|
|
selectedExpressionNewVariableId: '',
|
|
selectedExpressionNewVariableType: $scope.model.availableOutputVariableTypes[0],
|
|
selectedExpressionOutputValues: [['']],
|
|
currentHitPolicy: $scope.model.hitPolicy,
|
|
columnDefs: [
|
|
{
|
|
width: '250'
|
|
},
|
|
{
|
|
width: '40',
|
|
readOnly: true,
|
|
renderer: deleteRowRenderer
|
|
}
|
|
],
|
|
hotSettings: {
|
|
stretchH: 'none'
|
|
}
|
|
};
|
|
}
|
|
|
|
// Cancel button handler
|
|
$scope.cancel = function () {
|
|
$scope.close();
|
|
};
|
|
|
|
// Saving the edited input
|
|
$scope.save = function () {
|
|
if ($scope.model.newExpression) {
|
|
var newOutputExpression = {
|
|
variableId: $scope.popup.selectedExpressionNewVariableId,
|
|
type: $scope.popup.selectedExpressionNewVariableType,
|
|
label: $scope.popup.selectedExpressionLabel,
|
|
entries: getEntriesValues(hotInstance.getData())
|
|
};
|
|
$scope.addNewOutputExpression(newOutputExpression, $scope.model.selectedColumn + 1);
|
|
|
|
} else {
|
|
$scope.model.selectedExpression.variableId = $scope.popup.selectedExpressionNewVariableId;
|
|
$scope.model.selectedExpression.type = $scope.popup.selectedExpressionNewVariableType;
|
|
$scope.model.selectedExpression.label = $scope.popup.selectedExpressionLabel;
|
|
$scope.model.selectedExpression.entries = getEntriesValues(hotInstance.getData());
|
|
$scope.evaluateDecisionHeaders($scope.currentDecisionTable);
|
|
}
|
|
|
|
$scope.close();
|
|
};
|
|
|
|
$scope.close = function () {
|
|
|
|
$scope.$hide();
|
|
};
|
|
|
|
$scope.dumpData = function () {
|
|
console.log(hotInstance.getData());
|
|
}
|
|
|
|
}]);
|
|
|
|
angular.module('flowableModeler')
|
|
.controller('DecisionTableHitPolicyEditorCtrl', ['$rootScope', '$scope', '$q', '$translate', function ($rootScope, $scope, $q, $translate) {
|
|
|
|
$scope.popup = {
|
|
currentHitPolicy: $scope.model.hitPolicy,
|
|
currentCollectOperator: $scope.model.collectOperator,
|
|
availableHitPolicies: $scope.hitPolicies,
|
|
availableCollectOperators: $scope.collectOperators
|
|
};
|
|
|
|
// Cancel button handler
|
|
$scope.cancel = function () {
|
|
$scope.close();
|
|
};
|
|
|
|
// Saving the edited input
|
|
$scope.save = function () {
|
|
$scope.currentDecisionTable.hitIndicator = $scope.popup.currentHitPolicy;
|
|
if ($scope.popup.currentHitPolicy === 'COLLECT') {
|
|
$scope.currentDecisionTable.collectOperator = $scope.popup.currentCollectOperator;
|
|
} else {
|
|
$scope.currentDecisionTable.collectOperator = undefined;
|
|
}
|
|
|
|
$scope.evaluateDecisionHeaders($scope.currentDecisionTable);
|
|
|
|
$scope.close();
|
|
};
|
|
|
|
$scope.close = function () {
|
|
$scope.$hide();
|
|
};
|
|
|
|
}]);
|