"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 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 = {
                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>'
            }, customWidths = {
                priority: 100,
                summary: 350
            }, cellFilters = configurationModel.get('ticketConsole.cellFilters'), 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 (_.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;
                if (attribute && customFieldTypes.indexOf(attribute.field.type) !== -1) {
                    if (attribute.field.type === 'staticSelectionField') {
                        var returnObjMap = _.find(attribute.field.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] = _.uniq(optionMerge, 'name');
                                    }
                                }
                                else {
                                    mergedObj[key] = val;
                                }
                            });
                        }
                    }
                });
                ticketConsoleModel.mergedConsoleColumns = mergedObj;
                ticketConsoleModel.customColumnsObjs = _.where(_.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(_.indexBy(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') {
                                        attributeObj.cellFilter = (attributeObj.field.dataType === 'time') ? 'milliToTime' : ((attributeObj.field.dataType === 'date') ? 'date:"mediumDate"' : 'date:"medium"');
                                    }
                                }
                                if (attributeObj.hasOwnProperty('ootbMaping')) {
                                    attributeObj.field = attributeObj.ootbMaping[0];
                                }
                                else if (attributeObj.type === 'custom') {
                                    attributeObj.oldFields = _.cloneDeep(attributeObj.field);
                                    attributeObj.fieldType = attributeObj.field.type;
                                    attributeObj.field = attributeObj.name;
                                }
                                if (cellTemplates.hasOwnProperty(key)) {
                                    attributeObj.cellTemplate = cellTemplates[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') {
                                attributeObj.cellFilter = (attributeObj.field.dataType === 'time') ? 'milliToTime' : ((attributeObj.field.dataType === 'date') ? 'date:"mediumDate"' : 'date:"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];
                        }
                        setCellFilter(attributeObj, colName);
                        if (customWidths.hasOwnProperty(colName)) {
                            attributeObj.width = customWidths[colName];
                        }
                        configObj[colName] = attributeObj;
                    }
                });
                return configObj;
            };
            ticketConsoleModel.filterPreferenceGroup = filterPreferenceGroup;
            ticketConsoleModel.columnPreferenceGroup = columnPreferenceGroup;
            ticketConsoleModel.ribbonConfig = configurationModel.get('ticketConsole.ribbon');
            ticketConsoleModel.filterConfig = configurationModel.get('ticketConsole.filter');
            ticketConsoleModel.statsConfig = configurationModel.get('ticketConsole.stats');
            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.criteria = {
                filterCriteria: {},
                chunkInfo: { startIndex: 0, chunkSize: ticketConsoleModel.defaultChunkSize },
                sortInfo: {},
                attributeNames: [],
                customAttributeNames: []
            };
            ticketConsoleModel.itemList = [];
            ticketConsoleModel.selectedFilters = [];
            ticketConsoleModel.filterDict = _.indexBy((ticketConsoleModel.filterConfig), 'name');
            ticketConsoleModel.populateMetadataAndColumns = function () {
                return $q.all([metadataModel.getMetadataByTypes(EntityVO.TICKET_TYPES), consoleColumnsModel.getTicketAvailableColumnsList(), userModel.getUserPreferences(columnPreferenceGroup)]).then(function (configData) {
                    ticketConsoleModel.showStats = !configurationModel.explicitStatsRefresh;
                    ticketConsoleModel.metaDataArrays = configData[0];
                    ticketConsoleModel.availableColList = configData[1].itemList;
                    ticketConsoleModel.userSavedColumnPresets = configData[2] || [];
                    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 = _.merge(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 = _.pluck(_.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' }), filterChangeManagerMyGroup = _.find(ticketConsoleModel.filterDict.changeManagerGroup.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 }];
                    filterSubmitterMe.subLabel = userData.fullName;
                    filterSubmitterMe.criteria.value = [{ loginId: userData.loginId }];
                    filterChangeManagerMyGroup.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 = [];
                    _.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);
                        //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(_.uniq(fullRiskLevelList, 'name'), 'name');
                    fullChangeReasonsList = _.uniq(fullChangeReasonsList, 'name');
                    fullChangeClassList = _.sortBy(_.uniq(fullChangeClassList, 'name'), 'name');
                    fullInvestigationDriversList = _.sortBy(_.uniq(fullInvestigationDriversList, 'name'), 'name');
                    fullPriorityList = _.sortBy(_.uniq(fullPriorityList, 'name'), 'name');
                    fullMilestonesList = _.sortBy(_.uniq(fullMilestonesList, '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
                                }
                            });
                        });
                    }
                    //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 _.contains([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);
                }
                return $q.all([userModel.getUserPreferences(filterPreferenceGroup)]).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];
                    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'
                            }]
                    });
                    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 = _.pluck(_.filter(ticketConsoleModel.columnsConfig, function (column) {
                    return (column.visible && column.type === 'system');
                }), 'attributeName');
                ticketConsoleModel.criteria.customAttributeNames = _.pluck(_.filter(ticketConsoleModel.columnsConfig, function (column) {
                    return (column.visible && column.type === 'custom');
                }), 'attributeName');
            };
            ticketConsoleModel.getItemList = function () {
                if (!ticketConsoleModel.criteria.attributeNames.length) {
                    var cols = _.sortBy(_.where(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(_.where(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);
                        }
                    }
                }
                return consoleService.getTicketList(ticketConsoleModel.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;
                    return result.totalCount;
                });
            };
            ticketConsoleModel.dropCriteriaStartIndex = function () {
                ticketConsoleModel.criteria.chunkInfo.startIndex = 0;
            };
            ticketConsoleModel.getTicketConsoleMetric = function () {
                return consoleService.getTicketStats(ticketConsoleModel.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);
                        }
                    }
                });
            };
            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 = _.pluck(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] });
                        }
                        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.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
                        if (!(criteria[name] && criteria[name].length)) {
                            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.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;
                    })
                };
                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(_.indexBy(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 (ticketConsoleModel.selectedFilters.length >= 2);
            };
            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();
                });
            };
            return ticketConsoleModel;
        }
    ]);
}());