nucleus/libs/MEDIA.php

   1 <?php
   2 /*
   3  * Nucleus: PHP/MySQL Weblog CMS (http://nucleuscms.org/)
   4  * Copyright (C) 2002-2009 The Nucleus Group
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  * (see nucleus/documentation/index.html#license for more info)
  11  */
  12 /**
  13  * Media classes for nucleus
  14  *
  15  * @license http://nucleuscms.org/license.txt GNU General Public License
  16  * @copyright Copyright (C) 2002-2009 The Nucleus Group
  17  * @version $Id$
  18  * $NucleusJP: MEDIA.php,v 1.5 2006/07/17 20:03:44 kimitake Exp $
  19  */
  20
  21 define('PRIVATE_COLLECTION', 'Private Collection');
  22 define('READ_ONLY_MEDIA_FOLDER', '(Read Only)');
  23
  24 /**
  25   * Represents the media objects for a certain member
  26   */
  27 class MEDIA {
  28
  29         /**
  30           * Gets the list of collections available to the currently logged
  31           * in member
  32           *
  33           * @returns array of dirname => display name
  34           */
  35         function getCollectionList($exceptReadOnly = false) {
  36                 global $member, $DIR_MEDIA;
  37
  38                 $collections = array();
  39
  40                 // add private directory for member
  41                 $collections[$member->getID()] = PRIVATE_COLLECTION;
  42
  43                 // add global collections
  44                 if (!is_dir($DIR_MEDIA)) return $collections;
  45
  46                 $dirhandle = opendir($DIR_MEDIA);
  47                 while ($dirname = readdir($dirhandle)) {
  48                         // only add non-numeric (numeric=private) dirs
  49                         if (@is_dir($DIR_MEDIA . $dirname) &&
  50                                 ($dirname != '.') &&
  51                                 ($dirname != '..') &&
  52                                 ($dirname != 'CVS') &&
  53                                 (!is_numeric($dirname)))  {
  54                                 if (@is_writable($DIR_MEDIA . $dirname))
  55                                         $collections[$dirname] = $dirname;
  56                                 else if ($exceptReadOnly == false)
  57                                         $collections[$dirname] = $dirname . ' ' . READ_ONLY_MEDIA_FOLDER;
  58                         }
  59                 }
  60                 closedir($dirhandle);
  61
  62                 return $collections;
  63
  64         }
  65
  66         /**
  67           * Returns an array of MEDIAOBJECT objects for a certain collection
  68           *
  69           * @param $collection
  70           *             name of the collection
  71           * @param $filter
  72           *             filter on filename (defaults to none)
  73           */
  74         function getMediaListByCollection($collection, $filter = '') {
  75                 global $DIR_MEDIA;
  76
  77                 $filelist = array();
  78
  79                 // 1. go through all objects and add them to the filelist
  80
  81                 $mediadir = $DIR_MEDIA . $collection . '/';
  82
  83                 // return if dir does not exist
  84                 if (!is_dir($mediadir)) return $filelist;
  85
  86                 $dirhandle = opendir($mediadir);
  87                 while ($filename = readdir($dirhandle)) {
  88                         // only add files that match the filter
  89                         if (!@is_dir($filename) && MEDIA::checkFilter($filename, $filter))
  90                                 array_push($filelist, new MEDIAOBJECT($collection, $filename, filemtime($mediadir . $filename)));
  91                 }
  92                 closedir($dirhandle);
  93
  94                 // sort array so newer files are shown first
  95                 usort($filelist, 'sort_media');
  96
  97                 return $filelist;
  98         }
  99
 100         function checkFilter($strText, $strFilter) {
 101                 if ($strFilter == '')
 102                         return 1;
 103                 else
 104                         return is_integer(strpos(strtolower($strText), strtolower($strFilter)));
 105         }
 106
 107         /**
 108           * checks if a collection exists with the given name, and if it's
 109           * allowed for the currently logged in member to upload files to it
 110           */
 111         function isValidCollection($collectionName, $exceptReadOnly = false) {
 112                 global $member, $DIR_MEDIA;
 113
 114                 // allow creating new private directory
 115                 if ($collectionName === (string)$member->getID())
 116                         return true;
 117
 118                 $collections = MEDIA::getCollectionList($exceptReadOnly);
 119                 $dirname = $collections[$collectionName];
 120                 if ($dirname == NULL || $dirname === PRIVATE_COLLECTION)
 121                         return false;
 122
 123                 // other collections should exist and be writable
 124                 $collectionDir = $DIR_MEDIA . $collectionName;
 125                 if ($exceptReadOnly)
 126                         return (@is_dir($collectionDir) && @is_writable($collectionDir));
 127
 128                 // other collections should exist
 129                 return @is_dir($collectionDir);
 130         }
 131
 132         /**
 133           * Adds an uploaded file to the media archive
 134           *
 135           * @param collection
 136           *             collection
 137           * @param uploadfile
 138           *             the postFileInfo(..) array
 139           * @param filename
 140           *             the filename that should be used to save the file as
 141           *             (date prefix should be already added here)
 142           */
 143         function addMediaObject($collection, $uploadfile, $filename) {
 144                 global $DIR_MEDIA, $manager;
 145
 146                 $manager->notify('PreMediaUpload',array('collection' => &$collection, 'uploadfile' => $uploadfile, 'filename' => &$filename));
 147
 148                 // don't allow uploads to unknown or forbidden collections
 149                 $exceptReadOnly = true;
 150                 if (!MEDIA::isValidCollection($collection,$exceptReadOnly))
 151                         return _ERROR_DISALLOWED;
 152
 153                 // check dir permissions (try to create dir if it does not exist)
 154                 $mediadir = $DIR_MEDIA . $collection;
 155
 156                 // try to create new private media directories if needed
 157                 if (!@is_dir($mediadir) && is_numeric($collection)) {
 158                         $oldumask = umask(0000);
 159                         if (!@mkdir($mediadir, 0777))
 160                                 return _ERROR_BADPERMISSIONS;
 161                         umask($oldumask);
 162                 }
 163
 164                 // if dir still not exists, the action is disallowed
 165                 if (!@is_dir($mediadir))
 166                         return _ERROR_DISALLOWED;
 167
 168                 if (!is_writeable($mediadir))
 169                         return _ERROR_BADPERMISSIONS;
 170
 171                 // add trailing slash (don't add it earlier since it causes mkdir to fail on some systems)
 172                 $mediadir .= '/';
 173
 174                 if (file_exists($mediadir . $filename))
 175                         return _ERROR_UPLOADDUPLICATE;
 176
 177                 // move file to directory
 178                 if (is_uploaded_file($uploadfile)) {
 179                         if (!@move_uploaded_file($uploadfile, $mediadir . $filename))
 180                                 return _ERROR_UPLOADMOVEP;
 181                 } else {
 182                         if (!copy($uploadfile, $mediadir . $filename))
 183                                 return _ERROR_UPLOADCOPY ;
 184                 }
 185
 186                 // chmod uploaded file
 187                 $oldumask = umask(0000);
 188                 @chmod($mediadir . $filename, 0644);
 189                 umask($oldumask);
 190
 191                 $manager->notify('PostMediaUpload',array('collection' => $collection, 'mediadir' => $mediadir, 'filename' => $filename));
 192
 193                 return '';
 194
 195         }
 196
 197         /**
 198          * Adds an uploaded file to the media dir.
 199          *
 200          * @param $collection
 201          *              collection to use
 202          * @param $filename
 203          *              the filename that should be used to save the file as
 204          *              (date prefix should be already added here)
 205          * @param &$data
 206          *              File data (binary)
 207          *
 208          * NOTE: does not check if $collection is valid.
 209          */
 210         function addMediaObjectRaw($collection, $filename, &$data) {
 211                 global $DIR_MEDIA;
 212
 213                 // check dir permissions (try to create dir if it does not exist)
 214                 $mediadir = $DIR_MEDIA . $collection;
 215
 216                 // try to create new private media directories if needed
 217                 if (!@is_dir($mediadir) && is_numeric($collection)) {
 218                         $oldumask = umask(0000);
 219                         if (!@mkdir($mediadir, 0777))
 220                                 return _ERROR_BADPERMISSIONS;
 221                         umask($oldumask);
 222                 }
 223
 224                 // if dir still not exists, the action is disallowed
 225                 if (!@is_dir($mediadir))
 226                         return _ERROR_DISALLOWED;
 227
 228                 if (!is_writeable($mediadir))
 229                         return _ERROR_BADPERMISSIONS;
 230
 231                 // add trailing slash (don't add it earlier since it causes mkdir to fail on some systems)
 232                 $mediadir .= '/';
 233
 234                 if (file_exists($mediadir . $filename))
 235                         return _ERROR_UPLOADDUPLICATE;
 236
 237                 // create file
 238                 $fh = @fopen($mediadir . $filename, 'wb');
 239                 if (!$fh)
 240                         return _ERROR_UPLOADFAILED;
 241                 $ok = @fwrite($fh, $data);
 242                 @fclose($fh);
 243                 if (!$ok)
 244                         return _ERROR_UPLOADFAILED;
 245
 246                 // chmod uploaded file
 247                 $oldumask = umask(0000);
 248                 @chmod($mediadir . $filename, 0644);
 249                 umask($oldumask);
 250
 251                 return '';
 252
 253         }
 254
 255 }
 256
 257 /**
 258   * Represents the characteristics of one single media-object
 259   *
 260   * Description of properties:
 261   *  - filename: filename, without paths
 262   *  - timestamp: last modification (unix timestamp)
 263   *  - collection: collection to which the file belongs (can also be a owner ID, for private collections)
 264   *  - private: true if the media belongs to a private member collection
 265   */
 266 class MEDIAOBJECT {
 267
 268         var $private;
 269         var $collection;
 270         var $filename;
 271         var $timestamp;
 272
 273         function MEDIAOBJECT($collection, $filename, $timestamp) {
 274                 $this->private = is_numeric($collection);
 275                 $this->collection = $collection;
 276                 $this->filename = $filename;
 277                 $this->timestamp = $timestamp;
 278         }
 279
 280 }
 281
 282 /**
 283   * User-defined sort method to sort an array of MEDIAOBJECTS
 284   */
 285 function sort_media($a, $b) {
 286         if ($a->timestamp == $b->timestamp) return 0;
 287         return ($a->timestamp > $b->timestamp) ? -1 : 1;
 288 }
 289
 290 ?>