moodle-local_mycerts/locallib.php

<?php
// This file is part of the customcert module for 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/>.

/**
 * Customcert module internal API.
 *
 * @package    mod_customcert
 * @copyright  2013 Mark Nelson <markn@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

defined('MOODLE_INTERNAL') || die();

/**
 * @var string the print protection variable
 */
define('PROTECTION_PRINT', 'print');

/**
 * @var string the modify protection variable
 */
define('PROTECTION_MODIFY', 'modify');

/**
 * @var string the copy protection variable
 */
define('PROTECTION_COPY', 'copy');

/**
 * @var int the number of issues that will be displayed on each page in the report
 * If you want to display all customcerts on a page set this to 0.
 */
define('CUSTOMCERT_PER_PAGE', 20);

/**
 * @var int the max number of issues to display
 */
define('CUSTOMCERT_MAX_PER_PAGE', 300);

/**
 * Handles setting the protection field for the customcert
 *
 * @param stdClass $data
 * @return string the value to insert into the protection field
 */
function customcert_set_protection($data) {
    $protection = array();

    if (!empty($data->protection_print)) {
        $protection[] = PROTECTION_PRINT;
    }
    if (!empty($data->protection_modify)) {
        $protection[] = PROTECTION_MODIFY;
    }
    if (!empty($data->protection_copy)) {
        $protection[] = PROTECTION_COPY;
    }

    // Return the protection string.
    return implode(', ', $protection);
}

/**
 * Handles uploading an image for the customcert module.
 *
 * @param int $draftitemid the draft area containing the files
 * @param int $contextid the context we are storing this image in
 */
function customcert_upload_imagefiles($draftitemid, $contextid) {
    // Save the file if it exists that is currently in the draft area.
    file_save_draft_area_files($draftitemid, $contextid, 'mod_customcert', 'image', 0);
}

/**
 * Return the list of possible elements to add.
 *
 * @return array the list of images that can be used.
 */
function customcert_get_elements() {
    global $CFG;

    // Array to store the element types.
    $options = array();

    // Check that the directory exists.
    $elementdir = "$CFG->dirroot/mod/customcert/element";
    if (file_exists($elementdir)) {
        // Get directory contents.
        $elementfolders = new DirectoryIterator($elementdir);
        // Loop through the elements folder.
        foreach ($elementfolders as $elementfolder) {
            // If it is not a directory or it is '.' or '..', skip it.
            if (!$elementfolder->isDir() || $elementfolder->isDot()) {
                continue;
            }
            // Check that the standard class file exists, if not we do
            // not want to display it as an option as it will not work.
            $foldername = $elementfolder->getFilename();
            $classfile = "$elementdir/$foldername/lib.php";
            if (file_exists($classfile)) {
                // Need to require this file in case if we choose to add this element.
                require_once($classfile);
                $component = "customcertelement_{$foldername}";
                $options[$foldername] = get_string('pluginname', $component);
            }
        }
    }

    customcert_perform_asort($options);
    return $options;
}

/**
 * Return the list of possible fonts to use.
 */
function customcert_get_fonts() {
    global $CFG;

    // Array to store the available fonts.
    $options = array();

    // Location of fonts in Moodle.
    $fontdir = "$CFG->dirroot/lib/tcpdf/fonts";
    // Check that the directory exists.
    if (file_exists($fontdir)) {
        // Get directory contents.
        $fonts = new DirectoryIterator($fontdir);
        // Loop through the font folder.
        foreach ($fonts as $font) {
            // If it is not a file, or either '.' or '..', or
            // the extension is not php, or we can not open file,
            // skip it.
            if (!$font->isFile() || $font->isDot() || ($font->getExtension() != 'php')) {
                continue;
            }
            // Set the name of the font to null, the include next should then set this
            // value, if it is not set then the file does not include the necessary data.
            $name = null;
            // Some files include a display name, the include next should then set this
            // value if it is present, if not then $name is used to create the display name.
            $displayname = null;
            // Some of the TCPDF files include files that are not present, so we have to
            // suppress warnings, this is the TCPDF libraries fault, grrr.
            @include("$fontdir/$font");
            // If no $name variable in file, skip it.
            if (is_null($name)) {
                continue;
            }
            // Remove the extension of the ".php" file that contains the font information.
            $filename = basename($font, ".php");
            // Check if there is no display name to use.
            if (is_null($displayname)) {
                // Format the font name, so "FontName-Style" becomes "Font Name - Style".
                $displayname = preg_replace("/([a-z])([A-Z])/", "$1 $2", $name);
                $displayname = preg_replace("/([a-zA-Z])-([a-zA-Z])/", "$1 - $2", $displayname);
            }
            $options[$filename] = $displayname;
        }
        ksort($options);
    }

    return $options;
}

/**
 * Return the list of possible font sizes to use.
 */
function customcert_get_font_sizes() {
    // Array to store the sizes.
    $sizes = array();

    for ($i = 1; $i <= 60; $i++) {
        $sizes[$i] = $i;
    }

    return $sizes;
}

/**
 * Handles saving page data.
 *
 * @param stdClass $data the customcert data
 */
function customcert_save_page_data($data) {
    global $DB;

    // Set the time to a variable.
    $time = time();

    // Get the existing pages and save the page data.
    if ($pages = $DB->get_records('customcert_pages', array('customcertid' => $data->id))) {
        // Loop through existing pages.
        foreach ($pages as $page) {
            // Get the name of the fields we want from the form.
            $width = 'pagewidth_' . $page->id;
            $height = 'pageheight_' . $page->id;
            // Create the page data to update the DB with.
            $p = new stdClass();
            $p->id = $page->id;
            $p->width = $data->$width;
            $p->height = $data->$height;
            $p->timemodified = $time;
            // Update the page.
            $DB->update_record('customcert_pages', $p);
        }
    }
}

/**
 * Returns an instance of the element class.
 *
 * @param stdClass $element the element
 * @return stdClass|bool returns the instance of the element class, or false if element
 *         class does not exists.
 */
function customcert_get_element_instance($element) {
    global $CFG;

    $classfile = "$CFG->dirroot/mod/customcert/element/{$element->element}/lib.php";
    // Ensure this necessary file exists.
    if (file_exists($classfile)) {
        require_once($classfile);
        $classname = "customcert_element_{$element->element}";
        return new $classname($element);
    }

    return false;
}

/**
 * Handles adding another page to the customcert.
 *
 * @param stdClass $data the form data
 */
function customcert_add_page($data) {
    global $DB;

    // Set the page number to 1 to begin with.
    $pagenumber = 1;
    // Get the max page number.
    $sql = "SELECT MAX(pagenumber) as maxpage
            FROM {customcert_pages} cp
            WHERE cp.customcertid = :customcertid";
    if ($maxpage = $DB->get_record_sql($sql, array('customcertid' => $data->id))) {
        $pagenumber = $maxpage->maxpage + 1;
    }

    // Store time in a variable.
    $time = time();

    // New page creation.
    $page = new stdClass();
    $page->customcertid = $data->id;
    $page->width = '210';
    $page->height = '297';
    $page->pagenumber = $pagenumber;
    $page->timecreated = $time;
    $page->timemodified = $time;

    // Insert the page.
    $DB->insert_record('customcert_pages', $page);
}

/**
 * Handles deleting a page from the customcert.
 *
 * @param int $pageid the customcert page
 */
function customcert_delete_page($pageid) {
    global $DB;

    // Get the page.
    $page = $DB->get_record('customcert_pages', array('id' => $pageid), '*', MUST_EXIST);

    // Delete this page.
    $DB->delete_records('customcert_pages', array('id' => $page->id));

    // The element may have some extra tasks it needs to complete to completely delete itself.
    if ($elements = $DB->get_records('customcert_elements', array('pageid' => $page->id))) {
        foreach ($elements as $element) {
            // Get an instance of the element class.
            if ($e = customcert_get_element_instance($element)) {
                $e->delete_element();
            }
        }
    }

    // Now we want to decrease the page number values of
    // the pages that are greater than the page we deleted.
    $sql = "UPDATE {customcert_pages}
            SET pagenumber = pagenumber - 1
            WHERE customcertid = :customcertid
            AND pagenumber > :pagenumber";
    $DB->execute($sql, array('customcertid' => $page->customcertid,
        'pagenumber' => $page->pagenumber));
}

/**
 * Returns a list of all the templates.
 *
 * @return bool returns true if success, false otherwise
 */
function customcert_get_templates() {
    global $DB;

    return $DB->get_records_menu('customcert_template', array(), 'name ASC', 'id, name');
}

/**
 * Get the time the user has spent in the course.
 *
 * @param int $courseid
 * @return int the total time spent in seconds
 */
function customcert_get_course_time($courseid) {
    global $CFG, $DB, $USER;

    $logmanager = get_log_manager();
    $readers = $logmanager->get_readers();
    $enabledreaders = get_config('tool_log', 'enabled_stores');
    $enabledreaders = explode(',', $enabledreaders);

    // Go through all the readers until we find one that we can use.
    foreach ($enabledreaders as $enabledreader) {
        $reader = $readers[$enabledreader];
        if ($reader instanceof \logstore_legacy\log\store) {
            $logtable = 'log';
            $coursefield = 'course';
            $timefield = 'time';
            break;
        } else if ($reader instanceof \core\log\sql_internal_reader) {
            $logtable = $reader->get_internal_log_table_name();
            $coursefield = 'courseid';
            $timefield = 'timecreated';
            break;
        }
    }

    // If we didn't find a reader then return 0.
    if (!isset($logtable)) {
        return 0;
    }

    $sql = "SELECT id, $timefield
              FROM {{$logtable}}
             WHERE userid = :userid
               AND $coursefield = :courseid
          ORDER BY $timefield ASC";
    $params = array('userid' => $USER->id, 'courseid' => $courseid);
    $totaltime = 0;
    if ($logs = $DB->get_recordset_sql($sql, $params)) {
        foreach ($logs as $log) {
            if (!isset($login)) {
                // For the first time $login is not set so the first log is also the first login
                $login = $log->$timefield;
                $lasthit = $log->$timefield;
                $totaltime = 0;
            }
            $delay = $log->$timefield - $lasthit;
            if ($delay > ($CFG->sessiontimeout * 60)) {
                // The difference between the last log and the current log is more than
                // the timeout Register session value so that we have found a session!
                $login = $log->$timefield;
            } else {
                $totaltime += $delay;
            }
            // Now the actual log became the previous log for the next cycle
            $lasthit = $log->$timefield;
        }

        return $totaltime;
    }

    return 0;
}

/**
 * Returns a list of issued customcerts.
 *
 * @param int $customcertid
 * @param bool $groupmode are we in group mode
 * @param stdClass $cm the course module
 * @param int $page offset
 * @param int $perpage total per page
 * @return stdClass the users
 */
function customcert_get_issues($customcertid, $groupmode, $cm, $page, $perpage) {
    global $DB;

    // Get the conditional SQL.
    list($conditionssql, $conditionsparams) = customcert_get_conditional_issues_sql($cm, $groupmode);

    // Add the conditional SQL and the customcertid to form all used parameters.
    $allparams = $conditionsparams + array('customcertid' => $customcertid);

    // Return the issues.
    return $DB->get_records_sql("SELECT u.*, ci.code, ci.timecreated
                                 FROM {user} u
                                 INNER JOIN {customcert_issues} ci
                                 ON u.id = ci.userid
                                 WHERE u.deleted = 0
                                 AND ci.customcertid = :customcertid
                                 $conditionssql
                                 ORDER BY " . $DB->sql_fullname(),
        $allparams,
        $page * $perpage,
        $perpage);
}

/**
 * Returns the total number of issues for a given customcert.
 *
 * @param int $customcertid
 * @param stdClass $cm the course module
 * @param bool $groupmode the group mode
 * @return int the number of issues
 */
function customcert_get_number_of_issues($customcertid, $cm, $groupmode) {
    global $DB;

    // Get the conditional SQL.
    list($conditionssql, $conditionsparams) = customcert_get_conditional_issues_sql($cm, $groupmode);

    // Add the conditional SQL and the customcertid to form all used parameters.
    $allparams = $conditionsparams + array('customcertid' => $customcertid);

    // Return the number of issues.
    return $DB->count_records_sql("SELECT COUNT(u.id) as count
                                   FROM {user} u
                                   INNER JOIN {customcert_issues} ci
                                   ON u.id = ci.userid
                                   WHERE u.deleted = 0
                                   AND ci.customcertid = :customcertid
                                   $conditionssql",
        $allparams);
}

/**
 * Returns an array of the conditional variables to use in the get_issues SQL query.
 *
 * @param stdClass $cm the course module
 * @param bool $groupmode are we in group mode ?
 * @return array the conditional variables
 */
function customcert_get_conditional_issues_sql($cm, $groupmode) {
    global $CFG, $DB;

    // Get all users that can manage this customcert to exclude them from the report.
    $context = context_module::instance($cm->id);
    $conditionssql = '';
    $conditionsparams = array();
    if ($certmanagers = array_keys(get_users_by_capability($context, 'mod/customcert:manage', 'u.id'))) {
        list($sql, $params) = $DB->get_in_or_equal($certmanagers, SQL_PARAMS_NAMED, 'cert');
        $conditionssql .= "AND NOT u.id $sql \n";
        $conditionsparams += $params;
    }

    $restricttogroup = false;
    if ($groupmode) {
        $currentgroup = groups_get_activity_group($cm);
        if ($currentgroup) {
            $restricttogroup = true;
            $groupusers = array_keys(groups_get_members($currentgroup, 'u.*'));
            if (empty($groupusers)) {
                return array();
            }
        }
    }

    $restricttogrouping = false;

    // If groupmembersonly used, remove users who are not in any group.
    if (!empty($CFG->enablegroupings) and $cm->groupmembersonly) {
        if ($groupingusers = groups_get_grouping_members($cm->groupingid, 'u.id', 'u.id')) {
            $restricttogrouping = true;
        } else {
            return array();
        }
    }

    if ($restricttogroup || $restricttogrouping) {
        if ($restricttogroup) {
            $allowedusers = $groupusers;
        } else if ($restricttogroup && $restricttogrouping) {
            $allowedusers = array_intersect($groupusers, $groupingusers);
        } else {
            $allowedusers = $groupingusers;
        }

        list($sql, $params) = $DB->get_in_or_equal($allowedusers, SQL_PARAMS_NAMED, 'grp');
        $conditionssql .= "AND u.id $sql \n";
        $conditionsparams += $params;
    }

    return array($conditionssql, $conditionsparams);
}

/**
 * Generates a 10-digit code of random letters and numbers.
 *
 * @return string
 */
function customcert_generate_code() {
    global $DB;

    $uniquecodefound = false;
    $code = random_string(10);
    while (!$uniquecodefound) {
        if (!$DB->record_exists('customcert_issues', array('code' => $code))) {
            $uniquecodefound = true;
        } else {
            $code = random_string(10);
        }
    }

    return $code;
}

/**
 * Generate the grid PDF to show the layout of the PDF.
 *
 * @param int $pageid the customcert page
 */
function customcert_generate_grid_pdf($pageid) {
    global $CFG, $DB;

    require_once($CFG->libdir . '/pdflib.php');

    // Get the page.
    $page = $DB->get_record('customcert_pages', array('id' => $pageid), '*', MUST_EXIST);

    // Set the PDF name.
    $pdfname = get_string('gridpdfname', 'customcert', $page->id);

    // Create the pdf object.
    $pdf = new pdf();
    $pdf->setPrintHeader(false);
    $pdf->setPrintFooter(false);
    $pdf->SetTitle($pdfname);
    $pdf->SetMargins(0, 0);
    $pdf->SetAutoPageBreak(true, 0);

    // Add the page to the PDF.
    if ($page->width > $page->height) {
        $orientation = 'L';
    } else {
        $orientation = 'P';
    }
    $pdf->AddPage($orientation, array($page->width, $page->height));

    // The cell width.
    $cellwidth = 10;
    $cellheight = 10;

    // The increments we want to go up in.
    $inc = 20;
    $decpos = 4;

    // Draw first lines before we increment from here.
    $pdf->Line(($inc / 2) + 2, 0, ($inc / 2) + 2, $page->height);
    $pdf->Line(0, ($inc / 2), $page->width, ($inc / 2));

    // Now we want to start drawing the lines to make the grid.
    // Draw the horizontal lines.
    for ($h = $inc; $h <= $page->height; $h += $inc) {
        // Dirty hack cause the printer keeps cutting off characters
        // near the end of the page for some BS reason.
        if (strlen($h) <= 2) {
            $lmargin = 5;
        } else {
            $lmargin = 4;
        }
        // Write the distance we are at.
        $pdf->writeHTMLCell($cellwidth, $cellheight, $lmargin, $h - $decpos, $h);

        // Get the location we are going to draw the line and then draw it.
        $hline = $h + ($inc / 2);
        $pdf->Line(0, $hline, $page->width, $hline);
    }

    // Draw the vertical lines.
    for ($w = $inc; $w <= $page->width; $w += $inc) {
        // Write the distance we are at.
        $pdf->writeHTMLCell($cellwidth, $cellheight, $w - $decpos, 3, $w);

        // Get the location we are going to draw the line and then draw it.
        $wline = $w + ($inc / 2);
        $pdf->Line($wline, 0, $wline, $page->height);
    }

    $pdf->Output($pdfname . '.pdf', 'D');
    exit();
}

/**
 * Generate the PDF for the specified customcert and user.
 *
 * @param stdClass $customcert
 * @param bool $preview true if it is a preview, false otherwise
 */
function customcert_generate_pdf($customcert, $preview = false) {
    global $CFG, $DB;

    require_once($CFG->libdir . '/pdflib.php');

    // Get the pages for the customcert, there should always be at least one page for each customcert.
    if ($pages = $DB->get_records('customcert_pages', array('customcertid' => $customcert->id), 'pagenumber ASC')) {
        // Create the pdf object.
        $pdf = new pdf();
        if (!empty($customcert->protection)) {
            $protection = explode(', ', $customcert->protection);
            $pdf->SetProtection($protection);
        }
        $pdf->setPrintHeader(false);
        $pdf->setPrintFooter(false);
        $pdf->SetTitle($customcert->name);
        $pdf->SetMargins(0, 0);
        $pdf->SetAutoPageBreak(true, 0);
        // Remove full-stop at the end, if it exists, to avoid "..pdf" being created and being filtered by clean_filename.
        $filename = rtrim($customcert->name, '.');
        $filename = clean_filename($filename . '.pdf');
        // Loop through the pages and display their content.
        foreach ($pages as $page) {
            // Add the page to the PDF.
            if ($page->width > $page->height) {
                $orientation = 'L';
            } else {
                $orientation = 'P';
            }
            $pdf->AddPage($orientation, array($page->width, $page->height));
            // Get the elements for the page.
            if ($elements = $DB->get_records('customcert_elements', array('pageid' => $page->id), 'sequence ASC')) {
                // Loop through and display.
                foreach ($elements as $element) {
                    // Get an instance of the element class.
                    if ($e = customcert_get_element_instance($element)) {
                        $e->render($pdf, $preview);
                    }
                }
            }
        }
        $pdf->Output($filename, 'D');
    }
}

/**
 * Generate the report.
 *
 * @param stdClass $customcert
 * @param stdClass $users the list of users who have had a customcert issued
 * @param string $type
 */
function customcert_generate_report_file($customcert, $users, $type) {
    global $CFG, $COURSE;

    if ($type == 'ods') {
        require_once($CFG->libdir . '/odslib.class.php');
        $workbook = new MoodleODSWorkbook('-');
    } else if ($type == 'xls') {
        require_once($CFG->libdir . '/excellib.class.php');
        $workbook = new MoodleExcelWorkbook('-');
    }

    $filename = clean_filename($COURSE->shortname . ' ' . rtrim($customcert->name, '.') . '.' . $type);

    // Send HTTP headers.
    $workbook->send($filename);

    // Creating the first worksheet.
    $myxls = $workbook->add_worksheet(get_string('report', 'customcert'));

    // Print names of all the fields.
    $myxls->write_string(0, 0, get_string('lastname'));
    $myxls->write_string(0, 1, get_string('firstname'));
    $myxls->write_string(0, 2, get_string('idnumber'));
    $myxls->write_string(0, 3, get_string('group'));
    $myxls->write_string(0, 4, get_string('receiveddate', 'customcert'));
    $myxls->write_string(0, 5, get_string('code', 'customcert'));

    // Generate the data for the body of the spreadsheet.
    $row = 1;
    if ($users) {
        foreach ($users as $user) {
            $myxls->write_string($row, 0, $user->lastname);
            $myxls->write_string($row, 1, $user->firstname);
            $studentid = (!empty($user->idnumber)) ? $user->idnumber : ' ';
            $myxls->write_string($row, 2, $studentid);
            $ug2 = '';
            if ($usergrps = groups_get_all_groups($COURSE->id, $user->id)) {
                foreach ($usergrps as $ug) {
                    $ug2 = $ug2 . $ug->name;
                }
            }
            $myxls->write_string($row, 3, $ug2);
            $myxls->write_string($row, 4, userdate($user->timecreated));
            $myxls->write_string($row, 5, $user->code);
            $row++;
        }
    }
    // Close the workbook.
    $workbook->close();
}

/**
 * Perform asort on a given array.
 *
 * @param array $fields
 */
function customcert_perform_asort(&$fields) {
    if (class_exists('core_collator')) {
        core_collator::asort($fields);
    } else {
        collatorlib::asort($fields);
    }
}