WordPress 4.0
[autoinstalls/wordpress.git] / wp-includes / ms-blogs.php
1 <?php
2
3 /**
4  * Site/blog functions that work with the blogs table and related data.
5  *
6  * @package WordPress
7  * @subpackage Multisite
8  * @since MU
9  */
10
11 /**
12  * Update the last_updated field for the current blog.
13  *
14  * @since MU
15  */
16 function wpmu_update_blogs_date() {
17         global $wpdb;
18
19         update_blog_details( $wpdb->blogid, array('last_updated' => current_time('mysql', true)) );
20         /**
21          * Fires after the blog details are updated.
22          *
23          * @since MU
24          *
25          * @param int $blog_id Blog ID.
26          */
27         do_action( 'wpmu_blog_updated', $wpdb->blogid );
28 }
29
30 /**
31  * Get a full blog URL, given a blog id.
32  *
33  * @since MU
34  *
35  * @param int $blog_id Blog ID
36  * @return string
37  */
38 function get_blogaddress_by_id( $blog_id ) {
39         $bloginfo = get_blog_details( (int) $blog_id, false ); // only get bare details!
40         return esc_url( 'http://' . $bloginfo->domain . $bloginfo->path );
41 }
42
43 /**
44  * Get a full blog URL, given a blog name.
45  *
46  * @since MU
47  *
48  * @param string $blogname The (subdomain or directory) name
49  * @return string
50  */
51 function get_blogaddress_by_name( $blogname ) {
52         if ( is_subdomain_install() ) {
53                 if ( $blogname == 'main' )
54                         $blogname = 'www';
55                 $url = rtrim( network_home_url(), '/' );
56                 if ( !empty( $blogname ) )
57                         $url = preg_replace( '|^([^\.]+://)|', "\${1}" . $blogname . '.', $url );
58         } else {
59                 $url = network_home_url( $blogname );
60         }
61         return esc_url( $url . '/' );
62 }
63
64 /**
65  * Given a blog's (subdomain or directory) slug, retrieve its id.
66  *
67  * @since MU
68  *
69  * @param string $slug
70  * @return int A blog id
71  */
72 function get_id_from_blogname( $slug ) {
73         global $wpdb;
74
75         $current_site = get_current_site();
76         $slug = trim( $slug, '/' );
77
78         $blog_id = wp_cache_get( 'get_id_from_blogname_' . $slug, 'blog-details' );
79         if ( $blog_id )
80                 return $blog_id;
81
82         if ( is_subdomain_install() ) {
83                 $domain = $slug . '.' . $current_site->domain;
84                 $path = $current_site->path;
85         } else {
86                 $domain = $current_site->domain;
87                 $path = $current_site->path . $slug . '/';
88         }
89
90         $blog_id = $wpdb->get_var( $wpdb->prepare("SELECT blog_id FROM {$wpdb->blogs} WHERE domain = %s AND path = %s", $domain, $path) );
91         wp_cache_set( 'get_id_from_blogname_' . $slug, $blog_id, 'blog-details' );
92         return $blog_id;
93 }
94
95 /**
96  * Retrieve the details for a blog from the blogs table and blog options.
97  *
98  * @since MU
99  *
100  * @param int|string|array $fields A blog ID, a blog slug, or an array of fields to query against. Optional. If not specified the current blog ID is used.
101  * @param bool $get_all Whether to retrieve all details or only the details in the blogs table. Default is true.
102  * @return object Blog details.
103  */
104 function get_blog_details( $fields = null, $get_all = true ) {
105         global $wpdb;
106
107         if ( is_array($fields ) ) {
108                 if ( isset($fields['blog_id']) ) {
109                         $blog_id = $fields['blog_id'];
110                 } elseif ( isset($fields['domain']) && isset($fields['path']) ) {
111                         $key = md5( $fields['domain'] . $fields['path'] );
112                         $blog = wp_cache_get($key, 'blog-lookup');
113                         if ( false !== $blog )
114                                 return $blog;
115                         if ( substr( $fields['domain'], 0, 4 ) == 'www.' ) {
116                                 $nowww = substr( $fields['domain'], 4 );
117                                 $blog = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->blogs WHERE domain IN (%s,%s) AND path = %s ORDER BY CHAR_LENGTH(domain) DESC", $nowww, $fields['domain'], $fields['path'] ) );
118                         } else {
119                                 $blog = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->blogs WHERE domain = %s AND path = %s", $fields['domain'], $fields['path'] ) );
120                         }
121                         if ( $blog ) {
122                                 wp_cache_set($blog->blog_id . 'short', $blog, 'blog-details');
123                                 $blog_id = $blog->blog_id;
124                         } else {
125                                 return false;
126                         }
127                 } elseif ( isset($fields['domain']) && is_subdomain_install() ) {
128                         $key = md5( $fields['domain'] );
129                         $blog = wp_cache_get($key, 'blog-lookup');
130                         if ( false !== $blog )
131                                 return $blog;
132                         if ( substr( $fields['domain'], 0, 4 ) == 'www.' ) {
133                                 $nowww = substr( $fields['domain'], 4 );
134                                 $blog = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->blogs WHERE domain IN (%s,%s) ORDER BY CHAR_LENGTH(domain) DESC", $nowww, $fields['domain'] ) );
135                         } else {
136                                 $blog = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->blogs WHERE domain = %s", $fields['domain'] ) );
137                         }
138                         if ( $blog ) {
139                                 wp_cache_set($blog->blog_id . 'short', $blog, 'blog-details');
140                                 $blog_id = $blog->blog_id;
141                         } else {
142                                 return false;
143                         }
144                 } else {
145                         return false;
146                 }
147         } else {
148                 if ( ! $fields )
149                         $blog_id = get_current_blog_id();
150                 elseif ( ! is_numeric( $fields ) )
151                         $blog_id = get_id_from_blogname( $fields );
152                 else
153                         $blog_id = $fields;
154         }
155
156         $blog_id = (int) $blog_id;
157
158         $all = $get_all == true ? '' : 'short';
159         $details = wp_cache_get( $blog_id . $all, 'blog-details' );
160
161         if ( $details ) {
162                 if ( ! is_object( $details ) ) {
163                         if ( $details == -1 ) {
164                                 return false;
165                         } else {
166                                 // Clear old pre-serialized objects. Cache clients do better with that.
167                                 wp_cache_delete( $blog_id . $all, 'blog-details' );
168                                 unset($details);
169                         }
170                 } else {
171                         return $details;
172                 }
173         }
174
175         // Try the other cache.
176         if ( $get_all ) {
177                 $details = wp_cache_get( $blog_id . 'short', 'blog-details' );
178         } else {
179                 $details = wp_cache_get( $blog_id, 'blog-details' );
180                 // If short was requested and full cache is set, we can return.
181                 if ( $details ) {
182                         if ( ! is_object( $details ) ) {
183                                 if ( $details == -1 ) {
184                                         return false;
185                                 } else {
186                                         // Clear old pre-serialized objects. Cache clients do better with that.
187                                         wp_cache_delete( $blog_id, 'blog-details' );
188                                         unset($details);
189                                 }
190                         } else {
191                                 return $details;
192                         }
193                 }
194         }
195
196         if ( empty($details) ) {
197                 $details = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->blogs WHERE blog_id = %d /* get_blog_details */", $blog_id ) );
198                 if ( ! $details ) {
199                         // Set the full cache.
200                         wp_cache_set( $blog_id, -1, 'blog-details' );
201                         return false;
202                 }
203         }
204
205         if ( ! $get_all ) {
206                 wp_cache_set( $blog_id . $all, $details, 'blog-details' );
207                 return $details;
208         }
209
210         switch_to_blog( $blog_id );
211         $details->blogname              = get_option( 'blogname' );
212         $details->siteurl               = get_option( 'siteurl' );
213         $details->post_count    = get_option( 'post_count' );
214         restore_current_blog();
215
216         /**
217          * Filter a blog's details.
218          *
219          * @since MU
220          *
221          * @param object $details The blog details.
222          */
223         $details = apply_filters( 'blog_details', $details );
224
225         wp_cache_set( $blog_id . $all, $details, 'blog-details' );
226
227         $key = md5( $details->domain . $details->path );
228         wp_cache_set( $key, $details, 'blog-lookup' );
229
230         return $details;
231 }
232
233 /**
234  * Clear the blog details cache.
235  *
236  * @since MU
237  *
238  * @param int $blog_id Optional. Blog ID. Defaults to current blog.
239  */
240 function refresh_blog_details( $blog_id = 0 ) {
241         $blog_id = (int) $blog_id;
242         if ( ! $blog_id ) {
243                 $blog_id = get_current_blog_id();
244         }
245
246         $details = get_blog_details( $blog_id, false );
247         if ( ! $details ) {
248                 // Make sure clean_blog_cache() gets the blog ID
249                 // when the blog has been previously cached as
250                 // non-existent.
251                 $details = (object) array(
252                         'blog_id' => $blog_id,
253                         'domain' => null,
254                         'path' => null
255                 );
256         }
257
258         clean_blog_cache( $details );
259
260         /**
261          * Fires after the blog details cache is cleared.
262          *
263          * @since 3.4.0
264          *
265          * @param int $blog_id Blog ID.
266          */
267         do_action( 'refresh_blog_details', $blog_id );
268 }
269
270 /**
271  * Update the details for a blog. Updates the blogs table for a given blog id.
272  *
273  * @since MU
274  *
275  * @param int $blog_id Blog ID
276  * @param array $details Array of details keyed by blogs table field names.
277  * @return bool True if update succeeds, false otherwise.
278  */
279 function update_blog_details( $blog_id, $details = array() ) {
280         global $wpdb;
281
282         if ( empty($details) )
283                 return false;
284
285         if ( is_object($details) )
286                 $details = get_object_vars($details);
287
288         $current_details = get_blog_details($blog_id, false);
289         if ( empty($current_details) )
290                 return false;
291
292         $current_details = get_object_vars($current_details);
293
294         $details = array_merge($current_details, $details);
295         $details['last_updated'] = current_time('mysql', true);
296
297         $update_details = array();
298         $fields = array( 'site_id', 'domain', 'path', 'registered', 'last_updated', 'public', 'archived', 'mature', 'spam', 'deleted', 'lang_id');
299         foreach ( array_intersect( array_keys( $details ), $fields ) as $field )
300                 $update_details[$field] = $details[$field];
301
302         $result = $wpdb->update( $wpdb->blogs, $update_details, array('blog_id' => $blog_id) );
303
304         if ( false === $result )
305                 return false;
306
307         // If spam status changed, issue actions.
308         if ( $details['spam'] != $current_details['spam'] ) {
309                 if ( $details['spam'] == 1 ) {
310                         /**
311                          * Fires when the blog status is changed to 'spam'.
312                          *
313                          * @since MU
314                          *
315                          * @param int $blog_id Blog ID.
316                          */
317                         do_action( 'make_spam_blog', $blog_id );
318                 } else {
319                         /**
320                          * Fires when the blog status is changed to 'ham'.
321                          *
322                          * @since MU
323                          *
324                          * @param int $blog_id Blog ID.
325                          */
326                         do_action( 'make_ham_blog', $blog_id );
327                 }
328         }
329
330         // If mature status changed, issue actions.
331         if ( $details['mature'] != $current_details['mature'] ) {
332                 if ( $details['mature'] == 1 ) {
333                         /**
334                          * Fires when the blog status is changed to 'mature'.
335                          *
336                          * @since 3.1.0
337                          *
338                          * @param int $blog_id Blog ID.
339                          */
340                         do_action( 'mature_blog', $blog_id );
341                 } else {
342                         /**
343                          * Fires when the blog status is changed to 'unmature'.
344                          *
345                          * @since 3.1.0
346                          *
347                          * @param int $blog_id Blog ID.
348                          */
349                         do_action( 'unmature_blog', $blog_id );
350                 }
351         }
352
353         // If archived status changed, issue actions.
354         if ( $details['archived'] != $current_details['archived'] ) {
355                 if ( $details['archived'] == 1 ) {
356                         /**
357                          * Fires when the blog status is changed to 'archived'.
358                          *
359                          * @since MU
360                          *
361                          * @param int $blog_id Blog ID.
362                          */
363                         do_action( 'archive_blog', $blog_id );
364                 } else {
365                         /**
366                          * Fires when the blog status is changed to 'unarchived'.
367                          *
368                          * @since MU
369                          *
370                          * @param int $blog_id Blog ID.
371                          */
372                         do_action( 'unarchive_blog', $blog_id );
373                 }
374         }
375
376         // If deleted status changed, issue actions.
377         if ( $details['deleted'] != $current_details['deleted'] ) {
378                 if ( $details['deleted'] == 1 ) {
379                         /**
380                          * Fires when the blog status is changed to 'deleted'.
381                          *
382                          * @since 3.5.0
383                          *
384                          * @param int $blog_id Blog ID.
385                          */
386                         do_action( 'make_delete_blog', $blog_id );
387                 } else {
388                         /**
389                          * Fires when the blog status is changed to 'undeleted'.
390                          *
391                          * @since 3.5.0
392                          *
393                          * @param int $blog_id Blog ID.
394                          */
395                         do_action( 'make_undelete_blog', $blog_id );
396                 }
397         }
398
399         if ( isset( $details['public'] ) ) {
400                 switch_to_blog( $blog_id );
401                 update_option( 'blog_public', $details['public'] );
402                 restore_current_blog();
403         }
404
405         refresh_blog_details($blog_id);
406
407         return true;
408 }
409
410 /**
411  * Clean the blog cache
412  *
413  * @since 3.5.0
414  *
415  * @param stdClass $blog The blog details as returned from get_blog_details()
416  */
417 function clean_blog_cache( $blog ) {
418         $blog_id = $blog->blog_id;
419         $domain_path_key = md5( $blog->domain . $blog->path );
420
421         wp_cache_delete( $blog_id , 'blog-details' );
422         wp_cache_delete( $blog_id . 'short' , 'blog-details' );
423         wp_cache_delete(  $domain_path_key, 'blog-lookup' );
424         wp_cache_delete( 'current_blog_' . $blog->domain, 'site-options' );
425         wp_cache_delete( 'current_blog_' . $blog->domain . $blog->path, 'site-options' );
426         wp_cache_delete( 'get_id_from_blogname_' . trim( $blog->path, '/' ), 'blog-details' );
427         wp_cache_delete( $domain_path_key, 'blog-id-cache' );
428 }
429
430 /**
431  * Retrieve option value for a given blog id based on name of option.
432  *
433  * If the option does not exist or does not have a value, then the return value
434  * will be false. This is useful to check whether you need to install an option
435  * and is commonly used during installation of plugin options and to test
436  * whether upgrading is required.
437  *
438  * If the option was serialized then it will be unserialized when it is returned.
439  *
440  * @since MU
441  *
442  * @param int $id A blog ID. Can be null to refer to the current blog.
443  * @param string $option Name of option to retrieve. Expected to not be SQL-escaped.
444  * @param mixed $default Optional. Default value to return if the option does not exist.
445  * @return mixed Value set for the option.
446  */
447 function get_blog_option( $id, $option, $default = false ) {
448         $id = (int) $id;
449
450         if ( empty( $id ) )
451                 $id = get_current_blog_id();
452
453         if ( get_current_blog_id() == $id )
454                 return get_option( $option, $default );
455
456         switch_to_blog( $id );
457         $value = get_option( $option, $default );
458         restore_current_blog();
459
460         /**
461          * Filter a blog option value.
462          *
463          * The dynamic portion of the hook name, $option, refers to the blog option name.
464          *
465          * @since 3.5.0
466          *
467          * @param string  $value The option value.
468          * @param int     $id    Blog ID.
469          */
470         return apply_filters( "blog_option_{$option}", $value, $id );
471 }
472
473 /**
474  * Add a new option for a given blog id.
475  *
476  * You do not need to serialize values. If the value needs to be serialized, then
477  * it will be serialized before it is inserted into the database. Remember,
478  * resources can not be serialized or added as an option.
479  *
480  * You can create options without values and then update the values later.
481  * Existing options will not be updated and checks are performed to ensure that you
482  * aren't adding a protected WordPress option. Care should be taken to not name
483  * options the same as the ones which are protected.
484  *
485  * @since MU
486  *
487  * @param int $id A blog ID. Can be null to refer to the current blog.
488  * @param string $option Name of option to add. Expected to not be SQL-escaped.
489  * @param mixed $value Optional. Option value, can be anything. Expected to not be SQL-escaped.
490  * @return bool False if option was not added and true if option was added.
491  */
492 function add_blog_option( $id, $option, $value ) {
493         $id = (int) $id;
494
495         if ( empty( $id ) )
496                 $id = get_current_blog_id();
497
498         if ( get_current_blog_id() == $id )
499                 return add_option( $option, $value );
500
501         switch_to_blog( $id );
502         $return = add_option( $option, $value );
503         restore_current_blog();
504
505         return $return;
506 }
507
508 /**
509  * Removes option by name for a given blog id. Prevents removal of protected WordPress options.
510  *
511  * @since MU
512  *
513  * @param int $id A blog ID. Can be null to refer to the current blog.
514  * @param string $option Name of option to remove. Expected to not be SQL-escaped.
515  * @return bool True, if option is successfully deleted. False on failure.
516  */
517 function delete_blog_option( $id, $option ) {
518         $id = (int) $id;
519
520         if ( empty( $id ) )
521                 $id = get_current_blog_id();
522
523         if ( get_current_blog_id() == $id )
524                 return delete_option( $option );
525
526         switch_to_blog( $id );
527         $return = delete_option( $option );
528         restore_current_blog();
529
530         return $return;
531 }
532
533 /**
534  * Update an option for a particular blog.
535  *
536  * @since MU
537  *
538  * @param int $id The blog id
539  * @param string $option The option key
540  * @param mixed $value The option value
541  * @return bool True on success, false on failure.
542  */
543 function update_blog_option( $id, $option, $value, $deprecated = null ) {
544         $id = (int) $id;
545
546         if ( null !== $deprecated  )
547                 _deprecated_argument( __FUNCTION__, '3.1' );
548
549         if ( get_current_blog_id() == $id )
550                 return update_option( $option, $value );
551
552         switch_to_blog( $id );
553         $return = update_option( $option, $value );
554         restore_current_blog();
555
556         refresh_blog_details( $id );
557
558         return $return;
559 }
560
561 /**
562  * Switch the current blog.
563  *
564  * This function is useful if you need to pull posts, or other information,
565  * from other blogs. You can switch back afterwards using restore_current_blog().
566  *
567  * Things that aren't switched:
568  *  - autoloaded options. See #14992
569  *  - plugins. See #14941
570  *
571  * @see restore_current_blog()
572  * @since MU
573  *
574  * @param int $new_blog The id of the blog you want to switch to. Default: current blog
575  * @param bool $deprecated Deprecated argument
576  * @return bool Always returns True.
577  */
578 function switch_to_blog( $new_blog, $deprecated = null ) {
579         global $wpdb, $wp_roles;
580
581         if ( empty( $new_blog ) )
582                 $new_blog = $GLOBALS['blog_id'];
583
584         $GLOBALS['_wp_switched_stack'][] = $GLOBALS['blog_id'];
585
586         /*
587          * If we're switching to the same blog id that we're on,
588          * set the right vars, do the associated actions, but skip
589          * the extra unnecessary work
590          */
591         if ( $new_blog == $GLOBALS['blog_id'] ) {
592                 /**
593                  * Fires when the blog is switched.
594                  *
595                  * @since MU
596                  *
597                  * @param int $new_blog New blog ID.
598                  * @param int $new_blog Blog ID.
599                  */
600                 do_action( 'switch_blog', $new_blog, $new_blog );
601                 $GLOBALS['switched'] = true;
602                 return true;
603         }
604
605         $wpdb->set_blog_id( $new_blog );
606         $GLOBALS['table_prefix'] = $wpdb->get_blog_prefix();
607         $prev_blog_id = $GLOBALS['blog_id'];
608         $GLOBALS['blog_id'] = $new_blog;
609
610         if ( function_exists( 'wp_cache_switch_to_blog' ) ) {
611                 wp_cache_switch_to_blog( $new_blog );
612         } else {
613                 global $wp_object_cache;
614
615                 if ( is_object( $wp_object_cache ) && isset( $wp_object_cache->global_groups ) )
616                         $global_groups = $wp_object_cache->global_groups;
617                 else
618                         $global_groups = false;
619
620                 wp_cache_init();
621
622                 if ( function_exists( 'wp_cache_add_global_groups' ) ) {
623                         if ( is_array( $global_groups ) )
624                                 wp_cache_add_global_groups( $global_groups );
625                         else
626                                 wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'site-transient', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'rss', 'global-posts', ' blog-id-cache' ) );
627                         wp_cache_add_non_persistent_groups( array( 'comment', 'counts', 'plugins' ) );
628                 }
629         }
630
631         if ( did_action( 'init' ) ) {
632                 $wp_roles->reinit();
633                 $current_user = wp_get_current_user();
634                 $current_user->for_blog( $new_blog );
635         }
636
637         /** This filter is documented in wp-includes/ms-blogs.php */
638         do_action( 'switch_blog', $new_blog, $prev_blog_id );
639         $GLOBALS['switched'] = true;
640
641         return true;
642 }
643
644 /**
645  * Restore the current blog, after calling switch_to_blog()
646  *
647  * @see switch_to_blog()
648  * @since MU
649  *
650  * @return bool True on success, false if we're already on the current blog
651  */
652 function restore_current_blog() {
653         global $wpdb, $wp_roles;
654
655         if ( empty( $GLOBALS['_wp_switched_stack'] ) )
656                 return false;
657
658         $blog = array_pop( $GLOBALS['_wp_switched_stack'] );
659
660         if ( $GLOBALS['blog_id'] == $blog ) {
661                 /** This filter is documented in wp-includes/ms-blogs.php */
662                 do_action( 'switch_blog', $blog, $blog );
663                 // If we still have items in the switched stack, consider ourselves still 'switched'
664                 $GLOBALS['switched'] = ! empty( $GLOBALS['_wp_switched_stack'] );
665                 return true;
666         }
667
668         $wpdb->set_blog_id( $blog );
669         $prev_blog_id = $GLOBALS['blog_id'];
670         $GLOBALS['blog_id'] = $blog;
671         $GLOBALS['table_prefix'] = $wpdb->get_blog_prefix();
672
673         if ( function_exists( 'wp_cache_switch_to_blog' ) ) {
674                 wp_cache_switch_to_blog( $blog );
675         } else {
676                 global $wp_object_cache;
677
678                 if ( is_object( $wp_object_cache ) && isset( $wp_object_cache->global_groups ) )
679                         $global_groups = $wp_object_cache->global_groups;
680                 else
681                         $global_groups = false;
682
683                 wp_cache_init();
684
685                 if ( function_exists( 'wp_cache_add_global_groups' ) ) {
686                         if ( is_array( $global_groups ) )
687                                 wp_cache_add_global_groups( $global_groups );
688                         else
689                                 wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'site-transient', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'rss', 'global-posts', ' blog-id-cache' ) );
690                         wp_cache_add_non_persistent_groups( array( 'comment', 'counts', 'plugins' ) );
691                 }
692         }
693
694         if ( did_action( 'init' ) ) {
695                 $wp_roles->reinit();
696                 $current_user = wp_get_current_user();
697                 $current_user->for_blog( $blog );
698         }
699
700         /** This filter is documented in wp-includes/ms-blogs.php */
701         do_action( 'switch_blog', $blog, $prev_blog_id );
702
703         // If we still have items in the switched stack, consider ourselves still 'switched'
704         $GLOBALS['switched'] = ! empty( $GLOBALS['_wp_switched_stack'] );
705
706         return true;
707 }
708
709 /**
710  * Determines if switch_to_blog() is in effect
711  *
712  * @since 3.5.0
713  *
714  * @return bool True if switched, false otherwise.
715  */
716 function ms_is_switched() {
717         return ! empty( $GLOBALS['_wp_switched_stack'] );
718 }
719
720 /**
721  * Check if a particular blog is archived.
722  *
723  * @since MU
724  *
725  * @param int $id The blog id
726  * @return string Whether the blog is archived or not
727  */
728 function is_archived( $id ) {
729         return get_blog_status($id, 'archived');
730 }
731
732 /**
733  * Update the 'archived' status of a particular blog.
734  *
735  * @since MU
736  *
737  * @param int $id The blog id
738  * @param string $archived The new status
739  * @return string $archived
740  */
741 function update_archived( $id, $archived ) {
742         update_blog_status($id, 'archived', $archived);
743         return $archived;
744 }
745
746 /**
747  * Update a blog details field.
748  *
749  * @since MU
750  *
751  * @param int $blog_id BLog ID
752  * @param string $pref A field name
753  * @param string $value Value for $pref
754  * @return string $value
755  */
756 function update_blog_status( $blog_id, $pref, $value, $deprecated = null ) {
757         global $wpdb;
758
759         if ( null !== $deprecated  )
760                 _deprecated_argument( __FUNCTION__, '3.1' );
761
762         if ( ! in_array( $pref, array( 'site_id', 'domain', 'path', 'registered', 'last_updated', 'public', 'archived', 'mature', 'spam', 'deleted', 'lang_id') ) )
763                 return $value;
764
765         $result = $wpdb->update( $wpdb->blogs, array($pref => $value, 'last_updated' => current_time('mysql', true)), array('blog_id' => $blog_id) );
766
767         if ( false === $result )
768                 return false;
769
770         refresh_blog_details( $blog_id );
771
772         if ( 'spam' == $pref ) {
773                 if ( $value == 1 ) {
774                         /** This filter is documented in wp-includes/ms-blogs.php */
775                         do_action( 'make_spam_blog', $blog_id );
776                 } else {
777                         /** This filter is documented in wp-includes/ms-blogs.php */
778                         do_action( 'make_ham_blog', $blog_id );
779                 }
780         } elseif ( 'mature' == $pref ) {
781                 if ( $value == 1 ) {
782                         /** This filter is documented in wp-includes/ms-blogs.php */
783                         do_action( 'mature_blog', $blog_id );
784                 } else {
785                         /** This filter is documented in wp-includes/ms-blogs.php */
786                         do_action( 'unmature_blog', $blog_id );
787                 }
788         } elseif ( 'archived' == $pref ) {
789                 if ( $value == 1 ) {
790                         /** This filter is documented in wp-includes/ms-blogs.php */
791                         do_action( 'archive_blog', $blog_id );
792                 } else {
793                         /** This filter is documented in wp-includes/ms-blogs.php */
794                         do_action( 'unarchive_blog', $blog_id );
795                 }
796         } elseif ( 'deleted' == $pref ) {
797                 if ( $value == 1 ) {
798                         /** This filter is documented in wp-includes/ms-blogs.php */
799                         do_action( 'make_delete_blog', $blog_id );
800                 } else {
801                         /** This filter is documented in wp-includes/ms-blogs.php */
802                         do_action( 'make_undelete_blog', $blog_id );
803                 }
804         } elseif ( 'public' == $pref ) {
805                 /**
806                  * Fires after the current blog's 'public' setting is updated.
807                  *
808                  * @since MU
809                  *
810                  * @param int    $blog_id Blog ID.
811                  * @param string $value   The value of blog status.
812                  */
813                 do_action( 'update_blog_public', $blog_id, $value ); // Moved here from update_blog_public().
814         }
815
816         return $value;
817 }
818
819 /**
820  * Get a blog details field.
821  *
822  * @since MU
823  *
824  * @param int $id The blog id
825  * @param string $pref A field name
826  * @return bool $value
827  */
828 function get_blog_status( $id, $pref ) {
829         global $wpdb;
830
831         $details = get_blog_details( $id, false );
832         if ( $details )
833                 return $details->$pref;
834
835         return $wpdb->get_var( $wpdb->prepare("SELECT %s FROM {$wpdb->blogs} WHERE blog_id = %d", $pref, $id) );
836 }
837
838 /**
839  * Get a list of most recently updated blogs.
840  *
841  * @since MU
842  *
843  * @param mixed $deprecated Not used
844  * @param int $start The offset
845  * @param int $quantity The maximum number of blogs to retrieve. Default is 40.
846  * @return array The list of blogs
847  */
848 function get_last_updated( $deprecated = '', $start = 0, $quantity = 40 ) {
849         global $wpdb;
850
851         if ( ! empty( $deprecated ) )
852                 _deprecated_argument( __FUNCTION__, 'MU' ); // never used
853
854         return $wpdb->get_results( $wpdb->prepare("SELECT blog_id, domain, path FROM $wpdb->blogs WHERE site_id = %d AND public = '1' AND archived = '0' AND mature = '0' AND spam = '0' AND deleted = '0' AND last_updated != '0000-00-00 00:00:00' ORDER BY last_updated DESC limit %d, %d", $wpdb->siteid, $start, $quantity ) , ARRAY_A );
855 }
856
857 /**
858  * Handler for updating the blog date when a post is published or an already published post is changed.
859  *
860  * @since 3.3.0
861  *
862  * @param string $new_status The new post status
863  * @param string $old_status The old post status
864  * @param object $post Post object
865  */
866 function _update_blog_date_on_post_publish( $new_status, $old_status, $post ) {
867         $post_type_obj = get_post_type_object( $post->post_type );
868         if ( ! $post_type_obj || ! $post_type_obj->public ) {
869                 return;
870         }
871
872         if ( 'publish' != $new_status && 'publish' != $old_status ) {
873                 return;
874         }
875
876         // Post was freshly published, published post was saved, or published post was unpublished.
877
878         wpmu_update_blogs_date();
879 }
880
881 /**
882  * Handler for updating the blog date when a published post is deleted.
883  *
884  * @since 3.4.0
885  *
886  * @param int $post_id Post ID
887  */
888 function _update_blog_date_on_post_delete( $post_id ) {
889         $post = get_post( $post_id );
890
891         $post_type_obj = get_post_type_object( $post->post_type );
892         if ( ! $post_type_obj || ! $post_type_obj->public ) {
893                 return;
894         }
895
896         if ( 'publish' != $post->post_status ) {
897                 return;
898         }
899
900         wpmu_update_blogs_date();
901 }
902
903 /**
904  * Handler for updating the blog posts count date when a post is deleted.
905  *
906  * @since 4.0.0
907  *
908  * @param int $post_id Post ID.
909  */
910 function _update_posts_count_on_delete( $post_id ) {
911         $post = get_post( $post_id );
912
913         if ( ! $post || 'publish' !== $post->post_status ) {
914                 return;
915         }
916
917         update_posts_count();
918 }
919
920 /**
921  * Handler for updating the blog posts count date when a post status changes.
922  *
923  * @since 4.0.0
924  *
925  * @param string $new_status The status the post is changing to.
926  * @param string $old_status The status the post is changing from.
927  */
928 function _update_posts_count_on_transition_post_status( $new_status, $old_status ) {
929         if ( $new_status === $old_status ) {
930                 return;
931         }
932
933         if ( 'publish' !== $new_status && 'publish' !== $old_status ) {
934                 return;
935         }
936
937         update_posts_count();
938 }
939