539 lines
32 KiB
JavaScript
539 lines
32 KiB
JavaScript
"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;
|
|
}
|
|
]);
|
|
}());
|