blog (development code)
[moodle.git] / blog / class.BlogInfo.php
1 <?php //$Id$
2     /**
3      * class.BlogInfo.php
4      * Author: Jason Buberel
5      * Copyright (C) 2003, Jason Buberel
6      * jason@buberel.org
7      * http://www.buberel.org/
8      *
9      *******************************************************************
10      * This program is free software; you can redistribute it and/or modify it
11      * under the terms of the GNU General Public License as published by the
12      * Free Software Foundation; either version 2 of the License, or (at your
13      * option) any later version.
14      * 
15      * This program is distributed in the hope that it will be useful, but
16      * WITHOUT ANY WARRANTY; without even the implied warranty of
17      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18      * General Public License for more details.
19      * 
20      * You should have received a copy of the GNU General Public License along
21      * with this program; if not, write to the Free Software Foundation, Inc.,
22      * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23      *******************************************************************
24      *
25      * This class is used to represent a single weblog. It gives the
26      * developer access to all of the normal properties of the weblog.
27      * Through the use of the required BlogEntry class, you should be able
28      * to access all the data related to this particular weblog.
29      *
30      * To use BlogInfo, you create a new instance using the provided
31      * constructor:
32      *  include_once("class.BlogInfo.php");
33      *  $userid = 2;
34      *  $myBlog = new BlogInfo($userid);
35      *
36      * Once instantiated, the BlogInfo instance can be used to obtain
37      * information about the blog:
38      *
39      *  $myTitle = $myBlog->get_blog_title();
40      *
41      * The three most useful methods are those used to retrieve BlogEntries:
42      *
43      *  $someBlogEntry = $myBlog->get_blog_entry_by_id(200); // fetch the 200th blog entry.
44      *  $blogEntryList = $myBlog->get_last_N_entries(10); // fetch the 10 most recent
45      *                                                 // blog entries.
46      *  foreach ($blogEntryList as $blogEntry) {
47      *      print "Blog Entry Title: ($blogEntry->entryId) $blogEntry->get_blog_title()<br/>";
48      *  }
49      */
51 global $CFG;
52 include_once($CFG->dirroot.'/blog/lib.php');
53 include_once($CFG->dirroot.'/blog/class.BlogEntry.php');
55 class BlogInfo {
56     // member variables
57     var $userid; // moodle userid
58     var $blogtitle; // user preference blog_title
59     var $blogtagline; // user preference blog_tagline
60     var $blogtheme; // user preference blog_theme - id of the template being used for this blog.
61     
62     // lazy loading member variables
63     // DO NOT directly refer to these member vars. Instead use their
64     // getter functions to ensure they are loaded properly
65     var $blogadminuser = NULL; // moodle user object for this userid
66     var $blogadminname = NULL; // userid -> blog_users.name
67     var $blogadminemail = NULL; // userid -> blog_users.email
68     var $blogadminurl = NULL; // userid -> blog_users.url
69     var $blogEntries = NULL; // an array of entries for this blog. empty by default.
71     /**
72      * constructor- used to create the BlogInfo instance
73      * and populate it with information about the blog.
74      */
75     function BlogInfo($userid) {
76         global $CFG;
78         if ($userid == 0 || empty($userid)) {
79             return NULL;
80         }
81         
82         $this->blogEntries = array();
83         $this->userid = $userid;
84         $this->blogtitle = stripslashes_safe(get_user_preferences('blogtitle', $CFG->blog_default_title, $userid));
85         $this->blogtagline = stripslashes_safe(get_user_preferences('blogtagline', '', $userid));
86         $this->bloguseextendedbody = get_user_preferences('bloguseextendedbody', false, $userid);
87         $this->blogtheme = get_user_preferences('blogtheme', 0, $userid); //Daryl Hawes note: investigate blogtheme usage again
88 /*        if ($this->userid == 0) { 
89             $this->userid = 1;
90         }*/
91     }
93 ////////// getters and setters ///////////////
95     /**
96      * Getter for this blog's title, ->blogtitle
97      */
98     function get_blog_title() {
99         if (!isset($this->blogtitle)) {
100             return '';
101         }
102         return $this->blogtitle;
103     }
105     /**
106      *
107      */
108     function set_blog_title($title) {
109         if (set_user_preference('blogtitle', $title, $this->userid)) {
110             $this->blogtitle = $title;
111             return true;
112         }
113         return false;
114     }
115    
116     /**
117      *
118      */
119     function get_blog_use_extended_body() {
120         return $this->bloguseextendedbody;
121     }
123     /**
124      *
125      */
126     function set_blog_use_extended_body($extend) {
127         if (set_user_preference('bloguseextendedbody', $extend, $this->userid)) {
128             $this->useextendedbody = $extend;
129             return true;
130         }
131         return false;
132     }
134     /**
135      *
136      */
137     function get_blog_tagline() {
138         if (!isset($this->blogtagline)) {
139             return '';
140         }
141         return $this->blogtagline;
142     }
143     
144     /**
145      *
146      */
147     function set_blog_tagline($tag) {
148         if (set_user_preference('blogtagline', $tag, $this->userid)) {
149             $this->blogtagline = $tag;
150             return true;
151         }
152         return false;
153     }
155     /**
156      * 
157      */
158     function get_blog_url() {
159         global $CFG;
160         return $CFG->blog_blogurl .'?userid='. $this->userid;
161     }
162     // no setter for blog URL, as there is no place to put it.
164     /**
165      *
166      */
167     function get_blog_theme() {
168         return $this->blogtheme;
169     }
170     
171     /**
172      *
173      */
174     function set_blog_theme($theme) {
175         if (set_user_preference('blogtheme', $theme, $this->userid)) {
176             $this->blogtheme = $theme;
177             return true;
178         }
179         return false;
180     }
181     
182     /**
183      * Getter for this blog owner's full name
184      * Warning: Do not attempt to directly access ->blogadminname from this class
185      *          as it is loaded lazily - NULL until this getter is called
186      */
187     function get_blogadminname() {
188         if (empty($this->blogadminuser)) {
189             $this->blogadminuser = get_user_info_from_db('id', $this->userid);
190             $this->blogadminname = fullname($this->blogadminuser);
191         }
192         return $this->blogadminname;
193     }
195     /**
196      * Getter for this blog owner's email address
197      * Warning: Do not attempt to directly access ->blogadminemail from this class
198      *          as it is loaded lazily - NULL until this getter is called
199      */
200     function get_blogadminemail() {
201         if (empty($this->blogadminuser)) {
202             $this->blogadminuser = get_user_info_from_db('id', $this->userid);
203             $this->blogadminemail = $this->blogadminuser->email;
204         }
205         return $this->blogadminemail;
206     }
208     /**
209      * Getter for this blog owner's contact URL
210      * Warning: Do not attempt to directly access ->blogadminurl from this class
211      *          as it is loaded lazily - NULL until this getter is called
212      */
213     function get_blogadminurl() {
214         if (empty($this->blogadminuser)) {
215             $this->blogadminuser = get_user_info_from_db('id', $this->userid);
216             $this->blogadminurl = $this->blogadminuser->url;
217         }
218         return $this->blogadminurl;
219     }
221     function get_blogurl() {
222         return NULL;
223     }
225     /**
226      * return the timestamp when this blog was last updated.
227      * @return string Date of last modification in moodle's userdate() format.
228      */
229     function get_last_update() {
230         $where = 'userid='. $this->userid;
231         $record = get_record_select('post', $where, 'lastmodified');
232         return userdate($record->lastmodified);
233     }
235     /**
236      * Use this function to get a single numbered BlogEntry object
237      * for this blog.
238      * @todo perhaps a member array could be used to store these fetched BlogEntry objects
239      *      in case the same entry is requested from this same bloginfo object later
240      */
241     function get_blog_entry_by_id($entryId) {
242         global $CFG;
243     
244         foreach ($this->blogEntries as $cachedentry) {
245             if ($cachedentry->entryId == $entryId) {
246                 return $cachedentry;
247             }
248         }
249         $record = get_record('post', 'id', $entryId);    //teachers should be able to edit people's blogs, right?
250         //$record = get_record('post', 'author', $this->userid, 'id', $entryId);
251         // may have zero entries. in that case, return null.
252         if (empty($record)) {
253             // the result set is empty. return null.
254             return NULL;
255         } else {
256             // create the new blog entry object...
257             $blogEntry = new BlogEntry($record);
258             //cache the blogEntry in member var for future use if needed
259             $this->blogEntries[] = $blogEntry;
260             $this->blogEntries = array_unique($this->blogEntries);
261         }
262         return $blogEntry;
263     }
265     /**
266      * This function will remove the specified blog entry. It will
267      * perform any of the security checks necessary to ensure that the
268      * user is authorized to remove the entry. It will return false
269      * if there was an error trying to delete the entry.
270      * @param int $entryID The blog entry to delete by id
271      */
272     function delete_blog_entry_by_id($entryId) {
273         // figure out who the currently logged in user is.
274         global $USER;
275         if ( !isset($USER) || empty($USER) || !isset($USER->id) ) {
276             return false;
277         }
278         $uid = $USER->id;
279         // retrieve the entry.
280         $blogEntry = $this->get_blog_entry_by_id($entryId);
281         
282         if (empty($blogEntry) ) {
283             return false;
284         }
286         if (($uid == $blogEntry->entryuserid) || (blog_is_blog_admin($this->userid)) || (isadmin())) {
287             // yes, they are authorized, so remove the entry.
288             if ( $blogEntry->delete() ) {
289                 unset($this->blogEntries[$blogEntry]);
290                 return true;
291             }
292         }
293         // must not have worked...
294         return false;
295     }
296     
297     /**
298      * This function will return a list, in order, formatted as "YYYY-MM" for each year and month
299      * in which this blog has entries. Used by the 'blog_archives' block.
300      */
301     function get_year_month_of_entries() {
302         $entries = get_records('post', 'userid', $this->userid, 'lastmodified ASC');
303         $dateHash = array();
304         if ( !empty($entries) ) {
305             foreach ($entries as $entry) {
306                 $date = $entry->lastmodified;
307                 $truncDate = date("Y-m", $date); // this will return 9999-99 for the date.
308                 $dateHash[$truncDate] = 1;
309             }
310         }
311         return $dateHash;
312     }
314     /**
315      * Use this method to insert/create a new entry in the post table for
316      * this blog. The entry id of the new blog entry will be returned if the
317      * insertion is successful.
318      * @param string $title .
319      * @param string $body .
320      * @param string $extendedbody .
321      * @param int $userid .
322      * @param int $formatId .
323      * @param string $publishstate 'draft', 'teacher', 'course', 'group', 'site', 'public'
324      * @param int $courseid .
325      * @param int $groupid .
326      * @return int
327      */
328     function insert_blog_entry($title, $body, $extendedbody, $userid, $formatId, $publishstate='draft', $courseid='', $groupid='') {
329         global $CFG;
330         
331         // first, make sure the title and body are safe for insert.
332         $title = ereg_replace("'", '<tick>', $title);
333         $body = ereg_replace("'", '<tick>', $body);
334         // The wysiwyg html editor adds a <br /> tag to the extendedbody.
335         // cleanup the extendedbody first
336         if ($extendedbody == '<br />' || $extendedbody == '<br /><br />') {
337             $extendedbody = '';
338         }
339         $extendedbody = ereg_replace("'", '<tick>', $extendedbody);
340         $title = addslashes($title);
341         $body = addslashes($body);
342         $extendedbody = addslashes($extendedbody);
344         // come up with a new timestamp to insert.
345         // now insert the new entry.
346         $dataobject->summary = $body;
347         $dataobject->content = $extendedbody;
348         $dataobject->userid = $userid;
349         $dataobject->subject = $title;
350         $dataobject->format = $formatId;
351         
352         $timenow = time();
353         $dataobject->lastmodified = $timenow;        
354         $dataobject->created = $timenow;
355         $dataobject->publishstate = $publishstate;
356         if ($courseid != '') {
357             $dataobject->courseid = intval($courseid);
358         }
359         if ($groupid != '') {
360             $dataobject->groupid = intval($groupid);
361         }
363         $newentryid = insert_record('post', $dataobject);
365         if ($newentryid) {
366             // entry was created and $newentryid is its entryid.
367             
368             // create a unique hash for this id that will be its alternate identifier
369             unset($dataobject);
370             $dataobject->id = $newentryid;
371             $dataobject->uniquehash = md5($userid.$CFG->wwwroot.$newentryid);
372             update_record('post', $dataobject);
373             
374             // now create category entries
375             if (!empty($categoryids)) {
376                 foreach ($categoryids as $categoryid) {
377                     $cat->entryid = $newentryid;
378                     $cat->categoryid = $categoryid;
379                     insert_record('blog_categories_entries', $cat);
380                 }
381             }
382             // insert lastmodified into user pref so that recently modified blogs can be identified easily without joining tables
383             set_user_preference('bloglastmodified', $timenow, $this->userid);
384             return $newentryid;
385         }
386         return null;
387     }
389     /**
390      * Discovers the number of entries for this blog
391      * @return int Entry count
392      */
393     function get_entry_count() {
394         return count_records('post', 'userid', $this->userid);
395     }
397     /**
398         * returns the N most recent BlogEntry objects
399      * for this blog
400      */
401     function get_last_N_entries($n) {
402         return $this->get_blog_entries_by_range($n, 0);
403     }
404     
405     /**
406      *
407      */
408     function get_blog_entries_by_range($limit, $start) {
409         global $USER;
410     
411         $sqlsnippet = 'userid='. $this->userid;
412         $sort = 'id DESC';
413         $records = get_records_select('post', $sqlsnippet, $sort, '*', $start, $limit);
414         if (empty($records)) {
415             return array();
416         } else {
417             $blogEntries = array();
418             foreach($records as $record) {
419                 $blogEntry = new BlogEntry($record);
420                 //ensure that the user has rights to view this entry
421                 if ($blogEntry->user_can_view() ) {
422                     $blogEntries[] = $blogEntry;
423                 }
424             }
425 //            print_object($blogEntries); //debug
426             //cache the blogEntries in member var for future use if needed
427             $this->blogEntries = array_merge($this->blogEntries, $blogEntries);
428             $this->blogEntries = array_unique($this->blogEntries);
430             return $blogEntries;
431         }
432     }
434         /**
435         * update_blog_entry_by_id
436         *
437         * this funciton will update the selected blog entry after performing
438         * security checks to make sure the user is authorized to perform the update.
439         * Used by api.php
440         * @uses USER
441         */
442     function update_blog_entry_by_id($entryId, $title, $body, $extendedbody, $formatId, $categoryId, $publishstate='draft', $courseid='', $groupid='') {
443         // figure out who the currently logged in user is.
444         global $USER;
446         if ( !isset($USER) || empty($USER) || !isset($USER->id) ) {
447             return false;
448         } else {
449             $uid = $USER->id;
450         }
451         $body = ereg_replace("'", '<tick>', $body);
452         $extendedbody = ereg_replace("'", '<tick>', $extendedbody);
453         $title = ereg_replace("'", '<tick>', $title);
454         $title = addslashes($title);
455         $body = addslashes($body);
456         $extendedbody = addslashes($extendedbody);
458         // retrieve the entry
459         $blogEntry = $this->get_blog_entry_by_id($entryId);
460         //check if the user is authorized to make this change
461         if ( ($uid == $blogEntry->entryUserId) || (blog_is_blog_admin($this->userid)) || (isadmin()) ) {
462             // Yes they are authorized so update the entry.
463             if ( $blogEntry->update($title, $body, $extendedbody, $formatId, $categoryId, $publishstate, $courseid, $groupid) ) {
464                 return true;
465             }
466         }
467         // must not have worked...
468         return false;
469         
470     }
471     
473 ?>