collection.php

<?php
/**
 *
 * @package    mahara
 * @subpackage core
 * @author     Catalyst IT Ltd
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL version 3 or later
 * @copyright  For copyright information on Mahara, please see the README file distributed with this software.
 *
 */

defined('INTERNAL') || die();

class Collection {

    private $id;
    private $name;
    private $description;
    private $owner;
    private $group;
    private $institution;
    private $mtime;
    private $ctime;
    private $navigation;
    private $submittedgroup;
    private $submittedhost;
    private $submittedtime;
    private $submittedstatus;
    private $views;
    private $tags;
    private $framework;
    private $coverimage;
    private $progresscompletion;

    const UNSUBMITTED = 0;
    const SUBMITTED = 1;
    const PENDING_RELEASE = 2;

    public function __construct($id=0, $data=null) {

        if (!empty($id)) {
            $tempdata = get_record('collection','id',$id);
            if (empty($tempdata)) {
                throw new CollectionNotFoundException("Collection with id $id not found");
            }
            if (!empty($data)) {
                $data = array_merge((array)$tempdata, $data);
            }
            else {
                $data = $tempdata; // use what the database has
            }
            $this->id = $id;
        }
        else {
            $this->ctime = time();
            $this->mtime = time();
        }

        if (empty($data)) {
            $data = array();
        }
        foreach ((array)$data as $field => $value) {
            if (property_exists($this, $field)) {
                $this->{$field} = $value;
            }
        }
        if (empty($this->group) && empty($this->institution) && empty($this->owner)) {
            global $USER;
            $this->owner = $USER->get('id');
        }
    }

    public function get($field) {
        if (!property_exists($this, $field)) {
            throw new InvalidArgumentException("Field $field wasn't found in class " . get_class($this));
        }
        if ($field == 'tags') {
            return $this->get_tags();
        }
        if ($field == 'views') {
            return $this->views();
        }
        if ($field == 'coverimage') {
            return $this->get_coverimage();
        }
        return $this->{$field};
    }

    public function set($field, $value) {
        if (property_exists($this, $field)) {
            $this->{$field} = $value;
            $this->mtime = time();
            return true;
        }
        throw new InvalidArgumentException("Field $field wasn't found in class " . get_class($this));
    }

    /**
     * Helper function to create or update a Collection from the supplied data.
     *
     * @param array $data
     * @return collection           The newly created/updated collection
     */
    public static function save($data) {
        if (array_key_exists('id', $data)) {
            $id = $data['id'];
            $state = 'updatecollection';
        }
        else {
            $id = 0;
            $state = 'createcollection';
        }
        $collection = new Collection($id, $data);
        $collection->set('mtime', time());
        $collection->commit();
        $views = $collection->get('views');
        $viewids = array();
        if (!empty($views)) {
            foreach ($views['views'] as $view) {
                $viewids[] = $view->view;
            }
        }
        $eventdata = array('id' => $collection->get('id'),
                           'name' => $collection->get('name'),
                           'eventfor' => 'collection',
                           'viewids' => $viewids);
        handle_event($state, $eventdata);
        return $collection; // return newly created Collections id
    }

    /**
     * Deletes a Collection
     *
     */
    public function delete() {
        $viewids = get_column('collection_view', 'view', 'collection', $this->id);
        db_begin();

        // Delete navigation blocks within the collection's views which point at this collection.
        if ($viewids) {
            $values = $viewids;
            $values[] = 'navigation';
            $navigationblocks = get_records_select_assoc(
                'block_instance', 'view IN (' . join(',', array_fill(0, count($viewids), '?')) . ') AND blocktype = ?',
                $values
            );
            if ($navigationblocks) {
                safe_require('blocktype', 'navigation');
                foreach ($navigationblocks as $b) {
                    $bi = new BlockInstance($b->id, $b);
                    $configdata = $bi->get('configdata');
                    if (isset($configdata['collection']) && $configdata['collection'] == $this->id) {
                        $bi->delete();
                    }
                }
            }
        }

        delete_records('collection_view','collection',$this->id);
        delete_records('tag', 'resourcetype', 'collection', 'resourceid', $this->id);
        if (is_plugin_active('lti', 'module')) {
            delete_records('lti_assessment_submission', 'collectionid', $this->id);
        }
        delete_records('existingcopy', 'collection', $this->id);
        delete_records('collection', 'id', $this->id);
        // Delete any submission history
        delete_records('module_assessmentreport_history', 'event', 'collection', 'itemid', $this->id);

        // Secret url records belong to the collection, so remove them from the view.
        // @todo: add user message to whatever calls this.
        if ($viewids) {
            delete_records_select('view_access', 'view IN (' . join(',', $viewids) . ') AND token IS NOT NULL');
        }
        $data = array('id' => $this->id,
                      'name' => $this->name,
                      'eventfor' => 'collection',
                      'viewids' => $viewids);
        handle_event('deletecollection', $data);
        db_commit();
    }

    /**
     * This method updates the contents of the collection table only.
     */
    public function commit() {
        global $USER;

        $fordb = new stdClass();
        foreach (get_object_vars($this) as $k => $v) {
            $fordb->{$k} = $v;
            if (in_array($k, array('mtime', 'ctime', 'submittedtime')) && !empty($v)) {
                $fordb->{$k} = db_format_timestamp($v);
            }
        }

        db_begin();

        // if id is not empty we are editing an existing collection
        if (!empty($this->id)) {
            update_record('collection', $fordb, 'id');
        }
        else {
            $id = insert_record('collection', $fordb, 'id', true);
            if ($id) {
                $this->set('id', $id);
            }
        }

        if (isset($this->tags)) {
            if ($this->group) {
                $ownertype = 'group';
                $ownerid = $this->group;
            }
            else if ($this->institution) {
                $ownertype = 'institution';
                $ownerid = $this->institution;
            }
            else {
                $ownertype = 'user';
                $ownerid = $this->owner;
            }
            delete_records('tag', 'resourcetype', 'collection', 'resourceid', $this->get('id'));
            $tags = check_case_sensitive($this->get_tags(), 'tag');
            foreach (array_unique($tags) as $tag) {
                //truncate the tag before insert it into the database
                $tag = substr($tag, 0, 128);
                $tag = check_if_institution_tag($tag);
                insert_record('tag',
                    (object)array(
                        'resourcetype' => 'collection',
                        'resourceid' => $this->get('id'),
                        'ownertype' => $ownertype,
                        'ownerid' => $ownerid,
                        'tag' => $tag,
                        'ctime' => db_format_timestamp(time()),
                        'editedby' => $USER->get('id'),
                    )
                );
            }
        }

        db_commit();
    }

    /**
     * Generates a name for a newly created Collection
     */
    private static function new_name($name, $ownerdata) {
        $extText = get_string('version.', 'mahara');
        $tempname = preg_split('/ '. $extText . '[0-9]$/', $name);
        $name = $tempname[0];

        $taken = get_column_sql('
            SELECT name
            FROM {collection}
            WHERE ' . self::owner_sql($ownerdata) . "
                AND name LIKE ? || '%'", array($name));

        $ext = '';
        $i = 1;
        if ($taken) {
            while (in_array($name . $ext, $taken)) {
                $ext = ' ' . $extText . ++$i;
            }
        }
        return $name . $ext;
    }

    /**
     * Copy the cover image of the collection template
     *
     * @param Collection $template the collection template
     * @param array $collectiondata contains data about owner, group, institution of the copy
     * @return int new image artefact id
     */
    private static function copy_setting_coverimage(Collection $template, $collectiondata) {
        safe_require('artefact', 'file');
        $coverimageid = $template->get('coverimage');
        $owner = isset($collectiondata['owner']) ? $collectiondata['owner'] : null;
        $group = isset($collectiondata['group']) ? $collectiondata['group'] : null;
        $institution = isset($collectiondata['institution']) ? $collectiondata['institution'] : null;

        // if the owner of the template and the copy are the same, use the same file
        $sameowner = ($template->get('owner') && $template->get('owner') == $owner) ||
            ($template->get('group') && $template->get('group') == $group) ||
            ($template->get('institution') && $template->get('institution') == $institution);
        if ($sameowner) return $coverimageid;

        if ($coverimageid) {
            try {
                $a = artefact_instance_from_id($coverimageid);
                if ($a instanceof ArtefactTypeImage) {
                    $newid = $a->copy_for_new_owner(
                      $owner,
                      $group,
                      $institution
                    );
                }
                // move to cover image forlder
                $userobj = null;
                if ($owner) {
                    $userobj = new User();
                    $userobj->find_by_id($owner);
                }
                $newa = artefact_instance_from_id($newid);
                $folderid = ArtefactTypeImage::get_coverimage_folder($userobj, $group, $institution);
                $newa->move($folderid);
                return $newid;
            }
            catch (Exception $e) {
                return null;
            }
        }
        return null;
    }

    /**
     * Creates a Collection for the given user, based off a given template and other
     * Collection information supplied.
     *
     * Will set a default name of 'Copy of $collectiontitle' if name is not
     * specified in $collectiondata and $titlefromtemplate == false.
     *
     * @param array $collectiondata Contains information of the old collection, submitted in form
     * @param int $templateid The ID of the Collection to copy
     * @param int $userid     The user who has issued the command to create the
     *                        collection.
     * @param int $checkaccess Whether to check that the user can see the collection before copying it
     * @param boolean $titlefromtemplate  Title of new collection or view will be exactly copied from the template
     *
     * @return array A list consisting of the new collection, the template collection and
     *               information about the copy - i.e. how many blocks and
     *               artefacts were copied
     * @throws SystemException under various circumstances, see the source for
     *                         more information
     */
    public static function create_from_template($collectiondata, $templateid, $userid=null, $checkaccess=true, $titlefromtemplate=false) {
        require_once(get_config('libroot') . 'view.php');
        global $SESSION;

        if (is_null($userid)) {
            global $USER;
            $userid = $USER->get('id');
        }

        db_begin();

        $colltemplate = new Collection($templateid);

        $data = new stdClass();
        // Set a default name if one wasn't set in $collectiondata
        if ($titlefromtemplate) {
            $data->name = $colltemplate->get('name');
        }
        else if (!isset($collectiondata['name'])) {
            $desiredname = $colltemplate->get('name');
            if (get_config('renamecopies')) {
                $desiredname = get_string('Copyof', 'mahara', $desiredname);
            }
            $data->name = self::new_name($desiredname, (object)$collectiondata);
        }
        else {
            $data->name = $collectiondata['name'];
        }
        $data->description = $colltemplate->get('description');
        $data->coverimage = self::copy_setting_coverimage($colltemplate, $collectiondata);
        $data->tags = $colltemplate->get('tags');
        $data->navigation = $colltemplate->get('navigation');
        if (!empty($collectiondata['group'])) {
            $data->group = $collectiondata['group'];
        }
        else if (!empty($collectiondata['institution'])) {
            $data->institution = $collectiondata['institution'];
        }
        else if (!empty($collectiondata['owner'])) {
            $data->owner = $collectiondata['owner'];
        }
        else {
            $data->owner = $userid;
        }
        $data->framework = $colltemplate->get('framework');
        $data->submittedstatus = 0;

        $data->progresscompletion = $colltemplate->get('progresscompletion');
        $collection = self::save($data);

        $numcopied = array('pages' => 0, 'blocks' => 0, 'artefacts' => 0);

        $views = $colltemplate->get('views');
        if (empty($views)) {
            $views['views'] = array();
        }
        $copyviews = array();
        $evidenceviews = array();
        $artefactcopies = array();
        foreach ($views['views'] as $v) {
            $values = array(
                'new' => true,
                'owner' => isset($data->owner) ? $data->owner : null,
                'group' => isset($data->group) ? $data->group : null,
                'institution' => isset($data->institution) ? $data->institution : null,
                'usetemplate' => $v->view
            );
            list($view, $template, $copystatus) = View::create_from_template($values, $v->view, $userid, $checkaccess, $titlefromtemplate, $artefactcopies);
            // Check to see if we need to re-map any framework evidence
            if (!empty($data->framework) && $userid == $data->owner && count_records('framework_evidence', 'view', $v->view)) {
                $evidenceviews[$v->view] = $view->get('id');
            }
            if (isset($copystatus['quotaexceeded'])) {
                $SESSION->clear('messages');
                return array(null, $colltemplate, array('quotaexceeded' => true));
            }
            $copyviews['view_' . $view->get('id')] = true;
            $numcopied['blocks'] += $copystatus['blocks'];
            $numcopied['artefacts'] += $copystatus['artefacts'];
        }
        $numcopied['pages'] = count($views['views']);

        $collection->add_views($copyviews);

        // Update all the navigation blocks referring to this collection
        if ($viewids = get_column('collection_view', 'view', 'collection', $collection->get('id'))) {
            $navblocks = get_records_select_array(
                'block_instance',
                'view IN (' . join(',', array_fill(0, count($viewids), '?')) . ") AND blocktype = 'navigation'",
                $viewids
            );

            if ($navblocks) {
                safe_require('blocktype', 'navigation');
                foreach ($navblocks as $b) {
                    $bi = new BlockInstance($b->id, $b);
                    $configdata = $bi->get('configdata');
                    if (isset($configdata['collection']) && $configdata['collection'] == $templateid) {
                        $bi->set('configdata', array('collection' => $collection->get('id')));
                        $bi->commit();
                    }
                }
            }
        }
        // If there are views with framework evidence to re-map
        if (!empty($evidenceviews)) {
            // We need to get how the old views/artefacts/blocks/evidence fit together
            $evidences = get_records_sql_array('
                SELECT va.view, va.artefact, va.block, fe.*
                FROM {view} v
                JOIN {view_artefact} va ON va.view = v.id
                JOIN {artefact} a ON a.id = va.artefact
                JOIN {framework_evidence} fe ON fe.view = v.id
                WHERE v.id IN (' . join(',', array_keys($evidenceviews)) . ')
                AND a.id IN (' . join(',', array_keys($artefactcopies)) . ')
                AND fe.annotation = va.block', array());
            $newartefactcopies = array();
            foreach ($artefactcopies as $ac) {
                $newartefactcopies[$ac->newid] = 1;
            }
            // And get how the new views/artefacts/blocks fit together
            $newblocks = get_records_sql_assoc('
                SELECT va.artefact, va.view, va.block
                FROM {view} v
                JOIN {view_artefact} va ON va.view = v.id
                JOIN {artefact} a ON a.id = va.artefact
                WHERE v.id IN (' . join(',', array_values($evidenceviews)) . ')
                AND a.id IN (' . join(',', array_keys($newartefactcopies)) . ')
                AND artefacttype = ?', array('annotation'));

            foreach ($evidences as $evidence) {
                if (key_exists($evidence->artefact, $artefactcopies) && key_exists($artefactcopies[$evidence->artefact]->newid, $newartefactcopies)) {
                    $newartefact = $artefactcopies[$evidence->artefact]->newid;
                    $newevidence = new stdClass();
                    $newevidence->view = $newblocks[$newartefact]->view;
                    $newevidence->artefact = $newartefact;
                    $newevidence->annotation = $newblocks[$newartefact]->block;
                    $newevidence->framework = $evidence->framework;
                    $newevidence->element = $evidence->element;
                    $newevidence->state = 0;
                    $newevidence->reviewer = null;
                    $newevidence->ctime = $evidence->ctime;
                    $newevidence->mtime = $evidence->mtime;
                    insert_record('framework_evidence', $newevidence);
                }
            }
        }

        db_commit();

        return array(
            $collection,
            $colltemplate,
            $numcopied,
        );
    }

    /**
     * Returns a list of the current user, group, or institution collections
     *
     * @param offset current page to display
     * @param limit how many collections to display per page
     * @param groupid current group ID
     * @param institutionname current institution name
     * @return array (count: integer, data: array, offset: integer, limit: integer)
     */
    public static function get_mycollections_data($offset=0, $limit=10, $owner=null, $groupid=null, $institutionname=null) {
        if (!empty($groupid)) {
            $wherestm = '"group" = ?';
            $values = array($groupid);
            $count  = count_records('collection', 'group', $groupid);
        }
        else if (!empty($institutionname)) {
            $wherestm = 'institution = ?';
            $values = array($institutionname);
            $count  = count_records('collection', 'institution', $institutionname);
        }
        else if (!empty($owner)) {
            $wherestm = 'owner = ?';
            $values = array($owner);
            $count  = count_records('collection', 'owner', $owner);
        }
        else {
            $count = 0;
        }
        $data = array();
        if ($count > 0) {
            $data = get_records_sql_assoc("
                SELECT
                    c.id,
                    c.description,
                    c.name,
                    c.submittedgroup,
                    c.submittedhost,
                    c.submittedtime,
                    c.framework,
                    (SELECT COUNT(*) FROM {collection_view} cv WHERE cv.collection = c.id) AS numviews
                FROM {collection} c
                WHERE " . $wherestm .
                " ORDER BY c.name, c.ctime, c.id ASC
                ", $values, $offset, $limit);
        }

        self::add_submission_info($data);
        self::add_framework_urls($data);

        $result = (object) array(
            'count'  => $count,
            'data'   => $data,
            'offset' => $offset,
            'limit'  => $limit,
        );
        return $result;
    }

    private static function add_submission_info(&$data) {
        global $CFG;
        require_once($CFG->docroot . 'lib/group.php');

        if (empty($data)) {
            return;
        }

        $records = get_records_sql_assoc('
            SELECT c.id, c.submittedgroup, c.submittedhost, ' . db_format_tsfield('submittedtime') . ',
                   sg.name AS groupname, sg.urlid, sh.name AS hostname
              FROM {collection} c
         LEFT JOIN {group} sg ON c.submittedgroup = sg.id
         LEFT JOIN {host} sh ON c.submittedhost = sh.wwwroot
             WHERE c.id IN (' . join(',', array_fill(0, count($data), '?')) . ')
               AND (c.submittedgroup IS NOT NULL OR c.submittedhost IS NOT NULL)',
            array_keys($data)
        );

        if (empty($records)) {
            return;
        }

        foreach ($records as $r) {
            if (!empty($r->submittedgroup)) {
                $groupdata = (object) array(
                    'id'    => $r->submittedgroup,
                    'name'  => $r->groupname,
                    'urlid' => $r->urlid,
                    'time'  => $r->submittedtime,
                );
                $groupdata->url = group_homepage_url($groupdata);
                $data[$r->id]->submitinfo = $groupdata;
            }
            else if (!empty($r->submittedhost)) {
                $data[$r->id]->submitinfo = (object) array(
                    'name' => $r->hostname,
                    'url'  => $r->submittedhost,
                    'time'  => $r->submittedtime,
                );
            }
        }
    }

    /**
    * Gets the fields for the new/edit collection form
    * - populates the fields with collection data if it is an edit
    *
    * @param array $collection
    * @return array $elements
    */
    public function get_collectionform_elements() {
        safe_require('artefact', 'file');
        global $USER;
        $folder = ArtefactTypeImage::get_coverimage_folder($USER, $this->group, $this->institution);

        $highlight = array(0);
        $elements = array(
            'name' => array(
                'type' => 'text',
                'defaultvalue' => null,
                'title' => get_string('name', 'collection'),
                'size' => 30,
                'rules' => array(
                    'required' => true,
                ),
            ),
            'description' => array(
                'type'  => 'textarea',
                'rows' => 10,
                'cols' => 50,
                'resizable' => false,
                'defaultvalue' => null,
                'title' => get_string('description', 'collection'),
            ),
            'tags'        => array(
                'type'         => 'tags',
                'title'        => get_string('tags'),
                'description'  => get_string('tagsdescprofile'),
                'defaultvalue' => null,
                'help'         => true,
                'institution'  =>  $this->institution,
            ),
            'navigation' => array(
                'type'  => 'switchbox',
                'title' => get_string('viewnavigation','collection'),
                'description' => get_string('viewnavigationdesc','collection'),
                'defaultvalue' => 1,
            ),
            'coverimage' => array(
                'type'         => 'filebrowser',
                'title'        => get_string('coverimage', 'view'),
                'description'  => get_string('coverimagedescription', 'view'),
                'folder'       => $folder,
                'highlight'    => $highlight,
                'accept'       => 'image/*',
                'institution'  => $this->institution,
                'group'        => $this->group,
                'page'         => '',
                'filters'      => array(
                     'artefacttype' => array('image'),
                ),
                'config'       => array(
                    'upload'          => true,
                    'uploadagreement' => get_config_plugin('artefact', 'file', 'uploadagreement'),
                    'resizeonuploaduseroption' => get_config_plugin('artefact', 'file', 'resizeonuploaduseroption'),
                    'resizeonuploaduserdefault' => $USER->get_account_preference('resizeonuploaduserdefault'),
                    'createfolder'    => false,
                    'edit'            => false,
                    'select'          => true,
                    'selectone'       => true,
                ),
                'selectlistcallback' => 'artefact_get_records_by_id',
                'selectcallback'     => 'add_view_coverimage',
                'unselectcallback'   => 'delete_view_coverimage',
            ),
        );
        if ($frameworks = $this->get_available_frameworks()) {
            $options = array('' => get_string('noframeworkselected', 'module.framework'));
            foreach ($frameworks as $framework) {
                $options[$framework->id] = $framework->name;
            }
            $elements['framework'] = array(
                'type' => 'select',
                'title' => get_string('Framework', 'module.framework'),
                'options' => $options,
                'defaultvalue' => $this->framework,
                'width' => '280px',
                'description' => get_string('frameworkdesc', 'module.framework'),
            );
        }

        if ($this->can_have_progresscompletion()) {
            $elements['progresscompletion'] = array(
                'type'  => 'switchbox',
                'title' => get_string('progresscompletion', 'admin'),
                'description' => get_string('progresscompletiondesc', 'collection'),
                'defaultvalue' => 0,
            );
        }


        // populate the fields with the existing values if any
        if (!empty($this->id)) {
            foreach ($elements as $k => $element) {
                if ($k === 'tags') {
                    $elements[$k]['defaultvalue'] = $this->get_tags();
                }
                else if ($k == 'coverimage') {
                    $elements[$k]['defaultvalue'] = ($this->get('coverimage') ? array($this->get('coverimage')) : null);
                }
                else {
                    $elements[$k]['defaultvalue'] = $this->$k;
                }
            }
            $elements['id'] = array(
                'type' => 'hidden',
                'value' => $this->id,
            );
        }
        if (!empty($this->group)) {
            $elements['group'] = array(
                'type' => 'hidden',
                'value' => $this->group,
            );
        }
        else if (!empty($this->institution)) {
            $elements['institution'] = array(
                'type' => 'hidden',
                'value' => $this->institution,
            );
        }
        else if (!empty($this->owner)) {
            $elements['owner'] = array(
                'type' => 'hidden',
                'value' => $this->owner,
            );
        }

        return $elements;
    }

    /**
     * Returns array of views in the current collection
     *
     * @return array views
     */
    public function views() {

        if (!isset($this->views)) {

            $sql = "SELECT v.id, cv.*, v.title, v.owner, v.group, v.institution, v.ownerformat, v.urlid
                FROM {collection_view} cv JOIN {view} v ON cv.view = v.id
                WHERE cv.collection = ?
                ORDER BY cv.displayorder, v.title, v.ctime ASC";

            $result = get_records_sql_assoc($sql, array($this->get('id')));

            if (!empty($result)) {
                require_once('view.php');
                View::get_extra_view_info($result, false, false);
                $result = array_values($result);
                $max = $min = $result[0]['displayorder'];
                foreach ($result as &$r) {
                    $max = max($max, $r['displayorder']);
                    $min = min($min, $r['displayorder']);
                    $r = (object) $r;
                }
                $this->views = array(
                    'views'     => array_values($result),
                    'count'     => count($result),
                    'max'       => $max,
                    'min'       => $min,
                );
            }
            else {
                $this->views = array();
            }

        }

        return $this->views;
    }

    /**
     * Returns first view in the current collection
     *
     * @return View the first view of the collection, null if the collection is empty
     */
    public function first_view() {

        $viewid = get_field('collection_view', 'view', 'collection', $this->get('id'), 'displayorder', '0');
        $viewid = get_field_sql("SELECT cv.view
            FROM {collection_view} cv
            WHERE cv.collection = ?
            AND cv.displayorder = (
                SELECT MIN(displayorder)
                FROM {collection_view} cv2
                WHERE cv2.collection = ?)",
            array($this->get('id'), $this->get('id')));
        if ($viewid) {
            require_once('view.php');
            $view = new View($viewid);
            return $view;
        }
        return null;
    }

    /**
     * Check that a collection can have a framework
     *
     * @return bool
     */
    public function can_have_framework() {
        return ($this->get_framework_institution()) ? true : false;
    }

    /**
     * Check that a collection can have a portfolio progress completion
     *
     * @return bool
     */
    public function can_have_progresscompletion() {
        $allowspc = false;
        if (isset($this->group) && $this->group) {
            return $allowspc;
        }
        if (is_plugin_active('signoff', 'blocktype')) {
            require_once(get_config('docroot') . 'lib/institution.php');
            if ($this->institution) {
                $institution = $this->institution;
                $institution = new Institution($institution);
                $allowspc = ($institution->progresscompletion) ? $institution : false;
            }
            else if ($this->group) {
                $institution = get_field('group', 'institution', 'id', $this->group);
                $institution = new Institution($institution);
                $allowspc = ($institution->progresscompletion) ? $institution : false;
            }
            else {
                $user = new User();
                $user->find_by_id($this->owner);
                $institutionids = array_keys($user->get('institutions'));
                if (!empty($institutionids)) {
                    foreach ($institutionids as $institution) {
                        $institution = new Institution($institution);
                        if ($institution->progresscompletion == true) {
                            $allowspc = $institution;
                            break;
                        }
                    }
                }
                else {
                    $institution = new Institution('mahara');
                    $allowspc = ($institution->progresscompletion) ? $institution : false;
                }
            }
        }
        return $allowspc;
    }

    /**
     * Check if any allowed institutions lets a collection have a framework
     * and return first valid one.
     *
     * Checks:
     * - The collection is not owned by a group
     * - The framework plugin is active
     * - The institution has 'SmartEvidence' turned on
     * - There are frameworks available for the institutions
     *
     * @return object $institution or false
     */
     public function get_framework_institution() {
        require_once('institution.php');
        if (!empty($this->group)) {
            return false;
        }

        if (!is_plugin_active('framework', 'module')) {
            return false;
        }
        $allowsmartevidence = false;
        if ($this->institution) {
            $institution = $this->institution;
            $institution = new Institution($institution);
            $allowsmartevidence = ($institution->allowinstitutionsmartevidence) ? $institution : false;
        }
        else {
            $user = new User();
            $user->find_by_id($this->owner);
            $institutionids = array_keys($user->get('institutions'));
            if (!empty($institutionids)) {
                foreach ($institutionids as $institution) {
                    $institution = new Institution($institution);
                    if ($institution->allowinstitutionsmartevidence == true) {
                        $allowsmartevidence = $institution;
                        break;
                    }
                }
            }
            else {
                $institution = new Institution('mahara');
                $allowsmartevidence = ($institution->allowinstitutionsmartevidence) ? $institution : false;
            }
        }
        return $allowsmartevidence;
    }

    /**
     * Get available frameworks
     *
     * @return array Available frameworks
     */
    public function get_available_frameworks() {
        $institution = $this->get_framework_institution();
        if (!$institution) {
            return array();
        }

        if ($frameworks = Framework::get_frameworks($institution->name, true)) {
            // Inactive frameworks are only allowed if they were added to
            // collection when they were active.
            foreach ($frameworks as $key => $framework) {
                if (empty($framework->active) && $framework->id != $this->framework) {
                    unset ($frameworks[$key]);
                }
            }
            return $frameworks;
        }
        return array();
    }

    /**
     * Check that a collection has a framework
     * - The collection can have a framework
     * - It has a framework id
     * - It has views in the collection
     *
     * @return boolean
     */
    public function has_framework() {
        if (!$this->can_have_framework()) {
            return false;
        }
        if (empty($this->framework)) {
            return false;
        }
        if (!$this->views()) {
            return false;
        }
        if (!is_plugin_active('framework', 'module')) {
            return false;
        }
        return true;
    }

    /**
     * Check that a collection has progress completion enable
     * - The collection can have progress completion enabled
     * - It has progress completion enabled
     * - It has views in the collection
     *
     * @return boolean
     */
    public function has_progresscompletion() {
        if (!$this->can_have_progresscompletion()) {
            return false;
        }
        if (!$this->progresscompletion) {
            return false;
        }
        if (!$this->views()) {
            return false;
        }
        return true;
    }

    /**
     * Get collection framework option for collection navigation
     *
     * @return object $option;
     */
    public function collection_nav_framework_option() {
        $option = new stdClass();
        $option->framework = $this->framework;
        $option->id = $this->id;
        $option->title = get_field('framework', 'name', 'id', $this->framework);
        $option->framework = true;

        $option->fullurl = self::get_framework_url($option);

        return $option;
    }


    /**
     * Get collection framework option for collection navigation
     *
     * @return object $option;
     */
    public function collection_nav_progresscompletion_option() {
        $option = new stdClass();
        $option->id = $this->id;
        $option->title = get_string('progresscompletion', 'admin');
        $option->progresscompletion = true;

        $option->fullurl = self::get_progresscompletion_url($option);

        return $option;
    }

    /**
     * Adding the framework frameworkurl / fullurl to collections
     *
     * @param array  $data    Array of objects
     *
     * @return $data
     */
    public static function add_framework_urls(&$data) {
        if (is_array($data)) {
            foreach ($data as $k => $r) {
                $r->frameworkurl = self::get_framework_url($r, false);
                $r->fullurl = self::get_framework_url($r, true);
            }
        }
    }

    /**
     * Making the framework url
     *
     * @param object $data    Either a collection or standard object
     * @param bool   $fullurl Return full url rather than relative one
     *
     * @return $url
     */
    public static function get_framework_url($data, $fullurl = true) {
        $url = 'module/framework/matrix.php?id=' . $data->id;
        if ($fullurl) {
            return get_config('wwwroot') . $url;
        }
        return $url;
    }

    /**
     * Making the framework url
     *
     * @param object $data    Either a collection or standard object
     * @param bool   $fullurl Return full url rather than relative one
     *
     * @return $url
     */
    public static function get_progresscompletion_url($data, $fullurl = true) {
        $url = 'collection/progresscompletion.php?id=' . $data->id;
        if ($fullurl) {
            return get_config('wwwroot') . $url;
        }
        return $url;
    }

    /**
     * Get the available views the current user can choose to add to their collections.
     * Restrictions on this list include:
     * - currently dashboard, group and profile views are ignored to solve access issues
     * - default pages (with template == 2) are ignored
     * - each view can only belong to one collection
     * - locked/submitted views can't be added to collections
     *
     * @return array $views
     */
    public static function available_views($owner=null, $groupid=null, $institutionname=null) {
        if (!empty($groupid)) {
            $wherestm = '"group" = ?';
            $values = array($groupid);
        }
        else if (!empty($institutionname)) {
            $wherestm = 'institution = ?';
            $values = array($institutionname);
        }
        else if (!empty($owner)) {
            $wherestm = 'owner = ?';
            $values = array($owner);
        }
        else {
            return array();
        }
        ($views = get_records_sql_array("SELECT v.id, v.title
            FROM {view} v
            LEFT JOIN {collection_view} cv ON cv.view = v.id
            WHERE " . $wherestm .
            "   AND cv.view IS NULL
                AND v.type NOT IN ('dashboard','grouphomepage','profile')
                AND v.template != 2
                AND v.submittedgroup IS NULL
                AND v.submittedhost IS NULL
            GROUP BY v.id, v.title
            ORDER BY v.title ASC
            ", $values))
            || ($views = array());
        return $views;
    }

    /**
     * Submits the selected views to the collection
     *
     * @param array values selected views
     * @return integer count so we know what SESSION message to display
     */
    public function add_views($values) {
        require_once(get_config('libroot') . 'view.php');

        $count = 0; // how many views we are adding
        db_begin();

        // each view was marked with a key of view_<id> in order to identify the correct items
        // from the form values
        foreach ($values as $key => $value) {
            if (substr($key,0,5) === 'view_' AND $value == true) {
                $cv = array();
                $cv['view'] = substr($key,5);
                $cv['collection'] = $this->get('id');

                // set displayorder value
                $max = get_field('collection_view', 'MAX(displayorder)', 'collection', $this->get('id'));
                $cv['displayorder'] = is_numeric($max) ? $max + 1 : 0;

                insert_record('collection_view', (object)$cv);
                $count++;
            }
        }

        $viewids = get_column('collection_view', 'view', 'collection', $this->id);

        // Set the most permissive access records on all views
        View::combine_access($viewids, true);

        // Copy the whole view config from the first view to all the others
        if (count($viewids)) {
            $firstview = new View($viewids[0]);
            $viewconfig = array(
                'startdate'       => $firstview->get('startdate'),
                'stopdate'        => $firstview->get('stopdate'),
                'template'        => $firstview->get('template'),
                'retainview'      => $firstview->get('retainview'),
                'allowcomments'   => $firstview->get('allowcomments'),
                'approvecomments' => (int) ($firstview->get('allowcomments') && $firstview->get('approvecomments')),
                'accesslist'      => $firstview->get_access(),
                'lockblocks'      => $firstview->get('lockblocks'),
            );
            View::update_view_access($viewconfig, $viewids);
        }

        // Now that we have added views to the collection we need to update the collection modified date
        $this->mtime = db_format_timestamp(time());
        $this->commit();
        db_commit();

        return $count;
    }

    /**
     * Removes the selected views from the collection
     *
     * @param integer $view the view to remove
     */
    public function remove_view($view) {
        db_begin();

        $position = get_field_sql('
            SELECT displayorder FROM {collection_view}
                WHERE collection = ?
                AND view = ?',
                array($this->get('id'),$view)
        );

        delete_records('collection_view','view',$view,'collection',$this->get('id'));

        $this->update_display_order($position);
        // Secret url records belong to the collection, so remove them from the view.
        // @todo: add user message to whatever calls this.
        delete_records_select('view_access', 'view = ? AND token IS NOT NULL', array($view));

        // Now that we have removed views from the collection we need to update the collection modified date
        $this->mtime = db_format_timestamp(time());
        $this->commit();

        db_commit();
    }

    /**
     * Updates the position number of the views in a collection
     *
     * @param integer $start position from where to start updating
     */
    public function update_display_order($start = 0) {
        $start = intval($start);
        $ids = get_column_sql('
                SELECT view FROM {collection_view}
                WHERE collection = ?
                ORDER BY displayorder', array($this->get('id')));
        foreach ($ids as $k => $v) {
            if ($start <= $k) {
                set_field('collection_view', 'displayorder', $k, 'view', $v, 'collection',$this->get('id'));
            }
        }
    }

    /**
     * Sets the displayorder for a view
     *
     * @param integer   $id   view id
     * @param mixed  direction - either string consisting 'up' or 'down' to
     *               indicate which way to move $id item, or an array containing
     *               the ids in order you want them saved
     */
    public function set_viewdisplayorder($id, $direction) {
        if (is_array($direction)) {
            // we already have new sort order
            $neworder = $direction;
        }
        else {
            $ids = get_column_sql('
                SELECT view FROM {collection_view}
                WHERE collection = ?
                ORDER BY displayorder', array($this->get('id')));

            foreach ($ids as $k => $v) {
                if ($v == $id) {
                    $oldorder = $k;
                    break;
                }
            }

            if ($direction == 'up' && $oldorder > 0) {
                $neworder = array_merge(array_slice($ids, 0, $oldorder - 1),
                                        array($id, $ids[$oldorder-1]),
                                        array_slice($ids, $oldorder+1));
            }
            else if ($direction == 'down' && ($oldorder + 1 < count($ids))) {
                $neworder = array_merge(array_slice($ids, 0, $oldorder),
                                        array($ids[$oldorder+1], $id),
                                        array_slice($ids, $oldorder+2));
            }
        }
        if (isset($neworder)) {
            foreach ($neworder as $k => $v) {
                set_field('collection_view', 'displayorder', $k, 'view', $v, 'collection',$this->get('id'));
            }
            $this->set('mtime', time());
            $this->commit();
        }
    }

    /**
     * after editing the collection, redirect back to the appropriate place
     */
    public function post_edit_redirect($new=false, $copy=false, $urlparams=null) {
        $redirecturl = post_edit_redirect_url($new, $copy, $urlparams);
        redirect($redirecturl);
    }

    /**
     * returns the url that we need to redirect to sfter editing a collection
     */
    public function post_edit_redirect_url($new=false, $copy=false, $urlparams=null) {
        $redirecturl = get_config('wwwroot');
        if ($new || $copy) {
            $urlparams['id'] = $this->get('id');
            $redirecturl .= 'collection/views.php';
        }
        else {
            if ($this->get('group')) {
                // Group owned collection
                $redirecturl .= 'view/groupviews.php';
            }
            else if ($this->get('institution')) {
                if ($this->get('institution') == 'mahara') {
                    // Site owned collection
                    <