contextmenu_folder.php

<?php

// Plugin: contextmenu_folder
// Roundcube Context Menu Folder Manager
// Adds context menus with mailbox operations
class contextmenu_folder extends rcube_plugin
{

    // supported filters
    private static $filter_type_list = array(
        'unread',
        'special',
        'selected',
        'transient',
        'predefined'
    );

    // client environment variables, push/pull
    private static $allowed_names = array(
        'show_mode',
        'collect_special',
        'collect_selected',
        'collect_transient',
        'collect_predefined',
        'memento_current_mailbox',
        'memento_current_message',
        'memento_folder_locate_text',
        'memento_contact_parent_item',
        'memento_contact_header_item',
        'memento_contact_format_item'
    );

    // client environment variables, push only
    private static $environ_names = array(
        'activate_plugin',
        'enable_logging',
        'enable_refresh',
        'enable_folder_list_context_menu',
        'enable_folder_list_control_menu',
        'enable_message_list_context_menu',
        'filter_active',
        'filter_favorite',
        'contact_folder_format_list',
        'feature_choice',
        'icon_mapa',
        'allow_purge_regex',
        'hide_ctrl_menu_list',
        'hide_mbox_menu_list',
        'hide_mesg_menu_list',
        'transient_expire_mins'
    );

    // plugin ajax registered actions
    private static $action_names = array(
        'header_list',
        'folder_list',
        'folder_create',
        'folder_delete',
        'folder_rename',
        'folder_purge',
        'folder_scan_tree'
    );

    const ROOT = '';

    // root of mailbox hierarchy
    public $task = 'mail|settings';

    // supported tasks regex filter
    public $allowed_prefs = array();

    // see: rcube_plugin->$allowed_prefs
    private $config_default = array();

    // default plugin configuration
    private $rc;

    // controller singleton

    // early instace init
    function onload()
    { // rcube_plugin_api.load_plugin()
        $this->provide_allowed_prefs();
    }

    // final instace init
    function init()
    { // rcube_plugin.init()
        $this->rc = rcmail::get_instance();
        $this->require_plugin('jqueryui');
        $this->require_plugin('contextmenu');
        $task = $this->rc->task;
        $action = $this->rc->action;

        if ($task == 'mail' && $this->is_root_request()) {
            // periodic client pull
            if ($action == 'refresh') {
                $this->init_config();
                $this->log('client pull');
                $this->init_refresh_hook();
                return;
            }
            // plugin ajax action post
            if (strpos($action, $this->key('')) === 0) {
                $this->init_config();
                $this->log('action post: ' . $action);
                $this->init_mail_action();
                return;
            }
            // application window load
            if ($action == '' && $this->is_html_request()) {
                $this->init_config();
                $this->log('window load');
                $this->init_mail_hook();
                $this->init_mail_html_page();
                return;
            }
            return;
        }

        if ($task == 'settings') {
            $this->init_config();
            $this->log('settings');
            $this->init_settings_hook();
            $this->init_settings_html_page();
            return;
        }
    }

    // //////////////////////////

    // plugin name space
    function key($name)
    {
        return 'plugin.contextmenu_folder.' . $name; // keep in sync with *.js
    }

    // plugin server logger
    function log($line, $force = false)
    {
        if ($this->config_get('enable_logging') || $force) {
            $head = $this->key('');
            $file = $this->key('log');
            $func = debug_backtrace()[1]['function'];
            $text = $head . $func . ' : ' . $line;
            rcube::write_log($file, $text);
        }
    }

    // convert text to UTF7-IMAP
    static function utf7convert($mbox)
    {
        return mb_convert_encoding($mbox, 'UTF7-IMAP');
    }

    // localized quoted text
    function quoted($name)
    {
        return rcube::Q($this->gettext($name));
    }

    // load plugin preferences
    function config_get($name)
    {
        $key = $this->key($name);
        return $this->rc->config->get($key);
    }

    // save plugin preferences
    function config_put($name, $value)
    {
        $key = $this->key($name);
        $this->rc->user->save_prefs(array(
            $key => $value
        ));
    }

    // read client post result
    function input_value($name)
    {
        $name = str_replace('.', '_', $name); // PHP convention
        return rcube_utils::get_input_value($name, rcube_utils::INPUT_POST);
    }

    // imap backend storage mailbox separator
    function hierarchy_delimiter()
    {
        return $this->rc->storage->get_hierarchy_delimiter();
    }

    // verify if file is present at path
    function has_file($path)
    {
        return $path && is_file($path) && is_readable($path);
    }

    // load plugin default configuration file(s)
    function provide_config_default()
    {
        $config = null;
        $path = $this->home . '/' . 'config.inc.php.dist'; // rcube_plugin.home
        if ($this->has_file($path)) {
            ob_start();
            include ($path);
            ob_end_clean();
        }
        $path = $this->home . '/' . 'config.inc.php'; // rcube_plugin.home
        if ($this->has_file($path)) {
            ob_start();
            include ($path);
            ob_end_clean();
        }
        if (is_array($config)) {
            $this->config_default = $config;
        }
    }

    // //////////////////////////

    // setup config with default override
    function init_config()
    {
        // override rc->config->get
        $this->add_hook('config_get', array(
            $this,
            'hook_config_get'
        ));
        $this->provide_config_default();
        $this->provide_collect_special();
        $this->provide_collect_predefined();
    }

    // mail
    function init_mail_hook()
    {
        $this->add_hook('refresh', array(
            $this,
            'hook_refresh'
        ));
        $this->add_hook('preferences_update', array(
            $this,
            'hook_preferences_update'
        ));
    }

    // mail
    function init_mail_action()
    {
        foreach (self::$action_names as $name) {
            $this->register_action($this->key($name), array(
                $this,
                'action_' . $name
            ));
        }
    }

    // mail
    function init_mail_html_page()
    {
        $this->add_texts('localization', true);
        $this->include_script('contextmenu_folder.js');
        $this->include_stylesheet('assets/fontello/css/folder.css');
        $this->include_stylesheet('skins' . '/style.css');
        $this->include_stylesheet($this->local_skin_path() . '/style.css');
        $this->provide_client_env_var();
    }

    // refresh
    function init_refresh_hook()
    {
        $this->add_hook('new_messages', array(
            $this,
            'hook_new_messages'
        ));
    }

    // client environment variables
    function set_env($name, $value = null)
    {
        $key = $this->key($name);
        if (! isset($value)) {
            $value = $this->config_get($name);
        }
        $this->rc->output->set_env($key, $value);
    }

    // allow to save these prefs on demand
    function provide_allowed_prefs()
    {
        $allowed_prefs = array();
        foreach (self::$allowed_names as $name) {
            $allowed_prefs[] = $this->key($name);
        }
        $this->allowed_prefs = $allowed_prefs;
    }

    // client environment variables
    function provide_client_env_var()
    {
        $name_list = array_merge(self::$allowed_names, self::$environ_names);
        foreach ($name_list as $name) {
            $this->set_env($name);
        }
    }

    // root vs frame window request
    function is_root_request()
    {
        return empty($_REQUEST['_framed']);
    }

    // html vs ajax request
    function is_html_request()
    {
        return $this->rc->output->type == 'html';
    }

    // root vs frame window request
    function is_frame_request()
    {
        return isset($_REQUEST['_framed']);
    }

    // build list of imap special mailbox names
    function special_folder_list()
    {
        $storage = $this->rc->get_storage();
        $special_folders = $storage->get_special_folders();
        $folder_list = array_merge(array(
            'inbox' => 'INBOX'
        ), $special_folders);
        return $folder_list;
    }

    // mailbox descriptor in collection
    function mbox_meta($mbox = 'default', $action = 'default', $created_msec = 0)
    {
        $meta_info = array(
            'mbox' => $mbox,
            'action' => $action,
            'created_msec' => $created_msec
        );
        return $meta_info;
    }

    // rebuild 'special' mailbox collection from the configuration
    function provide_collect_special()
    {
        $collect_special = array();
        $mbox_list = $this->special_folder_list();
        foreach ($mbox_list as $mbox) {
            $collect_special[$mbox] = $this->mbox_meta($mbox);
        }
        $this->config_put('collect_special', $collect_special);
    }

    // rebuild 'predefined' mailbox collection from the configuration
    function provide_collect_predefined()
    {
        $collect_predefined = array();
        $mbox_list = $this->config_get('predefined_list');
        foreach ($mbox_list as $mbox) {
            $collect_predefined[$mbox] = $this->mbox_meta($mbox);
        }
        $this->config_put('collect_predefined', $collect_predefined);
    }

    // navigate mailbox hierarchy
    function parent_mbox($mbox)
    {
        $delimiter = $this->hierarchy_delimiter();
        if (strpos($mbox, $delimiter) === false) {
            return self::ROOT;
        } else {
            return substr($mbox, 0, strrpos($mbox, $delimiter));
        }
    }

    // detect imap special mailbox name
    function is_folder_special($name)
    {
        return $this->rc->storage->is_special_folder($name);
    }

    // find nubmer of unread messages in the mailbox
    function folder_count_unread($mbox)
    {
        $mode = 'UNSEEN';
        $force = true;
        $status = true;
        return $this->rc->storage->count($mbox, $mode, $force, $status);
    }

    // build mailbox filter flags from configuration
    function provide_filter($name)
    {
        $filter = array(); // $filter[type] = true|false
        $filter_keys = $this->config_get($name);
        foreach (self::$filter_type_list as $type) {
            $filter[$type] = in_array($type, $filter_keys);
        }
        return $filter;
    }

    // TODO periodic folder tree refresh
    function hook_refresh($args)
    {
        if ($this->config_get('enable_refresh')) {
            $this->log('TODO ');
            // $this->action_folder_list();
        }
        return $args;
    }

    // inject plugin default configuration
    function hook_config_get($args) // override rc->config->get
    {
        $name = $args['name']; // config key
        $result = $args['result']; // config value, global scope
        if (array_key_exists($name, $this->config_default)) {
            $default = $this->config_default[$name]; // config value, plugin scope
        } else {
            $default = null;
        }
        $has_global = isset($result);
        $has_plugin = isset($default);
        if (! $has_global && $has_plugin) {
            $args['result'] = $default; // use plugin default when global is not present
        }
        return $args;
    }

    // inspect prefs values, see rcube_user.php
    function hook_preferences_update($args)
    {
        // $this->log(print_r($args, true));
        return $args;
    }

    // notification for auto show 'unread' mailboxes
    function hook_new_messages($args)
    {
        $output = $this->rc->output;
        $output->command($this->key('folder_notify'), array(
            'folder' => $args['mailbox']
        ));
        // $output->send(); // executed elsewhere
        return $args;
    }

    // report back to client the change
    function folder_update($action, $source, $target)
    {
        $output = $this->rc->output;
        $status = array(
            'action' => $action,
            'source' => $source,
            'target' => $target
        );
        $this->log(print_r($status, true));
        $output->command($this->key('folder_update'), $status);
        $output->send();
    }

    // create complete folder tree, bottom up
    function folder_ensure_tree($target)
    {
        $storage = $this->rc->storage;
        if ($storage->folder_exists($target)) {
            return true;
        }
        $parent = $this->parent_mbox($target);
        if ($parent == self::ROOT || $storage->folder_exists($parent)) {
            return $storage->create_folder($target, true);
        }
        return $this->folder_ensure_tree($parent) && $storage->create_folder($target, true); // recurse
    }

    // create imap mailbox
    public function action_folder_create()
    {
        $output = $this->rc->output;
        $storage = $this->rc->storage;

        $source = '';
        $target = $this->input_value('target');
        // fix of UTF-8 and mUTF-7 imap folder name
        $target = $this->utf7convert($target);
        $result = $this->folder_ensure_tree($target);
        if ($result) {
            $this->folder_update('create', $source, $target);
        } else {
            $this->rc->display_server_error('error folder_create');
        }
    }

    // recursive delete tree bottom up
    // https://github.com/roundcube/roundcubemail/issues/5466
    function folder_delete($target)
    {
        $storage = $this->rc->storage;
        $delimiter = $this->hierarchy_delimiter();
        $pattern = $target . $delimiter . '%'; // own leaf only
        $folder_list = $storage->list_folders(self::ROOT, $pattern, 'mail', null, false);
        foreach ($folder_list as $folder) {
            if ($this->folder_delete($folder)) {
                continue;
            } else {
                return false;
            }
        }
        return $storage->delete_folder($target);
    }

    // delete imap mailbox
    public function action_folder_delete()
    {
        $output = $this->rc->output;
        $storage = $this->rc->storage;

        $source = '';
        $target = $this->input_value('target');
        $result = $this->folder_delete($target);
        // $result = $storage->delete_folder($target);
        if ($result) {
            $parent = $this->parent_mbox($target);
            if ($parent == self::ROOT) {
                $parent = 'INBOX';
            }
            $this->folder_update('delete', $source, $target);
        } else {
            $this->rc->display_server_error('error folder_delete');
        }
    }

    // rename imap mailbox
    public function action_folder_rename()
    {
        $output = $this->rc->output;
        $storage = $this->rc->storage;

        $source = $this->input_value('source');
        $target = $this->input_value('target');
        // fix of UTF-8 and mUTF-7 imap folder name
        $target = $this->utf7convert($target);
        $result = $storage->rename_folder($source, $target);
        if ($result) {
            $this->folder_update('rename', $source, $target);
        } else {
            $this->rc->display_server_error('error folder_rename');
        }
    }

    // empty imap folder of all messages
    public function action_folder_purge()
    {
        $output = $this->rc->output;
        $storage = $this->rc->storage;

        $source = $this->input_value('source');
        $target = $this->input_value('target');
        $result = $storage->clear_folder($target);
        if ($result) {
            $output->show_message('folderpurged', 'confirmation');
        } else {
            $this->rc->display_server_error('error folder_purge');
        }

        $output->command($this->key('folder_purge'), array());
        $output->send();
    }

    // produce flat, sorted, unfiltered, mailbox list
    public function action_folder_list()
    {
        $output = $this->rc->output;
        $storage = $this->rc->storage;

        $folder_list = $storage->list_folders();
        $output->command($this->key('folder_list'), array(
            'folder_list' => $folder_list
        ));
        $output->send();
    }

    // mark all un-seen messages in the mailbox as read
    function folder_mark_read($target)
    {
        $this->log($target);

        $output = $this->rc->output;
        $storage = $this->rc->storage;

        $search = $storage->search_once($target, 'ALL UNSEEN', true);
        if ($search->is_empty()) {
            return;
        }
        $message_list = $search->get();
        $storage->set_flag($message_list, 'SEEN', $target);
        $output->command('toggle_read_status', 'read', $message_list);
        rcmail_send_unread_count($target, true);
    }

    // recursively navigate mailbox and its descendants and mark all as read
    public function action_folder_scan_tree()
    {
        $output = $this->rc->output;
        $storage = $this->rc->storage;

        $target = $this->input_value('target');
        $scan_mode = $this->input_value('scan_mode');

        switch ($scan_mode) {
            case 'read_this':
                $this->folder_mark_read($target);
                break;
            case 'read_tree':
                $this->folder_mark_read($target);
                $delimiter = $this->hierarchy_delimiter();
                $pattern = $target . $delimiter . '*';
                $folder_list = $storage->list_folders(self::ROOT, $pattern, 'mail', null, false);
                foreach ($folder_list as $folder) {
                    $this->folder_mark_read($folder);
                }
                break;
            default:
                $this->log('invalid $scan_mode: ' . $scan_mode, true);
                break;
        }

        // confirm to client when done
        $output->command($this->key('folder_scan_tree'), array(
            'target' => $target,
            'scan_mode' => $scan_mode
        ));

        $output->send();
    }

    // guess business name from email domain
    function company_name($domain)
    {
        $generic_list = $this->config_get('domain_generic_list');
        $country_list = $this->config_get('domain_country_list');
        $domain = strtolower($domain);
        $company = explode(".", $domain);
        if (in_array(end($company), $generic_list)) {
            array_pop($company);
            $company = end($company);
        } else if (in_array(end($company), $country_list)) {
            array_pop($company);
            if (in_array(end($company), $generic_list)) {
                array_pop($company);
            }
            $company = end($company);
        } else {
            $company = implode(" ", $company);
        }
        $company = ucwords($company);
        return $company;
    }

    // provide structured message address headers
    public function action_header_list()
    {
        $uid = $this->input_value('uid');
        $mbox = $this->input_value('mbox');
        $message = new rcube_message($uid, $mbox);
        $header_list = array();
        foreach (array(
            'from',
            'to',
            'cc'
        ) as $type) {
            $header = $message->get_header($type);
            $subject = $message->get_header('subject');
            $address_list = rcube_mime::decode_address_list($header);
            foreach ($address_list as $address) {
                $name = trim($address['name']);
                if (strpos($name, ",") === false) {
                    $full_part = explode(" ", $name);
                } else { // reverse names order
                    $temp = explode(",", $name);
                    $full_part = array(
                        trim(end($temp)),
                        trim(reset($temp))
                    );
                }
                $full = implode(" ", $full_part);
                $full = ucwords($full);
                $full = trim($full);
                $mailto = strtolower($address['mailto']);
                $mailto_part = explode("@", $mailto);
                $prefix = reset($mailto_part);
                $domain = end($mailto_part);
                $company = $this->company_name($domain);
                $header_list[] = array(
                    'type' => $type,
                    'name' => $name,
                    'string' => $address['string'],
                    'full_name' => $full,
                    'full_head' => reset($full_part),
                    'full_tail' => end($full_part),
                    'mail_addr' => $mailto,
                    'prefix' => $prefix,
                    'domain' => $domain,
                    'company' => $company,
                    'subject' => $subject
                );
            }
        }
        // $this->log(print_r($header_list, true));
        $output = $this->rc->output;
        $output->command($this->key('header_list'), array(
            'header_list' => $header_list
        ));
        $output->send('plugin');
    }

    // //////////////////////////

    // settings
    function init_settings_hook()
    {
        $this->add_hook('preferences_list', array(
            $this,
            'hook_preferences_list'
        ));
        $this->add_hook('preferences_save', array(
            $this,
            'hook_preferences_save'
        ));
    }

    // settings
    function init_settings_html_page()
    {
        $output = $this->rc->output;
        if ($output->type == 'html') {
            $this->add_texts('localization', true);
        }
    }

    // plugin settings section
    function is_plugin_section($args)
    {
        return $args['section'] == 'mailbox';
    }

    // settings exposed to user
    function settings_checkbox_list()
    {
        return $this->config_get('settings_checkbox_list');
    }

    // settings exposed to user
    function settings_select_list()
    {
        return $this->config_get('settings_select_list');
    }

    // settings exposed to user
    function settings_area_list()
    {
        return $this->config_get('settings_area_list');
    }

    // settings exposed to user
    function settings_text_list()
    {
        return $this->config_get('settings_text_list');
    }

    // settings checkbox
    function build_checkbox(&$entry, $name)
    {
        $key = $this->key($name);
        $checkbox = new html_checkbox(array(
            'id' => $key,
            'name' => $key,
            'value' => 1
        ));
        $entry['options'][$name] = array(
            'title' => html::label($key, $this->quoted($name)),
            'content' => $checkbox->show($this->config_get($name))
        );
    }

    // settings multi select
    function build_select(&$entry, $name, $option_list = null)
    {
        if (! $option_list) { // list name convention
            $option_list = $this->config_get($name . '.' . 'list');
        }
        $key = $this->key($name);
        $select = new html_select(array(
            'id' => $key,
            'name' => $key . '[]', // use array
            'multiple' => true,
            'size' => 5
        ));
        $select->add($option_list, $option_list); // value => content
        $entry['options'][$name] = array(
            'title' => html::label($key, $this->quoted($name)),
            'content' => $select->show($this->config_get($name))
        );
    }

    // settings multi line text area
    function build_textarea(&$entry, $name)
    {
        $key = $this->key($name);
        $textarea = new html_textarea(array(
            'id' => $key,
            'name' => $key,
            'rows' => 5,
            'cols' => 65
        ));
        $entry['options'][$name] = array(
            'title' => html::label($key, $this->quoted($name)),
            'content' => $textarea->show(implode(PHP_EOL, $this->config_get($name)))
        );
    }

    // settings single line text input
    function build_text(&$entry, $name)
    {
        $key = $this->key($name);
        $input = new html_inputfield(array(
            'id' => $key,
            'name' => $key,
            'value' => 1
        ));
        $entry['options'][$name] = array(
            'title' => html::label($key, $this->quoted($name)),
            'content' => $input->show($this->config_get($name))
        );
    }

    // build settings ui
    function hook_preferences_list($args)
    {
        if ($this->is_plugin_section($args)) {
            $blocks = &$args['blocks'];
            $section = $this->key('section');
            $blocks[$section] = array();
            $entry = &$blocks[$section];
            $entry['name'] = $this->quoted('plugin_folder_menu');
            foreach ($this->settings_checkbox_list() as $name) {
                $this->build_checkbox($entry, $name);
            }
            foreach ($this->settings_select_list() as $name) {
                $this->build_select($entry, $name);
            }
            foreach ($this->settings_area_list() as $name) {
                $this->build_textarea($entry, $name);
            }
            foreach ($this->settings_text_list() as $name) {
                $this->build_text($entry, $name);
            }
        }
        return $args;
    }

    // settings checkbox
    function persist_checkbox(&$prefs, $name)
    {
        $key = $this->key($name);
        $value = $this->input_value($key);
        $prefs[$key] = $value ? true : false;
    }

    // settings multi select
    function persist_select(&$prefs, $name)
    {
        $key = $this->key($name);
        $value = $this->input_value($key);
        $prefs[$key] = $value;
    }

    // settings multi line text area
    function persist_textarea(&$prefs, $name)
    {
        $key = $this->key($name);
        $value = $this->input_value($key);
        $value = explode(PHP_EOL, $value); // array from text
        $value = array_map('trim', $value); // no spaces
        $value = array_filter($value); // no empty lines
                                       // sort($value); // alpha sorted
        $prefs[$key] = $value;
    }

    // settings single line text input
    function persist_text(&$prefs, $name)
    {
        $key = $this->key($name);
        $value = $this->input_value($key);
        $prefs[$key] = trim($value);
    }

    // persist user settings
    function hook_preferences_save($args)
    {
        if ($this->is_plugin_section($args)) {
            $prefs = &$args['prefs'];
            // $this->log('post: ' . print_r($_POST, true));
            foreach ($this->settings_checkbox_list() as $name) {
                $this->persist_checkbox($prefs, $name);
            }
            foreach ($this->settings_select_list() as $name) {
                $this->persist_select($prefs, $name);
            }
            foreach ($this->settings_area_list() as $name) {
                $this->persist_textarea($prefs, $name);
            }
            foreach ($this->settings_text_list() as $name) {
                $this->persist_text($prefs, $name);
            }
        }
        return $args;
    }
}

?>