flack / openpsa

lib/midcom/services/toolbars.php

<?php
/**
 * @package midcom.services
 * @author The Midgard Project, http://www.midgard-project.org
 * @copyright The Midgard Project, http://www.midgard-project.org
 * @license http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public License
 */

/**
 * On-site toolbar service.
 *
 * This service manages the toolbars used for the on-site administration system.
 * For each context, it provides the following set of toolbars:
 *
 * 1. The <i>Node</i> toolbar is applicable to the current
 *    node, which is usually a topic. MidCOM places the topic management operations
 *    into this toolbar, where applicable.
 *
 * 2. The <i>View</i> toolbar is applicable to the specific view ("url"). Usually
 *    this maps to a single displayed object (see also the bind_to() member
 *    function). MidCOM places the object-specific management operations (like
 *    Metadata controls) into this toolbar, if it is bound to an object. Otherwise,
 *    this toolbar is not touched by MidCOM.
 *
 * It is important to understand that the default toolbars made available through this
 * service are completely specific to a given request context. If you have a dynamic_load
 * running on a given site, it will have its own set of toolbars for each instance.
 *
 * In addition, components may retrieve a third kind of toolbars, which are not under
 * the general control of MidCOM, the <i>Object</i> toolbars. They apply to a single
 * database object (like a bound <i>View</i> toolbar). The usage of this kind of
 * toolbars is completely component-specific.
 *
 * <b>Implementation notes</b>
 *
 * It has yet to prove if the toolbar system is needed for a dynamic_load environments.
 * The main reason for this is that dl'ed stuff is often quite tight in space and thus cannot
 * display any toolbars in a sane way. Usually, the administrative tasks will be bound to the
 * main request.
 *
 * This could be different for portal applications, which display several components on the
 * welcome page, each with its own management options.
 *
 * <b>Configuration</b>
 * See midcom_config for configuration options.
 *
 * @package midcom.services
 */
class midcom_services_toolbars
{
    /**
     * The toolbars currently available.
     *
     * This array is indexed by context id; each value consists of a flat array
     * of two toolbars, the first object being the Node toolbar, the second
     * View toolbar. The toolbars are created on-demand.
     */
    private array $_toolbars = [];

    /**
     * Whether we're in centralized mode, i.e. centralized toolbar has been shown
     */
    private bool $_centralized_mode = false;

    public function get_class_magic_default_privileges() : array
    {
        return [
            'EVERYONE' => [],
            'ANONYMOUS' => [],
            'USERS' => []
        ];
    }

    /**
     * Returns the host toolbar of the current context.
     * The toolbar will be created if this is the first request.
     */
    function get_host_toolbar() : midcom_helper_toolbar_host

It is generally recommended to explicitly declare the visibility for methods.

    {
        return $this->_get_toolbar(MIDCOM_TOOLBAR_HOST);
    }

    /**
     * Returns the node toolbar of the current context.
     * The toolbar will be created if this is the first request.
     */
    public function get_node_toolbar() : midcom_helper_toolbar_node
    {
        return $this->_get_toolbar(MIDCOM_TOOLBAR_NODE);
    }

    /**
     * Returns the view toolbar of the current context.
     * The toolbar will be created if this is the first request.
     */
    public function get_view_toolbar() : midcom_helper_toolbar_view
    {
        return $this->_get_toolbar(MIDCOM_TOOLBAR_VIEW);
    }

    /**
     * Returns the help toolbar of the current context.
     * The toolbar will be created if this is the first request.
     */
    public function get_help_toolbar() : midcom_helper_toolbar_help
    {
        return $this->_get_toolbar(MIDCOM_TOOLBAR_HELP);
    }

    private function _get_toolbar(string $identifier) : midcom_helper_toolbar
    {
        $context = midcom_core_context::get();

        if (!array_key_exists($context->id, $this->_toolbars)) {
            $this->_toolbars[$context->id] = [
                MIDCOM_TOOLBAR_HELP => null,
                MIDCOM_TOOLBAR_HOST => null,
                MIDCOM_TOOLBAR_NODE => null,
                MIDCOM_TOOLBAR_VIEW => null
            ];
        }
        if (!isset($this->_toolbars[$context->id][$identifier])) {
            switch ($identifier) {
                case MIDCOM_TOOLBAR_HELP:
                    $component = $context->get_key(MIDCOM_CONTEXT_COMPONENT);
                    $toolbar = new midcom_helper_toolbar_help($component);

It seems like $component can also be of type false; however, parameter $component of midcom_helper_toolbar_help::__construct() does only seem to accept string, maybe add an additional type check?

                    break;
                case MIDCOM_TOOLBAR_HOST:
                    $toolbar = new midcom_helper_toolbar_host;
                    break;
                case MIDCOM_TOOLBAR_NODE:
                    $topic = $context->get_key(MIDCOM_CONTEXT_CONTENTTOPIC);
                    $toolbar = new midcom_helper_toolbar_node($topic);

It seems like $topic can also be of type false; however, parameter $topic of midcom_helper_toolbar_node::__construct() does only seem to accept midcom_db_topic, maybe add an additional type check?

                    break;
                case MIDCOM_TOOLBAR_VIEW:
                    $toolbar = new midcom_helper_toolbar_view;
                    break;
                default:
                    $toolbar = new midcom_helper_toolbar;
                    break;
            }
            $this->_toolbars[$context->id][$identifier] = $toolbar;
        }
        return $this->_toolbars[$context->id][$identifier];
    }

    /**
     * Add a toolbar
     *
     * @param string $identifier
     */
    function add_toolbar($identifier, midcom_helper_toolbar $toolbar)

It is generally recommended to explicitly declare the visibility for methods.

    {
        $context_id = midcom_core_context::get()->id;
        $this->_toolbars[$context_id][$identifier] = $toolbar;
    }

    /**
     * Renders the specified toolbar for the current context.
     *
     * If the toolbar is undefined, an empty string is returned.
     *
     * @param int $toolbar_identifier The toolbar identifier constant (one of
     *     MIDCOM_TOOLBAR_NODE or MIDCOM_TOOLBAR_VIEW etc.)
     * @see midcom_helper_toolbar::render()
     */
    function _render_toolbar($toolbar_identifier) : string

It is generally recommended to explicitly declare the visibility for methods.

    {
        $this->add_head_elements();
        return $this->_get_toolbar($toolbar_identifier)->render();
    }

    /**
     * Renders the node toolbar for the current context. If the toolbar is undefined,
     * an empty string is returned. If you want to show the toolbar directly, look for
     * the show_xxx_toolbar methods.
     *
     * @see midcom_helper_toolbar::render()
     */
    public function render_node_toolbar() : string
    {
        return $this->_render_toolbar(MIDCOM_TOOLBAR_NODE);
    }

    /**
     * Renders the view toolbar for the current context. If the toolbar is undefined,
     * an empty string is returned. If you want to show the toolbar directly, look for
     * the show_xxx_toolbar methods.
     *
     * @see midcom_helper_toolbar::render()
     */
    public function render_view_toolbar() : string
    {
        return $this->_render_toolbar(MIDCOM_TOOLBAR_VIEW);
    }

    /**
     * Renders the host toolbar for the current context. If the toolbar is undefined,
     * an empty string is returned. If you want to show the toolbar directly, look for
     * the show_xxx_toolbar methods.
     *
     * @see midcom_helper_toolbar::render()
     */
    public function render_host_toolbar() : string
    {
        return $this->_render_toolbar(MIDCOM_TOOLBAR_HOST);
    }

    /**
     * Renders the help toolbar for the current context. If the toolbar is undefined,
     * an empty string is returned. If you want to show the toolbar directly, look for
     * the show_xxx_toolbar methods.
     *
     * @see midcom_helper_toolbar::render()
     */
    public function render_help_toolbar() : string
    {
        return $this->_render_toolbar(MIDCOM_TOOLBAR_HELP);
    }

    /**
     * Displays the node toolbar for the current context. If the toolbar is undefined,
     * an empty string is returned.
     *
     * @see midcom_helper_toolbar::render()
     */
    function show_node_toolbar()

It is generally recommended to explicitly declare the visibility for methods.

    {
        if (!$this->_centralized_mode) {
            echo $this->render_node_toolbar();
        }
    }

    /**
     * Displays the host toolbar for the current context. If the toolbar is undefined,
     * an empty string is returned.
     *
     * @see midcom_helper_toolbar::render()
     */
    function show_host_toolbar()

It is generally recommended to explicitly declare the visibility for methods.

    {
        if (!$this->_centralized_mode) {
            echo $this->render_host_toolbar();
        }
    }

    /**
     * Displays the view toolbar for the current context. If the toolbar is undefined,
     * an empty string is returned.
     *
     * @see midcom_helper_toolbar::render()
     */
    public function show_view_toolbar()
    {
        if (!$this->_centralized_mode) {
            echo $this->render_view_toolbar();
        }
    }

    /**
     * Displays the help toolbar for the current context. If the toolbar is undefined,
     * an empty string is returned.
     *
     * @see midcom_helper_toolbar::render()
     */
    function show_help_toolbar()

It is generally recommended to explicitly declare the visibility for methods.

    {
        if (!$this->_centralized_mode) {
            echo $this->render_help_toolbar();
        }
    }

    private function add_head_elements(bool $centralized = false) : bool
    {
        if (   !midcom::get()->auth->user
            || !midcom::get()->config->get('toolbars_enable_centralized')
            || !midcom::get()->auth->can_user_do('midcom:centralized_toolbar', class: __CLASS__)) {
            return false;
        }
        if ($centralized && midcom::get()->auth->can_user_do('midcom:ajax', class: $this)) {

$this of type midcom_services_toolbars is incompatible with the type string expected by parameter $class of midcom_services_auth::can_user_do().

            $this->_centralized_mode = true;
            midcom::get()->head->enable_jquery_ui(['mouse', 'draggable']);
            midcom::get()->head->add_jsfile(MIDCOM_STATIC_URL . '/midcom.services.toolbars/jquery.midcom_services_toolbars.js');
            midcom::get()->head->prepend_stylesheet(MIDCOM_STATIC_URL . '/midcom.services.toolbars/fancy.css', 'screen');
        } else {
            $path = midcom::get()->config->get('toolbars_simple_css_path', MIDCOM_STATIC_URL . "/midcom.services.toolbars/simple.css");
            midcom::get()->head->prepend_stylesheet($path, 'screen');
        }
        midcom::get()->head->add_stylesheet(MIDCOM_STATIC_URL . '/stock-icons/font-awesome-4.7.0/css/font-awesome.min.css');
        return true;
    }

    /**
     * Displays the combined MidCOM toolbar system for the current context.
     *
     * @see midcom_helper_toolbar::render()
     */
    public function show()
    {
        $context_id = midcom_core_context::get()->id;

        if (empty($this->_toolbars[$context_id]) || !$this->add_head_elements(true)) {
            return;
        }

        $enable_drag = false;
        $toolbar_style = "";
        $toolbar_class = "midcom_services_toolbars_simple";

        if (midcom::get()->auth->can_user_do('midcom:ajax', class: __CLASS__)) {
            $enable_drag = true;
            $toolbar_class = "midcom_services_toolbars_fancy";
            $toolbar_style = "display: none;";
        }

        echo "<div class=\"{$toolbar_class}\" style=\"{$toolbar_style}\">\n";
        echo "    <div class=\"minimizer\">\n";
        echo "    </div>\n";
        echo "    <div class=\"items\">\n";

        foreach (array_reverse($this->_toolbars[$context_id], true) as $identifier => $toolbar) {
            $toolbar ??= $this->_get_toolbar($identifier);
            if (!$toolbar->is_rendered()) {
                $this->show_toolbar($identifier, $toolbar);
            }
        }
        echo "</div>\n";

        if ($enable_drag) {
            echo "     <div class=\"dragbar\"></div>\n";
        }
        echo "</div>\n";
        echo '<script type="text/javascript">';
        echo "jQuery('body div.midcom_services_toolbars_fancy').midcom_services_toolbar();";
        echo '</script>';
    }

    private function show_toolbar($identifier, midcom_helper_toolbar $toolbar)
    {
        if (empty($toolbar->items)) {
            return;
        }
        switch ($identifier) {
            case MIDCOM_TOOLBAR_VIEW:
                $id = $class = 'page';
                break;
            case MIDCOM_TOOLBAR_NODE:
                $id = $class = 'folder';
                break;
            case MIDCOM_TOOLBAR_HOST:
                $id = $class = 'host';
                break;
            case MIDCOM_TOOLBAR_HELP:
                $id = $class = 'help';
                break;
            default:
                $id = 'custom-' . $identifier;
                $class = 'custom';
                break;
        }
        echo "        <div id=\"midcom_services_toolbars_topic-{$id}\" class=\"item\">\n";
        echo "            <span class=\"midcom_services_toolbars_topic_title {$class}\">" . $toolbar->get_label() . "</span>\n";
        echo $toolbar->render();
        echo "        </div>\n";
    }
}