search/documents/resource_document.php

   1 <?php
   2 /**
   3 * Global Search Engine for Moodle
   4 *
   5 * @package search
   6 * @category core
   7 * @subpackage document_wrappers
   8 * @author Michael Campanis (mchampan) [cynnical@gmail.com], Valery Fremaux [valery.fremaux@club-internet.fr] > 1.8
   9 * @date 2008/03/31
  10 * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
  11 *
  12 * document handling for all resources
  13 * This file contains the mapping between a resource and it's indexable counterpart,
  14 *
  15 * Functions for iterating and retrieving the necessary records are now also included
  16 * in this file, rather than mod/resource/lib.php
  17 */
  18
  19 /**
  20 * requires and includes
  21 */
  22 require_once("$CFG->dirroot/search/documents/document.php");
  23 require_once("$CFG->dirroot/mod/resource/lib.php");
  24
  25 /* *
  26 * a class for representing searchable information
  27 *
  28 */
  29 class ResourceSearchDocument extends SearchDocument {
  30     public function __construct(&$resource, $context_id) {
  31         // generic information; required
  32         $doc->docid     = $resource['trueid'];
  33         $doc->documenttype = SEARCH_TYPE_RESOURCE;
  34         $doc->itemtype     = $resource['type'];
  35         $doc->contextid    = $context_id;
  36
  37         $doc->title     = strip_tags($resource['name']);
  38         $doc->date      = $resource['timemodified'];
  39         $doc->author    = '';
  40         $doc->contents  = strip_tags($resource['summary']).' '.strip_tags($resource['alltext']);
  41         $doc->url       = resource_make_link($resource['id']);
  42
  43         // module specific information; optional
  44         $data = array();
  45
  46         // construct the parent class
  47         parent::__construct($doc, $data, $resource['course'], 0, 0, PATH_FOR_SEARCH_TYPE_RESOURCE);
  48     } //constructor
  49 } //ResourceSearchDocument
  50
  51 /**
  52 * constructs valid access links to information
  53 * @param resourceId the of the resource
  54 * @return a full featured link element as a string
  55 */
  56 function resource_make_link($resource_id) {
  57     global $CFG;
  58
  59     return $CFG->wwwroot.'/mod/resource/view.php?id='.$resource_id;
  60 } //resource_make_link
  61
  62 /**
  63 * part of standard API
  64 *
  65 */
  66 function resource_iterator() {
  67     //trick to leave search indexer functionality intact, but allow
  68     //this document to only use the below function to return info
  69     //to be searched
  70     return array(true);
  71   } //resource_iterator
  72
  73 /**
  74 * part of standard API
  75 * this function does not need a content iterator, returns all the info
  76 * itself;
  77 * @param notneeded to comply API, remember to fake the iterator array though
  78 * @uses CFG
  79 * @return an array of searchable documents
  80 */
  81 function resource_get_content_for_index(&$notneeded) {
  82     global $CFG;
  83
  84     // starting with Moodle native resources
  85     $documents = array();
  86     $query = "
  87         SELECT
  88             id as trueid,
  89             r.*
  90         FROM
  91             {$CFG->prefix}resource as r
  92         WHERE
  93             alltext != '' AND
  94             alltext != ' ' AND
  95             alltext != '&nbsp;' AND
  96             type != 'file'
  97     ";
  98     $resources = get_records_sql($query);
  99
 100     foreach($resources as $aResource){
 101         $coursemodule = get_field('modules', 'id', 'name', 'resource');
 102         $cm = get_record('course_modules', 'course', $aResource->course, 'module', $coursemodule, 'instance', $aResource->id);
 103         $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 104         $aResource->id = $cm->id;
 105         $documents[] = new ResourceSearchDocument(get_object_vars($aResource), $context->id);
 106         mtrace("finished $aResource->name");
 107     }
 108
 109     // special physical files handling
 110     /**
 111     * this sequence searches for a compatible physical stream handler for getting a text
 112     * equivalence for the content.
 113     *
 114     */
 115     if (@$CFG->block_search_enable_file_indexing){
 116         $query = "
 117             SELECT
 118                r.id as trueid,
 119                cm.id as id,
 120                r.course as course,
 121                r.name as name,
 122                r.summary as summary,
 123                r.alltext as alltext,
 124                r.reference as reference,
 125                r.type as type,
 126                r.timemodified as timemodified
 127             FROM
 128                 {$CFG->prefix}resource as r,
 129                 {$CFG->prefix}course_modules as cm,
 130                 {$CFG->prefix}modules as m
 131             WHERE
 132                r.type = 'file' AND
 133                cm.instance = r.id AND
 134                cm.course = r.course AND
 135                cm.module = m.id AND
 136                m.name = 'resource'
 137         ";
 138         $resources = get_records_sql($query);
 139
 140         // invokes external content extractor if exists.
 141         if ($resources){
 142             foreach($resources as $aResource){
 143                 // fetches a physical indexable document and adds it to documents passed by ref
 144                 $coursemodule = get_field('modules', 'id', 'name', 'resource');
 145                 $cm = get_record('course_modules', 'id', $aResource->id);
 146                 $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 147                 resource_get_physical_file($aResource, $context->id, false, $documents);
 148             }
 149         }
 150     }
 151     return $documents;
 152 } //resource_get_content_for_index
 153
 154 /**
 155 * get text from a physical file
 156 * @param resource a resource for which to fetch some representative text
 157 * @param getsingle if true, returns a single search document, elsewhere return the array
 158 * given as documents increased by one
 159 * @param documents the array of documents, by ref, where to add the new document.
 160 * @return a search document when unique or false.
 161 */
 162 function resource_get_physical_file(&$resource, $context_id, $getsingle, &$documents = null){
 163     global $CFG;
 164
 165     // cannot index empty references
 166     if (empty($resource->reference)){
 167         mtrace("Cannot index, empty reference.");
 168         return false;
 169     }
 170
 171     // cannot index remote resources
 172     if (resource_is_url($resource->reference)){
 173         mtrace("Cannot index remote URLs.");
 174         return false;
 175     }
 176
 177     $fileparts = pathinfo($resource->reference);
 178     // cannot index unknown or masked types
 179     if (empty($fileparts['extension'])) {
 180         mtrace("Cannot index without explicit extension.");
 181         return false;
 182     }
 183
 184     // cannot index non existent file
 185     $file = "{$CFG->dataroot}/{$resource->course}/{$resource->reference}";
 186     if (!file_exists($file)){
 187         mtrace("Missing resource file $file : will not be indexed.");
 188         return false;
 189     }
 190
 191     $ext = strtolower($fileparts['extension']);
 192
 193     // cannot index unallowed or unhandled types
 194     if (!preg_match("/\b$ext\b/i", $CFG->block_search_filetypes)) {
 195         mtrace($fileparts['extension'] . ' is not an allowed extension for indexing');
 196         return false;
 197     }
 198     if (file_exists($CFG->dirroot.'/search/documents/physical_'.$ext.'.php')){
 199         include_once($CFG->dirroot.'/search/documents/physical_'.$ext.'.php');
 200         $function_name = 'get_text_for_indexing_'.$ext;
 201         $resource->alltext = $function_name($resource);
 202         if (!empty($resource->alltext)){
 203             if ($getsingle){
 204                 $single = new ResourceSearchDocument(get_object_vars($resource), $context_id);
 205                 mtrace("finished file $resource->name as {$resource->reference}");
 206                 return $single;
 207             } else {
 208                 $documents[] = new ResourceSearchDocument(get_object_vars($resource), $context_id);
 209             }
 210             mtrace("finished file $resource->name as {$resource->reference}");
 211         }
 212     } else {
 213         mtrace("fulltext handler not found for $ext type");
 214     }
 215     return false;
 216 }
 217
 218 /**
 219 * part of standard API.
 220 * returns a single resource search document based on a resource_entry id
 221 * @param id the id of the accessible document
 222 * @return a searchable object or null if failure
 223 */
 224 function resource_single_document($id, $itemtype) {
 225     global $CFG;
 226
 227     // rewriting with legacy moodle databse API
 228     $query = "
 229         SELECT
 230            r.id as trueid,
 231            cm.id as id,
 232            r.course as course,
 233            r.name as name,
 234            r.summary as summary,
 235            r.alltext as alltext,
 236            r.reference as reference,
 237            r.type as type,
 238            r.timemodified as timemodified
 239         FROM
 240             {$CFG->prefix}resource as r,
 241             {$CFG->prefix}course_modules as cm,
 242             {$CFG->prefix}modules as m
 243         WHERE
 244             cm.instance = r.id AND
 245             cm.course = r.course AND
 246             cm.module = m.id AND
 247             m.name = 'resource' AND
 248             ((r.type != 'file' AND
 249             r.alltext != '' AND
 250             r.alltext != ' ' AND
 251             r.alltext != '&nbsp;') OR
 252             r.type = 'file') AND
 253             r.id = '{$id}'
 254     ";
 255     $resource = get_record_sql($query);
 256
 257     if ($resource){
 258         $coursemodule = get_field('modules', 'id', 'name', 'resource');
 259         $cm = get_record('course_modules', 'id', $resource->id);
 260         $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 261         if ($resource->type == 'file' && @$CFG->block_search_enable_file_indexing){
 262             $document = resource_get_physical_file($resource, true, $context->id);
 263             if (!$document) mtrace("Warning : this document {$resource->name} will not be indexed");
 264             return $document;
 265         } else {
 266             return new ResourceSearchDocument(get_object_vars($resource), $context->id);
 267         }
 268     }
 269     mtrace("null resource");
 270     return null;
 271 } //resource_single_document
 272
 273 /**
 274 * dummy delete function that aggregates id with itemtype.
 275 * this was here for a reason, but I can't remember it at the moment.
 276 *
 277 */
 278 function resource_delete($info, $itemtype) {
 279     $object->id = $info;
 280     $object->itemtype = $itemtype;
 281     return $object;
 282 } //resource_delete
 283
 284 /**
 285 * returns the var names needed to build a sql query for addition/deletions
 286 *
 287 */
 288 function resource_db_names() {
 289     //[primary id], [table name], [time created field name], [time modified field name], [additional where conditions for sql]
 290     return array(array('id', 'resource', 'timemodified', 'timemodified', 'any', " (alltext != '' AND alltext != ' ' AND alltext != '&nbsp;' AND TYPE != 'file') OR TYPE = 'file' "));
 291 } //resource_db_names
 292
 293 /**
 294 * this function handles the access policy to contents indexed as searchable documents. If this
 295 * function does not exist, the search engine assumes access is allowed.
 296 * @param path the access path to the module script code
 297 * @param itemtype the information subclassing (usefull for complex modules, defaults to 'standard')
 298 * @param this_id the item id within the information class denoted by itemtype. In resources, this id
 299 * points to the resource record and not to the module that shows it.
 300 * @param user the user record denoting the user who searches
 301 * @param group_id the current group used by the user when searching
 302 * @return true if access is allowed, false elsewhere
 303 */
 304 function resource_check_text_access($path, $itemtype, $this_id, $user, $group_id, $context_id){
 305     global $CFG;
 306
 307     include_once("{$CFG->dirroot}/{$path}/lib.php");
 308
 309     $r = get_record('resource', 'id', $this_id);
 310     $module_context = get_record('context', 'id', $context_id);
 311     $cm = get_record('course_modules', 'id', $module_context->instanceid);
 312
 313     //check if found course module is visible
 314     if (!$cm->visible and !has_capability('moodle/course:viewhiddenactivities', $module_context)){
 315         return false;
 316     }
 317
 318     return true;
 319 }
 320
 321 /**
 322 * post processes the url for cleaner output.
 323 * @param string $title
 324 */
 325 function resource_link_post_processing($title){
 326     return mb_convert_encoding($title, 'UTF-8', 'auto');
 327 }
 328 ?>