WordPress.org

Make WordPress Core

Ticket #32450: 32450.01.patch

File 32450.01.patch, 11.3 KB (added by johnjamesjacoby, 5 years ago)
  • wp-includes/class-wp-site.php

     
     1<?php
     2
     3/**
     4 * WordPress Site class.
     5 *
     6 * Used by the `$current_blog` global
     7 *
     8 * @since 4.3.0
     9 */
     10class WP_Site {
     11
     12        /**
     13         * Site ID
     14         *
     15         * Named "blog" vs. "site" for legacy reasons
     16         *
     17         * @since 4.3.0
     18         *
     19         * @var int
     20         */
     21        public $blog_id;
     22
     23        /**
     24         * Network ID
     25         *
     26         * Named "site" vs. "network" for legacy reasons
     27         *
     28         * @since 4.3.0
     29         *
     30         * @var int
     31         */
     32        public $site_id = 1;
     33
     34        /**
     35         * Domain
     36         *
     37         * May contain subdomains
     38         *
     39         * @since 4.3.0
     40         *
     41         * @var string
     42         */
     43        public $domain = '';
     44
     45        /**
     46         * Path
     47         *
     48         * May contain multiple segments
     49         *
     50         * @since 4.3.0
     51         *
     52         * @var string
     53         */
     54        public $path = '';
     55
     56        /**
     57         * Timestap site was created
     58         *
     59         * @since 4.3.0
     60         *
     61         * @var string
     62         */
     63        public $registered = '0000-00-00 00:00:00';
     64
     65        /**
     66         * Timestap site was last updated
     67         *
     68         * @since 4.3.0
     69         *
     70         * @var string
     71         */
     72        public $last_updated = '0000-00-00 00:00:00';
     73
     74        /**
     75         * Is site public?
     76         *
     77         * @since 4.3.0
     78         *
     79         * @var int
     80         */
     81        public $public = 1;
     82
     83        /**
     84         * Is site archived?
     85         *
     86         * @since 4.3.0
     87         *
     88         * @var int
     89         */
     90        public $archived = 0;
     91
     92        /**
     93         * Is site mature?
     94         *
     95         * @since 4.3.0
     96         *
     97         * @var int
     98         */
     99        public $mature = 0;
     100
     101        /**
     102         * Is site spam?
     103         *
     104         * @since 4.3.0
     105         *
     106         * @var int
     107         */
     108        public $spam = 0;
     109
     110        /**
     111         * Is site deleted?
     112         *
     113         * @since 4.3.0
     114         *
     115         * @var int
     116         */
     117        public $deleted = 0;
     118
     119        /**
     120         * Language ID
     121         *
     122         * @since 4.3.0
     123         *
     124         * @var int
     125         */
     126        public $lang_id = 0;
     127
     128        /**
     129         * Constructor.
     130         *
     131         * @param WP_Site $site Site object.
     132         */
     133        public function __construct( $site ) {
     134                foreach ( get_object_vars( $site ) as $key => $value ) {
     135                        $this->$key = $value;
     136                }
     137        }
     138
     139        /**
     140         * Retrieve WP_Site instance.
     141         *
     142         * @static
     143         * @access public
     144         *
     145         * @param int $site_id Site ID.
     146         * @return WP_Site|bool Site object, false otherwise.
     147         */
     148        public static function get_instance( $site_id = 0 ) {
     149                global $wpdb;
     150
     151                if ( empty( $site_id ) ) {
     152                        return false;
     153                }
     154
     155                $_site = wp_cache_get( $site_id, 'blogs' );
     156
     157                if ( false === $_site ) {
     158                        $_site = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM {$wpdb->blogs} WHERE ID = %d LIMIT 1", $site_id ) );
     159
     160                        if ( empty( $_site ) ) {
     161                                return false;
     162                        }
     163
     164                        wp_cache_add( $_site->ID, $_site, 'posts' );
     165                }
     166
     167                return new WP_Site( $_site );
     168        }
     169
     170        /**
     171         * Retrieve a site object by its domain, path, and segments
     172         *
     173         * Used primarily by `get_site_by_path()`
     174         *
     175         * @since 4.3.0
     176         *
     177         * @param string   $domain   Domain to check
     178         * @param string   $path     Path to check
     179         * @param int|null $segments Path segments to use. Defaults to null, or the full path
     180         *
     181         * @return object|bool Site object if successful. False when no site is found
     182         */
     183        public static function get( $args = array() ) {
     184                global $wpdb;
     185
     186                $r = wp_parse_args( $args, array(
     187                        'domain'   => '',
     188                        'path'     => '',
     189                        'segments' => null
     190                ) );
     191
     192                $path_segments = array_filter( explode( '/', trim( $r['path'], '/' ) ) );
     193
     194                /**
     195                 * Filter the number of path segments to consider when searching for a site.
     196                 *
     197                 * @since 3.9.0
     198                 *
     199                 * @param int|null $segments The number of path segments to consider. WordPress by default looks at
     200                 *                           one path segment following the network path. The function default of
     201                 *                           null only makes sense when you know the requested path should match a site.
     202                 * @param string   $domain   The requested domain.
     203                 * @param string   $path     The requested path, in full.
     204                 */
     205                $segments = apply_filters( 'site_by_path_segments_count', $r['segments'], $r['domain'], $r['path'] );
     206
     207                if ( ( null !== $segments ) && ( count( $path_segments ) > $segments ) ) {
     208                        $path_segments = array_slice( $path_segments, 0, $segments );
     209                }
     210
     211                $paths = array();
     212
     213                while ( count( $path_segments ) ) {
     214                        $paths[] = '/' . implode( '/', $path_segments ) . '/';
     215                        array_pop( $path_segments );
     216                }
     217
     218                $paths[] = '/';
     219
     220                /**
     221                 * Determine a site by its domain and path.
     222                 *
     223                 * This allows one to short-circuit the default logic, perhaps by
     224                 * replacing it with a routine that is more optimal for your setup.
     225                 *
     226                 * Return null to avoid the short-circuit. Return false if no site
     227                 * can be found at the requested domain and path. Otherwise, return
     228                 * a site object.
     229                 *
     230                 * @since 3.9.0
     231                 *
     232                 * @param null|bool|object $site     Site value to return by path.
     233                 * @param string           $domain   The requested domain.
     234                 * @param string           $path     The requested path, in full.
     235                 * @param int|null         $segments The suggested number of paths to consult.
     236                 *                                   Default null, meaning the entire path was to be consulted.
     237                 * @param array            $paths    The paths to search for, based on $path and $segments.
     238                 */
     239                $pre = apply_filters( 'pre_get_site_by_path', null, $r['domain'], $r['path'], $r['segments'], $paths );
     240                if ( null !== $pre ) {
     241                        return $pre;
     242                }
     243
     244                /*
     245                 * @todo
     246                 * get_blog_details(), caching, etc. Consider alternative optimization routes,
     247                 * perhaps as an opt-in for plugins, rather than using the pre_* filter.
     248                 * For example: The segments filter can expand or ignore paths.
     249                 * If persistent caching is enabled, we could query the DB for a path <> '/'
     250                 * then cache whether we can just always ignore paths.
     251                 */
     252
     253                // Either www or non-www is supported, not both. If a www domain is requested,
     254                // query for both to provide the proper redirect.
     255                $domains = array( $r['domain'] );
     256                if ( 'www.' === substr( $r['domain'], 0, 4 ) ) {
     257                        $domains[]      = substr( $r['domain'], 4 );
     258                        $search_domains = "'" . implode( "', '", $wpdb->_escape( $domains ) ) . "'";
     259                }
     260
     261                if ( count( $paths ) > 1 ) {
     262                        $search_paths = "'" . implode( "', '", $wpdb->_escape( $paths ) ) . "'";
     263                }
     264
     265                // Multiple domains and paths
     266                if ( count( $domains ) > 1 && count( $paths ) > 1 ) {
     267                        $site = $wpdb->get_row( "SELECT * FROM {$wpdb->blogs} WHERE domain IN ({$search_domains}) AND path IN ({$search_paths}) ORDER BY CHAR_LENGTH(domain) DESC, CHAR_LENGTH(path) DESC LIMIT 1" );
     268
     269                // Multiple domains
     270                } elseif ( count( $domains ) > 1 ) {
     271                        $sql  = $wpdb->prepare( "SELECT * FROM {$wpdb->blogs} WHERE path = %s", $paths[0] );
     272                        $sql .= " AND domain IN ($search_domains) ORDER BY CHAR_LENGTH(domain) DESC LIMIT 1";
     273                        $site = $wpdb->get_row( $sql );
     274
     275                // Multiple paths
     276                } elseif ( count( $paths ) > 1 ) {
     277                        $sql  = $wpdb->prepare( "SELECT * FROM {$wpdb->blogs} WHERE domain = %s", $domains[0] );
     278                        $sql .= " AND path IN ($search_paths) ORDER BY CHAR_LENGTH(path) DESC LIMIT 1";
     279                        $site = $wpdb->get_row( $sql );
     280
     281                // Single site
     282                } else {
     283                        $sql  = $wpdb->prepare( "SELECT * FROM {$wpdb->blogs} WHERE domain = %s AND path = %s", $domains[0], $paths[0] );
     284                        $site = $wpdb->get_row( $sql );
     285                }
     286
     287                // Set $site to false if no results
     288                if ( empty( $site ) ) {
     289                        $site = false;
     290                }
     291
     292                return $site;
     293        }
     294}
  • wp-includes/ms-load.php

     
    287287 * @return object|bool Site object if successful. False when no site is found.
    288288 */
    289289function get_site_by_path( $domain, $path, $segments = null ) {
    290         global $wpdb;
    291 
    292         $path_segments = array_filter( explode( '/', trim( $path, '/' ) ) );
    293 
    294         /**
    295          * Filter the number of path segments to consider when searching for a site.
    296          *
    297          * @since 3.9.0
    298          *
    299          * @param int|null $segments The number of path segments to consider. WordPress by default looks at
    300          *                           one path segment following the network path. The function default of
    301          *                           null only makes sense when you know the requested path should match a site.
    302          * @param string   $domain   The requested domain.
    303          * @param string   $path     The requested path, in full.
    304          */
    305         $segments = apply_filters( 'site_by_path_segments_count', $segments, $domain, $path );
    306 
    307         if ( null !== $segments && count( $path_segments ) > $segments ) {
    308                 $path_segments = array_slice( $path_segments, 0, $segments );
    309         }
    310 
    311         $paths = array();
    312 
    313         while ( count( $path_segments ) ) {
    314                 $paths[] = '/' . implode( '/', $path_segments ) . '/';
    315                 array_pop( $path_segments );
    316         }
    317 
    318         $paths[] = '/';
    319 
    320         /**
    321          * Determine a site by its domain and path.
    322          *
    323          * This allows one to short-circuit the default logic, perhaps by
    324          * replacing it with a routine that is more optimal for your setup.
    325          *
    326          * Return null to avoid the short-circuit. Return false if no site
    327          * can be found at the requested domain and path. Otherwise, return
    328          * a site object.
    329          *
    330          * @since 3.9.0
    331          *
    332          * @param null|bool|object $site     Site value to return by path.
    333          * @param string           $domain   The requested domain.
    334          * @param string           $path     The requested path, in full.
    335          * @param int|null         $segments The suggested number of paths to consult.
    336          *                                   Default null, meaning the entire path was to be consulted.
    337          * @param array            $paths    The paths to search for, based on $path and $segments.
    338          */
    339         $pre = apply_filters( 'pre_get_site_by_path', null, $domain, $path, $segments, $paths );
    340         if ( null !== $pre ) {
    341                 return $pre;
    342         }
    343 
    344         /*
    345          * @todo
    346          * get_blog_details(), caching, etc. Consider alternative optimization routes,
    347          * perhaps as an opt-in for plugins, rather than using the pre_* filter.
    348          * For example: The segments filter can expand or ignore paths.
    349          * If persistent caching is enabled, we could query the DB for a path <> '/'
    350          * then cache whether we can just always ignore paths.
    351          */
    352 
    353         // Either www or non-www is supported, not both. If a www domain is requested,
    354         // query for both to provide the proper redirect.
    355         $domains = array( $domain );
    356         if ( 'www.' === substr( $domain, 0, 4 ) ) {
    357                 $domains[] = substr( $domain, 4 );
    358                 $search_domains = "'" . implode( "', '", $wpdb->_escape( $domains ) ) . "'";
    359         }
    360 
    361         if ( count( $paths ) > 1 ) {
    362                 $search_paths = "'" . implode( "', '", $wpdb->_escape( $paths ) ) . "'";
    363         }
    364 
    365         if ( count( $domains ) > 1 && count( $paths ) > 1 ) {
    366                 $site = $wpdb->get_row( "SELECT * FROM $wpdb->blogs WHERE domain IN ($search_domains) AND path IN ($search_paths) ORDER BY CHAR_LENGTH(domain) DESC, CHAR_LENGTH(path) DESC LIMIT 1" );
    367         } elseif ( count( $domains ) > 1 ) {
    368                 $sql = $wpdb->prepare( "SELECT * FROM $wpdb->blogs WHERE path = %s", $paths[0] );
    369                 $sql .= " AND domain IN ($search_domains) ORDER BY CHAR_LENGTH(domain) DESC LIMIT 1";
    370                 $site = $wpdb->get_row( $sql );
    371         } elseif ( count( $paths ) > 1 ) {
    372                 $sql = $wpdb->prepare( "SELECT * FROM $wpdb->blogs WHERE domain = %s", $domains[0] );
    373                 $sql .= " AND path IN ($search_paths) ORDER BY CHAR_LENGTH(path) DESC LIMIT 1";
    374                 $site = $wpdb->get_row( $sql );
    375         } else {
    376                 $site = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->blogs WHERE domain = %s AND path = %s", $domains[0], $paths[0] ) );
    377         }
    378 
    379         if ( $site ) {
    380                 // @todo get_blog_details()
    381                 return $site;
    382         }
    383 
    384         return false;
     290        return WP_Site::get( array(
     291                'domain'   => $domain,
     292                'path'     => $path,
     293                'segments' => $segments
     294        ) );
    385295}
    386296
    387297/**