1: <?php
  2: 
  3: /**
  4:  * root object class
  5:  * @package classes
  6:  */
  7: // force UTF-8 Ø
  8: // classes.php
  9: 
 10: /* * *****************************************************************************
 11:  * ******************************************************************************
 12:  * Persistent Object Class *****************************************************
 13:  *
 14:  * Parent ABSTRACT class of all persistent objects. This class should not be
 15:  * instantiated, only used for subclasses. This cannot be enforced, but please
 16:  * follow it!
 17:  *
 18:  * A child class should run the follwing in its constructor:
 19:  *
 20:  * $new = $this->instantiate('tablename',
 21:  *   array('uniquestring'=>$value, 'uniqueid'=>$uniqueid));
 22:  *
 23:  * where 'tablename' is the name of the database table to use for this object
 24:  * type, and array('uniquestring'=>$value, ...) defines a unique set of columns
 25:  * (keys) and their current values which uniquely identifies a single record in
 26:  * that database table for this object.
 27:  *
 28:  * Note: This is a persistable model that does not save automatically. You MUST
 29:  * call $this->save(); explicitly to persist the data in child classes.
 30:  *
 31:  * ******************************************************************************
 32:  * **************************************************************************** */
 33: 
 34: // The query cache
 35: $_zp_object_cache = array();
 36: define('OBJECT_CACHE_DEPTH', 150); //   how many objects to hold for each object class
 37: // ABSTRACT
 38: 
 39: class PersistentObject {
 40: 
 41:     var $loaded = false;
 42:     var $exists = false;
 43:     var $table;
 44:     var $transient;
 45:     protected $id = 0;
 46:     private $unique_set = NULL;
 47:     private $cache_by;
 48:     private $use_cache = false;
 49:     private $tempdata = NULL;
 50:     private $data = NULL;
 51:     private $updates = NULL;
 52: 
 53:     /**
 54:      *
 55:      * @deprecated
 56:      */
 57:     function __construct($tablename, $unique_set, $cache_by = NULL, $use_cache = true, $is_transient = false, $allowCreate = true) {
 58:         deprecated_functions::PersistentObject();
 59:         return instantiate($tablename, $unique_set, $cache_by, $use_cache, $is_transient, $allowCreate);
 60:     }
 61: 
 62:     /**
 63:       }
 64:      *
 65:      * Prime instantiator for Zenphoto objects
 66:      * @param $tablename    The name of the database table
 67:      * @param $unique_set   An array of unique fields
 68:      * @param $cache_by
 69:      * @param $use_cache
 70:      * @param $is_transient Set true to prevent database insertion
 71:      * @param $allowCreate Set true to allow a new object to be made.
 72:      * @return bool will be true if the unique_set does not already exist
 73:      */
 74:     function instantiate($tablename, $unique_set, $cache_by = NULL, $use_cache = true, $is_transient = false, $allowCreate = true) {
 75:         global $_zp_object_cache;
 76:         //  insure a cache entry
 77:         $classname = get_class($this);
 78:         if (!isset($_zp_object_cache[$classname])) {
 79:             $_zp_object_cache[$classname] = array();
 80:         }
 81:         // Initialize the variables.
 82:         // Load the data into the data array using $this->load()
 83:         $this->data = $this->tempdata = $this->updates = array();
 84:         $this->loaded = false;
 85:         $this->table = $tablename;
 86:         $this->unique_set = $unique_set;
 87:         if (is_null($cache_by)) {
 88:             $this->cache_by = serialize($unique_set);
 89:         } else {
 90:             $this->cache_by = $this->unique_set[$cache_by];
 91:         }
 92:         $this->use_cache = $use_cache;
 93:         $this->transient = $is_transient;
 94:         return $this->load($allowCreate);
 95:     }
 96: 
 97:     /**
 98:      *
 99:      * check the cache for presence of the entry and return it if found
100:      * @param $entry
101:      */
102:     private function getFromCache() {
103:         global $_zp_object_cache;
104:         if (isset($_zp_object_cache[$c = get_class($this)]) && isset($_zp_object_cache[$c][$this->cache_by])) {
105:             return $_zp_object_cache[$c][$this->cache_by];
106:         }
107:         return NULL;
108:     }
109: 
110:     /**
111:      *
112:      * add the entry to the cache
113:      * @param $entry
114:      */
115:     private function addToCache($entry) {
116:         global $_zp_object_cache;
117:         if ($entry) {
118:             if (count($_zp_object_cache[$classname = get_class($this)]) >= OBJECT_CACHE_DEPTH) {
119:                 array_shift($_zp_object_cache[$classname]); //  discard the oldest
120:             }
121:             $_zp_object_cache[$classname][$this->cache_by] = $entry;
122:         }
123:     }
124: 
125:     /**
126:      * Set a variable in this object. Does not persist to the database until
127:      * save() is called. So, IMPORTANT: Call save() after set() to persist.
128:      * If the requested variable is not in the database, sets it in temp storage,
129:      * which won't be persisted to the database.
130:      */
131:     function set($var, $value) {
132:         if (empty($var))
133:             return false;
134:         if ($this->loaded && !array_key_exists($var, $this->data)) {
135:             $this->tempdata[$var] = $value;
136:         } else {
137:             $this->updates[$var] = $value;
138:         }
139:         return true;
140:     }
141: 
142:     /**
143:      * Sets default values for new objects using the set() method.
144:      * Should do nothing in the base class; subclasses should override.
145:      */
146:     protected function setDefaults() {
147: 
148:     }
149: 
150:     /**
151:      * Change one or more values of the unique set assigned to this record.
152:      * Checks if the record already exists first, if so returns false.
153:      * If successful returns true and changes $this->unique_set
154:      * A call to move is instant, it does not require a save() following it.
155:      */
156:     function move($new_unique_set) {
157:         // Check if we have a row
158:         $result = query_single_row('SELECT * FROM ' . prefix($this->table) . getWhereClause($new_unique_set) . ' LIMIT 1;');
159:         if (!$result || $result['id'] == $this->id) { //    we should not find an entry for the new unique set!
160:             if (!zp_apply_filter('move_object', true, $this, $new_unique_set)) {
161:                 return false;
162:             }
163:             $sql = 'UPDATE ' . prefix($this->table) . getSetClause($new_unique_set) . ' ' . getWhereClause($this->unique_set);
164:             $result = query($sql);
165:             if ($result && db_affected_rows() == 1) { //    and the update should have effected just one record
166:                 $this->unique_set = $new_unique_set;
167:                 return true;
168:             }
169:         }
170:         return false;
171:     }
172: 
173:     /**
174:      * Copy this record to another unique set. Checks if the record exists there
175:      * first, if so returns false. If successful returns true. No changes are made
176:      * to this object and no other objects are created, just the database entry.
177:      * A call to copy is instant, it does not require a save() following it.
178:      */
179:     function copy($new_unique_set) {
180:         // Check if we have a row
181:         $result = query('SELECT * FROM ' . prefix($this->table) . getWhereClause($new_unique_set) . ' LIMIT 1;');
182: 
183:         if ($result && db_num_rows($result) == 0) {
184:             if (!zp_apply_filter('copy_object', true, $this, $new_unique_set)) {
185:                 return false;
186:             }
187:             // Note: It's important for $new_unique_set to come last, as its values should override.
188:             $insert_data = array_merge($this->data, $this->updates, $this->tempdata, $new_unique_set);
189:             unset($insert_data['id']);
190:             unset($insert_data['hitcounter']); //   start fresh on new copy
191:             if (empty($insert_data)) {
192:                 return true;
193:             }
194:             $sql = 'INSERT INTO ' . prefix($this->table) . ' (';
195:             $i = 0;
196:             foreach (array_keys($insert_data) as $col) {
197:                 if ($i > 0)
198:                     $sql .= ", ";
199:                 $sql .= "`$col`";
200:                 $i++;
201:             }
202:             $sql .= ') VALUES (';
203:             $i = 0;
204:             foreach (array_values($insert_data) as $value) {
205:                 if ($i > 0)
206:                     $sql .= ', ';
207:                 if (is_null($value)) {
208:                     $sql .= 'NULL';
209:                 } else {
210:                     $sql .= db_quote($value);
211:                 }
212:                 $i++;
213:             }
214:             $sql .= ');';
215:             $success = query($sql);
216:             if ($success && db_affected_rows() == 1) {
217:                 return zp_apply_filter('copy_object', db_insert_id(), $this);
218:             }
219:         }
220:         return false;
221:     }
222: 
223:     /**
224:      * Deletes object from the database
225:      *
226:      * @return bool
227:      */
228:     function remove() {
229:         if (!zp_apply_filter('remove_object', true, $this)) {
230:             return false;
231:         }
232:         $id = $this->id;
233:         if (empty($id)) {
234:             $id = ' is NULL'; //    allow delete of bad item!
235:         } else {
236:             $id = '=' . $id;
237:         }
238:         $sql = 'DELETE FROM ' . prefix($this->table) . ' WHERE `id`' . $id;
239:         $this->loaded = false;
240:         $this->transient = true;
241:         return query($sql);
242:     }
243: 
244:     /**
245:      * Returns the id
246:      *
247:      * @return string
248:      */
249:     function getID() {
250:         return $this->id;
251:     }
252: 
253:     /**
254:      *
255:      * returns the database record of the object
256:      * @return array
257:      */
258:     function getData() {
259:         $this->save();
260:         return $this->data;
261:     }
262: 
263:     /**
264:      * Get the value of a variable. If $current is false, return the value
265:      * as of the last save of this object.
266:      */
267:     function get($var, $current = true) {
268:         if ($current && isset($this->updates[$var])) {
269:             return $this->updates[$var];
270:         } else if (isset($this->data[$var])) {
271:             return $this->data[$var];
272:         } else if (isset($this->tempdata[$var])) {
273:             return $this->tempdata[$var];
274:         } else {
275:             return null;
276:         }
277:     }
278: 
279:     /**
280:      * Load the data array from the database, using the unique id set to get the unique record.
281:      *
282:      * @param bool $allowCreate set to true to enable new object creation.
283:      * @return false if the record already exists, true if a new record was created.
284:      */
285:     private function load($allowCreate) {
286:         $new = $entry = null;
287:         // Set up the SQL query in case we need it...
288:         $sql = 'SELECT * FROM ' . prefix($this->table) . getWhereClause($this->unique_set) . ' LIMIT 1;';
289:         // But first, try the cache.
290:         if ($this->use_cache) {
291:             $entry = $this->getFromCache();
292:         }
293:         // Check the database if: 1) not using cache, or 2) didn't get a hit.
294:         if (empty($entry)) {
295:             $entry = query_single_row($sql, false);
296:             // Save this entry into the cache so we get a hit next time.
297:             if ($entry)
298:                 $this->addToCache($entry);
299:         }
300: 
301:         // If we don't have an entry yet, this is a new record. Create it.
302:         if (empty($entry)) {
303:             if ($this->transient) { // no don't save it in the DB!
304:                 $entry = array_merge($this->unique_set, $this->updates, $this->tempdata);
305:                 $entry['id'] = 0;
306:             } else if (!$allowCreate) {
307:                 return NULL; // does not exist and we are not allowed to create it
308:             } else {
309:                 $new = true;
310:                 $this->save();
311:                 $entry = query_single_row($sql);
312:                 // If we still don't have an entry, something went wrong...
313:                 if (!$entry)
314:                     return null;
315:                 // Save this new entry into the cache so we get a hit next time.
316:                 $this->addToCache($entry);
317:             }
318:         }
319:         $this->data = $entry;
320:         $this->id = (int) $entry['id'];
321:         $this->loaded = true;
322:         return $new;
323:     }
324: 
325:     /**
326:      * Save the updates made to this object since the last update. Returns
327:      * true if successful, false if not.
328:      */
329:     function save() {
330:         if ($this->transient)
331:             return false; // If this object isn't supposed to be persisted, don't save it.
332:         if (!$this->unique_set) { // If we don't have a unique set, then this is incorrect. Don't attempt to save.
333:             zp_error('empty $this->unique set is empty');
334:             return false;
335:         }
336:         if (!$this->id) {
337:             $this->setDefaults();
338:             // Create a new object and set the id from the one returned.
339:             $insert_data = array_merge($this->unique_set, $this->updates, $this->tempdata);
340:             if (empty($insert_data)) {
341:                 return true;
342:             }
343:             $i = 0;
344:             $cols = $vals = '';
345:             foreach ($insert_data as $col => $value) {
346:                 if ($i > 0)
347:                     $cols .= ", ";
348:                 $cols .= "`$col`";
349:                 if ($i > 0)
350:                     $vals .= ", ";
351:                 if (is_null($value)) {
352:                     $vals .= "NULL";
353:                 } else {
354:                     $vals .= db_quote($value);
355:                 }
356:                 $i++;
357:             }
358:             $sql = 'INSERT INTO ' . prefix($this->table) . ' (' . $cols . ') VALUES (' . $vals . ')';
359:             $success = query($sql);
360:             if (!$success || db_affected_rows() != 1) {
361:                 return false;
362:             }
363:             foreach ($insert_data as $key => $value) { // copy over any changes
364:                 $this->data[$key] = $value;
365:             }
366:             $this->data['id'] = $this->id = (int) db_insert_id(); // so 'get' will retrieve it!
367:             $this->loaded = true;
368:             $this->updates = array();
369:             $this->tempdata = array();
370:         } else {
371:             // Save the existing object (updates only) based on the existing id.
372:             if (empty($this->updates)) {
373:                 return true;
374:             } else {
375:                 $sql = 'UPDATE ' . prefix($this->table) . ' SET';
376:                 $i = 0;
377:                 foreach ($this->updates as $col => $value) {
378:                     if ($i > 0)
379:                         $sql .= ",";
380:                     if (is_null($value)) {
381:                         $sql .= " `$col` = NULL";
382:                     } else {
383:                         $sql .= " `$col` = " . db_quote($value);
384:                     }
385:                     $this->data[$col] = $value;
386:                     $i++;
387:                 }
388:                 $sql .= ' WHERE id=' . $this->id . ';';
389:                 $success = query($sql);
390:                 if (!$success || db_affected_rows() != 1) {
391:                     return false;
392:                 }
393:                 foreach ($this->updates as $key => $value) {
394:                     $this->data[$key] = $value;
395:                 }
396:                 $this->updates = array();
397:             }
398:         }
399:         zp_apply_filter('save_object', true, $this);
400:         $this->addToCache($this->data);
401:         return true;
402:     }
403: 
404:     /**
405:      *
406:      * "Magic" function to return a string identifying the object when it is treated as a string
407:      * @return string
408:      */
409:     public function __toString() {
410:         return $this->table . " (" . $this->id . ")";
411:     }
412: 
413: }
414: 
415: //////////////////////////////////////////////////////////////////////////////////////////////////////
416: /**
417:  * The basic ThemeObject class. Extends PersistentObject, is extended by various Theme related objects.
418:  * Provides some basic methods that all use.
419:  */
420: class ThemeObject extends PersistentObject {
421: 
422:     private $commentcount; //Contains the number of comments
423:     var $comments = NULL; //Contains an array of the comments of the object
424:     var $manage_rights = ADMIN_RIGHTS;
425:     var $manage_some_rights = ADMIN_RIGHTS;
426:     var $view_rights = VIEW_ALL_RIGHTS;
427: 
428:     /**
429:      * Class instantiator
430:      */
431:     function __construct() {
432:         // no action required
433:     }
434: 
435:     /**
436:      * Returns the title
437:      *
438:      * @return string
439:      */
440:     function getTitle($locale = NULL) {
441:         $text = $this->get('title');
442:         if ($locale !== 'all') {
443:             $text = get_language_string($text, $locale);
444:         }
445:         $text = zpFunctions::unTagURLs($text);
446:         return $text;
447:     }
448: 
449:     /**
450:      * Stores the title
451:      *
452:      * @param string $title the title
453:      */
454:     function setTitle($title) {
455:         $this->set('title', zpFunctions::tagURLs($title));
456:     }
457: 
458:     /**
459:      * Returns the partent id
460:      *
461:      * @return string
462:      */
463:     function getParentID() {
464:         return $this->get('parentid');
465:     }
466: 
467:     /**
468:      * Sets the ParentID field
469:      * @param $v id of the parent
470:      */
471:     function setParentID($v) {
472:         $this->set('parentid', $v);
473:     }
474: 
475:     /**
476:      * Returns the hitcount
477:      *
478:      * @return int
479:      */
480:     function getHitcounter() {
481:         return $this->get('hitcounter');
482:     }
483: 
484:     /**
485:      * counts visits to the object
486:      */
487:     function countHit() {
488:         $this->set('hitcounter', $this->get('hitcounter') + 1);
489:         $this->save();
490:     }
491: 
492:     /**
493:      * Returns true published
494:      *
495:      * @return bool
496:      */
497:     function getShow() {
498:         return $this->get('show');
499:     }
500: 
501:     /**
502:      * Stores the published value
503:      *
504:      * @param bool $show True if the album is published
505:      */
506:     function setShow($show) {
507:         $old_show = $this->get('show');
508:         $new_show = (int) ($show && true);
509:         $this->set('show', $new_show);
510:         if ($old_show != $new_show && $this->get('id')) {
511:             zp_apply_filter('show_change', $this);
512:         }
513:     }
514: 
515:     /**
516:      * Returns the tag data
517:      *
518:      * @return string
519:      */
520:     function getTags() {
521:         return readTags($this->getID(), $this->table);
522:     }
523: 
524:     /**
525:      * Stores tag information
526:      *
527:      * @param string $tags the tag list
528:      */
529:     function setTags($tags) {
530:         if (!$this->getID()) { //   requires a valid id to link tags to the object
531:             $this->save();
532:         }
533:         storeTags(array_unique($tags), $this->getID(), $this->table);
534:     }
535: 
536:     /**
537:      * Checks if an object has a tag assigned.
538:      *
539:      * @param string $checktag tag to check for
540:      *
541:      * @return bool
542:      */
543:     function hasTag($checktag) {
544:         $tags = $this->getTags();
545:         return in_array($checktag, $tags);
546:     }
547: 
548:     /**
549:      * Returns the unformatted date
550:      *
551:      * @return int
552:      */
553:     function getDateTime() {
554:         return $this->get('date');
555:     }
556: 
557:     /**
558:      * Stores the date
559:      *
560:      * @param string $datetime formatted date
561:      */
562:     function setDateTime($datetime) {
563:         if ($datetime) {
564:             $newtime = dateTimeConvert($datetime);
565:             if ($newtime !== false) {
566:                 $this->set('date', $newtime);
567:             }
568:         } else {
569:             $this->set('date', NULL);
570:         }
571:     }
572: 
573:     /**
574:      * Returns the codeblocks as an serialized array
575:      *
576:      * @return array
577:      */
578:     function getCodeblock() {
579:         return zpFunctions::unTagURLs($this->get("codeblock"));
580:     }
581: 
582:     /**
583:      * set the codeblocks as an serialized array
584:      *
585:      */
586:     function setCodeblock($cb) {
587:         $this->set('codeblock', zpFunctions::tagURLs($cb));
588:     }
589: 
590:     /**
591:      * returns the custom data field
592:      *
593:      * @return string
594:      */
595:     function getCustomData($locale = NULL) {
596:         $text = $this->get('custom_data');
597:         if ($locale !== 'all') {
598:             $text = get_language_string($text, $locale);
599:         }
600:         $text = zpFunctions::unTagURLs($text);
601:         return $text;
602:     }
603: 
604:     /**
605:      * Sets the custom data field
606:      *
607:      * @param string $val the value to be put in custom_data
608:      */
609:     function setCustomData($val) {
610:         $this->set('custom_data', zpFunctions::tagURLs($val));
611:     }
612: 
613:     /**
614:      * Retuns true if comments are allowed
615:      *
616:      * @return bool
617:      */
618:     function getCommentsAllowed() {
619:         return $this->get('commentson');
620:     }
621: 
622:     /**
623:      * Sets the comments allowed flag
624:      *
625:      * @param bool $commentson true if they are allowed
626:      */
627:     function setCommentsAllowed($commentson) {
628:         $this->set('commentson', (int) ($commentson && true));
629:     }
630: 
631:     /**
632:      * Returns an array of comments for this album
633:      *
634:      * @param bool $moderated if false, ignores comments marked for moderation
635:      * @param bool $private if false ignores private comments
636:      * @param bool $desc set to true for descending order
637:      * @return array
638:      */
639:     function getComments($moderated = false, $private = false, $desc = false) {
640:         $sql = "SELECT *, (date + 0) AS date FROM " . prefix("comments") .
641:                         " WHERE `type`='" . $this->table . "' AND `ownerid`='" . $this->getID() . "'";
642:         if (!$moderated) {
643:             $sql .= " AND `inmoderation`=0";
644:         }
645:         if (!$private) {
646:             $sql .= " AND `private`=0";
647:         }
648:         $sql .= " ORDER BY id";
649:         if ($desc) {
650:             $sql .= ' DESC';
651:         }
652:         $comments = query_full_array($sql);
653:         $this->comments = $comments;
654:         return $this->comments;
655:     }
656: 
657:     /**
658:      * Adds comments to the album
659:      * assumes data is coming straight from GET or POST
660:      *
661:      * Returns a comment object
662:      *
663:      * @param string $name Comment author name
664:      * @param string $email Comment author email
665:      * @param string $website Comment author website
666:      * @param string $comment body of the comment
667:      * @param string $code CAPTCHA code entered
668:      * @param string $code_ok CAPTCHA hash expected
669:      * @param string $ip the IP address of the comment poster
670:      * @param bool $private set to true if the comment is for the admin only
671:      * @param bool $anon set to true if the poster wishes to remain anonymous
672:      * @param string $customdata
673:      * @return object
674:      */
675:     function addComment($name, $email, $website, $comment, $code, $code_ok, $ip, $private, $anon, $customdata) {
676:         $goodMessage = zp_apply_filter('object_addComment', $name, $email, $website, $comment, $code, $code_ok, $this, $ip, $private, $anon, $customdata);
677:         return $goodMessage;
678:     }
679: 
680:     /**
681:      * Returns the count of comments in the album. Ignores comments in moderation
682:      *
683:      * @return int
684:      */
685:     function getCommentCount() {
686:         if (is_null($this->commentcount)) {
687:             if ($this->comments == null) {
688:                 $count = db_count("comments", "WHERE `type`='" . $this->table . "' AND `inmoderation`=0 AND `private`=0 AND `ownerid`=" . $this->getID());
689:                 $this->commentcount = $count;
690:             } else {
691:                 $this->commentcount = count($this->comments);
692:             }
693:         }
694:         return $this->commentcount;
695:     }
696: 
697:     /**
698:      * Checks basic access rights of an object
699:      * @param bit $action what the caller wants to do
700:      */
701:     function isMyItem($action) {
702:   if (!$this->checkPublishDates()) {
703:     $this->setShow(0);
704:   }
705:         if (zp_loggedin($this->manage_rights)) {
706:             return true;
707:         }
708:         if (zp_loggedin($this->view_rights) && ($action == LIST_RIGHTS)) { // sees all
709:             return true;
710:         }
711:         if (zp_apply_filter('check_credentials', false, $this, $action)) {
712:             return true;
713:         }
714:         return NULL;
715:     }
716: 
717:     /**
718:      * returns false (deny) if gallery is "private"
719:      * @param $hint
720:      * @param $show
721:      */
722:     function checkForGuest(&$hint = NULL, &$show = NULL) {
723:         return !(GALLERY_SECURITY != 'public');
724:     }
725: 
726:     /**
727:      *
728:      * Checks if viewing of object is allowed
729:      * @param string $hint
730:      * @param string $show
731:      */
732:     function checkAccess(&$hint = NULL, &$show = NULL) {
733:     if ($this->isMyItem(LIST_RIGHTS)) {
734:       return true;
735:     }
736:     return $this->checkforGuest($hint, $show);
737:   }
738:   
739:   /**
740:    * Checks if the item is either expired or in scheduled publishing
741:    * A class method wrapper of the functions.php function of the same name
742:    * @return boolean
743:    */
744:   function checkPublishDates() {
745:     $row = array();
746:     if (isAlbumClass($this) || isImageClass($this)) {
747:       $row = array(
748:           'show' => $this->getShow(),
749:           'expiredate' => $this->getExpireDate(),
750:           'publishdate' => $this->getPublishDate()
751:       );
752:     } else if ($this->table == 'news' || $this->table == 'pages') {
753:       $row = array(
754:           'show' => $this->getShow(),
755:           'expiredate' => $this->getExpireDate(),
756:           'publishdate' => $this->getDateTime()
757:       );
758:     }
759:     $check = checkPublishDates($row);
760:     if ($check == 1 || $check == 2) {
761:       return false;
762:     } else {
763:       return true;
764:     }
765:   }
766: 
767: }
768: 
769: //////////////////////////////////////////////////////////////////////////////////////////////////////
770: /**
771:  * Root class for images and albums
772:  *
773:  */
774: class MediaObject extends ThemeObject {
775: 
776:     /**
777:      * Class instantiator
778:      */
779:     function __construct() {
780:         //  no actions required
781:     }
782: 
783:     /**
784:      * Returns the description
785:      *
786:      * @return string
787:      */
788:     function getDesc($locale = NULL) {
789:         $text = $this->get('desc');
790:         if ($locale == 'all') {
791:             return zpFunctions::unTagURLs($text);
792:         } else {
793:             return applyMacros(zpFunctions::unTagURLs(get_language_string($text, $locale)));
794:         }
795:     }
796: 
797:     /**
798:      * Stores the description
799:      *
800:      * @param string $desc description text
801:      */
802:     function setDesc($desc) {
803:         $desc = zpFunctions::tagURLs($desc);
804:         $this->set('desc', $desc);
805:     }
806: 
807:     /**
808:      * Returns the sort order
809:      *
810:      * @return string
811:      */
812:     function getSortOrder() {
813:         return $this->get('sort_order');
814:     }
815: 
816:     /**
817:      * Stores the sort order
818:      *
819:      * @param string $sortorder image sort order
820:      */
821:     function setSortOrder($sortorder) {
822:         $this->set('sort_order', $sortorder);
823:     }
824: 
825:     /**
826:      * Returns the guest user
827:      *
828:      * @return string
829:      */
830:     function getUser() {
831:         return $this->get('user');
832:     }
833: 
834:     /**
835:      * Sets the guest user
836:      *
837:      * @param string $user
838:      */
839:     function setUser($user) {
840:         $this->set('user', $user);
841:     }
842: 
843:     /**
844:      * Returns the password
845:      *
846:      * @return string
847:      */
848:     function getPassword() {
849:         if (GALLERY_SECURITY != 'public') {
850:             return NULL;
851:         } else {
852:             return $this->get('password');
853:         }
854:     }
855: 
856:     /**
857:      * Sets the encrypted password
858:      *
859:      * @param string $pwd the cleartext password
860:      */
861:     function setPassword($pwd) {
862:         $this->set('password', $pwd);
863:     }
864: 
865:     /**
866:      * Returns the password hint
867:      *
868:      * @return string
869:      */
870:     function getPasswordHint($locale = NULL) {
871:         $text = $this->get('password_hint');
872:         if ($locale !== 'all') {
873:             $text = get_language_string($text, $locale);
874:         }
875:         $text = zpFunctions::unTagURLs($text);
876:         return $text;
877:     }
878: 
879:     /**
880:      * Sets the password hint
881:      *
882:      * @param string $hint the hint text
883:      */
884:     function setPasswordHint($hint) {
885:         $this->set('password_hint', zpFunctions::tagURLs($hint));
886:     }
887: 
888:     /**
889:      * Returns the expire date
890:      *
891:      * @return string
892:      */
893:     function getExpireDate() {
894:         $dt = $this->get("expiredate");
895:         if ($dt == '0000-00-00 00:00:00') {
896:             return NULL;
897:         } else {
898:             return $dt;
899:         }
900:     }
901: 
902:     /**
903:      * sets the expire date
904:      *
905:      */
906:     function setExpireDate($ed) {
907:         if ($ed) {
908:             $newtime = dateTimeConvert($ed);
909:             if ($newtime === false)
910:                 return;
911:             $this->set('expiredate', $newtime);
912:         } else {
913:             $this->set('expiredate', NULL);
914:         }
915:     }
916: 
917:     /**
918:      * Returns the publish date
919:      *
920:      * @return string
921:      */
922:     function getPublishDate() {
923:         $dt = $this->get("publishdate");
924:         if ($dt == '0000-00-00 00:00:00') {
925:             return NULL;
926:         } else {
927:             return $dt;
928:         }
929:     }
930: 
931:     /**
932:      * sets the publish date
933:      *
934:      */
935:     function setPublishDate($ed) {
936:         if ($ed) {
937:             $newtime = dateTimeConvert($ed);
938:             if ($newtime === false)
939:                 return;
940:             $this->set('publishdate', $newtime);
941:         } else {
942:             $this->set('publishdate', NULL);
943:         }
944:     }
945: 
946: }
947: 
948: ?>
949: