| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| var App = require('app'); |
| var blueprintUtils = require('utils/blueprint'); |
| |
| App.EnhancedConfigsMixin = Em.Mixin.create(App.ConfigWithOverrideRecommendationParser, { |
| |
| /** |
| * this value is used for observing |
| * whether recommendations for dependent properties was received from server |
| * @type {number} |
| */ |
| recommendationTimeStamp: null, |
| |
| /** |
| * this property is used to force update min/max values |
| * for not default config groups |
| * @type {boolean} |
| */ |
| forceUpdateBoundaries: false, |
| |
| /** |
| * object with loaded recommendations |
| * |
| * @type {?Object} |
| */ |
| recommendationsConfigs: null, |
| |
| /** |
| * list of recommendations that should be applied without any config changes |
| * |
| * @type {Object[]} |
| */ |
| initialRecommendations: [], |
| |
| /** |
| * flag is true when Ambari changes some of the dependent properties |
| * @type {boolean} |
| */ |
| hasChangedDependencies: Em.computed.and('isControllerSupportsEnhancedConfigs', 'changedProperties.length'), |
| |
| /** |
| * defines is block with changed dependent configs should be shown |
| * rely on controller |
| * @type {boolean} |
| */ |
| isControllerSupportsEnhancedConfigs: Em.computed.existsIn('name', ['wizardStep7Controller','mainServiceInfoConfigsController']), |
| |
| /** |
| * Stores name and file name of changed config |
| * This used only for capacity-scheduler |
| * |
| * @property {object} |
| */ |
| currentlyChangedConfig: null, |
| |
| dependenciesGroupMessage: Em.I18n.t('popup.dependent.configs.dependencies.for.groups'), |
| |
| /** |
| * ConfigType-Widget map |
| * key - widget type |
| * value - widget view |
| * @type {object} |
| */ |
| widgetTypeMap: { |
| checkbox: 'CheckboxConfigWidgetView', |
| combo: 'ComboConfigWidgetView', |
| directory: 'TextFieldConfigWidgetView', |
| directories: 'DirectoryConfigWidgetView', |
| list: 'ListConfigWidgetView', |
| password: 'PasswordConfigWidgetView', |
| 'radio-buttons': 'RadioButtonConfigWidgetView', |
| slider: 'SliderConfigWidgetView', |
| 'text-field': 'TextFieldConfigWidgetView', |
| 'time-interval-spinner': 'TimeIntervalSpinnerView', |
| toggle: 'ToggleConfigWidgetView', |
| 'text-area': 'StringConfigWidgetView', |
| 'label': 'LabelView', |
| 'test-db-connection': 'TestDbConnectionWidgetView' |
| }, |
| |
| configNameWidgetMixinMap: { |
| num_llap_nodes: App.NumLlapNodesWidgetMixin |
| }, |
| |
| /** |
| * message for alert box for dependent configs |
| * @type {string} |
| */ |
| dependenciesMessage: function() { |
| var changedProperties = this.get('changedProperties').filterProperty('saveRecommended'); |
| var changedServices = changedProperties.mapProperty('serviceName').uniq(); |
| var cfgLenSuffix = changedProperties.length === 1 ? 'singular' : 'plural'; |
| var sLenSuffix = changedServices.length === 1 ? 'singular' : 'plural'; |
| return Em.I18n.t('popup.dependent.configs.dependencies.config.' + cfgLenSuffix).format(changedProperties.length) |
| + Em.I18n.t('popup.dependent.configs.dependencies.service.' + sLenSuffix).format(changedServices.length); |
| }.property('changedProperties.length'), |
| |
| /** |
| * dependent properties that was changed by Ambari |
| * @type {Object[]} |
| */ |
| changedProperties: function() { |
| return this.get('recommendations').filter(function(dp) { |
| return (this.get('selectedConfigGroup.isDefault') && Em.get(dp, 'configGroup').contains('Default')) |
| || [this.get('selectedConfigGroup.name'), this.get('selectedConfigGroup.dependentConfigGroups') && this.get('selectedConfigGroup.dependentConfigGroups')[Em.get(dp, 'serviceName')]].contains(Em.get(dp, 'configGroup')); |
| }, this); |
| }.property('recommendations.@each.saveRecommended', 'recommendations.@each.recommendedValue', 'selectedConfigGroup'), |
| |
| /** |
| * defines if change dependent group message should be shown |
| * @type {boolean} |
| */ |
| showSelectGroupsPopup: Em.computed.and('!selectedConfigGroup.isDefault', 'selectedService.dependentServiceNames.length'), |
| |
| /** |
| * set default values for dependentGroups |
| * @method setDependentGroups |
| */ |
| setDependentGroups: function () { |
| if (this.shouldSetDependentConfigs()) { |
| this.get('selectedService.dependentServiceNames').forEach(function (serviceName) { |
| if (!this.get('selectedConfigGroup.dependentConfigGroups')[serviceName]) { |
| var stepConfig = this.get('stepConfigs').findProperty('serviceName', serviceName); |
| if (stepConfig) { |
| this.setDependentConfigGroups(stepConfig, serviceName); |
| } |
| } |
| }, this); |
| } |
| }.observes('selectedConfigGroup'), |
| |
| /** |
| * |
| * @param {Em.Object} stepConfig |
| * @param {string} serviceName |
| */ |
| setDependentConfigGroups: function(stepConfig, serviceName) { |
| stepConfig.get('configGroups').filterProperty('isDefault', false).forEach(function (configGroup) { |
| this.get('selectedService.configGroups').filterProperty('isDefault', false).forEach(function (currentServiceGroup) { |
| if (currentServiceGroup.get('dependentConfigGroups')[serviceName] !== configGroup.get('name')) { |
| var dependentGroups = $.extend({}, this.get('selectedConfigGroup.dependentConfigGroups')); |
| dependentGroups[serviceName] = configGroup.get('name'); |
| this.set('selectedConfigGroup.dependentConfigGroups', dependentGroups); |
| } |
| }, this); |
| }, this); |
| }, |
| |
| /** |
| * |
| * @returns {boolean} |
| */ |
| shouldSetDependentConfigs: function() { |
| return Boolean(this.get('selectedConfigGroup') && |
| this.get('isControllerSupportsEnhancedConfigs') && |
| !this.get('selectedConfigGroup.isDefault') && |
| this.get('selectedService.dependentServiceNames.length')); |
| }, |
| |
| /******************************METHODS THAT WORKS WITH DEPENDENT CONFIGS *************************************/ |
| |
| /** |
| * get config group object for current service |
| * @param serviceName |
| * @returns {App.ConfigGroup|null} |
| */ |
| getGroupForService: function(serviceName) { |
| if (!this.get('stepConfigs') || this.get('stepConfigs.length') === 0) { |
| return null; |
| } |
| if (this.get('selectedService.serviceName') === serviceName) { |
| return this.get('selectedConfigGroup'); |
| } else { |
| var stepConfig = this.get('stepConfigs').findProperty('serviceName', serviceName); |
| if (stepConfig) { |
| var groups = stepConfig.get('configGroups'); |
| if (this.get('selectedConfigGroup.isDefault')) { |
| return groups.length ? groups.findProperty('isDefault') : null; |
| } else { |
| return groups.length ? groups.findProperty('name', this.get('selectedConfigGroup.dependentConfigGroups')[serviceName]) : null; |
| } |
| } else { |
| return null; |
| } |
| } |
| }, |
| |
| clearRecommendationsInfo: function() { |
| this.set('recommendationsConfigs', null); |
| }, |
| |
| clearRecommendations: function () { |
| this.clearRecommendationsInfo(); |
| this.clearAllRecommendations(); |
| }, |
| |
| /** |
| * sends request to get values for dependent configs |
| * @param {{type: string, name: string}[]} changedConfigs - list of changed configs to track recommendations |
| * @param {Function} [onComplete] |
| * @returns {$.ajax|null} |
| */ |
| loadConfigRecommendations: function (changedConfigs, onComplete) { |
| var updateDependencies = Em.isArray(changedConfigs) && changedConfigs.length > 0; |
| var stepConfigs = this.get('stepConfigs'); |
| var requiredTags = []; |
| |
| if (updateDependencies || Em.isNone(this.get('recommendationsConfigs'))) { |
| var recommendations = this.get('hostGroups'); |
| var dataToSend = this.getConfigRecommendationsParams(updateDependencies, changedConfigs); |
| this.modifyRecommendationConfigGroups(recommendations); |
| |
| if (!stepConfigs.someProperty('serviceName', 'MISC')) { |
| requiredTags.push({site: 'cluster-env', serviceName: 'MISC'}); |
| } |
| if (Em.isArray(changedConfigs) && changedConfigs.mapProperty('type').uniq()[0] === 'capacity-scheduler') { |
| this.set('currentlyChangedConfig', { |
| name: 'capacity-scheduler', |
| fileName: 'capacity-scheduler.xml' |
| }); |
| } else { |
| this.set('currentlyChangedConfig', null); |
| } |
| |
| if (App.Service.find().someProperty('serviceName', 'HDFS') && !stepConfigs.someProperty('serviceName', 'HDFS')) { |
| requiredTags.push({site: 'core-site', serviceName: 'HDFS'}); |
| } |
| |
| this.setUserContext(dataToSend); |
| if (requiredTags.length) { |
| this.loadAdditionalSites(requiredTags, stepConfigs, recommendations, dataToSend, onComplete); |
| } else { |
| this.addRecommendationRequestParams(recommendations, dataToSend, stepConfigs); |
| return this.getRecommendationsRequest(dataToSend, onComplete); |
| } |
| } else { |
| if (onComplete) { |
| onComplete() |
| } |
| } |
| return $.Deferred().resolve().promise(); |
| }, |
| |
| /** |
| * |
| * @param recommendations |
| * @param dataToSend |
| * @param stepConfigs |
| */ |
| addRecommendationRequestParams: function(recommendations, dataToSend, stepConfigs) { |
| recommendations.blueprint.configurations = blueprintUtils.buildConfigsJSON(stepConfigs); |
| dataToSend.recommendations = recommendations; |
| }, |
| |
| /** |
| * |
| * @param {Array} stepConfigs |
| * @param {object} recommendations |
| * @param {object} dataToSend |
| * @param {Function} onComplete |
| */ |
| loadAdditionalSites: function(sites, stepConfigs, recommendations, dataToSend, onComplete) { |
| var self = this; |
| App.router.get('configurationController').getCurrentConfigsBySites(sites).done(function (configs) { |
| stepConfigs = stepConfigs.concat(configs); |
| |
| self.addRecommendationRequestParams(recommendations, dataToSend, stepConfigs); |
| self.getRecommendationsRequest(dataToSend, onComplete); |
| }); |
| }, |
| |
| /** |
| * |
| * @param {object} recommendations |
| */ |
| modifyRecommendationConfigGroups: function(recommendations) { |
| var configGroup = this.get('selectedConfigGroup'); |
| |
| if (configGroup && !configGroup.get('isDefault') && configGroup.get('hosts.length') > 0) { |
| recommendations.config_groups = [this.buildConfigGroupJSON(this.get('selectedService.configs'), configGroup)]; |
| } else { |
| delete recommendations.config_groups; |
| } |
| }, |
| |
| /** |
| * |
| * @param {boolean} updateDependencies |
| * @param {Array} changedConfigs |
| * @returns {{recommend: string, hosts: *, services: *, changed_configurations: *}} |
| */ |
| getConfigRecommendationsParams: function(updateDependencies, changedConfigs) { |
| return { |
| recommend: updateDependencies ? 'configuration-dependencies' : 'configurations', |
| hosts: this.get('hostNames'), |
| services: this.get('serviceNames'), |
| changed_configurations: updateDependencies ? changedConfigs : undefined |
| }; |
| }, |
| |
| getRecommendationsRequest: function (dataToSend, callback) { |
| var self = this; |
| this.set('recommendationsInProgress', true); |
| return App.ajax.send({ |
| name: 'config.recommendations', |
| sender: self, |
| data: { |
| stackVersionUrl: App.get('stackVersionURL'), |
| dataToSend: dataToSend |
| }, |
| success: 'loadRecommendationsSuccess', |
| error: 'loadRecommendationsError', |
| callback: function () { |
| self.set('recommendationsInProgress', false); |
| self.set('recommendationTimeStamp', (new Date).getTime()); |
| if (callback) { |
| callback() |
| } |
| } |
| }); |
| }, |
| |
| setUserContext: function(dataToSend) { |
| var controllerName = this.get('content.controllerName'); |
| var changes = dataToSend.changed_configurations; |
| if (changes) { |
| dataToSend['user_context'] = {"operation" : "EditConfig"}; |
| } else { |
| if (!controllerName) { |
| dataToSend['user_context'] = {"operation" : "RecommendAttribute"}; |
| } else if (controllerName == 'addServiceController') { |
| dataToSend['user_context'] = { |
| "operation" : "AddService", |
| "operation_details" : (this.get('content.services')|| []).filterProperty('isSelected').filterProperty('isInstalled', false).mapProperty('serviceName').join(',') |
| }; |
| } else if (controllerName == 'installerController'){ |
| dataToSend['user_context'] = {"operation" : "ClusterCreate"}; |
| } |
| } |
| }, |
| |
| /** |
| * Defines if there is any changes made by user. |
| * Check all properties except recommended properties from popup |
| * |
| * @returns {boolean} |
| */ |
| isConfigHasInitialState: function() { |
| return Boolean(this.get('selectedConfigGroup.isDefault') && !Em.isNone(this.get('recommendationsConfigs')) |
| && !this.get('stepConfigs').filter(function(stepConfig) { |
| return stepConfig.get('changedConfigProperties').filter(function(c) { |
| var changedConfigIds = this.get('changedProperties').map(function(changed) { |
| return App.config.configId(changed.propertyName, changed.propertyFileName); |
| }); |
| return !changedConfigIds.contains(App.config.configId(c.get('name'), c.get('filename'))); |
| }, this).length; |
| }, this).length); |
| }, |
| |
| /** |
| * generates JSON with config group info to send it for recommendations |
| * @param configs |
| * @param configGroup |
| * @returns {{configurations: Object[], hosts: string[]}} |
| */ |
| buildConfigGroupJSON: function(configs, configGroup) { |
| Em.assert('configGroup can\'t be null', configGroup); |
| var hosts = configGroup.get('hosts'); |
| var configurations = {}; |
| var overrides = configs.forEach(function(cp) { |
| var override = cp.get('overrides') && cp.get('overrides').findProperty('group.name', configGroup.get('name')); |
| if (override) { |
| var tag = App.config.getConfigTagFromFileName(cp.get('filename')); |
| if (!configurations[tag]) { |
| configurations[tag] = { properties: {} }; |
| } |
| configurations[tag].properties[cp.get('name')] = override.get('value'); |
| } |
| }); |
| return { |
| configurations: [configurations], |
| hosts: hosts |
| } |
| }, |
| |
| /** |
| * shows popup with results for recommended value |
| * if case properties that was changes belongs to not default group |
| * user should pick to what config group from dependent service dependent properties will be saved |
| * @param data |
| * @param opt |
| * @param params |
| * @method dependenciesSuccess |
| */ |
| loadRecommendationsSuccess: function (data, opt, params) { |
| this._saveRecommendedValues(data, params.dataToSend.changed_configurations); |
| if (this.isConfigHasInitialState()) { |
| /** clearing all recommendations info **/ |
| this.undoRedoRecommended(this.get('recommendations'), false); |
| this.clearAllRecommendations(); |
| |
| /** |
| * resetting recommendations to initial state |
| * this case can be present when installed services depends on new added service on ADW |
| **/ |
| this.undoRedoRecommended(this.get('initialRecommendations'), true); |
| this.get('initialRecommendations').forEach(function (r) { |
| this.get('recommendations').pushObject(r); |
| }, this); |
| } |
| this.set("recommendationsConfigs", Em.get(data, "resources.0.recommendations.blueprint.configurations")); |
| }, |
| |
| loadRecommendationsError: Em.K, |
| |
| changedDependentGroup: function () { |
| var dependentServices = this.get('selectedService.dependentServiceNames'); |
| var isInstallWizard = this.get('content.controllerName') === 'installerController'; |
| var installedServices = App.Service.find().mapProperty('serviceName'); |
| var services = this.get('stepConfigs').filter(function (stepConfig) { |
| if (dependentServices.contains(stepConfig.get('serviceName'))) { |
| return isInstallWizard ? true : installedServices.contains(stepConfig.get('serviceName')); |
| } |
| return false; |
| }, this); |
| App.showSelectGroupsPopup(this.get('selectedService.serviceName'), |
| this.get('selectedService.configGroups').findProperty('name', this.get('selectedConfigGroup.name')), |
| services, this.get('recommendations')); |
| }, |
| |
| /** |
| * saves values from response for dependent config properties to <code>recommendations<code> |
| * @param data |
| * @param [changedConfigs=null] |
| * @method saveRecommendedValues |
| * @private |
| */ |
| _saveRecommendedValues: function(data, changedConfigs) { |
| Em.assert('invalid data - `data.resources[0].recommendations.blueprint.configurations` not defined ', data && data.resources[0] && Em.get(data.resources[0], 'recommendations.blueprint.configurations')); |
| var recommendations = data.resources[0].recommendations; |
| if (recommendations['config-groups'] && this.get('selectedConfigGroup') && !this.get('selectedConfigGroup.isDefault')) { |
| this.saveConfigGroupsRecommendations(recommendations, changedConfigs); |
| } else { |
| var configObject = recommendations.blueprint.configurations; |
| this.get('stepConfigs').forEach(function(stepConfig) { |
| this.updateConfigsByRecommendations(configObject, stepConfig.get('configs'), changedConfigs); |
| }, this); |
| this.addByRecommendations(configObject, changedConfigs); |
| } |
| this.cleanUpRecommendations(); |
| }, |
| |
| /** |
| * |
| * @param {object} recommendations |
| * @param {?Array} changedConfigs |
| */ |
| saveConfigGroupsRecommendations: function(recommendations, changedConfigs) { |
| var configForGroup = recommendations['config-groups'][0]; |
| this.get('stepConfigs').forEach(function(stepConfig) { |
| var configGroup = this.getGroupForService(stepConfig.get('serviceName')); |
| if (configGroup && this.isConfigGroupAffected(configForGroup.hosts, configGroup.get('hosts'))) { |
| this.updateOverridesByRecommendations(configForGroup.configurations, stepConfig.get('configs'), changedConfigs, configGroup); |
| this.updateOverridesByRecommendations(configForGroup.dependent_configurations, stepConfig.get('configs'), changedConfigs, configGroup); |
| this.toggleProperty('forceUpdateBoundaries'); |
| } |
| }, this); |
| }, |
| |
| |
| /** |
| * determine whether hosts of group affected by config modifications |
| * @param {Array} affectedHosts |
| * @param {Array} groupHosts |
| * @returns {boolean} |
| */ |
| isConfigGroupAffected: function(affectedHosts, groupHosts) { |
| return _.intersection(affectedHosts, groupHosts).length > 0; |
| }, |
| |
| /** |
| * method to show popup with dependent configs |
| * @method showChangedDependentConfigs |
| */ |
| showChangedDependentConfigs: function(event, callback, secondary) { |
| var self = this; |
| var recommendations = event ? this.get('changedProperties') : this.get('recommendations'), |
| recommendedChanges = recommendations.filterProperty('isEditable'), |
| requiredChanges = this.filterRequiredChanges(recommendations); |
| if (recommendedChanges.length > 0 || requiredChanges.length > 0) { |
| App.showDependentConfigsPopup(recommendedChanges, requiredChanges, function() { |
| self.onSaveRecommendedPopup(recommendedChanges.concat(requiredChanges)); |
| if (callback) callback(); |
| }, secondary, this); |
| } else { |
| if (callback) callback(); |
| } |
| }, |
| |
| /** |
| * |
| * @param {Array} recommendations |
| * @returns {Array} |
| */ |
| filterRequiredChanges: function(recommendations) { |
| return recommendations.filter(function(recommendation) { |
| if (recommendation.isEditable === false) { |
| if (!this.get('selectedConfigGroup.isDefault')) { |
| return App.ServiceConfigGroup.defaultGroupName !== recommendation.configGroup |
| } else { |
| return true; |
| } |
| } |
| }, this); |
| }, |
| |
| /** |
| * update configs when toggle checkbox on dependent configs popup |
| */ |
| onSaveRecommendedPopup: function(recommendations) { |
| var propertiesToUpdate = recommendations.filter(function(c) { |
| return Em.get(c, 'saveRecommendedDefault') !== Em.get(c, 'saveRecommended'); |
| }), |
| propertiesToUndo = propertiesToUpdate.filterProperty('saveRecommended', false), |
| propertiesToRedo = propertiesToUpdate.filterProperty('saveRecommended', true); |
| |
| this.undoRedoRecommended(propertiesToUndo, false); |
| this.undoRedoRecommended(propertiesToRedo, true); |
| this.set('recommendationTimeStamp', (new Date).getTime()); |
| }, |
| |
| /** |
| * run through config properties list (form dependent popup) |
| * and set value to default (undo) or recommended (redo) |
| * this happens when toggle checkbox in popup |
| * @param {Object[]} propertiesToUpdate |
| * @param {boolean} redo |
| */ |
| undoRedoRecommended: function(propertiesToUpdate, redo) { |
| propertiesToUpdate.forEach(function(p) { |
| var initial = redo ? Em.get(p, 'initialValue') : Em.get(p, 'recommendedValue'); |
| var recommended = redo ? Em.get(p, 'recommendedValue') : Em.get(p, 'initialValue'); |
| var stepConfig = this.get('stepConfigs').findProperty('serviceName', Em.get(p, 'serviceName')); |
| var config = stepConfig.get('configs').find(function(scp) { |
| return scp.get('name') === Em.get(p, 'propertyName') && |
| scp.get('filename') === App.config.getOriginalFileName(Em.get(p, 'propertyFileName')); |
| }); |
| var selectedGroup = App.ServiceConfigGroup.find() |
| .filterProperty('serviceName', Em.get(p, 'serviceName')) |
| .findProperty('name', Em.get(p, 'configGroup')); |
| |
| if (selectedGroup.get('isDefault')) { |
| this.setRecommendedForDefaultGroup(recommended, stepConfig, p, initial, config); |
| } else { |
| this.setRecommendedForGroup(recommended, selectedGroup, config, initial); |
| } |
| }, this); |
| }, |
| |
| /** |
| * |
| * @param {string} recommended |
| * @param {Em.Object} selectedGroup |
| * @param {object} config |
| * @param {string}initial |
| */ |
| setRecommendedForGroup: function(recommended, selectedGroup, config, initial) { |
| if (Em.isNone(recommended)) { |
| config.get('overrides').removeObject(config.getOverride(selectedGroup.get('name'))); |
| } else if (Em.isNone(initial)) { |
| this._addConfigOverrideRecommendation(config, recommended, null, selectedGroup); |
| } else { |
| var override = config.getOverride(selectedGroup.get('name')); |
| if (override) { |
| override.set('value', recommended); |
| } |
| } |
| }, |
| |
| /** |
| * |
| * @param {string} recommended |
| * @param {Em.Object} stepConfig |
| * @param {object|Em.Object} prop |
| * @param {string} initial |
| * @param {object} config |
| */ |
| setRecommendedForDefaultGroup: function(recommended, stepConfig, prop, initial, config) { |
| var name = Em.get(prop, 'propertyName'), |
| filename = Em.get(prop, 'propertyFileName'); |
| |
| if (Em.isNone(recommended)) { |
| stepConfig.get('configs').removeObject(config); |
| } else if (Em.isNone(initial)) { |
| var stackConfigProperty = App.configsCollection.getConfigByName(name, filename); |
| stepConfig.get('configs').pushObject(this._createNewProperty( |
| name, |
| filename, |
| Em.get(prop, 'serviceName'), |
| recommended, |
| stackConfigProperty? stackConfigProperty.propertyDependsOn : [])); |
| } else { |
| Em.set(config, 'value', recommended); |
| } |
| }, |
| |
| saveInitialRecommendations: function() { |
| this.get('recommendations').forEach(function (r) { |
| this.get('initialRecommendations').pushObject(r); |
| }, this); |
| }, |
| |
| /** |
| * disable saving recommended value for current config |
| * @param config |
| * @param {boolean} saveRecommended |
| * @method removeCurrentFromDependentList |
| */ |
| removeCurrentFromDependentList: function (config, saveRecommended) { |
| var recommendation = this.getRecommendation(config.get('name'), config.get('filename'), config.get('group.name')); |
| if (recommendation) this.saveRecommendation(recommendation, saveRecommended); |
| }, |
| |
| updateAttributesFromTheme: function (serviceName) { |
| this.prepareSectionsConfigProperties(serviceName); |
| const serviceConfigs = this.get('stepConfigs').findProperty('serviceName', serviceName).get('configs'), |
| configConditions = App.ThemeCondition.find().filter(condition => { |
| const dependentConfigName = condition.get('configName'), |
| dependentConfigFileName = condition.get('fileName'), |
| configsToDependOn = condition.getWithDefault('configs', []); |
| return serviceConfigs.some(serviceConfig => { |
| const serviceConfigName = Em.get(serviceConfig, 'name'), |
| serviceConfigFileName = Em.get(serviceConfig, 'filename'); |
| return (serviceConfigName === dependentConfigName && serviceConfigFileName === dependentConfigFileName) |
| || configsToDependOn.some(config => { |
| const {configName, fileName} = config; |
| return serviceConfigName === configName && serviceConfigFileName === fileName; |
| }); |
| }); |
| }); |
| this.updateAttributesFromConditions(configConditions, serviceConfigs, serviceName); |
| }, |
| |
| prepareSectionsConfigProperties: function (serviceName) { |
| const tabs = App.Tab.find().filterProperty('serviceName', serviceName); |
| tabs.forEach(tab => { |
| this.processTab(tab); |
| tab.get('sectionRows').forEach(row => { |
| row.forEach(section => { |
| section.get('subsectionRows').forEach(subRow => { |
| subRow.forEach(subsection => { |
| this.setConfigsToContainer(subsection); |
| subsection.get('subSectionTabs').forEach(subSectionTab => { |
| this.setConfigsToContainer(subSectionTab); |
| }); |
| }); |
| }); |
| }); |
| }); |
| }); |
| }, |
| |
| /** |
| * set {code} configs {code} array of subsection or subsection tab. |
| * Also correct widget should be used for each config (it's selected according to <code>widget.type</code> and |
| * <code>widgetTypeMap</code>). It may throw an error if needed widget can't be found in the <code>widgetTypeMap</code> |
| * @param containerObject |
| */ |
| setConfigsToContainer: function (containerObject) { |
| containerObject.set('configs', []); |
| |
| containerObject.get('configProperties').forEach(function (configId) { |
| const config = App.configsCollection.getConfig(configId); |
| if (Em.get(config, 'widgetType')) { |
| const stepConfig = this.get('stepConfigs').findProperty('serviceName', Em.get(config, 'serviceName')); |
| if (!stepConfig) return; |
| |
| const configProperty = stepConfig.get('configs').findProperty('id', Em.get(config, 'id')); |
| if (!configProperty) return; |
| |
| containerObject.get('configs').pushObject(configProperty); |
| |
| const widget = this.getWidgetView(config); |
| Em.assert('Unknown config widget view for config ' + configProperty.get('id') + ' with type ' + Em.get(config, 'widgetType'), widget); |
| |
| let additionalProperties = { |
| widget, |
| stackConfigProperty: config |
| }; |
| |
| const configConditions = App.ThemeCondition.find().filter(_configCondition => { |
| // Filter config condition depending on the value of another config |
| const conditionalConfigs = _configCondition.getWithDefault('configs', []).filterProperty('fileName', Em.get(config, 'filename')).filterProperty('configName', Em.get(config, 'name')); |
| // Filter config condition depending on the service existence or service state |
| const serviceConfigConditionFlag = ((_configCondition.get('configName') === Em.get(config, 'name')) && (_configCondition.get('fileName') === Em.get(config, 'filename')) && (_configCondition.get('resource') === 'service')); |
| let conditions; |
| |
| if (serviceConfigConditionFlag) { |
| const configCondition = { |
| configName: _configCondition.get('configName'), |
| fileName: _configCondition.get('fileName') |
| }; |
| conditions = conditionalConfigs.concat(configCondition) |
| } else { |
| conditions = conditionalConfigs; |
| } |
| return (conditions && conditions.length); |
| }); |
| |
| if (configConditions && configConditions.length) { |
| additionalProperties.configConditions = configConditions; |
| } |
| |
| const configAction = App.ConfigAction.find().filterProperty('fileName', Em.get(config, 'filename')).findProperty('configName', Em.get(config, 'name')); |
| |
| if (configAction) { |
| additionalProperties.configAction = configAction; |
| } |
| |
| configProperty.setProperties(additionalProperties); |
| |
| if (configProperty.get('overrides')) { |
| configProperty.get('overrides').setEach('stackConfigProperty', config); |
| } |
| if (configProperty.get('compareConfigs')) { |
| configProperty.get('compareConfigs').invoke('setProperties', { |
| isComparison: false, |
| stackConfigProperty: config |
| }); |
| } |
| } |
| }, this); |
| }, |
| |
| /** |
| * |
| * @param {object} config |
| * @returns {Em.View} |
| */ |
| getWidgetView: function (config) { |
| const configWidgetType = Em.get(config, 'widgetType'), |
| name = Em.get(config, 'name'), |
| mixin = this.get('configNameWidgetMixinMap')[name], |
| viewClass = App[this.get('widgetTypeMap')[configWidgetType]]; |
| return Em.isNone(mixin) ? viewClass : viewClass.extend(mixin); |
| }, |
| |
| updateAttributesFromConditions: function (configConditions, serviceConfigs, serviceName) { |
| let isConditionTrue; |
| configConditions.forEach(configCondition => { |
| const ifStatement = configCondition.get('if'); |
| if (configCondition.get('resource') === 'config') { |
| isConditionTrue = App.configTheme.calculateConfigCondition(ifStatement, serviceConfigs); |
| if (configCondition.get('type') === 'subsection' || configCondition.get('type') === 'subsectionTab') { |
| this.changeSubsectionAttribute(configCondition, isConditionTrue); |
| } else { |
| this.changeConfigAttribute(configCondition, isConditionTrue, serviceName); |
| } |
| } else if (configCondition.get('resource') === 'service') { |
| const service = App.Service.find().findProperty('serviceName', ifStatement); |
| if (service) { |
| isConditionTrue = true; |
| } else if (!service && this.get('allSelectedServiceNames') && this.get('allSelectedServiceNames').length) { |
| isConditionTrue = this.get('allSelectedServiceNames').contains(ifStatement); |
| } else { |
| isConditionTrue = false; |
| } |
| this.changeConfigAttribute(configCondition, isConditionTrue, serviceName); |
| } |
| }); |
| }, |
| |
| /** |
| * |
| * @param configCondition {App.ThemeCondition} |
| * @param isConditionTrue {boolean} |
| */ |
| changeConfigAttribute: function (configCondition, isConditionTrue, serviceName) { |
| const conditionalConfigName = configCondition.get('configName'), |
| conditionalConfigFileName = configCondition.get('fileName'), |
| serviceConfigs = this.get('stepConfigs').findProperty('serviceName', serviceName).get('configs'), |
| action = isConditionTrue ? configCondition.get('then') : configCondition.get('else'), |
| valueAttributes = action.property_value_attributes; |
| this.set('isChangingConfigAttributes', true); |
| for (let key in valueAttributes) { |
| if (valueAttributes.hasOwnProperty(key)) { |
| const valueAttribute = App.StackConfigValAttributesMap[key] || key, |
| conditionalConfig = serviceConfigs.filterProperty('filename', conditionalConfigFileName).findProperty('name', conditionalConfigName); |
| if (conditionalConfig) { |
| if (key === 'visible') { |
| conditionalConfig.set('hiddenBySection', !valueAttributes[key]); |
| } |
| conditionalConfig.set(valueAttribute, valueAttributes[key]); |
| } |
| } |
| } |
| this.set('isChangingConfigAttributes', false); |
| }, |
| /** |
| * |
| * @param subsectionCondition {App.ThemeCondition} |
| * @param isConditionTrue {boolean} |
| */ |
| changeSubsectionAttribute: function (subsectionCondition, isConditionTrue) { |
| var subsectionConditionName = subsectionCondition.get('name'); |
| var action = isConditionTrue ? subsectionCondition.get('then') : subsectionCondition.get('else'); |
| if (subsectionCondition.get('id')) { |
| const valueAttributes = action.property_value_attributes; |
| if (valueAttributes && !Em.none(valueAttributes.visible)) { |
| let themeResource; |
| if (subsectionCondition.get('type') === 'subsection') { |
| themeResource = App.SubSection.find().find(function (subsection) { |
| return subsection.get('name') === subsectionConditionName && subsectionCondition.get('id').toLowerCase().includes(subsection.get('themeName').toLowerCase()); |
| }); |
| } else if (subsectionCondition.get('type') === 'subsectionTab') { |
| themeResource = App.SubSectionTab.find().find(function (subsectionTab) { |
| return subsectionTab.get('name') === subsectionConditionName && subsectionCondition.get('id').toLowerCase().includes(subsectionTab.get('themeName').toLowerCase()); |
| }); |
| } |
| themeResource.set('isHiddenByConfig', !valueAttributes.visible); |
| themeResource.get('configs').setEach('hiddenBySection', !valueAttributes.visible); |
| themeResource.get('configs').setEach('hiddenBySubSection', !valueAttributes.visible); |
| } |
| } |
| }, |
| |
| /** |
| * Data reordering before tabs rendering. |
| * Reorder all sections/subsections into rows based on their rowIndex |
| * @param tab |
| */ |
| processTab: function (tab) { |
| // process sections |
| let sectionRows = []; |
| const sections = tab.get('sections'); |
| for (let j = 0; j < sections.get('length'); j++) { |
| const section = sections.objectAt(j); |
| let sectionRow = sectionRows[section.get('rowIndex')]; |
| if (!sectionRow) { |
| sectionRow = sectionRows[section.get('rowIndex')] = []; |
| } |
| sectionRow.push(section); |
| |
| //process subsections |
| const subsections = section.get('subSections'); |
| let subsectionRows = []; |
| for (let k = 0; k < subsections.get('length'); k++) { |
| const subsection = subsections.objectAt(k); |
| let subsectionRow = subsectionRows[subsection.get('rowIndex')]; |
| if (!subsectionRow) { |
| subsectionRow = subsectionRows[subsection.get('rowIndex')] = []; |
| } |
| subsectionRow.push(subsection); |
| // leave a title gap if one of the subsection on the same row within the same section has title |
| if (subsection.get('displayName')) { |
| subsectionRow.hasTitleGap = true; |
| } |
| } |
| section.set('subsectionRows', subsectionRows); |
| } |
| tab.set('sectionRows', sectionRows); |
| } |
| }); |
