Source for file filemanager.class.php

Documentation is available at filemanager.class.php

  1. <?php
  2. /**
  3.  * PHPDevShell is a RAD Framework aimed at developing administrative applications.
  4.  *
  5.  * @package PHPDevShell
  6.  * @link http://www.phpdevshell.org
  7.  * @copyright Copyright (C) 2007 Jason Schoeman, All rights reserved.
  8.  * @license GNU/LGPL, see readme/licensed_under_lgpl or http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
  9.  * @author Jason Schoeman, Contact: titan [at] phpdevshell [dot] org.
  10.  *
  11.  *  Copyright notice: See readme/notice
  12.  *  By using PHPDevShell you agree to notice and license, if you dont agree to this notice/license you are not allowed to use PHPDevShell.
  13.  */
  14. /**
  15.  * This class handles file uploads in its simplest form.
  16.  *
  17.  */
  18. class filemanager
  19. {
  20.     /**
  21.      * Should file uploads be logged to the database.
  22.      * Default will load settings from database.
  23.      *
  24.      * @var boolean 
  25.      */
  26.     public $log_uploads = 'default';
  27.     /**
  28.      * The default upload relative path for files.
  29.      * Default will load settings from database.
  30.      * Example : myupload
  31.      *
  32.      * @var string 
  33.      */
  34.     public $default_upload_directory = 'default';
  35.     /**
  36.      * Set permission for newly uploaded files.
  37.      * Default will load settings from database.
  38.      * Example : 0777
  39.      *
  40.      * @var int 
  41.      */
  42.     public $cmod = 'default';
  43.     /**
  44.      * The maximum allowed file upload size.
  45.      * Default will load settings from database.
  46.      * Example : 1000 (1kb)
  47.      *
  48.      * @var int 
  49.      */
  50.     public $max_filesize = 'default';
  51.     /**
  52.      * The maximum allowed image upload size.
  53.      * Default will load settings from database.
  54.      * Example : 1000 (1kb)
  55.      *
  56.      * @var int 
  57.      */
  58.     public $max_imagesize = 'default';
  59.     /**
  60.      * The allowed extentions for uploads.
  61.      * Default will load settings from database.
  62.      * Example : jpg,png,gif
  63.      *
  64.      * @var string 
  65.      */
  66.     public $allowed_ext = 'default';
  67.     /**
  68.      * Should thumbnails be created on image uploads.
  69.      * Default will load settings from database.
  70.      *
  71.      * @var boolean 
  72.      */
  73.     public $do_create_thumb = 'default';
  74.     /**
  75.      * Image quality of converted images.
  76.      * Default will load settings from database.
  77.      * Example : 80
  78.      *
  79.      * @var int 
  80.      */
  81.     public $image_quality = 'default';
  82.     /**
  83.      * Typical resize type for thumbnails.
  84.      * Default will load settings from database.
  85.      * Options : resize | resizepercent | cropfromcenter | crop
  86.      *
  87.      * @var string 
  88.      */
  89.     public $thumbnail_type = 'default';
  90.     /**
  91.      * Resize by pixels.
  92.      * Default will load settings from database.
  93.      * [Max Width, Max Height] example (resize image to no wider than 250 pixels wide and 250 pixels high) : 250,250
  94.      *
  95.      * @var string 
  96.      */
  97.     public $resize_thumb_dimension = 'default';
  98.     /**
  99.      * Resize by percentage.
  100.      * Default will load settings from database.
  101.      * [Percentage] example (reduce the image by 50%) : 50
  102.      *
  103.      * @var string 
  104.      */
  105.     public $resize_thumb_percent = 'default';
  106.     /**
  107.      * Crop from center.
  108.      * Default will load settings from database.
  109.      * [Crop Size] example (create a 100x100 pixel crop from the center of an image) : 100
  110.      *
  111.      * @var string 
  112.      */
  113.     public $crop_thumb_fromcenter = 'default';
  114.     /**
  115.      * Crop by measure.
  116.      * Default will load settings from database.
  117.      * [startX, startY, width, height] example (create a 100x50 pixel crop from the top left corner of an image) : 0,0,100,50
  118.      *
  119.      * @var string 
  120.      */
  121.     public $crop_thumb_dimension = 'default';
  122.     /**
  123.      * Add thumb reflections.
  124.      * Default will load settings from database.
  125.      *
  126.      * @var boolean 
  127.      */
  128.     public $do_thumb_reflect = 'default';
  129.     /**
  130.      * Reflection options.
  131.      * Default will load settings from database.
  132.      * Data fields expected are [[Percentage of image], [Reflection percentage], [Transparency of reflection], [Set Border], [Border Color]. Example : 40,40,80,true,#a4a4a4
  133.      *
  134.      * @var string 
  135.      */
  136.     public $thumb_reflect_settings = 'default';
  137.     /**
  138.      * This option will shrink a large image to a smaller then original viewable image. This should be larger then a thumbnail in most cases as this is the image the user can see when clicking on a thumbnail.
  139.      * Default will load settings from database.
  140.      *
  141.      * @var boolean 
  142.      */
  143.     public $do_create_resize_image = 'default';
  144.     /**
  145.      * [Max Width, Max Height] example (resize image to no wider than 500 pixels wide and 500 pixels high) : 500,500
  146.      * Default will load settings from database.
  147.      *
  148.      * @var string 
  149.      */
  150.     public $resize_image_dimension = 'default';
  151.     /**
  152.      * An alias to group the images with in a certain application.
  153.      * Will use active plugin name if left empty.
  154.      *
  155.      * @var string 
  156.      */
  157.     public $alias;
  158.     /**
  159.      * Groups file upload by menu id.
  160.      * Will use active menu id if left empty.
  161.      *
  162.      * @var int 
  163.      */
  164.     public $menu_id;
  165.     /**
  166.      * Groups file uploads to a specific document.
  167.      * Will use active menu id if left empty.
  168.      *
  169.      * @var int 
  170.      */
  171.     public $sub_id;
  172.     /**
  173.      * The group a file batch belongs to.
  174.      * Will use uploaders primary group id if left empty.
  175.      *
  176.      * @var int 
  177.      */
  178.     public $group_id;
  179.     /**
  180.      * Convert pdf to image using convert in Linux.
  181.      * Please note imagemagick needs to be installed on Linux server.
  182.      *
  183.      * @var boolean 
  184.      */
  185.     public $convert_pdf = false;
  186.     /**
  187.      * Choose the density image will be converted to from pdf.
  188.      *
  189.      * @var integer 
  190.      */
  191.     public $convert_density = '300';
  192.     /**
  193.      * Graphics Engine.
  194.      * Supports gd, imagick
  195.      *
  196.      * @var string 
  197.      */
  198.     public $graphics_engine = 'gd';
  199.     /**
  200.      * When converting to pdf with multiple pages, image copies will be stored here.
  201.      *
  202.      * @var array 
  203.      */
  204.     public $image_copies = array();
  205.     /**
  206.      * Holds a record of recently uploaded files.
  207.      *
  208.      * @var array 
  209.      */
  210.     public $upload_history = array();
  211.     /**
  212.      * Text Domain
  213.      *
  214.      * @var string 
  215.      */
  216.     public $d = 'core.lang';
  217.     /**
  218.      * This method simply renames the file to unix standards.
  219.      *
  220.      * @param string $filename 
  221.      * @param string $replace Replace odd characters with what?
  222.      */
  223.     public function safe_file_name ($filename, $replace = '_')
  224.     {
  225.         global $core;
  226.         return $core->safe_name($filename, $replace);
  227.     }
  228.  
  229.     /**
  230.      * Get a files extension.
  231.      *
  232.      * @param string $filename 
  233.      * @return string 
  234.      */
  235.     public function get_file_extension ($filename)
  236.     {
  237.         return end(explode('.', $filename));
  238.     }
  239.  
  240.     /**
  241.      * Get filename without extension.
  242.      *
  243.      * @param string $filename 
  244.      * @return string 
  245.      */
  246.     public function get_file_base ($filename)
  247.     {
  248.         $filename_ = explode('.', $filename);
  249.         return $filename_[0];
  250.     }
  251.  
  252.     /**
  253.      * Takes a filename and checks what icon needs to go with it.
  254.      *
  255.      * @param string $extension_lookup 
  256.      */
  257.     public function icon_type ($extension_lookup)
  258.     {
  259.         global $configuration;
  260.         if (empty($extension_lookup)) return false;
  261.         switch ($extension_lookup) {
  262.             case 'zip':
  263.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/archive.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  264.                 break;
  265.             case 'rar':
  266.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/archive.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  267.                 break;
  268.             case 'jar':
  269.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/archive.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  270.                 break;
  271.             case 'ace':
  272.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/archive.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  273.                 break;
  274.             case 'cab':
  275.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/archive.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  276.                 break;
  277.             case 'bz2':
  278.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/archive.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  279.                 break;
  280.             case 'tar':
  281.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/archive.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  282.                 break;
  283.             case 'gzip':
  284.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/archive.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  285.                 break;
  286.             case 'doc':
  287.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/doc.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  288.                 break;
  289.             case 'xls':
  290.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/xls.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  291.                 break;
  292.             case 'eps':
  293.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/eps.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  294.                 break;
  295.             case 'exe':
  296.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/exe.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  297.                 break;
  298.             case 'fla':
  299.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/fla.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  300.                 break;
  301.             case 'gif':
  302.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/gif.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  303.                 break;
  304.             case 'html':
  305.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/html.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  306.                 break;
  307.             case 'php':
  308.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/html.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  309.                 break;
  310.             case 'jpg':
  311.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/jpg.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  312.                 break;
  313.             case 'png':
  314.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/jpg.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  315.                 break;
  316.             case 'pdf':
  317.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/pdf.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  318.                 break;
  319.             case 'psd':
  320.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/psd.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  321.                 break;
  322.             case 'sig':
  323.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/sig.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  324.                 break;
  325.             case 'swf':
  326.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/swf.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  327.                 break;
  328.             case 'mpg':
  329.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/video2.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  330.                 break;
  331.             case 'avi':
  332.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/video2.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  333.                 break;
  334.             case 'wmp':
  335.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/video.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  336.                 break;
  337.             case 'bin':
  338.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/bin.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  339.                 break;
  340.             case 'txt':
  341.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/txt.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  342.                 break;
  343.             default:
  344.                 $icon = "<img src=\"templates/{$configuration['template_folder']}/images/icons/unknown.gif\" border=\"0\" alt=\"$extension_lookup\" title=\"$extension_lookup\">";
  345.                 break;
  346.         }
  347.         return $icon;
  348.     }
  349.  
  350.     /**
  351.      * Deletes a filename.
  352.      *
  353.      * @param string $filename 
  354.      */
  355.     public function delete_filename ($filename = false)
  356.     {
  357.         if (! empty($filename)) {
  358.             if (file_exists($filename)) {
  359.                 if (unlink($filename)) {
  360.                     return true;
  361.                 } else {
  362.                     return false;
  363.                 }
  364.             } else {
  365.                 return false;
  366.             }
  367.         }
  368.     }
  369.  
  370.     /**
  371.      * Creates directory according to month and year.
  372.      *
  373.      * @param string $directory Writable directory where new directories will be created and files stored.
  374.      * @param integer $cmod 
  375.      */
  376.     public function create_date_directory ($directory = false, $cmod = false)
  377.     {
  378.         $year = date('Y');
  379.         $month = date('m');
  380.         // Create directory strings.
  381.         $year_directory = $directory . '/' . $year . '/';
  382.         $full_directory = $directory . '/' . $year . '/' . $month . '/';
  383.         $thumb_directory = $directory . '/' . $year . '/' . $month . '/thumbs/';
  384.         $resize_directory = $directory . '/' . $year . '/' . $month . '/resize/';
  385.         // Check if year exists.
  386.         if (! file_exists($year_directory)) {
  387.             mkdir($year_directory);
  388.             chmod($year_directory, $cmod);
  389.             touch($year_directory . 'index.html');
  390.         }
  391.         // Check if full folder exists.
  392.         if (! file_exists($full_directory)) {
  393.             mkdir($full_directory);
  394.             chmod($full_directory, $cmod);
  395.             touch($full_directory . 'index.html');
  396.         }
  397.         // Check if thumbs folder exists.
  398.         if (! file_exists($thumb_directory)) {
  399.             mkdir($thumb_directory);
  400.             chmod($thumb_directory, $cmod);
  401.             touch($thumb_directory . 'index.html');
  402.         }
  403.         // Check if thumbs folder exists.
  404.         if (! file_exists($resize_directory)) {
  405.             mkdir($resize_directory);
  406.             chmod($resize_directory, $cmod);
  407.             touch($resize_directory . 'index.html');
  408.         }
  409.         // Return directory.
  410.         return $full_directory;
  411.     }
  412.  
  413.     /**
  414.      * Move file from temp directory to specified directory.
  415.      *
  416.      * @param string $uploaded_filename 
  417.      * @param string $directory 
  418.      * @param string $new_filename 
  419.      */
  420.     public function upload_file ($uploaded_filename, $directory, $new_filename)
  421.     {
  422.         if (move_uploaded_file($uploaded_filename, $directory . basename($new_filename))) {
  423.             return true;
  424.         } else {
  425.             return false;
  426.         }
  427.     }
  428.  
  429.     /**
  430.      * Creates unique and safe filename.
  431.      *
  432.      */
  433.     public function rename_unique_filename ($filename, $extension = false)
  434.     {
  435.         if (empty($filename)) {
  436.             return false;
  437.         } else {
  438.             if ($extension == false) {
  439.                 $extension_ = false;
  440.             } else {
  441.                 $extension_ = '.' . $extension;
  442.             }
  443.             $random = rand(0, 999999999);
  444.             $uniq = $this->safe_file_name($this->get_file_base($filename)) . '_' . uniqid($random) . $extension_;
  445.             return $uniq;
  446.         }
  447.     }
  448.  
  449.     /**
  450.      * Simplifies the whole process of uploading files with type=file.
  451.      *
  452.      * @param string $input_name The name of the <form type="file" name="???" />
  453.      * @param string $file_overwrite_id The id of the log that needs to be overwritten.
  454.      * @param string $file_description a Simple file description for uploaded item.
  455.      *
  456.      * @return string Will return the complete uploaded directory with its filename.
  457.      */
  458.     public function auto_upload ($input_name, $file_overwrite_id = false, $file_description = false)
  459.     {
  460.         // Set global variables.
  461.         global $template, $lang, $db, $configuration, $core;
  462.         // Start Exception handling.
  463.         try {
  464.             // Get database settings.
  465.             if (empty($this->setting)) {
  466.                 $this->setting = $db->get_settings(array('log_uploads' , 'default_upload_directory' , 'cmod' , 'max_filesize' , 'max_imagesize' , 'allowed_ext' , 'do_create_thumb' , 'do_create_resize_image' , 'image_quality' , 'thumbnail_type' , 'resize_thumb_dimension' , 'resize_image_dimension' , 'resize_thumb_percent' , 'crop_thumb_fromcenter' , 'crop_thumb_dimension' , 'do_thumb_reflect' , 'thumb_reflect_settings', 'graphics_engine'), 'PHPDevShell');
  467.             }
  468.             // Do we have files uploaded?
  469.             if (! empty($_FILES[$input_name]['tmp_name']) && ! empty($_FILES[$input_name]['name'])) {
  470.                 // Gain filenames.
  471.                 $tmp_name = $_FILES[$input_name]['tmp_name'];
  472.                 $original_name = $_FILES[$input_name]['name'];
  473.                 $uploaded_size = $_FILES[$input_name]['size'];
  474.                 $mime_type = $_FILES[$input_name]['type'];
  475.                 $extention_type = $this->get_file_extension($original_name);
  476.                 // Determine standard file association variables.
  477.                 (empty($this->sub_id)) ? $sub_id = $configuration['m'] : $sub_id = $this->sub_id;
  478.                 (empty($this->menu_id)) ? $menu_id = $configuration['m'] : $menu_id = $this->menu_id;
  479.                 (empty($this->alias)) ? $alias = $core->active_plugin() : $alias = $this->alias;
  480.                 (empty($file_description)) ? $file_description = $original_name : false;
  481.                 (empty($this->group_id)) ? $group_id = $configuration['user_group'] : $group_id = $this->group_id;
  482.                 // Determine correct file upload options.
  483.                 // graphics_engine
  484.                 $graphics_engine = $this->setting($this->graphics_engine, $this->setting['graphics_engine'], 'gd');
  485.                 define('DEFAULT_THUMBLIB_IMPLEMENTATION', $graphics_engine);
  486.                 // log_uploads
  487.                 $log_uploads = $this->setting($this->log_uploads, $this->setting['log_uploads'], true, true);
  488.                 // default_upload_directory
  489.                 $default_upload_directory = $this->setting($this->default_upload_directory, $this->setting['default_upload_directory'], 'upload');
  490.                 // cmod
  491.                 $cmod = $this->setting($this->cmod, octdec($this->setting['cmod']), 0644);
  492.                 // max_filesize
  493.                 $max_filesize = $this->setting($this->max_filesize, $this->setting['max_filesize'], false);
  494.                 // max_imagesize
  495.                 $max_imagesize = $this->setting($this->max_imagesize, $this->setting['max_imagesize'], false);
  496.                 // allowed_ext
  497.                 $allowed_ext = $this->setting($this->allowed_ext, $this->setting['allowed_ext'], false);
  498.                 // do_create_thumb
  499.                 $do_create_thumb = $this->setting($this->do_create_thumb, $this->setting['do_create_thumb'], true, true);
  500.                 // do_create_resize_image
  501.                 $do_create_resize_image = $this->setting($this->do_create_resize_image, $this->setting['do_create_resize_image'], true, true);
  502.                 // resize_image_dimension
  503.                 $resize_image_dimension = $this->setting($this->resize_image_dimension, $this->setting['resize_image_dimension'], '640,480');
  504.                 $resize_image_dimension_ = explode(',', $resize_image_dimension);
  505.                 // image_quality
  506.                 $image_quality = $this->setting($this->image_quality, $this->setting['image_quality'], 80);
  507.                 // Set mime type.
  508.                 if (stripos($mime_type, 'image') !== false) {
  509.                     $mime_upload = 'image';
  510.                     $check_size = $max_imagesize;
  511.                 } else {
  512.                     $mime_upload = 'file';
  513.                     $check_size = $max_filesize;
  514.                 }
  515.                 // Setup thumbnail settings.
  516.                 $set_thumb = array('jpegQuality' => $image_quality);
  517.                 //////////////////////////////////////////////////////////////
  518.                 // Error checking.
  519.                 if (! empty($check_size) && ($uploaded_size > $check_size)) {
  520.                     throw new error(sprintf($lang['file_to_large'], $original_name, $this->display_filesize($uploaded_size), $this->display_filesize($check_size)));
  521.                     $error[0] = true;
  522.                 }
  523.                 // Check extentions allowed.
  524.                 if (! empty($allowed_ext)) {
  525.                     // Check if we have the required extention.
  526.                     $extention_find = stripos($allowed_ext, $extention_type);
  527.                     // Check if extention is allowed.
  528.                     if ($extention_find === false) {
  529.                         throw new error(sprintf($lang['extention_not_allowed'], $extention_type, $allowed_ext));
  530.                         $error[1] = true;
  531.                     }
  532.                 }
  533.                 //////////////////////////////////////////////////////////////
  534.                 // Check file size.
  535.                 if (empty($error)) {
  536.                     // Create date directory.
  537.                     $final_upload_path = $this->create_date_directory($default_upload_directory, $cmod);
  538.                     // Create unique filename.
  539.                     $unique_filename = $this->rename_unique_filename($original_name, $extention_type);
  540.                     // Move files to correct folder.
  541.                     if ($this->upload_file($tmp_name, $final_upload_path, $unique_filename)) {
  542.                         // Check if we have a pdf and if we need to convert it.
  543.                         if ($this->convert_pdf == true && $extention_type == 'pdf') {
  544.                             $mime_upload = 'image';
  545.                             $pdf_path = $final_upload_path . $unique_filename;
  546.                             $jpg_file = str_replace(".pdf", ".jpg", "$unique_filename");
  547.                             $jpg_path = $final_upload_path . $jpg_file;
  548.                             exec("convert -density {$this->convert_density} -resize $resize_image_dimension_[0] -quality $image_quality $pdf_path $jpg_path");
  549.                             $mime_type = 'image/jpg';
  550.                             $extention_type = 'jpg';
  551.                             // Check if system renamed it.
  552.                             if (file_exists($jpg_path)) {
  553.                                 $unique_filename = $jpg_file;
  554.                             } else {
  555.                                 $unique_filename = str_replace(".jpg", "-0.jpg", "$jpg_file");
  556.                             }
  557.                             // Finally delete old pdf.
  558.                             $this->delete_filename($pdf_path);
  559.                         }
  560.                         // Initiate thumbnail.
  561.                         if ($mime_upload == 'image') {
  562.                             // Create thumbnail.
  563.                             $thumbnail_path = $final_upload_path . 'thumbs/' . $unique_filename;
  564.                             // Initiate thumb class.
  565.                             $thumbnail = thumbnail::create($final_upload_path . $unique_filename, $set_thumb);
  566.                             if (! empty($do_create_thumb)) {
  567.                                 // Create thumbnail.
  568.                                 $thumbnail_path = $final_upload_path . 'thumbs/' . $unique_filename;
  569.                                 // Initiate thumb class.
  570.                                 $resizeimg = thumbnail::create($final_upload_path . $unique_filename, $set_thumb);
  571.                                 // thumbnail_type
  572.                                 $thumbnail_type = $this->setting($this->thumbnail_type, $this->setting['thumbnail_type'], 'resize');
  573.                                 // Set preferred settings.
  574.                                 switch ($thumbnail_type) {
  575.                                     case 'resize':
  576.                                         // resize_thumb_dimension
  577.                                         $resize_thumb_dimension = $this->setting($this->resize_thumb_dimension, $this->setting['resize_thumb_dimension'], '150,150');
  578.                                         $resize_thumb_dimension_ = explode(',', $resize_thumb_dimension);
  579.                                         $thumbnail->resize($resize_thumb_dimension_[0], $resize_thumb_dimension_[1]);
  580.                                         break;
  581.                                     case 'resizepercent':
  582.                                         // resize_thumb_percent
  583.                                         $resize_thumb_percent = $this->setting($this->resize_thumb_percent, $this->setting['resize_thumb_percent'], '40');
  584.                                         $thumbnail->resizePercent($resize_thumb_percent);
  585.                                         break;
  586.                                     case 'cropfromcenter':
  587.                                         // crop_thumb_fromcenter
  588.                                         $crop_thumb_fromcenter = $this->setting($this->crop_thumb_fromcenter, $this->setting['crop_thumb_fromcenter'], '150');
  589.                                         $thumbnail->cropFromCenter($crop_thumb_fromcenter);
  590.                                         break;
  591.                                     case 'crop':
  592.                                         // crop_thumb_dimension
  593.                                         $crop_thumb_dimension = $this->setting($this->crop_thumb_dimension, $this->setting['crop_thumb_dimension'], '0,0,100,50');
  594.                                         $crop_thumb_dimension_ = explode(',', $crop_thumb_dimension);
  595.                                         $thumbnail->crop($crop_thumb_dimension_[0], $crop_thumb_dimension_[1], $crop_thumb_dimension_[2], $crop_thumb_dimension_[3]);
  596.                                         break;
  597.                                     default:
  598.                                         // resize_thumb_dimension
  599.                                         $resize_thumb_dimension = $this->setting($this->resize_thumb_dimension, $this->setting['resize_thumb_dimension'], '150,150');
  600.                                         $resize_thumb_dimension_ = explode(',', $resize_thumb_dimension);
  601.                                         $thumbnail->resize($resize_thumb_dimension_[0], $resize_thumb_dimension_[1]);
  602.                                         break;
  603.                                 }
  604.                                 // do_thumb_reflect
  605.                                 $do_thumb_reflect = $this->setting($this->do_thumb_reflect, $this->setting['do_thumb_reflect'], false, true);
  606.                                 // thumb_reflect_settings
  607.                                 if (! empty($do_thumb_reflect)) {
  608.                                     // thumb_reflect_settings
  609.                                     $thumb_reflect_settings = $this->setting($this->thumb_reflect_settings, $this->setting['thumb_reflect_settings'], '40,40,80,false,#fff');
  610.                                     $thumb_reflect_settings_ = explode(',', $thumb_reflect_settings);
  611.                                     $thumbnail->createReflection($thumb_reflect_settings_[0], $thumb_reflect_settings_[1], $thumb_reflect_settings_[2], $thumb_reflect_settings_[3], $thumb_reflect_settings_[4]);
  612.                                 }
  613.                                 //////////////////////////////////////////////
  614.                                 // Continue saving thumb image well. /////////
  615.                                 //////////////////////////////////////////////
  616.                                 // Finaly save thumbnail!
  617.                                 $thumbnail->save($thumbnail_path);
  618.                                 // Set needed permissions.
  619.                                 chmod($thumbnail_path, $cmod);
  620.                             }
  621.                             //////////////////////////////////////////////
  622.                             // Continue saving a resized image as well. //
  623.                             //////////////////////////////////////////////
  624.                             if (! empty($do_create_resize_image)) {
  625.                                 // Create thumbnail.
  626.                                 $resized_view_path = $final_upload_path . 'resize/' . $unique_filename;
  627.                                 // Initiate thumb class.
  628.                                 $resizeimg = thumbnail::create($final_upload_path . $unique_filename, $set_thumb);
  629.                                 // Resize view image if we need it.
  630.                                 $dimension = $resizeimg->getCurrentDimensions();
  631.                                 if ($dimension['width'] > $resize_image_dimension_[0] || $dimension['height'] > $resize_image_dimension_[1]) $resizeimg->resize($resize_image_dimension_[0], $resize_image_dimension_[1]);
  632.                                 // Save resized image!
  633.                                 $resizeimg->save($resized_view_path);
  634.                                 // Set needed permissions.
  635.                                 chmod($resized_view_path, $cmod);
  636.                             }
  637.                         } else {
  638.                             // We dont have an image so we wont have thumbs and resized images.
  639.                             $thumbnail_path = false;
  640.                             $resized_view_path = false;
  641.                         }
  642.                         // Should it be logged?
  643.                         if (! empty($log_uploads)) {
  644.                             // Now that all is good, lets log this entry to the database.
  645.                             $db->new_query("
  646.                                 REPLACE INTO
  647.                                     _db_core_upload_logs (file_id, sub_id, menu_id, alias, original_filename, new_filename, relative_path, thumbnail, resized, extention, mime_type, file_desc, group_id, user_id, date_stored, file_size)
  648.                                 VALUES
  649.                                     ('$file_overwrite_id', '$sub_id', '$menu_id', '$alias', '$original_name', '$unique_filename', '$final_upload_path', '$thumbnail_path', '$resized_view_path', '$extention_type', '$mime_type', '$file_description', '$group_id', '{$configuration['user_id']}', '{$configuration['time']}', '$uploaded_size')
  650.                             ");
  651.                         }
  652.                         // Set needed permissions.
  653.                         chmod($final_upload_path . $unique_filename, $cmod);
  654.                         // Return filename and relative path.
  655.                         return $final_upload_path . $unique_filename;
  656.                     } else {
  657.                         return false;
  658.                     }
  659.                 } else {
  660.                     return false;
  661.                 }
  662.             } else {
  663.                 return false;
  664.             }
  665.         } catch (Exception $e) {
  666.             throw new error($e->getMessage());
  667.         }
  668.     }
  669.  
  670.     /**
  671.      * Convert numeric into file size.
  672.      *
  673.      * @param numeric $filesize
  674.      * @return string
  675.      * @author info@levaravel.com
  676.      */
  677.     public function display_filesize ($filesize)
  678.     {
  679.         // Set global.
  680.         global $lang;
  681.         if (is_numeric($filesize)) {
  682.             $decr = 1024;
  683.             $step = 0;
  684.             $prefix = array($lang['bytes'] , $lang['kb'] , $lang['mb'] , $lang['gb'] , $lang['tb'] , $lang['pb']);
  685.             while (($filesize / $decr) > 0.9) {
  686.                 $filesize = $filesize / $decr;
  687.                 $step ++;
  688.             }
  689.             return round($filesize, 2) . ' ' . $prefix[$step];
  690.         } else {
  691.             return false;
  692.         }
  693.     }
  694.  
  695.     /**
  696.      * Internal check to see what thumbnail what settings to return.
  697.      *
  698.      * @param mixed $preferred_setting First passed through settings.
  699.      * @param mixed $database_setting Database called settings.
  700.      * @param mixed $fail_setting If all else fail use this setting.
  701.      * @param boolean $boolean Is setting a boolean value?
  702.      * @return mixed
  703.      */
  704.     private function setting ($preferred_setting, $database_setting, $fail_setting, $boolean = false)
  705.     {
  706.         if (empty($boolean)) {
  707.             if ($preferred_setting == 'default' && ! empty($database_setting)) {
  708.                 return $database_setting;
  709.             } else if (! empty($preferred_setting)) {
  710.                 return $preferred_setting;
  711.             } else {
  712.                 return $fail_setting;
  713.             }
  714.         } else {
  715.             if ($preferred_setting == 'default' && isset($database_setting)) {
  716.                 return $database_setting;
  717.             } else if (isset($preferred_setting)) {
  718.                 return $preferred_setting;
  719.             } else {
  720.                 return $fail_setting;
  721.             }
  722.         }
  723.     }
  724.  
  725.     /**
  726.      * Build query for extracting stored files.
  727.      *
  728.      * @param integer $file_id Get only a single file with a file_id.
  729.      * @param string $alias Load only files by this alias.
  730.      * @param integer $sub_id Load only files by this sub_id.
  731.      * @param integer $menu_id Load only files by this menu_id.
  732.      * @return string
  733.      */
  734.     private function build_file_query ($file_id = false, $alias = false, $sub_id = false, $menu_id = false)
  735.     {
  736.         // Define.
  737.         $query_grouped = false;
  738.         // Check if we need a single file.
  739.         if (! empty($file_id)) {
  740.             $query_grouped = " WHERE file_id = '$file_id' ";
  741.         } else {
  742.             // Group WHERE queries first level.
  743.             if (! empty($alias)) {
  744.                 $query_grouped .= " WHERE alias = '$alias' ";
  745.             } else if (! empty($sub_id)) {
  746.                 $query_grouped .= " WHERE sub_id = '$sub_id' ";
  747.                 $sub_id_set = true;
  748.             } else if (! empty($menu_id)) {
  749.                 $query_grouped .= " WHERE menu_id = '$menu_id' ";
  750.                 $menu_id_set = true;
  751.             }
  752.             // Group AND queries second level.
  753.             if (! empty($query_grouped)) {
  754.                 if (! empty($sub_id) && empty($sub_id_set)) {
  755.                     $query_grouped .= " AND sub_id = '$sub_id' ";
  756.                 }
  757.                 if (! empty($menu_id) && empty($menu_id_set)) {
  758.                     $query_grouped .= " AND menu_id = '$menu_id' ";
  759.                 }
  760.             } else {
  761.                 // We need no queries here.
  762.                 $query_grouped = false;
  763.             }
  764.         }
  765.         // Return results.
  766.         return $query_grouped;
  767.     }
  768.  
  769.     /**
  770.      * Delete file logs from database.
  771.      *
  772.      * @param integer $file_id Get only a single file with a file_id.
  773.      * @param string $alias Load only files by this alias.
  774.      * @param integer $sub_id Load only files by this sub_id.
  775.      * @param integer $menu_id Load only files by this menu_id.
  776.      * @return boolean Will return true if deleted.
  777.      */
  778.     public function delete_files ($file_id = false, $alias = false, $sub_id = false, $menu_id = false)
  779.     {
  780.         global $db;
  781.         // Load deleted item.
  782.         $files = $this->load_files($file_id, $alias, $sub_id, $menu_id);
  783.         // Define.
  784.         $query_grouped = $this->build_file_query($file_id, $alias, $sub_id, $menu_id);
  785.         // Delete query.
  786.         if ($db->new_query("
  787.             DELETE FROM
  788.                 _db_core_upload_logs
  789.                 $query_grouped
  790.         ")) {
  791.                 // Delete files.
  792.                 foreach ($files as $fa) {
  793.                     // Check if multiple images exists of a pdf conversion left over.
  794.                     if (strstr($fa['download_file'], '-0.jpg')) {
  795.                         $this->return_image_copies($fa['download_file']);
  796.                         // Loop multiple images and list them.
  797.                         if (!empty($this->image_copies)) {
  798.                             foreach ($this->image_copies as $multiple_images_) {
  799.                                 $this->delete_filename($multiple_images_);
  800.                             }
  801.                         }
  802.                     }
  803.                     // Delete Original.
  804.                     if (! empty($fa['download_file'])) $this->delete_filename($fa['download_file']);
  805.                     // Delete Resized.
  806.                     if (! empty($fa['resized'])) $this->delete_filename($fa['resized']);
  807.                     // Delete Thumb.
  808.                     if (! empty($fa['thumbnail'])) $this->delete_filename($fa['thumbnail']);
  809.                 }
  810.                 // Return array.
  811.                 return $files;
  812.         } else {
  813.             return false;
  814.         }
  815.     }
  816.  
  817.     /**
  818.      * Load uploaded files from the log database.
  819.      *
  820.      * @param integer $file_id Get only a single file with a file_id.
  821.      * @param string $alias Load only files by this alias.
  822.      * @param integer $sub_id Load only files by this sub_id.
  823.      * @param integer $menu_id Load only files by this menu_id.
  824.      * @param string $order What the query should be ordered by. allows you to order by any of these column values : file_id, sub_id, menu_id, alias, original_filename, new_filename, relative_path, thumbnail, resized, extention, mime_type, file_desc, group_id, user_id, date_stored
  825.      * @param string $limit how many files should be returned in the array.
  826.      * @return array
  827.      */
  828.     public function load_files ($file_id = false, $alias = false, $sub_id = false, $menu_id = false, $order = 'file_id DESC', $limit = '0,5')
  829.     {
  830.         global $db;
  831.         // Define.
  832.         $query_grouped = $this->build_file_query($file_id, $alias, $sub_id, $menu_id);
  833.         // Check order.
  834.         if (empty($file_id)) {
  835.             // Create order and limit query.
  836.             $order_by = " ORDER BY $order LIMIT $limit";
  837.         } else {
  838.             $order_by = false;
  839.         }
  840.         // Load files from database.
  841.         $load_files_db = $db->new_query("
  842.             SELECT
  843.                 file_id,
  844.                 sub_id,
  845.                 menu_id,
  846.                 alias,
  847.                 original_filename,
  848.                 new_filename,
  849.                 relative_path,
  850.                 thumbnail,
  851.                 resized,
  852.                 extention,
  853.                 mime_type,
  854.                 file_desc,
  855.                 group_id,
  856.                 user_id,
  857.                 date_stored,
  858.                 file_size
  859.             FROM
  860.                 _db_core_upload_logs
  861.                 $query_grouped
  862.                 $order_by
  863.         ");
  864.                 // Loop and gather results.
  865.                 while ($files_array = mysql_fetch_array($load_files_db)) {
  866.                     // Create download filename.
  867.                     $files_array['download_file'] = $files_array['relative_path'] . $files_array['new_filename'];
  868.                     // Create human readable file size.
  869.                     $files_array['format_file_size'] = $this->display_filesize($files_array['file_size']);
  870.                     // Create extention image.
  871.                     $files_array['extention_img'] = $this->icon_type($files_array['extention']);
  872.                     // File array.
  873.                     $final_files_return[$files_array['file_id']] = $files_array;
  874.                     // Clear.
  875.                     unset($files_array);
  876.                 }
  877.                 if (! empty($final_files_return)) {
  878.                     // Return results.
  879.                     return $final_files_return;
  880.                 } else {
  881.                     // No results to return.
  882.                     return array();
  883.                 }
  884.     }
  885.     /**
  886.      * Check if multiple images exists converted from a pdf with multiple pages.
  887.      *
  888.      * @param string $file
  889.      * @param int $nr The current file number in the loop.
  890.      */
  891.     public function return_image_copies ($file, $nr=0)
  892.     {
  893.         // Multiple files should exist, recall and check.
  894.         if (file_exists($file)) {
  895.             $this->image_copies[$nr] = $file;
  896.             $nr_next = $nr + 1;
  897.             $file_next = str_replace("-$nr.jpg", "-$nr_next.jpg", "$file");
  898.             $this->return_image_copies($file_next, $nr_next);
  899.         }
  900.     }
  901.  
  902.     /**
  903.      * Enables the caller to download a file to a local writable directory.
  904.      *
  905.      * @param $url The url to download from
  906.      * @param $copy_to The location to copy to add the name to the file too, example: /var/www/test.zip
  907.      * @return mixed
  908.      */
  909.     public function download_file($url, $copy_to)
  910.     {
  911.         global $template;
  912.         // Check if function exists.
  913.         if (!function_exists('curl_init')) {
  914.             throw new <a href="../PHPDevShell/error.html">error</a>(__('Oops cURL is not installed on your server, I cannot continue.', $this->d));
  915.             return false;
  916.         }
  917.         $err_msg = '';
  918.         $out = fopen($copy_to, 'wb');
  919.         if ($out == false) {
  920.             throw new <a href="../PHPDevShell/error.html">error</a>(sprintf(__('File %s could not be written to %s, please check permission, directories and if file exists.', $this->d), $url, $copy_to));
  921.             return false;
  922.         }
  923.         $ch = curl_init();
  924.         curl_setopt($ch, CURLOPT_FILE, $out);
  925.         curl_setopt($ch, CURLOPT_HEADER, 0);
  926.         curl_setopt($ch, CURLOPT_URL, $url);
  927.         curl_exec($ch);
  928.         if (curl_error($ch)) {
  929.             throw new <a href="../PHPDevShell/error.html">error</a>(sprintf(__('There was a cURL error : %s when I tried to copy to : %s',$this->d), curl_error($ch), $copy_to));
  930.             return false;
  931.         }
  932.         curl_close($ch);
  933.         return $copy_to;
  934.     }
  935.  
  936.     /**
  937.      * Extracts a ZIP archive to the specified extract path
  938.      *
  939.      * @param string $file The ZIP archive to extract (including the path)
  940.      * @param string $extractPath The path to extract the ZIP archive to
  941.      *
  942.      * @return boolean TURE if the ZIP archive is successfully extracted, FALSE if there was an errror
  943.      *
  944.      */
  945.     public function zip_extract($file, $extractPath)
  946.     {
  947.         $zip = new ZipArchive();
  948.         $res = $zip->open($file);
  949.         if ($res === TRUE) {
  950.             $zip->extractTo($extractPath);
  951.             $zip->close();
  952.             return TRUE;
  953.         } else {
  954.             return FALSE;
  955.         }
  956.  
  957.     }
  958.  
  959.     /**
  960.      * Copy file or folder from source to destination, it can do
  961.      * recursive copy as well and is very smart
  962.      * It recursively creates the dest file or directory path if there weren't exists
  963.      * Situtaions :
  964.      * - Src:/home/test/file.txt ,Dst:/home/test/b ,Result:/home/test/b -> If source was file copy file.txt name with b as name to destination
  965.      * - Src:/home/test/file.txt ,Dst:/home/test/b/ ,Result:/home/test/b/file.txt -> If source was file Creates b directory if does not exsits and copy file.txt into it
  966.      * - Src:/home/test ,Dst:/home/ ,Result:/home/test/** -> If source was directory copy test directory and all of its content into dest
  967.      * - Src:/home/test/ ,Dst:/home/ ,Result:/home/**-> if source was direcotry copy its content to dest
  968.      * - Src:/home/test ,Dst:/home/test2 ,Result:/home/test2/** -> if source was directoy copy it and its content to dest with test2 as name
  969.      * - Src:/home/test/ ,Dst:/home/test2 ,Result:->/home/test2/** if source was directoy copy it and its content to dest with test2 as name
  970.      * @todo
  971.      * - Should have rollback technique so it can undo the copy when it wasn't successful
  972.      * - Auto destination technique should be possible to turn off
  973.      * - Supporting callback function
  974.      * - May prevent some issues on shared enviroments : http://us3.php.net/umask
  975.      * @param $source //file or folder
  976.      * @param $dest ///file or folder
  977.      * @param $options //folderPermission,filePermission
  978.      * @return boolean
  979.      */
  980.     public function smartCopy($source, $dest, $options=array('folderPermission'=>0755,'filePermission'=>0644))
  981.     {
  982.         $result=false;
  983.  
  984.         if (is_file($source)) {
  985.             if ($dest[strlen($dest)-1]=='/') {
  986.                 if (!file_exists($dest)) {
  987.                     cmfcDirectory::makeAll($dest,$options['folderPermission'],true);
  988.                 }
  989.                 $__dest=$dest."/".basename($source);
  990.             } else {
  991.                 $__dest=$dest;
  992.             }
  993.             $result=copy($source, $__dest);
  994.             chmod($__dest,$options['filePermission']);
  995.  
  996.         } elseif(is_dir($source)) {
  997.             if ($dest[strlen($dest)-1]=='/') {
  998.                 if ($source[strlen($source)-1]=='/') {
  999.                     //Copy only contents
  1000.                 } else {
  1001.                     //Change parent itself and its contents
  1002.                     $dest=$dest.basename($source);
  1003.                     @mkdir($dest);
  1004.                     chmod($dest,$options['filePermission']);
  1005.                 }
  1006.             } else {
  1007.                 if ($source[strlen($source)-1]=='/') {
  1008.                     //Copy parent directory with new name and all its content
  1009.                     @mkdir($dest,$options['folderPermission']);
  1010.                     chmod($dest,$options['filePermission']);
  1011.                 } else {
  1012.                     //Copy parent directory with new name and all its content
  1013.                     @mkdir($dest,$options['folderPermission']);
  1014.                     chmod($dest,$options['filePermission']);
  1015.                 }
  1016.             }
  1017.  
  1018.             $dirHandle=opendir($source);
  1019.             while($file=readdir($dirHandle))
  1020.             {
  1021.                 if($file!="." && $file!="..")
  1022.                 {
  1023.                     if(!is_dir($source."/".$file)) {
  1024.                         $__dest=$dest."/".$file;
  1025.                     } else {
  1026.                         $__dest=$dest."/".$file;
  1027.                     }
  1028.                     //echo "$source/$file ||| $__dest<br />";
  1029.                     $result = $this->smartCopy($source."/".$file, $__dest, $options);
  1030.                 }
  1031.             }
  1032.             closedir($dirHandle);
  1033.  
  1034.         } else {
  1035.             $result=false;
  1036.         }
  1037.         return $result;
  1038.     }
  1039.  
  1040.     /**
  1041.      * Will delete a whole directory recursively (directory muste be writable).
  1042.      *
  1043.      * @param $dirname Directory to delete.
  1044.      * @return boolean.
  1045.      */
  1046.     public function delete_dir($dirname) {
  1047.         if (is_dir($dirname))
  1048.         $dir_handle = opendir($dirname);
  1049.         if (!$dir_handle)
  1050.         return false;
  1051.         while($file = readdir($dir_handle)) {
  1052.             if ($file != "." && $file != "..") {
  1053.                 if (!is_dir($dirname."/".$file))
  1054.                 unlink($dirname."/".$file);
  1055.                 else
  1056.                 $this->delete_dir($dirname.'/'.$file);
  1057.             }
  1058.         }
  1059.         closedir($dir_handle);
  1060.         rmdir($dirname);
  1061.         return true;
  1062.     }
  1063.  
  1064.  
  1065.     /**
  1066.      * Connects to a normal ftp or secure server.
  1067.      * If values left empty system will use PHPDevShell configuration values.
  1068.      *
  1069.      * @param $username
  1070.      * @param $password
  1071.      * @param $host
  1072.      * @param $port
  1073.      * @param $ssl
  1074.      * @param $timeout
  1075.      * @param $chdir
  1076.      * @return resource connection id.
  1077.      */
  1078.     public function establish_ftp ($username='config', $password='config', $host='config', $port='config', $ssl='config', $timeout='config', $chdir='config')
  1079.     {
  1080.         global $db, $template;
  1081.  
  1082.         // Load database settings.
  1083.         $conf = $db->get_settings(array('ftp_enable', 'ftp_username', 'ftp_password', 'ftp_host', 'ftp_port', 'ftp_ssl', 'ftp_timeout', 'ftp_root'));
  1084.  
  1085.         // Load defaults.
  1086.         if (!empty($conf['ftp_enable'])) {
  1087.             if ($username == 'config') $username = $conf['ftp_username'];
  1088.             if ($password == 'config') $password = $conf['ftp_password'];
  1089.             if ($host == 'config') $host = $conf['ftp_host'];
  1090.             if ($port == 'config') $port = $conf['ftp_port'];
  1091.             if ($ssl == 'config') $ssl = $conf['ftp_ssl'];
  1092.             if ($timeout == 'config') $timeout = $conf['ftp_timeout'];
  1093.             if ($chdir == 'config' && ! empty($conf['ftp_root'])) $chdir = $conf['ftp_root'];
  1094.         }
  1095.         // Establish connection.
  1096.         if ($ssl == false) {
  1097.             if (!$resource = ftp_connect($host, $port, $timeout)) {
  1098.                 throw new <a href="../PHPDevShell/error.html">error</a>(sprintf(__('I could not connect to local ftp server %s, user %s.', $this->d), $host, $username));
  1099.                 return false;
  1100.             }
  1101.         } else {
  1102.             if (!$resource = ftp_ssl_connect($host, $port, $timeout)) {
  1103.                 throw new <a href="../PHPDevShell/error.html">error</a>(sprintf(__('I could not connect using SSL to local ftp server %s, user %s.', $this->d), $host, $username));
  1104.                 return false;
  1105.             }
  1106.         }
  1107.         // Log in to server.
  1108.         if (ftp_login($resource, $username, $password)) {
  1109.             // Should we change the directory path.
  1110.             if (! empty($chdir) && $chdir != 'config') {
  1111.                 ftp_chdir($resource, $chdir);
  1112.             }
  1113.  
  1114.             return $resource;
  1115.         } else {
  1116.             throw new <a href="../PHPDevShell/error.html">error</a>(sprintf(__('Incorrect login for local ftp server %s, user %s.', $this->d), $host, $username));
  1117.             return false;
  1118.         }
  1119.     }
  1120.  
  1121.     /**
  1122.      * The following is a fully tested function (based on a previous note) that recursively puts files from a source directory to a destination directory. See http://rufy.com/tech/archives/000026.html for more information.
  1123.      *
  1124.      * NOTE: Use full path name for the destination directory and the destination directory must already exist
  1125.      *
  1126.      * @param resource $conn_id
  1127.      * @param string $src_dir
  1128.      * @param string $dst_dir
  1129.      * @return void
  1130.      */
  1131.     public function ftp_rcopy($conn_id, $src_dir, $dst_dir)
  1132.     {
  1133.         global $template;
  1134.         if ($dir = dir($src_dir)) {
  1135.             while($file = $dir->read()) { // do this for each file in the directory
  1136.                 if ($file != '.' && $file != '..') { // to prevent an infinite loop
  1137.                     if (is_dir($src_dir . '/' . $file)) { // do the following if it is a directory
  1138.                         if (!@ftp_nlist($conn_id, $dst_dir . '/' . $file)) {
  1139.                             ftp_mkdir($conn_id, $dst_dir . '/' . $file); // create directories that do not yet exist
  1140.                             ftp_chmod($conn_id, 0755, $dst_dir . '/' . $file);
  1141.                         }
  1142.                         $this->ftp_rcopy($conn_id, $src_dir . '/' . $file, $dst_dir . '/' . $file); // recursive part
  1143.                         $this->upload_history[] = array('from' => $src_dir . '/' . $file, 'to' => $dst_dir . '/' . $file);
  1144.                     } else {
  1145.                         if (!ftp_put($conn_id, $dst_dir . '/' . $file, $src_dir . '/' . $file, FTP_BINARY)) { // put the files
  1146.                             throw new <a href="../PHPDevShell/error.html">error</a>(sprintf(__('There was a problem copying file %s',$this->d), $dst_dir . '/' . $file));
  1147.                         } else {
  1148.                             $this->upload_history[] = array('from' => $src_dir . '/' . $file, 'to' => $dst_dir . '/' . $file);
  1149.                             ftp_chmod($conn_id, 0644, $dst_dir . '/' . $file);
  1150.                         }
  1151.                     }
  1152.                 }
  1153.             }
  1154.             $dir->close();
  1155.             if (!empty($this->upload_history)) {
  1156.                 return true;
  1157.             } else {
  1158.                 return false;
  1159.             }
  1160.         } else {
  1161.             return false;
  1162.         }
  1163.     }
  1164. }

Documentation generated on Sun, 09 Aug 2009 08:06:20 +0200 by phpDocumentor 1.4.1