2003-12-30 00:36:47 -05:00
< ? php
2004-10-08 15:49:58 -04:00
2005-01-30 02:34:03 -05:00
require_once ( ABSPATH . '/wp-admin/admin-functions.php' );
require_once ( ABSPATH . '/wp-admin/upgrade-schema.php' );
2003-12-30 00:36:47 -05:00
// Functions to be called in install and upgrade scripts
2004-01-12 07:12:45 -05:00
function upgrade_all () {
2005-10-27 18:04:12 -04:00
global $wp_current_db_version , $wp_db_version ;
$wp_current_db_version = __get_option ( 'db_version' );
// We are up-to-date. Nothing to do.
if ( $wp_db_version == $wp_current_db_version )
return ;
// If the version is not set in the DB, try to guess the version.
if ( empty ( $wp_current_db_version ) ) {
$wp_current_db_version = 0 ;
// If the template option exists, we have 1.5.
$template = __get_option ( 'template' );
if ( ! empty ( $template ) )
$wp_current_db_version = 2541 ;
}
2004-09-04 20:24:28 -04:00
populate_options ();
2005-10-27 18:04:12 -04:00
if ( $wp_current_db_version < 2541 ) {
upgrade_100 ();
upgrade_101 ();
upgrade_110 ();
upgrade_130 ();
}
2005-11-16 01:29:36 -05:00
if ( $wp_current_db_version < 3104 )
2005-10-27 18:04:12 -04:00
upgrade_160 ();
2005-01-30 02:34:03 -05:00
save_mod_rewrite_rules ();
2005-10-27 18:04:12 -04:00
update_option ( 'db_version' , $wp_db_version );
2004-06-13 13:02:44 -04:00
}
2003-12-30 00:36:47 -05:00
function upgrade_100 () {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2003-12-30 00:36:47 -05:00
// Get the title and ID of every post, post_name to check if it already has a value
2004-05-24 04:22:18 -04:00
$posts = $wpdb -> get_results ( " SELECT ID, post_title, post_name FROM $wpdb->posts WHERE post_name = '' " );
2004-05-05 04:00:13 -04:00
if ( $posts ) {
foreach ( $posts as $post ) {
if ( '' == $post -> post_name ) {
$newtitle = sanitize_title ( $post -> post_title );
2004-05-24 04:22:18 -04:00
$wpdb -> query ( " UPDATE $wpdb->posts SET post_name = ' $newtitle ' WHERE ID = ' $post->ID ' " );
2004-05-05 04:00:13 -04:00
}
2003-12-30 00:36:47 -05:00
}
}
2004-05-24 04:22:18 -04:00
$categories = $wpdb -> get_results ( " SELECT cat_ID, cat_name, category_nicename FROM $wpdb->categories " );
2003-12-30 00:36:47 -05:00
foreach ( $categories as $category ) {
if ( '' == $category -> category_nicename ) {
$newtitle = sanitize_title ( $category -> cat_name );
2004-05-24 04:22:18 -04:00
$wpdb -> query ( " UPDATE $wpdb->categories SET category_nicename = ' $newtitle ' WHERE cat_ID = ' $category->cat_ID ' " );
2003-12-30 00:36:47 -05:00
}
}
2004-09-04 20:24:28 -04:00
2004-05-24 04:22:18 -04:00
$wpdb -> query ( " UPDATE $wpdb->options SET option_value = REPLACE(option_value, 'wp-links/links-images/', 'wp-images/links/')
2004-10-05 03:36:50 -04:00
WHERE option_name LIKE 'links_rating_image%'
AND option_value LIKE 'wp-links/links-images/%' " );
2004-09-04 20:24:28 -04:00
2004-05-24 04:22:18 -04:00
$done_ids = $wpdb -> get_results ( " SELECT DISTINCT post_id FROM $wpdb->post2cat " );
2004-05-05 04:00:13 -04:00
if ( $done_ids ) :
foreach ( $done_ids as $done_id ) :
$done_posts [] = $done_id -> post_id ;
endforeach ;
$catwhere = ' AND ID NOT IN (' . implode ( ',' , $done_posts ) . ')' ;
else :
$catwhere = '' ;
endif ;
2004-05-24 04:22:18 -04:00
$allposts = $wpdb -> get_results ( " SELECT ID, post_category FROM $wpdb->posts WHERE post_category != '0' $catwhere " );
2004-05-05 04:00:13 -04:00
if ( $allposts ) :
foreach ( $allposts as $post ) {
// Check to see if it's already been imported
2004-05-24 04:22:18 -04:00
$cat = $wpdb -> get_row ( " SELECT * FROM $wpdb->post2cat WHERE post_id = $post->ID AND category_id = $post->post_category " );
2004-05-05 04:00:13 -04:00
if ( ! $cat && 0 != $post -> post_category ) { // If there's no result
$wpdb -> query ( "
2004-05-24 04:22:18 -04:00
INSERT INTO $wpdb -> post2cat
2004-05-05 04:00:13 -04:00
( post_id , category_id )
VALUES
( '$post->ID' , '$post->post_category' )
" );
}
2003-12-30 00:36:47 -05:00
}
2004-05-05 04:00:13 -04:00
endif ;
2003-12-30 00:36:47 -05:00
}
2004-01-03 20:58:31 -05:00
function upgrade_101 () {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2004-09-04 17:52:00 -04:00
2004-01-12 05:46:01 -05:00
// Clean up indices, add a few
2004-05-24 04:22:18 -04:00
add_clean_index ( $wpdb -> posts , 'post_name' );
add_clean_index ( $wpdb -> posts , 'post_status' );
add_clean_index ( $wpdb -> categories , 'category_nicename' );
add_clean_index ( $wpdb -> comments , 'comment_approved' );
add_clean_index ( $wpdb -> comments , 'comment_post_ID' );
add_clean_index ( $wpdb -> links , 'link_category' );
add_clean_index ( $wpdb -> links , 'link_visible' );
2004-01-03 20:58:31 -05:00
}
2004-02-27 00:48:00 -05:00
2004-02-01 07:14:28 -05:00
function upgrade_110 () {
2005-10-27 18:04:12 -04:00
global $wpdb ;
2004-02-01 07:14:28 -05:00
2004-02-10 23:51:19 -05:00
// Set user_nicename.
2005-10-27 18:04:12 -04:00
$users = $wpdb -> get_results ( " SELECT ID, user_nickname, user_nicename FROM $wpdb->users " );
foreach ( $users as $user ) {
if ( '' == $user -> user_nicename ) {
$newname = sanitize_title ( $user -> user_nickname );
$wpdb -> query ( " UPDATE $wpdb->users SET user_nicename = ' $newname ' WHERE ID = ' $user->ID ' " );
}
}
2004-02-10 23:51:19 -05:00
2004-09-08 06:31:19 -04:00
$users = $wpdb -> get_results ( " SELECT ID, user_pass from $wpdb->users " );
foreach ( $users as $row ) {
2004-02-09 04:56:57 -05:00
if ( ! preg_match ( '/^[A-Fa-f0-9]{32}$/' , $row -> user_pass )) {
2004-05-24 04:22:18 -04:00
$wpdb -> query ( 'UPDATE ' . $wpdb -> users . ' SET user_pass = MD5(\'' . $row -> user_pass . '\') WHERE ID = \'' . $row -> ID . '\'' );
2004-02-09 04:56:57 -05:00
}
}
2004-04-15 03:53:45 -04:00
2004-02-16 21:11:16 -05:00
2004-03-24 17:53:30 -05:00
// Get the GMT offset, we'll use that later on
2004-06-13 13:02:44 -04:00
$all_options = get_alloptions_110 ();
2004-03-24 17:53:30 -05:00
$time_difference = $all_options -> time_difference ;
$server_time = time () + date ( 'Z' );
$weblogger_time = $server_time + $time_difference * 3600 ;
$gmt_time = time ();
2004-02-22 20:52:38 -05:00
2004-03-24 17:53:30 -05:00
$diff_gmt_server = ( $gmt_time - $server_time ) / 3600 ;
$diff_weblogger_server = ( $weblogger_time - $server_time ) / 3600 ;
$diff_gmt_weblogger = $diff_gmt_server - $diff_weblogger_server ;
$gmt_offset = - $diff_gmt_weblogger ;
// Add a gmt_offset option, with value $gmt_offset
2004-09-04 20:24:28 -04:00
add_option ( 'gmt_offset' , $gmt_offset );
2004-03-24 17:53:30 -05:00
2004-05-09 17:30:57 -04:00
// Check if we already set the GMT fields (if we did, then
// MAX(post_date_gmt) can't be '0000-00-00 00:00:00'
// <michel_v> I just slapped myself silly for not thinking about it earlier
2004-05-24 04:22:18 -04:00
$got_gmt_fields = ( $wpdb -> get_var ( " SELECT MAX(post_date_gmt) FROM $wpdb->posts " ) == '0000-00-00 00:00:00' ) ? false : true ;
2004-05-09 17:30:57 -04:00
2004-03-24 17:53:30 -05:00
if ( ! $got_gmt_fields ) {
// Add or substract time to all dates, to get GMT dates
$add_hours = intval ( $diff_gmt_weblogger );
$add_minutes = intval ( 60 * ( $diff_gmt_weblogger - $add_hours ));
2004-05-24 04:22:18 -04:00
$wpdb -> query ( " UPDATE $wpdb->posts SET post_date_gmt = DATE_ADD(post_date, INTERVAL ' $add_hours : $add_minutes ' HOUR_MINUTE) " );
$wpdb -> query ( " UPDATE $wpdb->posts SET post_modified = post_date " );
$wpdb -> query ( " UPDATE $wpdb->posts SET post_modified_gmt = DATE_ADD(post_modified, INTERVAL ' $add_hours : $add_minutes ' HOUR_MINUTE) WHERE post_modified != '0000-00-00 00:00:00' " );
$wpdb -> query ( " UPDATE $wpdb->comments SET comment_date_gmt = DATE_ADD(comment_date, INTERVAL ' $add_hours : $add_minutes ' HOUR_MINUTE) " );
2005-03-16 17:53:33 -05:00
$wpdb -> query ( " UPDATE $wpdb->users SET user_registered = DATE_ADD(user_registered, INTERVAL ' $add_hours : $add_minutes ' HOUR_MINUTE) " );
2004-03-24 17:53:30 -05:00
}
2004-04-27 10:43:10 -04:00
}
2004-05-31 11:43:45 -04:00
function upgrade_130 () {
2004-09-04 18:22:35 -04:00
global $wpdb , $table_prefix ;
2004-05-31 11:43:45 -04:00
2004-06-17 20:22:09 -04:00
// Remove extraneous backslashes.
2004-09-04 22:41:01 -04:00
$posts = $wpdb -> get_results ( " SELECT ID, post_title, post_content, post_excerpt, guid, post_date, post_name, post_status, post_author FROM $wpdb->posts " );
2004-06-17 20:22:09 -04:00
if ( $posts ) {
foreach ( $posts as $post ) {
$post_content = addslashes ( deslash ( $post -> post_content ));
$post_title = addslashes ( deslash ( $post -> post_title ));
$post_excerpt = addslashes ( deslash ( $post -> post_excerpt ));
2004-09-04 22:41:01 -04:00
if ( empty ( $post -> guid ) )
2004-10-05 03:36:50 -04:00
$guid = get_permalink ( $post -> ID );
2004-09-04 22:41:01 -04:00
else
$guid = $post -> guid ;
$wpdb -> query ( " UPDATE $wpdb->posts SET post_title = ' $post_title ', post_content = ' $post_content ', post_excerpt = ' $post_excerpt ', guid = ' $guid ' WHERE ID = ' $post->ID ' " );
2004-06-17 20:22:09 -04:00
}
}
// Remove extraneous backslashes.
$comments = $wpdb -> get_results ( " SELECT comment_ID, comment_author, comment_content FROM $wpdb->comments " );
if ( $comments ) {
foreach ( $comments as $comment ) {
$comment_content = addslashes ( deslash ( $comment -> comment_content ));
$comment_author = addslashes ( deslash ( $comment -> comment_author ));
$wpdb -> query ( " UPDATE $wpdb->comments SET comment_content = ' $comment_content ', comment_author = ' $comment_author ' WHERE comment_ID = ' $comment->comment_ID ' " );
}
}
2004-07-15 19:31:06 -04:00
// Remove extraneous backslashes.
$links = $wpdb -> get_results ( " SELECT link_id, link_name, link_description FROM $wpdb->links " );
if ( $links ) {
foreach ( $links as $link ) {
$link_name = addslashes ( deslash ( $link -> link_name ));
$link_description = addslashes ( deslash ( $link -> link_description ));
$wpdb -> query ( " UPDATE $wpdb->links SET link_name = ' $link_name ', link_description = ' $link_description ' WHERE link_id = ' $link->link_id ' " );
}
}
2004-07-28 23:34:08 -04:00
// The "paged" option for what_to_show is no more.
if ( $wpdb -> get_var ( " SELECT option_value FROM $wpdb->options WHERE option_name = 'what_to_show' " ) == 'paged' ) {
$wpdb -> query ( " UPDATE $wpdb->options SET option_value = 'posts' WHERE option_name = 'what_to_show' " );
}
2004-08-09 03:17:54 -04:00
2005-03-29 00:34:30 -05:00
$active_plugins = __get_option ( 'active_plugins' );
// If plugins are not stored in an array, they're stored in the old
// newline separated format. Convert to new format.
if ( ! is_array ( $active_plugins ) ) {
$active_plugins = explode ( " \n " , trim ( $active_plugins ));
update_option ( 'active_plugins' , $active_plugins );
}
2004-08-30 03:16:40 -04:00
2004-09-04 18:04:19 -04:00
// Obsolete tables
2004-09-04 17:52:00 -04:00
$wpdb -> query ( 'DROP TABLE IF EXISTS ' . $table_prefix . 'optionvalues' );
2004-09-04 18:04:19 -04:00
$wpdb -> query ( 'DROP TABLE IF EXISTS ' . $table_prefix . 'optiontypes' );
2004-09-04 18:09:21 -04:00
$wpdb -> query ( 'DROP TABLE IF EXISTS ' . $table_prefix . 'optiongroups' );
2004-09-04 18:15:46 -04:00
$wpdb -> query ( 'DROP TABLE IF EXISTS ' . $table_prefix . 'optiongroup_options' );
2004-09-27 09:52:46 -04:00
// Update comments table to use comment_type
$wpdb -> query ( " UPDATE $wpdb->comments SET comment_type='trackback', comment_content = REPLACE(comment_content, '<trackback />', '') WHERE comment_content LIKE '<trackback />%' " );
2004-10-05 03:36:50 -04:00
$wpdb -> query ( " UPDATE $wpdb->comments SET comment_type='pingback', comment_content = REPLACE(comment_content, '<pingback />', '') WHERE comment_content LIKE '<pingback />%' " );
2004-09-27 09:52:46 -04:00
2004-12-18 16:21:50 -05:00
// Some versions have multiple duplicate option_name rows with the same values
$options = $wpdb -> get_results ( " SELECT option_name, COUNT(option_name) AS dupes FROM ` $wpdb->options ` GROUP BY option_name " );
foreach ( $options as $option ) {
if ( 1 != $option -> dupes ) { // Could this be done in the query?
$limit = $option -> dupes - 1 ;
$dupe_ids = $wpdb -> get_col ( " SELECT option_id FROM $wpdb->options WHERE option_name = ' $option->option_name ' LIMIT $limit " );
$dupe_ids = join ( $dupe_ids , ',' );
$wpdb -> query ( " DELETE FROM $wpdb->options WHERE option_id IN ( $dupe_ids ) " );
}
}
2005-01-02 05:09:16 -05:00
make_site_theme ();
2004-08-30 03:16:40 -04:00
}
2005-06-12 16:49:13 -04:00
function upgrade_160 () {
2005-11-15 17:55:24 -05:00
global $wpdb , $table_prefix , $wp_current_db_version ;
2005-10-27 18:04:12 -04:00
populate_roles_160 ();
2005-06-12 16:49:13 -04:00
$users = $wpdb -> get_results ( " SELECT * FROM $wpdb->users " );
foreach ( $users as $user ) :
if ( ! empty ( $user -> user_firstname ) )
2005-07-05 16:47:22 -04:00
update_usermeta ( $user -> ID , 'first_name' , $wpdb -> escape ( $user -> user_firstname ) );
2005-06-12 16:49:13 -04:00
if ( ! empty ( $user -> user_lastname ) )
2005-07-05 16:47:22 -04:00
update_usermeta ( $user -> ID , 'last_name' , $wpdb -> escape ( $user -> user_lastname ) );
2005-06-12 16:49:13 -04:00
if ( ! empty ( $user -> user_nickname ) )
2005-07-05 16:47:22 -04:00
update_usermeta ( $user -> ID , 'nickname' , $wpdb -> escape ( $user -> user_nickname ) );
2005-07-19 10:24:06 -04:00
if ( ! empty ( $user -> user_level ) )
2005-06-12 16:49:13 -04:00
update_usermeta ( $user -> ID , $table_prefix . 'user_level' , $user -> user_level );
if ( ! empty ( $user -> user_icq ) )
2005-07-05 16:47:22 -04:00
update_usermeta ( $user -> ID , 'icq' , $wpdb -> escape ( $user -> user_icq ) );
2005-06-12 16:49:13 -04:00
if ( ! empty ( $user -> user_aim ) )
2005-07-05 16:47:22 -04:00
update_usermeta ( $user -> ID , 'aim' , $wpdb -> escape ( $user -> user_aim ) );
2005-06-12 16:49:13 -04:00
if ( ! empty ( $user -> user_msn ) )
2005-07-05 16:47:22 -04:00
update_usermeta ( $user -> ID , 'msn' , $wpdb -> escape ( $user -> user_msn ) );
2005-06-12 16:49:13 -04:00
if ( ! empty ( $user -> user_yim ) )
2005-07-05 16:47:22 -04:00
update_usermeta ( $user -> ID , 'yim' , $wpdb -> escape ( $user -> user_icq ) );
2005-06-12 16:49:13 -04:00
if ( ! empty ( $user -> user_description ) )
2005-07-05 16:47:22 -04:00
update_usermeta ( $user -> ID , 'description' , $wpdb -> escape ( $user -> user_description ) );
2005-06-16 02:14:07 -04:00
2005-07-14 18:53:56 -04:00
if ( isset ( $user -> user_idmode ) ) :
2005-06-16 02:14:07 -04:00
$idmode = $user -> user_idmode ;
if ( $idmode == 'nickname' ) $id = $user -> user_nickname ;
if ( $idmode == 'login' ) $id = $user -> user_login ;
if ( $idmode == 'firstname' ) $id = $user -> user_firstname ;
if ( $idmode == 'lastname' ) $id = $user -> user_lastname ;
if ( $idmode == 'namefl' ) $id = $user -> user_firstname . ' ' . $user -> user_lastname ;
if ( $idmode == 'namelf' ) $id = $user -> user_lastname . ' ' . $user -> user_firstname ;
if ( ! $idmode ) $id = $user -> user_nickname ;
2005-07-05 16:47:22 -04:00
$id = $wpdb -> escape ( $id );
2005-06-16 02:14:07 -04:00
$wpdb -> query ( " UPDATE $wpdb->users SET display_name = ' $id ' WHERE ID = ' $user->ID ' " );
endif ;
2005-07-17 15:57:41 -04:00
2005-07-19 10:24:06 -04:00
// FIXME: RESET_CAPS is temporary code to reset roles and caps if flag is set.
$caps = get_usermeta ( $user -> ID , $table_prefix . 'capabilities' );
if ( empty ( $caps ) || defined ( 'RESET_CAPS' ) ) {
2005-07-17 15:57:41 -04:00
$level = get_usermeta ( $user -> ID , $table_prefix . 'user_level' );
$role = translate_level_to_role ( $level );
update_usermeta ( $user -> ID , $table_prefix . 'capabilities' , array ( $role => true ) );
}
2005-06-12 16:49:13 -04:00
endforeach ;
2005-07-08 21:27:46 -04:00
$old_user_fields = array ( 'user_firstname' , 'user_lastname' , 'user_icq' , 'user_aim' , 'user_msn' , 'user_yim' , 'user_idmode' , 'user_ip' , 'user_domain' , 'user_browser' , 'user_description' , 'user_nickname' , 'user_level' );
2005-06-14 19:22:55 -04:00
$wpdb -> hide_errors ();
2005-06-12 16:49:13 -04:00
foreach ( $old_user_fields as $old )
$wpdb -> query ( " ALTER TABLE $wpdb->users DROP $old " );
2005-06-14 19:22:55 -04:00
$wpdb -> show_errors ();
2005-07-23 02:22:48 -04:00
if ( 0 == $wpdb -> get_var ( " SELECT SUM(category_count) FROM $wpdb->categories " ) ) { // Create counts
$categories = $wpdb -> get_col ( " SELECT cat_ID FROM $wpdb->categories " );
foreach ( $categories as $cat_id ) {
2005-11-15 11:31:24 -05:00
$count = $wpdb -> get_var ( " SELECT COUNT(*) FROM $wpdb->post2cat , $wpdb->posts WHERE $wpdb->posts .ID= $wpdb->post2cat .post_id AND post_status='publish' AND category_id = ' $cat_id ' " );
2005-07-23 02:22:48 -04:00
$wpdb -> query ( " UPDATE $wpdb->categories SET category_count = ' $count ' WHERE cat_ID = ' $cat_id ' " );
}
}
2005-11-16 01:29:36 -05:00
// populate comment_count field of posts table
$comments = $wpdb -> get_results ( " SELECT comment_post_ID, COUNT(*) as c FROM $wpdb->comments GROUP BY comment_post_ID " );
if ( is_array ( $comments ) ) {
foreach ( $comments as $comment ) {
$wpdb -> query ( " UPDATE $wpdb->posts SET comment_count = $comment->c WHERE ID = ' $comment->comment_post_ID }' " );
}
}
2005-11-15 17:55:24 -05:00
// Some alpha versions used a post status of object instead of attachment and put
// the mime type in post_type instead of post_mime_type.
if ( $wp_current_db_version > 2541 && $wp_current_db_version <= 3091 ) {
$objects = $wpdb -> get_results ( " SELECT ID, post_type FROM $wpdb->posts WHERE post_status = 'object' " );
foreach ( $objects as $object ) {
$wpdb -> query ( " UPDATE $wpdb->posts SET post_status = 'attachment',
post_mime_type = '$object->post_type' ,
post_type = '' ,
guid = '$guid'
WHERE ID = $object -> ID " );
$meta = get_post_meta ( $postid , 'imagedata' , true );
if ( ! empty ( $meta [ 'file' ]) )
add_post_meta ( $object -> ID , '_wp_attached_file' , $meta [ 'file' ]);
}
}
2005-06-12 16:49:13 -04:00
}
2004-08-30 03:16:40 -04:00
// The functions we use to actually do stuff
// General
function maybe_create_table ( $table_name , $create_ddl ) {
global $wpdb ;
foreach ( $wpdb -> get_col ( " SHOW TABLES " , 0 ) as $table ) {
if ( $table == $table_name ) {
return true ;
}
}
//didn't find it try to create it.
$q = $wpdb -> query ( $create_ddl );
// we cannot directly tell that whether this succeeded!
foreach ( $wpdb -> get_col ( " SHOW TABLES " , 0 ) as $table ) {
if ( $table == $table_name ) {
return true ;
}
}
return false ;
}
function drop_index ( $table , $index ) {
global $wpdb ;
$wpdb -> hide_errors ();
$wpdb -> query ( " ALTER TABLE ` $table ` DROP INDEX ` $index ` " );
// Now we need to take out all the extra ones we may have created
for ( $i = 0 ; $i < 25 ; $i ++ ) {
$wpdb -> query ( " ALTER TABLE ` $table ` DROP INDEX ` { $index } _ $i ` " );
}
$wpdb -> show_errors ();
return true ;
}
function add_clean_index ( $table , $index ) {
global $wpdb ;
drop_index ( $table , $index );
$wpdb -> query ( " ALTER TABLE ` $table ` ADD INDEX ( ` $index ` ) " );
return true ;
}
/**
** maybe_add_column ()
** Add column to db table if it doesn ' t exist .
** Returns : true if already exists or on successful completion
** false on error
*/
function maybe_add_column ( $table_name , $column_name , $create_ddl ) {
global $wpdb , $debug ;
foreach ( $wpdb -> get_col ( " DESC $table_name " , 0 ) as $column ) {
if ( $debug ) echo ( " checking $column == $column_name <br /> " );
if ( $column == $column_name ) {
return true ;
}
}
//didn't find it try to create it.
$q = $wpdb -> query ( $create_ddl );
// we cannot directly tell that whether this succeeded!
foreach ( $wpdb -> get_col ( " DESC $table_name " , 0 ) as $column ) {
if ( $column == $column_name ) {
return true ;
}
}
return false ;
}
// get_alloptions as it was for 1.2.
function get_alloptions_110 () {
global $wpdb ;
if ( $options = $wpdb -> get_results ( " SELECT option_name, option_value FROM $wpdb->options " )) {
foreach ( $options as $option ) {
// "When trying to design a foolproof system,
// never underestimate the ingenuity of the fools :)" -- Dougal
if ( 'siteurl' == $option -> option_name ) $option -> option_value = preg_replace ( '|/+$|' , '' , $option -> option_value );
if ( 'home' == $option -> option_name ) $option -> option_value = preg_replace ( '|/+$|' , '' , $option -> option_value );
if ( 'category_base' == $option -> option_name ) $option -> option_value = preg_replace ( '|/+$|' , '' , $option -> option_value );
$all_options -> { $option -> option_name } = stripslashes ( $option -> option_value );
}
}
return $all_options ;
}
2005-03-29 00:34:30 -05:00
// Version of get_option that is private to install/upgrade.
function __get_option ( $setting ) {
global $wpdb ;
$option = $wpdb -> get_var ( " SELECT option_value FROM $wpdb->options WHERE option_name = ' $setting ' " );
@ $kellogs = unserialize ( $option );
if ( $kellogs !== FALSE )
return $kellogs ;
else
return $option ;
}
2004-08-30 03:16:40 -04:00
function deslash ( $content ) {
// Note: \\\ inside a regex denotes a single backslash.
// Replace one or more backslashes followed by a single quote with
// a single quote.
$content = preg_replace ( " / \\ \ +'/ " , " ' " , $content );
// Replace one or more backslashes followed by a double quote with
// a double quote.
$content = preg_replace ( '/\\\+"/' , '"' , $content );
// Replace one or more backslashes with one backslash.
$content = preg_replace ( " / \\ \ +/ " , " \\ " , $content );
return $content ;
}
function dbDelta ( $queries , $execute = true ) {
global $wpdb ;
// Seperate individual queries into an array
if ( ! is_array ( $queries ) ) {
$queries = explode ( ';' , $queries );
if ( '' == $queries [ count ( $queries ) - 1 ]) array_pop ( $queries );
}
$cqueries = array (); // Creation Queries
$iqueries = array (); // Insertion Queries
$for_update = array ();
// Create a tablename index for an array ($cqueries) of queries
foreach ( $queries as $qry ) {
if ( preg_match ( " |CREATE TABLE ([^ ]*)| " , $qry , $matches )) {
$cqueries [ strtolower ( $matches [ 1 ])] = $qry ;
$for_update [ $matches [ 1 ]] = 'Created table ' . $matches [ 1 ];
}
else if ( preg_match ( " |CREATE DATABASE ([^ ]*)| " , $qry , $matches )) {
array_unshift ( $cqueries , $qry );
}
else if ( preg_match ( " |INSERT INTO ([^ ]*)| " , $qry , $matches )) {
$iqueries [] = $qry ;
}
else if ( preg_match ( " |UPDATE ([^ ]*)| " , $qry , $matches )) {
$iqueries [] = $qry ;
}
else {
// Unrecognized query type
}
}
// Check to see which tables and fields exist
if ( $tables = $wpdb -> get_col ( 'SHOW TABLES;' )) {
// For every table in the database
foreach ( $tables as $table ) {
// If a table query exists for the database table...
if ( array_key_exists ( strtolower ( $table ), $cqueries ) ) {
// Clear the field and index arrays
unset ( $cfields );
unset ( $indices );
// Get all of the field names in the query from between the parens
preg_match ( " | \ ((.*) \ )|ms " , $cqueries [ strtolower ( $table )], $match2 );
$qryline = trim ( $match2 [ 1 ]);
// Separate field lines into an array
$flds = explode ( " \n " , $qryline );
//echo "<hr/><pre>\n".print_r(strtolower($table), true).":\n".print_r($cqueries, true)."</pre><hr/>";
// For every field line specified in the query
foreach ( $flds as $fld ) {
// Extract the field name
preg_match ( " |^([^ ]*)| " , trim ( $fld ), $fvals );
$fieldname = $fvals [ 1 ];
// Verify the found field name
$validfield = true ;
switch ( strtolower ( $fieldname ))
{
case '' :
case 'primary' :
case 'index' :
case 'fulltext' :
case 'unique' :
case 'key' :
$validfield = false ;
$indices [] = trim ( trim ( $fld ), " , \n " );
break ;
}
$fld = trim ( $fld );
// If it's a valid field, add it to the field array
if ( $validfield ) {
$cfields [ strtolower ( $fieldname )] = trim ( $fld , " , \n " );
}
}
// Fetch the table column structure from the database
$tablefields = $wpdb -> get_results ( " DESCRIBE { $table } ; " );
// For every field in the table
foreach ( $tablefields as $tablefield ) {
// If the table field exists in the field array...
if ( array_key_exists ( strtolower ( $tablefield -> Field ), $cfields )) {
// Get the field type from the query
preg_match ( " | " . $tablefield -> Field . " ([^ ]*( unsigned)?)|i " , $cfields [ strtolower ( $tablefield -> Field )], $matches );
$fieldtype = $matches [ 1 ];
// Is actual field type different from the field type in query?
if ( $tablefield -> Type != $fieldtype ) {
// Add a query to change the column type
$cqueries [] = " ALTER TABLE { $table } CHANGE COLUMN { $tablefield -> Field } " . $cfields [ strtolower ( $tablefield -> Field )];
$for_update [ $table . '.' . $tablefield -> Field ] = " Changed type of { $table } . { $tablefield -> Field } from { $tablefield -> Type } to { $fieldtype } " ;
}
// Get the default value from the array
//echo "{$cfields[strtolower($tablefield->Field)]}<br>";
if ( preg_match ( " | DEFAULT '(.*)'|i " , $cfields [ strtolower ( $tablefield -> Field )], $matches )) {
$default_value = $matches [ 1 ];
if ( $tablefield -> Default != $default_value )
{
// Add a query to change the column's default value
$cqueries [] = " ALTER TABLE { $table } ALTER COLUMN { $tablefield -> Field } SET DEFAULT ' { $default_value } ' " ;
$for_update [ $table . '.' . $tablefield -> Field ] = " Changed default value of { $table } . { $tablefield -> Field } from { $tablefield -> Default } to { $default_value } " ;
}
}
// Remove the field from the array (so it's not added)
unset ( $cfields [ strtolower ( $tablefield -> Field )]);
}
else {
// This field exists in the table, but not in the creation queries?
}
}
// For every remaining field specified for the table
foreach ( $cfields as $fieldname => $fielddef ) {
// Push a query line into $cqueries that adds the field to that table
$cqueries [] = " ALTER TABLE { $table } ADD COLUMN $fielddef " ;
$for_update [ $table . '.' . $fieldname ] = 'Added column ' . $table . '.' . $fieldname ;
}
// Index stuff goes here
// Fetch the table index structure from the database
$tableindices = $wpdb -> get_results ( " SHOW INDEX FROM { $table } ; " );
if ( $tableindices ) {
// Clear the index array
unset ( $index_ary );
// For every index in the table
foreach ( $tableindices as $tableindex ) {
// Add the index to the index data array
$keyname = $tableindex -> Key_name ;
$index_ary [ $keyname ][ 'columns' ][] = array ( 'fieldname' => $tableindex -> Column_name , 'subpart' => $tableindex -> Sub_part );
$index_ary [ $keyname ][ 'unique' ] = ( $tableindex -> Non_unique == 0 ) ? true : false ;
}
// For each actual index in the index array
foreach ( $index_ary as $index_name => $index_data ) {
// Build a create string to compare to the query
$index_string = '' ;
if ( $index_name == 'PRIMARY' ) {
$index_string .= 'PRIMARY ' ;
}
else if ( $index_data [ 'unique' ]) {
$index_string .= 'UNIQUE ' ;
}
$index_string .= 'KEY ' ;
if ( $index_name != 'PRIMARY' ) {
$index_string .= $index_name ;
}
$index_columns = '' ;
// For each column in the index
foreach ( $index_data [ 'columns' ] as $column_data ) {
if ( $index_columns != '' ) $index_columns .= ',' ;
// Add the field to the column list string
$index_columns .= $column_data [ 'fieldname' ];
if ( $column_data [ 'subpart' ] != '' ) {
$index_columns .= '(' . $column_data [ 'subpart' ] . ')' ;
}
}
// Add the column list to the index create string
$index_string .= ' (' . $index_columns . ')' ;
if ( ! (( $aindex = array_search ( $index_string , $indices )) === false )) {
unset ( $indices [ $aindex ]);
//echo "<pre style=\"border:1px solid #ccc;margin-top:5px;\">{$table}:<br/>Found index:".$index_string."</pre>\n";
}
//else echo "<pre style=\"border:1px solid #ccc;margin-top:5px;\">{$table}:<br/><b>Did not find index:</b>".$index_string."<br/>".print_r($indices, true)."</pre>\n";
}
}
// For every remaining index specified for the table
foreach ( $indices as $index ) {
// Push a query line into $cqueries that adds the index to that table
$cqueries [] = " ALTER TABLE { $table } ADD $index " ;
$for_update [ $table . '.' . $fieldname ] = 'Added index ' . $table . ' ' . $index ;
}
// Remove the original table creation query from processing
unset ( $cqueries [ strtolower ( $table )]);
unset ( $for_update [ strtolower ( $table )]);
} else {
// This table exists in the database, but not in the creation queries?
}
}
}
$allqueries = array_merge ( $cqueries , $iqueries );
if ( $execute ) {
foreach ( $allqueries as $query ) {
//echo "<pre style=\"border:1px solid #ccc;margin-top:5px;\">".print_r($query, true)."</pre>\n";
$wpdb -> query ( $query );
}
}
return $for_update ;
}
function make_db_current () {
global $wp_queries ;
$alterations = dbDelta ( $wp_queries );
echo " <ol> \n " ;
foreach ( $alterations as $alteration ) echo " <li> $alteration </li> \n " ;
echo " </ol> \n " ;
}
2004-09-04 21:22:17 -04:00
function make_db_current_silent () {
global $wp_queries ;
2004-08-30 03:16:40 -04:00
2004-09-04 21:22:17 -04:00
$alterations = dbDelta ( $wp_queries );
2004-05-31 11:43:45 -04:00
}
2005-01-04 17:46:45 -05:00
function make_site_theme_from_oldschool ( $theme_name , $template ) {
$home_path = get_home_path ();
2005-01-02 05:09:16 -05:00
$site_dir = ABSPATH . " wp-content/themes/ $template " ;
2005-01-04 17:46:45 -05:00
if ( ! file_exists ( " $home_path /index.php " ))
return false ;
// Copy files from the old locations to the site theme.
// TODO: This does not copy arbitarary include dependencies. Only the
// standard WP files are copied.
$files = array ( 'index.php' => 'index.php' , 'wp-layout.css' => 'style.css' , 'wp-comments.php' => 'comments.php' , 'wp-comments-popup.php' => 'comments-popup.php' );
foreach ( $files as $oldfile => $newfile ) {
if ( $oldfile == 'index.php' )
$oldpath = $home_path ;
else
$oldpath = ABSPATH ;
2005-02-14 22:32:43 -05:00
if ( $oldfile == 'index.php' ) { // Check to make sure it's not a new index
$index = implode ( '' , file ( " $oldpath / $oldfile " ));
if ( strstr ( $index , 'WP_USE_THEMES' ) ) {
if ( ! @ copy ( ABSPATH . 'wp-content/themes/default/index.php' , " $site_dir / $newfile " ))
return false ;
continue ; // Don't copy anything
}
}
2005-02-08 03:01:59 -05:00
if ( ! @ copy ( " $oldpath / $oldfile " , " $site_dir / $newfile " ))
2005-01-04 17:46:45 -05:00
return false ;
chmod ( " $site_dir / $newfile " , 0777 );
// Update the blog header include in each file.
$lines = explode ( " \n " , implode ( '' , file ( " $site_dir / $newfile " )));
if ( $lines ) {
$f = fopen ( " $site_dir / $newfile " , 'w' );
2005-03-29 00:34:30 -05:00
2005-01-04 17:46:45 -05:00
foreach ( $lines as $line ) {
2005-02-14 04:17:23 -05:00
if ( preg_match ( '/require.*wp-blog-header/' , $line ))
$line = '//' . $line ;
2005-01-05 16:57:51 -05:00
// Update stylesheet references.
2005-03-29 00:39:23 -05:00
$line = str_replace ( " <?php echo __get_option('siteurl'); ?>/wp-layout.css " , " <?php bloginfo('stylesheet_url'); ?> " , $line );
2005-01-05 16:57:51 -05:00
// Update comments template inclusion.
$line = str_replace ( " <?php include(ABSPATH . 'wp-comments.php'); ?> " , " <?php comments_template(); ?> " , $line );
2005-01-04 17:46:45 -05:00
fwrite ( $f , " { $line } \n " );
}
fclose ( $f );
}
2005-01-02 05:09:16 -05:00
}
2005-01-04 17:46:45 -05:00
// Add a theme header.
2005-03-29 00:34:30 -05:00
$header = " /* \n Theme Name: $theme_name\nTheme URI: " . __get_option ( 'siteurl' ) . " \n Description: A theme automatically created by the upgrade. \n Version: 1.0 \n Author: Moi \n */ \n " ;
2005-01-02 05:09:16 -05:00
2005-01-04 17:46:45 -05:00
$stylelines = file_get_contents ( " $site_dir /style.css " );
if ( $stylelines ) {
$f = fopen ( " $site_dir /style.css " , 'w' );
fwrite ( $f , $header );
fwrite ( $f , $stylelines );
fclose ( $f );
2005-01-02 05:09:16 -05:00
}
2005-01-04 17:46:45 -05:00
return true ;
}
function make_site_theme_from_default ( $theme_name , $template ) {
$site_dir = ABSPATH . " wp-content/themes/ $template " ;
2005-01-02 05:09:16 -05:00
$default_dir = ABSPATH . 'wp-content/themes/default' ;
2005-01-04 17:46:45 -05:00
2005-02-12 14:34:50 -05:00
// Copy files from the default theme to the site theme.
//$files = array('index.php', 'comments.php', 'comments-popup.php', 'footer.php', 'header.php', 'sidebar.php', 'style.css');
$theme_dir = @ dir ( " $default_dir " );
if ( $theme_dir ) {
while (( $theme_file = $theme_dir -> read ()) !== false ) {
if ( is_dir ( " $default_dir / $theme_file " ))
continue ;
if ( ! @ copy ( " $default_dir / $theme_file " , " $site_dir / $theme_file " ))
return ;
chmod ( " $site_dir / $theme_file " , 0777 );
}
2005-01-02 05:09:16 -05:00
}
// Rewrite the theme header.
$stylelines = explode ( " \n " , implode ( '' , file ( " $site_dir /style.css " )));
if ( $stylelines ) {
$f = fopen ( " $site_dir /style.css " , 'w' );
foreach ( $stylelines as $line ) {
2005-01-04 17:46:45 -05:00
if ( strstr ( $line , " Theme Name: " )) $line = " Theme Name: $theme_name " ;
2005-03-29 00:34:30 -05:00
elseif ( strstr ( $line , " Theme URI: " )) $line = " Theme URI: " . __get_option ( 'siteurl' );
2005-01-02 05:09:16 -05:00
elseif ( strstr ( $line , " Description: " )) $line = " Description: Your theme " ;
elseif ( strstr ( $line , " Version: " )) $line = " Version: 1 " ;
elseif ( strstr ( $line , " Author: " )) $line = " Author: You " ;
fwrite ( $f , " { $line } \n " );
}
fclose ( $f );
}
2005-02-12 14:34:50 -05:00
// Copy the images.
umask ( 0 );
if ( ! mkdir ( " $site_dir /images " , 0777 )) {
return false ;
}
$images_dir = @ dir ( " $default_dir /images " );
if ( $images_dir ) {
while (( $image = $images_dir -> read ()) !== false ) {
if ( is_dir ( " $default_dir /images/ $image " ))
continue ;
if ( ! @ copy ( " $default_dir /images/ $image " , " $site_dir /images/ $image " ))
return ;
chmod ( " $site_dir /images/ $image " , 0777 );
}
}
2005-01-04 17:46:45 -05:00
}
// Create a site theme from the default theme.
function make_site_theme () {
// Name the theme after the blog.
2005-03-29 00:34:30 -05:00
$theme_name = __get_option ( 'blogname' );
2005-01-04 17:46:45 -05:00
$template = sanitize_title ( $theme_name );
$site_dir = ABSPATH . " wp-content/themes/ $template " ;
// If the theme already exists, nothing to do.
if ( is_dir ( $site_dir )) {
return false ;
}
// We must be able to write to the themes dir.
if ( ! is_writable ( ABSPATH . " wp-content/themes " )) {
return false ;
}
2005-02-08 02:50:24 -05:00
umask ( 0 );
2005-01-04 17:46:45 -05:00
if ( ! mkdir ( $site_dir , 0777 )) {
return false ;
}
if ( file_exists ( ABSPATH . 'wp-layout.css' )) {
if ( ! make_site_theme_from_oldschool ( $theme_name , $template )) {
// TODO: rm -rf the site theme directory.
return false ;
}
} else {
if ( ! make_site_theme_from_default ( $theme_name , $template ))
// TODO: rm -rf the site theme directory.
return false ;
}
2005-01-02 05:09:16 -05:00
// Make the new site theme active.
2005-03-29 00:34:30 -05:00
$current_template = __get_option ( 'template' );
2005-01-02 05:09:16 -05:00
if ( $current_template == 'default' ) {
update_option ( 'template' , $template );
update_option ( 'stylesheet' , $template );
}
return $template ;
}
2005-07-11 18:39:50 -04:00
function translate_level_to_role ( $level ) {
switch ( $level ) {
case 10 :
case 9 :
case 8 :
2005-07-12 11:53:13 -04:00
return 'administrator' ;
2005-07-11 18:39:50 -04:00
case 7 :
case 6 :
case 5 :
2005-07-12 11:53:13 -04:00
return 'editor' ;
2005-07-11 18:39:50 -04:00
case 4 :
case 3 :
case 2 :
2005-07-12 11:53:13 -04:00
return 'author' ;
2005-07-11 18:39:50 -04:00
case 1 :
2005-07-12 11:53:13 -04:00
return 'contributor' ;
2005-07-11 18:39:50 -04:00
case 0 :
2005-07-12 11:53:13 -04:00
return 'subscriber' ;
2005-07-11 18:39:50 -04:00
}
}
2005-07-12 11:53:13 -04:00
?>