446 lines
27 KiB
JavaScript
446 lines
27 KiB
JavaScript
"use strict";
|
|
(function () {
|
|
'use strict';
|
|
angular.module('consoleModule')
|
|
.factory('knowledgeConsoleModel', ['consoleService', 'authService', 'consoleColumnsModel', 'configurationModel', 'metadataModel', 'userModel', 'knowledgeArticleModel', '$rootScope', '$q', '$filter', 'roles', 'i18nService',
|
|
function (consoleService, authService, consoleColumnsModel, configurationModel, metadataModel, userModel, knowledgeArticleModel, $rootScope, $q, $filter, roles, i18nService) {
|
|
var knowledgeConsoleModel = {}, metricRequestStats, headerCellTemplate = '<div class="ngHeaderSortColumn {{col.headerClass}}" ng-style="{\'cursor\': col.cursor}" ng-class="{ \'ngSorted\': !noSortVisible }">' +
|
|
'<div ux-id="column-header" ng-click="col.sort($event)" ng-class="\'colt\' + col.index" class="ngHeaderText">{{\'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 = 'knowledgeConsoleFilter', columnPreferenceGroup = 'knowledgeConsoleColumns', columnPreferenceDetailsId = '', searchEnabled = true, extendColumnConfig = function () {
|
|
_.forEach(knowledgeConsoleModel.columnsConfig, function (column) {
|
|
angular.extend(column, {
|
|
headerCellTemplate: headerCellTemplate,
|
|
minWidth: minWidth,
|
|
width: column.width || minWidth
|
|
});
|
|
});
|
|
};
|
|
knowledgeConsoleModel.filterPreferenceGroup = filterPreferenceGroup;
|
|
knowledgeConsoleModel.columnPreferenceGroup = columnPreferenceGroup;
|
|
knowledgeConsoleModel.ribbonConfig = configurationModel.get('knowledgeConsole.ribbon');
|
|
knowledgeConsoleModel.filterConfig = configurationModel.get('knowledgeConsole.filter');
|
|
knowledgeConsoleModel.statsConfig = configurationModel.get('knowledgeConsole.stats');
|
|
knowledgeConsoleModel.languages = configurationModel.get('knowledgeConsole.languages');
|
|
if (window.isRtl) {
|
|
knowledgeConsoleModel.statsConfig.reverse();
|
|
}
|
|
knowledgeConsoleModel.currentColumnsConfig = {};
|
|
metricRequestStats = _.map(knowledgeConsoleModel.statsConfig, function (stat) {
|
|
return { name: stat.name };
|
|
});
|
|
knowledgeConsoleModel.presetColumns = null;
|
|
knowledgeConsoleModel.defaultChunkSize = 75;
|
|
knowledgeConsoleModel.exceedChunkSize = false;
|
|
knowledgeConsoleModel.criteria = {
|
|
filterCriteria: {},
|
|
chunkInfo: { startIndex: 0, chunkSize: knowledgeConsoleModel.defaultChunkSize },
|
|
sortInfo: {},
|
|
attributeNames: []
|
|
};
|
|
knowledgeConsoleModel.itemList = [];
|
|
knowledgeConsoleModel.selectedFilters = [];
|
|
knowledgeConsoleModel.filterDict = _.keyBy(knowledgeConsoleModel.filterConfig, 'name');
|
|
knowledgeConsoleModel.isKcsCoachPreset = false;
|
|
knowledgeConsoleModel.kcsFilters = {
|
|
coachFilter: false,
|
|
teamMemberFilter: false,
|
|
authorName: '',
|
|
authorFilter: '',
|
|
assessmentMode: false
|
|
};
|
|
knowledgeConsoleModel.populateFilters = function () {
|
|
if (knowledgeConsoleModel.areFiltersPopulated) {
|
|
return $q.when(1);
|
|
}
|
|
return $q.all([userModel.getFullCurrentUserData(), metadataModel.getMetadataByType(EntityVO.TYPE_KNOWLEDGE), knowledgeArticleModel.getKnowledgeArticleTemplates()])
|
|
.then(function (result) {
|
|
knowledgeConsoleModel.showStats = !configurationModel.explicitStatsRefresh;
|
|
var currentLocale = i18nService.language, userData = result[0], metadata = result[1], templates = result[2], filterAuthorMe = _.find(knowledgeConsoleModel.filterDict.authors.options, { label: 'me' }), filterAssingneeMe = _.find(knowledgeConsoleModel.filterDict.assignees.options, { label: 'me' }), filterMyLanguage = _.find(knowledgeConsoleModel.filterDict.languages.options, { label: 'myLanguage' }), filterMyGroups = _.find(knowledgeConsoleModel.filterDict.assignedSupportGroups.options, { label: 'myGroup' }), filterMyOrganization = _.find(knowledgeConsoleModel.filterDict.organizations.options, { label: 'myOrganization' }), filterApproverMe = _.find(knowledgeConsoleModel.filterDict.approvalAssignment.options, { label: 'me' });
|
|
filterAuthorMe.subLabel = userData.fullName;
|
|
filterAuthorMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterAssingneeMe.subLabel = userData.fullName;
|
|
filterAssingneeMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterApproverMe.subLabel = userData.fullName;
|
|
filterApproverMe.criteria.value = [{ loginId: userData.loginId }];
|
|
filterMyLanguage.criteria.value = _.result(_.find(knowledgeConsoleModel.languages, { 'locale': currentLocale }), 'label');
|
|
filterMyLanguage.criteria.value = (filterMyLanguage.criteria.value) ? [filterMyLanguage.criteria.value] : ['English'];
|
|
filterMyGroups.criteria.value = userData.supportGroups;
|
|
filterMyOrganization.subLabel = userData.organization;
|
|
filterMyOrganization.criteria.value = [userData.organization];
|
|
_.forEach(metadata.statuses, function (status) {
|
|
knowledgeConsoleModel.filterDict.statusMappings.options.push({
|
|
name: status.label,
|
|
type: 'dynamic',
|
|
filterName: 'statusMappings',
|
|
criteria: {
|
|
name: 'statusMappings',
|
|
value: [status.name]
|
|
}
|
|
});
|
|
});
|
|
_.forEach(metadata.languages, function (language) {
|
|
knowledgeConsoleModel.filterDict.languages.options.push({
|
|
name: language.label,
|
|
type: 'dynamic',
|
|
filterName: 'languages',
|
|
criteria: {
|
|
name: 'languages',
|
|
value: [language.name]
|
|
}
|
|
});
|
|
});
|
|
knowledgeConsoleModel.filterDict.templateNames.options = _.map(templates, function (template) {
|
|
return {
|
|
name: template.templateObject.label,
|
|
type: 'dynamic',
|
|
criteria: {
|
|
name: 'templateNames',
|
|
value: [template.name]
|
|
}
|
|
};
|
|
});
|
|
});
|
|
};
|
|
knowledgeConsoleModel.populateConfiguration = function () {
|
|
if (!_.isEmpty(knowledgeConsoleModel.columnsConfig)) {
|
|
return $q.when(1);
|
|
}
|
|
return $q.all([userModel.getUserPreferences(columnPreferenceGroup), userModel.getUserPreferences(filterPreferenceGroup)]).then(function (config) {
|
|
knowledgeConsoleModel.userSavedColumnPresets = config[0] || [];
|
|
var defaultColumnPreset = _.find(knowledgeConsoleModel.userSavedColumnPresets, { name: 'columns' }) || {};
|
|
var columns = defaultColumnPreset.value || {};
|
|
knowledgeConsoleModel.currentColumnsConfig = columns;
|
|
columnPreferenceDetailsId = defaultColumnPreset.id;
|
|
knowledgeConsoleModel.columnsConfig = _.merge(_.cloneDeep(configurationModel.get('knowledgeConsole.columns')), columns);
|
|
knowledgeConsoleModel.availableColConfig = knowledgeConsoleModel.columnsConfig;
|
|
knowledgeConsoleModel.userSavedFilterPresets = config[1];
|
|
knowledgeConsoleModel.userSavedFilterPresets.unshift({
|
|
id: 'myAllOpenKnowledge',
|
|
fixed: true,
|
|
name: 'My Assigned Articles',
|
|
label: $filter('i18n')('console.knowledge.preDefinedUserFilter.myAllOpenKnowledge'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
restcall: true,
|
|
value: [{ filter: 'assignees', option: 'me' }, {
|
|
filter: 'statusMappings',
|
|
option: 'allOpen'
|
|
}]
|
|
}, {
|
|
id: 'myGroupAllOpenKnowledge',
|
|
fixed: true,
|
|
name: 'My Groups\' Assigned Articles',
|
|
label: $filter('i18n')('console.knowledge.preDefinedUserFilter.myGroupAllOpenKnowledge'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [{
|
|
filter: 'assignedSupportGroups',
|
|
option: 'myGroup'
|
|
}, { filter: 'statusMappings', option: 'allOpen' }]
|
|
}, {
|
|
id: 'favoriteKnowledge',
|
|
fixed: true,
|
|
name: 'My Favorites',
|
|
label: $filter('i18n')('console.knowledge.preDefinedUserFilter.favoriteKnowledge'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [{ filter: 'settings', option: 'favorite' }, {
|
|
filter: 'statusMappings',
|
|
option: 'allOpen'
|
|
}]
|
|
}, {
|
|
id: 'recentKnowledge',
|
|
fixed: true,
|
|
name: 'Recent Articles',
|
|
label: $filter('i18n')('console.knowledge.preDefinedUserFilter.recentKnowledge'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [{
|
|
filter: 'createDateRanges',
|
|
option: 'createDatePastWeek'
|
|
}, { filter: 'statusMappings', option: 'allOpen' }]
|
|
}, {
|
|
id: 'flaggedKnowledge',
|
|
fixed: true,
|
|
name: 'Flagged Articles',
|
|
label: $filter('i18n')('console.knowledge.preDefinedUserFilter.flaggedKnowledge'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [{ filter: 'settings', option: 'flagged' }, {
|
|
filter: 'statusMappings',
|
|
option: 'allOpen'
|
|
}]
|
|
});
|
|
if (authService.isAuthorized(roles.ITSM_KCS_COACH_ROLE)) {
|
|
knowledgeConsoleModel.userSavedFilterPresets.unshift({
|
|
id: 'myTeamKnowledge',
|
|
fixed: true,
|
|
name: 'My Team\'s Articles',
|
|
label: $filter('i18n')('console.knowledge.preDefinedUserFilter.myTeamKnowledge'),
|
|
systemgenerated: true,
|
|
defaultpreset: false,
|
|
value: [{
|
|
filter: 'statusMappings',
|
|
option: 'allOpen'
|
|
}]
|
|
});
|
|
}
|
|
knowledgeConsoleModel.userSavedPresets = _.cloneDeep(knowledgeConsoleModel.userSavedFilterPresets);
|
|
_.each(knowledgeConsoleModel.userSavedColumnPresets, function (columnPreset) {
|
|
if (columnPreset.name !== 'columns') {
|
|
var matchPreset = _.find(knowledgeConsoleModel.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;
|
|
knowledgeConsoleModel.userSavedPresets.push(columnPreset);
|
|
}
|
|
}
|
|
});
|
|
extendColumnConfig();
|
|
knowledgeConsoleModel.populateAttributeNames();
|
|
});
|
|
};
|
|
knowledgeConsoleModel.addUserSavedPresets = function (name) {
|
|
var filterPreset = _.find(knowledgeConsoleModel.userSavedFilterPresets, { name: name }), columnPreset = _.find(knowledgeConsoleModel.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;
|
|
}
|
|
knowledgeConsoleModel.userSavedPresets.push(combinedPreset);
|
|
};
|
|
knowledgeConsoleModel.populateAttributeNames = function () {
|
|
knowledgeConsoleModel.criteria.attributeNames = _.map(_.filter(knowledgeConsoleModel.columnsConfig, function (column) {
|
|
return column.visible;
|
|
}), 'attributeName');
|
|
};
|
|
knowledgeConsoleModel.getItemList = function () {
|
|
if (!knowledgeConsoleModel.criteria.attributeNames.length) {
|
|
var cols = _.sortBy(_.filter(knowledgeConsoleModel.columnsConfig, { visible: true }), 'order');
|
|
cols.forEach(function (col) {
|
|
knowledgeConsoleModel.criteria.attributeNames.push(col.attributeName);
|
|
});
|
|
}
|
|
return consoleService.getKnowledgeList(knowledgeConsoleModel.criteria).then(function (result) {
|
|
knowledgeConsoleModel.itemList = knowledgeConsoleModel.criteria.chunkInfo.startIndex ? knowledgeConsoleModel.itemList.concat(result.itemList) : result.itemList;
|
|
knowledgeConsoleModel.exceedChunkSize = result.exceedChunkSize;
|
|
return result.totalCount;
|
|
});
|
|
};
|
|
knowledgeConsoleModel.dropCriteriaStartIndex = function () {
|
|
knowledgeConsoleModel.criteria.chunkInfo.startIndex = 0;
|
|
};
|
|
knowledgeConsoleModel.getTicketConsoleMetric = function () {
|
|
return consoleService.getKnowledgeStats(knowledgeConsoleModel.criteria.filterCriteria, metricRequestStats)
|
|
.then(function (resultStats) {
|
|
_.forEach(knowledgeConsoleModel.statsConfig, function (stat) {
|
|
var resultStat = _.find(resultStats, { name: stat.name });
|
|
stat.value = resultStat ? resultStat.value : 0;
|
|
});
|
|
});
|
|
};
|
|
knowledgeConsoleModel.applyFilterSet = function (filterSet, fromMetric) {
|
|
_.forEach(filterSet, function (item) {
|
|
if (knowledgeConsoleModel.filterDict[item.filter]) {
|
|
var option = _.find(knowledgeConsoleModel.filterDict[item.filter].options, { name: item.option });
|
|
if (!option && item.type === 'dynamic') {
|
|
option = item.realOption;
|
|
knowledgeConsoleModel.filterDict[item.filter].options.push(item.realOption);
|
|
}
|
|
if (angular.isObject(option) && !option.active) {
|
|
option.active = true;
|
|
if (fromMetric && option.name === 'Published') {
|
|
var allOpenFilter = _.find(knowledgeConsoleModel.selectedFilters, { name: 'allOpen' });
|
|
if (allOpenFilter) {
|
|
allOpenFilter.active = false;
|
|
knowledgeConsoleModel.applyFilter(allOpenFilter);
|
|
}
|
|
}
|
|
knowledgeConsoleModel.applyFilter(option);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
knowledgeConsoleModel.applyColumnSet = function (columnSet) {
|
|
var defaultVisibleColumns = _.filter(knowledgeConsoleModel.columnsConfig, { 'visible': true });
|
|
knowledgeConsoleModel.presetColumns = [];
|
|
_.each(knowledgeConsoleModel.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;
|
|
knowledgeConsoleModel.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(knowledgeConsoleModel.presetColumns, { name: item.name })) {
|
|
var columnData = angular.copy(item);
|
|
knowledgeConsoleModel.presetColumns.push(columnData);
|
|
}
|
|
});
|
|
}
|
|
knowledgeConsoleModel.presetColumns = _.sortBy(knowledgeConsoleModel.presetColumns, 'order');
|
|
knowledgeConsoleModel.criteria.attributeNames = _.map(knowledgeConsoleModel.presetColumns, 'attributeName');
|
|
};
|
|
knowledgeConsoleModel.applyFilter = function (filterOption) {
|
|
var criteria = knowledgeConsoleModel.criteria.filterCriteria, name = filterOption.criteria.name, multiselect = _.isArray(filterOption.criteria.value);
|
|
if (knowledgeConsoleModel.isKcsCoachPreset) {
|
|
criteria.kcsCoach = "true";
|
|
}
|
|
else {
|
|
delete criteria.kcsCoach;
|
|
}
|
|
if (filterOption.active) {
|
|
var filterName = filterOption.filterName || filterOption.criteria.name, filter = knowledgeConsoleModel.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]) {
|
|
if (multiselect) {
|
|
criteria[name] = _.union(criteria[name], filterOption.criteria.value);
|
|
}
|
|
else {
|
|
var previousOption = _.find(knowledgeConsoleModel.selectedFilters, { criteria: { name: filterOption.criteria.name } });
|
|
previousOption.active = false;
|
|
knowledgeConsoleModel.applyFilter(previousOption);
|
|
criteria[name] = filterOption.criteria.value;
|
|
}
|
|
}
|
|
else {
|
|
criteria[name] = filterOption.criteria.value;
|
|
}
|
|
knowledgeConsoleModel.selectedFilters.unshift(filterOption);
|
|
knowledgeConsoleModel.setKcsFilters();
|
|
}
|
|
else {
|
|
criteria[name] = multiselect ? _.difference(criteria[name], filterOption.criteria.value) : '';
|
|
if (!criteria[name].length) {
|
|
delete criteria[name];
|
|
}
|
|
var index = _.findIndex(knowledgeConsoleModel.selectedFilters, function (filter) {
|
|
return filter.name === filterOption.name && filter.criteria.name === filterOption.criteria.name;
|
|
});
|
|
if (index !== -1) {
|
|
knowledgeConsoleModel.selectedFilters.splice(index, 1);
|
|
}
|
|
if (!knowledgeConsoleModel.selectedFilters.length && knowledgeConsoleModel.isKcsCoachPreset) {
|
|
delete criteria.kcsCoach;
|
|
}
|
|
}
|
|
};
|
|
knowledgeConsoleModel.saveFilterPreset = function (name) {
|
|
var copySelectedFilters = _.cloneDeep(knowledgeConsoleModel.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.saveKnowledgeFilterConfiguration(name, knowledgeConsoleModel.criteria.filterCriteria)]);
|
|
};
|
|
knowledgeConsoleModel.saveColumnPreset = function (name, columnsConfig) {
|
|
return userModel.updateUserPreferences(columnPreferenceGroup, { name: name, value: columnsConfig });
|
|
};
|
|
knowledgeConsoleModel.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(knowledgeConsoleModel.userSavedPresets, { name: userFilterPreset.name });
|
|
};
|
|
knowledgeConsoleModel.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) {
|
|
knowledgeConsoleModel.currentColumnsConfig = defaultColumnConfig.value;
|
|
columnPreferenceDetailsId = defaultColumnConfig.id;
|
|
}
|
|
});
|
|
};
|
|
knowledgeConsoleModel.setKcsFilters = function () {
|
|
knowledgeConsoleModel.kcsFilters.coachFilter
|
|
= knowledgeConsoleModel.kcsFilters.teamMemberFilter
|
|
= knowledgeConsoleModel.kcsFilters.assessmentMode
|
|
= knowledgeConsoleModel.isKcsCoachPreset
|
|
= false;
|
|
};
|
|
knowledgeConsoleModel.applyKcsFilter = function () {
|
|
if (knowledgeConsoleModel.kcsFilters.teamMemberFilter) {
|
|
knowledgeConsoleModel.isKcsCoachPreset = false;
|
|
knowledgeConsoleModel.kcsFilters.authorFilter.active = true;
|
|
knowledgeConsoleModel.applyFilter(knowledgeConsoleModel.kcsFilters.authorFilter);
|
|
knowledgeConsoleModel.applyFilterSet([{ filter: 'statusMappings', option: 'allOpen' }]);
|
|
}
|
|
else if (knowledgeConsoleModel.kcsFilters.coachFilter) {
|
|
knowledgeConsoleModel.isKcsCoachPreset = true;
|
|
knowledgeConsoleModel.applyFilterSet([{ filter: 'statusMappings', option: 'allOpen' }]);
|
|
}
|
|
};
|
|
knowledgeConsoleModel.enableAssessment = function () {
|
|
return _.has(knowledgeConsoleModel.criteria.filterCriteria, 'kcsCoach') ||
|
|
!_.isEmpty(_.find(knowledgeConsoleModel.selectedFilters, { filterName: 'authors', name: knowledgeConsoleModel.kcsFilters.authorName }));
|
|
};
|
|
knowledgeConsoleModel.enableKcsFilters = function () {
|
|
return knowledgeConsoleModel.kcsFilters.assessmentMode || (knowledgeConsoleModel.kcsFilters.coachFilter || knowledgeConsoleModel.kcsFilters.teamMemberFilter);
|
|
};
|
|
knowledgeConsoleModel.isSearchEnabled = function () {
|
|
return (searchEnabled || knowledgeConsoleModel.criteria.filterCriteria.kcsCoach);
|
|
};
|
|
knowledgeConsoleModel.setSearchEnabled = function (value) {
|
|
searchEnabled = !!value;
|
|
};
|
|
knowledgeConsoleModel.setKcsFilters();
|
|
return knowledgeConsoleModel;
|
|
}
|
|
]);
|
|
}());
|