Ghost/ghost/admin/app/controllers/settings/general.js

import classic from 'ember-classic-decorator';
import {action, computed} from '@ember/object';
import {inject as service} from '@ember/service';
/* eslint-disable ghost/ember/alias-model-in-controller */
import Controller from '@ember/controller';
import generatePassword from 'ghost-admin/utils/password-generator';
import validator from 'validator';
import {
    IMAGE_EXTENSIONS,
    IMAGE_MIME_TYPES
} from 'ghost-admin/components/gh-image-uploader';
import {task} from 'ember-concurrency';

function randomPassword() {
    let word = generatePassword(6);
    let randomN = Math.floor(Math.random() * 1000);

    return word + randomN;
}

@classic
export default class GeneralController extends Controller {
    @service config;
    @service ghostPaths;
    @service notifications;
    @service session;
    @service settings;
    @service frontend;
    @service ui;

    availableTimezones = null;
    imageExtensions = IMAGE_EXTENSIONS;
    imageMimeTypes = IMAGE_MIME_TYPES;
    _scratchFacebook = null;
    _scratchTwitter = null;

    @computed('config.blogUrl', 'settings.publicHash')
    get privateRSSUrl() {
        let blogUrl = this.get('config.blogUrl');
        let publicHash = this.get('settings.publicHash');

        return `${blogUrl}/${publicHash}/rss`;
    }

    @action
    save() {
        this.saveTask.perform();
    }

    @action
    setTimezone(timezone) {
        this.set('settings.timezone', timezone.name);
    }

    @action
    removeImage(image) {
        // setting `null` here will error as the server treats it as "null"
        this.settings.set(image, '');
    }

    /**
     * Opens a file selection dialog - Triggered by "Upload Image" buttons,
     * searches for the hidden file input within the .gh-setting element
     * containing the clicked button then simulates a click
     * @param  {MouseEvent} event - MouseEvent fired by the button click
     */
    @action
    triggerFileDialog(event) {
        event?.target.closest('.gh-setting-action')?.querySelector('input[type="file"]')?.click();
    }

    /**
     * Fired after an image upload completes
     * @param  {string} property - Property name to be set on `this.settings`
     * @param  {UploadResult[]} results - Array of UploadResult objects
     * @return {string} The URL that was set on `this.settings.property`
     */
    @action
    imageUploaded(property, results) {
        if (results[0]) {
            return this.settings.set(property, results[0].url);
        }
    }

    @action
    toggleIsPrivate(isPrivate) {
        let settings = this.settings;

        settings.set('isPrivate', isPrivate);
        settings.get('errors').remove('password');

        let changedAttrs = settings.changedAttributes();

        // set a new random password when isPrivate is enabled
        if (isPrivate && changedAttrs.isPrivate) {
            settings.set('password', randomPassword());

        // reset the password when isPrivate is disabled
        } else if (changedAttrs.password) {
            settings.set('password', changedAttrs.password[0]);
        }
    }

    @action
    validateFacebookUrl() {
        let newUrl = this._scratchFacebook;
        let errMessage = '';

        // reset errors and validation
        this.get('settings.errors').remove('facebook');
        this.get('settings.hasValidated').removeObject('facebook');

        if (!newUrl) {
            // Clear out the Facebook url
            this.set('settings.facebook', null);
            return;
        }

        try {
            // strip any facebook URLs out
            newUrl = newUrl.replace(/(https?:\/\/)?(www\.)?facebook\.com/i, '');

            // don't allow any non-facebook urls
            if (newUrl.match(/^(http|\/\/)/i)) {
                throw 'invalid url';
            }

            // strip leading / if we have one then concat to full facebook URL
            newUrl = newUrl.replace(/^\//, '');
            newUrl = `https://www.facebook.com/${newUrl}`;

            // don't allow URL if it's not valid
            if (!validator.isURL(newUrl)) {
                throw 'invalid url';
            }

            this.settings.set('facebook', newUrl);
            this.settings.notifyPropertyChange('facebook');
        } catch (e) {
            if (e === 'invalid url') {
                errMessage = 'The URL must be in a format like '
                           + 'https://www.facebook.com/yourPage';
                this.get('settings.errors').add('facebook', errMessage);
                return;
            }

            throw e;
        } finally {
            this.get('settings.hasValidated').pushObject('facebook');
        }
    }

    @action
    validateTwitterUrl() {
        let newUrl = this._scratchTwitter;
        let errMessage = '';

        // reset errors and validation
        this.get('settings.errors').remove('twitter');
        this.get('settings.hasValidated').removeObject('twitter');

        if (!newUrl) {
            // Clear out the Twitter url
            this.set('settings.twitter', '');
            return;
        }

        if (newUrl.match(/(?:twitter\.com\/)(\S+)/) || newUrl.match(/([a-z\d.]+)/i)) {
            let username = [];

            if (newUrl.match(/(?:twitter\.com\/)(\S+)/)) {
                [, username] = newUrl.match(/(?:twitter\.com\/)(\S+)/);
            } else {
                [username] = newUrl.match(/([^/]+)\/?$/mi);
            }

            // check if username starts with http or www and show error if so
            if (username.match(/^(http|www)|(\/)/) || !username.match(/^[a-z\d._]{1,15}$/mi)) {
                errMessage = !username.match(/^[a-z\d._]{1,15}$/mi) ? 'Your Username is not a valid Twitter Username' : 'The URL must be in a format like https://twitter.com/yourUsername';

                this.get('settings.errors').add('twitter', errMessage);
                this.get('settings.hasValidated').pushObject('twitter');
                return;
            }

            newUrl = `https://twitter.com/${username}`;

            this.settings.get('hasValidated').pushObject('twitter');
            this.settings.set('twitter', newUrl);
            this.settings.notifyPropertyChange('twitter');
        } else {
            errMessage = 'The URL must be in a format like '
                       + 'https://twitter.com/yourUsername';
            this.get('settings.errors').add('twitter', errMessage);
            this.get('settings.hasValidated').pushObject('twitter');
            return;
        }
    }

    _deleteTheme() {
        let theme = this.store.peekRecord('theme', this.themeToDelete.name);

        if (!theme) {
            return;
        }

        return theme.destroyRecord().catch((error) => {
            this.notifications.showAPIError(error);
        });
    }

    @task(function* () {
        let notifications = this.notifications;
        let config = this.config;

        if (this.settings.get('twitter') !== this._scratchTwitter) {
            this.send('validateTwitterUrl');
        }

        if (this.settings.get('facebook') !== this._scratchFacebook) {
            this.send('validateFacebookUrl');
        }

        try {
            let changedAttrs = this.settings.changedAttributes();
            let settings = yield this.settings.save();
            config.set('blogTitle', settings.get('title'));
            if (changedAttrs.password) {
                this.frontend.loginIfNeeded();
            }
            // this forces the document title to recompute after a blog title change
            this.ui.updateDocumentTitle();

            return settings;
        } catch (error) {
            if (error) {
                notifications.showAPIError(error, {key: 'settings.save'});
            }
            throw error;
        }
    })
        saveTask;
}