nggAdmin

NggAdmin - Class for admin operation.

Defined (1)

The class is defined in the following location(s).

/products/photocrati_nextgen/modules/ngglegacy/admin/functions.php  
  1. class nggAdmin{ 
  2.  
  3.     /** 
  4.      * create a new gallery & folder 
  5.      * 
  6.      * @class nggAdmin 
  7.      * @param string $name of the gallery 
  8.      * @param string $defaultpath 
  9.      * @param bool $output if the function should show an error messsage or not 
  10.      * @return 
  11.      */ 
  12.     static function create_gallery($title, $defaultpath, $output = true) { 
  13.  
  14.         global $user_ID; 
  15.         $fs = C_Fs::get_instance(); 
  16.         $storage = C_Gallery_Storage::get_instance(); 
  17.  
  18.         // get the current user ID 
  19.         wp_get_current_user(); 
  20.  
  21.         //cleanup pathname 
  22.         $name = sanitize_file_name( sanitize_title($title) ); 
  23.         $name = apply_filters('ngg_gallery_name', $name); 
  24.         $txt = ''; 
  25.  
  26.         $galleryObj = new stdClass; 
  27.         $galleryObj->path = ''; 
  28.         $nggRoot = $storage->get_gallery_abspath($galleryObj); 
  29.  
  30.         // No gallery name ? 
  31.         if ( empty($name) ) { 
  32.             if ($output) nggGallery::show_error( __('No valid gallery name!', 'nggallery') ); 
  33.             return false; 
  34.         } 
  35.  
  36.         $galleryObj = new stdClass; 
  37.         $galleryObj->path = $fs->join_paths($defaultpath, $name); 
  38.         $gallery_path = $storage->get_gallery_abspath($galleryObj); 
  39.  
  40.         // check for main folder 
  41.         if ( !is_dir($nggRoot) ) { 
  42.             if ( !wp_mkdir_p( $nggRoot ) ) { 
  43.                 $txt = __('Directory', 'nggallery').' <strong>' . esc_html( $nggRoot ) . '</strong> '.__('didn\'t exist. Please create first the main gallery folder ', 'nggallery').'!<br />'; 
  44.                 $txt .= __('Check this link, if you didn\'t know how to set the permission :', 'nggallery').' <a href="http://codex.wordpress.org/Changing_File_Permissions">http://codex.wordpress.org/Changing_File_Permissions</a> '; 
  45.                 if ($output) nggGallery::show_error($txt); 
  46.                 return false; 
  47.             } 
  48.         } 
  49.  
  50.         // 1. Check for existing folder 
  51.         if ( is_dir($gallery_path) && !(SAFE_MODE) ) { 
  52.             $suffix = 1; 
  53.             do { 
  54.                 $alt_name = substr ($name, 0, 200 - ( strlen( $suffix ) + 1 ) ) . "_$suffix"; 
  55.                 $galleryObj->path = $fs->join_paths($defaultpath, $alt_name); 
  56.                 $gallery_path = $storage->get_gallery_abspath($galleryObj); 
  57.                 $dir_check = is_dir($gallery_path); 
  58.                 $suffix++; 
  59.             } while ( $dir_check ); 
  60.             $name = $alt_name; 
  61.         } 
  62.  
  63.         $thumb_path = $fs->join_paths($gallery_path, 'thumbs'); 
  64.  
  65.         // 2. Create new gallery folder 
  66.         if ( !wp_mkdir_p ($gallery_path) ) 
  67.           $txt = __('Unable to create directory ', 'nggallery') . esc_html($gallery_path) . '!<br />'; 
  68.  
  69.         // 3. Check folder permission 
  70.         if ( !is_writeable($gallery_path) ) 
  71.             $txt .= __('Directory', 'nggallery').' <strong>' . esc_html($gallery_path) . '</strong> '.__('is not writeable !', 'nggallery').'<br />'; 
  72.  
  73.         // 4. Now create thumbnail folder inside 
  74.         if ( !is_dir($thumb_path) ) { 
  75.             if ( !wp_mkdir_p ($thumb_path) ) 
  76.                 $txt .= __('Unable to create directory ', 'nggallery').' <strong>' . esc_html($thumb_path) . '/thumbs !</strong>'; 
  77.         } 
  78.  
  79.         if (SAFE_MODE) { 
  80.             $help = __('The server setting Safe-Mode is on !', 'nggallery'); 
  81.             $help .= '<br />'.__('If you have problems, please create directory', 'nggallery').' <strong>' . esc_html($gallery_path) . '</strong> '; 
  82.             $help .= __('and the thumbnails directory', 'nggallery').' <strong>' . esc_html($thumb_path) . '</strong> '.__('with permission 777 manually !', 'nggallery'); 
  83.             if ($output) nggGallery::show_message($help); 
  84.         } 
  85.  
  86.         // show a error message 
  87.         if ( !empty($txt) ) { 
  88.             if (SAFE_MODE) { 
  89.                 // for safe_mode , better delete folder, both folder must be created manually 
  90.                 @rmdir($thumb_path); 
  91.                 @rmdir($gallery_path); 
  92.             } 
  93.             if ($output) nggGallery::show_error($txt); 
  94.             return false; 
  95.         } 
  96.  
  97.         // now add the gallery to the database 
  98.         $galleryID = nggdb::add_gallery($title, $defaultpath . $name, '', 0, 0, $user_ID ); 
  99.         // here you can inject a custom function 
  100.         do_action('ngg_created_new_gallery', $galleryID); 
  101.  
  102.         // return only the id if defined 
  103.         if ($output == false) 
  104.             return $galleryID; 
  105.  
  106.         if ($galleryID != false && !isset($_REQUEST['attach_to_post'])) { 
  107.             $message = __('Gallery ID %1$s successfully created. You can show this gallery in your post or page with the shortcode %2$s.<br/>', 'nggallery'); 
  108.             $message = sprintf($message, $galleryID, '<strong>[nggallery id=' . $galleryID . ']</strong>'); 
  109.             $message .= '<a href="' . admin_url() . 'admin.php?page=nggallery-manage-gallery&mode=edit&gid=' . $galleryID . '" >'; 
  110.             $message .= __('Edit gallery', 'nggallery'); 
  111.             $message .= '</a>'; 
  112.  
  113.             if ($output) nggGallery::show_message($message, 'gallery_created_msg'); 
  114.         } 
  115.         return true; 
  116.     } 
  117.  
  118.     /** 
  119.      * Scan folder for new images 
  120.      * 
  121.      * @class nggAdmin 
  122.      * @param string $dirname 
  123.      * @return array $files list of image filenames 
  124.      */ 
  125.     static function scandir( $dirname = '.' ) { 
  126.         $ext = apply_filters('ngg_allowed_file_types', array('jpeg', 'jpg', 'png', 'gif') ); 
  127.  
  128.         $files = array(); 
  129.         if( $handle = opendir( $dirname ) ) { 
  130.             while( false !== ( $file = readdir( $handle ) ) ) { 
  131.                 $info = M_I18n::mb_pathinfo( $file ); 
  132.                 // just look for images with the correct extension 
  133.                 if ( isset($info['extension']) ) { 
  134.                     if ( in_array( strtolower($info['extension']), $ext) ) { 
  135.                         if (!seems_utf8($file)) { 
  136.                             $file = utf8_encode( $file ); 
  137.                         } 
  138.  
  139.                         $files[] = $file; 
  140.                     } 
  141.                 } 
  142.             } 
  143.  
  144.             closedir( $handle ); 
  145.         } 
  146.         sort( $files ); 
  147.         return ( $files ); 
  148.     } 
  149.  
  150.     /** 
  151.      * nggAdmin::createThumbnail() - function to create or recreate a thumbnail 
  152.      * 
  153.      * @class nggAdmin 
  154.      * @param object | int $image contain all information about the image or the id 
  155.      * @return string result code 
  156.      * @since v1.0.0 
  157.      */ 
  158.     static function create_thumbnail($image) { 
  159.  
  160.         if (is_object($image)) { 
  161.             if (isset($image->id)) { 
  162.                 $image = $image->id; 
  163.             } 
  164.             elseif (isset($image->pid)) { 
  165.                 $image = $image->pid; 
  166.             } 
  167.         } 
  168.         $storage = C_Gallery_Storage::get_instance(); 
  169.  
  170.         // XXX NextGEN Legacy wasn't handling watermarks or reflections at this stage, so we're forcefully disabling them to maintain compatibility 
  171.         $params = array('watermark' => false, 'reflection' => false); 
  172.         $result = $storage->generate_thumbnail($image, $params); 
  173.  
  174.         if (!$result) 
  175.         { 
  176.             // XXX there isn't any error handling unfortunately at the moment in the generate_thumbnail functions, need a way to return proper error status 
  177.             return __('Error while creating thumbnail.', 'nggallery'); 
  178.         } 
  179.  
  180.         // success 
  181.         return '1'; 
  182.     } 
  183.  
  184.     /** 
  185.      * nggAdmin::resize_image() - create a new image, based on the height /width 
  186.      * 
  187.      * @class nggAdmin 
  188.      * @param object | int $image contain all information about the image or the id 
  189.      * @param integer $width optional 
  190.      * @param integer $height optional 
  191.      * @return string result code 
  192.      */ 
  193.     static function resize_image($image, $width = 0, $height = 0) 
  194.     { 
  195.         if (is_object($image)) { 
  196.             if (isset($image->id)) { 
  197.                 $image = $image->id; 
  198.             } 
  199.             elseif (isset($image->pid)) { 
  200.                 $image = $image->pid; 
  201.             } 
  202.         } 
  203.  
  204.         $storage = C_Gallery_Storage::get_instance(); 
  205.         // XXX maybe get rid of this...it's needed to get width/height defaults, placing these directly in generate_image_size could have unwanted consequences 
  206.         $settings = C_NextGen_Settings::get_instance(); 
  207.  
  208.         // XXX NextGEN Legacy wasn't handling watermarks or reflections at this stage, so we're forcefully disabling them to maintain compatibility 
  209.         $params = array('watermark' => false, 'reflection' => false); 
  210.  
  211.         if ($width > 0) { 
  212.             $params['width'] = $width; 
  213.         } 
  214.         else { 
  215.             $params['width'] = $settings->imgWidth; 
  216.         } 
  217.  
  218.         if ($height > 0) { 
  219.             $params['height'] = $height; 
  220.         } 
  221.         else { 
  222.             $params['height'] = $settings->imgHeight; 
  223.         } 
  224.  
  225.         $result = $storage->generate_image_size($image, 'full', $params); 
  226.  
  227.         if (!$result) 
  228.         { 
  229.             // XXX there isn't any error handling unfortunately at the moment in the generate_thumbnail functions, need a way to return proper error status 
  230.             return __('Error while resizing image.', 'nggallery'); 
  231.         } 
  232.  
  233.         // success 
  234.         return '1'; 
  235.     } 
  236.  
  237.     /** 
  238.      * Rotated/Flip an image based on the orientation flag or a definded angle 
  239.      * 
  240.      * @param int|object $image 
  241.      * @param string (optional) $dir, CW (clockwise)or CCW (counter clockwise), if set to false, the exif flag will be used 
  242.      * @param string (optional)  $flip, could be either false | V (flip vertical) | H (flip horizontal) 
  243.      * @return string result code 
  244.      */ 
  245.     static function rotate_image($image, $dir = false, $flip = false) 
  246.     { 
  247.         if (is_object($image)) { 
  248.             if (isset($image->id))        $image = $image->id; 
  249.             elseif (isset($image->pid))   $image = $image->pid; 
  250.         } 
  251.         $storage = C_Gallery_Storage::get_instance(); 
  252.  
  253.         // XXX NextGEN Legacy wasn't handling watermarks or reflections at this stage, so we're forcefully disabling them to maintain compatibility 
  254.         $params = array('watermark' => false, 'reflection' => false); 
  255.         $rotation = null; 
  256.  
  257.         if ($dir === 'CW') { 
  258.             $rotation = 90; 
  259.         } 
  260.         else if ($dir === 'CCW') { 
  261.             $rotation = -90; 
  262.         } 
  263.         // if you didn't define a rotation, we look for the orientation flag in EXIF 
  264.         else if ($dir === false) { 
  265.             $meta = new nggMeta( $image); 
  266.             $exif = $meta->get_EXIF(); 
  267.  
  268.             if (isset($exif['Orientation'])) { 
  269.  
  270.                 switch ($exif['Orientation']) { 
  271.                     case 5 : // vertical flip + 90 rotate right 
  272.                         $flip = 'V'; 
  273.                     case 6 : // 90 rotate right 
  274.                         $rotation = 90; 
  275.                         break; 
  276.                     case 7 : // horizontal flip + 90 rotate right 
  277.                         $flip = 'H'; 
  278.                     case 8 : // 90 rotate left 
  279.                         $rotation = -90; 
  280.                         break; 
  281.                     case 4 : // vertical flip 
  282.                         $flip = 'V'; 
  283.                         break; 
  284.                     case 3 : // 180 rotate left 
  285.                         $rotation = -180; 
  286.                         break; 
  287.                     case 2 : // horizontal flip 
  288.                         $flip = 'H'; 
  289.                         break; 
  290.                     case 1 : // no action in the case it doesn't need a rotation 
  291.                     default: 
  292.                         return '0'; 
  293.                         break; 
  294.                 } 
  295.             } else 
  296.                 return '0'; 
  297.         } 
  298.  
  299.         if ($rotation != null) { 
  300.             $params['rotation'] = $rotation; 
  301.         } 
  302.  
  303.         if ($flip != null) { 
  304.             $params['flip'] = $flip; 
  305.         } 
  306.  
  307.         $result = $storage->generate_image_size($image, 'full', $params); 
  308.  
  309.         if (!$result) 
  310.         { 
  311.             // XXX there isn't any error handling unfortunately at the moment in the generate_thumbnail functions, need a way to return proper error status 
  312.             return __('Error while rotating image.', 'nggallery'); 
  313.         } 
  314.  
  315.         // success 
  316.         return '1'; 
  317.     } 
  318.  
  319.     /** 
  320.      * nggAdmin::set_watermark() - set the watermark for the image 
  321.      * 
  322.      * @class nggAdmin 
  323.      * @param object | int $image contain all information about the image or the id 
  324.      * @return string result code 
  325.      */ 
  326.     static function set_watermark($image) { 
  327.  
  328.         if (is_object($image)) { 
  329.             if (isset($image->id)) { 
  330.                 $image = $image->id; 
  331.             } 
  332.             elseif (isset($image->pid)) { 
  333.                 $image = $image->pid; 
  334.             } 
  335.         } 
  336.  
  337.         $storage = C_Gallery_Storage::get_instance(); 
  338.  
  339.         // XXX NextGEN Legacy was only handling watermarks at this stage, so we're forcefully disabling all else 
  340.         $params = array('watermark' => true, 'reflection' => false, 'crop' => false); 
  341.         $result = $storage->generate_image_size($image, 'full', $params); 
  342.  
  343.         if (!$result) 
  344.         { 
  345.             // XXX there isn't any error handling unfortunately at the moment in the generate_thumbnail functions, need a way to return proper error status 
  346.             return __('Error while applying watermark to image.', 'nggallery'); 
  347.         } 
  348.  
  349.         // success 
  350.         return '1'; 
  351.     } 
  352.  
  353.     /** 
  354.      * Recover image from backup copy and reprocess it 
  355.      * 
  356.      * @class nggAdmin 
  357.      * @since 1.5.0 
  358.      * @param object | int $image contain all information about the image or the id 
  359.      * @return string result code 
  360.      */ 
  361.  
  362.     static function recover_image($image) { 
  363.  
  364.         return C_Gallery_Storage::get_instance()->recover_image($image); 
  365.     } 
  366.  
  367.     /** 
  368.      * Add images to database 
  369.      * 
  370.      * @class nggAdmin 
  371.      * @param int $galleryID 
  372.      * @param array $imageslist 
  373.      * @return array $image_ids Id's which are sucessful added 
  374.      */ 
  375.     static function add_Images($galleryID, $imageslist) { 
  376.  
  377.         global $wpdb, $ngg; 
  378.  
  379.         $image_ids = array(); 
  380.  
  381.         if ( is_array($imageslist) ) { 
  382.             foreach($imageslist as $picture) { 
  383.  
  384.                 // filter function to rename/change/modify image before 
  385.                 $picture = apply_filters('ngg_pre_add_new_image', $picture, $galleryID); 
  386.  
  387.                 // strip off the extension of the filename 
  388.                 $path_parts = M_I18n::mb_pathinfo( $picture ); 
  389.                 $alttext = ( !isset($path_parts['filename']) ) ? substr($path_parts['basename'], 0, strpos($path_parts['basename'], '.')) : $path_parts['filename']; 
  390.                 // save it to the database 
  391.                 $pic_id = nggdb::add_image( $galleryID, $picture, '', $alttext ); 
  392.  
  393.                 if (C_NextGen_Settings::get_instance()->imgBackup && !empty($pic_id)) 
  394.                 { 
  395.                     $storage = C_Gallery_Storage::get_instance(); 
  396.                     $storage->backup_image($pic_id); 
  397.                 } 
  398.  
  399.                 if ( !empty($pic_id) ) 
  400.                     $image_ids[] = $pic_id; 
  401.  
  402.                 // add the metadata 
  403.                 nggAdmin::import_MetaData( $pic_id ); 
  404.  
  405.                 // auto rotate 
  406.                 nggAdmin::rotate_image( $pic_id ); 
  407.  
  408.                 // Autoresize image if required 
  409.                 if ($ngg->options['imgAutoResize']) { 
  410.                     $imagetmp = nggdb::find_image( $pic_id ); 
  411.                     $sizetmp = @getimagesize ( $imagetmp->imagePath ); 
  412.                     $widthtmp = $ngg->options['imgWidth']; 
  413.                     $heighttmp = $ngg->options['imgHeight']; 
  414.                     if (($sizetmp[0] > $widthtmp && $widthtmp) || ($sizetmp[1] > $heighttmp && $heighttmp)) { 
  415.                         nggAdmin::resize_image( $pic_id ); 
  416.                     } 
  417.                 } 
  418.  
  419.                 // action hook for post process after the image is added to the database 
  420.                 $image = array( 'id' => $pic_id, 'filename' => $picture, 'galleryID' => $galleryID); 
  421.                 do_action('ngg_added_new_image', $image); 
  422.  
  423.             } 
  424.         } // is_array 
  425.  
  426.         // delete dirsize after adding new images 
  427.         delete_transient( 'dirsize_cache' ); 
  428.  
  429.         do_action('ngg_after_new_images_added', $galleryID, $image_ids ); 
  430.  
  431.         return $image_ids; 
  432.  
  433.     } 
  434.  
  435.     /** 
  436.      * Import some meta data into the database (if avialable) 
  437.      * 
  438.      * @class nggAdmin 
  439.      * @param array|int $imagesIds 
  440.      * @return string result code 
  441.      */ 
  442.     static function import_MetaData($imagesIds) { 
  443.  
  444.         global $wpdb; 
  445.  
  446.         require_once(NGGALLERY_ABSPATH . '/lib/image.php'); 
  447.  
  448.         if (!is_array($imagesIds)) 
  449.             $imagesIds = array($imagesIds); 
  450.  
  451.         foreach($imagesIds as $imageID) { 
  452.  
  453.             // Get the image 
  454.             $image = NULL; 
  455.             if (is_int($imageID)) { 
  456.                 $image = C_Image_Mapper::get_instance()->find($imageID); 
  457.             } 
  458.             else $image = $imageID; 
  459.  
  460.             if ($image) { 
  461.  
  462.                 $meta = nggAdmin::get_MetaData( $image); 
  463.  
  464.                 // get the title 
  465.                 $alttext = empty( $meta['title'] ) ? $image->alttext : $meta['title']; 
  466.  
  467.                 // get the caption / description field 
  468.                 $description = empty( $meta['caption'] ) ? $image->description : $meta['caption']; 
  469.  
  470.                 // get the file date/time from exif 
  471.                 $timestamp = $meta['timestamp']; 
  472.  
  473.                 // first update database 
  474.                 $result = $wpdb->query( 
  475.                     $wpdb->prepare("UPDATE $wpdb->nggpictures SET 
  476.                         alttext = %s,  
  477.                         description = %s,  
  478.                         imagedate = %s 
  479.                     WHERE pid = %d", $alttext, $description, $timestamp, $image->pid) ); 
  480.  
  481.                 if ($result === false) 
  482.                     return ' <strong>' . esc_html( $image->filename ) . ' ' . __('(Error : Couldn\'t not update data base)', 'nggallery') . '</strong>'; 
  483.  
  484.                 //this flag will inform us that the import is already one time performed 
  485.                 $meta['common']['saved'] = true; 
  486.                 $result = nggdb::update_image_meta($image->pid, $meta['common']); 
  487.  
  488.                 if ($result === false) 
  489.                     return ' <strong>' . esc_html( $image->filename ) . ' ' . __('(Error : Couldn\'t not update meta data)', 'nggallery') . '</strong>'; 
  490.  
  491.                 // add the tags if we found some 
  492.                 if ($meta['keywords']) { 
  493.                     $taglist = explode(', ', $meta['keywords']); 
  494.                     wp_set_object_terms($image->pid, $taglist, 'ngg_tag'); 
  495.                 } 
  496.  
  497.             } else 
  498.                 return ' <strong>' . esc_html( $image->filename ) . ' ' . __('(Error : Couldn\'t not find image)', 'nggallery') . '</strong>';// error check 
  499.         } 
  500.  
  501.         return '1'; 
  502.     } 
  503.  
  504.     /** 
  505.      * nggAdmin::get_MetaData() 
  506.      * 
  507.      * @class nggAdmin 
  508.      * @require NextGEN Meta class 
  509.      * @param int $id image ID 
  510.      * @return array metadata 
  511.      */ 
  512.     static function get_MetaData($image_or_id) { 
  513.  
  514.         require_once(NGGALLERY_ABSPATH . '/lib/meta.php'); 
  515.  
  516.         $meta = array(); 
  517.  
  518.         $pdata = new nggMeta($image_or_id); 
  519.  
  520.         $meta['title'] = trim ( $pdata->get_META('title') ); 
  521.         $meta['caption'] = trim ( $pdata->get_META('caption') ); 
  522.         $meta['keywords'] = trim ( $pdata->get_META('keywords') ); 
  523.         $meta['timestamp'] = $pdata->get_date_time(); 
  524.         // this contain other useful meta information 
  525.         $meta['common'] = $pdata->get_common_meta(); 
  526.         // hook for addon plugin to add more meta fields 
  527.         $meta = apply_filters('ngg_get_image_metadata', $meta, $pdata); 
  528.  
  529.         return $meta; 
  530.  
  531.     } 
  532.  
  533.     /** 
  534.      * Maybe import some meta data to the database. The functions checks the flag 'saved' 
  535.      * and if based on compat reason (pre V1.4.0) we save then some meta datas to the database 
  536.      * 
  537.      * @since V1.4.0 
  538.      * @param int $id 
  539.      * @return result 
  540.      */ 
  541.     function maybe_import_meta( $image_or_id ) { 
  542.  
  543.         require_once(NGGALLERY_ABSPATH . '/lib/meta.php'); 
  544.         $id = is_int($image_or_id) ? $image_or_id : $image_or_id->{$image_or_id->id_field}; 
  545.         $meta_obj = new nggMeta( $image_or_id ); 
  546.  
  547.         if ( $meta_obj->image->meta_data['saved'] != true ) { 
  548.             $common = $meta_obj->get_common_meta(); 
  549.             //this flag will inform us that the import is already one time performed 
  550.             $common['saved'] = true; 
  551.             $result = nggdb::update_image_meta($id, $common); 
  552.         } else 
  553.             return false; 
  554.  
  555.         return $result; 
  556.  
  557.     } 
  558.  
  559.     /** 
  560.      * nggAdmin::import_gallery() 
  561.      * TODO: Check permission of existing thumb folder & images 
  562.      * 
  563.      * @class nggAdmin 
  564.      * @param string $galleryfolder contains relative path to the gallery itself 
  565.      * @return void 
  566.      */ 
  567.     static function import_gallery($galleryfolder, $gallery_id=NULL) { 
  568.  
  569.         global $wpdb, $user_ID; 
  570.  
  571.         // get the current user ID 
  572.         wp_get_current_user(); 
  573.  
  574.         $created_msg = ''; 
  575.  
  576.         // remove trailing slash at the end, if somebody use it 
  577.         $galleryfolder = untrailingslashit($galleryfolder); 
  578.  
  579.         $fs = C_Fs::get_instance(); 
  580.         if (is_null($gallery_id)) { 
  581.             $gallerypath = $fs->join_paths($fs->get_document_root('content'), $galleryfolder); 
  582.         } else { 
  583.             $storage = C_Gallery_Storage::get_instance(); 
  584.             $gallerypath = $storage->get_gallery_abspath($gallery_id); 
  585.         } 
  586.  
  587.         if (!is_dir($gallerypath)) { 
  588.             nggGallery::show_error(sprintf(__("Directory <strong>%s</strong> doesn`t exist!", 'nggallery'), esc_html($gallerypath))); 
  589.             return ; 
  590.         } 
  591.  
  592.         // read list of images 
  593.         $new_imageslist = nggAdmin::scandir($gallerypath); 
  594.  
  595.         if (empty($new_imageslist)) { 
  596.             nggGallery::show_message(sprintf(__("Directory <strong>%s</strong> contains no pictures", 'nggallery'), esc_html($gallerypath))); 
  597.             return; 
  598.         } 
  599.  
  600.         // take folder name as gallery name 
  601.         $galleryname = basename($galleryfolder); 
  602.         $galleryname = apply_filters('ngg_gallery_name', $galleryname); 
  603.  
  604.         // check for existing gallery folder 
  605.         if (is_null($gallery_id)) 
  606.             $gallery_id = $wpdb->get_var("SELECT gid FROM $wpdb->nggallery WHERE path = '$galleryfolder' "); 
  607.  
  608.         if (!$gallery_id) { 
  609.             // now add the gallery to the database 
  610.             $gallery_id = nggdb::add_gallery( $galleryname, $galleryfolder, '', 0, 0, $user_ID ); 
  611.             if (!$gallery_id) { 
  612.                 nggGallery::show_error(__('Database error. Could not add gallery!', 'nggallery')); 
  613.                 return; 
  614.             } 
  615.             else { 
  616.                 do_action('ngg_created_new_gallery', $gallery_id); 
  617.             } 
  618.             $created_msg = sprintf( 
  619.                 _n("Gallery <strong>%s</strong> successfully created!", 'Galleries <strong>%s</strong> successfully created!', 1, 'nggallery'),  
  620.                 esc_html($galleryname) 
  621.  ); 
  622.         } 
  623.  
  624.         // Look for existing image list 
  625.         $old_imageslist = $wpdb->get_col("SELECT filename FROM $wpdb->nggpictures WHERE galleryid = '$gallery_id' "); 
  626.  
  627.         // if no images are there, create empty array 
  628.         if ($old_imageslist == NULL) 
  629.             $old_imageslist = array(); 
  630.  
  631.         // check difference 
  632.         $new_images = array_diff($new_imageslist, $old_imageslist); 
  633.  
  634.         // all images must be valid files 
  635.         foreach($new_images as $key => $picture) { 
  636.  
  637.             // filter function to rename/change/modify image before 
  638.             $picture = apply_filters('ngg_pre_add_new_image', $picture, $gallery_id); 
  639.             $new_images[$key] = $picture; 
  640.  
  641.             if (!@getimagesize($gallerypath . '/' . $picture) ) { 
  642.                 unset($new_images[$key]); 
  643.                 @unlink($gallerypath . '/' . $picture); 
  644.             } 
  645.         } 
  646.  
  647.         // add images to database 
  648.         $image_ids = nggAdmin::add_Images($gallery_id, $new_images); 
  649.         do_action('ngg_after_new_images_added', $gallery_id, $image_ids); 
  650.  
  651.         //add the preview image if needed 
  652.         nggAdmin::set_gallery_preview ( $gallery_id ); 
  653.  
  654.         // now create thumbnails 
  655.         nggAdmin::do_ajax_operation( 'create_thumbnail' , $image_ids, __('Create new thumbnails', 'nggallery') ); 
  656.  
  657.         //TODO:Message will not shown, because AJAX routine require more time, message should be passed to AJAX 
  658.         $message = $created_msg . sprintf(_n('%s picture successfully added', '%s pictures successfully added', count($image_ids), 'nggallery'), count($image_ids)); 
  659.         $message .= ' [<a href="' . admin_url() . 'admin.php?page=nggallery-manage-gallery&mode=edit&gid=' . $gallery_id . '" >'; 
  660.         $message .=  __('Edit gallery', 'nggallery'); 
  661.         $message .= '</a>]'; 
  662.  
  663.         nggGallery::show_message($message); 
  664.  
  665.         return; 
  666.     } 
  667.  
  668.     /** 
  669.      * Capability check. Check is the ID fit's to the user_ID 
  670.      * 
  671.      * @class nggAdmin 
  672.      * @param int $check_ID is the user_id 
  673.      * @return bool $result 
  674.      */ 
  675.     static function can_manage_this_gallery($check_ID) { 
  676.  
  677.         global $user_ID, $wp_roles; 
  678.  
  679.         if ( !current_user_can('NextGEN Manage others gallery') ) { 
  680.             // get the current user ID 
  681.             wp_get_current_user(); 
  682.  
  683.             if ( $user_ID != $check_ID) 
  684.                 return false; 
  685.         } 
  686.  
  687.         return true; 
  688.  
  689.     } 
  690.  
  691.     /** 
  692.      * Initate the Ajax operation 
  693.      * 
  694.      * @class nggAdmin 
  695.      * @param string $operation name of the function which should be executed 
  696.      * @param array $image_array 
  697.      * @param string $title name of the operation 
  698.      * @return string the javascript output 
  699.      */ 
  700.     static function do_ajax_operation( $operation, $image_array, $title = '' ) { 
  701.  
  702.         if ( !is_array($image_array) || empty($image_array) ) 
  703.             return; 
  704.  
  705.         $js_array = implode('", "', $image_array); 
  706.  
  707.         // send out some JavaScript, which initate the ajax operation 
  708.         ?> 
  709.         <script type="text/javascript"> 
  710.  
  711.             Images = new Array("<?php echo $js_array; ?>"); 
  712.  
  713.             nggAjaxOptions = { 
  714.                 operation: "<?php echo $operation; ?>",  
  715.                 ids: Images,  
  716.                 header: "<?php echo $title; ?>",  
  717.                 maxStep: Images.length 
  718.             }; 
  719.  
  720.             jQuery(document).ready( function() { 
  721.                 nggProgressBar.init( nggAjaxOptions ); 
  722.                 nggAjax.init( nggAjaxOptions ); 
  723.             } ); 
  724.         </script> 
  725.  
  726.     <?php 
  727.     } 
  728.  
  729.     /** 
  730.      * nggAdmin::set_gallery_preview() - define a preview pic after the first upload, can be changed in the gallery settings 
  731.      * 
  732.      * @class nggAdmin 
  733.      * @param int $galleryID 
  734.      * @return void 
  735.      */ 
  736.     static function set_gallery_preview( $galleryID ) 
  737.     { 
  738.         $gallery_mapper = C_Gallery_Mapper::get_instance(); 
  739.         if (($gallery = $gallery_mapper->find($galleryID))) { 
  740.             if (!$gallery->previewpic) { 
  741.                 $image_mapper = C_Image_Mapper::get_instance(); 
  742.                 if (($image = $image_mapper->select()->where(array('galleryid = %d', $galleryID))->where(array('exclude != 1'))-> 
  743.                     order_by($image_mapper->get_primary_key_column())->limit(1)->run_query())) { 
  744.                     $gallery->previewpic = $image->{$image->id_field}; 
  745.                     $gallery_mapper->save($gallery); 
  746.                 } 
  747.             } 
  748.         } 
  749.     } 
  750.  
  751.     /** 
  752.      * Return a JSON coded array of Image ids for a requested gallery 
  753.      * 
  754.      * @class nggAdmin 
  755.      * @param int $galleryID 
  756.      * @return arry (JSON) 
  757.      */ 
  758.     static function get_image_ids( $galleryID ) { 
  759.  
  760.         if ( !function_exists('json_encode') ) 
  761.             return(-2); 
  762.  
  763.         $gallery = nggdb::get_ids_from_gallery($galleryID, 'pid', 'ASC', false); 
  764.  
  765.         header('Content-Type: text/plain; charset=' . get_option('blog_charset'), true); 
  766.         $output = json_encode($gallery); 
  767.  
  768.         return $output; 
  769.     } 
  770.  
  771.     /** 
  772.      * Deprecated function, restored to fix compatibility with "NextGen Public Uploader" 
  773.      * 
  774.      * @deprecated 
  775.      * @class nggAdmin 
  776.      * @param string $filename 
  777.      * @return bool $result 
  778.      */ 
  779.     function chmod($filename = '') 
  780.     { 
  781.         $stat = @stat(dirname($filename)); 
  782.         $perms = $stat['mode'] & 0000666; 
  783.         if (@chmod($filename, $perms)) 
  784.             return true; 
  785.         return false; 
  786.     } 
  787.  
  788. } // END class nggAdmin