ambari/ambari-web/app/controllers/global/user_settings_controller.js

/**
 * 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 timezoneUtils = require('utils/date/timezone');

/**
 * Controller for user settings
 * Allows to get them from persist and update them to the persist
 *
 * @class UserSettingsController
 */
App.UserSettingsController = Em.Controller.extend(App.UserPref, {

  name: 'userSettingsController',

  /**
   * @type {object}
   */
  userSettings: {},

  /**
   * Each property's type is {name: string, defaultValue: *, formatter: function}
   *
   * @type {object}
   */
  userSettingsKeys: function () {
    var loginName = App.router.get('loginName');
    var prefix = 'admin-settings-';
    return {
      show_bg: {
        name: prefix +'show-bg-' + loginName,
        defaultValue: true
      },
      timezone: {
        name: prefix + 'timezone-' + loginName,
        defaultValue: timezoneUtils.detectUserTimezone(),
        formatter: function (v) {
          return timezoneUtils.get('timezonesMappedByValue')[v];
        }
      }
    };
  }.property('App.router.loginName'),

  /**
   * Load some user's setting from the persist
   * If <code>persistKey</code> is not provided, all settings are loaded
   *
   * @param {string} [persistKey]
   * @method dataLoading
   * @returns {$.Deferred.promise}
   */
  dataLoading: function (persistKey) {
    var key = persistKey ? this.get('userSettingsKeys.' + persistKey + '.name') : '';
    var dfd = $.Deferred();
    var self = this;
    this.getUserPref(key).complete(function () {
      var curPref = self.get('currentPrefObject');
      self.set('currentPrefObject', null);
      dfd.resolve(curPref);
    });
    return dfd.promise();
  },

  /**
   * Success-callback for user pref
   *
   * @param {*} response
   * @param {object} opt
   * @returns {*}
   * @method getUserPrefSuccessCallback
   */
  getUserPrefSuccessCallback: function (response, opt) {
    var getAllRequest = opt.url.contains('persist/?_');
    if (Em.isNone(response)) {
      this.updateUserPrefWithDefaultValues(response, getAllRequest);
    }
    this.set('currentPrefObject', response);
    return response;
  },

  /**
   * Error-callback for user-pref request
   * Update user pref with default values if user firstly login
   *
   * @param {object} request
   * @method getUserPrefErrorCallback
   */
  getUserPrefErrorCallback: function (request) {
    // this user is first time login
    if (404 == request.status) {
      this.updateUserPrefWithDefaultValues();
    }
  },

  /**
   * Load all current user's settings to the <code>userSettings</code>
   *
   * @method getAllUserSettings
   */
  getAllUserSettings: function () {
    var userSettingsKeys = this.get('userSettingsKeys');
    var userSettings = {};
    var self = this;
    this.dataLoading().done(function (json) {
      Object.keys(userSettingsKeys).forEach(function (k) {
        var value = userSettingsKeys[k].defaultValue;
        if (undefined === json[userSettingsKeys[k].name]) {
          self.postUserPref(k, userSettingsKeys[k].defaultValue);
        }
        else {
          value = JSON.parse(json[userSettingsKeys[k].name]);
        }
        if ('function' === Em.typeOf(userSettingsKeys[k].formatter)) {
          value = userSettingsKeys[k].formatter(value);
        }
        userSettings[k] = value;
      });
    });
    this.set('userSettings', userSettings);
  },

  /**
   * If user doesn't have any settings stored in the persist,
   * default values should be populated there
   *
   * @param {object} [response]
   * @param {boolean} [getAllRequest] determines, if user tried to get one field or all fields
   * @method updateUserPrefWithDefaultValues
   */
  updateUserPrefWithDefaultValues: function (response, getAllRequest) {
    response = response || {};
    var keys = this.get('userSettingsKeys');
    var self = this;
    if (getAllRequest) {
      Object.keys(keys).forEach(function (key) {
        if (Em.isNone(response[keys[key].name])) {
          self.postUserPref(key, keys[key].defaultValue);
        }
      });
    }
  },

  /**
   * "Short"-key method for post user settings to the persist
   * Example:
   *  real key is something like 'userSettingsKeys.timezone.name'
   *  but user should call this method with 'timezone'
   *
   * @method postUserPref
   * @param {string} key
   * @param {*} value
   * @returns {*}
   */
  postUserPref: function (key, value) {
    var k = key.startsWith('userSettingsKeys.') ? key : 'userSettingsKeys.' + key + '.name';
    var kk = k.replace('userSettingsKeys.', '').replace('.name', '');
    this.set('userSettings.' + kk, value);
    return this._super(this.get(k), value);
  },

  /**
   * Open popup with user settings after settings-request is complete
   *
   * @method showSettingsPopup
   */
  showSettingsPopup: function() {
    var self = this;
    // Settings only for admins
    if (!App.isAccessible('upgrade_ADMIN')) {
      return;
    }

    this.dataLoading()
    .done(function(response) {
      self.loadPrivileges().complete(function() {
        self._showSettingsPopup(response);
      });
    });
  },

  loadPrivileges: function() {
    return App.ajax.send({
      name: 'router.user.privileges',
      sender: this,
      data: {
        userName: App.db.getLoginName()
      },
      success: 'loadPrivilegesSuccessCallback'
    });
  },

  loadPrivilegesSuccessCallback: function(data) {
    var privileges = {
      clusters: {},
      views: {}
    };
    data.items.forEach(function(privilege) {
      privilege = privilege.PrivilegeInfo;
      if(privilege.type === 'CLUSTER'){
        // This is cluster
        privileges.clusters[privilege.cluster_name] = privileges.clusters[privilege.cluster_name] || [];
        privileges.clusters[privilege.cluster_name].push(privilege.permission_label);
      } else if ( privilege.type === 'VIEW'){
        privileges.views[privilege.instance_name] = privileges.views[privilege.instance_name] || { privileges:[]};
        privileges.views[privilege.instance_name].version = privilege.version;
        privileges.views[privilege.instance_name].view_name = privilege.view_name;
        privileges.views[privilege.instance_name].privileges.push(privilege.permission_label);
      }
    });
    // restructure data for view
    var clusters = [];
    var views = [];
    for (key in privileges.clusters){
      clusters.push({
        name: key,
        privileges: privileges.clusters[key]
      });
    }
    for (key in privileges.views) {
      views.push({
        instance_name: key,
        privileges: privileges.views[key].privileges,
        version: privileges.views[key].version,
        view_name: privileges.views[key].view_name
      });
    }
    privileges.clusters = clusters;
    privileges.views = views;
    this.set('privileges', data.items.length ? privileges : null);
  },

  /**
   * Show popup with settings for user
   * Don't call this method directly! Use <code>showSettingsPopup</code>
   *
   * @param {object} response
   * @returns {App.ModalPopup}
   * @method _showSettingsPopup
   * @private
   */
  _showSettingsPopup: function (response) {
    var curValue = null;
    var self = this;
    var keys = this.get('userSettingsKeys');
    var timezonesFormatted = timezoneUtils.get('timezones');
    var initValue = JSON.parse(response[keys.show_bg.name]);
    var initTimezone = timezonesFormatted.findProperty('value', JSON.parse(response[keys.timezone.name]));
    return App.ModalPopup.show({

      header: Em.I18n.t('common.userSettings'),

      bodyClass: Em.View.extend({

        templateName: require('templates/common/settings'),

        isNotShowBgChecked: !initValue,

        updateValue: function () {
          curValue = !this.get('isNotShowBgChecked');
        }.observes('isNotShowBgChecked'),

        timezonesList: timezonesFormatted,

        privileges: self.get('privileges'),

        isAdmin: App.get('isAmbariAdmin')
      }),

      /**
       * @type {string}
       */
      selectedTimezone: initTimezone,

      primary: Em.I18n.t('common.save'),

      onPrimary: function() {
        if (Em.isNone(curValue)) {
          curValue = initValue;
        }
        if (!App.get('testMode')) {
          self.postUserPref('show_bg', curValue);
          self.postUserPref('timezone', this.get('selectedTimezone.value'));
        }
        if (this.needsPageRefresh()) {
          location.reload();
        }
        this._super();
      },

      /**
       * Determines if page should be refreshed after user click "Save"
       *
       * @returns {boolean}
       */
      needsPageRefresh: function () {
        return initTimezone !== this.get('selectedTimezone');
      }

    })
  }

});