"use strict";
(function () {
    'use strict';
    angular.module('consoleModule')
        .factory('assetConsoleModel', ['consoleService', 'configurationModel', 'metadataModel', 'userModel', '$rootScope', '$q', '$filter', 'categoriesService', 'personModel', 'localStorageService',
        function (consoleService, configurationModel, metadataModel, userModel, $rootScope, $q, $filter, categoriesService, personModel, localStorageService) {
            var assetConsoleModel = {}, assetMetadata, 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">{{\'console.column.\' + col.displayName | i18n}}</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 = 'CIFilter', columnPreferenceGroup = 'assetConsoleColumns', columnPreferenceDetailsId = '', searchEnabled = true, extendColumnConfig = function () {
                _.forEach(assetConsoleModel.columnsConfig, function (column) {
                    angular.extend(column, {
                        headerCellTemplate: headerCellTemplate,
                        minWidth: minWidth,
                        width: column.width || minWidth
                    });
                });
            }, advancedFilters = ['cpu', 'operatingSystem', 'processor', 'rack'], mySiteFilterData = null, userId = localStorageService.get('user.userId');
            assetConsoleModel.filterPreferenceGroup = filterPreferenceGroup;
            assetConsoleModel.columnPreferenceGroup = columnPreferenceGroup;
            assetConsoleModel.ribbonConfig = configurationModel.get('assetConsole.ribbon');
            assetConsoleModel.filterConfig = configurationModel.get('assetConsole.filter');
            assetConsoleModel.statsConfig = configurationModel.get('assetConsole.stats');
            if (window.isRtl) {
                assetConsoleModel.statsConfig.reverse();
            }
            assetConsoleModel.currentColumnsConfig = {};
            assetConsoleModel.assetTypeFilter = _.find(assetConsoleModel.filterConfig, { name: 'assetTypes' });
            assetConsoleModel.presetColumns = null;
            assetConsoleModel.defaultChunkSize = 75;
            assetConsoleModel.exceedChunkSize = false;
            assetConsoleModel.criteria = {
                filterCriteria: {},
                chunkInfo: { startIndex: 0, chunkSize: assetConsoleModel.defaultChunkSize },
                sortInfo: {},
                attributeNames: []
            };
            assetConsoleModel.itemList = [];
            assetConsoleModel.selectedFilters = [];
            assetConsoleModel.filterDict = _.keyBy(assetConsoleModel.filterConfig, 'name');
            assetConsoleModel.cpuRangeValues = {};
            assetConsoleModel.populateFilters = function () {
                if (assetConsoleModel.areFiltersPopulated) {
                    return $q.when(1);
                }
                return $q.all([userModel.getFullCurrentUserData(), metadataModel.getMetadataByType(EntityVO.TYPE_ASSET), personModel.getPersonDetailsByID(userId)])
                    .then(function (result) {
                    var userData = result[0], metadata = result[1], userInfoData = result[2], filterApprovedByMe = _.find(assetConsoleModel.filterDict.approvedBy.options, { label: 'me' }), filterCreatedByMe = _.find(assetConsoleModel.filterDict.createdBy.options, { label: 'me' }), filterManagedByMe = _.find(assetConsoleModel.filterDict.managedBy.options, { label: 'me' }), filterOwnedByMe = _.find(assetConsoleModel.filterDict.owners.options, { label: 'me' }), filterSupportedByMe = _.find(assetConsoleModel.filterDict.supportedBy.options, { label: 'me' }), filterUsedByMe = _.find(assetConsoleModel.filterDict.usedBy.options, { label: 'me' }), filterMySite = _.find(assetConsoleModel.filterDict.sites.options, { label: 'mySite' }), filterMyRegion = _.find(assetConsoleModel.filterDict.region.options, { label: 'myRegion' }), filterMySiteGroup = _.find(assetConsoleModel.filterDict.siteGroup.options, { label: 'mySiteGroup' });
                    filterApprovedByMe.subLabel = filterCreatedByMe.subLabel = filterManagedByMe.subLabel =
                        filterOwnedByMe.subLabel = filterSupportedByMe.subLabel = filterUsedByMe.subLabel = userData.fullName;
                    if (userData.personId === "") {
                        userData.personId = userInfoData.personId;
                    }
                    filterApprovedByMe.criteria.value = filterCreatedByMe.criteria.value = filterManagedByMe.criteria.value =
                        filterOwnedByMe.criteria.value = filterSupportedByMe.criteria.value = filterUsedByMe.criteria.value =
                            [{ id: userData.personId }];
                    filterMySite.subLabel = userData.site.name;
                    mySiteFilterData = {
                        name: userData.site.name,
                        companyName: userData.company.name,
                        region: userData.site.region,
                        siteGroup: userData.site.siteGroup
                    };
                    filterMySite.criteria.value = [mySiteFilterData];
                    filterMySiteGroup.subLabel = userData.site.siteGroup;
                    filterMySiteGroup.criteria.value = [{
                            companyName: userData.company.name,
                            region: userData.site.region,
                            siteGroup: userData.site.siteGroup
                        }];
                    filterMyRegion.subLabel = userData.site.region;
                    filterMyRegion.criteria.value = [{
                            companyName: userData.company.name,
                            region: userData.site.region
                        }];
                    assetMetadata = metadata;
                    _.forEach(metadata.statuses, function (status) {
                        assetConsoleModel.filterDict.ticketSpecificStatuses.options.push({
                            name: status.label,
                            type: 'dynamic',
                            filterName: 'ticketSpecificStatuses',
                            criteria: {
                                name: 'ticketSpecificStatuses',
                                value: [status.name]
                            }
                        });
                    });
                    _.forEach(metadata.assetTypes, function (type) {
                        assetConsoleModel.filterDict.assetTypes.options.push({
                            name: type.label,
                            type: 'dynamic',
                            filterName: 'assetTypes',
                            criteria: {
                                name: 'assetTypes',
                                value: [type.name]
                            },
                            criteriaValue: type.name
                        });
                        //add subtypes
                        type.subType.forEach(function (subType) {
                            assetConsoleModel.filterDict.assetSubTypes.options.push({
                                name: subType.label,
                                type: 'dynamic',
                                filterName: 'assetSubTypes',
                                onDisplay: true,
                                criteria: {
                                    name: 'assetSubTypes',
                                    value: [subType.name],
                                    typeName: type.name
                                }
                            });
                        });
                    });
                });
            };
            assetConsoleModel.populateConfiguration = function () {
                if (!_.isEmpty(assetConsoleModel.columnsConfig)) {
                    return $q.when(1);
                }
                return $q.all([userModel.getUserPreferences(columnPreferenceGroup), userModel.getUserPreferences(filterPreferenceGroup), metadataModel.getMetadataByType(EntityVO.TYPE_ASSET)]).then(function (config) {
                    assetConsoleModel.userSavedColumnPresets = config[0] || [];
                    var defaultColumnPreset = _.find(assetConsoleModel.userSavedColumnPresets, { name: 'columns' }) || {};
                    var columns = defaultColumnPreset.value || {};
                    assetConsoleModel.currentColumnsConfig = columns;
                    columnPreferenceDetailsId = defaultColumnPreset.id;
                    assetConsoleModel.columnsConfig = _.merge(_.cloneDeep(configurationModel.get('assetConsole.columns')), columns);
                    assetConsoleModel.userSavedFilterPresets = config[1];
                    assetConsoleModel.userSavedFilterPresets.unshift({
                        id: 'allAssets',
                        fixed: true,
                        name: 'Hardware Managed by Me',
                        label: $filter('i18n')('console.asset.preDefinedUserFilter.myManagedAssetsFilter'),
                        systemgenerated: true,
                        defaultpreset: false,
                        value: [
                            { filter: 'managedBy', option: 'me' },
                            {
                                filter: 'ticketSpecificStatuses', option: 'Deployed', type: 'dynamic',
                                realOption: {
                                    name: $filter('localizeLabel')('Deployed', EntityVO.TYPE_STATUS, EntityVO.TYPE_ASSET),
                                    criteria: { name: 'ticketSpecificStatuses', value: ['Deployed'] }
                                }
                            },
                            {
                                filter: 'assetTypes',
                                option: 'Computer System',
                                type: 'dynamic',
                                realOption: {
                                    name: $filter('localizeLabel')('Computer System', 'assetType', EntityVO.TYPE_ASSET),
                                    criteria: { name: 'assetTypes', value: ['Computer System'] }
                                }
                            },
                            {
                                filter: 'assetTypes',
                                option: 'Hardware',
                                type: 'dynamic',
                                realOption: {
                                    name: $filter('localizeLabel')('Hardware', 'assetType', EntityVO.TYPE_ASSET),
                                    criteria: { name: 'assetTypes', value: ['Hardware'] }
                                }
                            }
                        ]
                    });
                    assetConsoleModel.userSavedPresets = _.cloneDeep(assetConsoleModel.userSavedFilterPresets);
                    _.each(assetConsoleModel.userSavedColumnPresets, function (columnPreset) {
                        if (columnPreset.name !== 'columns') {
                            var matchPreset = _.find(assetConsoleModel.userSavedPresets, { name: columnPreset.name });
                            if (matchPreset) {
                                matchPreset.columnId = columnPreset.id;
                                matchPreset.columnValue = columnPreset.value;
                            }
                            else {
                                columnPreset.columnId = columnPreset.id;
                                columnPreset.columnValue = columnPreset.value;
                                delete columnPreset.id;
                                delete columnPreset.value;
                                assetConsoleModel.userSavedPresets.push(columnPreset);
                            }
                        }
                    });
                    extendColumnConfig();
                    assetConsoleModel.populateAttributeNames();
                });
            };
            assetConsoleModel.addUserSavedPresets = function (name) {
                var filterPreset = _.find(assetConsoleModel.userSavedFilterPresets, { name: name }), columnPreset = _.find(assetConsoleModel.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;
                }
                assetConsoleModel.userSavedPresets.push(combinedPreset);
            };
            assetConsoleModel.updateUserSavedPresets = function (name) {
                console.log('Preset name: ' + name);
            };
            assetConsoleModel.populateAttributeNames = function () {
                assetConsoleModel.criteria.attributeNames = _.map(_.filter(assetConsoleModel.columnsConfig, function (column) {
                    return column.visible;
                }), 'attributeName');
            };
            assetConsoleModel.getItemList = function () {
                if (!assetConsoleModel.criteria.attributeNames.length) {
                    var cols = _.sortBy(_.filter(assetConsoleModel.columnsConfig, { visible: true }), 'order');
                    cols.forEach(function (col) {
                        assetConsoleModel.criteria.attributeNames.push(col.attributeName);
                    });
                }
                return consoleService.getAssetList(assetConsoleModel.criteria).then(function (result) {
                    assetConsoleModel.itemList = assetConsoleModel.criteria.chunkInfo.startIndex ? assetConsoleModel.itemList.concat(result.itemList) : result.itemList;
                    //since total count is returned zero by server client will check if the current result set contains chunksize items which means there can be more items
                    //once we get less than chunkSize items we have hit the end.
                    if (assetConsoleModel.criteria.chunkInfo.chunkSize === result.itemList.length) {
                        result.totalCount = assetConsoleModel.itemList.length + assetConsoleModel.criteria.chunkInfo.chunkSize;
                    }
                    else {
                        result.totalCount = assetConsoleModel.itemList.length;
                    }
                    assetConsoleModel.exceedChunkSize = result.exceedChunkSize;
                    return result.totalCount;
                });
            };
            assetConsoleModel.getRelatives = function (criteria) {
                return consoleService.getRelatives(criteria);
            };
            assetConsoleModel.getRelationshipTypes = function (criteria) {
                return consoleService.getRelationshipTypes(criteria);
            };
            assetConsoleModel.dropCriteriaStartIndex = function () {
                assetConsoleModel.criteria.chunkInfo.startIndex = 0;
            };
            assetConsoleModel.getTicketConsoleMetric = function () {
                /*return consoleService.getKnowledgeStats(assetConsoleModel.criteria.filterCriteria, metricRequestStats)
                 .then(function (resultStats) {
                 _.forEach(assetConsoleModel.statsConfig, function (stat) {
                 var resultStat = _.find(resultStats, { name: stat.name });
                 stat.value = resultStat ? resultStat.value : 0;
                 });
                 });*/
            };
            assetConsoleModel.applyFilterSet = function (filterSet) {
                _.forEach(filterSet, function (item) {
                    if (assetConsoleModel.filterDict[item.filter]) {
                        var option = _.find(assetConsoleModel.filterDict[item.filter].options, { name: item.option });
                        if (!option && item.type === 'dynamic') {
                            option = item.realOption;
                            if (assetConsoleModel.advancedFilterType(option)) {
                                option.subtype = 'range';
                                assetConsoleModel.filterDict[item.filter].options[0] = option;
                            }
                            else {
                                var newOption = _.find(assetConsoleModel.filterDict[item.filter].options, function (o) {
                                    if (o.criteria && option.criteria) {
                                        return _.isEqual(o.criteria, option.criteria);
                                    }
                                });
                                if (newOption) { //check for localized option name
                                    option = newOption;
                                }
                                else {
                                    assetConsoleModel.filterDict[item.filter].options.push(option);
                                }
                            }
                        }
                        if (angular.isObject(option) && !option.active) {
                            if (item.type === 'dynamic' && assetConsoleModel.advancedFilterType(option)) {
                                _.forEach(assetConsoleModel.filterDict[item.filter].criteriaKeys, function (criteriaKey) {
                                    _.forEach(option.criteria.value, function (val) {
                                        if (!_.isUndefined(val[criteriaKey.name])) {
                                            assetConsoleModel.filterDict[item.filter].selectiveClearFilters = true;
                                            criteriaKey.active = true;
                                            criteriaKey.fromPreset = true;
                                            criteriaKey.searchText = val[criteriaKey.name].value;
                                            criteriaKey.selectedValue = val[criteriaKey.name].value;
                                        }
                                    });
                                });
                            }
                            option.active = true;
                            assetConsoleModel.applyFilter(option);
                        }
                    }
                });
            };
            assetConsoleModel.applyColumnSet = function (columnSet) {
                var defaultVisibleColumns = _.filter(assetConsoleModel.columnsConfig, { 'visible': true });
                assetConsoleModel.presetColumns = [];
                assetConsoleModel.presetColumns = [];
                _.each(assetConsoleModel.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;
                        assetConsoleModel.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(assetConsoleModel.presetColumns, { name: item.name })) {
                            var columnData = angular.copy(item);
                            assetConsoleModel.presetColumns.push(columnData);
                        }
                    });
                }
                assetConsoleModel.presetColumns = _.sortBy(assetConsoleModel.presetColumns, 'order');
                assetConsoleModel.criteria.attributeNames = _.map(assetConsoleModel.presetColumns, 'attributeName');
            };
            assetConsoleModel.applyFilter = function (filterOption) {
                var criteria = assetConsoleModel.criteria.filterCriteria, name = filterOption.criteria.name, multiselect = _.isArray(filterOption.criteria.value);
                if (assetConsoleModel.advancedFilterType(filterOption)) {
                    multiselect = false;
                }
                if (filterOption.active) {
                    var filterName = filterOption.filterName || filterOption.criteria.name, filter = assetConsoleModel.filterDict[filterName];
                    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] && criteria[name] !== 'sites') {
                        if (multiselect) {
                            criteria[name] = _.union(criteria[name], filterOption.criteria.value);
                        }
                        else {
                            var previousOption = _.find(assetConsoleModel.selectedFilters, { criteria: { name: filterOption.criteria.name } });
                            previousOption.active = false;
                            assetConsoleModel.applyFilter(previousOption);
                            criteria[name] = filterOption.criteria.value;
                        }
                    }
                    else if (name === 'sites' || name === 'region' || name === 'siteGroup') {
                        criteria.sites = _.union(criteria.sites, filterOption.criteria.value);
                    }
                    else {
                        criteria[name] = filterOption.criteria.value;
                    }
                    if (criteria.assetTypes && criteria.assetTypes.length > 1) {
                        assetConsoleModel.removeAdvancedFilters();
                    }
                    if (name === 'assetTypes') {
                        assetConsoleModel.updateSubtypeFilters();
                    }
                    assetConsoleModel.selectedFilters.unshift(filterOption);
                }
                else { //!filterOption.active
                    if (criteria[name] && criteria[name] !== 'sites') {
                        criteria[name] = multiselect ? _.difference(criteria[name], filterOption.criteria.value) : '';
                    }
                    else {
                        criteria.sites = _.difference(criteria.sites, filterOption.criteria.value);
                    }
                    if (!(criteria[name] && criteria[name].length)) {
                        delete criteria[name];
                    }
                    if (criteria.sites && !criteria.sites.length) {
                        delete criteria.sites;
                    }
                    var index = _.findIndex(assetConsoleModel.selectedFilters, function (filter) {
                        return filter.name === filterOption.name && filter.criteria.name === filterOption.criteria.name;
                    });
                    assetConsoleModel.selectedFilters.splice(index, 1);
                    if (name === 'assetTypes') {
                        assetConsoleModel.updateSubtypeFilters();
                    }
                    if (filterOption.name === 'Computer System') {
                        assetConsoleModel.removeAdvancedFilters();
                    }
                }
            };
            assetConsoleModel.saveFilterPreset = function (name) {
                var copySelectedFilters = _.cloneDeep(assetConsoleModel.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)]);
            };
            assetConsoleModel.saveColumnPreset = function (name, columnsConfig) {
                return userModel.updateUserPreferences(columnPreferenceGroup, {
                    name: name,
                    value: columnsConfig
                });
            };
            assetConsoleModel.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(assetConsoleModel.userSavedPresets, { name: userFilterPreset.name });
            };
            assetConsoleModel.updateColumnConfig = function (columnsConfig, name, id) {
                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) {
                        assetConsoleModel.currentColumnsConfig = defaultColumnConfig.value;
                        columnPreferenceDetailsId = defaultColumnConfig.id;
                    }
                });
            };
            assetConsoleModel.getProductNamesByCompany = function (searchText) {
                return assetConsoleModel.getProductCategoriesByCompany(searchText, true);
            };
            assetConsoleModel.getProductCategoriesByCompany = function (searchText, isProductNameSearch) {
                var categoryName = 'product', params = {
                    entityType: EntityVO.TYPE_ASSET,
                    categoryType: categoryName,
                    searchText: searchText,
                    criteria: {
                        company: userModel.userFullData.company
                    }
                };
                if (isProductNameSearch) {
                    params.criteria.isEmpty = false; //DO NOT set this value true. Backend doesn't check true for now.
                }
                return categoriesService.searchCategories(params).then(function (result) {
                    var category = _.find(assetMetadata.categories, function (category) {
                        return category.name === categoryName;
                    });
                    return _.map(result.items, function (item) {
                        if (item.length) {
                            var serializedValue = _.compact(item).join(' > '), tiers = {};
                            for (var i = 0; i < category.listOfTiers.length; i++) {
                                tiers[category.listOfTiers[i].name] = item[i];
                            }
                            return {
                                value: serializedValue,
                                attributeMap: { categorizations: [{ name: categoryName, tiers: tiers }] }
                            };
                        }
                    });
                });
            };
            assetConsoleModel.advancedFilterType = function (filterOption) {
                return filterOption.criteria && filterOption.criteria.name !== 'rack' ? _.includes(advancedFilters, filterOption.criteria.name) : false;
            };
            assetConsoleModel.removeAdvancedFilters = function () {
                var criteria = assetConsoleModel.criteria.filterCriteria;
                _.forEach(advancedFilters, function (item) {
                    delete criteria[item];
                });
                _.remove(assetConsoleModel.selectedFilters, function (filter) {
                    if (_.includes(advancedFilters, filter.criteria.name)) {
                        filter.active = false;
                        return true;
                    }
                });
            };
            assetConsoleModel.updateSubtypeFilters = function () {
                var criteria = assetConsoleModel.criteria.filterCriteria, invalidSubTypes = [];
                if (criteria.assetTypes && criteria.assetSubTypes) {
                    _.remove(assetConsoleModel.selectedFilters, function (filter) {
                        if (filter.criteria.name === 'assetSubTypes' && !_.includes(criteria.assetTypes, filter.criteria.typeName)) {
                            invalidSubTypes.push(filter.criteria.value[0]);
                            filter.active = false;
                            return true;
                        }
                    });
                    _.remove(criteria.assetSubTypes, function (subtype) {
                        return _.includes(invalidSubTypes, subtype);
                    });
                }
            };
            assetConsoleModel.clearCriteriaKeyValues = function (name, criteriaKeys) {
                var currentFilter = _.find(assetConsoleModel.filterConfig, { name: name }), criteriaKeysArr = criteriaKeys;
                if (currentFilter) {
                    criteriaKeysArr = currentFilter.criteriaKeys;
                }
                _.forEach(criteriaKeysArr, function (key) {
                    key.active = false;
                    key.searchText = '';
                });
            };
            assetConsoleModel.clearSelectiveCriteriaKeyValues = function (filter) {
                var criteriaKeysArr = filter.criteriaKeys;
                if (filter.selectiveClearFilters) {
                    delete filter.selectiveClearFilters;
                }
                _.forEach(criteriaKeysArr, function (key) {
                    if (key.active && key.fromPreset) {
                        delete key.fromPreset;
                    }
                    else {
                        key.active = false;
                        key.searchText = '';
                    }
                });
            };
            assetConsoleModel.isSearchEnabled = function () {
                return searchEnabled;
            };
            assetConsoleModel.setSearchEnabled = function (value) {
                searchEnabled = !!value;
            };
            return assetConsoleModel;
        }
    ]);
}());