1269 lines
81 KiB
JavaScript
1269 lines
81 KiB
JavaScript
"use strict";
|
|
(function () {
|
|
'use strict';
|
|
angular.module('consoleModule')
|
|
.factory('ticketConsoleModel', ['consoleService', 'configurationModel', 'metadataModel', 'userModel', 'consoleColumnsModel', '$rootScope', '$q', '$filter', 'authService', 'roles',
|
|
function (consoleService, configurationModel, metadataModel, userModel, consoleColumnsModel, $rootScope, $q, $filter, authService, roles) {
|
|
var ticketConsoleModel = {}, metricRequestStats, headerCellTemplate = '<div class="ngHeaderSortColumn {{col.headerClass}}" ng-style="{\'cursor\': col.cursor}" ng-class="{ \'ngSorted\': !noSortVisible }">' +
|
|
'<div ux-id="column-header" ng-click="col.sort($event)" ng-class="\'colt\' + col.index" class="ngHeaderText">{{col.displayName}}</div>' +
|
|
' <div class="ngSortButtonUp" ng-show="col.showSortButtonDown()"></div>' +
|
|
' <div class="ngSortButtonDown" ng-show="col.showSortButtonUp()"></div>' +
|
|
' <div class="ngSortPriority">{{col.sortPriority}}</div>' +
|
|
' <div ng-class="{ ngPinnedIcon: col.pinned, ngUnPinnedIcon: !col.pinned }" ng-click="togglePin(col)" ng-show="col.pinnable"></div>' +
|
|
'</div>' +
|
|
'<div ng-show="col.resizable" class="ngHeaderGrip" ng-click="col.gripClick($event)" ng-mousedown="col.gripOnMouseDown($event)"></div>', minWidth = 140, filterPreferenceGroup = 'TicketConsoleFilter', columnPreferenceGroup = 'TicketConsoleColumns', columnPreferenceDetailsId = '', cellTemplates = {
|
|
needsAttention: '<div class=\"ngCenteredCellText fixed-width-narrow\" ng-class=\"col.colIndex()\" ng-bind-html="COL_FIELD | tcCellNeedsAttention:row.entity"></div>',
|
|
priority: '<div class=\"ngCenteredCellText fixed-width-narrow\" ng-class=\"col.colIndex()\" ng-bind-html="COL_FIELD | tcCellPriority:row.entity.type"></div>',
|
|
targetDate: '<div class=\"ngCellText\" ng-class=\"col.colIndex()\"><span ng-cell-text class=\"{{(row.getProperty(col.field) | haveDatePassed) ? \'ngCellDatePassed\' : \'\'}}\"><time-ticker ng-if="row.getProperty(col.field)" refresh-interval=\'30000\' time=\'row.getProperty(col.field)\'></time-ticker></span></div>'
|
|
}, quickSearchCellTemplate = '<div class=\"ngCellText\" ng-class=\"col.colIndex()\"><span ng-cell-text ng-bind-html="row.getProperty(col.field) | tcCellHighlight:row.entity.highlight"></span></div>', customWidths = {
|
|
priority: 100,
|
|
summary: 350
|
|
}, cellFilters = configurationModel.get('ticketConsole.cellFilters'), searchEnabled = true, extendColumnConfig = function () {
|
|
_.forEach(ticketConsoleModel.columnsConfig, function (column) {
|
|
if (_.isObject(column)) {
|
|
angular.extend(column, {
|
|
headerCellTemplate: headerCellTemplate,
|
|
minWidth: minWidth,
|
|
width: column.width || minWidth
|
|
});
|
|
}
|
|
});
|
|
}, validatePreset = function (preset) {
|
|
var validPreset = preset, tempArray = [];
|
|
_.each(preset.value, function (val) {
|
|
if (_.findIndex(ticketConsoleModel.filterConfig, { name: val.filter }) === -1) {
|
|
tempArray.push(val);
|
|
}
|
|
});
|
|
_.each(tempArray, function (item) {
|
|
if (item.filter === 'advanceSearchQuery') {
|
|
validPreset = true;
|
|
}
|
|
else if (_.findIndex(ticketConsoleModel.availableColConfig, { name: item.filter, type: 'custom' }) === -1) {
|
|
validPreset = false;
|
|
}
|
|
});
|
|
if (validPreset) {
|
|
_.each(preset.columnValue, function (val, key) {
|
|
if (key !== 'newColumnType' && _.findIndex(ticketConsoleModel.availableColConfig, { name: key }) === -1) {
|
|
delete preset.columnValue[key];
|
|
}
|
|
});
|
|
}
|
|
return validPreset;
|
|
}, formatColumnField = function (key, val) {
|
|
var customFieldTypes = ['numberField', 'dynamicSelectionField', 'staticSelectionField', 'characterField'], availableColumns = ticketConsoleModel.availableColConfig, attribute = _.find(availableColumns, { name: key }), returnValue = val, fieldObj;
|
|
if (attribute && attribute.field && attribute.field.type && attribute.field.options) {
|
|
fieldObj = attribute.field;
|
|
}
|
|
else if (attribute && attribute.oldFields && attribute.oldFields.type && attribute.oldFields.options) {
|
|
fieldObj = attribute.oldFields;
|
|
}
|
|
if (fieldObj && fieldObj.type === 'staticSelectionField' && customFieldTypes.indexOf(fieldObj.type) !== -1) {
|
|
var returnObjMap = _.find(fieldObj.options, { index: val });
|
|
returnValue = (returnObjMap) ? returnObjMap.label : '';
|
|
}
|
|
return returnValue;
|
|
}, getTicketTypesForOption = function (option, filter) {
|
|
var ticketTypes = [];
|
|
_.each(ticketConsoleModel.metaDataArrays, function (ticketMeta) {
|
|
if (ticketMeta.consoleColumns && !_.isEmpty(ticketMeta.consoleColumns)) {
|
|
var ticketType = ticketMeta.metadatatype, filOptions = ticketMeta.consoleColumns[filter.name];
|
|
if (_.isArray(filOptions)) {
|
|
if (!_.isUndefined(_.find(filOptions, { name: option.name }))) {
|
|
ticketTypes.push(ticketType);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return ticketTypes;
|
|
}, formatFilterOptionForCustomField = function (options, obj) {
|
|
obj.showLabelInPill = true;
|
|
obj.label = obj.displayName;
|
|
obj.visible = true;
|
|
obj.onDisplay = true;
|
|
if (obj.fieldType === 'staticSelectionField') {
|
|
_.each(options, function (op) {
|
|
op.type = 'constant';
|
|
op.filterType = 'customFilter';
|
|
op.onDisplay = true;
|
|
op.criteria = {
|
|
name: obj.name,
|
|
value: [op.name],
|
|
ticketTypes: getTicketTypesForOption(op, obj)
|
|
};
|
|
});
|
|
}
|
|
else if (obj.fieldType === 'numberField') {
|
|
options = [
|
|
{
|
|
label: obj.displayName,
|
|
type: 'range',
|
|
subtype: 'range',
|
|
filterType: 'customFilter',
|
|
criteria: {
|
|
name: obj.name,
|
|
value: [{ min: 1, max: 1 }]
|
|
}
|
|
}
|
|
];
|
|
obj.range = {
|
|
min: obj.oldFields.min,
|
|
max: obj.oldFields.max
|
|
};
|
|
}
|
|
else if (obj.fieldType === 'dateTimeField') {
|
|
if (obj.oldFields.dataType === 'datetime') {
|
|
options = [
|
|
{
|
|
name: 'createDatePast24',
|
|
label: 'past24',
|
|
type: 'date',
|
|
filterType: 'customFilter',
|
|
defaultValues: {
|
|
start: 'moment().subtract(1, "days").valueOf()',
|
|
end: 'moment().valueOf()'
|
|
},
|
|
criteria: {
|
|
name: obj.name
|
|
}
|
|
},
|
|
{
|
|
name: 'createDatePast48',
|
|
label: 'past48',
|
|
type: 'date',
|
|
filterType: 'customFilter',
|
|
defaultValues: {
|
|
start: 'moment().subtract(2, "days").valueOf()',
|
|
end: 'moment().valueOf()'
|
|
},
|
|
criteria: {
|
|
name: obj.name
|
|
}
|
|
},
|
|
{
|
|
name: 'createDatePastWeek',
|
|
label: 'pastWeek',
|
|
type: 'date',
|
|
filterType: 'customFilter',
|
|
defaultValues: {
|
|
start: 'moment().subtract(7, "days").valueOf()',
|
|
end: 'moment().valueOf()'
|
|
},
|
|
criteria: {
|
|
name: obj.name
|
|
}
|
|
},
|
|
{
|
|
name: 'createDateCustomRange',
|
|
label: 'customRange',
|
|
type: 'timeStampRange',
|
|
filterType: 'customFilter',
|
|
format: 'mediumDate',
|
|
startDatePicker: {
|
|
date: new Date()
|
|
},
|
|
endDatePicker: {
|
|
date: new Date()
|
|
},
|
|
criteria: {
|
|
name: obj.name
|
|
}
|
|
}
|
|
];
|
|
}
|
|
else if (obj.oldFields.dataType === 'date' || obj.oldFields.dataType === 'time') {
|
|
options = [
|
|
{
|
|
name: 'createDateCustomRange',
|
|
label: 'customRange',
|
|
type: 'timeStampRange',
|
|
filterType: 'customFilter',
|
|
format: 'mediumDate',
|
|
startDatePicker: {
|
|
date: new Date()
|
|
},
|
|
endDatePicker: {
|
|
date: new Date()
|
|
},
|
|
criteria: {
|
|
name: obj.name
|
|
}
|
|
}
|
|
];
|
|
}
|
|
}
|
|
else {
|
|
options = [
|
|
{
|
|
label: obj.displayName,
|
|
type: 'search',
|
|
subtype: 'keyword',
|
|
filterType: 'customFilter'
|
|
}
|
|
];
|
|
}
|
|
obj.options = options;
|
|
return obj;
|
|
}, composeFilterConfig = function (dict) {
|
|
var mergedObj = {};
|
|
_.forEach(ticketConsoleModel.metaDataArrays, function (ticketData) {
|
|
if (!_.isEmpty(ticketData.consoleColumns)) {
|
|
if (_.isEmpty(mergedObj)) {
|
|
mergedObj = _.assign(mergedObj, ticketData.consoleColumns);
|
|
}
|
|
else {
|
|
_.each(ticketData.consoleColumns, function (val, key) {
|
|
if (mergedObj.hasOwnProperty(key)) {
|
|
if (_.isArray(val)) {
|
|
var optionMerge = mergedObj[key].concat(val);
|
|
mergedObj[key] = _.uniqBy(optionMerge, 'name');
|
|
}
|
|
}
|
|
else {
|
|
mergedObj[key] = val;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
ticketConsoleModel.mergedConsoleColumns = mergedObj;
|
|
ticketConsoleModel.customColumnsObjs = _.filter(_.merge(_.cloneDeep(ticketConsoleModel.availableColumnsConfig), ticketConsoleModel.currentColumnsConfig), { type: 'custom' });
|
|
var customFilterDict = [];
|
|
_.each(ticketConsoleModel.customColumnsObjs, function (obj) {
|
|
if (obj.visible && mergedObj.hasOwnProperty(obj.attributeName)) {
|
|
obj = formatFilterOptionForCustomField(mergedObj[obj.attributeName], obj);
|
|
if (_.isUndefined(_.find(ticketConsoleModel.filterConfig, { name: obj.name }))) {
|
|
customFilterDict.push(obj);
|
|
}
|
|
}
|
|
});
|
|
ticketConsoleModel.filterConfig = _.sortBy(ticketConsoleModel.filterConfig.concat(customFilterDict), 'name');
|
|
dict = _.assign(_.keyBy(customFilterDict, 'name'), dict);
|
|
return dict;
|
|
}, setCellFilter = function (attrObj, key) {
|
|
if (cellFilters.hasOwnProperty(key)) {
|
|
attrObj.cellFilter = cellFilters[key];
|
|
}
|
|
}, composeColumnConfig = function (columns) {
|
|
var availableColumns = columns, columnsObj = {}, columnsArr = [];
|
|
_.forEach(ticketConsoleModel.metaDataArrays, function (ticketData) {
|
|
if (!_.isEmpty(ticketData.consoleColumns)) {
|
|
columnsObj[ticketData.metadatatype] = Object.keys(ticketData.consoleColumns);
|
|
columnsArr.push(Object.keys(ticketData.consoleColumns));
|
|
}
|
|
});
|
|
var commonColumns = _.intersection.apply(null, columnsArr), configObj = {};
|
|
_.forEach(ticketConsoleModel.metaDataArrays, function (ticketData) {
|
|
_.forEach(ticketData.consoleColumns, function (v, key) {
|
|
var tempObj = {};
|
|
tempObj = { ticketType: [ticketData.metadatatype] };
|
|
if (configObj.hasOwnProperty(key)) {
|
|
configObj[key].ticketType.push(ticketData.metadatatype);
|
|
}
|
|
if (commonColumns.indexOf(key) === -1 && !configObj.hasOwnProperty(key)) {
|
|
var attributeObj = _.find(availableColumns, { name: key });
|
|
if (!_.isUndefined(attributeObj)) {
|
|
tempObj.attributeName = key;
|
|
if (attributeObj.hasOwnProperty('field')) {
|
|
if (attributeObj.field.label) {
|
|
tempObj.displayName = attributeObj.field.label;
|
|
}
|
|
if (attributeObj.field.type === 'dateTimeField') {
|
|
/* We are using the date filter in cellTemplate and the date filter converts the epoch value according to the current timezone.We need to display date values in GMT.
|
|
Added UTC tz for mediumDate filter. So that date only column field values will be shown in UTC.*/
|
|
attributeObj.cellFilter = (attributeObj.field.dataType === 'time') ? 'milliToTime' : ((attributeObj.field.dataType === 'date') ? 'date:"mediumDate":"+0:00"' : 'datePreConfigTimezone:"medium"');
|
|
}
|
|
}
|
|
if (attributeObj.hasOwnProperty('ootbMaping')) {
|
|
attributeObj.field = attributeObj.ootbMaping[0];
|
|
}
|
|
else if (attributeObj.type === 'custom') {
|
|
if (!attributeObj.oldFields) {
|
|
attributeObj.oldFields = _.cloneDeep(attributeObj.field);
|
|
}
|
|
attributeObj.fieldType = attributeObj.field.type;
|
|
attributeObj.field = attributeObj.name;
|
|
}
|
|
if (cellTemplates.hasOwnProperty(key)) {
|
|
attributeObj.cellTemplate = cellTemplates[key];
|
|
}
|
|
setCustomCellTemplateForColumns(attributeObj, key);
|
|
setCellFilter(attributeObj, key);
|
|
if (customWidths.hasOwnProperty(key)) {
|
|
attributeObj.width = customWidths[key];
|
|
}
|
|
tempObj = _.assign(tempObj, attributeObj);
|
|
configObj[key] = tempObj;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
_.forEach(commonColumns, function (colName) {
|
|
var attributeObj = _.find(availableColumns, { name: colName });
|
|
if (!_.isUndefined(attributeObj)) {
|
|
attributeObj.attributeName = colName;
|
|
if (attributeObj.hasOwnProperty('field')) {
|
|
if (attributeObj.field.label) {
|
|
attributeObj.displayName = attributeObj.field.label;
|
|
}
|
|
if (attributeObj.field.type === 'dateTimeField') {
|
|
/* We are using the date filter in cellTemplate and the date filter converts the epoch value according to the current timezone.We need to display date values in GMT.
|
|
Added UTC tz for mediumDate filter. So that date only column field values will be shown in UTC.*/
|
|
attributeObj.cellFilter = (attributeObj.field.dataType === 'time') ? 'milliToTime' : ((attributeObj.field.dataType === 'date') ? 'date:"mediumDate":"+0:00"' : 'datePreConfigTimezone:"medium"');
|
|
}
|
|
}
|
|
if (attributeObj.hasOwnProperty('ootbMaping')) {
|
|
attributeObj.field = attributeObj.ootbMaping[0];
|
|
}
|
|
else if (attributeObj.type === 'custom') {
|
|
attributeObj.fieldType = attributeObj.field.type;
|
|
attributeObj.field = attributeObj.name;
|
|
}
|
|
if (cellTemplates.hasOwnProperty(colName)) {
|
|
attributeObj.cellTemplate = cellTemplates[colName];
|
|
}
|
|
setCustomCellTemplateForColumns(attributeObj, colName);
|
|
setCellFilter(attributeObj, colName);
|
|
if (customWidths.hasOwnProperty(colName)) {
|
|
attributeObj.width = customWidths[colName];
|
|
}
|
|
configObj[colName] = attributeObj;
|
|
}
|
|
});
|
|
return configObj;
|
|
};
|
|
ticketConsoleModel.filterPreferenceGroup = filterPreferenceGroup;
|
|
ticketConsoleModel.columnPreferenceGroup = columnPreferenceGroup;
|
|
ticketConsoleModel.formatFilterOptionForCustomField = formatFilterOptionForCustomField;
|
|
ticketConsoleModel.ribbonConfig = configurationModel.get('ticketConsole.ribbon');
|
|
ticketConsoleModel.filterConfig = configurationModel.get('ticketConsole.filter');
|
|
ticketConsoleModel.statsConfig = configurationModel.get('ticketConsole.stats');
|
|
ticketConsoleModel.quickSearchMaxCharLimit = configurationModel.get('ticketConsole.config.quickSearchCharLimit');
|
|
if (window.isRtl) {
|
|
ticketConsoleModel.statsConfig.reverse();
|
|
}
|
|
ticketConsoleModel.currentColumnsConfig = {};
|
|
ticketConsoleModel.ticketTypeFilter = _.find(ticketConsoleModel.filterConfig, { name: 'ticketTypes' });
|
|
ticketConsoleModel.presetColumns = null;
|
|
metricRequestStats = _.map(ticketConsoleModel.statsConfig, function (stat) {
|
|
return { name: stat.name };
|
|
});
|
|
ticketConsoleModel.defaultChunkSize = 75;
|
|
ticketConsoleModel.exceedChunkSize = false;
|
|
ticketConsoleModel.criteria = {
|
|
filterCriteria: {},
|
|
chunkInfo: { startIndex: 0, chunkSize: ticketConsoleModel.defaultChunkSize },
|
|
sortInfo: {},
|
|
attributeNames: [],
|
|
customAttributeNames: []
|
|
};
|
|
ticketConsoleModel.itemList = [];
|
|
ticketConsoleModel.selectedFilters = [];
|
|
ticketConsoleModel.filterDict = _.keyBy((ticketConsoleModel.filterConfig), 'name');
|
|
ticketConsoleModel.checkIfPwaEnabled = function (conf) {
|
|
var enabledFlag = conf.configurationParameters && (conf.configurationParameters['Enable-Progressive-Views'] === 'T' || conf.configurationParameters['Enable-Progressive-Views'] === 'true'), midtierUrl = localStorage.getItem('midtierUrl');
|
|
return (enabledFlag && midtierUrl);
|
|
};
|
|
ticketConsoleModel.populateMetadataAndColumns = function () {
|
|
return $q.all([metadataModel.getMetadataByTypes(EntityVO.TICKET_TYPES), consoleColumnsModel.getTicketAvailableColumnsList(), userModel.getUserPreferences(columnPreferenceGroup), metadataModel.getMetadataByType(EntityVO.TYPE_GLOBAL)]).then(function (configData) {
|
|
ticketConsoleModel.showStats = !configurationModel.explicitStatsRefresh;
|
|
ticketConsoleModel.metaDataArrays = configData[0];
|
|
ticketConsoleModel.availableColList = _.cloneDeep(configData[1].itemList);
|
|
ticketConsoleModel.userSavedColumnPresets = configData[2] || [];
|
|
ticketConsoleModel.quickSearchHighlightedColumn = (configData[3] && configData[3].quickSearchHighlightedCols) || [];
|
|
ticketConsoleModel.removeDateRestriction = (configData[3] && configData[3].removeDateRestriction) || [];
|
|
ticketConsoleModel.isPwaEnabled = ticketConsoleModel.checkIfPwaEnabled(configData[3]) || false;
|
|
if (!ticketConsoleModel.isPwaEnabled) {
|
|
ticketConsoleModel.availableColList = _.reject(ticketConsoleModel.availableColList, { name: 'majorIncident' });
|
|
}
|
|
if (!configurationModel.showNeedsAttentionFlag) {
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'needsAttention' });
|
|
ticketConsoleModel.ribbonConfig = _.reject(ticketConsoleModel.ribbonConfig, { name: 'bulk-need-attention' });
|
|
metricRequestStats = _.reject(metricRequestStats, { name: 'needsAttention' });
|
|
}
|
|
var consoleDefaultColumns = _.find(ticketConsoleModel.userSavedColumnPresets, { name: 'defaultConsoleColumns' }) || {}, defaultColumnPreset = _.find(ticketConsoleModel.userSavedColumnPresets, { name: 'columns' }) || {}, columns;
|
|
if (_.isEmpty(defaultColumnPreset) && !_.isEmpty(consoleDefaultColumns)) {
|
|
columns = consoleDefaultColumns.value || {};
|
|
}
|
|
else {
|
|
if (_.isEmpty(defaultColumnPreset.value)) {
|
|
columns = consoleDefaultColumns.value || {};
|
|
}
|
|
else {
|
|
var mergeWithDefault = false;
|
|
_.each(defaultColumnPreset.value, function (col) {
|
|
if (col.type !== 'system' && col.type !== 'custom') {
|
|
// check if merge the columns with default columns is required
|
|
mergeWithDefault = true;
|
|
return false;
|
|
}
|
|
});
|
|
if (mergeWithDefault) {
|
|
columns = _.mergeWith(consoleDefaultColumns.value, defaultColumnPreset.value, function (a, b) {
|
|
if (_.isObject(a)) {
|
|
a.type = 'system';
|
|
}
|
|
});
|
|
// save this preference
|
|
ticketConsoleModel.updateColumnConfig(columns);
|
|
}
|
|
else {
|
|
columns = defaultColumnPreset.value || {};
|
|
}
|
|
}
|
|
}
|
|
ticketConsoleModel.availableColConfig = _.cloneDeep(ticketConsoleModel.availableColList);
|
|
_.each(columns, function (val, key) {
|
|
if (_.isUndefined(_.find(ticketConsoleModel.availableColList, { name: key }))) {
|
|
delete columns[key];
|
|
}
|
|
});
|
|
ticketConsoleModel.currentColumnsConfig = columns;
|
|
columnPreferenceDetailsId = defaultColumnPreset.id;
|
|
ticketConsoleModel.avialableCustomColumns = _.map(_.filter(ticketConsoleModel.availableColList, { type: 'custom' }), 'name');
|
|
ticketConsoleModel.availableColumnsConfig = composeColumnConfig(ticketConsoleModel.availableColList);
|
|
});
|
|
};
|
|
ticketConsoleModel.populateFilters = function () {
|
|
if (ticketConsoleModel.areFiltersPopulated) {
|
|
return $q.when(1);
|
|
}
|
|
return $q.all([userModel.getFullCurrentUserData()]).then(function (result) {
|
|
ticketConsoleModel.filterDict = composeFilterConfig(ticketConsoleModel.filterDict);
|
|
var userData = result[0], filterAssingneeMe = _.find(ticketConsoleModel.filterDict.assignees.options, { label: 'me' }), filterMyGroups = _.find(ticketConsoleModel.filterDict.assignedSupportGroups.options, { label: 'myGroup' }), filterMyOrganization = _.find(ticketConsoleModel.filterDict.organizations.options, { label: 'myOrganization' }), filterMySite = _.find(ticketConsoleModel.filterDict.sites.options, { label: 'mySite' }), filterChangeManagerMe = _.find(ticketConsoleModel.filterDict.changeManager.options, { label: 'me' }), filterRequestManagerMe = _.find(ticketConsoleModel.filterDict.requestManagers.options, { label: 'me' }), filterChangeManagerMyGroup = _.find(ticketConsoleModel.filterDict.changeManagerGroup.options, { label: 'myGroup' }), filterRequestManagerMyGroup = _.find(ticketConsoleModel.filterDict.requestManagerGroups.options, { label: 'myGroup' }), filterSubmitterMe = _.find(ticketConsoleModel.filterDict.submittedBy.options, { label: 'me' }), filterApprovedByMe = _.find(ticketConsoleModel.filterDict.approvedBy.options, { label: 'me' }), filterApproverMe = _.find(ticketConsoleModel.filterDict.approvalAssignment.options, { label: 'me' }), filterApproverMyGroups = _.find(ticketConsoleModel.filterDict.approvalAssignment.options, { label: 'myGroup' }), filterProblemCoordinatorMe = _.find(ticketConsoleModel.filterDict.problemCoordinators.options, { label: 'me' }), filterReleaseCoordinatorMe = _.find(ticketConsoleModel.filterDict.releaseCoordinator.options, { label: 'me' }), filterProblemCoordinatorMyGroups = _.find(ticketConsoleModel.filterDict.problemCoordinatorGroups.options, { label: 'myGroup' }), filterReleaseCoordinatorMyGroups = _.find(ticketConsoleModel.filterDict.releaseCoordinatorGroup.options, { label: 'myGroup' });
|
|
filterAssingneeMe.subLabel = userData.fullName;
|
|
filterAssingneeMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterMyGroups.criteria.value = userData.supportGroups;
|
|
filterMyOrganization.subLabel = userData.organization;
|
|
filterMyOrganization.criteria.value = [userData.organization];
|
|
filterMySite.subLabel = userData.site.name;
|
|
filterMySite.criteria.value = [{ name: userData.site.name }];
|
|
filterChangeManagerMe.subLabel = userData.fullName;
|
|
filterChangeManagerMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterRequestManagerMe.subLabel = userData.fullName;
|
|
filterRequestManagerMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterSubmitterMe.subLabel = userData.fullName;
|
|
filterSubmitterMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterChangeManagerMyGroup.criteria.value = userData.supportGroups;
|
|
filterRequestManagerMyGroup.criteria.value = userData.supportGroups;
|
|
filterApprovedByMe.subLabel = userData.fullName;
|
|
filterApprovedByMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterApproverMe.subLabel = userData.fullName;
|
|
filterApproverMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterApproverMyGroups.criteria.value = userData.supportGroups;
|
|
filterProblemCoordinatorMe.subLabel = userData.fullName;
|
|
filterProblemCoordinatorMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterReleaseCoordinatorMe.subLabel = userData.fullName;
|
|
filterReleaseCoordinatorMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterProblemCoordinatorMyGroups.criteria.value = userData.supportGroups;
|
|
filterReleaseCoordinatorMyGroups.criteria.value = userData.supportGroups;
|
|
var fullStatusesList = [], fullRiskLevelList = [], fullChangeReasonsList = [], fullChangeClassList = [], fullInvestigationDriversList = [], fullPriorityList = [], fullMilestonesList = [], fullIncidentTypesList = [], majorIncidentList = [];
|
|
_.forEach(ticketConsoleModel.metaDataArrays, function (ticketMetadata) {
|
|
if ((ticketMetadata.metadatatype === EntityVO.TYPE_CHANGE && !authService.isAuthorized(roles.ITSM_CHANGE_USER_ROLE)) ||
|
|
(ticketMetadata.metadatatype === EntityVO.TYPE_KNOWNERROR && !authService.isAuthorized(roles.ITSM_PROBLEM_USER_ROLE)) ||
|
|
(ticketMetadata.metadatatype === EntityVO.TYPE_PROBLEM && !authService.isAuthorized(roles.ITSM_PROBLEM_USER_ROLE)) ||
|
|
(ticketMetadata.metadatatype === EntityVO.TYPE_INCIDENT && !authService.isAuthorized(roles.ITSM_AGENT_ROLE)) ||
|
|
(ticketMetadata.metadatatype === EntityVO.TYPE_WORKORDER && !authService.isAuthorized(roles.ITSM_AGENT_ROLE)) ||
|
|
(ticketMetadata.metadatatype === EntityVO.TYPE_SERVICEREQUEST && !authService.isAuthorized(roles.ITSM_AGENT_ROLE))) {
|
|
return;
|
|
}
|
|
fullRiskLevelList = fullRiskLevelList.concat(ticketMetadata.riskLevels);
|
|
fullChangeReasonsList = fullChangeReasonsList.concat(ticketMetadata.changeReasons);
|
|
fullChangeClassList = fullChangeClassList.concat(ticketMetadata.timings);
|
|
fullInvestigationDriversList = fullInvestigationDriversList.concat(ticketMetadata.investigationDrivers);
|
|
if (ticketMetadata.metadatatype === EntityVO.TYPE_INCIDENT) {
|
|
fullIncidentTypesList = fullIncidentTypesList.concat(ticketMetadata.types);
|
|
if (ticketConsoleModel.isPwaEnabled) {
|
|
majorIncidentList = majorIncidentList.concat(ticketMetadata.majorIncident);
|
|
}
|
|
}
|
|
//fullStatusesList = fullStatusesList.concat(ticketMetadata.statuses); //TicketType element added to each status in the status list.
|
|
_.forEach(ticketMetadata.statuses, function (specificStatus) {
|
|
if (_.findIndex(fullStatusesList, { name: specificStatus.name }) !== -1) {
|
|
var oldStatusObject = _.find(fullStatusesList, { name: specificStatus.name });
|
|
oldStatusObject.ticketTypes.push(ticketMetadata.metadatatype);
|
|
}
|
|
else {
|
|
specificStatus.ticketTypes = [ticketMetadata.metadatatype];
|
|
fullStatusesList.push(specificStatus);
|
|
}
|
|
});
|
|
_.forEach(ticketMetadata.priorities, function (specificPriority) {
|
|
if (_.findIndex(fullPriorityList, { name: specificPriority.name }) !== -1) {
|
|
var oldPriorityObject = _.find(fullPriorityList, { name: specificPriority.name });
|
|
oldPriorityObject.ticketTypes.push(ticketMetadata.metadatatype);
|
|
}
|
|
else {
|
|
specificPriority.ticketTypes = [EntityVO.TYPE_SERVICEREQUEST, ticketMetadata.metadatatype];
|
|
fullPriorityList.push(specificPriority);
|
|
}
|
|
});
|
|
_.forEach(ticketMetadata.milestones, function (specificMilestone) {
|
|
if (_.findIndex(fullMilestonesList, { name: specificMilestone.name }) !== -1) {
|
|
var oldMilestonesObject = _.find(fullMilestonesList, { name: specificMilestone.name });
|
|
oldMilestonesObject.ticketTypes.push(ticketMetadata.metadatatype);
|
|
}
|
|
else {
|
|
specificMilestone.ticketTypes = [ticketMetadata.metadatatype];
|
|
fullMilestonesList.push(specificMilestone);
|
|
}
|
|
});
|
|
});
|
|
//fullStatusesList = _.sortBy(_.uniq(fullStatusesList, 'name'), 'name');
|
|
fullRiskLevelList = _.sortBy(_.uniqBy(fullRiskLevelList, 'name'), 'name');
|
|
fullChangeReasonsList = _.uniqBy(fullChangeReasonsList, 'name');
|
|
fullChangeClassList = _.sortBy(_.uniqBy(fullChangeClassList, 'name'), 'name');
|
|
fullInvestigationDriversList = _.sortBy(_.uniqBy(fullInvestigationDriversList, 'name'), 'name');
|
|
fullPriorityList = _.sortBy(_.uniqBy(fullPriorityList, 'name'), 'name');
|
|
fullMilestonesList = _.sortBy(_.uniqBy(fullMilestonesList, 'name'), 'name');
|
|
fullIncidentTypesList = _.sortBy(_.uniqBy(fullIncidentTypesList, 'name'), 'name');
|
|
majorIncidentList = _.sortBy(_.uniqBy(majorIncidentList, 'name'), 'name');
|
|
if (!ticketConsoleModel.metaDataRefresh) {
|
|
_.forEach(fullStatusesList, function (specificStatus) {
|
|
var flag = _.find(ticketConsoleModel.filterDict.statuses.options, { name: specificStatus.label });
|
|
if (flag) {
|
|
flag.criteria.value.push(specificStatus.name);
|
|
flag.criteria.ticketTypes.push(specificStatus.ticketTypes);
|
|
flag.criteria.ticketTypes = _.flatten(flag.criteria.ticketTypes);
|
|
}
|
|
else {
|
|
ticketConsoleModel.filterDict.statuses.options.push({
|
|
name: specificStatus.label,
|
|
type: 'dynamic',
|
|
filterName: 'statuses',
|
|
criteria: {
|
|
name: 'ticketSpecificStatuses',
|
|
value: [specificStatus.name],
|
|
ticketTypes: specificStatus.ticketTypes //Add element ticket type
|
|
}
|
|
});
|
|
}
|
|
});
|
|
_.forEach(fullRiskLevelList, function (riskLevel) {
|
|
ticketConsoleModel.filterDict.riskLevel.options.push({
|
|
name: riskLevel.label,
|
|
type: 'dynamic',
|
|
filterName: 'riskLevel',
|
|
criteria: {
|
|
name: 'riskLevel',
|
|
value: [riskLevel.name]
|
|
}
|
|
});
|
|
});
|
|
_.forEach(fullChangeReasonsList, function (changeReason) {
|
|
ticketConsoleModel.filterDict.changeReason.options.push({
|
|
name: changeReason.label,
|
|
type: 'dynamic',
|
|
filterName: 'changeReason',
|
|
criteria: {
|
|
name: 'changeReason',
|
|
value: [changeReason.name]
|
|
}
|
|
});
|
|
});
|
|
_.forEach(fullChangeClassList, function (changeClass) {
|
|
ticketConsoleModel.filterDict.changeClass.options.push({
|
|
name: changeClass.label,
|
|
type: 'dynamic',
|
|
filterName: 'changeClass',
|
|
criteria: {
|
|
name: 'changeClass',
|
|
value: [changeClass.name]
|
|
}
|
|
});
|
|
});
|
|
_.forEach(fullInvestigationDriversList, function (investigationDriver) {
|
|
ticketConsoleModel.filterDict.investigationDrivers.options.push({
|
|
name: investigationDriver.label,
|
|
type: 'dynamic',
|
|
filterName: 'investigationDrivers',
|
|
criteria: {
|
|
name: 'investigationDrivers',
|
|
value: [investigationDriver.name]
|
|
}
|
|
});
|
|
});
|
|
_.forEach(fullPriorityList, function (priority) {
|
|
ticketConsoleModel.filterDict.priorities.options.push({
|
|
name: priority.label,
|
|
filterValue: priority.name,
|
|
type: 'dynamic',
|
|
filterName: 'priorities',
|
|
criteria: {
|
|
name: 'priorities',
|
|
value: [priority.name],
|
|
ticketTypes: priority.ticketTypes //Add element ticket type
|
|
}
|
|
});
|
|
});
|
|
_.forEach(fullMilestonesList, function (milestone) {
|
|
ticketConsoleModel.filterDict.milestone.options.push({
|
|
name: milestone.label,
|
|
type: 'dynamic',
|
|
filterName: 'milestone',
|
|
criteria: {
|
|
name: 'milestone',
|
|
value: [milestone.name],
|
|
ticketTypes: milestone.ticketTypes //Add element ticket type
|
|
}
|
|
});
|
|
});
|
|
_.forEach(fullIncidentTypesList, function (incidentType) {
|
|
ticketConsoleModel.filterDict.incidentTypes.options.push({
|
|
name: incidentType.label,
|
|
type: 'dynamic',
|
|
filterName: 'incidentTypes',
|
|
criteria: {
|
|
name: 'incidentTypes',
|
|
value: [incidentType.name]
|
|
}
|
|
});
|
|
});
|
|
_.forEach(majorIncidentList, function (majorIncident) {
|
|
ticketConsoleModel.filterDict.majorIncident.options.push({
|
|
name: majorIncident.label,
|
|
type: 'dynamic',
|
|
filterName: 'majorIncident',
|
|
criteria: {
|
|
name: 'majorIncident',
|
|
value: [majorIncident.name]
|
|
}
|
|
});
|
|
});
|
|
}
|
|
//TODO: refactor this to work with configuration
|
|
if (!configurationModel.isServerApplicationEnabled(EntityVO.TYPE_SLM) || (!authService.isAuthorized(roles.ITSM_AGENT_ROLE) && !authService.isAuthorized(roles.ITSM_CHANGE_USER_ROLE))) {
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'slmStatusMappings' });
|
|
}
|
|
if (!configurationModel.isServerApplicationEnabled(EntityVO.TYPE_SERVICEREQUEST)) {
|
|
ticketConsoleModel.filterDict.ticketTypes.options = _.reject(ticketConsoleModel.filterDict.ticketTypes.options, { name: EntityVO.TYPE_SERVICEREQUEST });
|
|
}
|
|
if (!configurationModel.isServerApplicationEnabled(EntityVO.TYPE_WORKORDER)) {
|
|
ticketConsoleModel.filterDict.ticketTypes.options = _.reject(ticketConsoleModel.filterDict.ticketTypes.options, { name: EntityVO.TYPE_WORKORDER });
|
|
}
|
|
if (!configurationModel.isServerApplicationEnabled(EntityVO.TYPE_CHANGE) || !authService.isAuthorized(roles.ITSM_CHANGE_USER_ROLE)) {
|
|
ticketConsoleModel.filterDict.ticketTypes.options = _.reject(ticketConsoleModel.filterDict.ticketTypes.options, { name: EntityVO.TYPE_CHANGE });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'changeClass' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'changeManager' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'changeManagerGroup' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'riskLevel' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'changeReason' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'approvalStatuses' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'approvalAssignment' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'approvedBy' });
|
|
}
|
|
if (!configurationModel.isServerApplicationEnabled(EntityVO.TYPE_RELEASE) || !authService.isAuthorized(roles.ITSM_RELEASE_USER_ROLE)) {
|
|
ticketConsoleModel.filterDict.ticketTypes.options = _.reject(ticketConsoleModel.filterDict.ticketTypes.options, { name: EntityVO.TYPE_RELEASE });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'deploymentStartDate,' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'deploymentEndDate' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'milestone' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'releaseCoordinator' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'releaseCoordinatorGroup' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'targetDate' });
|
|
}
|
|
if (!authService.isAuthorized(roles.ITSM_AGENT_ROLE)) {
|
|
ticketConsoleModel.filterDict.ticketTypes.options = _.reject(ticketConsoleModel.filterDict.ticketTypes.options, function (item) {
|
|
return _.includes([EntityVO.TYPE_SERVICEREQUEST, EntityVO.TYPE_WORKORDER, EntityVO.TYPE_INCIDENT], item.name);
|
|
});
|
|
}
|
|
if (!configurationModel.isServerApplicationEnabled(EntityVO.TYPE_PROBLEM) || !authService.isAuthorized(roles.ITSM_PROBLEM_USER_ROLE)) {
|
|
ticketConsoleModel.filterDict.ticketTypes.options = _.reject(ticketConsoleModel.filterDict.ticketTypes.options, { name: EntityVO.TYPE_PROBLEM });
|
|
ticketConsoleModel.filterDict.ticketTypes.options = _.reject(ticketConsoleModel.filterDict.ticketTypes.options, { name: EntityVO.TYPE_KNOWNERROR });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'problemCoordinatorGroups' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'problemCoordinators' });
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'investigationDrivers' });
|
|
}
|
|
if (!authService.isAuthorized(roles.ITSM_AGENT_ROLE) && !authService.isAuthorized(roles.ITSM_CHANGE_USER_ROLE)) {
|
|
ticketConsoleModel.filterConfig = _.reject(ticketConsoleModel.filterConfig, { name: 'organizations' });
|
|
}
|
|
var enabledServerApplications = configurationModel.get('enabledServerApplications');
|
|
_.forEach(ticketConsoleModel.filterDict.statuses.options, function (option) {
|
|
if (option.criteria && option.criteria.ticketTypes) {
|
|
ticketConsoleModel.filterDict.statuses.options = _.reject(ticketConsoleModel.filterDict.statuses.options, function (option) {
|
|
return _.intersection(enabledServerApplications, option.criteria.ticketTypes).length === 0;
|
|
});
|
|
}
|
|
});
|
|
_.forEach(ticketConsoleModel.filterDict.priorities.options, function (option) {
|
|
if (option.criteria && option.criteria.ticketTypes) {
|
|
ticketConsoleModel.filterDict.priorities.options = _.reject(ticketConsoleModel.filterDict.priorities.options, function (option) {
|
|
return _.intersection(enabledServerApplications, option.criteria.ticketTypes).length === 0;
|
|
});
|
|
}
|
|
});
|
|
});
|
|
};
|
|
ticketConsoleModel.populateConfiguration = function () {
|
|
if (!_.isEmpty(ticketConsoleModel.columnsConfig)) {
|
|
return $q.when(1);
|
|
}
|
|
ticketConsoleModel.restrictConsoleResultForNoOfDays = configurationModel.restrictConsoleResultForNoOfDays;
|
|
return $q.all([userModel.getUserPreferences(filterPreferenceGroup), metadataModel.getMetadataByType(EntityVO.TYPE_GLOBAL)]).then(function (config) {
|
|
ticketConsoleModel.columnsConfig = _.merge(_.cloneDeep(ticketConsoleModel.availableColumnsConfig), ticketConsoleModel.currentColumnsConfig);
|
|
//ticketConsoleModel.columnsConfig = _.merge(_.cloneDeep(configurationModel.get('ticketConsole.columns')), columns);
|
|
if (!configurationModel.isServerApplicationEnabled(EntityVO.TYPE_SLM)) {
|
|
delete ticketConsoleModel.columnsConfig.slaStatus;
|
|
}
|
|
ticketConsoleModel.userSavedFilterPresets = config[0];
|
|
if (configurationModel.showNeedsAttentionFlag) {
|
|
ticketConsoleModel.userSavedFilterPresets.unshift({
|
|
id: 'needsAttentionFilter',
|
|
fixed: true,
|
|
name: 'Needs Attention',
|
|
label: $filter('i18n')('console.ticket.preDefinedUserFilter.needsAttentionFilter'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [
|
|
{ filter: 'assignees', option: 'me' },
|
|
{ filter: 'needsAttention', option: 'flagged' }
|
|
]
|
|
});
|
|
}
|
|
ticketConsoleModel.userSavedFilterPresets.unshift({
|
|
id: 'myAllOpenTicketsFilter',
|
|
fixed: true,
|
|
name: 'My Assigned Tickets',
|
|
label: $filter('i18n')('console.ticket.preDefinedUserFilter.myAllOpenTicketsFilter'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [
|
|
{ filter: 'assignees', option: 'me' },
|
|
{ filter: 'statuses', option: 'allOpen' }
|
|
]
|
|
}, {
|
|
id: 'myGroupOpenTicketsFilter',
|
|
fixed: true,
|
|
name: 'My Groups\' Assigned Tickets',
|
|
label: $filter('i18n')('console.ticket.preDefinedUserFilter.myGroupOpenTicketsFilter'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [
|
|
{ filter: 'assignedSupportGroups', option: 'myGroup' },
|
|
{ filter: 'statuses', option: 'allOpen' }
|
|
]
|
|
});
|
|
if (configurationModel.showSecurityTickets) {
|
|
var localizedOption = $filter('i18n')('console.filter.optionName.securityIncident');
|
|
ticketConsoleModel.userSavedFilterPresets.unshift({
|
|
id: 'securityTicketsFilter',
|
|
fixed: true,
|
|
name: 'Security Tickets',
|
|
label: $filter('i18n')('console.ticket.preDefinedUserFilter.securityTickets'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [
|
|
{ filter: 'assignedSupportGroups', option: 'myGroup' },
|
|
{ filter: 'incidentTypes', option: localizedOption }
|
|
]
|
|
});
|
|
}
|
|
ticketConsoleModel.userSavedPresets = _.cloneDeep(ticketConsoleModel.userSavedFilterPresets);
|
|
_.each(ticketConsoleModel.userSavedColumnPresets, function (columnPreset) {
|
|
if (columnPreset.name !== 'columns' && columnPreset.name !== 'defaultConsoleColumns') {
|
|
var matchPreset = _.find(ticketConsoleModel.userSavedPresets, { name: columnPreset.name });
|
|
if (matchPreset) {
|
|
matchPreset.columnId = columnPreset.id;
|
|
matchPreset.columnValue = columnPreset.value;
|
|
matchPreset = validatePreset(matchPreset);
|
|
if (!matchPreset) {
|
|
_.remove(ticketConsoleModel.userSavedPresets, { name: columnPreset.name });
|
|
}
|
|
}
|
|
else {
|
|
columnPreset.columnId = columnPreset.id;
|
|
columnPreset.columnValue = columnPreset.value;
|
|
delete columnPreset.id;
|
|
delete columnPreset.value;
|
|
ticketConsoleModel.userSavedPresets.push(columnPreset);
|
|
}
|
|
}
|
|
});
|
|
extendColumnConfig();
|
|
ticketConsoleModel.populateAttributeNames();
|
|
});
|
|
};
|
|
ticketConsoleModel.addUserSavedPresets = function (name) {
|
|
var filterPreset = _.find(ticketConsoleModel.userSavedFilterPresets, { name: name }), columnPreset = _.find(ticketConsoleModel.userSavedColumnPresets, { name: name }), combinedPreset = {};
|
|
if (filterPreset) {
|
|
combinedPreset = filterPreset;
|
|
if (columnPreset) {
|
|
combinedPreset.columnId = columnPreset.id;
|
|
combinedPreset.columnValue = columnPreset.value;
|
|
}
|
|
}
|
|
else if (columnPreset) {
|
|
combinedPreset.columnId = columnPreset.id;
|
|
combinedPreset.columnValue = columnPreset.value;
|
|
combinedPreset.name = columnPreset.name;
|
|
}
|
|
ticketConsoleModel.userSavedPresets.push(combinedPreset);
|
|
};
|
|
ticketConsoleModel.populateAttributeNames = function () {
|
|
ticketConsoleModel.criteria.attributeNames = _.map(_.filter(ticketConsoleModel.columnsConfig, function (column) {
|
|
return (column.visible && column.type === 'system');
|
|
}), 'attributeName');
|
|
ticketConsoleModel.criteria.customAttributeNames = _.map(_.filter(ticketConsoleModel.columnsConfig, function (column) {
|
|
return (column.visible && column.type === 'custom');
|
|
}), 'attributeName');
|
|
};
|
|
function addCCSDateLimitToCriteria() {
|
|
var criteria = _.cloneDeep(ticketConsoleModel.criteria), includeDateRestriction = true;
|
|
if (ticketConsoleModel.restrictConsoleResultForNoOfDays) {
|
|
if (ticketConsoleModel.removeDateRestriction && ticketConsoleModel.removeDateRestriction.length) {
|
|
for (var index = 0; index < ticketConsoleModel.removeDateRestriction.length; index++) {
|
|
if (Object.keys(criteria.filterCriteria).indexOf(ticketConsoleModel.removeDateRestriction[index]) !== -1
|
|
&& !_.isEmpty(criteria.filterCriteria[ticketConsoleModel.removeDateRestriction[index]])) {
|
|
includeDateRestriction = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!ticketConsoleModel.checkDateFilterAdded() && includeDateRestriction) {
|
|
var date = new Date();
|
|
var currentDate = date.getTime();
|
|
date.setDate(date.getDate() - ticketConsoleModel.restrictConsoleResultForNoOfDays);
|
|
var fromDate = date.getTime();
|
|
criteria.filterCriteria['createDateRanges'] = [];
|
|
criteria.filterCriteria['createDateRanges'].push({ start: fromDate, end: currentDate });
|
|
}
|
|
}
|
|
return criteria;
|
|
}
|
|
ticketConsoleModel.getItemList = function () {
|
|
if (!ticketConsoleModel.criteria.attributeNames.length) {
|
|
var cols = _.sortBy(_.filter(ticketConsoleModel.columnsConfig, { visible: true, type: 'system' }), 'order');
|
|
cols.forEach(function (col) {
|
|
ticketConsoleModel.criteria.attributeNames.push(col.attributeName);
|
|
});
|
|
}
|
|
if (!ticketConsoleModel.criteria.customAttributeNames.length) {
|
|
var customCols = _.sortBy(_.filter(ticketConsoleModel.columnsConfig, { visible: true, type: 'custom' }), 'order');
|
|
customCols.forEach(function (col) {
|
|
ticketConsoleModel.criteria.customAttributeNames.push(col.attributeName);
|
|
});
|
|
}
|
|
_.each(ticketConsoleModel.criteria.attributeNames, function (colVal, index) {
|
|
var found = _.find(ticketConsoleModel.columnsConfig, { attributeName: colVal, type: 'custom' });
|
|
if (found) {
|
|
ticketConsoleModel.criteria.attributeNames.splice(index, 1);
|
|
ticketConsoleModel.criteria.customAttributeNames = _.union(ticketConsoleModel.criteria.customAttributeNames, [colVal]);
|
|
}
|
|
});
|
|
if (ticketConsoleModel.criteria.customAttributeNames.length
|
|
&& !ticketConsoleModel.appliedPreset.defaultpreset
|
|
&& _.isObject(ticketConsoleModel.appliedPreset.columnValue)) {
|
|
var arrLength = ticketConsoleModel.criteria.customAttributeNames.length;
|
|
for (var i = arrLength; i >= 0; i--) {
|
|
if (!_.has(ticketConsoleModel.appliedPreset.columnValue, ticketConsoleModel.criteria.customAttributeNames[i])) {
|
|
ticketConsoleModel.criteria.customAttributeNames.splice(i, 1);
|
|
}
|
|
}
|
|
}
|
|
var criteria = _.cloneDeep(ticketConsoleModel.criteria);
|
|
//Use CCS date limit only when there is no custom date range selected
|
|
if (!(ticketConsoleModel.criteria.filterCriteria && ticketConsoleModel.criteria.filterCriteria.createDateRanges)) {
|
|
criteria = addCCSDateLimitToCriteria();
|
|
}
|
|
return consoleService.getTicketList(criteria).then(function (result) {
|
|
_.forEach(result.itemList, function (item) {
|
|
if (!_.isUndefined(item.customFields)) {
|
|
_.each(item.customFields, function (val, key) {
|
|
if (val === 0 || val) {
|
|
item[key] = formatColumnField(key, val);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
ticketConsoleModel.itemList = ticketConsoleModel.criteria.chunkInfo.startIndex ? ticketConsoleModel.itemList.concat(result.itemList) : result.itemList;
|
|
ticketConsoleModel.exceedChunkSize = result.exceedChunkSize;
|
|
return result.totalCount;
|
|
});
|
|
};
|
|
ticketConsoleModel.dropCriteriaStartIndex = function () {
|
|
ticketConsoleModel.criteria.chunkInfo.startIndex = 0;
|
|
};
|
|
ticketConsoleModel.getTicketConsoleMetric = function () {
|
|
var criteria = _.cloneDeep(ticketConsoleModel.criteria);
|
|
//Use CCS date limit only when there is no custom date range selected
|
|
if (!(ticketConsoleModel.criteria.filterCriteria && ticketConsoleModel.criteria.filterCriteria.createDateRanges)) {
|
|
criteria = addCCSDateLimitToCriteria();
|
|
}
|
|
return consoleService.getTicketStats(criteria.filterCriteria, metricRequestStats)
|
|
.then(function (resultStats) {
|
|
_.forEach(ticketConsoleModel.statsConfig, function (stat) {
|
|
var resultStat = _.find(resultStats, { name: stat.name });
|
|
stat.value = resultStat ? resultStat.value : 0;
|
|
});
|
|
});
|
|
};
|
|
ticketConsoleModel.applyFilterSet = function (filterSet) {
|
|
_.forEach(filterSet, function (item) {
|
|
if (ticketConsoleModel.filterDict[item.filter]) {
|
|
var criteria = item.checkForLocale ? { filterValue: item.option } : { name: item.option }, option = _.find(ticketConsoleModel.filterDict[item.filter].options, criteria);
|
|
if (!option && item.type === 'dynamic') {
|
|
option = item.realOption;
|
|
ticketConsoleModel.filterDict[item.filter].options.push(item.realOption);
|
|
}
|
|
if (angular.isObject(option) && !option.active) {
|
|
option.active = true;
|
|
ticketConsoleModel.applyFilter(option);
|
|
}
|
|
if (angular.isObject(option) && ticketConsoleModel.metaDataRefresh) {
|
|
option.active = true;
|
|
ticketConsoleModel.applyFilter(option);
|
|
}
|
|
}
|
|
else if (item.filter === 'advanceSearchQuery') {
|
|
ticketConsoleModel.applyFilter({
|
|
advancedFilter: true,
|
|
criteria: {
|
|
name: 'advanceSearchQuery',
|
|
value: item.option
|
|
}
|
|
});
|
|
}
|
|
});
|
|
};
|
|
ticketConsoleModel.applyColumnSet = function (columnSet) {
|
|
var defaultVisibleColumns = _.filter(ticketConsoleModel.columnsConfig, { visible: true });
|
|
if (!configurationModel.isServerApplicationEnabled(EntityVO.TYPE_SLM)) {
|
|
delete ticketConsoleModel.columnsConfig.slaStatus;
|
|
}
|
|
ticketConsoleModel.presetColumns = [];
|
|
_.each(ticketConsoleModel.columnsConfig, function (item) {
|
|
var presetColumn = columnSet[item.name], columnData;
|
|
if (presetColumn) {
|
|
columnData = angular.copy(item);
|
|
columnData.order = presetColumn.order;
|
|
columnData.visible = (typeof presetColumn.visible !== 'undefined') ? presetColumn.visible : true;
|
|
ticketConsoleModel.presetColumns.push(columnData);
|
|
}
|
|
});
|
|
//check if preset was created before 1.5SP1
|
|
//accordingly loop and add columns from default column set to keep behavior consistent
|
|
if (!columnSet.newColumnType && defaultVisibleColumns.length) {
|
|
_.forEach(defaultVisibleColumns, function (item) {
|
|
if (!_.find(ticketConsoleModel.presetColumns, { name: item.name })) {
|
|
var columnData = angular.copy(item);
|
|
ticketConsoleModel.presetColumns.push(columnData);
|
|
}
|
|
});
|
|
}
|
|
ticketConsoleModel.presetColumns = _.sortBy(ticketConsoleModel.presetColumns, 'order');
|
|
ticketConsoleModel.criteria.attributeNames = _.map(ticketConsoleModel.presetColumns, 'attributeName');
|
|
};
|
|
ticketConsoleModel.applyFilter = function (filterOption) {
|
|
var criteria = ticketConsoleModel.criteria.filterCriteria, name = filterOption.criteria.name, multiselect = _.isArray(filterOption.criteria.value), filterName = filterOption.filterName || filterOption.criteria.name, filter = ticketConsoleModel.filterDict[filterName], filterVal;
|
|
function getFilterValue(filter) {
|
|
var value, valueObj, attribute, availableColumns = ticketConsoleModel.availableColConfig;
|
|
if (filter.fieldType === 'dateTimeField') {
|
|
value = filterOption.criteria.value[0];
|
|
}
|
|
else if (filter.fieldType === 'staticSelectionField') {
|
|
attribute = _.find(availableColumns, { name: filterName });
|
|
if (attribute && attribute.field && attribute.field.options) {
|
|
valueObj = _.find(attribute.field.options, { name: filterOption.criteria.value[0] });
|
|
}
|
|
else if (attribute && attribute.oldFields && attribute.oldFields.options) {
|
|
valueObj = _.find(attribute.oldFields.options, { name: filterOption.criteria.value[0] });
|
|
}
|
|
value = (valueObj && valueObj.index > -1) ? valueObj.index : null;
|
|
}
|
|
else {
|
|
value = filterOption.criteria.value[0];
|
|
}
|
|
return value;
|
|
}
|
|
function removeElements(parentArray, elementsToRemove) {
|
|
parentArray = _.cloneDeep(parentArray);
|
|
_.remove(parentArray, function (value) {
|
|
var index = _.findIndex(elementsToRemove, function (elementToDelete) {
|
|
return _.isEqual(elementToDelete, value);
|
|
});
|
|
return index > -1;
|
|
});
|
|
return parentArray;
|
|
}
|
|
function uniqueArray(parentArray) {
|
|
parentArray = _.cloneDeep(parentArray);
|
|
for (var index = 0; index < parentArray.length; index++) {
|
|
for (var minorIndex = index + 1; minorIndex < parentArray.length; minorIndex++) {
|
|
if (_.isEqual(parentArray[index], parentArray[minorIndex])) {
|
|
parentArray.splice(minorIndex, 1);
|
|
minorIndex--;
|
|
}
|
|
}
|
|
}
|
|
return parentArray;
|
|
}
|
|
if (filterOption.advancedFilter && name === 'advanceSearchQuery') {
|
|
criteria.advanceSearchQuery = filterOption.criteria.value;
|
|
return;
|
|
}
|
|
if (filterOption.active) {
|
|
if (filter && filter.showLabelInPill) {
|
|
filterOption.filterName = filter.name;
|
|
filterOption.filterLabel = filter.label;
|
|
}
|
|
if (filterOption.type === 'date') {
|
|
filterOption.criteria.value = [{}];
|
|
_.forEach(filterOption.defaultValues, function (value, key) {
|
|
filterOption.criteria.value[0][key] = $rootScope.$eval(value, { moment: moment });
|
|
});
|
|
filterOption.criteria.value[0].id = filterOption.label; //used for Android to fetch saved filters
|
|
multiselect = false;
|
|
}
|
|
if (filterOption.type === 'dynamic' && filterOption.criteria.type === 'date') {
|
|
multiselect = false;
|
|
}
|
|
if (criteria[name]) {
|
|
if (multiselect) {
|
|
criteria[name] = _.union(criteria[name], filterOption.criteria.value);
|
|
criteria[name] = uniqueArray(criteria[name]); //required as union is unable to compare objects
|
|
}
|
|
else {
|
|
var previousOption = _.find(ticketConsoleModel.selectedFilters, { criteria: { name: filterOption.criteria.name } });
|
|
previousOption.active = false;
|
|
ticketConsoleModel.applyFilter(previousOption);
|
|
criteria[name] = filterOption.criteria.value;
|
|
}
|
|
}
|
|
else {
|
|
if (filterOption.filterType && filterOption.filterType === 'customFilter') {
|
|
if (filter) {
|
|
filterVal = getFilterValue(filter);
|
|
}
|
|
if (criteria.hasOwnProperty('customCriteria')) {
|
|
if (criteria.customCriteria.hasOwnProperty(name) && _.isArray(criteria.customCriteria[name]) && multiselect) {
|
|
criteria.customCriteria[name].push(filterVal);
|
|
}
|
|
else {
|
|
if (!multiselect) {
|
|
var oldOption = _.find(ticketConsoleModel.selectedFilters, { criteria: { name: filterOption.criteria.name } });
|
|
if (oldOption) {
|
|
oldOption.active = false;
|
|
ticketConsoleModel.applyFilter(oldOption);
|
|
}
|
|
}
|
|
criteria.customCriteria[name] = [filterVal];
|
|
}
|
|
}
|
|
else {
|
|
criteria.customCriteria = {};
|
|
criteria.customCriteria[name] = [filterVal];
|
|
}
|
|
}
|
|
else {
|
|
criteria[name] = filterOption.criteria.value;
|
|
}
|
|
}
|
|
ticketConsoleModel.selectedFilters.unshift(filterOption);
|
|
}
|
|
else {
|
|
if (filterOption.filterType && filterOption.filterType === 'customFilter') {
|
|
if (filter) {
|
|
filterVal = getFilterValue(filter);
|
|
}
|
|
criteria.customCriteria[name] = multiselect ? _.difference(criteria.customCriteria[name], [filterVal]) : [];
|
|
if (!criteria.customCriteria[name].length) {
|
|
delete criteria.customCriteria[name];
|
|
}
|
|
}
|
|
else {
|
|
criteria[name] = multiselect ? removeElements(criteria[name], filterOption.criteria.value) : ''; //_.difference doesn't support object comparison
|
|
var itemFound = _.filter(ticketConsoleModel.selectedFilters, function (obj) {
|
|
return obj.criteria.name === name && obj.criteria.value.length === 0 && filterOption.criteria.value.length > 0;
|
|
});
|
|
if (!(criteria[name] && criteria[name].length) && itemFound.length === 0) {
|
|
delete criteria[name];
|
|
}
|
|
}
|
|
var index = _.findIndex(ticketConsoleModel.selectedFilters, function (filter) {
|
|
if (filter.name === filterOption.name && filter.criteria.name === filterOption.criteria.name) {
|
|
if (filterOption.criteria.name !== 'affectedBusinessServices') {
|
|
return true;
|
|
}
|
|
else {
|
|
return (filter.criteria.value === filterOption.criteria.value) ? true : false;
|
|
}
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
});
|
|
if (index >= 0) {
|
|
ticketConsoleModel.selectedFilters.splice(index, 1);
|
|
}
|
|
}
|
|
};
|
|
ticketConsoleModel.applyQuickSearch = function (input) {
|
|
if (input !== '') {
|
|
ticketConsoleModel.criteria.filterCriteria.quickSearchText = input;
|
|
}
|
|
else {
|
|
delete ticketConsoleModel.criteria.filterCriteria.quickSearchText;
|
|
}
|
|
};
|
|
ticketConsoleModel.checkDateFilterAdded = function () {
|
|
var dateFilterFound = false;
|
|
_.each(ticketConsoleModel.selectedFilters, function (filter) {
|
|
if (filter.criteria.type === 'date' || filter.type === 'date') {
|
|
dateFilterFound = true;
|
|
return;
|
|
}
|
|
});
|
|
ticketConsoleModel.dateFilterFound = dateFilterFound;
|
|
return ticketConsoleModel.dateFilterFound;
|
|
};
|
|
ticketConsoleModel.saveFilterPreset = function (name) {
|
|
var copySelectedFilters = _.cloneDeep(ticketConsoleModel.selectedFilters), filterSet = {
|
|
name: name,
|
|
value: _.map(copySelectedFilters.reverse(), function (filterOption) {
|
|
var cfg = {
|
|
filter: filterOption.filterName || filterOption.criteria.name,
|
|
option: filterOption.name
|
|
};
|
|
if (filterOption.type === 'dynamic') {
|
|
cfg.type = 'dynamic';
|
|
cfg.realOption = angular.copy(filterOption);
|
|
delete cfg.realOption.active;
|
|
}
|
|
return cfg;
|
|
})
|
|
};
|
|
if (ticketConsoleModel.criteria && ticketConsoleModel.criteria.filterCriteria && ticketConsoleModel.criteria.filterCriteria.advanceSearchQuery) {
|
|
filterSet.value.push({
|
|
filter: 'advanceSearchQuery',
|
|
option: ticketConsoleModel.criteria.filterCriteria.advanceSearchQuery
|
|
});
|
|
}
|
|
return $q.all([
|
|
userModel.updateUserPreferences(filterPreferenceGroup, filterSet),
|
|
consoleService.saveTicketFilterConfiguration(name, ticketConsoleModel.criteria.filterCriteria)
|
|
]);
|
|
};
|
|
ticketConsoleModel.saveColumnPreset = function (name, columnsConfig) {
|
|
return userModel.updateUserPreferences(columnPreferenceGroup, {
|
|
name: name,
|
|
value: columnsConfig
|
|
});
|
|
};
|
|
ticketConsoleModel.removeUserFilterPreset = function (userFilterPreset) {
|
|
if (userFilterPreset.id) {
|
|
userModel.removeUserPreferences(filterPreferenceGroup, userFilterPreset);
|
|
consoleService.removeFilterConfiguration(userFilterPreset.name, userFilterPreset.id);
|
|
}
|
|
if (userFilterPreset.columnId) {
|
|
userModel.removeUserPreferences(columnPreferenceGroup, { id: userFilterPreset.columnId });
|
|
}
|
|
_.remove(ticketConsoleModel.userSavedPresets, { name: userFilterPreset.name });
|
|
};
|
|
ticketConsoleModel.updateColumnConfig = function (columnsConfig, name, id) {
|
|
function addItemToFilterConfig(item) {
|
|
var indexFound = false;
|
|
_.each(ticketConsoleModel.filterConfig, function (conf, index) {
|
|
if (conf.name >= item.name) {
|
|
ticketConsoleModel.filterConfig.splice(index, 0, item);
|
|
indexFound = true;
|
|
return false;
|
|
}
|
|
});
|
|
if (!indexFound) {
|
|
ticketConsoleModel.filterConfig.splice(ticketConsoleModel.filterConfig.length, 0, item);
|
|
}
|
|
}
|
|
function removeAppliedFiltersForNewlyAddedColumn(removedCol) {
|
|
var criteria = ticketConsoleModel.criteria.filterCriteria, selectedFilters = ticketConsoleModel.selectedFilters, tempObj;
|
|
if (criteria.hasOwnProperty('customCriteria') && criteria.customCriteria[removedCol]) {
|
|
criteria.customColumnRemoved = true;
|
|
delete criteria.customCriteria[removedCol];
|
|
}
|
|
_.remove(selectedFilters, { filterType: 'customFilter', filterName: removedCol });
|
|
tempObj = _.find(ticketConsoleModel.customColumnsObjs, { name: removedCol });
|
|
if (tempObj) {
|
|
tempObj.expanded = false;
|
|
if (tempObj.options && _.isArray(tempObj.options)) {
|
|
_.each(tempObj.options, function (op) {
|
|
if (op.active) {
|
|
op.active = false;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
var newlyAddedColumns = _.difference(_.keys(columnsConfig), _.keys(ticketConsoleModel.currentColumnsConfig)), newlyRemovedColumns = _.difference(_.keys(ticketConsoleModel.currentColumnsConfig), _.keys(columnsConfig)), newCols = [];
|
|
if (newlyAddedColumns.length) {
|
|
_.each(newlyAddedColumns, function (col) {
|
|
var tempObj = _.find(ticketConsoleModel.customColumnsObjs, { name: col });
|
|
if (tempObj) {
|
|
tempObj = formatFilterOptionForCustomField(ticketConsoleModel.mergedConsoleColumns[tempObj.attributeName], tempObj);
|
|
newCols.push(tempObj);
|
|
}
|
|
});
|
|
}
|
|
return userModel.updateUserPreferences(columnPreferenceGroup, {
|
|
id: id ? id : columnPreferenceDetailsId,
|
|
name: name ? name : 'columns',
|
|
value: columnsConfig
|
|
}, { updateColumns: true }).then(function (props) {
|
|
var defaultColumnConfig = id ? _.find(props, { id: id }) : _.find(props, { name: 'columns' });
|
|
if (defaultColumnConfig) {
|
|
ticketConsoleModel.currentColumnsConfig = defaultColumnConfig.value;
|
|
columnPreferenceDetailsId = defaultColumnConfig.id;
|
|
}
|
|
// Inserting new filters for the newly added custom columns
|
|
if (newlyAddedColumns.length && newCols.length) {
|
|
_.each(newCols, function (newCustomFilter) {
|
|
addItemToFilterConfig(newCustomFilter);
|
|
});
|
|
ticketConsoleModel.filterDict = _.assign(_.keyBy(newCols, 'name'), ticketConsoleModel.filterDict);
|
|
}
|
|
// Removing filters for newly removed custom columns
|
|
if (newlyRemovedColumns.length) {
|
|
_.each(newlyRemovedColumns, function (col) {
|
|
removeAppliedFiltersForNewlyAddedColumn(col);
|
|
var removeIndex = _.findIndex(ticketConsoleModel.filterConfig, { name: col });
|
|
if (removeIndex !== -1) {
|
|
ticketConsoleModel.filterConfig.splice(removeIndex, 1);
|
|
}
|
|
if (!_.isUndefined(ticketConsoleModel.filterDict[col])) {
|
|
delete ticketConsoleModel.filterDict[col];
|
|
}
|
|
});
|
|
}
|
|
});
|
|
};
|
|
ticketConsoleModel.checkForRangeFilter = function (filterOption) {
|
|
return (filterOption.subtype === 'range' && filterOption.filterType === 'customFilter');
|
|
};
|
|
ticketConsoleModel.isSearchEnabled = function () {
|
|
return searchEnabled;
|
|
};
|
|
ticketConsoleModel.setSearchEnabled = function (value) {
|
|
searchEnabled = !!value;
|
|
};
|
|
ticketConsoleModel.resetCache = function (callback) {
|
|
ticketConsoleModel.metaDataRefresh = true;
|
|
ticketConsoleModel.columnsConfig = [];
|
|
ticketConsoleModel.areFiltersPopulated = undefined;
|
|
delete userModel.userConfig.TicketConsoleColumns;
|
|
delete userModel.userConfig.TicketConsoleFilter;
|
|
_.each(EntityVO.TICKET_TYPES, function (type) {
|
|
delete metadataModel.cache[type];
|
|
});
|
|
consoleColumnsModel.consoleRefreshMetadata().then(function () {
|
|
ticketConsoleModel.selectedFilters = [];
|
|
callback();
|
|
});
|
|
};
|
|
function setCustomCellTemplateForColumns(attributeObj, colName) {
|
|
if (!configurationModel.enableAdvanceSearchInConsole && ticketConsoleModel.quickSearchHighlightedColumn.indexOf(attributeObj.field || colName) !== -1) {
|
|
attributeObj.cellTemplate = quickSearchCellTemplate;
|
|
}
|
|
}
|
|
return ticketConsoleModel;
|
|
}
|
|
]);
|
|
}());
|