Proyectos de Subversion Moodle

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle 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 3 of the License, or
// (at your option) any later version.
//
// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * this file contains CSV file suspension processor.
 *
 * File         csv.php
 * Encoding     UTF-8
 * @copyright   Sebsoft.nl
 * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace tool_usersuspension\processor;

/**
 * Description of csv
 *
 * @package     tool_usersuspension
 *
 * @copyright   Sebsoft.nl
 * @author      R.J. van Dongen <rogier@sebsoft.nl>
 * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class csv {

    /**
     * @var int SUSPEND MODE
     */
    const MODE_SUSPEND = 1;
    /**
     * @var int UNSUSPEND MODE
     */
    const MODE_UNSUSPEND = 2;

    /**
     * CSV Filename
     * @var string
     */
    protected $file;
    /**
     * CSV read delimiter
     * @var string
     */
    protected $delimiter = ';';
    /**
     * CSV read enclosure
     * @var string
     */
    protected $enclosure = '"';
    /**
     * CSV read escape character
     * @var string
     */
    protected $escape = '\\';
    /**
     * CSV file handle
     * @var string
     */
    protected $fh;
    /**
     * Notification handler.
     * Should be a callable that takes a single string argument
     * @var \callable
     */
    protected $notifycallback;
    /**
     * User exclusion list.
     * This is a list of userids that are excluded from processing.
     * @var array list of userids
     */
    protected $exclusionlist;
    /**
     * Set test run.
     * @var bool
     */
    protected $testmode = false;
    /**
     * Set run mode.
     * @var bool
     */
    protected $mode = 1;

    /**
     * Return CSV filename
     *
     * @return string
     */
    public function get_file() {
        return $this->file;
    }

    /**
     * Return CSV read delimiter
     *
     * @return string
     */
    public function get_delimiter() {
        return $this->delimiter;
    }

    /**
     * Return CSV read enclosure
     *
     * @return string
     */
    public function get_enclosure() {
        return $this->enclosure;
    }

    /**
     * Return CSV read escape character
     *
     * @return string
     */
    public function get_escape() {
        return $this->escape;
    }

    /**
     * Set CSV filename
     *
     * @param string $file filename
     * @return \tool_usersuspension\processor\csv
     */
    public function set_file($file) {
        $this->file = $file;
        return $this;
    }

    /**
     * Set CSV column delimiter
     *
     * @param string $delimiter CSV column delimiter
     * @return \tool_usersuspension\processor\csv
     */
    public function set_delimiter($delimiter) {
        $this->delimiter = $delimiter;
        return $this;
    }

    /**
     * Set CSV enclosure
     *
     * @param string $enclosure CSV enclosure
     * @return \tool_usersuspension\processor\csv
     */
    public function set_enclosure($enclosure) {
        $this->enclosure = $enclosure;
        return $this;
    }

    /**
     * Set CSV escape character
     *
     * @param string $escape CSV escape character
     * @return \tool_usersuspension\processor\csv
     */
    public function set_escape($escape) {
        $this->escape = $escape;
        return $this;
    }

    /**
     * Set callback function for messages, e.g. 'mtrace'.
     * Should take a single string argument denoting the message.
     *
     * @param \callable $notifycallback
     * @return \tool_usersuspension\processor\csv
     */
    public function set_notifycallback($notifycallback) {
        if (is_callable($notifycallback)) {
            $this->notifycallback = $notifycallback;
        }
        return $this;
    }

    /**
     * Do we suspend at all (have a test run)?
     * @return bool
     */
    public function get_testmode() {
        return $this->testmode;
    }

    /**
     * Set no-suspend mode (test mode)
     *
     * @param bool $testmode
     * @return $this
     */
    public function set_testmode($testmode = true) {
        $this->testmode = $testmode;
        return $this;
    }

    /**
     * Get run mode
     * @return int
     */
    public function get_mode() {
        return $this->mode;
    }

    /**
     * Get run mode
     * @param int $mode
     * @return $this
     */
    public function set_mode($mode) {
        $this->mode = $mode;
        return $this;
    }

    /**
     * Create a new instance of a CSV processor
     */
    public function __construct() {
        $this->fh = null;
    }

    /**
     * Pass on a message to the notifycallback, if applicable
     *
     * @param string $msg
     */
    protected function notify($msg) {
        if (isset($this->notifycallback) && $this->notifycallback !== null) {
            call_user_func($this->notifycallback, $msg);
        }
    }

    /**
     * Process the CSV file
     *
     * @return void
     */
    public function process() {
        // Load exclusions.
        $this->notify(get_string('notify:load-exclude-list', 'tool_usersuspension'));
        $this->exclusionlist = \tool_usersuspension\util::get_user_exclusion_list();
        $this->notify(get_string('notify:load-file', 'tool_usersuspension', $this->file));
        $this->fh = fopen($this->file, 'r+b');
        if ($this->fh === false) {
            $this->notify(get_string('notify:load-file-fail', 'tool_usersuspension', $this->file));
            return;
        }
        while (true && !feof($this->fh)) {
            $line = fgetcsv($this->fh, 0, $this->delimiter, $this->enclosure, $this->escape);
            if ($line !== null && $line !== false) {
                if ($line[0] != 'type') {
                    $this->p_process_line($line);
                }
            }
        }
        fclose($this->fh);
    }

    /**
     * Process a single CSV line
     *
     * @param array $line array representing the read CSV line
     * @return bool true if successfully processed, false otherwise
     */
    protected function p_process_line($line) {
        if (count($line) === 1) {
            // Assumes email.
            $line = array('email', $line[0]);
        }
        // Continue normal processing. Note that we CLEAN the params.
        $rs = false;
        $type = clean_param(trim($line[0]), PARAM_ALPHA);
        switch ($type) {
            case 'email':
                $email = clean_param(trim($line[1]), PARAM_EMAIL);
                if ($this->mode == static::MODE_SUSPEND) {
                    $rs = $this->p_suspend_user(array('email' => $email));
                } else {
                    $rs = $this->p_unsuspend_user(array('email' => $email));
                }
                break;
            case 'idnumber':
                $idnumber = clean_param(trim($line[1]), PARAM_NOTAGS);
                if ($this->mode == static::MODE_SUSPEND) {
                    $rs = $this->p_suspend_user(array('idnumber' => $idnumber));
                } else {
                    $rs = $this->p_unsuspend_user(array('idnumber' => $idnumber));
                }
                break;
            case 'username':
                $username = clean_param(trim($line[1]), PARAM_USERNAME);
                if ($this->mode == static::MODE_SUSPEND) {
                    $rs = $this->p_suspend_user(array('username' => $username));
                } else {
                    $rs = $this->p_unsuspend_user(array('username' => $username));
                }
                break;
            default:
                $this->notify(get_string('notify:unknown-suspend-type', 'tool_usersuspension', $type));
                break;
        }
        return $rs;
    }

    /**
     * Performs the user suspension.
     * The user, when found, is checked against the exclusion list to determine
     * if he/she shouldn't be suspended.
     *
     * @param array $params general parameters to use in the query to lookup a record from the database
     * @return bool true if successfully suspended, false otherwise
     */
    protected function p_suspend_user($params) {
        global $CFG, $DB;
        $this->notify(__METHOD__ . ": " . key($params) . ' = ' . current($params));
        $params['mnethostid'] = $CFG->mnet_localhost_id;
        $params['deleted'] = 0;
        $params['suspended'] = 0;
        $user = $DB->get_record('user', $params);
        if (!empty($user)) {
            if (in_array($user->id, $this->exclusionlist)) {
                $this->notify(get_string('notify:suspend-excluded-user', 'tool_usersuspension', $user));
                return;
            }
            $this->notify(get_string('notify:suspend-user', 'tool_usersuspension', $user));
            // Suspend this user.
            if ($this->testmode) {
                $result = true;
                $this->notify(get_string('msg:user:suspend:nosuspendmode', 'tool_usersuspension', $user));
                return $result;
            }
            $result = \tool_usersuspension\util::do_suspend_user($user);
            if ($result === true) {
                $this->notify(get_string('msg:user:suspend:success', 'tool_usersuspension', $user));
            } else {
                $this->notify(get_string('msg:user:suspend:failed', 'tool_usersuspension', $user));
            }
            return $result;
        }
        $this->notify("\t" . get_string('msg:user:not-found', 'tool_usersuspension'));
        return false;
    }

    /**
     * Performs the user suspension.
     * The user, when found, is checked against the exclusion list to determine
     * if he/she shouldn't be suspended.
     *
     * @param array $params general parameters to use in the query to lookup a record from the database
     * @return bool true if successfully suspended, false otherwise
     */
    protected function p_unsuspend_user($params) {
        global $CFG, $DB;
        $this->notify(__METHOD__ . ": " . key($params) . ' = ' . current($params));
        $params['mnethostid'] = $CFG->mnet_localhost_id;
        $params['deleted'] = 0;
        $params['suspended'] = 1;
        $user = $DB->get_record('user', $params);
        if (!empty($user)) {
            if (in_array($user->id, $this->exclusionlist)) {
                $this->notify(get_string('notify:suspend-excluded-user', 'tool_usersuspension', $user));
                return;
            }
            $this->notify(get_string('notify:suspend-user', 'tool_usersuspension', $user));
            // Suspend this user.
            if ($this->testmode) {
                $result = true;
                $this->notify(get_string('msg:user:suspend:nosuspendmode', 'tool_usersuspension', $user));
                return $result;
            }
            $result = \tool_usersuspension\util::do_unsuspend_user($user);
            if ($result === true) {
                $this->notify(get_string('msg:user:unsuspend:success', 'tool_usersuspension', $user));
            } else {
                $this->notify(get_string('msg:user:unsuspend:failed', 'tool_usersuspension', $user));
            }
            return $result;
        }
        $this->notify("\t" . get_string('msg:user:not-found', 'tool_usersuspension'));
        return false;
    }

}