<?php
/**
* The sitemap cache watcher.
*
* @since 0.9.0
* @package RankMath
* @subpackage RankMath\Sitemap
* @author Rank Math <support@rankmath.com>
*
* @copyright Copyright (C) 2008-2019, Yoast BV
* The following code is a derivative work of the code from the Yoast(https://github.com/Yoast/wordpress-seo/), which is licensed under GPL v3.
*/
namespace RankMath\Sitemap;
use RankMath\Helper;
use RankMath\Sitemap\Sitemap;
use RankMath\Traits\Hooker;
defined( 'ABSPATH' ) || exit;
/**
* Cache_Watcher class.
*/
class Cache_Watcher {
use Hooker;
/**
* Holds the options that, when updated, should cause the cache to clear.
*
* @var array
*/
protected static $cache_clear = [];
/**
* Holds the flag to clear all cache.
*
* @var boolean
*/
protected static $clear_all = false;
/**
* Holds the array of types to clear.
*
* @var array
*/
protected static $clear_types = [];
/**
* Holds the array of post types being imported.
*
* @var array
*/
private $importing_post_types = [];
/**
* The constructor.
*/
public function __construct() {
$this->action( 'save_post', 'save_post' );
$this->action( 'transition_post_status', 'status_transition', 10, 3 );
$this->action( 'admin_footer', 'status_transition_bulk_finished' );
$this->action( 'edited_terms', 'invalidate_term', 10, 2 );
$this->action( 'clean_term_cache', 'invalidate_term', 10, 2 );
$this->action( 'clean_object_term_cache', 'invalidate_term', 10, 2 );
$this->action( 'delete_user', 'invalidate_author' );
$this->action( 'user_register', 'invalidate_author' );
$this->action( 'profile_update', 'invalidate_author' );
$this->action( 'rank_math/sitemap/invalidate_object_type', 'invalidate_object_type', 10, 2 );
add_action( 'shutdown', [ __CLASS__, 'clear_queued' ] );
add_action( 'update_option', [ __CLASS__, 'clear_on_option_update' ] );
add_action( 'deleted_term_relationships', [ __CLASS__, 'invalidate' ] );
// Clear cache when user updates any of these options.
self::register_clear_on_option_update( 'home' );
self::register_clear_on_option_update( 'permalink_structure' );
self::register_clear_on_option_update( 'rank_math_modules' );
self::register_clear_on_option_update( 'rank-math-options-titles' );
self::register_clear_on_option_update( 'rank-math-options-general' );
self::register_clear_on_option_update( 'rank-math-options-sitemap' );
self::register_clear_on_option_update( 'date_format' );
}
/**
* Check for relevant post type before invalidation.
*
* @param int $post_id Post ID to possibly invalidate for.
*/
public function save_post( $post_id ) {
$post = get_post( $post_id );
if ( ! empty( $post->post_password ) || 'auto-draft' === $post->post_status ) {
return false;
}
update_user_meta( $post->post_author, 'last_update', get_post_modified_time( 'U', false, $post ) );
$this->invalidate_post( $post_id );
$this->invalidate_author( $post->post_author );
}
/**
* Hooked into transition_post_status. Will initiate search engine pings
* if the post is being published, is a post type that a sitemap is built for
* and is a post that is included in sitemaps.
*
* @param string $new_status New post status.
* @param string $old_status Old post status.
* @param \WP_Post $post Post object.
*/
public function status_transition( $new_status, $old_status, $post ) {
if ( 'publish' !== $new_status ) {
return;
}
if ( defined( 'WP_IMPORTING' ) ) {
$this->status_transition_bulk( $new_status, $old_status, $post );
return;
}
if ( $this->can_exclude( $post ) ) {
return;
}
if ( WP_CACHE ) {
wp_schedule_single_event( ( time() + 300 ), 'rank_math/sitemap/hit_index' );
}
}
/**
* Can exclude post type.
*
* @param \WP_Post $post Post object.
*
* @return bool
*/
private function can_exclude( $post ) {
$post_type = get_post_type( $post );
wp_cache_delete( 'lastpostmodified:gmt:' . $post_type, 'timeinfo' );
// None of our interest.
// If the post type is excluded in options, we can stop.
return 'nav_menu_item' === $post_type || ! Sitemap::is_object_indexable( $post->ID );
}
/**
* While bulk importing, just save unique `post_types`.
*
* When importing is done, if we have a `post_type` that is saved in the sitemap
* try to ping the search engines
*
* @param string $new_status New post status.
* @param string $old_status Old post status.
* @param \WP_Post $post Post object.
*/
private function status_transition_bulk( $new_status, $old_status, $post ) {
$this->importing_post_types[] = get_post_type( $post );
$this->importing_post_types = array_unique( $this->importing_post_types );
}
/**
* After import finished, walk through imported `post_types` and update info.
*/
public function status_transition_bulk_finished() {
if ( ! defined( 'WP_IMPORTING' ) || empty( $this->importing_post_types ) ) {
return;
}
if ( false === $this->maybe_ping_search_engines() ) {
return;
}
if ( WP_CACHE ) {
do_action( 'rank_math/sitemap/hit_index' );
}
}
/**
* Check if we can ping search engines.
*
* @return bool
*/
private function maybe_ping_search_engines() {
$ping = false;
$accessible_post_types = Helper::get_accessible_post_types();
foreach ( $this->importing_post_types as $post_type ) {
wp_cache_delete( 'lastpostmodified:gmt:' . $post_type, 'timeinfo' );
if ( in_array( $post_type, $accessible_post_types, true ) ) {
$ping = true;
}
}
return $ping;
}
/**
* Helper to invalidate in hooks where type is passed as second argument.
*
* @param int $unused Unused term ID value.
* @param string $taxonomy Taxonomy to invalidate.
*/
public static function invalidate_term( $unused, $taxonomy ) {
if ( false !== Helper::get_settings( 'sitemap.tax_' . $taxonomy . '_sitemap' ) ) {
self::invalidate( $taxonomy );
}
}
/**
* Delete cache transients for index and specific type.
*
* Always deletes the main index sitemaps cache, as that's always invalidated by any other change.
*
* @param string $type Sitemap type to invalidate.
*/
public static function invalidate( $type ) {
self::clear( [ $type ] );
}
/**
* Invalidate sitemap cache for the post type of a post.
* Don't invalidate for revisions.
*
* @param int $post_id Post ID to invalidate type for.
*/
public static function invalidate_post( $post_id ) {
if ( wp_is_post_revision( $post_id ) ) {
return;
}
self::invalidate( get_post_type( $post_id ) );
}
/**
* Invalidate sitemap cache for authors.
*
* @param int $user_id User ID.
*/
public static function invalidate_author( $user_id ) {
$user = get_user_by( 'id', $user_id );
if ( 'user_register' === current_action() || 'profile_update' === current_action() ) {
update_user_meta( $user_id, 'last_update', time() );
}
if ( $user && ! is_null( $user->roles ) && ! in_array( 'subscriber', $user->roles, true ) ) {
self::invalidate( 'author' );
}
}
/**
* Function to clear the Sitemap Cache.
*
* @param string $object_type Object type for destination where to save.
* @param int $object_id Object id for destination where to save.
*
* @return void
*/
public static function invalidate_object_type( $object_type, $object_id ) {
if ( 'post' === $object_type ) {
self::invalidate_post( $object_id );
return;
}
if ( 'user' === $object_type ) {
self::invalidate_author( $object_id );
return;
}
if ( 'term' === $object_type ) {
$term = get_term( $object_id );
self::invalidate_term( $object_id, $term->taxonomy );
}
}
/**
* Delete cache transients for given sitemaps types or all by default.
*
* @param array $types Set of sitemap types to delete cache transients for.
*/
public static function clear( $types = [] ) {
if ( ! Sitemap::is_cache_enabled() ) {
return;
}
// No types provided, clear all.
if ( empty( $types ) ) {
self::$clear_all = true;
return;
}
// Always invalidate the index sitemap as well.
if ( ! in_array( '1', $types, true ) ) {
array_unshift( $types, '1' );
}
foreach ( $types as $type ) {
if ( ! in_array( $type, self::$clear_types, true ) ) {
self::$clear_types[] = $type;
}
}
}
/**
* Invalidate storage for cache types queued to clear.
*/
public static function clear_queued() {
if ( self::$clear_all ) {
Cache::invalidate_storage();
self::$clear_all = false;
self::$clear_types = [];
return;
}
foreach ( self::$clear_types as $type ) {
Cache::invalidate_storage( $type );
}
self::$clear_types = [];
}
/**
* Adds a hook that when given option is updated, the cache is cleared.
*
* @param string $option Option name.
* @param string $type Sitemap type.
*/
public static function register_clear_on_option_update( $option, $type = '' ) {
self::$cache_clear[ $option ] = $type;
}
/**
* Clears the transient cache when a given option is updated, if that option has been registered before.
*
* @param string $option The option name that's being updated.
*/
public static function clear_on_option_update( $option ) {
if ( ! array_key_exists( $option, self::$cache_clear ) ) {
return;
}
// Clear all caches.
if ( empty( self::$cache_clear[ $option ] ) ) {
self::clear();
return;
}
// Clear specific provided type(s).
$types = (array) self::$cache_clear[ $option ];
self::clear( $types );
}
}