Original

Versions

07.26 php saved
The_Cake_Eater
Tags add more
 
Note
Version 1.4.1 of upload behaviour
  1. <?php
  2. /**
  3. *  Improved Upload Behaviour
  4. *
  5. *  This behaviour is based on Chris Partridge's upload behaviour (http://bin.cakephp.org/saved/17539)
  6. *  @author Chris Partridge http://blog.chris-partridge.info/2007/03/16/uploadbehavior-is-here/
  7. *  @author Tane Piper (digitalspaghetti@gmail.com)
  8. *  @author Tijs Teulings
  9. *  @author The_Cake_Eater
  10. *
  11. *  @link http://www.digitalspaghetti.me.uk
  12. *
  13. *  @todo fields dir, mimetype, filesize will break if more than one fields are used for upload
  14. *  @todo option to only overwrite files that were referenced by the same field before
  15. *  @todo add naming mode 'modelid' where the file name is model->id + extension ==> is tricky since the id is not available in beforeSave for new records
  16. *
  17. *  @version 1.4
  18. *
  19. *  How to use
  20. *  ==========
  21. *  1) Download this behaviour and place it in your models/behaviours/upload.php
  22. *  2) Insert the following SQL into your database.  This is a basic model you can expand on:
  23. *        CREATE TABLE `images` (
  24. *          `id` int(8) unsigned NOT NULL auto_increment,
  25. *          `filename` varchar(255) default NULL,
  26. *          `dir` varchar(255) default NULL,
  27. *          `mimetype` varchar(255) NULL,
  28. *          `filesize` int(11) unsigned default NULL,
  29. *          `created` datetime default NULL,
  30. *          `modified` datetime default NULL,
  31. *          PRIMARY KEY  (`id`) ) ENGINE=MyISAM  DEFAULT CHARSET=utf8;
  32. *  3) In your model that you want to have the upload behavior work, place the below code.  This example is for an Image model:
  33. *
  34. *     var $actsAs = array('Upload' => array(
  35. *        'filename' => array(
  36. *           'dir' => 'files/images',
  37. *           'overwrite_existing' => false,
  38. *           'delete_obsolete_files' => true,
  39. *           'naming' => 'filename',
  40. *           'naming_if_exists' => 'increment',
  41. *           'create_directory' => false,
  42. *           'allowed_mime' => array('image/jpeg', 'image/pjpeg', 'image/gif', 'image/png', 'image/x-png'),
  43. *           'allowed_ext'  => array('.jpg', '.jpeg', '.png', '.gif'),
  44. *           'thumbsizes' => array(
  45. *              'small'   =>    array('width'=>100, 'height'=>100),
  46. *              'medium'  =>    array('width'=>220, 'height'=>220),
  47. *              'large'   =>   array('width'=>800, 'height'=>600)
  48. *           )
  49. *        )
  50. *    ));
  51. *
  52. *  The above code will save the uploaded file's name in the 'filename' field in database,
  53. *  it will not overwrite existing files, instead it will create a random filename if
  54. *  it already exists.
  55. *  Allowed Mimetypes and extentions should be pretty explanitory
  56. *  For thumbnails, when the file is uploaded, it will create 3 thumbnail sizes and prepend the name
  57. *  to the thumbfiles (i.e. image_001.jpg will produced thumb.small.image_001.jpg, thumb.medium.image_001.jpg, etc)
  58. *
  59. *  4) Create your upload view, make sure it's a multipart/form-data form, and the filename field is of type $form->file
  60. *  5) Make sure your directory is at least CHMOD 775, also check your php.ini MAX_UPLOAD_SIZE is enough to support the filesizes you are uploading
  61. *
  62. *  Version History
  63. *  ===============
  64. *  1.4.1 26/7/2007 The_Cake_Eater http://bin.cakephp.org/saved/22189
  65. *    - replacing files with files having the same name failed
  66. * 
  67. *  1.4 25/7/2007 The_Cake_Eater http://bin.cakephp.org/saved/22189
  68. *    - fixed the merging of defauilt options with given options
  69. *    + introduced 'naming' option specifying how the name is generatd (filename, random)
  70. *    + introduced 'naming_if_exists' option specifying how alternate names are generated (random, increment)
  71. *    + introduced 'delete_obsolete_files' option specifying if files that are no longer referenced by a field (replaced with a new file)
  72. *                  or files referenced by a deleted record are deleted
  73. *    * refactoring of parts of the code
  74. *    - some minor fixes
  75. *    - some performance improvements
  76. *
  77. *  1.3 12/7/2007 Tijs Teulings (tijs@automatique.nl) http://bin.cakephp.org/saved/21813
  78. *    - default quality to 'high'
  79. *    - fixed proportional resizing
  80. *    - fixed permissions for both thumbs and originals
  81. *
  82. *  1.2 22/6/2007 Tijs Teulings http://bin.cakephp.org/saved/21697
  83. *    * made filename checks case insensitive
  84. *    * removed thumb component dependency
  85. *    - fixes permissions for original file now
  86. *    - fixed handling of file extensions (supports filenames with dots in them now)
  87. *    * rounding new sizes for more reliable results
  88. *
  89. *  1.1
  90. *    * Improved Image scaling code
  91. *    - Fixed check to see if file exists and rename file to unique name
  92. *    * Improved model actsAs to allow more thumbnail sizes
  93. *
  94. *  1.0
  95. *    + Initial release with thumbnail code.
  96. */
  97.  
  98. uses('folder');
  99. uses('file');
  100.  
  101. class UploadBehavior extends ModelBehavior
  102. {
  103.    static $default_options = array('dir' => '',
  104.    'allowed_mime'          => array(),
  105.    'allowed_ext'           => array(),
  106.    'delete_obsolete_files' => true,
  107.    'overwrite_existing'    => false,
  108.    'naming'                => 'filename', // random, filename
  109.    'naming_if_exists'      => 'random',   // random, increment
  110.    'create_directory'      => true,
  111.    'thumbsizes'            => array()
  112.    );
  113.  
  114.    /*
  115.     * temporary registry of obsolete file names, required since obsolete files are identified in beforeSave and beforeDelete
  116.     * but are removed in afterSave and afterDelete
  117.     */
  118.    var $__obsoleteFiles = array();
  119.  
  120.    /*
  121.     * parses the configuration array and sets up the $this->settings property
  122.     */
  123.    function setup(&$model, $config=array())
  124.    {
  125.       $folder = &new Folder;
  126.  
  127.       // iterate over all upload enabled fields
  128.       foreach($config as $field => $options)
  129.       {
  130.          // Check if given field exists
  131.          if(!$model->hasField($field)) {
  132.             unset($config[$field]);
  133.             unset($model->data[$model->name][$field]);
  134.             continue;
  135.          }
  136.  
  137.          // Merge given options with defaults
  138.          $options = array_merge(UploadBehavior::$default_options, $options);
  139.          $config[$field] = $options;
  140.  
  141.          // FIXME this looks odd
  142.          // Generate temporary directory if none provided
  143.          if(empty($options['dir'])) {
  144.             $options['dir'] = 'img' . DS . 'uploads' . DS . $model->name;
  145.          }
  146.  
  147.          // Check if directory exists and create it recursively if required
  148.          if(!is_dir($options['dir'])) {
  149.             if($options['create_directory'] && !$folder->create($options['dir'])) {
  150.                unset($config[$field]);
  151.                unset($model->data[$model->name][$field]);
  152.                continue;
  153.             }
  154.          }
  155.  
  156.          // Check if directory is writable
  157.          if(!is_writable($options['dir'])) {
  158.             unset($config[$field]);
  159.             unset($model->data[$model->name][$field]);
  160.             continue;
  161.          }
  162.  
  163.          // Check that the given directory does not have a DS on the end
  164.          if($options['dir'][strlen($options['dir'])-1] == DS) {
  165.             $options['dir'] = substr($options['dir'],0,strlen($options['dir'])-2);
  166.          }
  167.       }
  168.       $this->settings[$model->name] = $config;
  169.    }
  170.  
  171.    function beforeSave(&$model)
  172.    {
  173.       // return if no fields are configured for file upload
  174.       if(count($this->settings[$model->name]) == 0) return;
  175.  
  176.       foreach($this->settings[$model->name] as $field=>$options)
  177.       {
  178.          if (isset($model->data[$model->name][$field]))
  179.          {
  180.             // Check for upload
  181.             if(isset($model->data) && !is_array($model->data[$model->name][$field]))
  182.             {
  183.                unset($model->data[$model->name][$field]);
  184.                continue;
  185.             }
  186.  
  187.             // Check for error
  188.             if($model->data[$model->name][$field]['error'] > 0)
  189.             {
  190.                unset($model->data[$model->name][$field]);
  191.                continue;
  192.             }
  193.  
  194.             // Fix the file name
  195.             $model->data[$model->name][$field]['name'] = $this->__getFilteredFileName($model->data[$model->name][$field]['name']);
  196.            
  197.             // Check mime type
  198.             if(count($options['allowed_mime']) > 0 && !in_array($model->data[$model->name][$field]['type'], $options['allowed_mime']))
  199.             {
  200.                unset($model->data[$model->name][$field]);
  201.                continue;
  202.             }
  203.  
  204.             // Check if file extension is allowed
  205.             if(count($options['allowed_ext']) > 0)
  206.             {
  207.                $extension = false;
  208.                foreach($options['allowed_ext'] as $allowed_ext)
  209.                {
  210.                   if(substr(strtolower($model->data[$model->name][$field]['name']),-strlen($allowed_ext)) == $allowed_ext)
  211.                   {
  212.                      $extension = $allowed_ext;
  213.                      break;
  214.                   }
  215.                }
  216.  
  217.                if(!$extension)
  218.                {
  219.                   unset($model->data[$model->name][$field]);
  220.                   continue;
  221.                }
  222.             }
  223.  
  224.             $model->data[$model->name][$field]['name'] = $this->__getTargetFileName($options, $model, $field, $extension);
  225.             $saveAs = $options['dir'] . DS . $model->data[$model->name][$field]['name'];
  226.  
  227.             // Attempt to move uploaded file
  228.             if(!move_uploaded_file($model->data[$model->name][$field]['tmp_name'], $saveAs))
  229.             {
  230.                // if moving fails clear the variables and move on to the next field
  231.                unset($model->data[$model->name][$field]);
  232.                unset($saveAs);
  233.                continue;
  234.             }
  235.  
  236.             // Create thumbnail of uploaded image
  237.             $this->__createThumbs($options, $model, $field, $saveAs);
  238.      
  239.             // Attempt to set correct file permissions
  240.             if(!chmod($saveAs, 0755))
  241.             {
  242.                // if chmod fails clear the variable and move on to the next field
  243.                unset($saveAs);
  244.                continue;
  245.             }
  246.  
  247.             // Update model data
  248.             // FIXME dir, mimetype, filesize, dir are the same for multiple upload field
  249.             $model->data[$model->name]['dir'] = $options['dir'];
  250.             $model->data[$model->name]['mimetype'] = $model->data[$model->name][$field]['type'];
  251.             $model->data[$model->name]['filesize'] = $model->data[$model->name][$field]['size'];
  252.             $model->data[$model->name][$field] = $model->data[$model->name][$field]['name'];
  253.  
  254.             if($options['delete_obsolete_files'] && $model->id)
  255.             {
  256.                
  257.                // retrieve the previous file associated with the current field
  258.                $oldFile = $this->__getFieldValueFromDB($model, $field);
  259.                if(empty($oldFile)) continue;
  260.                
  261.                if($oldFile != $model->data[$model->name][$field])
  262.                {
  263.                   // register the file for garbage collection after successful saving of the model
  264.                   $key = $model->name.'#'.$model->id;
  265.                   if(!isset($this->__obsoleteFiles[$key])) $this->__obsoleteFiles[$key] = array();
  266.                   $this->__obsoleteFiles[$key][$field] = $this->__getFieldValueFromDB($model, $field);
  267.                }
  268.             }
  269.          }
  270.       }
  271.    }
  272.  
  273.    function onError(&$model, $error)
  274.    {
  275.       // if an error occured during save operations precautionary unregister files marked as obsolete related to the current model
  276.       if($model->id)
  277.       {
  278.          $key = $model->name.'#'.$model->id;
  279.          unset($this->__obsoleteFiles[$key]);
  280.       }
  281.    }
  282.  
  283.    function afterSave(&$model, $created)
  284.    {
  285.       // check if any upload fields are defined
  286.       if(count($this->settings[$model->name]) == 0) return;
  287.  
  288.       if(!$created) $this->__deleteObsoleteFiles($model); 
  289.    }
  290.    
  291.    function afterDelete(&$model)
  292.    {
  293.       // return if no fields are configured for file upload
  294.       if(count($this->settings[$model->name]) == 0) return;
  295.  
  296.       $this->__deleteObsoleteFiles($model);
  297.    }
  298.    
  299.    function beforeDelete(&$model)
  300.    {
  301.       // return if no fields are configured for file upload
  302.       if(count($this->settings[$model->name]) == 0) return;
  303.      
  304.       $fieldNames = array_keys($this->settings[$model->name]);
  305.       $fieldValues = $this->__getFieldValuesFromDB($model, $fieldNames);
  306.  
  307.       foreach($this->settings[$model->name] as $fieldName=>$options)
  308.       {
  309.          if($options['delete_obsolete_files'])
  310.          {
  311.             $dir = $options['dir'];
  312.  
  313.             $fileName = $fieldValues[$fieldName];
  314.            
  315.             // register the file for garbage collection after successful saving of the model
  316.             $key = $model->name.'#'.$model->id;
  317.             if(!isset($this->__obsoleteFiles[$key])) $this->__obsoleteFiles[$key] = array();
  318.             $this->__obsoleteFiles[$key][$fieldName] = $fileName;
  319.          }
  320.       }
  321.       return true;
  322.    }
  323.  
  324.    /**
  325.     * creates a thumbnail image
  326.     */
  327.    function __createThumb($name, $filename, $new_w, $new_h)
  328.    {
  329.       $path_info = pathinfo($name);
  330.       $ext = $path_info['extension'];
  331.  
  332.       if (preg_match('/jpg|jpeg/i', $ext))
  333.       {
  334.          $src_img = imagecreatefromjpeg($name);
  335.       }
  336.  
  337.       if (preg_match('/png/i', $ext))
  338.       {
  339.          $src_img = imagecreatefrompng($name);
  340.       }
  341.  
  342.       $old_x = imagesx($src_img);
  343.       $old_y = imagesy($src_img);
  344.  
  345.       $newSizes = $this->__proportionalResize($old_x, $old_y, $new_w, $new_h);
  346.  
  347.       $thumb_w = $newSizes[0];
  348.       $thumb_h = $newSizes[1];
  349.        
  350.       $dst_img = imagecreatetruecolor($thumb_w, $thumb_h);
  351.       imagecopyresampled($dst_img, $src_img, 0, 0, 0, 0, $thumb_w, $thumb_h, $old_x, $old_y);
  352.  
  353.       if (preg_match("/png/i", $ext))
  354.       {
  355.          imagepng($dst_img, $filename, 0); // no compression
  356.       } else {
  357.          imagejpeg($dst_img, $filename, 100); // 100% quality
  358.       }
  359.  
  360.       imagedestroy($dst_img);
  361.       imagedestroy($src_img);
  362.    }
  363.  
  364.    function __createThumbs(&$options, &$model, $fieldName, $saveAs)
  365.    {
  366.       // This is hard-coded to only support JPEG + PNG at this time
  367.       // Code unable to handle other formats
  368.       if (count($options['allowed_ext']) > 0 && in_array($model->data[$model->name][$fieldName]['type'], array('image/jpeg', 'image/pjpeg', 'image/png')))
  369.       {
  370.          foreach ($options['thumbsizes'] as $key => $value)
  371.          {
  372.             $this->__createThumb($saveAs, $options['dir'] . DS . 'thumb.' . $key . '.' . $model->data[$model->name][$fieldName]['name'], $value['width'], $value['height']);
  373.          }
  374.       }
  375.    }
  376.  
  377.    function __deleteObsoleteFiles(&$model)
  378.    {
  379.       // check if obsolete files for the current model exist
  380.       $key = $model->name.'#'.$model->id;
  381.       if(!isset($this->__obsoleteFiles[$key])) return;
  382.  
  383.       // get a handle to the obsolete files
  384.       $obsoleteFilesByFieldName = $this->__obsoleteFiles[$key];
  385.       unset($this->__obsoleteFiles[$key]);
  386.  
  387.       foreach($this->settings[$model->name] as $fieldName=>$options)
  388.       {
  389.          if(!isset($obsoleteFilesByFieldName[$fieldName])) continue;
  390.  
  391.          $obsoleteFileForField = $obsoleteFilesByFieldName[$fieldName];
  392.          $dir = $options['dir'];
  393.          
  394.          if(file_exists($dir.DS.$obsoleteFileForField)) unlink($dir.DS.$obsoleteFileForField);
  395.          
  396.          foreach ($options['thumbsizes'] as $key => $value)
  397.          {
  398.             unlink($dir.DS.'thumb.' . $key . '.' . $obsoleteFileForField);
  399.          }
  400.       }
  401.    }
  402.    
  403.    function __getFilteredFileName($filename)
  404.    {
  405.       $filtered_filename  = '';
  406.  
  407.       $patterns = array(
  408.       '/\s/', // Whitespace
  409.       '/\&/', // Ampersand
  410.       '/\+/'  // Plus
  411.       );
  412.       $replacements = array(
  413.       '_',    // Whitespace
  414.       'and',  // Ampersand
  415.       'plus'  // Plus
  416.       );
  417.        
  418.       $filename = preg_replace($patterns, $replacements, $filename);
  419.  
  420.       for ($i=0;$i<strlen($filename);$i++)
  421.       {
  422.          $current_char = substr($filename,$i,1);
  423.          if (ctype_alnum($current_char) == TRUE || $current_char == "_" || $current_char == ".")
  424.          {
  425.             $filtered_filename .= $current_char;
  426.          }
  427.       }
  428.  
  429.       return $filtered_filename;
  430.    }
  431.  
  432.    function __getFieldValueFromDB(&$model, $fieldName)
  433.    {
  434.       $rs = $model->find(array($model->escapeField() => $model->id), $fieldName);
  435.       return $rs[$model->name][$fieldName];
  436.    }
  437.    
  438.    function __getFieldValuesFromDB(&$model, $fieldNames)
  439.    {
  440.       $rs = $model->find(array($model->escapeField() => $model->id), $fieldNames);
  441.       return $rs[$model->name];
  442.    }
  443.    
  444.    function __getTargetFileName(&$options, &$model, $field, $extension)
  445.    {
  446.       // Calculate a new name if a naming mode other than 'filename' has been selected
  447.       switch($options['naming'])
  448.       {
  449.          case 'random':  $fileName = uniqid() . $extension; break;
  450.          default:        $fileName = substr($model->data[$model->name][$field]['name'], 0, -strlen($extension)) . $extension;
  451.       }
  452.  
  453.       // Calculate final save path
  454.       $saveAs = $options['dir'] . DS . $fileName;
  455.  
  456.       // Check if file with the desired name exists already
  457.       if(file_exists($saveAs))
  458.       {
  459.          // if overwrite is enabled and removing the existing file succeeded, then return the file name directly
  460.          if($options['overwrite_existing'] && unlink($saveAs)) return $fileName;
  461.          
  462.          // find a unique filename by appending a counter to the base name
  463.          if($options['naming_if_exists']=='increment')
  464.          {
  465.             $basename = substr($fileName, 0, -strlen($extension));
  466.             $inc=1;
  467.             do
  468.             {
  469.                $fileName = $basename . '_' . $inc . $extension;
  470.                $saveAs = $options['dir'] . DS . $candidate;
  471.                $inc++;
  472.             }
  473.             while(file_exists($saveAs));
  474.  
  475.             return $fileName;
  476.          }
  477.              
  478.          // find a unique file name by using a UID as the base name
  479.          else
  480.          {
  481.             do
  482.             {
  483.                $fileName = uniqid('') . $extension;
  484.                $saveAs = $options['dir'] . DS . $fileName;
  485.             }
  486.             while(file_exists($saveAs));
  487.          }
  488.       }
  489.       return $fileName;
  490.    }
  491.    
  492.    function __proportionalResize($old_width, $old_height, $new_width = false, $new_height = false)
  493.    {
  494.       if (($new_width === false) && ($new_height === false)) return false;
  495.        
  496.       $old_aspect_ratio = $old_width / $old_height;
  497.        
  498.       if ($new_width === false) {
  499.          $new_width = $new_height * $old_aspect_ratio;
  500.       } elseif ($new_height === false) {
  501.          $new_height = $new_width / $old_aspect_ratio;
  502.       }
  503.       $new_aspect_ratio = $new_width / $new_height;
  504.       if ($new_aspect_ratio == $old_aspect_ratio) {
  505.          // great, done
  506.       } elseif ($new_aspect_ratio < $old_aspect_ratio) {
  507.          // limited by width
  508.          $new_height = $new_width / $old_aspect_ratio;
  509.       } elseif ($new_aspect_ratio > $old_aspect_ratio) {
  510.          // limited by height
  511.          $new_width = $new_height * $old_aspect_ratio;
  512.       }
  513.       return array(round($new_width), round($new_height));
  514.    }
  515. }
  516. ?>
Parsed in 0.716 seconds, using GeSHi 1.0.7.14

Modify this Paste