Subversion Repositories svnkaklik

Compare Revisions

Ignore whitespace Rev 5 → Rev 6

/web/test/gallery/phpwebgallery/admin/include/functions.php
0,0 → 1,1329
<?php
// +-----------------------------------------------------------------------+
// | PhpWebGallery - a PHP based picture gallery |
// | Copyright (C) 2002-2003 Pierrick LE GALL - pierrick@phpwebgallery.net |
// | Copyright (C) 2003-2005 PhpWebGallery Team - http://phpwebgallery.net |
// +-----------------------------------------------------------------------+
// | branch : BSF (Best So Far)
// | file : $RCSfile: functions.php,v $
// | last update : $Date: 2005/01/08 11:23:52 $
// | last modifier : $Author: plg $
// | revision : $Revision: 1.48 $
// +-----------------------------------------------------------------------+
// | This program is free software; you can redistribute it and/or modify |
// | it under the terms of the GNU General Public License as published by |
// | the Free Software Foundation |
// | |
// | This program is distributed in the hope that it will be useful, but |
// | WITHOUT ANY WARRANTY; without even the implied warranty of |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// | General Public License for more details. |
// | |
// | You should have received a copy of the GNU General Public License |
// | along with this program; if not, write to the Free Software |
// | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, |
// | USA. |
// +-----------------------------------------------------------------------+
 
include(PHPWG_ROOT_PATH.'admin/include/functions_metadata.php');
 
$tab_ext_create_TN = array ( 'jpg', 'png', 'JPG', 'PNG' );
 
// is_image returns true if the given $filename (including the path) is a
// picture according to its format and its extension.
// As GD library can only generate pictures from jpeg and png files, if you
// ask if the filename is an image for thumbnail creation (second parameter
// set to true), the only authorized formats are jpeg and png.
function is_image( $filename, $create_thumbnail = false )
{
global $conf, $tab_ext_create_TN;
 
if (is_file($filename)
and in_array(get_extension($filename), $conf['picture_ext']))
{
$size = getimagesize( $filename );
// $size[2] == 1 means GIF
// $size[2] == 2 means JPG
// $size[2] == 3 means PNG
if ( !$create_thumbnail )
{
if ( in_array( get_extension( $filename ), $conf['picture_ext'] )
and ( $size[2] == 1 or $size[2] == 2 or $size[2] == 3 ) )
{
return true;
}
}
else
{
if ( in_array( get_extension( $filename ), $tab_ext_create_TN )
and ( $size[2] == 2 or $size[2] == 3 ) )
{
return true;
}
}
}
return false;
}
 
/**
* returns an array with all picture files according to $conf['file_ext']
*
* @param string $dir
* @return array
*/
function get_pwg_files($dir)
{
global $conf;
 
$pictures = array();
if ($opendir = opendir($dir))
{
while ($file = readdir($opendir))
{
if (in_array(get_extension($file), $conf['file_ext']))
{
array_push($pictures, $file);
}
}
}
return $pictures;
}
 
/**
* returns an array with all thumbnails according to $conf['picture_ext']
* and $conf['prefix_thumbnail']
*
* @param string $dir
* @return array
*/
function get_thumb_files($dir)
{
global $conf;
 
$prefix_length = strlen($conf['prefix_thumbnail']);
$thumbnails = array();
if ($opendir = @opendir($dir.'/thumbnail'))
{
while ($file = readdir($opendir))
{
if (in_array(get_extension($file), $conf['picture_ext'])
and substr($file, 0, $prefix_length) == $conf['prefix_thumbnail'])
{
array_push($thumbnails, $file);
}
}
}
return $thumbnails;
}
 
/**
* returns an array with representative picture files of a directory
* according to $conf['picture_ext']
*
* @param string $dir
* @return array
*/
function get_representative_files($dir)
{
global $conf;
 
$pictures = array();
if ($opendir = @opendir($dir.'/pwg_representative'))
{
while ($file = readdir($opendir))
{
if (in_array(get_extension($file), $conf['picture_ext']))
{
array_push($pictures, $file);
}
}
}
return $pictures;
}
 
function TN_exists( $dir, $file )
{
global $conf;
 
$filename = get_filename_wo_extension( $file );
foreach ( $conf['picture_ext'] as $ext ) {
$test = $dir.'/thumbnail/'.$conf['prefix_thumbnail'].$filename.'.'.$ext;
if ( is_file ( $test ) )
{
return $ext;
}
}
return false;
}
 
// The function delete_site deletes a site and call the function
// delete_categories for each primary category of the site
function delete_site( $id )
{
// destruction of the categories of the site
$query = '
SELECT id
FROM '.CATEGORIES_TABLE.'
WHERE site_id = '.$id.'
;';
$result = pwg_query($query);
$category_ids = array();
while ($row = mysql_fetch_array($result))
{
array_push($category_ids, $row['id']);
}
delete_categories($category_ids);
// destruction of the site
$query = '
DELETE FROM '.SITES_TABLE.'
WHERE id = '.$id.'
;';
pwg_query($query);
}
 
// The function delete_categories deletes the categories identified by the
// (numeric) key of the array $ids. It also deletes (in the database) :
// - all the elements of the category (delete_elements, see further)
// - all the links between elements and this category
// - all the restrictions linked to the category
// The function works recursively.
function delete_categories($ids)
{
global $counts;
 
if (count($ids) == 0)
{
return;
}
 
// add sub-category ids to the given ids : if a category is deleted, all
// sub-categories must be so
$ids = get_subcat_ids($ids);
// destruction of all the related elements
$query = '
SELECT id
FROM '.IMAGES_TABLE.'
WHERE storage_category_id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
$result = pwg_query($query);
$element_ids = array();
while ($row = mysql_fetch_array($result))
{
array_push($element_ids, $row['id']);
}
delete_elements($element_ids);
 
// destruction of the links between images and this category
$query = '
DELETE FROM '.IMAGE_CATEGORY_TABLE.'
WHERE category_id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
 
// destruction of the access linked to the category
$query = '
DELETE FROM '.USER_ACCESS_TABLE.'
WHERE cat_id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
$query = '
DELETE FROM '.GROUP_ACCESS_TABLE.'
WHERE cat_id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
 
// destruction of the category
$query = '
DELETE FROM '.CATEGORIES_TABLE.'
WHERE id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
 
if (isset($counts['del_categories']))
{
$counts['del_categories']+= count($ids);
}
}
 
// The function delete_elements deletes the elements identified by the
// (numeric) values of the array $ids. It also deletes (in the database) :
// - all the comments related to elements
// - all the links between categories and elements
// - all the favorites associated to elements
function delete_elements($ids)
{
global $counts;
 
if (count($ids) == 0)
{
return;
}
// destruction of the comments on the image
$query = '
DELETE FROM '.COMMENTS_TABLE.'
WHERE image_id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
 
// destruction of the links between images and this category
$query = '
DELETE FROM '.IMAGE_CATEGORY_TABLE.'
WHERE image_id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
 
// destruction of the favorites associated with the picture
$query = '
DELETE FROM '.FAVORITES_TABLE.'
WHERE image_id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
 
// destruction of the rates associated to this element
$query = '
DELETE FROM '.RATE_TABLE.'
WHERE element_id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
// destruction of the image
$query = '
DELETE FROM '.IMAGES_TABLE.'
WHERE id IN (
'.wordwrap(implode(', ', $ids), 80, "\n").')
;';
pwg_query($query);
 
if (isset($counts['del_elements']))
{
$counts['del_elements']+= count($ids);
}
}
 
// The delete_user function delete a user identified by the $user_id
// It also deletes :
// - all the access linked to this user
// - all the links to any group
// - all the favorites linked to this user
// - all sessions linked to this user
// - calculated permissions linked to the user
function delete_user($user_id)
{
// destruction of the access linked to the user
$query = '
DELETE FROM '.USER_ACCESS_TABLE.'
WHERE user_id = '.$user_id.'
;';
pwg_query($query);
 
// destruction of the group links for this user
$query = '
DELETE FROM '.USER_GROUP_TABLE.'
WHERE user_id = '.$user_id.'
;';
pwg_query($query);
 
// destruction of the favorites associated with the user
$query = '
DELETE FROM '.FAVORITES_TABLE.'
WHERE user_id = '.$user_id.'
;';
pwg_query($query);
 
// destruction of the sessions linked with the user
$query = '
DELETE FROM '.SESSIONS_TABLE.'
WHERE user_id = '.$user_id.'
;';
pwg_query($query);
 
// deletion of calculated permissions linked to the user
$query = '
DELETE FROM '.USER_FORBIDDEN_TABLE.'
WHERE user_id = '.$user_id.'
;';
pwg_query($query);
 
// destruction of the user
$query = '
DELETE FROM '.USERS_TABLE.'
WHERE id = '.$user_id.'
;';
pwg_query($query);
}
 
/**
* updates calculated informations about a set of categories : date_last and
* nb_images. It also verifies that the representative picture is really
* linked to the category. Optionnaly recursive.
*
* @param mixed category id
* @param boolean recursive
* @returns void
*/
function update_category($ids = 'all', $recursive = false)
{
// retrieving all categories to update
$cat_ids = array();
$query = '
SELECT id
FROM '.CATEGORIES_TABLE;
if (is_array($ids))
{
if ($recursive)
{
foreach ($ids as $num => $id)
{
if ($num == 0)
{
$query.= '
WHERE ';
}
else
{
$query.= '
OR ';
}
$query.= 'uppercats REGEXP \'(^|,)'.$id.'(,|$)\'';
}
}
else
{
$query.= '
WHERE id IN ('.wordwrap(implode(', ', $ids), 80, "\n").')';
}
}
$query.= '
;';
$result = pwg_query( $query );
while ( $row = mysql_fetch_array( $result ) )
{
array_push($cat_ids, $row['id']);
}
$cat_ids = array_unique($cat_ids);
 
if (count($cat_ids) == 0)
{
return false;
}
// calculate informations about categories retrieved
$query = '
SELECT category_id,
COUNT(image_id) AS nb_images,
MAX(date_available) AS date_last
FROM '.IMAGES_TABLE.' INNER JOIN '.IMAGE_CATEGORY_TABLE.' ON id = image_id
WHERE category_id IN ('.wordwrap(implode(', ', $cat_ids), 80, "\n").')
GROUP BY category_id
;';
$result = pwg_query($query);
$datas = array();
$query_ids = array();
while ( $row = mysql_fetch_array( $result ) )
{
array_push($query_ids, $row['category_id']);
array_push($datas, array('id' => $row['category_id'],
'date_last' => $row['date_last'],
'nb_images' => $row['nb_images']));
}
// if all links between a category and elements have disappeared, no line
// is returned but the update must be done !
foreach (array_diff($cat_ids, $query_ids) as $id)
{
array_push($datas, array('id' => $id, 'nb_images' => 0));
}
$fields = array('primary' => array('id'),
'update' => array('date_last', 'nb_images'));
mass_updates(CATEGORIES_TABLE, $fields, $datas);
 
$query = '
UPDATE '.CATEGORIES_TABLE.'
SET representative_picture_id = NULL
WHERE nb_images = 0
;';
pwg_query($query);
if (count($cat_ids) > 0)
{
$categories = array();
// find all categories where the setted representative is not possible
$query = '
SELECT id
FROM '.CATEGORIES_TABLE.' LEFT JOIN '.IMAGE_CATEGORY_TABLE.'
ON id = category_id AND representative_picture_id = image_id
WHERE representative_picture_id IS NOT NULL
AND id IN ('.wordwrap(implode(', ', $cat_ids), 80, "\n").')
AND category_id IS NULL
;';
$result = pwg_query($query);
while ($row = mysql_fetch_array($result))
{
array_push($categories, $row['id']);
}
// find categories with elements and with no representant
$query = '
SELECT id
FROM '.CATEGORIES_TABLE.'
WHERE representative_picture_id IS NULL
AND nb_images != 0
;';
$result = pwg_query($query);
while ($row = mysql_fetch_array($result))
{
array_push($categories, $row['id']);
}
 
$categories = array_unique($categories);
set_random_representant($categories);
}
}
 
function check_date_format( $date )
{
// date arrives at this format : DD/MM/YYYY
@list($day,$month,$year) = explode( '/', $date );
return @checkdate( $month, $day, $year );
}
 
function date_convert( $date )
{
// date arrives at this format : DD/MM/YYYY
// It must be transformed in YYYY-MM-DD
list($day,$month,$year) = explode( '/', $date );
return $year.'-'.$month.'-'.$day;
}
 
function date_convert_back( $date )
{
// date arrives at this format : YYYY-MM-DD
// It must be transformed in DD/MM/YYYY
if ( $date != '' )
{
list($year,$month,$day) = explode( '-', $date );
return $day.'/'.$month.'/'.$year;
}
else
{
return '';
}
}
 
// get_keywords returns an array with relevant keywords found in the string
// given in argument. Keywords must be separated by comma in this string.
// keywords must :
// - be longer or equal to 3 characters
// - not contain ', " or blank characters
// - unique in the string ("test,test" -> "test")
function get_keywords( $keywords_string )
{
$keywords = array();
 
$candidates = explode( ',', $keywords_string );
foreach ( $candidates as $candidate ) {
if ( strlen($candidate) >= 3 and !preg_match( '/(\'|"|\s)/', $candidate ) )
array_push( $keywords, $candidate );
}
 
return array_unique( $keywords );
}
 
/**
* returns an array with the ids of the restricted categories for the user
*
* Returns an array with the ids of the restricted categories for the
* user. If the $check_invisible parameter is set to true, invisible
* categorie are added to the restricted one in the array.
*
* @param int $user_id
* @param string $user_status
* @param bool $check_invisible
* @param bool $use_groups
* @return array
*/
function get_user_restrictions( $user_id, $user_status,
$check_invisible, $use_groups = true )
{
// 1. retrieving ids of private categories
$query = 'SELECT id FROM '.CATEGORIES_TABLE;
$query.= " WHERE status = 'private'";
$query.= ';';
$result = pwg_query( $query );
$privates = array();
while ( $row = mysql_fetch_array( $result ) )
{
array_push( $privates, $row['id'] );
}
// 2. retrieving all authorized categories for the user
$authorized = array();
// 2.1. retrieving authorized categories thanks to personnal user
// authorization
$query = 'SELECT cat_id FROM '.USER_ACCESS_TABLE;
$query.= ' WHERE user_id = '.$user_id;
$query.= ';';
$result = pwg_query( $query );
while ( $row = mysql_fetch_array( $result ) )
{
array_push( $authorized, $row['cat_id'] );
}
// 2.2. retrieving authorized categories thanks to group authorization to
// which the user is a member
if ( $use_groups )
{
$query = 'SELECT ga.cat_id';
$query.= ' FROM '.USER_GROUP_TABLE.' as ug';
$query.= ', '.GROUP_ACCESS_TABLE.' as ga';
$query.= ' WHERE ug.group_id = ga.group_id';
$query.= ' AND ug.user_id = '.$user_id;
$query.= ';';
$result = pwg_query( $query );
while ( $row = mysql_fetch_array( $result ) )
{
array_push( $authorized, $row['cat_id'] );
}
$authorized = array_unique( $authorized );
}
 
$forbidden = array();
foreach ( $privates as $private ) {
if ( !in_array( $private, $authorized ) )
{
array_push( $forbidden, $private );
}
}
 
if ( $check_invisible )
{
// 3. adding to the restricted categories, the invisible ones
if ( $user_status != 'admin' )
{
$query = 'SELECT id FROM '.CATEGORIES_TABLE;
$query.= " WHERE visible = 'false';";
$result = pwg_query( $query );
while ( $row = mysql_fetch_array( $result ) )
{
array_push( $forbidden, $row['id'] );
}
}
}
return array_unique( $forbidden );
}
 
/**
* updates the calculated data users.forbidden_categories, it includes
* sub-categories of the direct forbidden categories
*
* @param nt $user_id
* @return array
*/
function update_user_restrictions( $user_id )
{
$restrictions = get_user_all_restrictions( $user_id );
 
// update the users.forbidden_categories in database
$query = 'UPDATE '.USERS_TABLE;
$query.= ' SET forbidden_categories = ';
if ( count( $restrictions ) > 0 )
$query.= "'".implode( ',', $restrictions )."'";
else
$query.= 'NULL';
$query .= ' WHERE id = '.$user_id;
$query.= ';';
pwg_query( $query );
 
return $restrictions;
}
 
/**
* returns all the restricted categories ids including sub-categories
*
* @param int $user_id
* @return array
*/
function get_user_all_restrictions( $user_id )
{
global $page;
$query = 'SELECT status';
$query.= ' FROM '.USERS_TABLE;
$query.= ' WHERE id = '.$user_id;
$query.= ';';
$row = mysql_fetch_array( pwg_query( $query ) );
$base_restrictions=get_user_restrictions($user_id,$row['status'],true,true);
 
$restrictions = $base_restrictions;
foreach ( $base_restrictions as $category_id ) {
echo $category_id.' is forbidden to user '.$user_id.'<br />';
$restrictions =
array_merge( $restrictions,
$page['plain_structure'][$category_id]['all_subcats_ids'] );
}
 
return array_unique( $restrictions );
}
 
// The function is_user_allowed returns :
// - 0 : if the category is allowed with this $restrictions array
// - 1 : if this category is not allowed
// - 2 : if an uppercat category is not allowed
// Note : the restrictions array must represent ONLY direct forbidden
// categories, not all forbidden categories
function is_user_allowed( $category_id, $restrictions )
{
if ( in_array( $category_id, $restrictions ) ) return 1;
 
$query = 'SELECT uppercats';
$query.= ' FROM '.CATEGORIES_TABLE;
$query.= ' WHERE id = '.$category_id;
$query.= ';';
$row = mysql_fetch_array( pwg_query( $query ) );
$uppercats = explode( ',', $row['uppercats'] );
foreach ( $uppercats as $category_id ) {
if ( in_array( $category_id, $restrictions ) ) return 2;
}
 
// no restriction found : the user is allowed to access this category
return 0;
}
 
/**
* returns an array containing sub-directories which can be a category
*
* directories nammed "thumbnail", "pwg_high" or "pwg_representative" are
* omitted
*
* @param string $basedir
* @return array
*/
function get_category_directories( $basedir )
{
$sub_dirs = array();
if ( $opendir = opendir( $basedir ) )
{
while ( $file = readdir( $opendir ) )
{
if ($file != '.'
and $file != '..'
and $file != 'thumbnail'
and $file != 'pwg_high'
and $file != 'pwg_representative'
and is_dir($basedir.'/'.$file))
{
array_push( $sub_dirs, $file );
}
}
}
return $sub_dirs;
}
 
/**
* returns an array containing sub-directories which can be a category,
* recursive by default
*
* directories nammed "thumbnail", "pwg_high" or "pwg_representative" are
* omitted
*
* @param string $basedir
* @return array
*/
function get_fs_directories($path, $recursive = true)
{
$dirs = array();
if (is_dir($path))
{
if ($contents = opendir($path))
{
while (($node = readdir($contents)) !== false)
{
if (is_dir($path.'/'.$node)
and $node != '.'
and $node != '..'
and $node != 'thumbnail'
and $node != 'pwg_high'
and $node != 'pwg_representative')
{
array_push($dirs, $path.'/'.$node);
if ($recursive)
{
$dirs = array_merge($dirs, get_fs_directories($path.'/'.$node));
}
}
}
}
}
 
return $dirs;
}
 
/**
* inserts multiple lines in a table
*
* @param string table_name
* @param array dbfields
* @param array inserts
* @return void
*/
function mass_inserts($table_name, $dbfields, $datas)
{
// inserts all found categories
$query = '
INSERT INTO '.$table_name.'
('.implode(',', $dbfields).')
VALUES';
foreach ($datas as $insert_id => $insert)
{
$query.= '
';
if ($insert_id > 0)
{
$query.= ',';
}
$query.= '(';
foreach ($dbfields as $field_id => $dbfield)
{
if ($field_id > 0)
{
$query.= ',';
}
if (!isset($insert[$dbfield]) or $insert[$dbfield] == '')
{
$query.= 'NULL';
}
else
{
$query.= "'".$insert[$dbfield]."'";
}
}
$query.=')';
}
$query.= '
;';
pwg_query($query);
}
 
/**
* updates multiple lines in a table
*
* @param string table_name
* @param array dbfields
* @param array datas
* @return void
*/
function mass_updates($tablename, $dbfields, $datas)
{
// depending on the MySQL version, we use the multi table update or N
// update queries
$query = 'SELECT VERSION() AS version;';
$row = mysql_fetch_array(pwg_query($query));
if (count($datas) < 10 or version_compare($row['version'],'4.0.4') < 0)
{
// MySQL is prior to version 4.0.4, multi table update feature is not
// available
foreach ($datas as $data)
{
$query = '
UPDATE '.$tablename.'
SET ';
foreach ($dbfields['update'] as $num => $key)
{
if ($num >= 1)
{
$query.= ",\n ";
}
$query.= $key.' = ';
if (isset($data[$key]))
{
$query.= '\''.$data[$key].'\'';
}
else
{
$query.= 'NULL';
}
}
$query.= '
WHERE ';
foreach ($dbfields['primary'] as $num => $key)
{
if ($num > 1)
{
$query.= ' AND ';
}
$query.= $key.' = \''.$data[$key].'\'';
}
$query.= '
;';
pwg_query($query);
}
}
else
{
// creation of the temporary table
$query = '
DESCRIBE '.$tablename.'
;';
$result = pwg_query($query);
$columns = array();
$all_fields = array_merge($dbfields['primary'], $dbfields['update']);
while ($row = mysql_fetch_array($result))
{
if (in_array($row['Field'], $all_fields))
{
$column = $row['Field'];
$column.= ' '.$row['Type'];
if (!isset($row['Null']) or $row['Null'] == '')
{
$column.= ' NOT NULL';
}
if (isset($row['Default']))
{
$column.= " default '".$row['Default']."'";
}
array_push($columns, $column);
}
}
$temporary_tablename = $tablename.'_'.micro_seconds();
$query = '
CREATE TABLE '.$temporary_tablename.'
(
'.implode(",\n", $columns).',
PRIMARY KEY (id)
)
;';
pwg_query($query);
mass_inserts($temporary_tablename, $all_fields, $datas);
// update of images table by joining with temporary table
$query = '
UPDATE '.$tablename.' AS t1, '.$temporary_tablename.' AS t2
SET '.implode("\n , ",
array_map(
create_function('$s', 'return "t1.$s = t2.$s";')
, $dbfields['update'])).'
WHERE '.implode("\n AND ",
array_map(
create_function('$s', 'return "t1.$s = t2.$s";')
, $dbfields['primary'])).'
;';
pwg_query($query);
$query = '
DROP TABLE '.$temporary_tablename.'
;';
pwg_query($query);
}
}
 
/**
* updates the global_rank of categories under the given id_uppercat
*
* @param int id_uppercat
* @return void
*/
function update_global_rank($id_uppercat = 'all')
{
$query = '
SELECT id,rank
FROM '.CATEGORIES_TABLE.'
;';
$result = pwg_query($query);
$ranks_array = array();
while ($row = mysql_fetch_array($result))
{
$ranks_array[$row['id']] = $row['rank'];
}
 
// which categories to update ?
$uppercats_array = array();
 
$query = '
SELECT id,uppercats
FROM '.CATEGORIES_TABLE;
if (is_numeric($id_uppercat))
{
$query.= '
WHERE uppercats REGEXP \'(^|,)'.$id_uppercat.'(,|$)\'
AND id != '.$id_uppercat.'
';
}
$query.= '
;';
$result = pwg_query($query);
while ($row = mysql_fetch_array($result))
{
$uppercats_array[$row['id']] = $row['uppercats'];
}
$datas = array();
foreach ($uppercats_array as $id => $uppercats)
{
$data = array();
$data['id'] = $id;
$global_rank = preg_replace('/(\d+)/e',
"\$ranks_array['$1']",
str_replace(',', '.', $uppercats));
$data['global_rank'] = $global_rank;
array_push($datas, $data);
}
 
$fields = array('primary' => array('id'), 'update' => array('global_rank'));
mass_updates(CATEGORIES_TABLE, $fields, $datas);
}
 
/**
* change the visible property on a set of categories
*
* @param array categories
* @param string value
* @return void
*/
function set_cat_visible($categories, $value)
{
if (!in_array($value, array('true', 'false')))
{
return false;
}
 
// unlocking a category => all its parent categories become unlocked
if ($value == 'true')
{
$uppercats = get_uppercat_ids($categories);
$query = '
UPDATE '.CATEGORIES_TABLE.'
SET visible = \'true\'
WHERE id IN ('.implode(',', $uppercats).')
;';
pwg_query($query);
}
// locking a category => all its child categories become locked
if ($value == 'false')
{
$subcats = get_subcat_ids($categories);
$query = '
UPDATE '.CATEGORIES_TABLE.'
SET visible = \'false\'
WHERE id IN ('.implode(',', $subcats).')
;';
pwg_query($query);
}
}
 
/**
* change the status property on a set of categories : private or public
*
* @param array categories
* @param string value
* @return void
*/
function set_cat_status($categories, $value)
{
if (!in_array($value, array('public', 'private')))
{
return false;
}
 
// make public a category => all its parent categories become public
if ($value == 'public')
{
$uppercats = get_uppercat_ids($categories);
$query = '
UPDATE '.CATEGORIES_TABLE.'
SET status = \'public\'
WHERE id IN ('.implode(',', $uppercats).')
;';
pwg_query($query);
}
// make a category private => all its child categories become private
if ($value == 'private')
{
$subcats = get_subcat_ids($categories);
$query = '
UPDATE '.CATEGORIES_TABLE.'
SET status = \'private\'
WHERE id IN ('.implode(',', $subcats).')
;';
pwg_query($query);
}
}
 
/**
* returns all uppercats category ids of the given category ids
*
* @param array cat_ids
* @return array
*/
function get_uppercat_ids($cat_ids)
{
if (!is_array($cat_ids) or count($cat_ids) < 1)
{
return array();
}
$uppercats = array();
 
$query = '
SELECT uppercats
FROM '.CATEGORIES_TABLE.'
WHERE id IN ('.implode(',', $cat_ids).')
;';
$result = pwg_query($query);
while ($row = mysql_fetch_array($result))
{
$uppercats = array_merge($uppercats,
explode(',', $row['uppercats']));
}
$uppercats = array_unique($uppercats);
 
return $uppercats;
}
 
/**
* set a new random representant to the categories
*
* @param array categories
*/
function set_random_representant($categories)
{
$datas = array();
foreach ($categories as $category_id)
{
$query = '
SELECT image_id
FROM '.IMAGE_CATEGORY_TABLE.'
WHERE category_id = '.$category_id.'
ORDER BY RAND()
LIMIT 0,1
;';
list($representative) = mysql_fetch_array(pwg_query($query));
$data = array('id' => $category_id,
'representative_picture_id' => $representative);
array_push($datas, $data);
}
 
$fields = array('primary' => array('id'),
'update' => array('representative_picture_id'));
mass_updates(CATEGORIES_TABLE, $fields, $datas);
}
 
/**
* order categories (update categories.rank and global_rank database fields)
*
* the purpose of this function is to give a rank for all categories
* (insides its sub-category), even the newer that have none at te
* beginning. For this, ordering function selects all categories ordered by
* rank ASC then name ASC for each uppercat.
*
* @returns void
*/
function ordering()
{
$current_rank = 0;
$current_uppercat = '';
$query = '
SELECT id, if(id_uppercat is null,\'\',id_uppercat) AS id_uppercat
FROM '.CATEGORIES_TABLE.'
ORDER BY id_uppercat,rank,name
;';
$result = pwg_query($query);
$datas = array();
while ($row = mysql_fetch_array($result))
{
if ($row['id_uppercat'] != $current_uppercat)
{
$current_rank = 0;
$current_uppercat = $row['id_uppercat'];
}
$data = array('id' => $row['id'], 'rank' => ++$current_rank);
array_push($datas, $data);
}
 
$fields = array('primary' => array('id'), 'update' => array('rank'));
mass_updates(CATEGORIES_TABLE, $fields, $datas);
}
 
/**
* returns the fulldir for each given category id
*
* @param array cat_ids
* @return array
*/
function get_fulldirs($cat_ids)
{
if (count($cat_ids) == 0)
{
return array();
}
// caching directories of existing categories
$query = '
SELECT id, dir
FROM '.CATEGORIES_TABLE.'
WHERE dir IS NOT NULL
;';
$result = pwg_query($query);
$cat_dirs = array();
while ($row = mysql_fetch_array($result))
{
$cat_dirs[$row['id']] = $row['dir'];
}
 
// caching galleries_url
$query = '
SELECT id, galleries_url
FROM '.SITES_TABLE.'
;';
$result = pwg_query($query);
$galleries_url = array();
while ($row = mysql_fetch_array($result))
{
$galleries_url[$row['id']] = $row['galleries_url'];
}
 
// categories : id, site_id, uppercats
$categories = array();
$query = '
SELECT id, uppercats, site_id
FROM '.CATEGORIES_TABLE.'
WHERE id IN (
'.wordwrap(implode(', ', $cat_ids), 80, "\n").')
;';
$result = pwg_query($query);
while ($row = mysql_fetch_array($result))
{
array_push($categories, $row);
}
// filling $cat_fulldirs
$cat_fulldirs = array();
foreach ($categories as $category)
{
$uppercats = str_replace(',', '/', $category['uppercats']);
$cat_fulldirs[$category['id']] = $galleries_url[$category['site_id']];
$cat_fulldirs[$category['id']].= preg_replace('/(\d+)/e',
"\$cat_dirs['$1']",
$uppercats);
}
 
return $cat_fulldirs;
}
 
/**
* returns an array with all file system files according to
* $conf['file_ext']
*
* @param string $path
* @param bool recursive
* @return array
*/
function get_fs($path, $recursive = true)
{
global $conf;
 
// because isset is faster than in_array...
if (!isset($conf['flip_picture_ext']))
{
$conf['flip_picture_ext'] = array_flip($conf['picture_ext']);
}
if (!isset($conf['flip_file_ext']))
{
$conf['flip_file_ext'] = array_flip($conf['file_ext']);
}
 
$fs['elements'] = array();
$fs['thumbnails'] = array();
$fs['representatives'] = array();
$subdirs = array();
 
if (is_dir($path))
{
if ($contents = opendir($path))
{
while (($node = readdir($contents)) !== false)
{
if (is_file($path.'/'.$node))
{
$extension = get_extension($node);
// if (in_array($extension, $conf['picture_ext']))
if (isset($conf['flip_picture_ext'][$extension]))
{
if (basename($path) == 'thumbnail')
{
array_push($fs['thumbnails'], $path.'/'.$node);
}
else if (basename($path) == 'pwg_representative')
{
array_push($fs['representatives'], $path.'/'.$node);
}
else
{
array_push($fs['elements'], $path.'/'.$node);
}
}
// else if (in_array($extension, $conf['file_ext']))
else if (isset($conf['flip_file_ext'][$extension]))
{
array_push($fs['elements'], $path.'/'.$node);
}
}
else if (is_dir($path.'/'.$node)
and $node != '.'
and $node != '..'
and $node != 'pwg_high'
and $recursive)
{
array_push($subdirs, $node);
}
}
}
closedir($contents);
 
foreach ($subdirs as $subdir)
{
$tmp_fs = get_fs($path.'/'.$subdir);
 
$fs['elements'] = array_merge($fs['elements'],
$tmp_fs['elements']);
$fs['thumbnails'] = array_merge($fs['thumbnails'],
$tmp_fs['thumbnails']);
$fs['representatives'] = array_merge($fs['representatives'],
$tmp_fs['representatives']);
}
}
return $fs;
}
 
/**
* stupidly returns the current microsecond since Unix epoch
*/
function micro_seconds()
{
$t1 = explode(' ', microtime());
$t2 = explode('.', $t1[0]);
$t2 = $t1[1].substr($t2[1], 0, 6);
return $t2;
}
?>