2017-10-29 01:13:06 +00:00
|
|
|
/*
|
|
|
|
Copyright 2017 Travis Ralston
|
|
|
|
|
|
|
|
Licensed 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
import Promise from 'bluebird';
|
|
|
|
import DeviceSettingsHandler from "./DeviceSettingsHandler";
|
|
|
|
import RoomDeviceSettingsHandler from "./RoomDeviceSettingsHandler";
|
|
|
|
import DefaultSettingsHandler from "./DefaultSettingsHandler";
|
|
|
|
import RoomAccountSettingsHandler from "./RoomAccountSettingsHandler";
|
|
|
|
import AccountSettingsHandler from "./AccountSettingsHandler";
|
|
|
|
import RoomSettingsHandler from "./RoomSettingsHandler";
|
|
|
|
import ConfigSettingsHandler from "./ConfigSettingsHandler";
|
2017-11-04 05:19:45 +00:00
|
|
|
import {_t} from '../languageHandler';
|
2017-10-29 01:13:06 +00:00
|
|
|
import SdkConfig from "../SdkConfig";
|
2017-11-04 05:19:45 +00:00
|
|
|
import {SETTINGS} from "./Settings";
|
2017-11-05 03:32:00 +00:00
|
|
|
import LocalEchoWrapper from "./LocalEchoWrapper";
|
2017-10-29 01:13:06 +00:00
|
|
|
|
2017-11-04 05:19:45 +00:00
|
|
|
/**
|
|
|
|
* Represents the various setting levels supported by the SettingsStore.
|
|
|
|
*/
|
|
|
|
export const SettingLevel = {
|
|
|
|
// Note: This enum is not used in this class or in the Settings file
|
|
|
|
// This should always be used elsewhere in the project.
|
|
|
|
DEVICE: "device",
|
|
|
|
ROOM_DEVICE: "room-device",
|
|
|
|
ROOM_ACCOUNT: "room-account",
|
|
|
|
ACCOUNT: "account",
|
|
|
|
ROOM: "room",
|
|
|
|
CONFIG: "config",
|
|
|
|
DEFAULT: "default",
|
2017-10-29 01:13:06 +00:00
|
|
|
};
|
|
|
|
|
2017-11-04 05:19:45 +00:00
|
|
|
// Convert the settings to easier to manage objects for the handlers
|
2017-10-29 01:53:12 +00:00
|
|
|
const defaultSettings = {};
|
|
|
|
const featureNames = [];
|
|
|
|
for (const key of Object.keys(SETTINGS)) {
|
2017-10-29 02:21:34 +00:00
|
|
|
defaultSettings[key] = SETTINGS[key].default;
|
2017-10-29 01:13:06 +00:00
|
|
|
if (SETTINGS[key].isFeature) featureNames.push(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
const LEVEL_HANDLERS = {
|
|
|
|
"device": new DeviceSettingsHandler(featureNames),
|
|
|
|
"room-device": new RoomDeviceSettingsHandler(),
|
|
|
|
"room-account": new RoomAccountSettingsHandler(),
|
|
|
|
"account": new AccountSettingsHandler(),
|
|
|
|
"room": new RoomSettingsHandler(),
|
|
|
|
"config": new ConfigSettingsHandler(),
|
|
|
|
"default": new DefaultSettingsHandler(defaultSettings),
|
|
|
|
};
|
|
|
|
|
2017-11-05 03:32:00 +00:00
|
|
|
// Wrap all the handlers with local echo
|
|
|
|
for (const key of Object.keys(LEVEL_HANDLERS)) {
|
|
|
|
LEVEL_HANDLERS[key] = new LocalEchoWrapper(LEVEL_HANDLERS[key]);
|
|
|
|
}
|
|
|
|
|
2017-10-30 02:44:00 +00:00
|
|
|
const LEVEL_ORDER = [
|
|
|
|
'device', 'room-device', 'room-account', 'account', 'room', 'config', 'default',
|
|
|
|
];
|
|
|
|
|
2017-10-29 01:13:06 +00:00
|
|
|
/**
|
|
|
|
* Controls and manages application settings by providing varying levels at which the
|
|
|
|
* setting value may be specified. The levels are then used to determine what the setting
|
|
|
|
* value should be given a set of circumstances. The levels, in priority order, are:
|
|
|
|
* - "device" - Values are determined by the current device
|
|
|
|
* - "room-device" - Values are determined by the current device for a particular room
|
|
|
|
* - "room-account" - Values are determined by the current account for a particular room
|
|
|
|
* - "account" - Values are determined by the current account
|
|
|
|
* - "room" - Values are determined by a particular room (by the room admins)
|
|
|
|
* - "config" - Values are determined by the config.json
|
|
|
|
* - "default" - Values are determined by the hardcoded defaults
|
|
|
|
*
|
|
|
|
* Each level has a different method to storing the setting value. For implementation
|
|
|
|
* specific details, please see the handlers. The "config" and "default" levels are
|
|
|
|
* both always supported on all platforms. All other settings should be guarded by
|
|
|
|
* isLevelSupported() prior to attempting to set the value.
|
|
|
|
*
|
|
|
|
* Settings can also represent features. Features are significant portions of the
|
|
|
|
* application that warrant a dedicated setting to toggle them on or off. Features are
|
|
|
|
* special-cased to ensure that their values respect the configuration (for example, a
|
|
|
|
* feature may be reported as disabled even though a user has specifically requested it
|
|
|
|
* be enabled).
|
|
|
|
*/
|
|
|
|
export default class SettingsStore {
|
|
|
|
/**
|
|
|
|
* Gets the translated display name for a given setting
|
|
|
|
* @param {string} settingName The setting to look up.
|
2017-10-30 03:48:29 +00:00
|
|
|
* @param {"device"|"room-device"|"room-account"|"account"|"room"|"config"|"default"} atLevel
|
|
|
|
* The level to get the display name for; Defaults to 'default'.
|
2017-10-29 01:13:06 +00:00
|
|
|
* @return {String} The display name for the setting, or null if not found.
|
|
|
|
*/
|
2017-10-30 03:48:29 +00:00
|
|
|
static getDisplayName(settingName, atLevel = "default") {
|
2017-10-29 01:13:06 +00:00
|
|
|
if (!SETTINGS[settingName] || !SETTINGS[settingName].displayName) return null;
|
2017-10-30 03:48:29 +00:00
|
|
|
|
|
|
|
let displayName = SETTINGS[settingName].displayName;
|
|
|
|
if (displayName instanceof Object) {
|
|
|
|
if (displayName[atLevel]) displayName = displayName[atLevel];
|
|
|
|
else displayName = displayName["default"];
|
|
|
|
}
|
|
|
|
|
|
|
|
return _t(displayName);
|
2017-10-29 01:13:06 +00:00
|
|
|
}
|
|
|
|
|
2017-10-29 02:21:34 +00:00
|
|
|
/**
|
|
|
|
* Returns a list of all available labs feature names
|
|
|
|
* @returns {string[]} The list of available feature names
|
|
|
|
*/
|
|
|
|
static getLabsFeatures() {
|
|
|
|
const possibleFeatures = Object.keys(SETTINGS).filter((s) => SettingsStore.isFeature(s));
|
|
|
|
|
|
|
|
const enableLabs = SdkConfig.get()["enableLabs"];
|
|
|
|
if (enableLabs) return possibleFeatures;
|
|
|
|
|
|
|
|
return possibleFeatures.filter((s) => SettingsStore._getFeatureState(s) === "labs");
|
|
|
|
}
|
|
|
|
|
2017-10-29 01:13:06 +00:00
|
|
|
/**
|
|
|
|
* Determines if a setting is also a feature.
|
|
|
|
* @param {string} settingName The setting to look up.
|
|
|
|
* @return {boolean} True if the setting is a feature.
|
|
|
|
*/
|
|
|
|
static isFeature(settingName) {
|
|
|
|
if (!SETTINGS[settingName]) return false;
|
|
|
|
return SETTINGS[settingName].isFeature;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determines if a given feature is enabled. The feature given must be a known
|
|
|
|
* feature.
|
|
|
|
* @param {string} settingName The name of the setting that is a feature.
|
|
|
|
* @param {String} roomId The optional room ID to validate in, may be null.
|
|
|
|
* @return {boolean} True if the feature is enabled, false otherwise
|
|
|
|
*/
|
|
|
|
static isFeatureEnabled(settingName, roomId = null) {
|
|
|
|
if (!SettingsStore.isFeature(settingName)) {
|
|
|
|
throw new Error("Setting " + settingName + " is not a feature");
|
|
|
|
}
|
|
|
|
|
2017-10-29 01:53:12 +00:00
|
|
|
return SettingsStore.getValue(settingName, roomId);
|
2017-10-29 01:13:06 +00:00
|
|
|
}
|
|
|
|
|
2017-10-29 02:21:34 +00:00
|
|
|
/**
|
|
|
|
* Sets a feature as enabled or disabled on the current device.
|
|
|
|
* @param {string} settingName The name of the setting.
|
|
|
|
* @param {boolean} value True to enable the feature, false otherwise.
|
|
|
|
* @returns {Promise} Resolves when the setting has been set.
|
|
|
|
*/
|
|
|
|
static setFeatureEnabled(settingName, value) {
|
2017-11-04 21:46:15 +00:00
|
|
|
// Verify that the setting is actually a setting
|
|
|
|
if (!SETTINGS[settingName]) {
|
|
|
|
throw new Error("Setting '" + settingName + "' does not appear to be a setting.");
|
|
|
|
}
|
|
|
|
|
2017-10-29 02:21:34 +00:00
|
|
|
return SettingsStore.setValue(settingName, null, "device", value);
|
|
|
|
}
|
|
|
|
|
2017-10-29 01:13:06 +00:00
|
|
|
/**
|
|
|
|
* Gets the value of a setting. The room ID is optional if the setting is not to
|
|
|
|
* be applied to any particular room, otherwise it should be supplied.
|
|
|
|
* @param {string} settingName The name of the setting to read the value of.
|
|
|
|
* @param {String} roomId The room ID to read the setting value in, may be null.
|
2017-11-04 22:38:26 +00:00
|
|
|
* @param {boolean} excludeDefault True to disable using the default value.
|
2017-10-29 01:45:48 +00:00
|
|
|
* @return {*} The value, or null if not found
|
2017-10-29 01:13:06 +00:00
|
|
|
*/
|
2017-11-04 22:38:26 +00:00
|
|
|
static getValue(settingName, roomId = null, excludeDefault = false) {
|
|
|
|
return SettingsStore.getValueAt(LEVEL_ORDER[0], settingName, roomId, false, excludeDefault);
|
2017-10-30 02:44:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets a setting's value at a particular level, ignoring all levels that are more specific.
|
|
|
|
* @param {"device"|"room-device"|"room-account"|"account"|"room"} level The level to
|
|
|
|
* look at.
|
|
|
|
* @param {string} settingName The name of the setting to read.
|
|
|
|
* @param {String} roomId The room ID to read the setting value in, may be null.
|
2017-10-31 01:49:44 +00:00
|
|
|
* @param {boolean} explicit If true, this method will not consider other levels, just the one
|
|
|
|
* provided. Defaults to false.
|
2017-11-04 22:38:26 +00:00
|
|
|
* @param {boolean} excludeDefault True to disable using the default value.
|
2017-10-30 02:44:00 +00:00
|
|
|
* @return {*} The value, or null if not found.
|
|
|
|
*/
|
2017-11-04 22:38:26 +00:00
|
|
|
static getValueAt(level, settingName, roomId = null, explicit = false, excludeDefault = false) {
|
2017-10-30 02:44:00 +00:00
|
|
|
const minIndex = LEVEL_ORDER.indexOf(level);
|
|
|
|
if (minIndex === -1) throw new Error("Level " + level + " is not prioritized");
|
2017-10-29 01:13:06 +00:00
|
|
|
|
2017-11-04 21:46:15 +00:00
|
|
|
// Verify that the setting is actually a setting
|
|
|
|
if (!SETTINGS[settingName]) {
|
|
|
|
throw new Error("Setting '" + settingName + "' does not appear to be a setting.");
|
|
|
|
}
|
|
|
|
|
2017-10-29 01:13:06 +00:00
|
|
|
if (SettingsStore.isFeature(settingName)) {
|
|
|
|
const configValue = SettingsStore._getFeatureState(settingName);
|
2017-10-29 01:45:48 +00:00
|
|
|
if (configValue === "enable") return true;
|
|
|
|
if (configValue === "disable") return false;
|
2017-10-29 01:13:06 +00:00
|
|
|
// else let it fall through the default process
|
|
|
|
}
|
|
|
|
|
|
|
|
const handlers = SettingsStore._getHandlers(settingName);
|
|
|
|
|
2017-10-31 01:49:44 +00:00
|
|
|
if (explicit) {
|
|
|
|
let handler = handlers[level];
|
|
|
|
if (!handler) return null;
|
|
|
|
return handler.getValue(settingName, roomId);
|
|
|
|
}
|
|
|
|
|
2017-10-30 02:44:00 +00:00
|
|
|
for (let i = minIndex; i < LEVEL_ORDER.length; i++) {
|
|
|
|
let handler = handlers[LEVEL_ORDER[i]];
|
2017-10-29 01:45:48 +00:00
|
|
|
if (!handler) continue;
|
2017-11-04 22:38:26 +00:00
|
|
|
if (excludeDefault && LEVEL_ORDER[i] === "default") continue;
|
2017-10-29 01:13:06 +00:00
|
|
|
|
2017-10-29 01:45:48 +00:00
|
|
|
const value = handler.getValue(settingName, roomId);
|
2017-10-29 07:43:52 +00:00
|
|
|
if (value === null || value === undefined) continue;
|
2017-10-29 01:45:48 +00:00
|
|
|
return value;
|
|
|
|
}
|
2017-10-29 01:13:06 +00:00
|
|
|
|
2017-10-30 02:44:00 +00:00
|
|
|
return null;
|
2017-10-29 22:02:51 +00:00
|
|
|
}
|
|
|
|
|
2017-10-29 01:13:06 +00:00
|
|
|
/**
|
|
|
|
* Sets the value for a setting. The room ID is optional if the setting is not being
|
|
|
|
* set for a particular room, otherwise it should be supplied. The value may be null
|
|
|
|
* to indicate that the level should no longer have an override.
|
|
|
|
* @param {string} settingName The name of the setting to change.
|
|
|
|
* @param {String} roomId The room ID to change the value in, may be null.
|
|
|
|
* @param {"device"|"room-device"|"room-account"|"account"|"room"} level The level
|
|
|
|
* to change the value at.
|
2017-10-29 01:45:48 +00:00
|
|
|
* @param {*} value The new value of the setting, may be null.
|
2017-10-29 01:13:06 +00:00
|
|
|
* @return {Promise} Resolves when the setting has been changed.
|
|
|
|
*/
|
|
|
|
static setValue(settingName, roomId, level, value) {
|
2017-11-04 21:46:15 +00:00
|
|
|
// Verify that the setting is actually a setting
|
|
|
|
if (!SETTINGS[settingName]) {
|
|
|
|
throw new Error("Setting '" + settingName + "' does not appear to be a setting.");
|
|
|
|
}
|
|
|
|
|
2017-10-29 01:13:06 +00:00
|
|
|
const handler = SettingsStore._getHandler(settingName, level);
|
|
|
|
if (!handler) {
|
|
|
|
throw new Error("Setting " + settingName + " does not have a handler for " + level);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!handler.canSetValue(settingName, roomId)) {
|
2017-10-30 03:48:29 +00:00
|
|
|
throw new Error("User cannot set " + settingName + " at " + level + " in " + roomId);
|
2017-10-29 01:13:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return handler.setValue(settingName, roomId, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determines if the current user is permitted to set the given setting at the given
|
|
|
|
* level for a particular room. The room ID is optional if the setting is not being
|
|
|
|
* set for a particular room, otherwise it should be supplied.
|
|
|
|
* @param {string} settingName The name of the setting to check.
|
|
|
|
* @param {String} roomId The room ID to check in, may be null.
|
|
|
|
* @param {"device"|"room-device"|"room-account"|"account"|"room"} level The level to
|
|
|
|
* check at.
|
|
|
|
* @return {boolean} True if the user may set the setting, false otherwise.
|
|
|
|
*/
|
|
|
|
static canSetValue(settingName, roomId, level) {
|
2017-11-04 21:46:15 +00:00
|
|
|
// Verify that the setting is actually a setting
|
|
|
|
if (!SETTINGS[settingName]) {
|
|
|
|
throw new Error("Setting '" + settingName + "' does not appear to be a setting.");
|
|
|
|
}
|
|
|
|
|
2017-10-29 01:13:06 +00:00
|
|
|
const handler = SettingsStore._getHandler(settingName, level);
|
|
|
|
if (!handler) return false;
|
|
|
|
return handler.canSetValue(settingName, roomId);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determines if the given level is supported on this device.
|
|
|
|
* @param {"device"|"room-device"|"room-account"|"account"|"room"} level The level
|
|
|
|
* to check the feasibility of.
|
|
|
|
* @return {boolean} True if the level is supported, false otherwise.
|
|
|
|
*/
|
|
|
|
static isLevelSupported(level) {
|
|
|
|
if (!LEVEL_HANDLERS[level]) return false;
|
|
|
|
return LEVEL_HANDLERS[level].isSupported();
|
|
|
|
}
|
|
|
|
|
|
|
|
static _getHandler(settingName, level) {
|
|
|
|
const handlers = SettingsStore._getHandlers(settingName);
|
|
|
|
if (!handlers[level]) return null;
|
|
|
|
return handlers[level];
|
|
|
|
}
|
|
|
|
|
|
|
|
static _getHandlers(settingName) {
|
|
|
|
if (!SETTINGS[settingName]) return {};
|
|
|
|
|
|
|
|
const handlers = {};
|
2017-10-29 02:21:34 +00:00
|
|
|
for (const level of SETTINGS[settingName].supportedLevels) {
|
2017-10-29 01:13:06 +00:00
|
|
|
if (!LEVEL_HANDLERS[level]) throw new Error("Unexpected level " + level);
|
|
|
|
handlers[level] = LEVEL_HANDLERS[level];
|
|
|
|
}
|
|
|
|
|
2017-10-29 23:08:39 +00:00
|
|
|
// Always support 'default'
|
|
|
|
if (!handlers['default']) handlers['default'] = LEVEL_HANDLERS['default'];
|
|
|
|
|
2017-10-29 01:13:06 +00:00
|
|
|
return handlers;
|
|
|
|
}
|
|
|
|
|
|
|
|
static _getFeatureState(settingName) {
|
|
|
|
const featuresConfig = SdkConfig.get()['features'];
|
|
|
|
const enableLabs = SdkConfig.get()['enableLabs']; // we'll honour the old flag
|
|
|
|
|
|
|
|
let featureState = enableLabs ? "labs" : "disable";
|
|
|
|
if (featuresConfig && featuresConfig[settingName] !== undefined) {
|
|
|
|
featureState = featuresConfig[settingName];
|
|
|
|
}
|
|
|
|
|
|
|
|
const allowedStates = ['enable', 'disable', 'labs'];
|
2017-10-29 02:21:34 +00:00
|
|
|
if (!allowedStates.includes(featureState)) {
|
2017-10-29 01:13:06 +00:00
|
|
|
console.warn("Feature state '" + featureState + "' is invalid for " + settingName);
|
|
|
|
featureState = "disable"; // to prevent accidental features.
|
|
|
|
}
|
|
|
|
|
|
|
|
return featureState;
|
|
|
|
}
|
|
|
|
}
|