← Back to branch summary

~ubuntu-branches/ubuntu/trusty/moodle/trusty-proposed

« back to all changes in this revision

Viewing changes to blog/locallib.php

  • Committer: Package Import Robot
  • Author(s): Thijs Kinkhorst
  • Date: 2013-07-19 08:52:46 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20130719085246-yebwditc2exoap2r
Tags: 2.5.1-1
http://bugs.debian.org/429339
http://bugs.debian.org/716972
http://bugs.debian.org/716986
http://bugs.debian.org/717080
http://bugs.debian.org/717108
http://bugs.debian.org/717278
* New upstream version: 2.5.1.
  - Fixes security issues:
    CVE-2013-2242 CVE-2013-2243 CVE-2013-2244 CVE-2013-2245
    CVE-2013-2246
* Depend on apache2 instead of obsolete apache2-mpm-prefork.
* Use packaged libphp-phpmailer (closes: #429339), adodb,
  HTMLPurifier, PclZip.
* Update debconf translations, thanks Salvatore Merone, Pietro Tollot,
  Joe Hansen, Yuri Kozlov, Holger Wansing, Américo Monteiro,
  Adriano Rafael Gomes, victory, Michał Kułach.
  (closes: #716972, #716986, #717080, #717108, #717278)

Show diffs side-by-side

added added

removed removed

Lines of Context:
blog/locallib.php
39
39
 * @copyright  2009 Nicolas Connault
40
40
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
41
41
 */
42
 
class blog_entry {
 
42
class blog_entry implements renderable {
43
43
    // Public Database fields
44
44
    public $id;
45
45
    public $userid;
66
66
    public $form;
67
67
    public $tags = array();
68
68
 
 
69
    /** @var StdClass Data needed to render the entry */
 
70
    public $renderable;
 
71
 
69
72
    // Methods
70
73
    /**
71
74
     * Constructor. If given an id, will fetch the corresponding record from the DB.
73
76
     * @param mixed $idorparams A blog entry id if INT, or data for a new entry if array
74
77
     */
75
78
    public function __construct($id=null, $params=null, $form=null) {
76
 
        global $DB, $PAGE;
 
79
        global $DB, $PAGE, $CFG;
77
80
 
78
81
        if (!empty($id)) {
79
82
            $object = $DB->get_record('post', array('id' => $id));
86
89
            }
87
90
        }
88
91
 
 
92
        if (!empty($CFG->useblogassociations)) {
 
93
            $associations = $DB->get_records('blog_association', array('blogid' => $this->id));
 
94
            foreach ($associations as $association) {
 
95
                $context = context::instance_by_id($association->contextid);
 
96
                if ($context->contextlevel == CONTEXT_COURSE) {
 
97
                    $this->courseassoc = $association->contextid;
 
98
                } else if ($context->contextlevel == CONTEXT_MODULE) {
 
99
                    $this->modassoc = $association->contextid;
 
100
                }
 
101
            }
 
102
        }
 
103
 
89
104
        $this->form = $form;
90
105
    }
91
106
 
 
107
 
92
108
    /**
93
 
     * Prints or returns the HTML for this blog entry.
94
 
     *
95
 
     * @param bool $return
96
 
     * @return string
 
109
     * Gets the required data to print the entry
97
110
     */
98
 
    public function print_html($return=false) {
99
 
 
100
 
        global $USER, $CFG, $COURSE, $DB, $OUTPUT, $PAGE;
101
 
 
102
 
        $user = $DB->get_record('user', array('id'=>$this->userid));
103
 
        $cmttext = '';
 
111
    public function prepare_render() {
 
112
 
 
113
        global $DB, $CFG, $PAGE;
 
114
 
 
115
        $this->renderable = new StdClass();
 
116
 
 
117
        $this->renderable->user = $DB->get_record('user', array('id'=>$this->userid));
 
118
 
 
119
        // Entry comments.
104
120
        if (!empty($CFG->usecomments) and $CFG->blogusecomments) {
105
121
            require_once($CFG->dirroot . '/comment/lib.php');
106
 
            // Comments
 
122
 
107
123
            $cmt = new stdClass();
108
 
            $cmt->context = get_context_instance(CONTEXT_USER, $user->id);
 
124
            $cmt->context = context_user::instance($this->userid);
109
125
            $cmt->courseid = $PAGE->course->id;
110
126
            $cmt->area = 'format_blog';
111
127
            $cmt->itemid = $this->id;
112
128
            $cmt->showcount = $CFG->blogshowcommentscount;
113
129
            $cmt->component = 'blog';
114
 
            $comment = new comment($cmt);
115
 
            $cmttext = $comment->output(true);
 
130
            $this->renderable->comment = new comment($cmt);
116
131
        }
 
132
 
117
133
        $this->summary = file_rewrite_pluginfile_urls($this->summary, 'pluginfile.php', SYSCONTEXTID, 'blog', 'post', $this->id);
118
134
 
119
 
        $options = array('overflowdiv'=>true);
120
 
        $template['body'] = format_text($this->summary, $this->summaryformat, $options);
121
 
        $template['title'] = format_string($this->subject);
122
 
        $template['userid'] = $user->id;
123
 
        $template['author'] = fullname($user);
124
 
        $template['created'] = userdate($this->created);
125
 
 
126
 
        if ($this->created != $this->lastmodified) {
127
 
            $template['lastmod'] = userdate($this->lastmodified);
128
 
        }
129
 
 
130
 
        $template['publishstate'] = $this->publishstate;
131
 
 
132
 
        $stredit = get_string('edit');
133
 
        $strdelete = get_string('delete');
134
 
 
135
 
        // Check to see if the entry is unassociated with group/course level access
136
 
        $unassociatedentry = false;
137
 
        if (!empty($CFG->useblogassociations) && ($this->publishstate == 'group' || $this->publishstate == 'course')) {
138
 
            if (!$DB->record_exists('blog_association', array('blogid' => $this->id))) {
139
 
                $unassociatedentry = true;
140
 
            }
141
 
        }
142
 
 
143
 
        // Start printing of the blog
144
 
        $table = new html_table();
145
 
        $table->cellspacing = 0;
146
 
        $table->attributes['class'] = 'forumpost blog_entry blog'. ($unassociatedentry ? 'draft' : $template['publishstate']);
147
 
        $table->attributes['id'] = 'b'.$this->id;
148
 
        $table->width = '100%';
149
 
 
150
 
        $picturecell = new html_table_cell();
151
 
        $picturecell->attributes['class'] = 'picture left';
152
 
        $picturecell->text = $OUTPUT->user_picture($user);
153
 
 
154
 
        $table->head[] = $picturecell;
155
 
 
156
 
        $topiccell = new html_table_cell();
157
 
        $topiccell->attributes['class'] = 'topic starter';
158
 
        $titlelink =  html_writer::link(new moodle_url('/blog/index.php', array('entryid' => $this->id)), $template['title']);
159
 
        $topiccell->text = $OUTPUT->container($titlelink, 'subject');
160
 
        $topiccell->text .= $OUTPUT->container_start('author');
161
 
 
162
 
        $fullname = fullname($user, has_capability('moodle/site:viewfullnames', get_context_instance(CONTEXT_COURSE, $PAGE->course->id)));
163
 
        $by = new stdClass();
164
 
        $by->name =  html_writer::link(new moodle_url('/user/view.php', array('id' => $user->id, 'course' => $PAGE->course->id)), $fullname);
165
 
        $by->date = $template['created'];
166
 
 
167
 
        $topiccell->text .= get_string('bynameondate', 'forum', $by);
168
 
        $topiccell->text .= $OUTPUT->container_end();
169
 
 
 
135
        // External blog link.
170
136
        if ($this->uniquehash && $this->content) {
171
137
            if ($externalblog = $DB->get_record('blog_external', array('id' => $this->content))) {
172
138
                $urlparts = parse_url($externalblog->url);
173
 
                $topiccell->text .= $OUTPUT->container(get_string('retrievedfrom', 'blog').get_string('labelsep', 'langconfig').html_writer::link($urlparts['scheme'].'://'.$urlparts['host'], $externalblog->name), 'externalblog');
174
 
            }
175
 
        }
176
 
 
177
 
        $topiccell->header = false;
178
 
        $table->head[] = $topiccell;
179
 
 
180
 
        // Actual content
181
 
        $mainrow = new html_table_row();
182
 
 
183
 
        $leftsidecell = new html_table_cell();
184
 
        $leftsidecell->attributes['class'] = 'left side';
185
 
        $mainrow->cells[] = $leftsidecell;
186
 
 
187
 
        $contentcell = new html_table_cell();
188
 
        $contentcell->attributes['class'] = 'content';
189
 
 
190
 
        $attachedimages = $OUTPUT->container($this->print_attachments(), 'attachments');
191
 
 
192
 
        // retrieve associations in case they're needed early
193
 
        $blogassociations = $DB->get_records('blog_association', array('blogid' => $this->id));
194
 
 
195
 
        // determine text for publish state
196
 
        switch ($template['publishstate']) {
197
 
            case 'draft':
198
 
                $blogtype = get_string('publishtonoone', 'blog');
199
 
            break;
200
 
            case 'site':
201
 
                $blogtype = get_string('publishtosite', 'blog');
202
 
            break;
203
 
            case 'public':
204
 
                $blogtype = get_string('publishtoworld', 'blog');
205
 
            break;
206
 
            default:
207
 
                $blogtype = '';
208
 
            break;
209
 
 
210
 
        }
211
 
 
212
 
        $contentcell->text .= $OUTPUT->container($blogtype, 'audience');
213
 
 
214
 
        $contentcell->text .= $template['body'];
215
 
        $contentcell->text .= $attachedimages;
216
 
 
217
 
        // Uniquehash is used as a link to an external blog
218
 
        if (!empty($this->uniquehash)) {
219
 
            $contentcell->text .= $OUTPUT->container_start('externalblog');
220
 
            $contentcell->text .= html_writer::link($this->uniquehash, get_string('linktooriginalentry', 'blog'));
221
 
            $contentcell->text .= $OUTPUT->container_end();
222
 
        }
223
 
 
224
 
        // Links to tags
225
 
        $officialtags = tag_get_tags_csv('post', $this->id, TAG_RETURN_HTML, 'official');
226
 
        $defaulttags = tag_get_tags_csv('post', $this->id, TAG_RETURN_HTML, 'default');
227
 
 
228
 
        if (!empty($CFG->usetags) && ($officialtags || $defaulttags) ) {
229
 
            $contentcell->text .= $OUTPUT->container_start('tags');
230
 
 
231
 
            if ($officialtags) {
232
 
                $contentcell->text .= get_string('tags', 'tag') .': '. $OUTPUT->container($officialtags, 'officialblogtags');
233
 
                if ($defaulttags) {
234
 
                    $contentcell->text .=  ', ';
235
 
                }
236
 
            }
237
 
            $contentcell->text .=  $defaulttags;
238
 
            $contentcell->text .= $OUTPUT->container_end();
239
 
        }
240
 
 
241
 
        // Add associations
242
 
        if (!empty($CFG->useblogassociations) && $blogassociations) {
243
 
            $contentcell->text .= $OUTPUT->container_start('tags');
244
 
            $assocstr = '';
245
 
            $hascourseassocs = false;
246
 
            $assoctype = '';
247
 
 
248
 
            // First find and show the associated course
249
 
            foreach ($blogassociations as $assocrec) {
250
 
                $context = get_context_instance_by_id($assocrec->contextid);
251
 
                if ($context->contextlevel ==  CONTEXT_COURSE) {
252
 
                    $assocurl = new moodle_url('/course/view.php', array('id' => $context->instanceid));
253
 
                    $text = $DB->get_field('course', 'shortname', array('id' => $context->instanceid)); //TODO: performance!!!!
254
 
                    $assocstr .= $OUTPUT->action_icon($assocurl, new pix_icon('i/course', $text), null, array(), true);
255
 
                    $hascourseassocs = true;
256
 
                    $assoctype = get_string('course');
257
 
                }
258
 
            }
259
 
 
260
 
            // Now show mod association
261
 
            foreach ($blogassociations as $assocrec) {
262
 
                $context = get_context_instance_by_id($assocrec->contextid);
263
 
 
264
 
                if ($context->contextlevel ==  CONTEXT_MODULE) {
265
 
                    if ($hascourseassocs) {
266
 
                        $assocstr .= ', ';
267
 
                        $hascourseassocs = false;
268
 
                    }
269
 
 
270
 
                    $modinfo = $DB->get_record('course_modules', array('id' => $context->instanceid));
271
 
                    $modname = $DB->get_field('modules', 'name', array('id' => $modinfo->module));
272
 
 
273
 
                    $assocurl = new moodle_url('/mod/'.$modname.'/view.php', array('id' => $modinfo->id));
274
 
                    $text = $DB->get_field($modname, 'name', array('id' => $modinfo->instance)); //TODO: performance!!!!
275
 
                    $assocstr .= $OUTPUT->action_icon($assocurl, new pix_icon('icon', $text, $modname), null, array(), true);
276
 
                    $assocstr .= ', ';
277
 
                    $assoctype = get_string('modulename', $modname);
278
 
 
279
 
                }
280
 
            }
281
 
            $assocstr = substr($assocstr, 0, -2);
282
 
            $contentcell->text .= get_string('associated', 'blog', $assoctype) . ': '. $assocstr;
283
 
 
284
 
            $contentcell->text .= $OUTPUT->container_end();
285
 
        }
286
 
 
287
 
        if ($unassociatedentry) {
288
 
            $contentcell->text .= $OUTPUT->container(get_string('associationunviewable', 'blog'), 'noticebox');
289
 
        }
290
 
 
291
 
    /// Commands
292
 
 
293
 
        $contentcell->text .= $OUTPUT->container_start('commands');
294
 
 
295
 
        if (blog_user_can_edit_entry($this)) {
296
 
            if (empty($this->uniquehash)) {
297
 
                //External blog entries should not be edited
298
 
                $contentcell->text .= html_writer::link(new moodle_url('/blog/edit.php',
299
 
                                                        array('action' => 'edit', 'entryid' => $this->id)),
300
 
                                                        $stredit) . ' | ';
301
 
            }
302
 
            $contentcell->text .= html_writer::link(new moodle_url('/blog/edit.php',
303
 
                                                    array('action' => 'delete', 'entryid' => $this->id)),
304
 
                                                    $strdelete) . ' | ';
305
 
        }
306
 
 
307
 
        $contentcell->text .= html_writer::link(new moodle_url('/blog/index.php', array('entryid' => $this->id)), get_string('permalink', 'blog'));
308
 
 
309
 
        $contentcell->text .= $OUTPUT->container_end();
310
 
 
311
 
        if (isset($template['lastmod']) ){
312
 
            $contentcell->text .= '<div style="font-size: 55%;">';
313
 
            $contentcell->text .= ' [ '.get_string('modified').': '.$template['lastmod'].' ]';
314
 
            $contentcell->text .= '</div>';
315
 
        }
316
 
 
317
 
        //add comments under everything
318
 
        $contentcell->text .= $cmttext;
319
 
 
320
 
        $mainrow->cells[] = $contentcell;
321
 
        $table->data = array($mainrow);
322
 
 
323
 
        if ($return) {
324
 
            return html_writer::table($table);
325
 
        } else {
326
 
            echo html_writer::table($table);
327
 
        }
 
139
                $this->renderable->externalblogtext = get_string('retrievedfrom', 'blog') . get_string('labelsep', 'langconfig');
 
140
                $this->renderable->externalblogtext .= html_writer::link($urlparts['scheme'] . '://'.$urlparts['host'], $externalblog->name);
 
141
            }
 
142
        }
 
143
 
 
144
        // Retrieve associations
 
145
        $this->renderable->unassociatedentry = false;
 
146
        if (!empty($CFG->useblogassociations)) {
 
147
 
 
148
            // Adding the entry associations data.
 
149
            if ($associations = $associations = $DB->get_records('blog_association', array('blogid' => $this->id))) {
 
150
 
 
151
                // Check to see if the entry is unassociated with group/course level access.
 
152
                if ($this->publishstate == 'group' || $this->publishstate == 'course') {
 
153
                    $this->renderable->unassociatedentry = true;
 
154
                }
 
155
 
 
156
                foreach ($associations as $key => $assocrec) {
 
157
 
 
158
                    if (!$context = context::instance_by_id($assocrec->contextid, IGNORE_MISSING)) {
 
159
                        unset($associations[$key]);
 
160
                        continue;
 
161
                    }
 
162
 
 
163
                    // The renderer will need the contextlevel of the association.
 
164
                    $associations[$key]->contextlevel = $context->contextlevel;
 
165
 
 
166
                    // Course associations.
 
167
                    if ($context->contextlevel ==  CONTEXT_COURSE) {
 
168
                        $instancename = $DB->get_field('course', 'shortname', array('id' => $context->instanceid)); //TODO: performance!!!!
 
169
 
 
170
                        $associations[$key]->url = $assocurl = new moodle_url('/course/view.php', array('id' => $context->instanceid));
 
171
                        $associations[$key]->text = $instancename;
 
172
                        $associations[$key]->icon = new pix_icon('i/course', $associations[$key]->text);
 
173
                    }
 
174
 
 
175
                    // Mod associations.
 
176
                    if ($context->contextlevel ==  CONTEXT_MODULE) {
 
177
 
 
178
                        // Getting the activity type and the activity instance id
 
179
                        $sql = 'SELECT cm.instance, m.name FROM {course_modules} cm
 
180
                                  JOIN {modules} m ON m.id = cm.module
 
181
                                 WHERE cm.id = :cmid';
 
182
                        $modinfo = $DB->get_record_sql($sql, array('cmid' => $context->instanceid));
 
183
                        $instancename = $DB->get_field($modinfo->name, 'name', array('id' => $modinfo->instance)); //TODO: performance!!!!
 
184
 
 
185
                        $associations[$key]->type = get_string('modulename', $modinfo->name);
 
186
                        $associations[$key]->url = new moodle_url('/mod/' . $modinfo->name . '/view.php', array('id' => $context->instanceid));
 
187
                        $associations[$key]->text = $instancename;
 
188
                        $associations[$key]->icon = new pix_icon('icon', $associations[$key]->text, $modinfo->name);
 
189
                    }
 
190
                }
 
191
            }
 
192
            $this->renderable->blogassociations = $associations;
 
193
        }
 
194
 
 
195
        // Entry attachments.
 
196
        $this->renderable->attachments = $this->get_attachments();
 
197
 
 
198
        $this->renderable->usercanedit = blog_user_can_edit_entry($this);
 
199
    }
 
200
 
 
201
 
 
202
    /**
 
203
     * Gets the entry attachments list
 
204
     * @return array List of blog_entry_attachment instances
 
205
     */
 
206
    function get_attachments() {
 
207
 
 
208
        global $CFG;
 
209
 
 
210
        require_once($CFG->libdir.'/filelib.php');
 
211
 
 
212
        $syscontext = context_system::instance();
 
213
 
 
214
        $fs = get_file_storage();
 
215
        $files = $fs->get_area_files($syscontext->id, 'blog', 'attachment', $this->id);
 
216
 
 
217
        // Adding a blog_entry_attachment for each non-directory file.
 
218
        $attachments = array();
 
219
        foreach ($files as $file) {
 
220
            if ($file->is_directory()) {
 
221
                continue;
 
222
            }
 
223
            $attachments[] = new blog_entry_attachment($file, $this->id);
 
224
        }
 
225
 
 
226
        return $attachments;
328
227
    }
329
228
 
330
229
    /**
364
263
        }
365
264
 
366
265
        tag_set('post', $this->id, $this->tags);
 
266
        events_trigger('blog_entry_added', $this);
367
267
    }
368
268
 
369
269
    /**
375
275
    public function edit($params=array(), $form=null, $summaryoptions=array(), $attachmentoptions=array()) {
376
276
        global $CFG, $USER, $DB, $PAGE;
377
277
 
378
 
        $sitecontext = get_context_instance(CONTEXT_SYSTEM);
 
278
        $sitecontext = context_system::instance();
379
279
        $entry = $this;
380
280
 
381
281
        $this->form = $form;
397
297
        tag_set('post', $entry->id, $entry->tags);
398
298
 
399
299
        add_to_log(SITEID, 'blog', 'update', 'index.php?userid='.$USER->id.'&entryid='.$entry->id, $entry->subject);
 
300
        events_trigger('blog_entry_edited', $entry);
400
301
    }
401
302
 
402
303
    /**
414
315
        tag_set('post', $this->id, array());
415
316
 
416
317
        add_to_log(SITEID, 'blog', 'delete', 'index.php?userid='. $this->userid, 'deleted blog entry with entry id# '. $this->id);
 
318
        events_trigger('blog_entry_deleted', $this);
417
319
    }
418
320
 
419
321
    /**
446
348
        $assocobject->blogid = $this->id;
447
349
        $DB->insert_record('blog_association', $assocobject);
448
350
 
449
 
        $context = get_context_instance_by_id($contextid);
 
351
        $context = context::instance_by_id($contextid);
450
352
        $courseid = null;
451
353
 
452
354
        if ($context->contextlevel == CONTEXT_COURSE) {
480
382
    }
481
383
 
482
384
    /**
483
 
     * if return=html, then return a html string.
484
 
     * if return=text, then return a text-only string.
485
 
     * otherwise, print HTML for non-images, and return image HTML
486
 
     *
487
 
     * @param bool $return Whether to return or print the generated code
488
 
     * @return void
489
 
     */
490
 
    public function print_attachments($return=false) {
491
 
        global $CFG, $OUTPUT;
492
 
 
493
 
        require_once($CFG->libdir.'/filelib.php');
494
 
 
495
 
        $fs = get_file_storage();
496
 
 
497
 
        $syscontext = get_context_instance(CONTEXT_SYSTEM);
498
 
 
499
 
        $files = $fs->get_area_files($syscontext->id, 'blog', 'attachment', $this->id);
500
 
 
501
 
        $imagereturn = "";
502
 
        $output = "";
503
 
 
504
 
        $strattachment = get_string("attachment", "forum");
505
 
 
506
 
        foreach ($files as $file) {
507
 
            if ($file->is_directory()) {
508
 
                continue;
509
 
            }
510
 
 
511
 
            $filename = $file->get_filename();
512
 
            $ffurl    = file_encode_url($CFG->wwwroot.'/pluginfile.php', '/'.SYSCONTEXTID.'/blog/attachment/'.$this->id.'/'.$filename);
513
 
            $mimetype = $file->get_mimetype();
514
 
 
515
 
            $icon     = mimeinfo_from_type("icon", $mimetype);
516
 
            $type     = mimeinfo_from_type("type", $mimetype);
517
 
 
518
 
            $image = $OUTPUT->pix_icon("f/$icon", $filename, 'moodle', array('class'=>'icon'));
519
 
 
520
 
            if ($return == "html") {
521
 
                $output .= html_writer::link($ffurl, $image);
522
 
                $output .= html_writer::link($ffurl, $filename);
523
 
 
524
 
            } else if ($return == "text") {
525
 
                $output .= "$strattachment $filename:\n$ffurl\n";
526
 
 
527
 
            } else {
528
 
                if (in_array($type, array('image/gif', 'image/jpeg', 'image/png'))) {    // Image attachments don't get printed as links
529
 
                    $imagereturn .= '<br /><img src="'.$ffurl.'" alt="" />';
530
 
                } else {
531
 
                    $imagereturn .= html_writer::link($ffurl, $image);
532
 
                    $imagereturn .= format_text(html_writer::link($ffurl, $filename), FORMAT_HTML, array('context'=>$syscontext));
533
 
                }
534
 
            }
535
 
        }
536
 
 
537
 
        if ($return) {
538
 
            return $output;
539
 
        }
540
 
 
541
 
        return $imagereturn;
542
 
 
543
 
    }
544
 
 
545
 
    /**
546
385
     * function to attach tags into an entry
547
386
     * @return void
548
387
     */
578
417
            $userid = $USER->id;
579
418
        }
580
419
 
581
 
        $sitecontext = get_context_instance(CONTEXT_SYSTEM);
 
420
        $sitecontext = context_system::instance();
582
421
 
583
422
        if (has_capability('moodle/blog:manageentries', $sitecontext)) {
584
423
            return true; // can edit any blog entry
602
441
     */
603
442
    public function can_user_view($targetuserid) {
604
443
        global $CFG, $USER, $DB;
605
 
        $sitecontext = get_context_instance(CONTEXT_SYSTEM);
 
444
        $sitecontext = context_system::instance();
606
445
 
607
 
        if (empty($CFG->bloglevel) || !has_capability('moodle/blog:view', $sitecontext)) {
 
446
        if (empty($CFG->enableblogs) || !has_capability('moodle/blog:view', $sitecontext)) {
608
447
            return false; // blog system disabled or user has no blog view capability
609
448
        }
610
449
 
640
479
 
641
480
            case BLOG_USER_LEVEL:
642
481
            default:
643
 
                $personalcontext = get_context_instance(CONTEXT_USER, $targetuserid);
 
482
                $personalcontext = context_user::instance($targetuserid);
644
483
                return has_capability('moodle/user:readuserblogs', $personalcontext);
645
484
                break;
646
485
        }
755
594
 
756
595
        // fix for MDL-9165, use with readuserblogs capability in a user context can read that user's private blogs
757
596
        // admins can see all blogs regardless of publish states, as described on the help page
758
 
        if (has_capability('moodle/user:readuserblogs', get_context_instance(CONTEXT_SYSTEM))) {
 
597
        if (has_capability('moodle/user:readuserblogs', context_system::instance())) {
759
598
            // don't add permission constraints
760
599
 
761
600
        } else if(!empty($this->filters['user']) && has_capability('moodle/user:readuserblogs',
762
 
                get_context_instance(CONTEXT_USER, (empty($this->filters['user']->id) ? 0 : $this->filters['user']->id)))) {
 
601
                context_user::instance((empty($this->filters['user']->id) ? 0 : $this->filters['user']->id)))) {
763
602
            // don't add permission constraints
764
603
 
765
604
        } else {
809
648
     * @return void
810
649
     */
811
650
    public function print_entries() {
812
 
        global $CFG, $USER, $DB, $OUTPUT;
813
 
        $sitecontext = get_context_instance(CONTEXT_SYSTEM);
 
651
        global $CFG, $USER, $DB, $OUTPUT, $PAGE;
 
652
        $sitecontext = context_system::instance();
 
653
 
 
654
        // Blog renderer
 
655
        $output = $PAGE->get_renderer('blog');
814
656
 
815
657
        $page  = optional_param('blogpage', 0, PARAM_INT);
816
658
        $limit = optional_param('limit', get_user_preferences('blogpagesize', 10), PARAM_INT);
836
678
            $userid = optional_param('userid', null, PARAM_INT);
837
679
 
838
680
            if (empty($userid) || (!empty($userid) && $userid == $USER->id)) {
 
681
 
 
682
                $courseid = optional_param('courseid', null, PARAM_INT);
 
683
                $modid = optional_param('modid', null, PARAM_INT);
 
684
 
839
685
                $addurl = new moodle_url("$CFG->wwwroot/blog/edit.php");
840
686
                $urlparams = array('action' => 'add',
841
687
                                   'userid' => $userid,
842
 
                                   'courseid' => optional_param('courseid', null, PARAM_INT),
 
688
                                   'courseid' => $courseid,
843
689
                                   'groupid' => optional_param('groupid', null, PARAM_INT),
844
 
                                   'modid' => optional_param('modid', null, PARAM_INT),
 
690
                                   'modid' => $modid,
845
691
                                   'tagid' => optional_param('tagid', null, PARAM_INT),
846
692
                                   'tag' => optional_param('tag', null, PARAM_INT),
847
693
                                   'search' => optional_param('search', null, PARAM_INT));
848
694
 
849
 
                foreach ($urlparams as $var => $val) {
850
 
                    if (empty($val)) {
851
 
                        unset($urlparams[$var]);
852
 
                    }
853
 
                }
 
695
                $urlparams = array_filter($urlparams);
854
696
                $addurl->params($urlparams);
855
697
 
856
698
                $addlink = '<div class="addbloglink">';
862
704
 
863
705
        if ($entries) {
864
706
            $count = 0;
865
 
 
866
707
            foreach ($entries as $entry) {
867
708
                $blogentry = new blog_entry(null, $entry);
868
 
                $blogentry->print_html();
 
709
 
 
710
                // Get the required blog entry data to render it
 
711
                $blogentry->prepare_render();
 
712
                echo $output->render($blogentry);
 
713
 
869
714
                $count++;
870
715
            }
871
716
 
1022
867
                // Ignore course filter if blog associations are not enabled
1023
868
                if ($this->id != $SITE->id && !empty($CFG->useblogassociations)) {
1024
869
                    $this->overrides = array('site');
1025
 
                    $context = get_context_instance(CONTEXT_COURSE, $this->id);
 
870
                    $context = context_course::instance($this->id);
1026
871
                    $this->tables['ba'] = 'blog_association';
1027
872
                    $this->conditions[] = 'p.id = ba.blogid';
1028
873
                    $this->conditions[] = 'ba.contextid = '.$context->id;
1038
883
                if (!empty($CFG->useblogassociations)) {
1039
884
                    $this->overrides = array('course', 'site');
1040
885
 
1041
 
                    $context = get_context_instance(CONTEXT_MODULE, $this->id);
 
886
                    $context = context_module::instance($this->id);
1042
887
                    $this->tables['ba'] = 'blog_association';
1043
888
                    $this->tables['p']  = 'post';
1044
889
                    $this->conditions = array('p.id = ba.blogid', 'ba.contextid = ?');
1088
933
            $this->params[]     = $this->id;
1089
934
 
1090
935
            if (!empty($CFG->useblogassociations)) {  // only show blog entries associated with this course
1091
 
                $coursecontext     = get_context_instance(CONTEXT_COURSE, $DB->get_field('groups', 'courseid', array('id' => $this->id)));
 
936
                $coursecontext     = context_course::instance($DB->get_field('groups', 'courseid', array('id' => $this->id)));
1092
937
                $this->tables['ba'] = 'blog_association';
1093
938
                $this->conditions[] = 'gm.groupid = ?';
1094
939
                $this->conditions[] = 'ba.contextid = ?';
1138
983
}
1139
984
 
1140
985
/**
1141
 
 * This filter restricts the results to a time interval in seconds up to mktime()
 
986
 * This filter restricts the results to a time interval in seconds up to time()
1142
987
 */
1143
988
class blog_filter_since extends blog_filter {
1144
989
    public function __construct($interval) {
1145
990
        $this->conditions[] = 'p.lastmodified >= ? AND p.lastmodified <= ?';
1146
 
        $this->params[] = mktime() - $interval;
1147
 
        $this->params[] = mktime();
 
991
        $this->params[] = time() - $interval;
 
992
        $this->params[] = time();
1148
993
    }
1149
994
}
1150
995
 
1163
1008
        $this->params[] = "%$searchterm%";
1164
1009
    }
1165
1010
}
 
1011
 
 
1012
 
 
1013
/**
 
1014
 * Renderable class to represent an entry attachment
 
1015
 */
 
1016
class blog_entry_attachment implements renderable {
 
1017
 
 
1018
    public $filename;
 
1019
    public $url;
 
1020
    public $file;
 
1021
 
 
1022
    /**
 
1023
     * Gets the file data
 
1024
     *
 
1025
     * @param stored_file $file
 
1026
     * @param int $entryid Attachment entry id
 
1027
     */
 
1028
    public function __construct($file, $entryid) {
 
1029
 
 
1030
        global $CFG;
 
1031
 
 
1032
        $this->file = $file;
 
1033
        $this->filename = $file->get_filename();
 
1034
        $this->url = file_encode_url($CFG->wwwroot.'/pluginfile.php', '/'.SYSCONTEXTID.'/blog/attachment/'.$entryid.'/'.$this->filename);
 
1035
    }
 
1036
 
 
1037
}