first commit
This commit is contained in:
Rachit Bhargava
@@ -0,0 +1,694 @@
|
||||
<?php
|
||||
|
||||
namespace Yoast\WP\SEO\Repositories;
|
||||
|
||||
use Yoast\WP\Lib\ORM;
|
||||
use Yoast\WP\Lib\Model;
|
||||
use Yoast\WP\SEO\Helpers\Taxonomy_Helper;
|
||||
use Yoast\WP\SEO\Helpers\Post_Type_Helper;
|
||||
use Yoast\WP\SEO\Helpers\Author_Archive_Helper;
|
||||
|
||||
/**
|
||||
* Repository containing all cleanup queries.
|
||||
*/
|
||||
class Indexable_Cleanup_Repository {
|
||||
|
||||
/**
|
||||
* A helper for taxonomies.
|
||||
*
|
||||
* @var Taxonomy_Helper
|
||||
*/
|
||||
private $taxonomy;
|
||||
|
||||
/**
|
||||
* A helper for post types.
|
||||
*
|
||||
* @var Post_Type_Helper
|
||||
*/
|
||||
private $post_type;
|
||||
|
||||
/**
|
||||
* A helper for author archives.
|
||||
*
|
||||
* @var Author_Archive_Helper
|
||||
*/
|
||||
private $author_archive;
|
||||
|
||||
/**
|
||||
* The constructor.
|
||||
*
|
||||
* @param Taxonomy_Helper $taxonomy A helper for taxonomies.
|
||||
* @param Post_Type_Helper $post_type A helper for post types.
|
||||
* @param Author_Archive_Helper $author_archive A helper for author archives.
|
||||
*/
|
||||
public function __construct( Taxonomy_Helper $taxonomy, Post_Type_Helper $post_type, Author_Archive_Helper $author_archive ) {
|
||||
$this->taxonomy = $taxonomy;
|
||||
$this->post_type = $post_type;
|
||||
$this->author_archive = $author_archive;
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts a query for this repository.
|
||||
*
|
||||
* @return ORM
|
||||
*/
|
||||
public function query() {
|
||||
return Model::of_type( 'Indexable' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes rows from the indexable table depending on the object_type and object_sub_type.
|
||||
*
|
||||
* @param string $object_type The object type to query.
|
||||
* @param string $object_sub_type The object subtype to query.
|
||||
* @param int $limit The limit we'll apply to the delete query.
|
||||
*
|
||||
* @return int|bool The number of rows that was deleted or false if the query failed.
|
||||
*/
|
||||
public function clean_indexables_with_object_type_and_object_sub_type( string $object_type, string $object_sub_type, int $limit ) {
|
||||
global $wpdb;
|
||||
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: There is no unescaped user input.
|
||||
$sql = $wpdb->prepare( "DELETE FROM $indexable_table WHERE object_type = %s AND object_sub_type = %s ORDER BY id LIMIT %d", $object_type, $object_sub_type, $limit );
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
return $wpdb->query( $sql );
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts amount of indexables by object type and object sub type.
|
||||
*
|
||||
* @param string $object_type The object type to check.
|
||||
* @param string $object_sub_type The object sub type to check.
|
||||
*
|
||||
* @return float|int
|
||||
*/
|
||||
public function count_indexables_with_object_type_and_object_sub_type( string $object_type, string $object_sub_type ) {
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', $object_type )
|
||||
->where( 'object_sub_type', $object_sub_type )
|
||||
->count();
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes rows from the indexable table depending on the post_status.
|
||||
*
|
||||
* @param string $post_status The post status to query.
|
||||
* @param int $limit The limit we'll apply to the delete query.
|
||||
*
|
||||
* @return int|bool The number of rows that was deleted or false if the query failed.
|
||||
*/
|
||||
public function clean_indexables_with_post_status( $post_status, $limit ) {
|
||||
global $wpdb;
|
||||
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: There is no unescaped user input.
|
||||
$sql = $wpdb->prepare( "DELETE FROM $indexable_table WHERE object_type = 'post' AND post_status = %s ORDER BY id LIMIT %d", $post_status, $limit );
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
return $wpdb->query( $sql );
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts indexables with a certain post status.
|
||||
*
|
||||
* @param string $post_status The post status to count.
|
||||
*
|
||||
* @return float|int
|
||||
*/
|
||||
public function count_indexables_with_post_status( string $post_status ) {
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', 'post' )
|
||||
->where( 'post_status', $post_status )
|
||||
->count();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up any indexables that belong to post types that are not/no longer publicly viewable.
|
||||
*
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return bool|int The number of deleted rows, false if the query fails.
|
||||
*/
|
||||
public function clean_indexables_for_non_publicly_viewable_post( $limit ) {
|
||||
global $wpdb;
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
$included_post_types = $this->post_type->get_indexable_post_types();
|
||||
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: Too hard to fix.
|
||||
if ( empty( $included_post_types ) ) {
|
||||
$delete_query = $wpdb->prepare(
|
||||
"DELETE FROM $indexable_table
|
||||
WHERE object_type = 'post'
|
||||
AND object_sub_type IS NOT NULL
|
||||
LIMIT %d",
|
||||
$limit
|
||||
);
|
||||
}
|
||||
else {
|
||||
// phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.ReplacementsWrongNumber -- Reason: we're passing an array instead.
|
||||
$delete_query = $wpdb->prepare(
|
||||
"DELETE FROM $indexable_table
|
||||
WHERE object_type = 'post'
|
||||
AND object_sub_type IS NOT NULL
|
||||
AND object_sub_type NOT IN ( " . \implode( ', ', \array_fill( 0, \count( $included_post_types ), '%s' ) ) . ' )
|
||||
LIMIT %d',
|
||||
\array_merge( $included_post_types, [ $limit ] )
|
||||
);
|
||||
}
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: No relevant caches.
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery -- Reason: Most performant way.
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.NotPrepared -- Reason: Is it prepared already.
|
||||
return $wpdb->query( $delete_query );
|
||||
// phpcs:enable
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts all indexables for non public post types.
|
||||
*
|
||||
* @return float|int
|
||||
*/
|
||||
public function count_indexables_for_non_publicly_viewable_post() {
|
||||
$included_post_types = $this->post_type->get_indexable_post_types();
|
||||
|
||||
if ( empty( $included_post_types ) ) {
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', 'post' )
|
||||
->where_not_equal( 'object_sub_type', 'null' )
|
||||
->count();
|
||||
}
|
||||
else {
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', 'post' )
|
||||
->where_not_equal( 'object_sub_type', 'null' )
|
||||
->where_not_in( 'object_sub_type', $included_post_types )
|
||||
->count();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up any indexables that belong to taxonomies that are not/no longer publicly viewable.
|
||||
*
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return bool|int The number of deleted rows, false if the query fails.
|
||||
*/
|
||||
public function clean_indexables_for_non_publicly_viewable_taxonomies( $limit ) {
|
||||
global $wpdb;
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
$included_taxonomies = $this->taxonomy->get_indexable_taxonomies();
|
||||
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: Too hard to fix.
|
||||
if ( empty( $included_taxonomies ) ) {
|
||||
$delete_query = $wpdb->prepare(
|
||||
"DELETE FROM $indexable_table
|
||||
WHERE object_type = 'term'
|
||||
AND object_sub_type IS NOT NULL
|
||||
LIMIT %d",
|
||||
$limit
|
||||
);
|
||||
}
|
||||
else {
|
||||
// phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.ReplacementsWrongNumber -- Reason: we're passing an array instead.
|
||||
$delete_query = $wpdb->prepare(
|
||||
"DELETE FROM $indexable_table
|
||||
WHERE object_type = 'term'
|
||||
AND object_sub_type IS NOT NULL
|
||||
AND object_sub_type NOT IN ( " . \implode( ', ', \array_fill( 0, \count( $included_taxonomies ), '%s' ) ) . ' )
|
||||
LIMIT %d',
|
||||
\array_merge( $included_taxonomies, [ $limit ] )
|
||||
);
|
||||
}
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: No relevant caches.
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery -- Reason: Most performant way.
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.NotPrepared -- Reason: Is it prepared already.
|
||||
return $wpdb->query( $delete_query );
|
||||
// phpcs:enable
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up any indexables that belong to post type archive page that are not/no longer publicly viewable.
|
||||
*
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return bool|int The number of deleted rows, false if the query fails.
|
||||
*/
|
||||
public function clean_indexables_for_non_publicly_viewable_post_type_archive_pages( $limit ) {
|
||||
global $wpdb;
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
$included_post_types = $this->post_type->get_indexable_post_archives();
|
||||
|
||||
$post_archives = [];
|
||||
|
||||
foreach ( $included_post_types as $post_type ) {
|
||||
$post_archives[] = $post_type->name;
|
||||
}
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: Too hard to fix.
|
||||
if ( empty( $post_archives ) ) {
|
||||
$delete_query = $wpdb->prepare(
|
||||
"DELETE FROM $indexable_table
|
||||
WHERE object_type = 'post-type-archive'
|
||||
AND object_sub_type IS NOT NULL
|
||||
LIMIT %d",
|
||||
$limit
|
||||
);
|
||||
}
|
||||
else {
|
||||
// phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.ReplacementsWrongNumber -- Reason: we're passing an array instead.
|
||||
$delete_query = $wpdb->prepare(
|
||||
"DELETE FROM $indexable_table
|
||||
WHERE object_type = 'post-type-archive'
|
||||
AND object_sub_type IS NOT NULL
|
||||
AND object_sub_type NOT IN ( " . \implode( ', ', \array_fill( 0, \count( $post_archives ), '%s' ) ) . ' )
|
||||
LIMIT %d',
|
||||
\array_merge( $post_archives, [ $limit ] )
|
||||
);
|
||||
}
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: No relevant caches.
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery -- Reason: Most performant way.
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.NotPrepared -- Reason: Is it prepared already.
|
||||
return $wpdb->query( $delete_query );
|
||||
// phpcs:enable
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts indexables for non publicly viewable taxonomies.
|
||||
*
|
||||
* @return float|int
|
||||
*/
|
||||
public function count_indexables_for_non_publicly_viewable_taxonomies() {
|
||||
$included_taxonomies = $this->taxonomy->get_indexable_taxonomies();
|
||||
if ( empty( $included_taxonomies ) ) {
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', 'term' )
|
||||
->where_not_equal( 'object_sub_type', 'null' )
|
||||
->count();
|
||||
}
|
||||
else {
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', 'term' )
|
||||
->where_not_equal( 'object_sub_type', 'null' )
|
||||
->where_not_in( 'object_sub_type', $included_taxonomies )
|
||||
->count();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts indexables for non publicly viewable taxonomies.
|
||||
*
|
||||
* @return float|int
|
||||
*/
|
||||
public function count_indexables_for_non_publicly_post_type_archive_pages() {
|
||||
$included_post_types = $this->post_type->get_indexable_post_archives();
|
||||
|
||||
$post_archives = [];
|
||||
|
||||
foreach ( $included_post_types as $post_type ) {
|
||||
$post_archives[] = $post_type->name;
|
||||
}
|
||||
if ( empty( $post_archives ) ) {
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', 'post-type-archive' )
|
||||
->where_not_equal( 'object_sub_type', 'null' )
|
||||
->count();
|
||||
}
|
||||
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', 'post-type-archive' )
|
||||
->where_not_equal( 'object_sub_type', 'null' )
|
||||
->where_not_in( 'object_sub_type', $post_archives )
|
||||
->count();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up any user indexables when the author archives have been disabled.
|
||||
*
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return bool|int The number of deleted rows, false if the query fails.
|
||||
*/
|
||||
public function clean_indexables_for_authors_archive_disabled( $limit ) {
|
||||
global $wpdb;
|
||||
|
||||
if ( ! $this->author_archive->are_disabled() ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: Too hard to fix.
|
||||
$delete_query = $wpdb->prepare( "DELETE FROM $indexable_table WHERE object_type = 'user' LIMIT %d", $limit );
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: No relevant caches.
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery -- Reason: Most performant way.
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.NotPrepared -- Reason: Is it prepared already.
|
||||
return $wpdb->query( $delete_query );
|
||||
// phpcs:enable
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts the amount of author archive indexables if they are not disabled.
|
||||
*
|
||||
* @return float|int
|
||||
*/
|
||||
public function count_indexables_for_authors_archive_disabled() {
|
||||
if ( ! $this->author_archive->are_disabled() ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return $this
|
||||
->query()
|
||||
->where( 'object_type', 'user' )
|
||||
->count();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up any indexables that belong to users that have their author archives disabled.
|
||||
*
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return bool|int The number of deleted rows, false if the query fails.
|
||||
*/
|
||||
public function clean_indexables_for_authors_without_archive( $limit ) {
|
||||
global $wpdb;
|
||||
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
$author_archive_post_types = $this->author_archive->get_author_archive_post_types();
|
||||
$viewable_post_stati = \array_filter( \get_post_stati(), 'is_post_status_viewable' );
|
||||
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: Too hard to fix.
|
||||
// phpcs:disable WordPress.DB.PreparedSQLPlaceholders.ReplacementsWrongNumber -- Reason: we're passing an array instead.
|
||||
$delete_query = $wpdb->prepare(
|
||||
"DELETE FROM $indexable_table
|
||||
WHERE object_type = 'user'
|
||||
AND object_id NOT IN (
|
||||
SELECT DISTINCT post_author
|
||||
FROM $wpdb->posts
|
||||
WHERE post_type IN ( " . \implode( ', ', \array_fill( 0, \count( $author_archive_post_types ), '%s' ) ) . ' )
|
||||
AND post_status IN ( ' . \implode( ', ', \array_fill( 0, \count( $viewable_post_stati ), '%s' ) ) . ' )
|
||||
) LIMIT %d',
|
||||
\array_merge( $author_archive_post_types, $viewable_post_stati, [ $limit ] )
|
||||
);
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: No relevant caches.
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery -- Reason: Most performant way.
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.NotPrepared -- Reason: Is it prepared already.
|
||||
return $wpdb->query( $delete_query );
|
||||
// phpcs:enable
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts total amount of indexables for authors without archives.
|
||||
*
|
||||
* @return bool|int|\mysqli_result|resource|null
|
||||
*/
|
||||
public function count_indexables_for_authors_without_archive() {
|
||||
global $wpdb;
|
||||
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
$author_archive_post_types = $this->author_archive->get_author_archive_post_types();
|
||||
$viewable_post_stati = \array_filter( \get_post_stati(), 'is_post_status_viewable' );
|
||||
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: Too hard to fix.
|
||||
// phpcs:disable WordPress.DB.PreparedSQLPlaceholders.ReplacementsWrongNumber -- Reason: we're passing an array instead.
|
||||
$count_query = $wpdb->prepare(
|
||||
"SELECT count(*) FROM $indexable_table
|
||||
WHERE object_type = 'user'
|
||||
AND object_id NOT IN (
|
||||
SELECT DISTINCT post_author
|
||||
FROM $wpdb->posts
|
||||
WHERE post_type IN ( " . \implode( ', ', \array_fill( 0, \count( $author_archive_post_types ), '%s' ) ) . ' )
|
||||
AND post_status IN ( ' . \implode( ', ', \array_fill( 0, \count( $viewable_post_stati ), '%s' ) ) . ' )
|
||||
)',
|
||||
\array_merge( $author_archive_post_types, $viewable_post_stati )
|
||||
);
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: No relevant caches.
|
||||
// phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery -- Reason: Most performant way.
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.NotPrepared -- Reason: Is it prepared already.
|
||||
return $wpdb->get_col( $count_query )[0];
|
||||
// phpcs:enable
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes rows from the indexable table where the source is no longer there.
|
||||
*
|
||||
* @param string $source_table The source table which we need to check the indexables against.
|
||||
* @param string $source_identifier The identifier which the indexables are matched to.
|
||||
* @param string $object_type The indexable object type.
|
||||
* @param int $limit The limit we'll apply to the delete query.
|
||||
*
|
||||
* @return int|bool The number of rows that was deleted or false if the query failed.
|
||||
*/
|
||||
public function clean_indexables_for_object_type_and_source_table( $source_table, $source_identifier, $object_type, $limit ) {
|
||||
global $wpdb;
|
||||
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
$source_table = $wpdb->prefix . $source_table;
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: There is no unescaped user input.
|
||||
$query = $wpdb->prepare(
|
||||
"
|
||||
SELECT indexable_table.object_id
|
||||
FROM {$indexable_table} indexable_table
|
||||
LEFT JOIN {$source_table} AS source_table
|
||||
ON indexable_table.object_id = source_table.{$source_identifier}
|
||||
WHERE source_table.{$source_identifier} IS NULL
|
||||
AND indexable_table.object_id IS NOT NULL
|
||||
AND indexable_table.object_type = '{$object_type}'
|
||||
LIMIT %d",
|
||||
$limit
|
||||
);
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
$orphans = $wpdb->get_col( $query );
|
||||
|
||||
if ( empty( $orphans ) ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
return $wpdb->query( "DELETE FROM $indexable_table WHERE object_type = '{$object_type}' AND object_id IN( " . \implode( ',', $orphans ) . ' )' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts indexables for given source table + source identifier + object type.
|
||||
*
|
||||
* @param string $source_table The source table.
|
||||
* @param string $source_identifier The source identifier.
|
||||
* @param string $object_type The object type.
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function count_indexables_for_object_type_and_source_table( string $source_table, string $source_identifier, string $object_type ) {
|
||||
global $wpdb;
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
$source_table = $wpdb->prefix . $source_table;
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: There is no unescaped user input.
|
||||
$query = $wpdb->prepare(
|
||||
"
|
||||
SELECT count(*)
|
||||
FROM {$indexable_table} indexable_table
|
||||
LEFT JOIN {$source_table} AS source_table
|
||||
ON indexable_table.object_id = source_table.{$source_identifier}
|
||||
WHERE source_table.{$source_identifier} IS NULL
|
||||
AND indexable_table.object_id IS NOT NULL
|
||||
AND indexable_table.object_type = '{$object_type}'"
|
||||
);
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
return $wpdb->get_col( $query )[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans orphaned rows from a yoast table.
|
||||
*
|
||||
* @param string $table The table to clean up.
|
||||
* @param string $column The table column the cleanup will rely on.
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return int|bool The number of deleted rows, false if the query fails.
|
||||
*/
|
||||
public function cleanup_orphaned_from_table( $table, $column, $limit ) {
|
||||
global $wpdb;
|
||||
|
||||
$table = Model::get_table_name( $table );
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
// Warning: If this query is changed, make sure to update the query in cleanup_orphaned_from_table in Premium as well.
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: There is no unescaped user input.
|
||||
$query = $wpdb->prepare(
|
||||
"
|
||||
SELECT table_to_clean.{$column}
|
||||
FROM {$table} table_to_clean
|
||||
LEFT JOIN {$indexable_table} AS indexable_table
|
||||
ON table_to_clean.{$column} = indexable_table.id
|
||||
WHERE indexable_table.id IS NULL
|
||||
AND table_to_clean.{$column} IS NOT NULL
|
||||
LIMIT %d",
|
||||
$limit
|
||||
);
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
$orphans = $wpdb->get_col( $query );
|
||||
|
||||
if ( empty( $orphans ) ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
return $wpdb->query( "DELETE FROM $table WHERE {$column} IN( " . \implode( ',', $orphans ) . ' )' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts orphaned rows from a yoast table.
|
||||
*
|
||||
* @param string $table The table to clean up.
|
||||
* @param string $column The table column the cleanup will rely on.
|
||||
*
|
||||
* @return int|bool The number of deleted rows, false if the query fails.
|
||||
*/
|
||||
public function count_orphaned_from_table( string $table, string $column ) {
|
||||
global $wpdb;
|
||||
|
||||
$table = Model::get_table_name( $table );
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
// Warning: If this query is changed, make sure to update the query in cleanup_orphaned_from_table in Premium as well.
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: There is no unescaped user input.
|
||||
$query = $wpdb->prepare(
|
||||
"
|
||||
SELECT count(*)
|
||||
FROM {$table} table_to_clean
|
||||
LEFT JOIN {$indexable_table} AS indexable_table
|
||||
ON table_to_clean.{$column} = indexable_table.id
|
||||
WHERE indexable_table.id IS NULL
|
||||
AND table_to_clean.{$column} IS NOT NULL"
|
||||
);
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
return $wpdb->get_col( $query )[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the author_id of indexables which author_id is not in the wp_users table with the id of the reassingned
|
||||
* user.
|
||||
*
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return int|bool The number of updated rows, false if query to get data fails.
|
||||
*/
|
||||
public function update_indexables_author_to_reassigned( $limit ) {
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
$reassigned_authors_objs = $this->get_reassigned_authors( $limit );
|
||||
|
||||
if ( $reassigned_authors_objs === false ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return $this->update_indexable_authors( $reassigned_authors_objs, $limit );
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetches pairs of old_id -> new_id indexed by old_id.
|
||||
* By using the old_id (i.e. the id of the user that has been deleted) as key of the associative array, we can
|
||||
* easily compose an array of unique pairs of old_id -> new_id.
|
||||
*
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return int|bool The associative array with shape [ old_id => [ old_id, new_author ] ] or false if query to get
|
||||
* data fails.
|
||||
*/
|
||||
private function get_reassigned_authors( $limit ) {
|
||||
global $wpdb;
|
||||
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
$posts_table = $wpdb->posts;
|
||||
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: There is no unescaped user input.
|
||||
$query = $wpdb->prepare(
|
||||
"
|
||||
SELECT {$indexable_table}.author_id, {$posts_table}.post_author
|
||||
FROM {$indexable_table} JOIN {$posts_table} on {$indexable_table}.object_id = {$posts_table}.id
|
||||
WHERE object_type='post'
|
||||
AND {$indexable_table}.author_id <> {$posts_table}.post_author
|
||||
ORDER BY {$indexable_table}.author_id
|
||||
LIMIT %d",
|
||||
$limit
|
||||
);
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
return $wpdb->get_results( $query, \OBJECT_K );
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the indexable's author_id referring to a deleted author with the id of the reassigned user.
|
||||
*
|
||||
* @param array $reassigned_authors_objs The array of objects with shape [ old_id => [ old_id, new_id ] ].
|
||||
* @param int $limit The limit we'll apply to the queries.
|
||||
*
|
||||
* @return int|bool The associative array with shape [ old_id => [ old_id, new_author ] ] or false if query to get
|
||||
* data fails.
|
||||
*/
|
||||
private function update_indexable_authors( $reassigned_authors_objs, $limit ) {
|
||||
global $wpdb;
|
||||
|
||||
$indexable_table = Model::get_table_name( 'Indexable' );
|
||||
|
||||
// This is a workaround for the fact that the array_column function does not work on objects in PHP 5.6.
|
||||
$reassigned_authors_array = \array_map(
|
||||
function ( $obj ) {
|
||||
return (array) $obj;
|
||||
},
|
||||
$reassigned_authors_objs
|
||||
);
|
||||
|
||||
$reassigned_authors = \array_combine( \array_column( $reassigned_authors_array, 'author_id' ), \array_column( $reassigned_authors_array, 'post_author' ) );
|
||||
|
||||
foreach ( $reassigned_authors as $old_author_id => $new_author_id ) {
|
||||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Reason: There is no unescaped user input.
|
||||
$query = $wpdb->prepare(
|
||||
"
|
||||
UPDATE {$indexable_table}
|
||||
SET {$indexable_table}.author_id = {$new_author_id}
|
||||
WHERE {$indexable_table}.author_id = {$old_author_id}
|
||||
AND object_type='post'
|
||||
LIMIT %d",
|
||||
$limit
|
||||
);
|
||||
// phpcs:enable
|
||||
|
||||
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: Already prepared.
|
||||
$wpdb->query( $query );
|
||||
}
|
||||
|
||||
return count( $reassigned_authors );
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
<?php
|
||||
|
||||
namespace Yoast\WP\SEO\Repositories;
|
||||
|
||||
use Yoast\WP\Lib\Model;
|
||||
use Yoast\WP\Lib\ORM;
|
||||
use Yoast\WP\SEO\Builders\Indexable_Hierarchy_Builder;
|
||||
use Yoast\WP\SEO\Models\Indexable;
|
||||
|
||||
/**
|
||||
* Class Indexable_Hierarchy_Repository.
|
||||
*/
|
||||
class Indexable_Hierarchy_Repository {
|
||||
|
||||
/**
|
||||
* Represents the indexable hierarchy builder.
|
||||
*
|
||||
* @var Indexable_Hierarchy_Builder
|
||||
*/
|
||||
protected $builder;
|
||||
|
||||
/**
|
||||
* Sets the hierarchy builder.
|
||||
*
|
||||
* @required
|
||||
*
|
||||
* @param Indexable_Hierarchy_Builder $builder The indexable hierarchy builder.
|
||||
*/
|
||||
public function set_builder( Indexable_Hierarchy_Builder $builder ) {
|
||||
$this->builder = $builder;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes all ancestors for an indexable.
|
||||
*
|
||||
* @param int $indexable_id The indexable id.
|
||||
*
|
||||
* @return bool Whether or not the indexables were successfully deleted.
|
||||
*/
|
||||
public function clear_ancestors( $indexable_id ) {
|
||||
return $this->query()->where( 'indexable_id', $indexable_id )->delete_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds an ancestor to an indexable.
|
||||
*
|
||||
* @param int $indexable_id The indexable id.
|
||||
* @param int $ancestor_id The ancestor id.
|
||||
* @param int $depth The depth.
|
||||
*
|
||||
* @return bool Whether or not the ancestor was added successfully.
|
||||
*/
|
||||
public function add_ancestor( $indexable_id, $ancestor_id, $depth ) {
|
||||
$hierarchy = $this->query()->create(
|
||||
[
|
||||
'indexable_id' => $indexable_id,
|
||||
'ancestor_id' => $ancestor_id,
|
||||
'depth' => $depth,
|
||||
'blog_id' => \get_current_blog_id(),
|
||||
]
|
||||
);
|
||||
|
||||
return $hierarchy->save();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the ancestors. Create them when empty.
|
||||
*
|
||||
* @param Indexable $indexable The indexable to get the ancestors for.
|
||||
*
|
||||
* @return int[] The indexable id's of the ancestors in order of grandparent to child.
|
||||
*/
|
||||
public function find_ancestors( Indexable $indexable ) {
|
||||
$ancestors = $this->query()
|
||||
->select( 'ancestor_id' )
|
||||
->where( 'indexable_id', $indexable->id )
|
||||
->order_by_desc( 'depth' )
|
||||
->find_array();
|
||||
|
||||
if ( ! empty( $ancestors ) ) {
|
||||
if ( \count( $ancestors ) === 1 && $ancestors[0]['ancestor_id'] === '0' ) {
|
||||
return [];
|
||||
}
|
||||
return \wp_list_pluck( $ancestors, 'ancestor_id' );
|
||||
}
|
||||
|
||||
$indexable = $this->builder->build( $indexable );
|
||||
|
||||
return \wp_list_pluck( $indexable->ancestors, 'id' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds the children for a given indexable.
|
||||
*
|
||||
* @param Indexable $indexable The indexable to find the children for.
|
||||
*
|
||||
* @return array Array with indexable id's for the children.
|
||||
*/
|
||||
public function find_children( Indexable $indexable ) {
|
||||
$children = $this->query()
|
||||
->select( 'indexable_id' )
|
||||
->where( 'ancestor_id', $indexable->id )
|
||||
->find_array();
|
||||
|
||||
if ( empty( $children ) ) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return \wp_list_pluck( $children, 'indexable_id' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts a query for this repository.
|
||||
*
|
||||
* @return ORM
|
||||
*/
|
||||
public function query() {
|
||||
return Model::of_type( 'Indexable_Hierarchy' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds all the children by given ancestor id's.
|
||||
*
|
||||
* @param array $object_ids List of id's to get the children for.
|
||||
*
|
||||
* @return array List of indexable id's for the children.
|
||||
*/
|
||||
public function find_children_by_ancestor_ids( array $object_ids ) {
|
||||
if ( empty( $object_ids ) ) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$children = $this->query()
|
||||
->select( 'indexable_id' )
|
||||
->where_in( 'ancestor_id', $object_ids )
|
||||
->find_array();
|
||||
|
||||
if ( empty( $children ) ) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return \wp_list_pluck( $children, 'indexable_id' );
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,547 @@
|
||||
<?php
|
||||
|
||||
namespace Yoast\WP\SEO\Repositories;
|
||||
|
||||
use Psr\Log\LoggerInterface;
|
||||
use wpdb;
|
||||
use Yoast\WP\Lib\Model;
|
||||
use Yoast\WP\Lib\ORM;
|
||||
use Yoast\WP\SEO\Builders\Indexable_Builder;
|
||||
use Yoast\WP\SEO\Helpers\Current_Page_Helper;
|
||||
use Yoast\WP\SEO\Helpers\Indexable_Helper;
|
||||
use Yoast\WP\SEO\Loggers\Logger;
|
||||
use Yoast\WP\SEO\Models\Indexable;
|
||||
use Yoast\WP\SEO\Services\Indexables\Indexable_Version_Manager;
|
||||
|
||||
/**
|
||||
* Class Indexable_Repository.
|
||||
*/
|
||||
class Indexable_Repository {
|
||||
|
||||
/**
|
||||
* The indexable builder.
|
||||
*
|
||||
* @var Indexable_Builder
|
||||
*/
|
||||
private $builder;
|
||||
|
||||
/**
|
||||
* Represents the hierarchy repository.
|
||||
*
|
||||
* @var Indexable_Hierarchy_Repository
|
||||
*/
|
||||
protected $hierarchy_repository;
|
||||
|
||||
/**
|
||||
* The current page helper.
|
||||
*
|
||||
* @var Current_Page_Helper
|
||||
*/
|
||||
protected $current_page;
|
||||
|
||||
/**
|
||||
* The logger object.
|
||||
*
|
||||
* @var LoggerInterface
|
||||
*/
|
||||
protected $logger;
|
||||
|
||||
/**
|
||||
* The WordPress database.
|
||||
*
|
||||
* @var wpdb
|
||||
*/
|
||||
protected $wpdb;
|
||||
|
||||
/**
|
||||
* Represents the indexable helper.
|
||||
*
|
||||
* @var Indexable_Helper
|
||||
*/
|
||||
protected $indexable_helper;
|
||||
|
||||
/**
|
||||
* Checks if Indexables are up to date.
|
||||
*
|
||||
* @var Indexable_Version_Manager
|
||||
*/
|
||||
protected $version_manager;
|
||||
|
||||
/**
|
||||
* Returns the instance of this class constructed through the ORM Wrapper.
|
||||
*
|
||||
* @param Indexable_Builder $builder The indexable builder.
|
||||
* @param Current_Page_Helper $current_page The current post helper.
|
||||
* @param Logger $logger The logger.
|
||||
* @param Indexable_Hierarchy_Repository $hierarchy_repository The hierarchy repository.
|
||||
* @param wpdb $wpdb The WordPress database instance.
|
||||
* @param Indexable_Version_Manager $version_manager The indexable version manager.
|
||||
*/
|
||||
public function __construct(
|
||||
Indexable_Builder $builder,
|
||||
Current_Page_Helper $current_page,
|
||||
Logger $logger,
|
||||
Indexable_Hierarchy_Repository $hierarchy_repository,
|
||||
wpdb $wpdb,
|
||||
Indexable_Version_Manager $version_manager
|
||||
) {
|
||||
$this->builder = $builder;
|
||||
$this->current_page = $current_page;
|
||||
$this->logger = $logger;
|
||||
$this->hierarchy_repository = $hierarchy_repository;
|
||||
$this->wpdb = $wpdb;
|
||||
$this->version_manager = $version_manager;
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts a query for this repository.
|
||||
*
|
||||
* @return ORM
|
||||
*/
|
||||
public function query() {
|
||||
return Model::of_type( 'Indexable' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to find the indexable for the current WordPress page. Returns false if no indexable could be found.
|
||||
* This may be the result of the indexable not existing or of being unable to determine what type of page the
|
||||
* current page is.
|
||||
*
|
||||
* @return bool|Indexable The indexable. If no indexable is found returns an empty indexable. Returns false if there is a database error.
|
||||
*/
|
||||
public function for_current_page() {
|
||||
$indexable = false;
|
||||
|
||||
switch ( true ) {
|
||||
case $this->current_page->is_simple_page():
|
||||
$indexable = $this->find_by_id_and_type( $this->current_page->get_simple_page_id(), 'post' );
|
||||
break;
|
||||
case $this->current_page->is_home_static_page():
|
||||
$indexable = $this->find_by_id_and_type( $this->current_page->get_front_page_id(), 'post' );
|
||||
break;
|
||||
case $this->current_page->is_home_posts_page():
|
||||
$indexable = $this->find_for_home_page();
|
||||
break;
|
||||
case $this->current_page->is_term_archive():
|
||||
$indexable = $this->find_by_id_and_type( $this->current_page->get_term_id(), 'term' );
|
||||
break;
|
||||
case $this->current_page->is_date_archive():
|
||||
$indexable = $this->find_for_date_archive();
|
||||
break;
|
||||
case $this->current_page->is_search_result():
|
||||
$indexable = $this->find_for_system_page( 'search-result' );
|
||||
break;
|
||||
case $this->current_page->is_post_type_archive():
|
||||
$indexable = $this->find_for_post_type_archive( $this->current_page->get_queried_post_type() );
|
||||
break;
|
||||
case $this->current_page->is_author_archive():
|
||||
$indexable = $this->find_by_id_and_type( $this->current_page->get_author_id(), 'user' );
|
||||
break;
|
||||
case $this->current_page->is_404():
|
||||
$indexable = $this->find_for_system_page( '404' );
|
||||
break;
|
||||
}
|
||||
|
||||
if ( $indexable === false ) {
|
||||
return $this->query()->create(
|
||||
[
|
||||
'object_type' => 'unknown',
|
||||
'post_status' => 'unindexed',
|
||||
'version' => 1,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
return $indexable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves an indexable by its permalink.
|
||||
*
|
||||
* @param string $permalink The indexable permalink.
|
||||
*
|
||||
* @return bool|Indexable The indexable, false if none could be found.
|
||||
*/
|
||||
public function find_by_permalink( $permalink ) {
|
||||
$permalink_hash = \strlen( $permalink ) . ':' . \md5( $permalink );
|
||||
|
||||
// Find by both permalink_hash and permalink, permalink_hash is indexed so will be used first by the DB to optimize the query.
|
||||
return $this->query()
|
||||
->where( 'permalink_hash', $permalink_hash )
|
||||
->where( 'permalink', $permalink )
|
||||
->find_one();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves all the indexable instances of a certain object type.
|
||||
*
|
||||
* @param string $object_type The object type.
|
||||
*
|
||||
* @return Indexable[] The array with all the indexable instances of a certain object type.
|
||||
*/
|
||||
public function find_all_with_type( $object_type ) {
|
||||
/**
|
||||
* The array with all the indexable instances of a certain object type.
|
||||
*
|
||||
* @var Indexable[] $indexables
|
||||
*/
|
||||
$indexables = $this
|
||||
->query()
|
||||
->where( 'object_type', $object_type )
|
||||
->find_many();
|
||||
|
||||
return \array_map( [ $this, 'upgrade_indexable' ], $indexables );
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves all the indexable instances of a certain object subtype.
|
||||
*
|
||||
* @param string $object_type The object type.
|
||||
* @param string $object_sub_type The object subtype.
|
||||
*
|
||||
* @return Indexable[] The array with all the indexable instances of a certain object subtype.
|
||||
*/
|
||||
public function find_all_with_type_and_sub_type( $object_type, $object_sub_type ) {
|
||||
/**
|
||||
* The array with all the indexable instances of a certain object type and subtype.
|
||||
*
|
||||
* @var Indexable[] $indexables
|
||||
*/
|
||||
$indexables = $this
|
||||
->query()
|
||||
->where( 'object_type', $object_type )
|
||||
->where( 'object_sub_type', $object_sub_type )
|
||||
->find_many();
|
||||
|
||||
return \array_map( [ $this, 'upgrade_indexable' ], $indexables );
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the homepage indexable.
|
||||
*
|
||||
* @param bool $auto_create Optional. Create the indexable if it does not exist.
|
||||
*
|
||||
* @return bool|Indexable Instance of indexable.
|
||||
*/
|
||||
public function find_for_home_page( $auto_create = true ) {
|
||||
$indexable = \wp_cache_get( 'home-page', 'yoast-seo-indexables' );
|
||||
if ( ! $indexable ) {
|
||||
/**
|
||||
* Indexable instance.
|
||||
*
|
||||
* @var Indexable $indexable
|
||||
*/
|
||||
$indexable = $this->query()->where( 'object_type', 'home-page' )->find_one();
|
||||
|
||||
if ( $auto_create && ! $indexable ) {
|
||||
$indexable = $this->builder->build_for_home_page();
|
||||
}
|
||||
|
||||
$indexable = $this->upgrade_indexable( $indexable );
|
||||
|
||||
\wp_cache_set( 'home-page', $indexable, 'yoast-seo-indexables', ( 5 * \MINUTE_IN_SECONDS ) );
|
||||
}
|
||||
|
||||
return $indexable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the date archive indexable.
|
||||
*
|
||||
* @param bool $auto_create Optional. Create the indexable if it does not exist.
|
||||
*
|
||||
* @return bool|Indexable Instance of indexable.
|
||||
*/
|
||||
public function find_for_date_archive( $auto_create = true ) {
|
||||
/**
|
||||
* Indexable instance.
|
||||
*
|
||||
* @var Indexable $indexable
|
||||
*/
|
||||
$indexable = $this->query()->where( 'object_type', 'date-archive' )->find_one();
|
||||
|
||||
if ( $auto_create && ! $indexable ) {
|
||||
$indexable = $this->builder->build_for_date_archive();
|
||||
}
|
||||
|
||||
return $this->upgrade_indexable( $indexable );
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves an indexable for a post type archive.
|
||||
*
|
||||
* @param string $post_type The post type.
|
||||
* @param bool $auto_create Optional. Create the indexable if it does not exist.
|
||||
*
|
||||
* @return bool|Indexable The indexable, false if none could be found.
|
||||
*/
|
||||
public function find_for_post_type_archive( $post_type, $auto_create = true ) {
|
||||
/**
|
||||
* Indexable instance.
|
||||
*
|
||||
* @var Indexable $indexable
|
||||
*/
|
||||
$indexable = $this->query()
|
||||
->where( 'object_type', 'post-type-archive' )
|
||||
->where( 'object_sub_type', $post_type )
|
||||
->find_one();
|
||||
|
||||
if ( $auto_create && ! $indexable ) {
|
||||
$indexable = $this->builder->build_for_post_type_archive( $post_type );
|
||||
}
|
||||
|
||||
return $this->upgrade_indexable( $indexable );
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the indexable for a system page.
|
||||
*
|
||||
* @param string $object_sub_type The type of system page.
|
||||
* @param bool $auto_create Optional. Create the indexable if it does not exist.
|
||||
*
|
||||
* @return bool|Indexable Instance of indexable.
|
||||
*/
|
||||
public function find_for_system_page( $object_sub_type, $auto_create = true ) {
|
||||
/**
|
||||
* Indexable instance.
|
||||
*
|
||||
* @var Indexable $indexable
|
||||
*/
|
||||
$indexable = $this->query()
|
||||
->where( 'object_type', 'system-page' )
|
||||
->where( 'object_sub_type', $object_sub_type )
|
||||
->find_one();
|
||||
|
||||
if ( $auto_create && ! $indexable ) {
|
||||
$indexable = $this->builder->build_for_system_page( $object_sub_type );
|
||||
}
|
||||
|
||||
return $this->upgrade_indexable( $indexable );
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves an indexable by its ID and type.
|
||||
*
|
||||
* @param int $object_id The indexable object ID.
|
||||
* @param string $object_type The indexable object type.
|
||||
* @param bool $auto_create Optional. Create the indexable if it does not exist.
|
||||
*
|
||||
* @return bool|Indexable Instance of indexable.
|
||||
*/
|
||||
public function find_by_id_and_type( $object_id, $object_type, $auto_create = true ) {
|
||||
$indexable = $this->query()
|
||||
->where( 'object_id', $object_id )
|
||||
->where( 'object_type', $object_type )
|
||||
->find_one();
|
||||
|
||||
if ( $auto_create && ! $indexable ) {
|
||||
$indexable = $this->builder->build_for_id_and_type( $object_id, $object_type );
|
||||
}
|
||||
else {
|
||||
$indexable = $this->upgrade_indexable( $indexable );
|
||||
}
|
||||
|
||||
return $indexable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves multiple indexables at once by their id's and type.
|
||||
*
|
||||
* @param int[] $object_ids The array of indexable object id's.
|
||||
* @param string $object_type The indexable object type.
|
||||
* @param bool $auto_create Optional. Create the indexable if it does not exist.
|
||||
*
|
||||
* @return Indexable[] An array of indexables.
|
||||
*/
|
||||
public function find_by_multiple_ids_and_type( $object_ids, $object_type, $auto_create = true ) {
|
||||
if ( empty( $object_ids ) ) {
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents an array of indexable objects.
|
||||
*
|
||||
* @var Indexable[] $indexables
|
||||
*/
|
||||
$indexables = $this->query()
|
||||
->where_in( 'object_id', $object_ids )
|
||||
->where( 'object_type', $object_type )
|
||||
->find_many();
|
||||
|
||||
if ( $auto_create ) {
|
||||
$indexables_available = [];
|
||||
foreach ( $indexables as $indexable ) {
|
||||
$indexables_available[] = $indexable->object_id;
|
||||
}
|
||||
|
||||
$indexables_to_create = \array_diff( $object_ids, $indexables_available );
|
||||
|
||||
foreach ( $indexables_to_create as $indexable_to_create ) {
|
||||
$indexables[] = $this->builder->build_for_id_and_type( $indexable_to_create, $object_type );
|
||||
}
|
||||
}
|
||||
|
||||
return \array_map( [ $this, 'upgrade_indexable' ], $indexables );
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds the indexables by id's.
|
||||
*
|
||||
* @param array $indexable_ids The indexable id's.
|
||||
*
|
||||
* @return Indexable[] The found indexables.
|
||||
*/
|
||||
public function find_by_ids( array $indexable_ids ) {
|
||||
if ( empty( $indexable_ids ) ) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$indexables = $this
|
||||
->query()
|
||||
->where_in( 'id', $indexable_ids )
|
||||
->find_many();
|
||||
|
||||
return \array_map( [ $this, 'upgrade_indexable' ], $indexables );
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all ancestors of a given indexable.
|
||||
*
|
||||
* @param Indexable $indexable The indexable to find the ancestors of.
|
||||
*
|
||||
* @return Indexable[] All ancestors of the given indexable.
|
||||
*/
|
||||
public function get_ancestors( Indexable $indexable ) {
|
||||
// If we've already set ancestors on the indexable no need to get them again.
|
||||
if ( \is_array( $indexable->ancestors ) && ! empty( $indexable->ancestors ) ) {
|
||||
return \array_map( [ $this, 'upgrade_indexable' ], $indexable->ancestors );
|
||||
}
|
||||
|
||||
$indexable_ids = $this->hierarchy_repository->find_ancestors( $indexable );
|
||||
|
||||
// If we've set ancestors on the indexable because we had to build them to find them.
|
||||
if ( \is_array( $indexable->ancestors ) && ! empty( $indexable->ancestors ) ) {
|
||||
return \array_map( [ $this, 'upgrade_indexable' ], $indexable->ancestors );
|
||||
}
|
||||
|
||||
if ( empty( $indexable_ids ) ) {
|
||||
return [];
|
||||
}
|
||||
|
||||
if ( $indexable_ids[0] === 0 && \count( $indexable_ids ) === 1 ) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$indexables = $this->query()
|
||||
->where_in( 'id', $indexable_ids )
|
||||
->order_by_expr( 'FIELD(id,' . \implode( ',', $indexable_ids ) . ')' )
|
||||
->find_many();
|
||||
|
||||
return \array_map( [ $this, 'upgrade_indexable' ], $indexables );
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all subpages with a given post_parent.
|
||||
*
|
||||
* @param int $post_parent The post parent.
|
||||
* @param array $exclude_ids The id's to exclude.
|
||||
*
|
||||
* @return Indexable[] array of indexables.
|
||||
*/
|
||||
public function get_subpages_by_post_parent( $post_parent, $exclude_ids = [] ) {
|
||||
$query = $this->query()
|
||||
->where( 'post_parent', $post_parent )
|
||||
->where( 'object_type', 'post' )
|
||||
->where( 'post_status', 'publish' );
|
||||
|
||||
if ( ! empty( $exclude_ids ) ) {
|
||||
$query->where_not_in( 'object_id', $exclude_ids );
|
||||
}
|
||||
return $query->find_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the incoming link count for an indexable without first fetching it.
|
||||
*
|
||||
* @param int $indexable_id The indexable id.
|
||||
* @param int $count The incoming link count.
|
||||
*
|
||||
* @return bool Whether or not the update was succeful.
|
||||
*/
|
||||
public function update_incoming_link_count( $indexable_id, $count ) {
|
||||
return (bool) $this->query()
|
||||
->set( 'incoming_link_count', $count )
|
||||
->where( 'id', $indexable_id )
|
||||
->update_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that the given indexable has a permalink.
|
||||
*
|
||||
* Will be deprecated in 17.3 - Use upgrade_indexable instead.
|
||||
*
|
||||
* @codeCoverageIgnore
|
||||
*
|
||||
* @param Indexable $indexable The indexable.
|
||||
*
|
||||
* @return bool|Indexable The indexable.
|
||||
*/
|
||||
public function ensure_permalink( $indexable ) {
|
||||
// @phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- self::class is safe.
|
||||
// @phpcs:ignore Squiz.PHP.CommentedOutCode.Found
|
||||
// _deprecated_function( __METHOD__, 'Yoast SEO 17.3', self::class . '::upgrade_indexable' );
|
||||
|
||||
return $this->upgrade_indexable( $indexable );
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if an Indexable is outdated, and rebuilds it when necessary.
|
||||
*
|
||||
* @param Indexable $indexable The indexable.
|
||||
*
|
||||
* @return Indexable The indexable.
|
||||
*/
|
||||
public function upgrade_indexable( $indexable ) {
|
||||
if ( $this->version_manager->indexable_needs_upgrade( $indexable ) ) {
|
||||
$indexable = $this->builder->build( $indexable );
|
||||
}
|
||||
return $indexable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resets the permalinks of the passed object type and subtype.
|
||||
*
|
||||
* @param string|null $type The type of the indexable. Can be null.
|
||||
* @param string|null $subtype The subtype. Can be null.
|
||||
*
|
||||
* @return int|bool The number of permalinks changed if the query was succesful. False otherwise.
|
||||
*/
|
||||
public function reset_permalink( $type = null, $subtype = null ) {
|
||||
$query = $this->query()->set(
|
||||
[
|
||||
'permalink' => null,
|
||||
'permalink_hash' => null,
|
||||
'version' => 0,
|
||||
]
|
||||
);
|
||||
|
||||
if ( $type !== null ) {
|
||||
$query->where( 'object_type', $type );
|
||||
}
|
||||
|
||||
if ( $type !== null && $subtype !== null ) {
|
||||
$query->where( 'object_sub_type', $subtype );
|
||||
}
|
||||
|
||||
return $query->update_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the total number of stored indexables.
|
||||
*
|
||||
* @return int The total number of stored indexables.
|
||||
*/
|
||||
public function get_total_number_of_indexables() {
|
||||
return $this->query()->count();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
<?php
|
||||
|
||||
namespace Yoast\WP\SEO\Repositories;
|
||||
|
||||
use Yoast\WP\Lib\Model;
|
||||
use Yoast\WP\Lib\ORM;
|
||||
use Yoast\WP\SEO\Models\Primary_Term;
|
||||
|
||||
/**
|
||||
* Class Primary_Term_Repository.
|
||||
*/
|
||||
class Primary_Term_Repository {
|
||||
|
||||
/**
|
||||
* Starts a query for this repository.
|
||||
*
|
||||
* @return ORM
|
||||
*/
|
||||
public function query() {
|
||||
return Model::of_type( 'Primary_Term' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves a primary term by a post ID and taxonomy.
|
||||
*
|
||||
* @param int $post_id The post the indexable is based upon.
|
||||
* @param string $taxonomy The taxonomy the indexable belongs to.
|
||||
* @param bool $auto_create Optional. Creates an indexable if it does not exist yet.
|
||||
*
|
||||
* @return Primary_Term|null Instance of a primary term.
|
||||
*/
|
||||
public function find_by_post_id_and_taxonomy( $post_id, $taxonomy, $auto_create = true ) {
|
||||
/**
|
||||
* Instance of the primary term.
|
||||
*
|
||||
* @var Primary_Term $primary_term
|
||||
*/
|
||||
$primary_term = $this->query()
|
||||
->where( 'post_id', $post_id )
|
||||
->where( 'taxonomy', $taxonomy )
|
||||
->find_one();
|
||||
|
||||
if ( $auto_create && ! $primary_term ) {
|
||||
$primary_term = $this->query()->create();
|
||||
}
|
||||
|
||||
return $primary_term;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,210 @@
|
||||
<?php
|
||||
|
||||
namespace Yoast\WP\SEO\Repositories;
|
||||
|
||||
use Yoast\WP\Lib\Model;
|
||||
use Yoast\WP\Lib\ORM;
|
||||
use Yoast\WP\SEO\Models\SEO_Links;
|
||||
|
||||
/**
|
||||
* Class SEO_Links_Repository.
|
||||
*/
|
||||
class SEO_Links_Repository {
|
||||
|
||||
/**
|
||||
* Starts a query for this repository.
|
||||
*
|
||||
* @return ORM
|
||||
*/
|
||||
public function query() {
|
||||
return Model::of_type( 'SEO_Links' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds all SEO Links by post ID.
|
||||
*
|
||||
* @param int $post_id The post ID.
|
||||
*
|
||||
* @return SEO_Links[] The SEO Links.
|
||||
*/
|
||||
public function find_all_by_post_id( $post_id ) {
|
||||
return $this->query()
|
||||
->where( 'post_id', $post_id )
|
||||
->find_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds all SEO Links by indexable ID.
|
||||
*
|
||||
* @param int $indexable_id The indexable ID.
|
||||
*
|
||||
* @return SEO_Links[] The SEO Links.
|
||||
*/
|
||||
public function find_all_by_indexable_id( $indexable_id ) {
|
||||
return $this->query()
|
||||
->where( 'indexable_id', $indexable_id )
|
||||
->find_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves an SEO Link by url.
|
||||
*
|
||||
* @param string $url The SEO Link's url.
|
||||
*
|
||||
* @return SEO_Links|false The SEO Link, or false if none found.
|
||||
*/
|
||||
public function find_one_by_url( $url ) {
|
||||
return $this->query()
|
||||
->select( 'target_post_id' )
|
||||
->where( 'url', $url )
|
||||
->find_one();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves all SEO Links by target post ID.
|
||||
*
|
||||
* @param string $target_post_id The SEO Link's target post ID.
|
||||
*
|
||||
* @return SEO_Links[] The SEO Links.
|
||||
*/
|
||||
public function find_all_by_target_post_id( $target_post_id ) {
|
||||
return $this->query()
|
||||
->where( 'target_post_id', $target_post_id )
|
||||
->find_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the ID of the target indexable of a link.
|
||||
*
|
||||
* @param int $link_id The ID of the link to be updated.
|
||||
* @param int $target_indexable_id The ID of the target indexable.
|
||||
*
|
||||
* @return bool Whether or not the update was succeful.
|
||||
*/
|
||||
public function update_target_indexable_id( $link_id, $target_indexable_id ) {
|
||||
return (bool) $this->query()
|
||||
->set( 'target_indexable_id', $target_indexable_id )
|
||||
->where( 'id', $link_id )
|
||||
->update_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears all SEO Links by post ID.
|
||||
*
|
||||
* @param int $post_id The post ID.
|
||||
*
|
||||
* @return bool Whether or not the delete was succesfull.
|
||||
*/
|
||||
public function delete_all_by_post_id( $post_id ) {
|
||||
return $this->query()
|
||||
->where( 'post_id', $post_id )
|
||||
->delete_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears all SEO Links by post ID where the indexable id is null.
|
||||
*
|
||||
* @param int $post_id The post ID.
|
||||
*
|
||||
* @return bool Whether or not the delete was succesfull.
|
||||
*/
|
||||
public function delete_all_by_post_id_where_indexable_id_null( $post_id ) {
|
||||
return $this->query()
|
||||
->where( 'post_id', $post_id )
|
||||
->where_null( 'indexable_id' )
|
||||
->delete_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears all SEO Links by indexable ID.
|
||||
*
|
||||
* @param int $indexable_id The indexable ID.
|
||||
*
|
||||
* @return bool Whether or not the delete was succesfull.
|
||||
*/
|
||||
public function delete_all_by_indexable_id( $indexable_id ) {
|
||||
return $this->query()
|
||||
->where( 'indexable_id', $indexable_id )
|
||||
->delete_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns incoming link counts for a number of posts.
|
||||
*
|
||||
* @param array $post_ids The post IDs.
|
||||
*
|
||||
* @return array An array of associative arrays, each containing a post id and incoming property.
|
||||
*/
|
||||
public function get_incoming_link_counts_for_post_ids( $post_ids ) {
|
||||
return $this->query()
|
||||
->select_expr( 'COUNT( id )', 'incoming' )
|
||||
->select( 'target_post_id', 'post_id' )
|
||||
->where_in( 'target_post_id', $post_ids )
|
||||
->group_by( 'target_post_id' )
|
||||
->find_array();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns incoming link counts for a number of indexables.
|
||||
*
|
||||
* @param array $indexable_ids The indexable IDs.
|
||||
*
|
||||
* @return array An array of associative arrays, each containing a indexable id and incoming property.
|
||||
*/
|
||||
public function get_incoming_link_counts_for_indexable_ids( $indexable_ids ) {
|
||||
// This query only returns ID's with an incoming count > 0. We need to restore any ID's with 0 incoming links later.
|
||||
$indexable_counts = $this->query()
|
||||
->select_expr( 'COUNT( id )', 'incoming' )
|
||||
->select( 'target_indexable_id' )
|
||||
->where_in( 'target_indexable_id', $indexable_ids )
|
||||
->group_by( 'target_indexable_id' )
|
||||
->find_array();
|
||||
|
||||
// If the above query fails, do not update anything.
|
||||
if ( ! \is_array( $indexable_counts ) ) {
|
||||
return [];
|
||||
}
|
||||
|
||||
// Get all ID's returned from the query and set them as keys for easy access.
|
||||
$returned_ids = \array_flip( \array_column( $indexable_counts, 'target_indexable_id' ) );
|
||||
|
||||
// Loop over the original ID's and search them in the returned ID's. If they don't exist, add them with an incoming count of 0.
|
||||
foreach ( $indexable_ids as $id ) {
|
||||
// Cast the ID to string, as the arrays only contain stringified versions of the ID.
|
||||
$id = \strval( $id );
|
||||
if ( isset( $returned_ids[ $id ] ) === false ) {
|
||||
$indexable_counts[] = [
|
||||
'incoming' => '0',
|
||||
'target_indexable_id' => $id,
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
return $indexable_counts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes all seo links for the given ids.
|
||||
*
|
||||
* @param int[] $ids The seo link ids.
|
||||
*
|
||||
* @return bool Whether or not the delete was succesfull.
|
||||
*/
|
||||
public function delete_many_by_id( $ids ) {
|
||||
return $this->query()
|
||||
->where_in( 'id', $ids )
|
||||
->delete_many();
|
||||
}
|
||||
|
||||
/**
|
||||
* Insert multiple seo links.
|
||||
*
|
||||
* @param SEO_Links[] $links The seo links to be inserted.
|
||||
*
|
||||
* @return bool Whether or not the insert was succesfull.
|
||||
*/
|
||||
public function insert_many( $links ) {
|
||||
return $this->query()
|
||||
->insert_many( $links );
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user