Docman_Controller::_dispatch() - Code Metrics - Enalean/tuleap - Measure and Improve Code Quality continuously with Scrutinizer

Docman_Controller::_dispatch() F
last analyzed 2016-01-22 17:23 UTC

↳ Parent: Docman_Controller
Complexity

Conditions	214
Paths	1528
Size

Total Lines	1017
Code Lines	770
Duplication

Lines	0
Ratio	0 %
Metric	Value
dl	0
loc	1017
rs	2
cc	214
eloc	770
nc	1528
nop	4
How to fix Long Method Complexity

<?php
/*
 * Copyright (c) STMicroelectronics, 2006. All Rights Reserved.
 * Copyright (c) Enalean, 2015.
 *
 * Originally written by Manuel Vacelet, 2006
 * 
 * This file is a part of Codendi.
 *
 * Codendi is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Codendi is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Codendi. If not, see <http://www.gnu.org/licenses/>.
 */
require_once('DocmanConstants.class.php');
require_once('common/mvc/Controler.class.php');
require_once('common/include/HTTPRequest.class.php');
require_once('common/user/UserManager.class.php');

require_once('view/Docman_View_GetShowViewVisitor.class.php');
require_once('view/Docman_View_GetFieldsVisitor.class.php');


require_once('Docman_Token.class.php');
//require_once('DocmanOneFolderIsWriteable.class.php');

require_once('common/include/Feedback.class.php');

require_once('Docman_NotificationsManager.class.php');
require_once('Docman_NotificationsManager_Add.class.php');
require_once('Docman_NotificationsManager_Delete.class.php');
require_once('Docman_NotificationsManager_Move.class.php');
require_once('Docman_NotificationsManager_Subscribers.class.php');

require_once('Docman_Log.class.php');
require_once('common/event/EventManager.class.php');

require_once('Docman_PermissionsManager.class.php');

require_once('Docman_ReportFactory.class.php');
require_once('Docman_MetadataFactory.class.php');


class Docman_Controller extends Controler {
    // variables
    var $request;
    var $user;
    var $groupId;
    var $themePath;
    var $plugin;
    var $logger;
    var $feedback;
    var $user_can_admin;
    var $reportId;
    var $hierarchy;

    function Docman_Controller(&$plugin, $pluginPath, $themePath, &$request) {
        $this->request        =& $request;
        $this->user           = null;
        $this->groupId        = null;
        $this->user_can_admin = null;
        $this->pluginPath     = $pluginPath;
        $this->themePath      = $themePath;
        $this->plugin         = $plugin;
        $this->view           = null;
        $this->reportId       = null;
        $this->hierarchy      = array();
        $this->feedback       = false;

        $this->feedback =& $GLOBALS['Response']->_feedback;

        $event_manager =& $this->_getEventManager();
        
        // Events that will call the Docman Logger
        $logEvents = array (
                         'plugin_docman_event_add',
                         'plugin_docman_event_edit',
                         'plugin_docman_event_move',
                         'plugin_docman_event_del',
                         'plugin_docman_event_del_version',
                         'plugin_docman_event_access',
                         'plugin_docman_event_new_version',
                         'plugin_docman_event_restore',
                         'plugin_docman_event_restore_version',
                         'plugin_docman_event_metadata_update',
                         'plugin_docman_event_set_version_author',
                         'plugin_docman_event_set_version_date',
                         'plugin_docman_event_lock_add',
                         'plugin_docman_event_lock_del',
                         'plugin_docman_event_perms_change',
                     );
                     
        $this->logger  =& new Docman_Log();
        foreach ($logEvents as $event) {
            $event_manager->addListener($event, $this->logger, 'log', true);
        }

        // Other events
        $this->notificationsManager =& new Docman_NotificationsManager($this->getProject(), get_server_url().$this->getDefaultUrl(), $this->feedback, $this->getMailBuilder());
        $event_manager->addListener('plugin_docman_event_edit',            $this->notificationsManager, 'somethingHappen', true);
        $event_manager->addListener('plugin_docman_event_new_version',     $this->notificationsManager, 'somethingHappen', true);
        $event_manager->addListener('plugin_docman_event_metadata_update', $this->notificationsManager, 'somethingHappen', true);
        $event_manager->addListener('send_notifications',    $this->notificationsManager, 'sendNotifications', true);
        $this->notificationsManager_Add =& new Docman_NotificationsManager_Add($this->getProject(), get_server_url().$this->getDefaultUrl(), $this->feedback, $this->getMailBuilder());
        $event_manager->addListener('plugin_docman_event_add', $this->notificationsManager_Add, 'somethingHappen', true);
        $event_manager->addListener('send_notifications',    $this->notificationsManager_Add, 'sendNotifications', true);
        $this->notificationsManager_Delete =& new Docman_NotificationsManager_Delete($this->getProject(), get_server_url().$this->getDefaultUrl(), $this->feedback, $this->getMailBuilder());
        $event_manager->addListener('plugin_docman_event_del', $this->notificationsManager_Delete, 'somethingHappen', true);
        $event_manager->addListener('send_notifications',    $this->notificationsManager_Delete, 'sendNotifications', true);
        $this->notificationsManager_Move =& new Docman_NotificationsManager_Move($this->getProject(), get_server_url().$this->getDefaultUrl(), $this->feedback, $this->getMailBuilder());
        $event_manager->addListener('plugin_docman_event_move', $this->notificationsManager_Move, 'somethingHappen', true);
        $event_manager->addListener('send_notifications',     $this->notificationsManager_Move, 'sendNotifications', true);
        $this->notificationsManager_Subscribers = new Docman_NotificationsManager_Subscribers($this->getProject(), get_server_url().$this->getDefaultUrl(), $this->feedback, $this->getMailBuilder());
        $event_manager->addListener('plugin_docman_event_subcribers', $this->notificationsManager_Subscribers, 'somethingHappen', true);
    }

    /**
     * Wrapper to i18n string call for docman.
     * static
     */
    function txt($key, $vars = array()) {
        return $GLOBALS['Language']->getText('plugin_docman', $key, $vars);
    }

    // Franlky, this is not at all the best place to do this.
    function installDocman($ugroupsMapping, $group_id = false) {
        $_gid = $group_id ? $group_id : (int) $this->request->get('group_id');

        $item_factory =& $this->_getItemFactory();
        $root =& $item_factory->getRoot($_gid);
        if ($root) {
            // Docman already install for this project.
            return false;
        } else {
            $pm = ProjectManager::instance();
            $project = $pm->getProject($_gid);
            $tmplGroupId = (int) $project->getTemplate();
            $this->_cloneDocman($tmplGroupId, $_gid, $ugroupsMapping);
        }
    }

    function _cloneDocman($srcGroupId, $dstGroupId, $ugroupsMapping) {
        $user = $this->getUser();

        // Clone Docman permissions
        $dPm = $this->_getPermissionsManager();
        if($ugroupsMapping === false) {
            $dPm->setDefaultDocmanPermissions($dstGroupId);
        }
        else {
            $dPm->cloneDocmanPermissions($srcGroupId, $dstGroupId);
        }

        // Clone Metadata definitions
        $metadataMapping = array();
        $mdFactory = new Docman_MetadataFactory($srcGroupId);
        $mdFactory->cloneMetadata($dstGroupId, $metadataMapping);

        // Clone Items, Item's permissions and metadata values
        $itemFactory = $this->_getItemFactory();
        $dataRoot = $this->getProperty('docman_root');
        $itemMapping = $itemFactory->cloneItems($srcGroupId, $dstGroupId, $user, $metadataMapping, $ugroupsMapping, $dataRoot);

        // Clone reports
        $reportFactory = new Docman_ReportFactory($srcGroupId);
        $reportFactory->copy($dstGroupId, $metadataMapping, $user, false, $itemMapping);

        //@todo: verify that key for title for root is copied instead of
        //       string
    }

    function getLogger() {
        return $this->logger;
    }
    function logsDaily($params) {
        $this->logger->logsDaily($params);
    }
    
    function _getEventManager() {
        return EventManager::instance();
    }

    /**
     * Obtain instance of Docman_PermissionsManager
     *
     * @return Docman_PermissionsManager
     */
    private function _getPermissionsManager() {
        return Docman_PermissionsManager::instance($this->getGroupId());
    }

    function &getUser() {
        if($this->user === null) {
            $um =& UserManager::instance();
            $this->user = $um->getCurrentUser();
        }
        return $this->user;
    }
    
    /***************** PERMISSIONS ************************/
    function userCanRead($item_id) {
        $dPm  = $this->_getPermissionsManager();
        $user =& $this->getUser();
        return $dPm->userCanRead($user, $item_id);
    }
    function userCanWrite($item_id) {
        $dPm  = $this->_getPermissionsManager();
        $user =& $this->getUser();
        return $dPm->userCanWrite($user, $item_id);
    }
    function userCanManage($item_id) {
        $dPm  = $this->_getPermissionsManager();
        $user =& $this->getUser();
        return $dPm->userCanManage($user, $item_id);
    }
    function userCanAdmin() {
        $dPm  = $this->_getPermissionsManager();
        $user =& $this->getUser();
        return $dPm->userCanAdmin($user);
    }
    /******************************************************/
    
    function setRequest($request) {
        $this->request = $request;
    }
    
    function getGroupId() {
        if($this->groupId === null) {
            $_gid = (int) $this->request->get('group_id');
            if($_gid > 0) {
                $this->groupId = $_gid;
            }
        }
        return $this->groupId;
    }

    function getDefaultUrl() {
        $_gid = $this->getGroupId();
        return $this->pluginPath.'/?group_id='.$_gid;
    }

    function getAdminUrl() {
        $_gid = $this->getGroupId();
        return $this->pluginPath.'/admin/?group_id='.$_gid;
    }
    
    function getThemePath() {
        return $this->themePath;
    }
    
    function setReportId($id) {
        $this->reportId = $id;
    }
    function getReportId() {
        return $this->reportId;
    }

    function _initReport($item) {
        $reportFactory = new Docman_ReportFactory($this->getGroupId());
        
        if($this->reportId === null && $this->request->exist('report_id')) {
            $this->reportId = (int) $this->request->get('report_id');
        }
        $report =& $reportFactory->get($this->reportId, $this->request, $item, $this->feedback);

        $this->_viewParams['filter'] =& $report;            
    }


    /*private*/ function _checkBrowserCompliance() {
        if($this->request_type == 'http' && $this->request->browserIsNetscape4()) {
            $this->feedback->log('warning', $GLOBALS['Language']->getText('plugin_docman', 'docman_browserns4'));
        }
    }

    function getValueInArrays($key, $array1, $array2) {
        $value = null;
        if(isset($array1[$key])) {
            $value = $array1[$key];
        }
        elseif(isset($array2[$key])) {
            $value = $array2[$key];
        }
        return $value;
    }

    function setMetadataValuesFromUserInput(&$item, $itemArray, $metadataArray) {
        $mdvFactory = new Docman_MetadataValueFactory($this->groupId);
        $mdFactory = new Docman_MetadataFactory($this->groupId);

        $mdIter =& $item->getMetadataIterator();
        $mdIter->rewind();
        while($mdIter->valid()) {
            $md =& $mdIter->current();
            
            $value = $this->getValueInArrays($md->getLabel(), $itemArray, $metadataArray);
            if($value !== null) {
                $mdv = $mdvFactory->newMetadataValue($item->getId(), $md->getId(), $md->getType(), $value);
                $val = $mdv->getValue();
                $mdvFactory->validateInput($md, $val);
                $md->setValue($val);
                // Take care to update hardcoded values too.
                if($mdFactory->isHardCodedMetadata($md->getLabel())) {
                    $item->updateHardCodedMetadata($md);
                }
            }
            $mdIter->next();
        }
    }

    function createItemFromUserInput() {
        $new_item = null;
        if($this->request->exist('item')) {
            $item_factory =& $this->_getItemFactory();
            $mdFactory = new Docman_MetadataFactory($this->_viewParams['group_id']);

            $i = $this->request->get('item');
            $new_item = $item_factory->getItemFromRow($i);
            $new_item->setGroupId($this->_viewParams['group_id']);
            // Build metadata list (from db) ...
            $mdFactory->appendItemMetadataList($new_item);
            // ... and set the value (from user input)
            $this->setMetadataValuesFromUserInput($new_item,
                                                  $i,
                                                  $this->request->get('metadata'));
            if ($i['item_type'] == PLUGIN_DOCMAN_ITEM_TYPE_EMBEDDEDFILE) {
                $tmp_path = tempnam($GLOBALS['tmp_dir'], 'embedded_file');
                $f = fopen($tmp_path, 'w');
                fwrite($f, $this->request->get('content'));
                fclose($f);
                $v = new Docman_Version();
                $v->setPath($tmp_path);
                $new_item->setCurrentVersion($v);
            }
        }
        return $new_item;
    }
    
    function updateMetadataFromUserInput(&$item) {
        $this->setMetadataValuesFromUserInput($item, 
                                             $this->request->get('item'), 
                                             $this->request->get('metadata'));
    }

    function updateItemFromUserInput(&$item) {
        if($this->request->exist('item')) {
            $i = $this->request->get('item');
            $itemFactory =& $this->_getItemFactory();
            switch($itemFactory->getItemTypeForItem($item)) {
            case PLUGIN_DOCMAN_ITEM_TYPE_WIKI:
                $item->setPagename($i['wiki_page']);
                break;
            case PLUGIN_DOCMAN_ITEM_TYPE_LINK:
                $item->setUrl($i['link_url']);
                break;
            }
        }
    }

    function request() {
        if ($this->request->exist('action') 
            && ($this->request->get('action') == 'plugin_docman_approval_reviewer' 
                || $this->request->get('action') == 'plugin_docman_approval_requester'
                )
            )
        {
            if ($this->request->get('hide')) {
                user_set_preference('hide_'. $this->request->get('action'), 1);
            } else {
                user_del_preference('hide_'. $this->request->get('action'));
            }
            exit;

        }
        if (!$this->request->exist('group_id')) {
            $this->feedback->log('error', 'Project is missing.');
            $this->_setView('Error');
        } else {
            $_groupId = (int) $this->request->get('group_id');
            $pm = ProjectManager::instance();
            $project = $pm->getProject($_groupId);
            if($project == false) {
                $this->feedback->log('error', 'Project is missing.');
                $this->_setView('Error');
                return;
            }
            
            // Browser alert
            $this->_checkBrowserCompliance();
            
            //token for redirection
            $tok =& new Docman_Token();
            
            $this->_viewParams['docman']         =& $this;
            $this->_viewParams['user']           =& $this->getUser();
            $this->_viewParams['token']          =  $tok->getToken();
            $this->_viewParams['default_url']    =  $this->getDefaultUrl();
            $this->_viewParams['theme_path']     =  $this->getThemePath();
            $this->_viewParams['group_id']       = (int) $this->request->get('group_id');                
            if($this->request->exist('version_number')) {
                $this->_viewParams['version_number'] = (int) $this->request->get('version_number');
            }

            if ($this->request->exist('section')) {
                $this->_viewParams['section'] = $this->request->get('section');
            } else if ($this->request->get('action') == 'permissions') {
                $this->_viewParams['section'] = 'permissions';
            }
            $view = $this->request->exist('action') ? $this->request->get('action') : 'show';
            $this->_viewParams['action'] = $view;

            // Start is used by Table view (like LIMIT start,offset)
            if($this->request->exist('start')) {
                $this->_viewParams['start']       = (int) $this->request->get('start');
            }
            
            if($this->request->exist('pv')) {
                $this->_viewParams['pv']       = (int) $this->request->get('pv');
            }

            if($this->request->exist('report')) {
                $this->_viewParams['report'] = $this->request->get('report');
                $views                       = Docman_View_Browse::getDefaultViews();
                $validator                   = new Valid_WhiteList('report', $views);
                $views_keys                  = array_keys($views);
                $default_view                = $views[$views_keys[0]];
                $this->_viewParams['report'] = $this->request->getValidated('report', $validator, $default_view);
            }

            $item_factory =& $this->_getItemFactory();
            $root =& $item_factory->getRoot($this->request->get('group_id'));
            if (!$root) {
                // Install
                $_gid = (int) $this->request->get('group_id');
                
                $pm = ProjectManager::instance();
                $project = $pm->getProject($_gid);
                $tmplGroupId = (int) $project->getTemplate();
                $this->_cloneDocman($tmplGroupId, $_gid, false);
                if (!$item_factory->getRoot($_gid)) {
                    $item_factory->createRoot($_gid, 'roottitle_lbl_key');
                }
                $this->_viewParams['redirect_to'] = $_SERVER['REQUEST_URI'];
                $this->view = 'Redirect';
            } else {
                $id = $this->request->get('id');
                if (!$id && $this->request->exist('item')) {
                    $i = $this->request->get('item');
                    if (isset($i['id'])) {
                        $id = $i['id'];
                    }
                }
                if ($id) {
                    $item =& $item_factory->getItemFromDb($id);
                    
                    if (!$item) {
                        $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_item_deleted'));
                        $this->_setView('DocmanError');
                    }

                } else {
                    $item =& $root;
                }
                if ($item) {
                    // Load report
                    // If the item (folder) defined in the report is not the
                    // same than the current one, replace it.
                    $this->_initReport($item);
                    if($this->_viewParams['filter'] !== null 
                       && $this->_viewParams['filter']->getItemId() !== null
                       && $this->_viewParams['filter']->getItemId() != $item->getId()) {
                        $reportItem = $item_factory->getItemFromDb($this->_viewParams['filter']->getItemId());
                        // If item defined in the report exists, use it
                        // otherwise raise an error
                        if(!$reportItem) {
                            $this->feedback->log('warning', $GLOBALS['Language']->getText('plugin_docman', 'error_report_baditemid'));
                        } else {
                            unset($item);
                            $item = $reportItem;
                        }
                    }
                    
                    if ($this->request->get('action') == 'ajax_reference_tooltip') {
                        $this->groupId = $item->getGroupId();
                    }
                    if ($item->getGroupId() != $this->getGroupId()) {
                        $pm = ProjectManager::instance();
                        $g = $pm->getProject($this->getGroupId());
                        $this->_set_doesnot_belong_to_project_error($item, $g);
                    } else {
                        $user = $this->getUser();
                        $dpm = $this->_getPermissionsManager();
                        $can_read = $dpm->userCanAccess($user, $item->getId());
                        $folder_or_document = is_a($item, 'Docman_Folder') ? 'folder' : 'document';
                        if (!$can_read) {
                            if ($this->request->get('action') == 'ajax_reference_tooltip') {
                                $this->_setView('AjaxReferenceTooltipError');
                            } else {
                                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_view'));
                                $this->_setView('PermissionDeniedError');
                            }
                        } else {
                            $mdFactory = new Docman_MetadataFactory($this->_viewParams['group_id']);
                            $mdFactory->appendItemMetadataList($item);
                                                        
                            $get_show_view =& new Docman_View_GetShowViewVisitor();
                            $this->_viewParams['item'] =& $item;
                            if (strpos($view, 'admin') === 0 && !$this->userCanAdmin()) {
                                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_admin'));
                                $this->view = $item->accept($get_show_view, $this->request->get('report'));
                            } else {
                                if($item->isObsolete()) {
                                    $this->feedback->log('warning', $this->txt('warning_obsolete'));
                                }
                                $this->_dispatch($view, $item, $root, $get_show_view);
                            }
                        }
                    }
                }
            }
        }
    }

    function _dispatch($view, $item, $root, $get_show_view) {
        $item_factory =& $this->_getItemFactory();
        $user =& $this->getUser();
        $dpm = $this->_getPermissionsManager();

        switch ($view) {
        case 'show':
            if($item->isObsolete()) {
                if(!$this->userCanAdmin($item->getId())) {
                    // redirect to details view
                    $this->view = 'Details';
                    break;
                }
            }
            $this->view = $item->accept($get_show_view, $this->request->get('report'));
            break;
        case 'expandFolder':
            $this->action = 'expandFolder';
            if ($this->request->get('view') == 'ulsubfolder') {
                $this->view = 'RawTree';
            } else {
                $this->_viewParams['item'] =& $root;
                $this->view = 'Tree';
            }
            break;
        case 'getRootFolder':
            $this->_viewParams['action_result'] = $root->getId();
            $this->_setView('getRootFolder');
            break;
        case 'collapseFolder':
            $this->action = 'collapseFolder';
            $this->_viewParams['item'] =& $root;
            $this->view = 'Tree';
            break;
        case 'admin_set_permissions':
            $this->action = $view;
            $this->view   = 'Admin_Permissions';
            break;
        case 'admin_change_view':
            $this->action = $view;
            $this->_viewParams['default_url_params'] = array('action'  => 'admin_view',
                                                             'id'      => $item->getParentId());
            $this->view = 'RedirectAfterCrud';
            break;
        case 'admin':
        case 'details':
            $this->view = ucfirst($view);
            break;
        case 'admin_view':
            $this->view = 'Admin_View';
            break;
        case 'admin_permissions':
            $this->view = 'Admin_Permissions';
            break;
        case 'admin_metadata':
            $this->view = 'Admin_Metadata';
            $mdFactory = new Docman_MetadataFactory($this->_viewParams['group_id']);
            $mdIter =& $mdFactory->getMetadataForGroup();
            $this->_viewParams['mdIter'] =& $mdIter;
            break;
        case 'admin_md_details':
            // Sanitize
            $_mdLabel = $this->request->get('md');
    
            $md = null;
            $mdFactory = new Docman_MetadataFactory($this->_viewParams['group_id']);
            $valid = $this->validateMetadata($_mdLabel, $md);
    
            if(!$valid) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 
                                                                            'error_invalid_md'));
                $this->view = 'RedirectAfterCrud';
                $this->_viewParams['default_url_params'] = array('action' => 'admin_metadata');
            }
            else {
                $this->view = 'Admin_MetadataDetails';
                $mdFactory->appendMetadataValueList($md, false);
                $this->_viewParams['md'] =& $md;
            }
            break;
        case 'admin_md_details_update':
            $_name = trim($this->request->get('name'));
            $_label = $this->request->get('label');
            
            $mdFactory = $this->_getMetadataFactory($this->_viewParams['group_id']);
            if($mdFactory->isValidLabel($_label)) {
                $this->_viewParams['default_url_params'] = array('action'  => 'admin_md_details', 'md' => $_label);
                if ($mdFactory->isHardCodedMetadata($_label) || $this->validateUpdateMetadata($_name, $_label)) {
                    $this->action = $view;
                }
            } else {
                $this->_viewParams['default_url_params'] = array('action'  => 'admin_metadata');
            }
            $this->view = 'RedirectAfterCrud';
            break;
        case 'admin_create_metadata':
            $_name = trim($this->request->get('name'));
            $valid = $this->validateNewMetadata($_name);
            
            if ($valid) {
                $this->action = $view;
            }
            
            $this->_viewParams['default_url_params'] = array('action'  => 'admin_metadata');
            $this->view = 'RedirectAfterCrud';
            break;
        case 'admin_delete_metadata':
            $valid = false;
            // md
            // Sanitize
            $_mdLabel = $this->request->get('md');
                                        
            // Valid
            $logmsg = '';
            $mdFactory = new Docman_MetadataFactory($this->_viewParams['group_id']);
            $md = null;
            $vld = $this->validateMetadata($_mdLabel, $md);
            if($vld) {
                if(!$mdFactory->isHardCodedMetadata($md->getLabel())) {
                    $valid = true;
                }
                else {
                    $logmsg = $GLOBALS['Language']->getText('plugin_docman', 
                                                            'error_cannot_delete_hc_md');
                }
            }
            else {
                $logmsg = $GLOBALS['Language']->getText('plugin_docman', 
                                                        'error_invalid_md');
            }
    
            if(!$valid) {
                if($logmsg != '') {
                    $this->feedback->log('error', $logmsg);
                }
                $this->view = 'RedirectAfterCrud';
                $this->_viewParams['default_url_params'] = array('action' => 'admin_metadata');
            }
            else {
                $this->action = $view;
                $this->_actionParams['md'] = $md;
            }
                                        
            break;
        case 'admin_create_love':
            $mdFactory = $this->_getMetadataFactory($this->_viewParams['group_id']);
            if($mdFactory->isValidLabel($this->request->get('md'))) {
                $this->action = $view;
                $this->_viewParams['default_url_params'] = array('action'  => 'admin_md_details',
                                                                 'md' => $this->request->get('md'));
            } else {
                $this->_viewParams['default_url_params'] = array('action'  => 'admin_metadata');
            }
            $this->view = 'RedirectAfterCrud';
            break;
        case 'admin_delete_love':
            $mdFactory = $this->_getMetadataFactory($this->_viewParams['group_id']);
            if($mdFactory->isValidLabel($this->request->get('md'))) {
                $this->action = $view;
                $this->_viewParams['default_url_params'] = array('action'  => 'admin_md_details',
                                                                 'md' => $this->request->get('md'));
            } else {
                $this->_viewParams['default_url_params'] = array('action'  => 'admin_metadata');
            }
            $this->view = 'RedirectAfterCrud';
            break;
        case 'admin_display_love':
            $valid = false;
            // Required params:
            // md (string [a-z_]+)
            // loveid (int)
    
            // Sanitize
            $_mdLabel = $this->request->get('md');
            $_loveId = (int) $this->request->get('loveid');
    
            // Valid
            $md = null;
            $love = null;
            $this->validateMetadata($_mdLabel, $md);
            if($md !== null && $md->getLabel() !== 'status') {
                $valid = $this->validateLove($_loveId, $md, $love);
            }
    
            if(!$valid) {
                $this->view = 'RedirectAfterCrud';
                $this->_viewParams['default_url_params'] = array('action' => 'admin_metadata');
            }
            else {
                $mdFactory = new Docman_MetadataFactory($this->groupId);
                $mdFactory->appendMetadataValueList($md, false);
    
                $this->view = 'Admin_MetadataDetailsUpdateLove';
                $this->_viewParams['md'] = $md;
                $this->_viewParams['love'] = $love;
            }
            break;
        case 'admin_update_love':
            $valid = false;
            // Required params:
            // md (string [a-z_]+)
            // loveid (int)
            //
            // rank (beg, end, [0-9]+)
            // name
            // descr
    
            // Sanitize
            /// @todo sanitize md, rank, name, descr
            $_mdLabel = $this->request->get('md');
            $_loveId = (int) $this->request->get('loveid');
            $_rank = $this->request->get('rank');
            $_name = $this->request->get('name');
            $_descr = $this->request->get('descr');
    
            // Valid
            $md = null;
            $love = null;
            $this->validateMetadata($_mdLabel, $md);
            if($md !== null && $md->getLabel() !== 'status') {
                $valid = $this->validateLove($_loveId, $md, $love);
            }
    
            if(!$valid) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_md_or_love'));
                $this->view = 'RedirectAfterCrud';
                $this->_viewParams['default_url_params'] = array('action' => 'admin_metadata');
            }
            else {
                // Set parameters
                $love->setRank($_rank);
                $love->setName($_name);
                $love->setDescription($_descr);
    
                // define action
                $this->action = $view;
                $this->_actionParams['md'] = $md;
                $this->_actionParams['love'] = $love;
            }
            break;

        case 'admin_import_metadata_check':
            $ok = false;
            if($this->request->existAndNonEmpty('plugin_docman_metadata_import_group')) {
                $pm = ProjectManager::instance();
                $srcGroup = $pm->getProjectFromAutocompleter($this->request->get('plugin_docman_metadata_import_group'));
                if ($srcGroup && !$srcGroup->isError()) {
                    $this->_viewParams['sSrcGroupId'] = $srcGroup->getGroupId();
                    $this->view = 'Admin_MetadataImport';
                    $ok = true;
                }
            }
            if (!$ok) {
                $this->view = 'RedirectAfterCrud';
                $this->_viewParams['default_url_params'] = array('action' => 'admin_metadata');
            }
            break;

        case 'admin_import_metadata':
            if($this->request->existAndNonEmpty('confirm')) {
                                            
                if($this->request->existAndNonEmpty('plugin_docman_metadata_import_group')) {
                    $pm = ProjectManager::instance();
                    $srcGroup = $pm->getProjectFromAutocompleter($this->request->get('plugin_docman_metadata_import_group'));
                    $srcGroupId = $srcGroup->getGroupId();
                    $this->_actionParams['sSrcGroupId'] = $srcGroupId;
                    $this->_actionParams['sGroupId'] = $this->_viewParams['group_id'];

                    $this->action = $view;
                } else {
                    $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'missing_param'));
                    $this->feedback->log('info', $GLOBALS['Language']->getText('plugin_docman', 'operation_canceled'));
                }
            } else {
                $this->feedback->log('info', $GLOBALS['Language']->getText('plugin_docman', 'operation_canceled'));
            }
            $this->view = 'RedirectAfterCrud';
            $this->_viewParams['default_url_params'] = array('action' => 'admin_metadata');
            break;

        case 'admin_obsolete':
            $this->view = 'Admin_Obsolete';
            break;

        case 'admin_lock_infos':
            $this->view = 'Admin_LockInfos';
            break;

        case 'move':
            if (!$this->userCanWrite($item->getId()) || !$this->userCanWrite($item->getParentId())) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_move'));
                $this->view = 'Details';
            } else {
                if ($this->request->exist('quick_move')) {
                    $this->action = 'move';
                    $this->view = null;
                } else {
                    $this->_viewParams['hierarchy'] =& $this->getItemHierarchy($root);
                    $this->view = ucfirst($view);
                }
            }
            break;
        case 'newGlobalDocument':
            if ($dpm->oneFolderIsWritable($user)) {
                $this->_viewParams['hierarchy'] =& $this->getItemHierarchy($root);
                $this->view = 'New_FolderSelection';
            } else {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_create'));
                $this->view = $item->accept($get_show_view, $this->request->get('report'));
            }
            break;
        case 'newDocument':
        case 'newFolder':
            if ($this->request->exist('cancel')) {
                $this->_set_redirectView();
            } else {
                if (!$this->userCanWrite($item->getId())) {
                    $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_create'));
                    $this->view = 'Details';
                } else {
                    //$this->_viewParams['hierarchy'] =& $this->getItemHierarchy($root);
                    $this->_viewParams['ordering'] = $this->request->get('ordering');
                    if($this->request->get('item_type') == PLUGIN_DOCMAN_ITEM_TYPE_FOLDER) {
                        $view = 'newFolder';
                    }
                    $this->view = ucfirst($view);
                }
            }
            break;
        case 'monitor':
            if ($this->request->exist('monitor')) {
                $this->_actionParams['monitor'] =  $this->request->get('monitor');
                if ($this->request->exist('cascade')) {
                    $this->_actionParams['cascade'] = $this->request->get('cascade');
                }
                $this->_actionParams['item']    =& $item;
                $this->action = 'monitor';
            }
            $this->_setView('Details');
            break;
        case 'remove_monitoring':
            $this->_actionParams['listeners_to_delete'] = array();
            if ($this->userCanManage($item->getId())) {
                if ($this->request->exist('listeners_to_delete')) {
                    $um      = UserManager::instance();
                    $vUserId = new Valid_UInt('listeners_to_delete');
                    if($this->request->validArray($vUserId)) {
                        $userIds = $this->request->get('listeners_to_delete');
                        $users   = array();
                        foreach ($userIds as $userId) {
                            $users[] = $um->getUserById($userId);
                        }
                        $this->_actionParams['listeners_to_delete'] = $users;
                        $this->_actionParams['item']                = $item;
                    }
                }
                $this->action = 'remove_monitoring';
                $this->_setView('Details');
            } else {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'notifications_permission_denied'));
                $this->_setView('Details');
            }
            break;

        case 'add_monitoring':
            $this->_actionParams['listeners_to_add'] = array();
            $this->_actionParams['invalid_users']    = false;
            if ($this->userCanManage($item->getId())) {
                if ($this->request->exist('listeners_to_add')) {
                    $um    = UserManager::instance();
                    $vUser = new Valid_Text('listeners_to_add');
                    if($this->request->valid($vUser)) {
                        $usernames = array_map('trim', preg_split('/[,;]/', $this->request->get('listeners_to_add')));
                        $users     = array();
                        $vUserName = new Valid_String();
                        $vUserName->required();
                        foreach ($usernames as $username) {
                            if ($vUserName->validate($username) && $user = $um->findUser($username)) {
                                $users[] =$user;
                            } else {
                                $this->_actionParams['invalid_users'] = true;
                            }
                        }
                        if ($this->request->exist('monitor_cascade')) {
                            $this->_actionParams['monitor_cascade'] = $this->request->get('monitor_cascade');
                        }
                        $this->_actionParams['listeners_to_add'] = $users;
                        $this->_actionParams['item']             = $item;
                    }
                }
                $this->action = 'add_monitoring';
                $this->_setView('Details');
            } else {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'notifications_permission_denied'));
                $this->_setView('Details');
            }
            break;

        case 'move_here':
            if (!$this->request->exist('item_to_move')) {
                $this->feedback->log('error', 'Missing parameter.');
                $this->view = 'DocmanError';
            } else {
                $item_to_move =& $item_factory->getItemFromDb($this->request->get('item_to_move'));
                $this->view = null;
                if ($this->request->exist('confirm')) {
                    if (!$item_to_move || !($this->userCanWrite($item->getId()) && $this->userCanWrite($item_to_move->getId()) && $this->userCanWrite($item_to_move->getParentId()))) {
                        $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_move'));
                        $this->_set_moveView_errorPerms();
                    } else {
                        $this->action = 'move';
                    }
                } 
                if (!$this->view) {
                    $this->_set_redirectView();
                }
            }
            break;
        case 'permissions':
            if (!$this->userCanManage($item->getId())) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_perms'));
                $this->view = 'Details';
            } else {
                $this->action = 'permissions';
                $this->view   = 'Details';
            }
            break;
        case 'confirmDelete':
            if (!$this->userCanWrite($item->getId()) || !$this->userCanWrite($item->getParentId())) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_delete'));
                $this->view = 'Details';
            } else {
                $this->view   = 'Delete';
            }
            break;
        case 'action_new_version':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_edit'));
                $this->view = 'Details';
            } else {
                $dPm = $this->_getPermissionsManager();
                if($dPm->getLockFactory()->itemIsLocked($item)) {
                    $this->feedback->log('warning', $GLOBALS['Language']->getText('plugin_docman', 'event_lock_add'));
                }
                $this->view   = 'NewVersion';
            }
            break;
        case 'action_update':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_edit'));
                $this->view = 'Details';
            } else {
                $this->view   = 'Update';
            }
            break;

        case 'action_copy':
            //@XSS: validate action against a regexp.
            $_action = $this->request->get('orig_action');
            $_id     = (int) $this->request->get('orig_id');
            $this->_actionParams['item'] = $item;

            $this->action = $view;
            if(!$this->request->exist('ajax_copy')) {
                $this->_viewParams['default_url_params'] = array('action'  => $_action,
                                                                 'id'      => $_id);
                $this->view = 'RedirectAfterCrud';
            }
            break;

        case 'action_cut':
            $_action = $this->request->get('orig_action');
            $_id = (int) $this->request->get('orig_id');
            $this->_actionParams['item'] = $item;

            $this->action = $view;
            if(!$this->request->exist('ajax_cut')) {
                $this->_viewParams['default_url_params'] = array('action'  => $_action,
                                                                 'id'      => $_id);
                $this->view = 'RedirectAfterCrud';
            }
            break;

        case 'action_paste':
            $itemToPaste = null;
            $mode        = null;
            $allowed = $this->checkPasteIsAllowed($item, $itemToPaste, $mode);
            if(!$allowed) {
                $this->view = 'Details';
            }
            else {
                $this->_viewParams['itemToPaste'] = $itemToPaste;
                $this->_viewParams['srcMode']     = $mode;
                $this->view = 'Paste';
            }
            break;

        case 'paste_cancel':
            // intend to be only called through ajax call
            $item_factory->delCopyPreference();
            $item_factory->delCutPreference();
            break;
            
        case 'paste':
            if($this->request->exist('cancel')) {
                $this->_viewParams['default_url_params'] = array('action'  => 'show');
                $this->view = 'RedirectAfterCrud';
            } else {
                $itemToPaste = null;
                $mode        = null;
                $allowed = $this->checkPasteIsAllowed($item, $itemToPaste, $mode);
                if(!$allowed) {
                    $this->view = 'Details';
                }
                else {
                    $this->_viewParams['importMd'] = false;
                    if($this->userCanAdmin()) {
                        if($this->request->exist('import_md') &&
                           $this->request->get('import_md') == '1') {
                            $this->_viewParams['importMd'] = true;
                        }
                    }
                    $this->_viewParams['item'] = $item;
                    $this->_viewParams['rank'] = $this->request->get('rank');
                    $this->_viewParams['itemToPaste'] = $itemToPaste;
                    $this->_viewParams['srcMode']     = $mode;
                    /*$this->action = $view;
                                                
                    $this->_viewParams['default_url_params'] = array('action'  => 'show',
                                                                     'id'      => $item->getId());
                    $this->view = 'RedirectAfterCrud';*/
                    $this->_viewParams['item']        = $item;
                    $this->_viewParams['rank']        = $this->request->get('rank');
                    $this->_viewParams['itemToPaste'] = $itemToPaste;
                    $this->_viewParams['srcMode']     = $mode;
                    $this->view                       = 'PasteInProgress';
                }
            }
            break;

        case 'approval_create':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $this->txt('error_perms_edit'));
                $this->view = 'Details';
            } else {
                $this->view = 'ApprovalCreate';
            }
            break;
                                        
        case 'approval_delete':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $this->txt('error_perms_edit'));
                $this->view = 'Details';
            } else {
                if ($this->request->exist('confirm')) {
                    $this->action = $view;
                    $this->_actionParams['item']   = $item;

                    // Version
                    $vVersion = new Valid_UInt('version');
                    $vVersion->required();
                    if($this->request->valid($vVersion)) {
                        $this->_actionParams['version'] = $this->request->get('version');
                    } else {
                        $this->_actionParams['version'] = null;
                    }
                }
                                            
                $this->_viewParams['default_url_params'] = array('action'  => 'details',
                                                                 'section' => 'approval',
                                                                 'id'      => $item->getId());
                $this->view = 'RedirectAfterCrud';
            }
            break;

        case 'approval_update':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $this->txt('error_perms_edit'));
                $this->view = 'Details';
            } else {
                $this->_actionParams['item']   = $item;

                // Settings
                $this->_actionParams['status']       = (int) $this->request->get('status');
                $this->_actionParams['description']  = $this->request->get('description');
                $this->_actionParams['notification'] = (int) $this->request->get('notification');
                $this->_actionParams['reminder']     = $this->request->get('reminder');
                $this->_actionParams['occurence']    = (int) $this->request->get('occurence');
                $this->_actionParams['period']       = (int) $this->request->get('period');

                // Users
                $this->_actionParams['user_list'] = $this->request->get('user_list');
                $this->_actionParams['ugroup_list'] = null;
                if(is_array($this->request->get('ugroup_list'))) {
                    $this->_actionParams['ugroup_list'] = array_map('intval', $this->request->get('ugroup_list'));
                }

                // Selected users
                $this->_actionParams['sel_user'] = null;
                if(is_array($this->request->get('sel_user'))) {
                    $this->_actionParams['sel_user'] = array_map('intval', $this->request->get('sel_user'));
                }
                $allowedAct = array('100', 'mail', 'del');
                $this->_actionParams['sel_user_act'] = null;
                if(in_array($this->request->get('sel_user_act'), $allowedAct)) {
                    $this->_actionParams['sel_user_act'] = $this->request->get('sel_user_act');
                }

                // Resend
                $this->_actionParams['resend_notif'] = false;
                if($this->request->get('resend_notif') == 'yes') {
                    $this->_actionParams['resend_notif'] = true;
                }

                // Version
                $vVersion = new Valid_UInt('version');
                $vVersion->required();
                if($this->request->valid($vVersion)) {
                    $this->_actionParams['version'] = $this->request->get('version');
                } else {
                    $this->_actionParams['version'] = null;
                }

                // Import
                $vImport = new Valid_WhiteList('app_table_import', array('copy', 'reset', 'empty'));
                $vImport->required();
                $this->_actionParams['import'] = $this->request->getValidated('app_table_import', $vImport, false);

                // Owner
                $vOwner = new Valid_String('table_owner');
                $vOwner->required();
                $this->_actionParams['table_owner'] = $this->request->getValidated('table_owner', $vOwner, false);

                //
                // Special handeling of table deletion
                if($this->_actionParams['status'] == PLUGIN_DOCMAN_APPROVAL_TABLE_DELETED) {
                    $this->_viewParams['default_url_params'] = array('action' => 'approval_create',
                                                                     'delete' => 'confirm',
                                                                     'id'     => $item->getId());
                } else {
                    // Action!
                    $this->action = $view;
                    $this->_viewParams['default_url_params'] = array('action'  => 'approval_create',
                                                                     'id'      => $item->getId());
                }
                if($this->_actionParams['version'] !== null) {
                    $this->_viewParams['default_url_params']['version'] = $this->_actionParams['version'];
                }
                $this->view = 'RedirectAfterCrud';
            }
            break;

        case 'approval_upd_user':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $this->txt('error_perms_edit'));
                $this->view = 'Details';
            } else {
                $this->_actionParams['item'] = $item;
                $this->_actionParams['user_id'] = (int) $this->request->get('user_id');
                $this->_actionParams['rank']    = $this->request->get('rank');
                $this->action = $view;

                $this->_viewParams['default_url_params'] = array('action'  => 'approval_create',
                                                                 'id'      => $item->getId());
                $this->view = 'RedirectAfterCrud';
            }
            break;

        case 'approval_del_user':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $this->txt('error_perms_edit'));
                $this->view = 'Details';
            } else {
                $this->_actionParams['item'] = $item;
                $this->_actionParams['user_id'] = (int) $this->request->get('user_id');
                $this->action = $view;

                $this->_viewParams['default_url_params'] = array('action'  => 'approval_create',
                                                                 'id'      => $item->getId());
                $this->view = 'RedirectAfterCrud';
            }
            break;

        case 'approval_user_commit':
            $atf =& Docman_ApprovalTableFactoriesFactory::getFromItem($item);
            $table = $atf->getTable();
            $atrf =& new Docman_ApprovalTableReviewerFactory($table, $item);
            if (!$this->userCanRead($item->getId())
                || !$atrf->isReviewer($user->getId())
                || !$table->isEnabled()) {
                $this->feedback->log('error', $this->txt('error_perms_edit'));
                $this->view = 'Details';
            }
            else {
                $this->_actionParams['item'] = $item;

                $svState = 0;
                $sState = (int) $this->request->get('state');
                if($sState >= 0 && $sState < 5) {
                    $svState = $sState;
                }
                $this->_actionParams['svState'] = $svState;

                $this->_actionParams['sVersion'] = null;
                if($this->request->exist('version')) {
                    $sVersion = (int) $this->request->get('version');
                    switch($item_factory->getItemTypeForItem($item)) {
                    case PLUGIN_DOCMAN_ITEM_TYPE_WIKI:
                        if($sVersion <= 0) {
                            $sVersion = null;
                        }
                    case PLUGIN_DOCMAN_ITEM_TYPE_FILE:
                    case PLUGIN_DOCMAN_ITEM_TYPE_EMBEDDEDFILE:
                        // assume ok: do nothing.
                        break;
                    default:
                        $sVersion = null;
                    }
                    $this->_actionParams['sVersion'] = $sVersion;
                }
                $this->_actionParams['usComment'] = $this->request->get('comment');
                $this->_actionParams['monitor'] = (int) $this->request->get('monitor');

                $this->action = $view;

                $this->_viewParams['default_url_params'] = array('action'  => 'details',
                                                                 'section' => 'approval',
                                                                 'id'      => $item->getId());
                $this->view = 'RedirectAfterCrud';
            }
            break;

        case 'approval_notif_resend':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $this->txt('error_perms_edit'));
                $this->view = 'Details';
            } else {
                $this->action = $view;
                $this->_actionParams['item'] = $item;
                                            
                $this->_viewParams['default_url_params'] = array('action'  => 'approval_create',
                                                                 'id'      => $item->getId());
                $this->view = 'RedirectAfterCrud';
            }
            break;

        case 'edit':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_edit'));
                $this->view = 'Details';
            } else {
                $mdFactory = new Docman_MetadataFactory($this->_viewParams['group_id']);
                $mdFactory->appendAllListOfValuesToItem($item);
                $this->view   = 'Edit';
            }
            break;
        case 'delete':
            if (!($this->userCanWrite($item->getId()) && $this->userCanWrite($item->getParentId()))) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_delete'));
                $this->_set_deleteView_errorPerms();
            } else if ($this->request->exist('confirm')) {
                $this->action = $view;
                $this->_set_redirectView();
            } else {
                $this->view = 'Details';
            }
            break;

        case 'deleteVersion':
            if (!($this->userCanWrite($item->getId()) && $this->userCanWrite($item->getParentId()))) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_delete'));
                $this->_set_deleteView_errorPerms();
            } else if ($this->request->exist('confirm')) {
                $this->action = $view;
                $this->_set_redirectView();
            } else {
                $this->view = 'Details';
            }
            break;

        case 'createFolder':
        case 'createDocument':
        case 'createItem':
            if ($this->request->exist('cancel')) {
                $this->_set_redirectView();
            } else {
                $i = $this->request->get('item');
                if (!$i || !isset($i['parent_id'])) {
                    $this->feedback->log('error', 'Missing parameter.');
                    $this->view = 'DocmanError';
                } else {
                    $parent =& $item_factory->getItemFromDb($i['parent_id']);
                    if (!$parent || $parent->getGroupId() != $this->getGroupId() || !$this->userCanWrite($parent->getId())) {
                        $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_create'));
                        $this->_set_createItemView_errorParentDoesNotExist($item, $get_show_view);
                    } else {
                        //Validations
                        $new_item = $this->createItemFromUserInput();
        
                        $valid = $this->_validateRequest(array_merge($new_item->accept(new Docman_View_GetFieldsVisitor()), 
                                                                     $new_item->accept(new Docman_View_GetSpecificFieldsVisitor(), array('request' => &$this->request))));
                                                    
                        if ($user->isMember($this->getGroupId(), 'A') || $user->isMember($this->getGroupId(), 'N1') || $user->isMember($this->getGroupId(), 'N2')) {
                            $news = $this->request->get('news');
                            if ($news) {
                                $is_news_details = isset($news['details']) && trim($news['details']);
                                $is_news_summary = isset($news['summary']) && trim($news['summary']);
                                if ($is_news_details && !$is_news_summary) {
                                    $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_create_news_summary'));
                                    $valid = false;
                                }
                                if (!$is_news_details && $is_news_summary) {
                                    $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_create_news_details'));
                                    $valid = false;
                                }
                            }
                        }

                        if ($valid) {
                            $this->action = $view;
                            $this->_set_redirectView();
                        } else {
                            // Propagate return page
                            $this->_viewParams['token']               = $this->request->get('token');

                            $this->_viewParams['force_item']          = $new_item;
                            $this->_viewParams['force_news']          = $this->request->get('news');
                            $this->_viewParams['force_permissions']   = $this->request->get('permissions');
                            $this->_viewParams['force_ordering']      = $this->request->get('ordering');
                            $this->_viewParams['display_permissions'] = $this->request->exist('user_has_displayed_permissions');
                            $this->_viewParams['display_news']        = $this->request->exist('user_has_displayed_news');
                            $this->_viewParams['hierarchy']           =& $this->getItemHierarchy($root);
                            $this->_set_createItemView_afterCreate($view);
                        }
                    }
                }
            }
            break;
        case 'update':
            $this->_viewParams['recurseOnDocs'] = false;
            $this->_actionParams['recurseOnDocs'] = false;
            if($this->request->get('recurse_on_doc') == 1) {
                $this->_viewParams['recurseOnDocs'] = true;
                $this->_actionParams['recurseOnDocs'] = true;
            }
        case 'update_wl':
        case 'new_version':
            if (!$this->userCanWrite($item->getId())) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_edit'));
                $this->view = 'Details';
            } else {
                // For properties update ('update' action), we need to confirm
                // the recursive application of metadata update.
                if($view == 'update' &&
                   $this->request->exist('recurse') &&
                   !$this->request->exist('cancel')) {
                    $this->_viewParams['recurse'] = $this->request->get('recurse');
                    if(!$this->request->exist('validate_recurse')) {
                        $updateConfirmed = false;
                    } elseif($this->request->get('validate_recurse') != 'true') {
                        $updateConfirmed = false;
                    } else {
                        $updateConfirmed = true;
                    }
                } else {
                    $updateConfirmed = true;
                }

                $valid = true;
                if ($this->request->exist('confirm')) {
                    //Validations
                    if ($view == 'update') {
                        $this->updateMetadataFromUserInput($item);
                        $valid = $this->_validateRequest($item->accept(new Docman_View_GetFieldsVisitor()));
                    } else {
                        $this->updateItemFromUserInput($item);
                        $valid = (($this->_validateApprovalTable($this->request, $item))&&($this->_validateRequest($item->accept(new Docman_View_GetSpecificFieldsVisitor(), array('request' => &$this->request)))));
                    }
                    //Actions
                    if ($valid && $updateConfirmed) {
                        if ($view == 'update_wl') {
                            $this->action = 'update';
                        } else {
                            $this->action = $view;
                        }
                    }
                }
                //Views
                if ($valid && $updateConfirmed) {
                    if ($redirect_to = Docman_Token::retrieveUrl($this->request->get('token'))) {
                        $this->_viewParams['redirect_to'] = $redirect_to;
                    }
                    $this->view = 'RedirectAfterCrud';
                } else {
                    if ($view == 'update_wl') {
                        $this->view = 'Update';
                    } else if ($view == 'new_version') {
                        // Keep fields values
                        $v = $this->request->get('version');
                        $this->_viewParams['label']     = $v['label'];
                        $this->_viewParams['changelog'] = $v['changelog'];
                        if ($item instanceof Docman_EmbeddedFile) {
                            $v = $item->getCurrentVersion();
                            $v->setContent($this->request->get('content'));
                        }
                        $this->view = 'NewVersion';
                    } else {
                        $mdFactory = new Docman_MetadataFactory($this->_viewParams['group_id']);
                        $mdFactory->appendAllListOfValuesToItem($item);
                        if($this->request->existAndNonEmpty('token')) {
                            // propagate the token so the user will be
                            // redirected to the original page even after
                            // several properties update errors or
                            // confirmations.
                            $this->_viewParams['token'] = $this->request->get('token');
                        }
                        $this->_viewParams['updateConfirmed'] = $updateConfirmed;
                        // The item may have changed (new user input)
                        unset($this->_viewParams['item']);
                        $this->_viewParams['item'] =& $item;

                        $this->view = 'Edit';
                    }
                }
            }
            break;
        case 'change_view':
            $this->action = $view;
            break;
        case 'install':
            $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_alreadyinstalled'));
            $this->view = 'DocmanError';
            break;
        case 'search':
            $this->view = 'Table';
            break;
        case 'positionWithinFolder':
            $this->_viewParams['force_ordering'] = $this->request->get('default_position');
            $this->_viewParams['exclude'] = $this->request->get('exclude');
            $this->_viewParams['hierarchy'] =& $this->getItemHierarchy($root);
            $this->view = ucfirst($view);
            break;
        case 'permissionsForItem':
            $this->_viewParams['user_can_manage'] = $this->userCanManage($item->getId());
            $this->view = ucfirst($view);
            break;
        case 'report_settings':
            $this->view = 'ReportSettings';
            break;
        case 'report_del':
            if($this->request->exist('report_id')) {
                $this->_actionParams['sReportId'] = (int) $this->request->get('report_id');
                $this->_actionParams['sGroupId']  = $this->_viewParams['group_id'];

                $this->action = $view;
            }
            $this->_viewParams['default_url_params'] = array('action'  => 'report_settings');
            $this->view = 'RedirectAfterCrud';
                                        
            break;
        case 'report_upd':
            if($this->request->exist('report_id')) {
                $this->_actionParams['sReportId'] = (int) $this->request->get('report_id');
                $this->_actionParams['sGroupId']  = $this->_viewParams['group_id'];
                $usScope = $this->request->get('scope');
                if($usScope === 'I' || $usScope === 'P') {
                    $this->_actionParams['sScope'] = $usScope;
                }
                $this->_actionParams['description'] = $this->request->get('description');
                $this->_actionParams['title']       = $this->request->get('title');
                $this->_actionParams['sImage'] = (int) $this->request->get('image');

                $this->action = $view;
            }
            $this->_viewParams['default_url_params'] = array('action'  => 'report_settings');
            $this->view = 'RedirectAfterCrud';
            break;

        case 'report_import':
            if($this->request->exist('import_search_report_from_group')) {
                $pm = ProjectManager::instance();
                $srcGroup = $pm->getProjectFromAutocompleter($this->request->get('import_search_report_from_group'));
                if ($srcGroup && !$srcGroup->isError()) {
                    $this->_actionParams['sGroupId']       = $this->_viewParams['group_id'];
                    $this->_actionParams['sImportGroupId'] = $srcGroup->getGroupId();
                    $this->_actionParams['sImportReportId'] = null;
                    if($this->request->exist('import_report_id') && trim($this->request->get('import_report_id')) != '') {
                        $this->_actionParams['sImportReportId'] = (int) $this->request->get('import_report_id');
                    }
                    $this->action = $view;
                }
            }
                                        
            $this->_viewParams['default_url_params'] = array('action'  => 'report_settings');
            $this->view = 'RedirectAfterCrud';
            break;

        case 'action_lock_add':
            $this->_actionParams['item'] = $item;
            $this->action = 'action_lock_add';
            break;

        case 'action_lock_del':
            $this->_actionParams['item'] = $item;
            $this->action = 'action_lock_del';
            break;

        case 'ajax_reference_tooltip':
            $this->view = 'AjaxReferenceTooltip';
            break;
            
        default:
            $purifier = Codendi_HTMLPurifier::instance();
            die($purifier->purify($view) . ' is not supported');

            break;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        }
    }

    function getProperty($name) {
        $info =& $this->plugin->getPluginInfo();
        return $info->getPropertyValueForName($name);
    }
    var $item_factory;
    function &_getItemFactory() {
        if (!$this->item_factory) {
            $this->item_factory =& new Docman_ItemFactory();
        }
        return $this->item_factory;
    }
    
    var $metadataFactory;
    function &_getMetadataFactory($groupId) {
        if(!isset($metadataFactory[$groupId])) {

            $metadataFactory[$groupId] = new Docman_MetadataFactory($groupId);
        }
        return $metadataFactory[$groupId];
    }

    function forceView($view) {
        $this->view = $view;
    }
 
    function _validateApprovalTable($request, $item) {
        $atf = Docman_ApprovalTableFactoriesFactory::getFromItem($item);
        if($atf && $atf->tableExistsForItem()) {
            $vAppTable = new Valid_WhiteList('app_table_import', array('copy', 'reset', 'empty'));
            $vAppTable->required();
            if (!$request->valid($vAppTable)) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_no_option'));
                return false;
            }
        }
        return true;
    }

    function _validateRequest($fields) {
        $valid = true;
        foreach($fields as $field) {
            $validatorList = null;
            if(is_a($field, 'Docman_MetadataHtml')) {
                $fv = $field->getValidator($this->request);
                if($fv !== null) {
                    if(!is_array($fv)) {
                        $validatorList = array($fv);
                    }
                    else {
                        $validatorList =& $fv;
                    }
                }
            }
            else {
                if (isset($field['validator'])) {
                    if (!is_array($field['validator'])) {
                        $validatorList = array($field['validator']);
                    }
                    else {
                        $validatorList = $field['validator'];
                    }
                }
            }
            
            if($validatorList !== null) {
                foreach($validatorList as $v) {
                    if (!$v->isValid()) {
                        $valid = false;
                        foreach($v->getErrors() as $error) {
                            $this->feedback->log('error', $error);
                        }
                    }
                }
            }            
        }
        return $valid;
    }
    
    function validateMetadata($label, &$md) {
        $valid = false;
        
        $mdFactory = new Docman_MetadataFactory($this->groupId);
        if($mdFactory->isValidLabel($label)) {
            $_md =& $mdFactory->getFromLabel($label);
            if($_md !== null 
               && $_md->getGroupId() == $this->groupId) {
                $valid = true;
                $md = $_md;
            }
        }
        
        return $valid;
    }
    
    /**
    * Checks that the new property have a non-empty name,
    * and also checks that the same name is not already taken by
    * another property
    */
    private function validateNewMetadata($name) {
        $name = trim($name);
        if ($name == '') {
            $valid = false;
            $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'admin_metadata_new_name_missing'));
        } else {
            $mdFactory = new Docman_MetadataFactory($this->groupId);
            
            if($mdFactory->findByName($name)->count() == 0) {
                $valid = true;
            } else {
                $valid = false;
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'admin_metadata_new_name_exists', $name));
            }
        }
        
        return $valid;
    }
    
    /**
    * Checks that the updating property have a non-empty name,
    * and if the name have been changed, also checks that the same
    * name is not already taken by another property
    */
    private function validateUpdateMetadata($name, $label) {
        $name = trim($name);
        if ($name == '') {
            $valid = false;
            $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'admin_metadata_new_name_missing'));
        } else {
            $mdFactory = new Docman_MetadataFactory($this->groupId);
            
            $md = $mdFactory->getFromLabel($label);
            // name has changed
            if ($md !== null && $md->getName() != $name) {
                if($mdFactory->findByName($name)->count() == 0) {
                    $valid = true;
                } else {
                    $valid = false;
                    $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'admin_metadata_new_name_exists', $name));
                }
            } else {
                $valid = true;
            }
        }
        
        return $valid;
    }
    
    function validateLove($loveId, $md, &$love) {
        $valid = false;
        
        $loveFactory = new Docman_MetadataListOfValuesElementFactory($md->getId());
        $_love =& $loveFactory->getByElementId($loveId, $md->getLabel());
        if($_love !== null) {
            // Still Need to verify that $love belong to $md
            $valid = true;
            $love = $_love;
        }
        
        return $valid;
    }
    
    function checkPasteIsAllowed($item, &$itemToPaste, &$mode) {
        $isAllowed = false;
        
        $itemFactory =& $this->_getItemFactory();
        $user        =& $this->getUser();
        
        $type = $itemFactory->getItemTypeForItem($item);
        if(PLUGIN_DOCMAN_ITEM_TYPE_FOLDER != $type) {
            $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_paste_in_document'));
        }
        elseif (!$this->userCanWrite($item->getId())) {
            $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_perms_edit'));
        } 
        else {
            $copiedItemId = $itemFactory->getCopyPreference($user);
            $cutItemId    = $itemFactory->getCutPreference($user, $item->getGroupId());
            $itemToPaste  = null;
            
            if ($copiedItemId !== false && $cutItemId === false) {
                $itemToPaste = $itemFactory->getItemFromDb($copiedItemId);
                $mode        = 'copy'; 
            }
            elseif ($item->getId() == $cutItemId) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_paste_same_Item'));
                return false;
            }
            elseif ($copiedItemId === false && $cutItemId !== false) {
                if ($itemFactory->isInSubTree($item->getId(), $cutItemId)) {
                    $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_cut_paste_in_subItem'));
                    return false;
                }
                $itemToPaste = $itemFactory->getItemFromDb($cutItemId);
                $mode        = 'cut';
            } 
            else {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_paste_no_valid_item'));
                return false;
            }
            
            if($itemToPaste == null) {
                $this->feedback->log('error', $GLOBALS['Language']->getText('plugin_docman', 'error_paste_no_valid_item'));
            }
            else {
                $isAllowed = true;
            }
        }
        
        return $isAllowed;
    }
    
    function actionsManagement() {
        // Redefine actions classes names building.
        $className = get_class($this);
        $class = substr($className, 0, -(strlen("Controller"))) . 'Actions';
        require_once($class.'.class.php');
        $wa = new $class($this, $this->gid);
        $wa->process($this->action, $this->_actionParams);
    }

    function viewsManagement() {
        if ($this->view !== null) {
            $className = $this->_includeView();
            if (class_exists($className)) {
                $wv = new $className($this);
                return $wv->display($this->_viewParams);
            } else {
                die($className .' does not exist.');

            }
        }
    }
    function _count(&$item, &$hierarchy, $go = false) {
        $nb = $go ? 1 : 0;
        if (is_a($hierarchy, 'Docman_Folder')) {
            $list =& $hierarchy->getAllItems();
            $iter =& $list->iterator();
            while($iter->valid()) {
                $o =& $iter->current();
                $n = $this->_count($item, $o, $go ? $go : $o->getId() == $item->getId());
                if ($n) {
                    $nb += $n;
                }
                $iter->next();
            }
        }
        return $nb;
    }
    
    function &getItemHierarchy($rootItem) {
        if(!isset($this->hierarchy[$rootItem->getId()])) {
            $itemFactory = new Docman_ItemFactory($rootItem->getGroupId());
            $this->hierarchy[$rootItem->getId()] =& $itemFactory->getItemTree($rootItem, $this->getUser(), false, true);
        }
        return $this->hierarchy[$rootItem->getId()];
    }

    /**
     * @return Project
     */
    private function getProject() {
        return ProjectManager::instance()->getProject($this->getGroupId());
    }

    private function getMailBuilder() {
        return new MailBuilder(TemplateRendererFactory::build());
    }
}
Enalean / tuleap

GitHub Access Token became invalid

Docman_Controller::_dispatch() F last analyzed 2016-01-22 17:23 UTC

Complexity

Size

Duplication

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Docman_Controller::_dispatch() F
last analyzed 2016-01-22 17:23 UTC
