element-web/src/UserSettingsStore.js

/*
Copyright 2015, 2016 OpenMarket Ltd

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 MatrixClientPeg from './MatrixClientPeg';
import Notifier from './Notifier';
import { _t } from './languageHandler';

/*
 * TODO: Make things use this. This is all WIP - see UserSettings.js for usage.
 */

export default {
    LABS_FEATURES: [
        {
            name: "-",
            id: 'matrix_apps',
            default: true,

            // XXX: Always use default, ignore localStorage and remove from labs
            override: true,
        },
    ],

    // horrible but it works. The locality makes this somewhat more palatable.
    doTranslations: function() {
        this.LABS_FEATURES[0].name = _t("Matrix Apps");
    },

    loadProfileInfo: function() {
        const cli = MatrixClientPeg.get();
        return cli.getProfileInfo(cli.credentials.userId);
    },

    saveDisplayName: function(newDisplayname) {
        return MatrixClientPeg.get().setDisplayName(newDisplayname);
    },

    loadThreePids: function() {
        if (MatrixClientPeg.get().isGuest()) {
            return Promise.resolve({
                threepids: [],
            }); // guests can't poke 3pid endpoint
        }
        return MatrixClientPeg.get().getThreePids();
    },

    saveThreePids: function(threePids) {
        // TODO
    },

    getEnableNotifications: function() {
        return Notifier.isEnabled();
    },

    setEnableNotifications: function(enable) {
        if (!Notifier.supportsDesktopNotifications()) {
            return;
        }
        Notifier.setEnabled(enable);
    },

    getEnableAudioNotifications: function() {
        return Notifier.isAudioEnabled();
    },

    setEnableAudioNotifications: function(enable) {
        Notifier.setAudioEnabled(enable);
    },

    changePassword: function(oldPassword, newPassword) {
        const cli = MatrixClientPeg.get();

        const authDict = {
            type: 'm.login.password',
            user: cli.credentials.userId,
            password: oldPassword,
        };

        return cli.setPassword(authDict, newPassword);
    },

    /*
     * Returns the email pusher (pusher of type 'email') for a given
     * email address. Email pushers all have the same app ID, so since
     * pushers are unique over (app ID, pushkey), there will be at most
     * one such pusher.
     */
    getEmailPusher: function(pushers, address) {
        if (pushers === undefined) {
            return undefined;
        }
        for (let i = 0; i < pushers.length; ++i) {
            if (pushers[i].kind === 'email' && pushers[i].pushkey === address) {
                return pushers[i];
            }
        }
        return undefined;
    },

    hasEmailPusher: function(pushers, address) {
        return this.getEmailPusher(pushers, address) !== undefined;
    },

    addEmailPusher: function(address, data) {
        return MatrixClientPeg.get().setPusher({
            kind: 'email',
            app_id: 'm.email',
            pushkey: address,
            app_display_name: 'Email Notifications',
            device_display_name: address,
            lang: navigator.language,
            data: data,
            append: true,  // We always append for email pushers since we don't want to stop other accounts notifying to the same email address
        });
    },

    getUrlPreviewsDisabled: function() {
        const event = MatrixClientPeg.get().getAccountData('org.matrix.preview_urls');
        return (event && event.getContent().disable);
    },

    setUrlPreviewsDisabled: function(disabled) {
        // FIXME: handle errors
        return MatrixClientPeg.get().setAccountData('org.matrix.preview_urls', {
            disable: disabled,
        });
    },

    getSyncedSettings: function() {
        const event = MatrixClientPeg.get().getAccountData('im.vector.web.settings');
        return event ? event.getContent() : {};
    },

    getSyncedSetting: function(type, defaultValue = null) {
        const settings = this.getSyncedSettings();
        return settings.hasOwnProperty(type) ? settings[type] : defaultValue;
    },

    setSyncedSetting: function(type, value) {
        const settings = this.getSyncedSettings();
        settings[type] = value;
        // FIXME: handle errors
        return MatrixClientPeg.get().setAccountData('im.vector.web.settings', settings);
    },

    getLocalSettings: function() {
        const localSettingsString = localStorage.getItem('mx_local_settings') || '{}';
        return JSON.parse(localSettingsString);
    },

    getLocalSetting: function(type, defaultValue = null) {
        const settings = this.getLocalSettings();
        return settings.hasOwnProperty(type) ? settings[type] : defaultValue;
    },

    setLocalSetting: function(type, value) {
        const settings = this.getLocalSettings();
        settings[type] = value;
        // FIXME: handle errors
        localStorage.setItem('mx_local_settings', JSON.stringify(settings));
    },

    getFeatureById(feature: string) {
        for (let i = 0; i < this.LABS_FEATURES.length; i++) {
            const f = this.LABS_FEATURES[i];
            if (f.id === feature) {
                return f;
            }
        }
        return null;
    },

    isFeatureEnabled: function(featureId: string): boolean {
        // Disable labs for guests.
        if (MatrixClientPeg.get().isGuest()) return false;

        const feature = this.getFeatureById(featureId);
        if (!feature) {
            console.warn(`Unknown feature "${featureId}"`);
            return false;
        }
        // Return the default if this feature has an override to be the default value or
        // if the feature has never been toggled and is therefore not in localStorage
        if (Object.keys(feature).includes('override') ||
            localStorage.getItem(`mx_labs_feature_${featureId}`) === null
        ) {
            return feature.default;
        }
        return localStorage.getItem(`mx_labs_feature_${featureId}`) === 'true';
    },

    setFeatureEnabled: function(featureId: string, enabled: boolean) {
        localStorage.setItem(`mx_labs_feature_${featureId}`, enabled);
    },
};