├── .nvmrc
├── admin-functions.php
├── common-functions.php
├── compat
    ├── jetpack-functions.php
    └── wpml-functions.php
├── composer.json
├── css
    ├── duplicate-post-options.css
    └── duplicate-post.css
├── duplicate-post.php
├── duplicate_post_yoast_icon-125x125.png
├── gpl-2.0.txt
├── js
    └── src
    │   ├── duplicate-post-edit-script.js
    │   ├── duplicate-post-elementor.js
    │   ├── duplicate-post-functions.js
    │   ├── duplicate-post-options.js
    │   ├── duplicate-post-quick-edit-script.js
    │   ├── duplicate-post-strings.js
    │   └── helpers
    │       └── safe-create-interpolate-element.js
├── options.php
├── readme.txt
├── src
    ├── admin
    │   ├── options-form-generator.php
    │   ├── options-inputs.php
    │   ├── options-page.php
    │   ├── options.php
    │   └── views
    │   │   └── options.php
    ├── duplicate-post.php
    ├── handlers
    │   ├── bulk-handler.php
    │   ├── check-changes-handler.php
    │   ├── handler.php
    │   ├── link-handler.php
    │   └── save-post-handler.php
    ├── permissions-helper.php
    ├── post-duplicator.php
    ├── post-republisher.php
    ├── revisions-migrator.php
    ├── ui
    │   ├── admin-bar.php
    │   ├── asset-manager.php
    │   ├── block-editor.php
    │   ├── bulk-actions.php
    │   ├── classic-editor.php
    │   ├── column.php
    │   ├── link-builder.php
    │   ├── metabox.php
    │   ├── newsletter.php
    │   ├── post-states.php
    │   ├── row-actions.php
    │   └── user-interface.php
    ├── utils.php
    └── watchers
    │   ├── bulk-actions-watcher.php
    │   ├── copied-post-watcher.php
    │   ├── link-actions-watcher.php
    │   ├── original-post-watcher.php
    │   ├── republished-post-watcher.php
    │   └── watchers.php
└── yarn.lock


/.nvmrc:
--------------------------------------------------------------------------------
1 | 16
2 | 


--------------------------------------------------------------------------------
/common-functions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Common functions.
  4 |  *
  5 |  * @package Yoast\WP\Duplicate_Post
  6 |  * @since   2.0
  7 |  */
  8 | 
  9 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
 10 | use Yoast\WP\Duplicate_Post\UI\Link_Builder;
 11 | use Yoast\WP\Duplicate_Post\Utils;
 12 | 
 13 | /**
 14 |  * Tests if post type is enabled to be copied.
 15 |  *
 16 |  * @param string $post_type The post type to check.
 17 |  * @return bool
 18 |  */
 19 | function duplicate_post_is_post_type_enabled( $post_type ) {
 20 | 	$duplicate_post_types_enabled = get_option( 'duplicate_post_types_enabled', [ 'post', 'page' ] );
 21 | 	if ( ! is_array( $duplicate_post_types_enabled ) ) {
 22 | 		$duplicate_post_types_enabled = [ $duplicate_post_types_enabled ];
 23 | 	}
 24 | 
 25 | 	/** This filter is documented in src/permissions-helper.php */
 26 | 	$duplicate_post_types_enabled = apply_filters( 'duplicate_post_enabled_post_types', $duplicate_post_types_enabled );
 27 | 	return in_array( $post_type, $duplicate_post_types_enabled, true );
 28 | }
 29 | 
 30 | /**
 31 |  * Template tag to retrieve/display duplicate post link for post.
 32 |  *
 33 |  * @param int    $id      Optional. Post ID.
 34 |  * @param string $context Optional, default to display. How to write the '&', defaults to '&amp;'.
 35 |  * @param bool   $draft   Optional, default to true.
 36 |  * @return string
 37 |  */
 38 | function duplicate_post_get_clone_post_link( $id = 0, $context = 'display', $draft = true ) {
 39 | 	$post = get_post( $id );
 40 | 	if ( ! $post ) {
 41 | 		return '';
 42 | 	}
 43 | 
 44 | 	$link_builder       = new Link_Builder();
 45 | 	$permissions_helper = new Permissions_Helper();
 46 | 
 47 | 	if ( ! $permissions_helper->should_links_be_displayed( $post ) ) {
 48 | 		return '';
 49 | 	}
 50 | 
 51 | 	if ( $draft ) {
 52 | 		return $link_builder->build_new_draft_link( $post, $context );
 53 | 	}
 54 | 	else {
 55 | 		return $link_builder->build_clone_link( $post, $context );
 56 | 	}
 57 | }
 58 | 
 59 | /**
 60 |  * Displays duplicate post link for post.
 61 |  *
 62 |  * @param string|null $link   Optional. Anchor text.
 63 |  * @param string      $before Optional. Display before edit link.
 64 |  * @param string      $after  Optional. Display after edit link.
 65 |  * @param int         $id     Optional. Post ID.
 66 |  *
 67 |  * @return void
 68 |  */
 69 | function duplicate_post_clone_post_link( $link = null, $before = '', $after = '', $id = 0 ) {
 70 | 	$post = get_post( $id );
 71 | 	if ( ! $post ) {
 72 | 		return;
 73 | 	}
 74 | 
 75 | 	$url = duplicate_post_get_clone_post_link( $post->ID );
 76 | 	if ( ! $url ) {
 77 | 		return;
 78 | 	}
 79 | 
 80 | 	if ( $link === null ) {
 81 | 		$link = __( 'Copy to a new draft', 'duplicate-post' );
 82 | 	}
 83 | 
 84 | 	$link = '<a class="post-clone-link" href="' . esc_url( $url ) . '">' . esc_html( $link ) . '</a>';
 85 | 
 86 | 	/**
 87 | 	 * Filter on the clone link HTML.
 88 | 	 *
 89 | 	 * @param string $link The full HTML tag of the link.
 90 | 	 * @param int    $ID   The ID of the post.
 91 | 	 *
 92 | 	 * @return string
 93 | 	 */
 94 | 	echo $before . apply_filters( 'duplicate_post_clone_post_link', $link, $post->ID ) . $after; // phpcs:ignore WordPress.Security.EscapeOutput
 95 | }
 96 | 
 97 | /**
 98 |  * Gets the original post.
 99 |  *
100 |  * @param int|null $post   Optional. Post ID or Post object.
101 |  * @param string   $output Optional, default is Object. Either OBJECT, ARRAY_A, or ARRAY_N.
102 |  * @return mixed Post data.
103 |  */
104 | function duplicate_post_get_original( $post = null, $output = OBJECT ) {
105 | 	return Utils::get_original( $post, $output );
106 | }
107 | 


--------------------------------------------------------------------------------
/compat/jetpack-functions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * JetPack compatibility functions.
 4 |  *
 5 |  * @package Yoast\WP\Duplicate_Post
 6 |  * @since   3.2
 7 |  */
 8 | 
 9 | add_action( 'admin_init', 'duplicate_post_jetpack_init' );
10 | 
11 | /**
12 |  * Add handlers for JetPack compatibility.
13 |  *
14 |  * @return void
15 |  */
16 | function duplicate_post_jetpack_init() {
17 | 	add_filter( 'duplicate_post_excludelist_filter', 'duplicate_post_jetpack_add_to_excludelist', 10, 1 );
18 | 
19 | 	if ( class_exists( 'WPCom_Markdown' ) ) {
20 | 		add_action( 'duplicate_post_pre_copy', 'duplicate_post_jetpack_disable_markdown', 10 );
21 | 		add_action( 'duplicate_post_post_copy', 'duplicate_post_jetpack_enable_markdown', 10 );
22 | 	}
23 | }
24 | 
25 | /**
26 |  * Add some JetPack custom field wildcards to be filtered out when cloning.
27 |  *
28 |  * @param array $meta_excludelist The array containing the blacklist of custom fields.
29 |  * @return array
30 |  */
31 | function duplicate_post_jetpack_add_to_excludelist( $meta_excludelist ) {
32 | 	$meta_excludelist[] = '_wpas*'; // Jetpack Publicize.
33 | 	$meta_excludelist[] = '_publicize*'; // Jetpack Publicize.
34 | 
35 | 	$meta_excludelist[] = '_jetpack*'; // Jetpack Subscriptions etc.
36 | 
37 | 	return $meta_excludelist;
38 | }
39 | 
40 | /**
41 |  * Disable Markdown.
42 |  *
43 |  * To be called before copy.
44 |  *
45 |  * @return void
46 |  */
47 | function duplicate_post_jetpack_disable_markdown() {
48 | 	WPCom_Markdown::get_instance()->unload_markdown_for_posts();
49 | }
50 | 
51 | /**
52 |  * Enaable Markdown.
53 |  *
54 |  * To be called after copy.
55 |  *
56 |  * @return void
57 |  */
58 | function duplicate_post_jetpack_enable_markdown() {
59 | 	WPCom_Markdown::get_instance()->load_markdown_for_posts();
60 | }
61 | 


--------------------------------------------------------------------------------
/compat/wpml-functions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * WPML compatibility functions
  4 |  *
  5 |  * @global array $duplicated_posts Array to store the posts being duplicated.
  6 |  *
  7 |  * @package Yoast\WP\Duplicate_Post
  8 |  * @since   3.2
  9 |  */
 10 | 
 11 | add_action( 'admin_init', 'duplicate_post_wpml_init' );
 12 | 
 13 | /**
 14 |  * Add handlers for WPML compatibility.
 15 |  *
 16 |  * @return void
 17 |  */
 18 | function duplicate_post_wpml_init() {
 19 | 	if ( defined( 'ICL_SITEPRESS_VERSION' ) ) {
 20 | 		add_action( 'dp_duplicate_page', 'duplicate_post_wpml_copy_translations', 10, 3 );
 21 | 		add_action( 'dp_duplicate_post', 'duplicate_post_wpml_copy_translations', 10, 3 );
 22 | 		add_action( 'shutdown', 'duplicate_wpml_string_packages', 11 );
 23 | 	}
 24 | }
 25 | 
 26 | global $duplicated_posts;
 27 | 
 28 | // phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals -- Reason: Renaming a global variable is a BC break.
 29 | $duplicated_posts = [];
 30 | 
 31 | /**
 32 |  * Copy post translations.
 33 |  *
 34 |  * @global SitePress $sitepress        Instance of the Main WPML class.
 35 |  * @global array     $duplicated_posts Array of duplicated posts.
 36 |  *
 37 |  * @param int     $post_id ID of the copy.
 38 |  * @param WP_Post $post    Original post object.
 39 |  * @param string  $status  Status of the new post.
 40 |  *
 41 |  * @return void
 42 |  */
 43 | function duplicate_post_wpml_copy_translations( $post_id, $post, $status = '' ) {
 44 | 	global $sitepress;
 45 | 	global $duplicated_posts;
 46 | 
 47 | 	remove_action( 'dp_duplicate_page', 'duplicate_post_wpml_copy_translations', 10 );
 48 | 	remove_action( 'dp_duplicate_post', 'duplicate_post_wpml_copy_translations', 10 );
 49 | 
 50 | 	$current_language = $sitepress->get_current_language();
 51 | 	$trid             = $sitepress->get_element_trid( $post->ID );
 52 | 	if ( ! empty( $trid ) ) {
 53 | 		$translations = $sitepress->get_element_translations( $trid );
 54 | 		$new_trid     = $sitepress->get_element_trid( $post_id );
 55 | 		foreach ( $translations as $code => $details ) {
 56 | 			if ( $code !== $current_language ) {
 57 | 				if ( $details->element_id ) {
 58 | 					$translation = get_post( $details->element_id );
 59 | 					if ( ! $translation ) {
 60 | 						continue;
 61 | 					}
 62 | 					$new_post_id = duplicate_post_create_duplicate( $translation, $status );
 63 | 					if ( ! is_wp_error( $new_post_id ) ) {
 64 | 						$sitepress->set_element_language_details(
 65 | 							$new_post_id,
 66 | 							'post_' . $translation->post_type,
 67 | 							$new_trid,
 68 | 							$code,
 69 | 							$current_language
 70 | 						);
 71 | 					}
 72 | 				}
 73 | 			}
 74 | 		}
 75 | 
 76 | 		// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals -- Reason: see above.
 77 | 		$duplicated_posts[ $post->ID ] = $post_id;
 78 | 	}
 79 | }
 80 | 
 81 | /**
 82 |  * Duplicate string packages.
 83 |  *
 84 |  * @global array() $duplicated_posts Array of duplicated posts.
 85 |  *
 86 |  * @return void
 87 |  */
 88 | function duplicate_wpml_string_packages() { // phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals -- Reason: renaming the function would be a BC-break.
 89 | 	global $duplicated_posts;
 90 | 
 91 | 	foreach ( $duplicated_posts as $original_post_id => $duplicate_post_id ) {
 92 | 		// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals -- Reason: using WPML native filter.
 93 | 		$original_string_packages = apply_filters( 'wpml_st_get_post_string_packages', false, $original_post_id );
 94 | 
 95 | 		// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals -- Reason: using WPML native filter.
 96 | 		$new_string_packages = apply_filters( 'wpml_st_get_post_string_packages', false, $duplicate_post_id );
 97 | 
 98 | 		if ( is_array( $original_string_packages ) ) {
 99 | 			foreach ( $original_string_packages as $original_string_package ) {
100 | 				$translated_original_strings = $original_string_package->get_translated_strings( [] );
101 | 
102 | 				foreach ( $new_string_packages as $new_string_package ) {
103 | 					$cache = new WPML_WP_Cache( 'WPML_Package' );
104 | 					$cache->flush_group_cache();
105 | 					$new_strings = $new_string_package->get_package_strings();
106 | 					foreach ( $new_strings as $new_string ) {
107 | 
108 | 						if ( isset( $translated_original_strings[ $new_string->name ] ) ) {
109 | 							foreach ( $translated_original_strings[ $new_string->name ] as $language => $translated_string ) {
110 | 
111 | 								do_action(
112 | 									// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals -- Reason: using WPML native filter.
113 | 									'wpml_add_string_translation',
114 | 									$new_string->id,
115 | 									$language,
116 | 									$translated_string['value'],
117 | 									$translated_string['status']
118 | 								);
119 | 							}
120 | 						}
121 | 					}
122 | 				}
123 | 			}
124 | 		}
125 | 	}
126 | }
127 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"name": "yoast/duplicate-post",
  3 | 	"description": "The go-to tool for cloning posts and pages, including the powerful Rewrite & Republish feature.",
  4 | 	"license": "GPL-2.0-or-later",
  5 | 	"type": "wordpress-plugin",
  6 | 	"keywords": [
  7 | 		"wordpress",
  8 | 		"post",
  9 | 		"copy",
 10 | 		"clone"
 11 | 	],
 12 | 	"authors": [
 13 | 		{
 14 | 			"name": "Enrico Battocchi & Team Yoast",
 15 | 			"email": "support@yoast.com",
 16 | 			"homepage": "https://yoast.com"
 17 | 		}
 18 | 	],
 19 | 	"homepage": "https://wordpress.org/plugins/duplicate-post/",
 20 | 	"support": {
 21 | 		"issues": "https://github.com/Yoast/duplicate-post/issues",
 22 | 		"forum": "https://wordpress.org/support/plugin/duplicate-post",
 23 | 		"source": "https://github.com/Yoast/duplicate-post",
 24 | 		"security": "https://yoast.com/security-program/"
 25 | 	},
 26 | 	"require": {
 27 | 		"php": "^7.4 || ^8.0",
 28 | 		"composer/installers": "^1.12.0 || ^2.0"
 29 | 	},
 30 | 	"require-dev": {
 31 | 		"roave/security-advisories": "dev-master",
 32 | 		"yoast/wp-test-utils": "^1.2.0",
 33 | 		"yoast/yoastcs": "^3.2.0"
 34 | 	},
 35 | 	"autoload": {
 36 | 		"classmap": [
 37 | 			"src/"
 38 | 		]
 39 | 	},
 40 | 	"autoload-dev": {
 41 | 		"psr-4": {
 42 | 			"Yoast\\WP\\Duplicate_Post\\Tests\\": "tests/"
 43 | 		},
 44 | 		"classmap": [
 45 | 			"config/"
 46 | 		]
 47 | 	},
 48 | 	"config": {
 49 | 		"allow-plugins": {
 50 | 			"composer/installers": true,
 51 | 			"dealerdirect/phpcodesniffer-composer-installer": true
 52 | 		},
 53 | 		"classmap-authoritative": true,
 54 | 		"lock": false
 55 | 	},
 56 | 	"scripts": {
 57 | 		"lint": [
 58 | 			"@php ./vendor/php-parallel-lint/php-parallel-lint/parallel-lint . -e php --show-deprecated --exclude vendor --exclude node_modules --exclude .git"
 59 | 		],
 60 | 		"cs": [
 61 | 			"Yoast\\WP\\Duplicate_Post\\Config\\Composer\\Actions::check_coding_standards"
 62 | 		],
 63 | 		"check-cs-thresholds": [
 64 | 			"@putenv YOASTCS_THRESHOLD_ERRORS=65",
 65 | 			"@putenv YOASTCS_THRESHOLD_WARNINGS=0",
 66 | 			"Yoast\\WP\\Duplicate_Post\\Config\\Composer\\Actions::check_cs_thresholds"
 67 | 		],
 68 | 		"check-cs": [
 69 | 			"@check-cs-warnings -n"
 70 | 		],
 71 | 		"check-cs-warnings": [
 72 | 			"@php ./vendor/squizlabs/php_codesniffer/bin/phpcs"
 73 | 		],
 74 | 		"check-staged-cs": [
 75 | 			"@check-cs-warnings --filter=GitStaged"
 76 | 		],
 77 | 		"check-branch-cs": [
 78 | 			"Yoast\\WP\\Duplicate_Post\\Config\\Composer\\Actions::check_branch_cs"
 79 | 		],
 80 | 		"fix-cs": [
 81 | 			"@php ./vendor/squizlabs/php_codesniffer/bin/phpcbf"
 82 | 		],
 83 | 		"test": [
 84 | 			"@php ./vendor/phpunit/phpunit/phpunit --no-coverage"
 85 | 		],
 86 | 		"coverage": [
 87 | 			"@php ./vendor/phpunit/phpunit/phpunit"
 88 | 		],
 89 | 		"test-wp": [
 90 | 			"@php ./vendor/phpunit/phpunit/phpunit -c phpunit-wp.xml.dist --no-coverage"
 91 | 		],
 92 | 		"coverage-wp": [
 93 | 			"@php ./vendor/phpunit/phpunit/phpunit -c phpunit-wp.xml.dist"
 94 | 		],
 95 | 		"integration-test": [
 96 | 			"@test-wp"
 97 | 		],
 98 | 		"integration-coverage": [
 99 | 			"@coverage-wp"
100 | 		]
101 | 	},
102 | 	"scripts-descriptions": {
103 | 		"lint": "Check the PHP files for parse errors.",
104 | 		"cs": "See a menu with the code style checking script options.",
105 | 		"check-cs-thresholds": "Check the PHP files for code style violations and best practices and verify the number of issues does not exceed predefined thresholds.",
106 | 		"check-cs": "Check the PHP files for code style violations and best practices, ignoring warnings.",
107 | 		"check-cs-warnings": "Check the PHP files for code style violations and best practices, including warnings.",
108 | 		"check-staged-cs": "Check the staged PHP files for code style violations and best practices.",
109 | 		"check-branch-cs": "Check the PHP files changed in the current branch for code style violations and best practices.",
110 | 		"fix-cs": "Auto-fix code style violations in the PHP files.",
111 | 		"test": "Run the unit tests without code coverage.",
112 | 		"coverage": "Run the unit tests with code coverage.",
113 | 		"test-wp": "Run the WP unit tests without code coverage.",
114 | 		"coverage-wp": "Run the WP unit tests with code coverage.",
115 | 		"integration-test": "Deprecated. Alias for the \"test-wp\" script.",
116 | 		"integration-coverage": "Deprecated. Alias for the \"coverage-wp\" script."
117 | 	}
118 | }
119 | 


--------------------------------------------------------------------------------
/css/duplicate-post-options.css:
--------------------------------------------------------------------------------
 1 | #duplicate_post_settings_form header.nav-tab-wrapper {
 2 | 	margin: 22px 0 0 0;
 3 | }
 4 | 
 5 | #duplicate_post_settings_form header .nav-tab{
 6 | 	cursor: pointer;
 7 | }
 8 | 
 9 | #duplicate_post_settings_form header .nav-tab:focus {
10 | 	color: #555;
11 | 	box-shadow: none;
12 | 	outline: 1px dotted #000000;
13 | }
14 | 
15 | .no-js #duplicate_post_settings_form header.nav-tab-wrapper {
16 | 	display: none;
17 | }
18 | 
19 | .no-js #duplicate_post_settings_form section {
20 | 	border-top: 1px dashed #aaa;
21 | 	margin-top: 22px;
22 | 	padding-top: 22px;
23 | }
24 | 
25 | .no-js #duplicate_post_settings_form section:first-of-type {
26 | 	margin: 0;
27 | 	padding: 0;
28 | 	border: 0;
29 | }
30 | 
31 | .no-js #duplicate_post_settings_form section[hidden] {
32 | 	display: block;
33 | }
34 | 
35 | #duplicate_post_settings_form label.taxonomy_private {
36 | 	font-style: italic;
37 | }
38 | 
39 | #duplicate_post_settings_form .toggle-private-taxonomies.button-link {
40 | 	font-size: small;
41 | 	margin-top: 1em;
42 | }
43 | 


--------------------------------------------------------------------------------
/css/duplicate-post.css:
--------------------------------------------------------------------------------
 1 | #wp-admin-bar-root-default>#wp-admin-bar-duplicate-post>.ab-item .ab-icon::before,
 2 | #wp-admin-bar-root-default>#wp-admin-bar-new-draft>.ab-item .ab-icon::before,
 3 | #wp-admin-bar-root-default>#wp-admin-bar-rewrite-republish>.ab-item .ab-icon::before{
 4 | 	content:
 5 | 		url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='20' height='20' viewBox='0 0 20 20'><path d='M18.9 4.3c0.6 0 1.1 0.5 1.1 1.1v13.6c0 0.6-0.5 1.1-1.1 1.1h-10.7c-0.6 0-1.1-0.5-1.1-1.1v-3.2h-6.1c-0.6 0-1.1-0.5-1.1-1.1v-7.5c0-0.6 0.3-1.4 0.8-1.8l4.6-4.6c0.4-0.4 1.2-0.8 1.8-0.8h4.6c0.6 0 1.1 0.5 1.1 1.1v3.7c0.4-0.3 1-0.4 1.4-0.4h4.6zM12.9 6.7l-3.3 3.3h3.3v-3.3zM5.7 2.4l-3.3 3.3h3.3v-3.3zM7.9 9.6l3.5-3.5v-4.6h-4.3v4.6c0 0.6-0.5 1.1-1.1 1.1h-4.6v7.1h5.7v-2.9c0-0.6 0.3-1.4 0.8-1.8zM18.6 18.6v-12.9h-4.3v4.6c0 0.6-0.5 1.1-1.1 1.1h-4.6v7.1h10z' fill='rgba(240,245,250,.6)'/></svg>");
 6 | 	top: 2px;
 7 | }
 8 | 
 9 | #wp-admin-bar-root-default>#wp-admin-bar-duplicate-post:hover>.ab-item .ab-icon::before,
10 | #wp-admin-bar-root-default>#wp-admin-bar-new-draft:hover>.ab-item .ab-icon::before,
11 | #wp-admin-bar-root-default>#wp-admin-bar-rewrite-republish:hover>.ab-item .ab-icon::before,
12 | #wp-admin-bar-root-default>#wp-admin-bar-duplicate-post:focus>.ab-item .ab-icon::before,
13 | #wp-admin-bar-root-default>#wp-admin-bar-new-draft:focus>.ab-item .ab-icon::before,
14 | #wp-admin-bar-root-default>#wp-admin-bar-rewrite-republish:focus>.ab-item .ab-icon::before{
15 | 	content:
16 | 		url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='20' height='20' viewBox='0 0 20 20'><path d='M18.9 4.3c0.6 0 1.1 0.5 1.1 1.1v13.6c0 0.6-0.5 1.1-1.1 1.1h-10.7c-0.6 0-1.1-0.5-1.1-1.1v-3.2h-6.1c-0.6 0-1.1-0.5-1.1-1.1v-7.5c0-0.6 0.3-1.4 0.8-1.8l4.6-4.6c0.4-0.4 1.2-0.8 1.8-0.8h4.6c0.6 0 1.1 0.5 1.1 1.1v3.7c0.4-0.3 1-0.4 1.4-0.4h4.6zM12.9 6.7l-3.3 3.3h3.3v-3.3zM5.7 2.4l-3.3 3.3h3.3v-3.3zM7.9 9.6l3.5-3.5v-4.6h-4.3v4.6c0 0.6-0.5 1.1-1.1 1.1h-4.6v7.1h5.7v-2.9c0-0.6 0.3-1.4 0.8-1.8zM18.6 18.6v-12.9h-4.3v4.6c0 0.6-0.5 1.1-1.1 1.1h-4.6v7.1h10z' fill='rgba(0, 185, 235, 1)'/></svg>");
17 | }
18 | 
19 | /* Copy links in the classic editor. */
20 | #duplicate-action {
21 | 	margin-bottom: 12px;
22 | }
23 | 
24 | #rewrite-republish-action {
25 | 	margin-bottom: -2px;
26 | }
27 | 
28 | #rewrite-republish-action + #delete-action {
29 | 	margin-top: 8px;
30 | }
31 | 
32 | /* Copy links in the block editor. */
33 | .components-button.dp-editor-post-copy-to-draft,
34 | .components-button.dp-editor-post-rewrite-republish {
35 | 	margin-left: -6px;
36 | 	text-decoration: underline;
37 | }
38 | 
39 | #check-changes-action  {
40 | 	padding: 6px 10px 8px;
41 | }
42 | 
43 | @media screen and (max-width: 782px){
44 | 	#wp-admin-bar-root-default>#wp-admin-bar-duplicate-post,
45 | 	#wp-admin-bar-root-default>#wp-admin-bar-new-draft,
46 | 	#wp-admin-bar-root-default>#wp-admin-bar-rewrite-republish {
47 | 		display: block;
48 | 		position: static;
49 | 	}
50 | 	#wp-admin-bar-root-default>#wp-admin-bar-duplicate-post>.ab-item,
51 | 	#wp-admin-bar-root-default>#wp-admin-bar-new-draft>.ab-item,
52 | 	#wp-admin-bar-root-default>#wp-admin-bar-rewrite-republish>.ab-item {
53 | 		text-indent: 100%;
54 | 		white-space: nowrap;
55 | 		overflow: hidden;
56 | 		width: 52px;
57 | 		padding: 0;
58 | 		color: #999;
59 | 		position: static;
60 | 	}
61 | 	#wp-admin-bar-root-default>#wp-admin-bar-duplicate-post>.ab-item .ab-icon::before,
62 | 	#wp-admin-bar-root-default>#wp-admin-bar-new-draft>.ab-item .ab-icon::before,
63 | 	#wp-admin-bar-root-default>#wp-admin-bar-rewrite-republish>.ab-item .ab-icon::before {
64 | 		display: block;
65 | 		text-indent: 0;
66 | 		font: 400 32px/1 dashicons;
67 | 		speak: none;
68 | 		top: 0px;
69 | 		width: 52px;
70 | 		text-align: center;
71 | 		-webkit-font-smoothing: antialiased;
72 | 		-moz-osx-font-smoothing: grayscale;
73 | 	}
74 | 	#rewrite-republish-action + #delete-action {
75 | 		margin-top: 0;
76 | 	}
77 | }
78 | 
79 | fieldset#duplicate_post_quick_edit_fieldset{
80 | 	clear: both;
81 | }
82 | 
83 | fieldset#duplicate_post_quick_edit_fieldset label{
84 | 	display: inline;
85 | 	margin: 0;
86 | 	vertical-align: unset;
87 | }
88 | 
89 | fieldset#duplicate_post_quick_edit_fieldset a{
90 | 	text-decoration: underline;
91 | }
92 | 


--------------------------------------------------------------------------------
/duplicate-post.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Duplicate Post plugin.
  4 |  *
  5 |  * @package Yoast\WP\Duplicate_Post
  6 |  * @since   0.1
  7 |  *
  8 |  * @wordpress-plugin
  9 |  * Plugin Name: Yoast Duplicate Post
 10 |  * Plugin URI:  https://yoast.com/wordpress/plugins/duplicate-post/
 11 |  * Description: The go-to tool for cloning posts and pages, including the powerful Rewrite & Republish feature.
 12 |  * Version:     4.5
 13 |  * Author:      Enrico Battocchi & Team Yoast
 14 |  * Author URI:  https://yoa.st/team-yoast-duplicate
 15 |  * Text Domain: duplicate-post
 16 |  * Requires at least: 6.6
 17 |  * Requires PHP: 7.4
 18 |  *
 19 |  * Copyright 2020-2024 Yoast BV (email : info@yoast.com)
 20 |  *
 21 |  * This program is free software; you can redistribute it and/or modify
 22 |  * it under the terms of the GNU General Public License as published by
 23 |  * the Free Software Foundation; either version 2 of the License, or
 24 |  * (at your option) any later version.
 25 |  *
 26 |  * This program is distributed in the hope that it will be useful,
 27 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 28 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 29 |  * GNU General Public License for more details.
 30 |  *
 31 |  * You should have received a copy of the GNU General Public License
 32 |  * along with this program; if not, write to the Free Software
 33 |  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 34 |  */
 35 | 
 36 | use Yoast\WP\Duplicate_Post\Duplicate_Post;
 37 | 
 38 | if ( ! defined( 'ABSPATH' ) ) {
 39 | 	exit();
 40 | }
 41 | 
 42 | if ( ! defined( 'DUPLICATE_POST_FILE' ) ) {
 43 | 	define( 'DUPLICATE_POST_FILE', __FILE__ );
 44 | }
 45 | 
 46 | if ( ! defined( 'DUPLICATE_POST_PATH' ) ) {
 47 | 	define( 'DUPLICATE_POST_PATH', plugin_dir_path( __FILE__ ) );
 48 | }
 49 | 
 50 | define( 'DUPLICATE_POST_CURRENT_VERSION', '4.5' );
 51 | 
 52 | $duplicate_post_autoload_file = DUPLICATE_POST_PATH . 'vendor/autoload.php';
 53 | 
 54 | if ( is_readable( $duplicate_post_autoload_file ) ) {
 55 | 	require $duplicate_post_autoload_file;
 56 | }
 57 | 
 58 | if ( class_exists( Duplicate_Post::class ) ) {
 59 | 	// Initialize the main autoloaded class.
 60 | 	add_action( 'plugins_loaded', '__duplicate_post_main' );
 61 | }
 62 | 
 63 | /**
 64 |  * Loads the Duplicate Post main class.
 65 |  *
 66 |  * {@internal Function name change would be BC-break.}
 67 |  *
 68 |  * @phpcs:disable PHPCompatibility.FunctionNameRestrictions.ReservedFunctionNames.FunctionDoubleUnderscore
 69 |  * @phpcs:disable WordPress.NamingConventions.ValidFunctionName.FunctionDoubleUnderscore
 70 |  * @phpcs:disable WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedFunctionFound
 71 |  *
 72 |  * @return void
 73 |  */
 74 | function __duplicate_post_main() {
 75 | 	new Duplicate_Post();
 76 | }
 77 | // phpcs:enable
 78 | 
 79 | add_filter( 'plugin_action_links_' . plugin_basename( __FILE__ ), 'duplicate_post_plugin_actions', 10 );
 80 | 
 81 | /**
 82 |  * Adds 'Settings' link to plugin entry in the Plugins list.
 83 |  *
 84 |  * @see 'plugin_action_links_$plugin_file'
 85 |  *
 86 |  * @param array $actions An array of plugin action links.
 87 |  * @return array
 88 |  */
 89 | function duplicate_post_plugin_actions( $actions ) {
 90 | 	$settings_action = [
 91 | 		'settings' => sprintf(
 92 | 			'<a href="%1$s" %2$s>%3$s</a>',
 93 | 			menu_page_url( 'duplicatepost', false ),
 94 | 			/* translators: Hidden accessibility text. */
 95 | 			'aria-label="' . __( 'Settings for Duplicate Post', 'duplicate-post' ) . '"',
 96 | 			esc_html__( 'Settings', 'duplicate-post' )
 97 | 		),
 98 | 	];
 99 | 
100 | 	$actions = ( $settings_action + $actions );
101 | 	return $actions;
102 | }
103 | 
104 | require_once DUPLICATE_POST_PATH . 'common-functions.php';
105 | 
106 | if ( is_admin() ) {
107 | 	include_once DUPLICATE_POST_PATH . 'admin-functions.php';
108 | }
109 | 


--------------------------------------------------------------------------------
/duplicate_post_yoast_icon-125x125.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Yoast/duplicate-post/6231de5544a901a5bba32974579c5a6eb1e46bfa/duplicate_post_yoast_icon-125x125.png


--------------------------------------------------------------------------------
/js/src/duplicate-post-edit-script.js:
--------------------------------------------------------------------------------
  1 | /* global duplicatePost, duplicatePostNotices */
  2 | 
  3 | import { registerPlugin } from "@wordpress/plugins";
  4 | import { PluginPostStatusInfo } from "@wordpress/edit-post";
  5 | import { Fragment } from "@wordpress/element";
  6 | import { Button } from '@wordpress/components';
  7 | import { __ } from "@wordpress/i18n";
  8 | import { select, subscribe, dispatch } from "@wordpress/data";
  9 | import { redirectOnSaveCompletion } from "./duplicate-post-functions";
 10 | 
 11 | 
 12 | class DuplicatePost {
 13 | 	constructor() {
 14 | 		this.renderNotices();
 15 | 		this.removeSlugSidebarPanel();
 16 | 	}
 17 | 
 18 | 	/**
 19 | 	 * Handles the redirect from the copy to the original.
 20 | 	 *
 21 | 	 * @returns {void}
 22 | 	 */
 23 | 	handleRedirect() {
 24 | 		if ( ! parseInt( duplicatePost.rewriting, 10 ) ) {
 25 | 			return;
 26 | 		}
 27 | 
 28 | 		let wasSavingPost      = false;
 29 | 		let wasSavingMetaboxes = false;
 30 | 		let wasAutoSavingPost  = false;
 31 | 
 32 | 		/**
 33 | 		 * Determines when the redirect needs to happen.
 34 | 		 *
 35 | 		 * @returns {void}
 36 | 		 */
 37 | 		subscribe( () => {
 38 | 			if ( ! this.isSafeRedirectURL( duplicatePost.originalEditURL ) || ! this.isCopyAllowedToBeRepublished() ) {
 39 | 				return;
 40 | 			}
 41 | 
 42 | 			const completed = redirectOnSaveCompletion( duplicatePost.originalEditURL, { wasSavingPost, wasSavingMetaboxes, wasAutoSavingPost } );
 43 | 
 44 | 			wasSavingPost      = completed.isSavingPost;
 45 | 			wasSavingMetaboxes = completed.isSavingMetaBoxes;
 46 | 			wasAutoSavingPost  = completed.isAutosavingPost;
 47 | 		} );
 48 | 	}
 49 | 
 50 | 	/**
 51 | 	 * Checks whether the URL for the redirect from the copy to the original matches the expected format.
 52 | 	 *
 53 | 	 * Allows only URLs with a http(s) protocol, a pathname matching the admin
 54 | 	 * post.php page and a parameter string with the expected parameters.
 55 | 	 *
 56 | 	 * @returns {bool} Whether the redirect URL matches the expected format.
 57 | 	 */
 58 | 	isSafeRedirectURL( url ) {
 59 | 		const parser = document.createElement( 'a' );
 60 | 		parser.href  = url;
 61 | 
 62 | 		if (
 63 | 			/^https?:$/.test( parser.protocol ) &&
 64 | 			/\/wp-admin\/post\.php$/.test( parser.pathname ) &&
 65 | 			/\?action=edit&post=[0-9]+&dprepublished=1&dpcopy=[0-9]+&dpnonce=[a-z0-9]+/i.test( parser.search )
 66 | 		) {
 67 | 			return true;
 68 | 		}
 69 | 
 70 | 		return false;
 71 | 	}
 72 | 
 73 | 	/**
 74 | 	 * Determines whether a Rewrite & Republish copy can be republished.
 75 | 	 *
 76 | 	 * @return bool Whether the Rewrite & Republish copy can be republished.
 77 | 	 */
 78 | 	isCopyAllowedToBeRepublished() {
 79 | 		const currentPostStatus = select( 'core/editor' ).getCurrentPostAttribute( 'status' );
 80 | 
 81 | 		if ( currentPostStatus === 'dp-rewrite-republish' || currentPostStatus === 'private' ) {
 82 | 			return true;
 83 | 		}
 84 | 
 85 | 		return false;
 86 | 	}
 87 | 
 88 | 	/**
 89 | 	 * Renders the notices in the block editor.
 90 | 	 *
 91 | 	 * @returns {void}
 92 | 	 */
 93 | 	renderNotices() {
 94 | 		if ( ! duplicatePostNotices || ! ( duplicatePostNotices instanceof Object ) ) {
 95 | 			return;
 96 | 		}
 97 | 
 98 | 		for ( const [ key, notice ] of Object.entries( duplicatePostNotices ) ) {
 99 | 			if ( notice.status && notice.text ) {
100 | 				dispatch( 'core/notices' ).createNotice(
101 | 					notice.status,
102 | 					notice.text,
103 | 					{
104 | 						isDismissible: notice.isDismissible || true,
105 | 					}
106 | 				);
107 | 			}
108 | 		}
109 | 	}
110 | 
111 | 	/**
112 | 	 * Removes the slug panel from the block editor sidebar when the post is a Rewrite & Republish copy.
113 | 	 *
114 | 	 * @returns {void}
115 | 	 */
116 | 	removeSlugSidebarPanel() {
117 | 		if ( parseInt( duplicatePost.rewriting, 10 ) ) {
118 | 			dispatch( 'core/edit-post' ).removeEditorPanel( 'post-link' );
119 | 		}
120 | 	}
121 | 
122 | 	/**
123 | 	 * Renders the links in the PluginPostStatusInfo component.
124 | 	 *
125 | 	 * @returns {JSX.Element} The rendered links.
126 | 	 */
127 | 	render() {
128 | 		// Don't try to render anything if there is no store.
129 | 		if ( ! select( 'core/editor' ) || ! ( wp.editPost && wp.editPost.PluginPostStatusInfo ) ) {
130 | 			return null;
131 | 		}
132 | 
133 | 		const currentPostStatus = select( 'core/editor' ).getEditedPostAttribute( 'status' );
134 | 
135 | 		return (
136 | 			( duplicatePost.showLinksIn.submitbox === '1' ) &&
137 | 			<Fragment>
138 | 				{ ( duplicatePost.newDraftLink !== '' && duplicatePost.showLinks.new_draft === '1' ) &&
139 | 					<PluginPostStatusInfo>
140 | 						<Button
141 | 							isTertiary={ true }
142 | 							className="dp-editor-post-copy-to-draft"
143 | 							href={ duplicatePost.newDraftLink }
144 | 						>
145 | 							{ __( 'Copy to a new draft', 'duplicate-post' ) }
146 | 						</Button>
147 | 					</PluginPostStatusInfo>
148 | 				}
149 | 				{ ( currentPostStatus === 'publish' && duplicatePost.rewriteAndRepublishLink !== '' && duplicatePost.showLinks.rewrite_republish === '1' ) &&
150 | 					<PluginPostStatusInfo>
151 | 						<Button
152 | 							isTertiary={ true }
153 | 							className="dp-editor-post-rewrite-republish"
154 | 							href={ duplicatePost.rewriteAndRepublishLink }
155 | 						>
156 | 							{ __( 'Rewrite & Republish', 'duplicate-post' ) }
157 | 						</Button>
158 | 					</PluginPostStatusInfo>
159 | 				}
160 | 			</Fragment>
161 | 		);
162 | 	}
163 | }
164 | 
165 | const instance = new DuplicatePost();
166 | instance.handleRedirect();
167 | 
168 | registerPlugin( 'duplicate-post', {
169 | 	render: instance.render
170 | } );
171 | 


--------------------------------------------------------------------------------
/js/src/duplicate-post-elementor.js:
--------------------------------------------------------------------------------
 1 | /* global $e, duplicatePost, elementor */
 2 | 
 3 | /**
 4 |  * Hooks into Elementor on initialization.
 5 |  *
 6 |  * @returns {void}
 7 |  */
 8 | function duplicatePostOnElementorInitialize() {
 9 | 
10 | 	/**
11 | 	 * Class that defines the redirect action to execute after republishing.
12 | 	 */
13 | 	class RedirectAfterRepublish extends $e.modules.hookUI.After {
14 | 
15 | 		/**
16 | 		 * Gets the command to run on.
17 | 		 *
18 | 		 * @returns {string} The command.
19 | 		 */
20 | 		getCommand() {
21 | 			return "document/save/save";
22 | 		}
23 | 
24 | 		/**
25 | 		 * Gets the conditions on which to run on.
26 | 		 *
27 | 		 * @param {Object} args The arguments to use.
28 | 		 *
29 | 		 * @returns {boolean} Whether the post status is that of a published post.
30 | 		 */
31 | 		getConditions( args ) {
32 | 			const { status } = args;
33 | 
34 | 			return status === "publish";
35 | 		}
36 | 
37 | 		/**
38 | 		 * Gets the ID of the action.
39 | 		 *
40 | 		 * @returns {string} The ID.
41 | 		 */
42 | 		getId() {
43 | 			return "redirect-after-republish";
44 | 		}
45 | 
46 | 		/**
47 | 		 * Applies the redirect if the condtions are met.
48 | 		 *
49 | 		 * @param {Object} args The arguments to use.
50 | 		 *
51 | 		 * @returns {void}
52 | 		 */
53 | 		apply( args ) {
54 | 			if ( args.status === "publish" && duplicatePost.originalEditURL && duplicatePost.rewriting === "1" ) {
55 | 				window.location.assign( duplicatePost.originalEditURL );
56 | 			}
57 | 		}
58 | 	}
59 | 
60 | 	$e.hooks.registerUIAfter( new RedirectAfterRepublish() );
61 | }
62 | 
63 | /**
64 |  * Removes the Save as Template option for Rewrite and Republish copy.
65 |  *
66 |  * @returns {void}
67 |  */
68 | function duplicatePostRemoveSaveTemplate() {
69 | 	if ( duplicatePost.rewriting === "0" ) {
70 | 		return;
71 | 	}
72 | 
73 | 	elementor
74 | 		.getPanelView()
75 | 		.footer
76 | 		.currentView
77 | 		.removeSubMenuItem( "saver-options", {
78 | 			name: "save-template",
79 | 		} );
80 | }
81 | 
82 | // Wait on `window.elementor`.
83 | jQuery( window ).on( "elementor:init", () => {
84 | 	// Wait on Elementor app to have started.
85 | 	window.elementor.on( "panel:init", () => {
86 | 		duplicatePostOnElementorInitialize();
87 | 		duplicatePostRemoveSaveTemplate();
88 | 	} );
89 | } );
90 | 


--------------------------------------------------------------------------------
/js/src/duplicate-post-functions.js:
--------------------------------------------------------------------------------
 1 | import { dispatch, select } from "@wordpress/data";
 2 | 
 3 | /**
 4 |  * This redirects without showing the warning that occurs due to a Gutenberg bug.
 5 |  *
 6 |  * Edits made to the post on the PHP side are not correctly recognized and thus the warning for unsaved changes is shown.
 7 |  * By updating the post status ourselves on the JS side as well we avoid this.
 8 |  *
 9 |  * @param {string} url The url to redirect to.
10 |  *
11 |  * @returns {void}
12 |  */
13 | const redirectWithoutWarning = ( url ) => {
14 | 	const currentPostStatus = select( 'core/editor' ).getCurrentPostAttribute( 'status' );
15 | 	const editedPostStatus  = select( 'core/editor' ).getEditedPostAttribute( 'status' );
16 | 
17 | 	if ( currentPostStatus === 'dp-rewrite-republish' && editedPostStatus === 'publish' ) {
18 | 		dispatch( 'core/editor' ).editPost( { status: currentPostStatus } );
19 | 	}
20 | 
21 | 	window.location.assign( url );
22 | }
23 | 
24 | /**
25 |  * Redirects to url when saving in the block editor has completed.
26 |  *
27 |  * @param {string} url         The url to redirect to.
28 |  * @param {Object} editorState The current editor state regarding saving the post, metaboxes and autosaving.
29 |  *
30 |  * @returns {Object} The updated editor state.
31 |  */
32 | export const redirectOnSaveCompletion = ( url, editorState ) => {
33 | 	const isSavingPost       = select( 'core/editor' ).isSavingPost();
34 | 	const isAutosavingPost   = select( 'core/editor' ).isAutosavingPost();
35 | 	const hasActiveMetaBoxes = select( 'core/edit-post' ).hasMetaBoxes();
36 | 	const isSavingMetaBoxes  = select( 'core/edit-post' ).isSavingMetaBoxes();
37 | 
38 | 	// When there are custom meta boxes, redirect after they're saved.
39 | 	if ( hasActiveMetaBoxes && ! isSavingMetaBoxes && editorState.wasSavingMetaboxes ) {
40 | 		redirectWithoutWarning( url );
41 | 	}
42 | 
43 | 	// When there are no custom meta boxes, redirect after the post is saved.
44 | 	if ( ! hasActiveMetaBoxes && ! isSavingPost && editorState.wasSavingPost && ! editorState.wasAutoSavingPost ) {
45 | 		redirectWithoutWarning( url );
46 | 	}
47 | 
48 | 	return { isSavingPost, isSavingMetaBoxes, isAutosavingPost };
49 | };
50 | 


--------------------------------------------------------------------------------
/js/src/duplicate-post-options.js:
--------------------------------------------------------------------------------
  1 | let tablist;
  2 | let tabs;
  3 | let panels;
  4 | 
  5 | // For easy reference
  6 | const keys = {
  7 | 	end: 35,
  8 | 	home: 36,
  9 | 	left: 37,
 10 | 	up: 38,
 11 | 	right: 39,
 12 | 	down: 40,
 13 | 	delete: 46
 14 | };
 15 | 
 16 | // Add or substract depending on key pressed
 17 | const direction = {
 18 | 	37: - 1,
 19 | 	38: - 1,
 20 | 	39: 1,
 21 | 	40: 1
 22 | };
 23 | 
 24 | 
 25 | function generateArrays() {
 26 | 	tabs = document.querySelectorAll( "#duplicate_post_settings_form [role=\"tab\"]" );
 27 | 	panels = document.querySelectorAll( "#duplicate_post_settings_form [role=\"tabpanel\"]" );
 28 | }
 29 | 
 30 | function addListeners( index ) {
 31 | 	tabs[index].addEventListener( "click", function ( event ) {
 32 | 		const tab = event.target;
 33 | 		activateTab( tab, false );
 34 | 	} );
 35 | 	tabs[index].addEventListener( "keydown", function ( event ) {
 36 | 		const key = event.keyCode;
 37 | 
 38 | 		switch ( key ) {
 39 | 			case keys.end:
 40 | 				event.preventDefault();
 41 | 				// Activate last tab
 42 | 				activateTab( tabs[tabs.length - 1] );
 43 | 				break;
 44 | 			case keys.home:
 45 | 				event.preventDefault();
 46 | 				// Activate first tab
 47 | 				activateTab( tabs[0] );
 48 | 				break;
 49 | 			default:
 50 | 				break;
 51 | 		}
 52 | 	} );
 53 | 	tabs[index].addEventListener( "keyup", function ( event ) {
 54 | 		const key = event.keyCode;
 55 | 
 56 | 		switch ( key ) {
 57 | 			case keys.left:
 58 | 			case keys.right:
 59 | 				switchTabOnArrowPress( event );
 60 | 				break;
 61 | 			default:
 62 | 				break;
 63 | 		}
 64 | 	} );
 65 | 
 66 | 	// Build an array with all tabs (<button>s) in it
 67 | 	tabs[index].index = index;
 68 | }
 69 | 
 70 | 
 71 | // Either focus the next, previous, first, or last tab
 72 | // depending on key pressed
 73 | function switchTabOnArrowPress( event ) {
 74 | 	const pressed = event.keyCode;
 75 | 
 76 | 	for ( let x = 0; x < tabs.length; x ++ ) {
 77 | 		tabs[x].addEventListener( "focus", focusEventHandler );
 78 | 	}
 79 | 
 80 | 	if ( direction[pressed] ) {
 81 | 		const target = event.target;
 82 | 		if ( target.index !== undefined ) {
 83 | 			if ( tabs[target.index + direction[pressed]] ) {
 84 | 				tabs[target.index + direction[pressed]].focus();
 85 | 			}
 86 | 			else if ( pressed === keys.left || pressed === keys.up ) {
 87 | 				focusLastTab();
 88 | 			}
 89 | 			else if ( pressed === keys.right || pressed === keys.down ) {
 90 | 				focusFirstTab();
 91 | 			}
 92 | 		}
 93 | 	}
 94 | }
 95 | 
 96 | // Activates any given tab panel
 97 | function activateTab( tab, setFocus ) {
 98 | 	setFocus = setFocus || true;
 99 | 	// Deactivate all other tabs
100 | 	deactivateTabs();
101 | 
102 | 	// Remove tabindex attribute
103 | 	tab.removeAttribute( "tabindex" );
104 | 
105 | 	// Set the tab as selected
106 | 	tab.setAttribute( "aria-selected", "true" );
107 | 
108 | 	tab.classList.add( "nav-tab-active" );
109 | 
110 | 	// Get the value of aria-controls (which is an ID)
111 | 	const controls = tab.getAttribute( "aria-controls" );
112 | 
113 | 	// Remove hidden attribute from tab panel to make it visible
114 | 	document.getElementById( controls )
115 | 	        .removeAttribute( "hidden" );
116 | 
117 | 	// Set focus when required
118 | 	if ( setFocus ) {
119 | 		tab.focus();
120 | 	}
121 | }
122 | 
123 | // Deactivate all tabs and tab panels
124 | function deactivateTabs() {
125 | 	for ( let t = 0; t < tabs.length; t ++ ) {
126 | 		tabs[t].setAttribute( "tabindex", "-1" );
127 | 		tabs[t].setAttribute( "aria-selected", "false" );
128 | 		tabs[t].classList.remove( "nav-tab-active" );
129 | 		tabs[t].removeEventListener( "focus", focusEventHandler );
130 | 	}
131 | 
132 | 	for ( let p = 0; p < panels.length; p ++ ) {
133 | 		panels[p].setAttribute( "hidden", "hidden" );
134 | 	}
135 | }
136 | 
137 | // Make a guess
138 | function focusFirstTab() {
139 | 	tabs[0].focus();
140 | }
141 | 
142 | // Make a guess
143 | function focusLastTab() {
144 | 	tabs[tabs.length - 1].focus();
145 | }
146 | 
147 | //
148 | function focusEventHandler( event ) {
149 | 	const target = event.target;
150 | 
151 | 	checkTabFocus( target );
152 | }
153 | 
154 | // Only activate tab on focus if it still has focus after the delay
155 | function checkTabFocus( target ) {
156 | 	const focused = document.activeElement;
157 | 
158 | 	if ( target === focused ) {
159 | 		activateTab( target, false );
160 | 	}
161 | }
162 | 
163 | document.addEventListener( "DOMContentLoaded", function () {
164 | 	tablist = document.querySelectorAll( "#duplicate_post_settings_form [role=\"tablist\"]" )[0];
165 | 
166 | 	generateArrays();
167 | 
168 | 	// Bind listeners
169 | 	for ( let i = 0; i < tabs.length; ++ i ) {
170 | 		addListeners( i );
171 | 	}
172 | } );
173 | 
174 | jQuery( function () {
175 | 	jQuery( ".taxonomy_private" )
176 | 		.hide();
177 | 
178 | 	jQuery( ".toggle-private-taxonomies" )
179 | 		.on( "click", function () {
180 | 			const buttonElement = jQuery( this );
181 | 
182 | 			jQuery( ".taxonomy_private" )
183 | 				.toggle( 300, function () {
184 | 					buttonElement.attr( "aria-expanded", jQuery( this )
185 | 						.is( ":visible" ) );
186 | 				} );
187 | 		} );
188 | } );
189 | 


--------------------------------------------------------------------------------
/js/src/duplicate-post-quick-edit-script.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Injects column data about original post into the Quick Edit.
 3 |  *
 4 |  * @package Duplicate Post
 5 |  * @since 3.2.4
 6 |  */
 7 | 
 8 | (function(jQuery) {
 9 | 	var $wp_inline_edit = inlineEditPost.edit;
10 | 	inlineEditPost.edit = function( id ) {
11 | 		$wp_inline_edit.apply( this, arguments );
12 | 		var $post_id = 0;
13 | 		if ( typeof( id ) == 'object' ) {
14 | 			$post_id = parseInt( this.getId( id ) );
15 | 		}
16 | 		if ( $post_id > 0 ) {
17 | 			var $edit_row = jQuery( '#edit-' + $post_id );
18 | 			var $post_row = jQuery( '#post-' + $post_id );
19 | 
20 | 			var has_original                      = ( jQuery( '.duplicate_post_original_item span', $post_row ).data( 'noOriginal' ) !== 1 );
21 | 			var original                          = jQuery( '.duplicate_post_original_item span', $post_row ).html();
22 | 			var is_copy_for_rewrite_and_republish = ( jQuery( '.duplicate_post_original_item span', $post_row ).data( 'copyIsForRewriteAndRepublish' ) === 1 );
23 | 
24 | 			if ( has_original && ! is_copy_for_rewrite_and_republish ) {
25 | 				jQuery( '.duplicate_post_original_item_title_span', $edit_row ).html( original );
26 | 				jQuery( '#duplicate_post_quick_edit_fieldset', $edit_row ).show();
27 | 			} else {
28 | 				jQuery( '#duplicate_post_quick_edit_fieldset', $edit_row ).hide();
29 | 				jQuery( '.duplicate_post_original_item_title_span', $edit_row ).html( '' );
30 | 			}
31 | 		}
32 | 	};
33 | 
34 | } )( jQuery );
35 | 


--------------------------------------------------------------------------------
/js/src/duplicate-post-strings.js:
--------------------------------------------------------------------------------
 1 | /* global duplicatePostStrings */
 2 | 
 3 | import { safeCreateInterpolateElement } from "./helpers/safe-create-interpolate-element";
 4 | import { Button } from "@wordpress/components";
 5 | import { __, setLocaleData } from "@wordpress/i18n";
 6 | import { dispatch, subscribe } from "@wordpress/data";
 7 | import { redirectOnSaveCompletion } from "./duplicate-post-functions";
 8 | 
 9 | const saveAndCompare = () => {
10 | 	dispatch( 'core/editor' ).savePost();
11 | 
12 | 	let wasSavingPost      = false;
13 | 	let wasSavingMetaboxes = false;
14 | 	let wasAutoSavingPost  = false;
15 | 
16 | 	/**
17 | 	 * Determines when the redirect needs to happen.
18 | 	 *
19 | 	 * @returns {void}
20 | 	 */
21 | 	subscribe( () => {
22 | 		const completed = redirectOnSaveCompletion( duplicatePostStrings.checkLink, { wasSavingPost, wasSavingMetaboxes, wasAutoSavingPost } );
23 | 
24 | 		wasSavingPost      = completed.isSavingPost;
25 | 		wasSavingMetaboxes = completed.isSavingMetaBoxes;
26 | 		wasAutoSavingPost  = completed.isAutosavingPost;
27 | 	} );
28 | }
29 | 
30 | const republishStrings = {
31 | 	'Publish'  : __( 'Republish', 'duplicate-post' ),
32 | 	'Publish:' : __( 'Republish:', 'duplicate-post' ),
33 | 	'Publish on:' : __( 'Republish on:', 'duplicate-post' ),
34 | 
35 | 	'Are you ready to publish?'	: __( 'Are you ready to republish your post?', 'duplicate-post' ),
36 | 	'Double-check your settings before publishing.':
37 | 		safeCreateInterpolateElement(
38 | 			__( 'After republishing your changes will be merged into the original post and you\'ll be redirected there.<br /><br />Do you want to compare your changes with the original version before merging?<br /><br /><button>Save changes and compare</button>',
39 | 				'duplicate-post' ),
40 | 			{
41 | 				button: <Button isSecondary onClick={ saveAndCompare } />,
42 | 				br: <br />
43 | 			}
44 | 		),
45 | 
46 | 	'Schedule'  : __( 'Schedule republish', 'duplicate-post' ),
47 | 	'Schedule…' : __( 'Schedule republish…', 'duplicate-post' ),
48 | 	'post action/button label\u0004Schedule' : __( 'Schedule republish', 'duplicate-post' ),
49 | 
50 | 	'Are you ready to schedule?' : __( 'Are you ready to schedule the republishing of your post?', 'duplicate-post' ),
51 | 	'Your work will be published at the specified date and time.':
52 | 		safeCreateInterpolateElement(
53 | 			__( 'You\'re about to replace the original with this rewritten post at the specified date and time.<br /><br />Do you want to compare your changes with the original version before merging?<br /><br /><button>Save changes and compare</button>',
54 | 				'duplicate-post' ),
55 | 			{
56 | 				button: <Button isSecondary onClick={ saveAndCompare } />,
57 | 				br: <br />
58 | 			}
59 | 		),
60 | 	'is now scheduled. It will go live on':
61 | 		__( ', the rewritten post, is now scheduled to replace the original post. It will be published on',
62 | 		'duplicate-post' ),
63 | };
64 | 
65 | for ( const original in republishStrings ) {
66 | 	setLocaleData( {
67 | 		[ original ]: [
68 | 			republishStrings[ original ],
69 | 			'duplicate-post'
70 | 		]
71 | 	} );
72 | }
73 | 


--------------------------------------------------------------------------------
/js/src/helpers/safe-create-interpolate-element.js:
--------------------------------------------------------------------------------
 1 | import { createInterpolateElement } from "@wordpress/element";
 2 | 
 3 | /**
 4 |  * Wrapper function for `createInterpolateElement` to catch errors.
 5 |  *
 6 |  * @param {string} interpolatedString The interpolated string.
 7 |  * @param {Object<string, JSX.Element>} conversionMap The conversion map object.
 8 |  * @returns {JSX.Element|string} The interpolated element or string if it failed.
 9 |  */
10 | export const safeCreateInterpolateElement = ( interpolatedString, conversionMap ) => {
11 | 	try {
12 | 		return createInterpolateElement( interpolatedString, conversionMap );
13 | 	} catch ( error ) {
14 | 		console.error( "Error in translation for:", interpolatedString, error );
15 | 		return interpolatedString;
16 | 	}
17 | };
18 | 


--------------------------------------------------------------------------------
/options.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post;
 4 | 
 5 | use Yoast\WP\Duplicate_Post\Admin\Options;
 6 | use Yoast\WP\Duplicate_Post\Admin\Options_Form_Generator;
 7 | use Yoast\WP\Duplicate_Post\Admin\Options_Inputs;
 8 | use Yoast\WP\Duplicate_Post\Admin\Options_Page;
 9 | use Yoast\WP\Duplicate_Post\UI\Asset_Manager;
10 | 
11 | if ( ! \defined( 'ABSPATH' ) ) {
12 | 	exit();
13 | }
14 | 
15 | $duplicate_post_options_page = new Options_Page(
16 | 	new Options(),
17 | 	new Options_Form_Generator( new Options_Inputs() ),
18 | 	new Asset_Manager()
19 | );
20 | 
21 | $duplicate_post_options_page->register_hooks();
22 | 


--------------------------------------------------------------------------------
/readme.txt:
--------------------------------------------------------------------------------
  1 | === Yoast Duplicate Post ===
  2 | Contributors: 		yoast, lopo
  3 | Donate link: 		https://yoast.com/wordpress/plugins/duplicate-post/
  4 | Tags: 				duplicate post, copy, clone
  5 | Requires at least: 	6.6
  6 | Tested up to: 		6.8
  7 | Stable tag: 		4.5
  8 | Requires PHP:		7.4
  9 | License: 			GPLv2 or later
 10 | License URI: 		http://www.gnu.org/licenses/gpl-2.0.html
 11 | 
 12 | The go-to tool for cloning posts and pages, including the powerful Rewrite & Republish feature.
 13 | 
 14 | == Description ==
 15 | 
 16 | This plugin allows users to clone posts of any type, or copy them to new drafts for further editing.
 17 | 
 18 | How it works:
 19 | 
 20 | 1. In 'Edit Posts'/'Edit Pages', you can click on 'Clone' link below the post/page title: this will immediately create a copy and return to the list.
 21 | 
 22 | 2. In 'Edit Posts'/'Edit Pages', you can select one or more items, then choose 'Clone' in the 'Bulk Actions' dropdown to copy them all at once.
 23 | 
 24 | 3. In 'Edit Posts'/'Edit Pages', you can click on 'New Draft' link below the post/page title.
 25 | 
 26 | 4. On the post edit screen, you can click on 'Copy to a new draft' above "Cancel"/"Move to trash" or in the admin bar.
 27 | 
 28 | 5. While viewing a post as a logged in user, you can click on 'Copy to a new draft' in the admin bar.
 29 | 
 30 | 3, 4 and 5 will lead to the edit page for the new draft: change what you want, click on 'Publish' and you're done.
 31 | 
 32 | There is also a **template tag**, so you can put it in your templates and clone your posts/pages from the front-end. Clicking on the link will lead you to the edit page for the new draft, just like the admin bar link.
 33 | 
 34 | Duplicate Post has many useful settings to customize its behavior and restrict its use to certain roles or post types. Check out the extensive documentation on [yoast.com](https://yoast.com/wordpress/plugins/duplicate-post/) and our [developer docs](https://developer.yoast.com/duplicate-post/overview/).
 35 | 
 36 | == Installation ==
 37 | 
 38 | Use WordPress' Add New Plugin feature, searching "Duplicate Post", or download the archive and:
 39 | 
 40 | 1. Unzip the archive on your computer
 41 | 2. Upload `duplicate-post` directory to the `/wp-content/plugins/` directory
 42 | 3. Activate the plugin through the 'Plugins' menu in WordPress
 43 | 4. Go to Settings -> Duplicate Post and customize behaviour as needed
 44 | 
 45 | == Frequently Asked Questions ==
 46 | 
 47 | = The plugin doesn't work, why? =
 48 | 
 49 | First, check your version of WordPress: the plugin is not supposed to work on old versions anymore. Make sure also to upgrade to the last version of the plugin!
 50 | 
 51 | Then try to deactivate and re-activate it, some user have reported that this fixes some problems.
 52 | 
 53 | Pay also attention to the "Permissions" tab in the Settings: make sure the plugin is enabled for the desired roles and post types.
 54 | 
 55 | If it still doesn't work, maybe there is some kind of conflict with other plugins: feel free [to write in the forum](https://wordpress.org/support/plugin/duplicate-post) and we'll try to discover a solution (it will be *really* helpful if you try to deactivate all your other plugins one by one to see which one conflicts with mine... But do it only if you know what you're doing, I will not be responsible of any problem you may experience).
 56 | 
 57 | = The plugin is not translated in my language! =
 58 | 
 59 | From version 3.0 the plugin's translations are managed by the WordPress.org platform and the plugin is shipped without language files, so first of all update translations under Dashboard->Updates.
 60 | 
 61 | If Duplicate Post is still in English, or if there are some untranslated strings, you can [help translating to your language](https://translate.wordpress.org/projects/wp-plugins/duplicate-post): you only need a WordPress.org account.
 62 | 
 63 | == Screenshots ==
 64 | 
 65 | 1. Classic editor.
 66 | 2. Block editor.
 67 | 3. Post list.
 68 | 4. Admin bar menu.
 69 | 5. Bulk actions.
 70 | 6. The options page.
 71 | 
 72 | == Changelog ==
 73 | 
 74 | = 4.5 =
 75 | 
 76 | Release date: 2022-06-28
 77 | 
 78 | #### Enhancements
 79 | 
 80 | * Improves the impact of the plugin on the performance of the site by avoiding useless calls on the `gettext` filter.
 81 | 
 82 | #### Bugfixes
 83 | 
 84 | * Fixes a bug where a section in the Classic Editor's submitbox would be displayed with incorrect margins.
 85 | 
 86 | #### Other
 87 | 
 88 | * Sets the WordPress tested up to version to 6.0.
 89 | 
 90 | = 4.4 =
 91 | 
 92 | Release date: 2022-01-25
 93 | 
 94 | #### Enhancements
 95 | 
 96 | * Converts the upgrade notice into a welcome notice for first-time users.
 97 | 
 98 | #### Bugfixes
 99 | 
100 | * Fixes a bug where HTML tags in a Custom HTML block would be removed when republishing a scheduled Rewrite & Republish copy.
101 | * Fixes a bug where the button style would be broken in the Classic Editor.
102 | * Fixes a bug where a fatal error would be triggered in the Widgets page in combination with some themes or plugins.
103 | 
104 | #### Other
105 | 
106 | * Sets the WordPress tested up to version to 5.9.
107 | 
108 | = Earlier versions =
109 | For the changelog of earlier versions, please refer to [the changelog on yoast.com](https://yoa.st/duplicate-post-changelog).
110 | 
111 | == Contribute ==
112 | 
113 | If you find this useful and if you want to contribute, there are two ways:
114 | 
115 |    1. Submit your bug reports, suggestions and requests for features on [GitHub](https://github.com/Yoast/duplicate-post);
116 |    2. If you want to translate it to your language (there are just a few lines of text), you can use the [translation project](https://translate.wordpress.org/projects/wp-plugins/duplicate-post);
117 | 


--------------------------------------------------------------------------------
/src/admin/options-form-generator.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Admin;
  4 | 
  5 | use WP_Taxonomy;
  6 | use Yoast\WP\Duplicate_Post\Utils;
  7 | 
  8 | /**
  9 |  * Class Options_Form_Generator.
 10 |  */
 11 | class Options_Form_Generator {
 12 | 
 13 | 	/**
 14 | 	 * The Options_Inputs instance.
 15 | 	 *
 16 | 	 * @var Options_Inputs
 17 | 	 */
 18 | 	protected $options_inputs;
 19 | 
 20 | 	/**
 21 | 	 * Options_Form_Generator constructor.
 22 | 	 *
 23 | 	 * @param Options_Inputs $inputs The Options_Inputs instance.
 24 | 	 */
 25 | 	public function __construct( Options_Inputs $inputs ) {
 26 | 		$this->options_inputs = $inputs;
 27 | 	}
 28 | 
 29 | 	/**
 30 | 	 * Generates the HTML output of an input control, based on the passed options.
 31 | 	 *
 32 | 	 * @param array  $options       The options to base the input on.
 33 | 	 * @param string $parent_option The parent option, used for grouped inputs. Optional.
 34 | 	 *
 35 | 	 * @return string The HTML output.
 36 | 	 */
 37 | 	public function generate_options_input( array $options, $parent_option = '' ) {
 38 | 		$output = '';
 39 | 
 40 | 		foreach ( $options as $option => $option_values ) {
 41 | 			// Skip empty options.
 42 | 			if ( empty( $option_values ) ) {
 43 | 				continue;
 44 | 			}
 45 | 
 46 | 			// Check for support of the current WordPress version.
 47 | 			if ( \array_key_exists( 'version', $option_values ) && \version_compare( \get_bloginfo( 'version' ), $option_values['version'] ) < 0 ) {
 48 | 				continue;
 49 | 			}
 50 | 
 51 | 			if ( \array_key_exists( 'sub_options', $option_values ) ) {
 52 | 				$output .= $this->generate_options_input( $option_values['sub_options'], $option );
 53 | 
 54 | 				continue;
 55 | 			}
 56 | 
 57 | 			// If callback, call it.
 58 | 			if ( \array_key_exists( 'callback', $option_values ) ) {
 59 | 				$output .= $this->{$option_values['callback']}();
 60 | 
 61 | 				continue;
 62 | 			}
 63 | 
 64 | 			if ( ! \array_key_exists( 'type', $option_values ) ) {
 65 | 				continue;
 66 | 			}
 67 | 
 68 | 			$id = ( \array_key_exists( 'id', $option_values ) ? $option_values['id'] : $this->prepare_input_id( $option ) );
 69 | 
 70 | 			if ( $parent_option !== '' ) {
 71 | 				$id     = \sprintf( '%s-%s', $this->prepare_input_id( $parent_option ), $id );
 72 | 				$option = \sprintf( '%s[%s]', $parent_option, $option );
 73 | 			}
 74 | 
 75 | 			switch ( $option_values['type'] ) {
 76 | 				case 'checkbox':
 77 | 					$output .= $this->options_inputs->checkbox(
 78 | 						$option,
 79 | 						$option_values['value'],
 80 | 						$id,
 81 | 						$this->is_checked( $option, $option_values, $parent_option )
 82 | 					);
 83 | 
 84 | 					$output .= \sprintf( '<label for="%s">%s</label>', $id, \esc_html( $option_values['label'] ) );
 85 | 					break;
 86 | 				case 'text':
 87 | 					$output .= $this->options_inputs->text( $option, $option_values['value'], $id );
 88 | 					break;
 89 | 				case 'number':
 90 | 					$output .= $this->options_inputs->number( $option, $option_values['value'], $id );
 91 | 
 92 | 					break;
 93 | 			}
 94 | 
 95 | 			if ( \array_key_exists( 'description', $option_values ) ) {
 96 | 				$output .= ' ' . $this->extract_description( $option_values['description'], $id );
 97 | 			}
 98 | 
 99 | 			$output .= '<br />';
100 | 		}
101 | 
102 | 		return $output;
103 | 	}
104 | 
105 | 	/**
106 | 	 * Sorts taxonomy objects based on being public, followed by being private
107 | 	 * and when the visibility is equal, on the taxonomy public name (case-sensitive).
108 | 	 *
109 | 	 * @param WP_Taxonomy $taxonomy1 First taxonomy object.
110 | 	 * @param WP_Taxonomy $taxonomy2 Second taxonomy object.
111 | 	 *
112 | 	 * @return int An integer less than, equal to, or greater than zero indicating respectively
113 | 	 *             the first taxonomy should be sorted before, at the same level or after the second taxonomy.
114 | 	 */
115 | 	public function sort_taxonomy_objects( $taxonomy1, $taxonomy2 ) {
116 | 		if ( $taxonomy1->public === true && $taxonomy2->public === false ) {
117 | 			return -1;
118 | 		}
119 | 		elseif ( $taxonomy1->public === false && $taxonomy2->public === true ) {
120 | 			return 1;
121 | 		}
122 | 
123 | 		// Same visibility, sort by name.
124 | 		return \strnatcmp( $taxonomy1->labels->name, $taxonomy2->labels->name );
125 | 	}
126 | 
127 | 	/**
128 | 	 * Extracts and formats the description associated with the input field.
129 | 	 *
130 | 	 * @param string|array<string> $description The description string. Can be an array of strings.
131 | 	 * @param string               $id          The ID of the input field.
132 | 	 *
133 | 	 * @return string The description HTML for the input.
134 | 	 */
135 | 	public function extract_description( $description, $id ) {
136 | 		if ( ! \is_array( $description ) ) {
137 | 			return \sprintf( '<span id="%s-description">(%s)</span>', $id, \esc_html( $description ) );
138 | 		}
139 | 
140 | 		return \sprintf( '<p id="%s-description">%s</p>', $id, \implode( '<br />', \array_map( '\esc_html', $description ) ) );
141 | 	}
142 | 
143 | 	/**
144 | 	 * Generates a list of checkboxes for registered taxonomies.
145 | 	 *
146 | 	 * @return string The generated taxonomies list.
147 | 	 */
148 | 	public function generate_taxonomy_exclusion_list() {
149 | 		$taxonomies = \get_taxonomies( [], 'objects' );
150 | 
151 | 		\usort( $taxonomies, [ $this, 'sort_taxonomy_objects' ] );
152 | 
153 | 		$taxonomies_blacklist = \get_option( 'duplicate_post_taxonomies_blacklist' );
154 | 
155 | 		if ( ! \is_array( $taxonomies_blacklist ) ) {
156 | 			$taxonomies_blacklist = [];
157 | 		}
158 | 
159 | 		$output = '';
160 | 
161 | 		foreach ( $taxonomies as $taxonomy ) {
162 | 			if ( $taxonomy->name === 'post_format' ) {
163 | 				continue;
164 | 			}
165 | 
166 | 			$is_public = ( $taxonomy->public ) ? 'public' : 'private';
167 | 			$name      = \esc_attr( $taxonomy->name );
168 | 
169 | 			$output .= \sprintf( '<div class="taxonomy_%s">', $is_public );
170 | 			$output .= $this->generate_options_input(
171 | 				[
172 | 					'duplicate_post_taxonomies_blacklist[]' => [
173 | 						'type'    => 'checkbox',
174 | 						'id'      => 'duplicate-post-' . $this->prepare_input_id( $name ),
175 | 						'value'   => $name,
176 | 						'checked' => \in_array( $taxonomy->name, $taxonomies_blacklist, true ),
177 | 						'label'   => $taxonomy->labels->name . ' [' . $taxonomy->name . ']',
178 | 					],
179 | 				]
180 | 			);
181 | 			$output .= '</div>';
182 | 		}
183 | 
184 | 		return $output;
185 | 	}
186 | 
187 | 	/**
188 | 	 * Generates a list of checkboxes for registered roles.
189 | 	 *
190 | 	 * @return string The generated roles list.
191 | 	 */
192 | 	public function generate_roles_permission_list() {
193 | 		$post_types        = \get_post_types( [ 'show_ui' => true ], 'objects' );
194 | 		$edit_capabilities = [ 'edit_posts' => true ];
195 | 
196 | 		foreach ( $post_types as $post_type ) {
197 | 			$edit_capabilities[ $post_type->cap->edit_posts ] = true;
198 | 		}
199 | 
200 | 		$output = '';
201 | 
202 | 		foreach ( Utils::get_roles() as $name => $display_name ) {
203 | 			$role = \get_role( $name );
204 | 
205 | 			if ( \count( \array_intersect_key( $role->capabilities, $edit_capabilities ) ) > 0 ) {
206 | 				$output .= $this->generate_options_input(
207 | 					[
208 | 						'duplicate_post_roles[]' => [
209 | 							'type'    => 'checkbox',
210 | 							'id'      => 'duplicate-post-' . $this->prepare_input_id( $name ),
211 | 							'value'   => $name,
212 | 							'checked' => $role->has_cap( 'copy_posts' ),
213 | 							'label'   => \translate_user_role( $display_name ),
214 | 						],
215 | 					]
216 | 				);
217 | 			}
218 | 		}
219 | 
220 | 		return $output;
221 | 	}
222 | 
223 | 	/**
224 | 	 * Generates a list of checkboxes for registered post types.
225 | 	 *
226 | 	 * @return string The generated post types list.
227 | 	 */
228 | 	public function generate_post_types_list() {
229 | 		$post_types        = \get_post_types( [ 'show_ui' => true ], 'objects' );
230 | 		$hidden_post_types = $this->get_hidden_post_types();
231 | 		$output            = '';
232 | 
233 | 		foreach ( $post_types as $post_type_object ) {
234 | 			if ( \in_array( $post_type_object->name, $hidden_post_types, true ) ) {
235 | 				continue;
236 | 			}
237 | 
238 | 			$name = \esc_attr( $post_type_object->name );
239 | 
240 | 			$output .= $this->generate_options_input(
241 | 				[
242 | 					'duplicate_post_types_enabled[]' => [
243 | 						'type'    => 'checkbox',
244 | 						'id'      => 'duplicate-post-' . $this->prepare_input_id( $name ),
245 | 						'value'   => $name,
246 | 						'checked' => $this->is_post_type_enabled( $post_type_object->name ),
247 | 						'label'   => $post_type_object->labels->name,
248 | 					],
249 | 				]
250 | 			);
251 | 		}
252 | 
253 | 		return $output;
254 | 	}
255 | 
256 | 	/**
257 | 	 * Determines whether the passed option should result in a checked checkbox or not.
258 | 	 *
259 | 	 * @param string $option        The option to search for.
260 | 	 * @param array  $option_values The option's values.
261 | 	 * @param string $parent_option The parent option. Optional.
262 | 	 *
263 | 	 * @return bool Whether or not the checkbox should be checked.
264 | 	 */
265 | 	public function is_checked( $option, $option_values, $parent_option = '' ) {
266 | 		if ( \array_key_exists( 'checked', $option_values ) ) {
267 | 			return $option_values['checked'];
268 | 		}
269 | 
270 | 		// Check for serialized options.
271 | 		$saved_option = ! empty( $parent_option ) ? \get_option( $parent_option ) : \get_option( $option );
272 | 
273 | 		if ( ! \is_array( $saved_option ) ) {
274 | 			return (int) $saved_option === 1;
275 | 		}
276 | 
277 | 		// Clean up the sub-option's name.
278 | 		$cleaned_option = \trim( \str_replace( $parent_option, '', $option ), '[]' );
279 | 
280 | 		return \array_key_exists( $cleaned_option, $saved_option ) && (int) $saved_option[ $cleaned_option ] === 1;
281 | 	}
282 | 
283 | 	/**
284 | 	 * Prepares the passed ID so it's properly formatted.
285 | 	 *
286 | 	 * @param string $id The ID to prepare.
287 | 	 *
288 | 	 * @return string The prepared input ID.
289 | 	 */
290 | 	public function prepare_input_id( $id ) {
291 | 		return \str_replace( '_', '-', $id );
292 | 	}
293 | 
294 | 	/**
295 | 	 * Checks whether or not a post type is enabled.
296 | 	 *
297 | 	 * @codeCoverageIgnore As this is a simple wrapper for a function that is also being used elsewhere, we can skip testing for now.
298 | 	 *
299 | 	 * @param string $post_type The post type.
300 | 	 *
301 | 	 * @return bool Whether or not the post type is enabled.
302 | 	 */
303 | 	public function is_post_type_enabled( $post_type ) {
304 | 		$duplicate_post_types_enabled = \get_option( 'duplicate_post_types_enabled', [ 'post', 'page' ] );
305 | 		if ( ! \is_array( $duplicate_post_types_enabled ) ) {
306 | 			$duplicate_post_types_enabled = [ $duplicate_post_types_enabled ];
307 | 		}
308 | 		return \in_array( $post_type, $duplicate_post_types_enabled, true );
309 | 	}
310 | 
311 | 	/**
312 | 	 * Generates a list of post types that should be hidden from the options page.
313 | 	 *
314 | 	 * @return array The array of names of the post types to hide.
315 | 	 */
316 | 	public function get_hidden_post_types() {
317 | 		$hidden_post_types = [
318 | 			'attachment',
319 | 			'wp_block',
320 | 		];
321 | 
322 | 		if ( Utils::is_plugin_active( 'woocommerce/woocommerce.php' ) ) {
323 | 			$hidden_post_types[] = 'product';
324 | 		}
325 | 
326 | 		return $hidden_post_types;
327 | 	}
328 | }
329 | 


--------------------------------------------------------------------------------
/src/admin/options-inputs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post\Admin;
 4 | 
 5 | /**
 6 |  * Class Options_Inputs.
 7 |  */
 8 | class Options_Inputs {
 9 | 
10 | 	/**
11 | 	 * Creates a basic input based on the passed parameters.
12 | 	 *
13 | 	 * @param string $type       The type of input.
14 | 	 * @param string $name       The name of the input.
15 | 	 * @param string $value      The value of the input.
16 | 	 * @param string $id         The ID of the input.
17 | 	 * @param string $attributes The additional attributes to use. Optional.
18 | 	 *
19 | 	 * @return string The input's HTML output.
20 | 	 */
21 | 	protected function input( $type, $name, $value, $id, $attributes = '' ) {
22 | 		return \sprintf(
23 | 			'<input type="%s" name="%s" id="%s" value="%s" %s />',
24 | 			\esc_attr( $type ),
25 | 			\esc_attr( $name ),
26 | 			\esc_attr( $id ),
27 | 			\esc_attr( $value ),
28 | 			$attributes
29 | 		);
30 | 	}
31 | 
32 | 	/**
33 | 	 * Creates a checkbox input.
34 | 	 *
35 | 	 * @param string $name    The name of the checkbox.
36 | 	 * @param string $value   The value of the checkbox.
37 | 	 * @param string $id      The ID of the checkbox.
38 | 	 * @param bool   $checked Whether or not the checkbox should be checked.
39 | 	 *
40 | 	 * @return string The checkbox' HTML output.
41 | 	 */
42 | 	public function checkbox( $name, $value, $id, $checked = false ) {
43 | 		$checked = \checked( $checked, true, false );
44 | 
45 | 		return $this->input( 'checkbox', $name, $value, $id, $checked );
46 | 	}
47 | 
48 | 	/**
49 | 	 * Creates a text field input.
50 | 	 *
51 | 	 * @param string $name  The name of the text field.
52 | 	 * @param string $value The value of the text field.
53 | 	 * @param string $id    The ID of the text field.
54 | 	 *
55 | 	 * @return string The text field's HTML output.
56 | 	 */
57 | 	public function text( $name, $value, $id ) {
58 | 		return $this->input( 'text', $name, $value, $id );
59 | 	}
60 | 
61 | 	/**
62 | 	 * Creates a number input.
63 | 	 *
64 | 	 * @param string $name  The name of the number input.
65 | 	 * @param string $value The value of the number input.
66 | 	 * @param string $id    The ID of the number input.
67 | 	 *
68 | 	 * @return string The number input's HTML output.
69 | 	 */
70 | 	public function number( $name, $value, $id ) {
71 | 		return $this->input( 'number', $name, $value, $id, 'min="0" step="1"' );
72 | 	}
73 | }
74 | 


--------------------------------------------------------------------------------
/src/admin/options-page.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Admin;
  4 | 
  5 | use Yoast\WP\Duplicate_Post\UI\Asset_Manager;
  6 | use Yoast\WP\Duplicate_Post\Utils;
  7 | 
  8 | /**
  9 |  * Class Options_Page.
 10 |  */
 11 | class Options_Page {
 12 | 
 13 | 	/**
 14 | 	 * The Options instance.
 15 | 	 *
 16 | 	 * @var Options
 17 | 	 */
 18 | 	protected $options;
 19 | 
 20 | 	/**
 21 | 	 * The Options_Form_Generator instance.
 22 | 	 *
 23 | 	 * @var Options_Form_Generator
 24 | 	 */
 25 | 	protected $generator;
 26 | 
 27 | 	/**
 28 | 	 * Holds the asset manager.
 29 | 	 *
 30 | 	 * @var Asset_Manager
 31 | 	 */
 32 | 	protected $asset_manager;
 33 | 
 34 | 	/**
 35 | 	 * Options_Page constructor.
 36 | 	 *
 37 | 	 * @param Options                $options       The Options class instance.
 38 | 	 * @param Options_Form_Generator $generator     The Options_Form_Generator class instance.
 39 | 	 * @param Asset_Manager          $asset_manager The Asset_Manager class instance.
 40 | 	 */
 41 | 	public function __construct( Options $options, Options_Form_Generator $generator, Asset_Manager $asset_manager ) {
 42 | 		$this->options       = $options;
 43 | 		$this->generator     = $generator;
 44 | 		$this->asset_manager = $asset_manager;
 45 | 	}
 46 | 
 47 | 	/**
 48 | 	 * Registers the necessary hooks.
 49 | 	 *
 50 | 	 * @return void
 51 | 	 */
 52 | 	public function register_hooks() {
 53 | 		if ( \is_admin() ) {
 54 | 			\add_action( 'admin_menu', [ $this, 'register_menu' ] );
 55 | 			\add_action( 'admin_init', [ $this->options, 'register_settings' ] );
 56 | 		}
 57 | 	}
 58 | 
 59 | 	/**
 60 | 	 * Enqueues the assets.
 61 | 	 *
 62 | 	 * @return void
 63 | 	 */
 64 | 	public function enqueue_assets() {
 65 | 		$this->asset_manager->enqueue_options_styles();
 66 | 		$this->asset_manager->enqueue_options_script();
 67 | 	}
 68 | 
 69 | 	/**
 70 | 	 * Registers the menu item.
 71 | 	 *
 72 | 	 * @return void
 73 | 	 */
 74 | 	public function register_menu() {
 75 | 		$page_hook = \add_options_page(
 76 | 			\__( 'Duplicate Post Options', 'duplicate-post' ),
 77 | 			\__( 'Duplicate Post', 'duplicate-post' ),
 78 | 			'manage_options',
 79 | 			'duplicatepost',
 80 | 			[ $this, 'generate_page' ]
 81 | 		);
 82 | 
 83 | 		\add_action( $page_hook, [ $this, 'enqueue_assets' ] );
 84 | 	}
 85 | 
 86 | 	/**
 87 | 	 * Generates the inputs for the specified tab / fieldset.
 88 | 	 *
 89 | 	 * @codeCoverageIgnore As this is a simple wrapper for two functions that are already tested elsewhere, we can skip testing.
 90 | 	 *
 91 | 	 * @param string $tab      The tab to get the configuration for.
 92 | 	 * @param string $fieldset The fieldset to get the configuration for. Optional.
 93 | 	 *
 94 | 	 * @return string The HTML output for the controls present on the tab / fieldset.
 95 | 	 */
 96 | 	public function generate_tab_inputs( $tab, $fieldset = '' ) {
 97 | 		$options = $this->options->get_options_for_tab( $tab, $fieldset );
 98 | 
 99 | 		return $this->generator->generate_options_input( $options );
100 | 	}
101 | 
102 | 	/**
103 | 	 * Generates an input for a single option.
104 | 	 *
105 | 	 * @codeCoverageIgnore As this is a simple wrapper for two functions that are already tested elsewhere, we can skip testing.
106 | 	 *
107 | 	 * @param string $option The option configuration to base the input on.
108 | 	 *
109 | 	 * @return string The input HTML.
110 | 	 */
111 | 	public function generate_input( $option ) {
112 | 		return $this->generator->generate_options_input( $this->options->get_option( $option ) );
113 | 	}
114 | 
115 | 	/**
116 | 	 * Registers the proper capabilities.
117 | 	 *
118 | 	 * @return void
119 | 	 */
120 | 	public function register_capabilities() {
121 | 		if ( ! \current_user_can( 'promote_users' ) || ! $this->settings_updated() ) {
122 | 			return;
123 | 		}
124 | 
125 | 		$roles = $this->get_duplicate_post_roles();
126 | 
127 | 		foreach ( Utils::get_roles() as $name => $display_name ) {
128 | 			$role = \get_role( $name );
129 | 
130 | 			if ( ! $role->has_cap( 'copy_posts' ) && \in_array( $name, $roles, true ) ) {
131 | 				/* If the role doesn't have the capability and it was selected, add it. */
132 | 				$role->add_cap( 'copy_posts' );
133 | 			}
134 | 
135 | 			if ( $role->has_cap( 'copy_posts' ) && ! \in_array( $name, $roles, true ) ) {
136 | 				/* If the role has the capability and it wasn't selected, remove it. */
137 | 				$role->remove_cap( 'copy_posts' );
138 | 			}
139 | 		}
140 | 	}
141 | 
142 | 	/**
143 | 	 * Generates the options page.
144 | 	 *
145 | 	 * @codeCoverageIgnore
146 | 	 *
147 | 	 * @return void
148 | 	 */
149 | 	public function generate_page() {
150 | 		$this->register_capabilities();
151 | 
152 | 		require_once \DUPLICATE_POST_PATH . 'src/admin/views/options.php';
153 | 	}
154 | 
155 | 	/**
156 | 	 * Checks whether settings have been updated.
157 | 	 *
158 | 	 * @return bool Whether or not the settings have been updated.
159 | 	 */
160 | 	protected function settings_updated() {
161 | 		return isset( $_GET['settings-updated'] ) && $_GET['settings-updated'] === 'true';
162 | 	}
163 | 
164 | 	/**
165 | 	 * Gets the registered custom roles.
166 | 	 *
167 | 	 * @return array The roles. Returns an empty array if there are none.
168 | 	 */
169 | 	protected function get_duplicate_post_roles() {
170 | 		$roles = \get_option( 'duplicate_post_roles' );
171 | 
172 | 		if ( empty( $roles ) ) {
173 | 			$roles = [];
174 | 		}
175 | 
176 | 		return $roles;
177 | 	}
178 | }
179 | 


--------------------------------------------------------------------------------
/src/admin/options.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Admin;
  4 | 
  5 | /**
  6 |  * Options class.
  7 |  *
  8 |  * @since 4.0
  9 |  */
 10 | class Options {
 11 | 
 12 | 	/**
 13 | 	 * Registers the settings.
 14 | 	 *
 15 | 	 * @return void
 16 | 	 */
 17 | 	public function register_settings() {
 18 | 		foreach ( \array_keys( $this->get_options() ) as $option ) {
 19 | 			\register_setting( 'duplicate_post_group', $option );
 20 | 		}
 21 | 	}
 22 | 
 23 | 	/**
 24 | 	 * Gets the options for the specified tab.
 25 | 	 *
 26 | 	 * Also allows filtering on a particular fieldset.
 27 | 	 *
 28 | 	 * @param string $tab      The tab to get the options for.
 29 | 	 * @param string $fieldset The fieldset to get the options for. Optional.
 30 | 	 *
 31 | 	 * @return array The options for the specified tab.
 32 | 	 */
 33 | 	public function get_options_for_tab( $tab, $fieldset = '' ) {
 34 | 		$options = $this->get_options();
 35 | 
 36 | 		$options = \array_filter(
 37 | 			$options,
 38 | 			static function ( $option ) use ( $tab ) {
 39 | 				return \array_key_exists( 'tab', $option ) && $option['tab'] === $tab;
 40 | 			}
 41 | 		);
 42 | 
 43 | 		if ( empty( $options ) ) {
 44 | 			return [];
 45 | 		}
 46 | 
 47 | 		// If a fieldset is specified, filter out the corresponding options.
 48 | 		if ( ! empty( $fieldset ) ) {
 49 | 			$options = \array_filter(
 50 | 				$options,
 51 | 				static function ( $option ) use ( $fieldset ) {
 52 | 					return \array_key_exists( 'fieldset', $option ) && $option['fieldset'] === $fieldset;
 53 | 				}
 54 | 			);
 55 | 		}
 56 | 
 57 | 		return $options;
 58 | 	}
 59 | 
 60 | 	/**
 61 | 	 * Gets an option from the options array, based on its name.
 62 | 	 *
 63 | 	 * @param string $name The name of the option to retrieve.
 64 | 	 *
 65 | 	 * @return array The option. Empty array if it does not exist.
 66 | 	 */
 67 | 	public function get_option( $name ) {
 68 | 		$options = $this->get_options();
 69 | 
 70 | 		return \array_key_exists( $name, $options ) ? [ $name => $options[ $name ] ] : [];
 71 | 	}
 72 | 
 73 | 	/**
 74 | 	 * Gets the list of registered options.
 75 | 	 *
 76 | 	 * @codeCoverageIgnore
 77 | 	 *
 78 | 	 * @return array The options.
 79 | 	 */
 80 | 	public function get_options() {
 81 | 		return [
 82 | 			'duplicate_post_copytitle'                    => [
 83 | 				'tab'      => 'what-to-copy',
 84 | 				'fieldset' => 'elements-to-copy',
 85 | 				'type'     => 'checkbox',
 86 | 				'label'    => \__( 'Title', 'duplicate-post' ),
 87 | 				'value'    => 1,
 88 | 			],
 89 | 			'duplicate_post_copydate'                     => [
 90 | 				'tab'      => 'what-to-copy',
 91 | 				'fieldset' => 'elements-to-copy',
 92 | 				'type'     => 'checkbox',
 93 | 				'label'    => \__( 'Date', 'duplicate-post' ),
 94 | 				'value'    => 1,
 95 | 			],
 96 | 			'duplicate_post_copystatus'                   => [
 97 | 				'tab'      => 'what-to-copy',
 98 | 				'fieldset' => 'elements-to-copy',
 99 | 				'type'     => 'checkbox',
100 | 				'label'    => \__( 'Status', 'duplicate-post' ),
101 | 				'value'    => 1,
102 | 			],
103 | 			'duplicate_post_copyslug'                     => [
104 | 				'tab'      => 'what-to-copy',
105 | 				'fieldset' => 'elements-to-copy',
106 | 				'type'     => 'checkbox',
107 | 				'label'    => \__( 'Slug', 'duplicate-post' ),
108 | 				'value'    => 1,
109 | 			],
110 | 			'duplicate_post_copyexcerpt'                  => [
111 | 				'tab'      => 'what-to-copy',
112 | 				'fieldset' => 'elements-to-copy',
113 | 				'type'     => 'checkbox',
114 | 				'label'    => \__( 'Excerpt', 'duplicate-post' ),
115 | 				'value'    => 1,
116 | 			],
117 | 			'duplicate_post_copycontent'                  => [
118 | 				'tab'      => 'what-to-copy',
119 | 				'fieldset' => 'elements-to-copy',
120 | 				'type'     => 'checkbox',
121 | 				'label'    => \__( 'Content', 'duplicate-post' ),
122 | 				'value'    => 1,
123 | 			],
124 | 			'duplicate_post_copythumbnail'                => [
125 | 				'tab'      => 'what-to-copy',
126 | 				'fieldset' => 'elements-to-copy',
127 | 				'type'     => 'checkbox',
128 | 				'label'    => \__( 'Featured Image', 'duplicate-post' ),
129 | 				'value'    => 1,
130 | 			],
131 | 			'duplicate_post_copytemplate'                 => [
132 | 				'tab'      => 'what-to-copy',
133 | 				'fieldset' => 'elements-to-copy',
134 | 				'type'     => 'checkbox',
135 | 				'label'    => \__( 'Template', 'duplicate-post' ),
136 | 				'value'    => 1,
137 | 			],
138 | 			'duplicate_post_copyformat'                   => [
139 | 				'tab'      => 'what-to-copy',
140 | 				'fieldset' => 'elements-to-copy',
141 | 				'type'     => 'checkbox',
142 | 				'label'    => \__( 'Post format', 'duplicate-post' ),
143 | 				'value'    => 1,
144 | 			],
145 | 			'duplicate_post_copyauthor'                   => [
146 | 				'tab'      => 'what-to-copy',
147 | 				'fieldset' => 'elements-to-copy',
148 | 				'type'     => 'checkbox',
149 | 				'label'    => \__( 'Author', 'duplicate-post' ),
150 | 				'value'    => 1,
151 | 			],
152 | 			'duplicate_post_copypassword'                 => [
153 | 				'tab'      => 'what-to-copy',
154 | 				'fieldset' => 'elements-to-copy',
155 | 				'type'     => 'checkbox',
156 | 				'label'    => \__( 'Password', 'duplicate-post' ),
157 | 				'value'    => 1,
158 | 			],
159 | 			'duplicate_post_copyattachments'              => [
160 | 				'tab'         => 'what-to-copy',
161 | 				'fieldset'    => 'elements-to-copy',
162 | 				'type'        => 'checkbox',
163 | 				'label'       => \__( 'Attachments', 'duplicate-post' ),
164 | 				'value'       => 1,
165 | 				'description' => \__( 'you probably want this unchecked, unless you have very special requirements', 'duplicate-post' ),
166 | 			],
167 | 			'duplicate_post_copychildren'                 => [
168 | 				'tab'      => 'what-to-copy',
169 | 				'fieldset' => 'elements-to-copy',
170 | 				'type'     => 'checkbox',
171 | 				'label'    => \__( 'Children', 'duplicate-post' ),
172 | 				'value'    => 1,
173 | 			],
174 | 			'duplicate_post_copycomments'                 => [
175 | 				'tab'         => 'what-to-copy',
176 | 				'fieldset'    => 'elements-to-copy',
177 | 				'type'        => 'checkbox',
178 | 				'label'       => \__( 'Comments', 'duplicate-post' ),
179 | 				'value'       => 1,
180 | 				'description' => \__( 'except pingbacks and trackbacks', 'duplicate-post' ),
181 | 			],
182 | 			'duplicate_post_copymenuorder'                => [
183 | 				'tab'      => 'what-to-copy',
184 | 				'fieldset' => 'elements-to-copy',
185 | 				'type'     => 'checkbox',
186 | 				'label'    => \__( 'Menu order', 'duplicate-post' ),
187 | 				'value'    => 1,
188 | 			],
189 | 			'duplicate_post_title_prefix'                 => [
190 | 				'tab'         => 'what-to-copy',
191 | 				'type'        => 'text',
192 | 				'label'       => \__( 'Title prefix', 'duplicate-post' ),
193 | 				'value'       => \get_option( 'duplicate_post_title_prefix' ),
194 | 				'description' => [ \__( 'Prefix to be added before the title, e.g. "Copy of" (blank for no prefix)', 'duplicate-post' ) ],
195 | 			],
196 | 			'duplicate_post_title_suffix'                 => [
197 | 				'tab'         => 'what-to-copy',
198 | 				'type'        => 'text',
199 | 				'label'       => \__( 'Title suffix', 'duplicate-post' ),
200 | 				'value'       => \get_option( 'duplicate_post_title_suffix' ),
201 | 				'description' => [ \__( 'Suffix to be added after the title, e.g. "(dup)" (blank for no suffix)', 'duplicate-post' ) ],
202 | 			],
203 | 			'duplicate_post_increase_menu_order_by'       => [
204 | 				'tab'         => 'what-to-copy',
205 | 				'type'        => 'number',
206 | 				'label'       => \__( 'Increase menu order by', 'duplicate-post' ),
207 | 				'value'       => \get_option( 'duplicate_post_increase_menu_order_by' ),
208 | 				'description' => [ \__( 'Add this number to the original menu order (blank or zero to retain the value)', 'duplicate-post' ) ],
209 | 			],
210 | 			'duplicate_post_blacklist'                    => [
211 | 				'tab'         => 'what-to-copy',
212 | 				'type'        => 'text',
213 | 				'label'       => \__( 'Do not copy these fields', 'duplicate-post' ),
214 | 				'value'       => \get_option( 'duplicate_post_blacklist' ),
215 | 				'description' => [
216 | 					\__( 'Comma-separated list of meta fields that must not be copied.', 'duplicate-post' ),
217 | 					\__( 'You can use * to match zero or more alphanumeric characters or underscores: e.g. field*', 'duplicate-post' ),
218 | 				],
219 | 			],
220 | 			'duplicate_post_taxonomies_blacklist'         => [
221 | 				'tab'      => 'what-to-copy',
222 | 				'callback' => 'generate_taxonomy_exclusion_list',
223 | 			],
224 | 			'duplicate_post_roles'                        => [
225 | 				'tab'      => 'permissions',
226 | 				'callback' => 'generate_roles_permission_list',
227 | 			],
228 | 			'duplicate_post_types_enabled'                => [
229 | 				'tab'      => 'permissions',
230 | 				'callback' => 'generate_post_types_list',
231 | 			],
232 | 			'duplicate_post_show_original_meta_box'       => [
233 | 				'tab'         => 'display',
234 | 				'fieldset'    => 'show-original',
235 | 				'type'        => 'checkbox',
236 | 				'label'       => \__( 'In a metabox in the Edit screen', 'duplicate-post' ),
237 | 				'value'       => 1,
238 | 				'description' => [
239 | 					\__( "You'll also be able to delete the reference to the original item with a checkbox", 'duplicate-post' ),
240 | 				],
241 | 			],
242 | 			'duplicate_post_show_original_column'         => [
243 | 				'tab'         => 'display',
244 | 				'fieldset'    => 'show-original',
245 | 				'type'        => 'checkbox',
246 | 				'label'       => \__( 'In a column in the Post list', 'duplicate-post' ),
247 | 				'value'       => 1,
248 | 				'description' => [
249 | 					\__( "You'll also be able to delete the reference to the original item with a checkbox in Quick Edit", 'duplicate-post' ),
250 | 				],
251 | 			],
252 | 			'duplicate_post_show_original_in_post_states' => [
253 | 				'tab'      => 'display',
254 | 				'fieldset' => 'show-original',
255 | 				'type'     => 'checkbox',
256 | 				'label'    => \__( 'After the title in the Post list', 'duplicate-post' ),
257 | 				'value'    => 1,
258 | 			],
259 | 			'duplicate_post_show_notice'                  => [
260 | 				'tab'   => 'display',
261 | 				'type'  => 'checkbox',
262 | 				'label' => \__( 'Show welcome notice', 'duplicate-post' ),
263 | 				'value' => 1,
264 | 			],
265 | 			'duplicate_post_show_link'                    => [
266 | 				'tab'         => 'display',
267 | 				'fieldset'    => 'show-links',
268 | 				'sub_options' => [
269 | 					'new_draft'         => [
270 | 						'type'  => 'checkbox',
271 | 						'label' => \__( 'New Draft', 'duplicate-post' ),
272 | 						'value' => 1,
273 | 					],
274 | 					'clone'             => [
275 | 						'type'  => 'checkbox',
276 | 						'label' => \__( 'Clone', 'duplicate-post' ),
277 | 						'value' => 1,
278 | 					],
279 | 					'rewrite_republish' => [
280 | 						'type'  => 'checkbox',
281 | 						'label' => \__( 'Rewrite & Republish', 'duplicate-post' ),
282 | 						'value' => 1,
283 | 					],
284 | 				],
285 | 			],
286 | 			'duplicate_post_show_link_in' => [
287 | 				'tab'         => 'display',
288 | 				'fieldset'    => 'show-links-in',
289 | 				'sub_options' => [
290 | 					'row'         => [
291 | 						'type'     => 'checkbox',
292 | 						'label'    => \__( 'Post list', 'duplicate-post' ),
293 | 						'value'    => 1,
294 | 					],
295 | 					'adminbar' => [
296 | 						'type'        => 'checkbox',
297 | 						'label'       => \__( 'Admin bar', 'duplicate-post' ),
298 | 						'value'       => 1,
299 | 					],
300 | 					'submitbox' => [
301 | 						'type'  => 'checkbox',
302 | 						'label' => \__( 'Edit screen', 'duplicate-post' ),
303 | 						'value' => 1,
304 | 					],
305 | 					'bulkactions' => [
306 | 						'type'  => 'checkbox',
307 | 						'label' => \__( 'Bulk Actions', 'duplicate-post' ),
308 | 						'value' => 1,
309 | 					],
310 | 				],
311 | 			],
312 | 		];
313 | 	}
314 | }
315 | 


--------------------------------------------------------------------------------
/src/admin/views/options.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Admin\Views;
  4 | 
  5 | if ( ! \defined( 'DUPLICATE_POST_CURRENT_VERSION' ) ) {
  6 | 	\header( 'Status: 403 Forbidden' );
  7 | 	\header( 'HTTP/1.1 403 Forbidden' );
  8 | 	exit();
  9 | }
 10 | 
 11 | ?>
 12 | <div class="wrap">
 13 | 	<h1>
 14 | 		<?php \esc_html_e( 'Duplicate Post Options', 'duplicate-post' ); ?>
 15 | 	</h1>
 16 | 
 17 | 	<form id="duplicate_post_settings_form" method="post" action="options.php" style="clear: both">
 18 | 		<?php \settings_fields( 'duplicate_post_group' ); ?>
 19 | 
 20 | 		<header role="tablist" aria-label="
 21 | 		<?php
 22 | 			/* translators: Hidden accessibility text. */
 23 | 			\esc_attr_e( 'Settings sections', 'duplicate-post' );
 24 | 		?>
 25 | 		" class="nav-tab-wrapper">
 26 | 			<button
 27 | 					type="button"
 28 | 					role="tab"
 29 | 					class="nav-tab nav-tab-active"
 30 | 					aria-selected="true"
 31 | 					aria-controls="what-tab"
 32 | 					id="what"><?php \esc_html_e( 'What to copy', 'duplicate-post' ); ?>
 33 | 			</button>
 34 | 			<button
 35 | 					type="button"
 36 | 					role="tab"
 37 | 					class="nav-tab"
 38 | 					aria-selected="false"
 39 | 					aria-controls="who-tab"
 40 | 					id="who"
 41 | 					tabindex="-1"><?php \esc_html_e( 'Permissions', 'duplicate-post' ); ?>
 42 | 			</button>
 43 | 			<button
 44 | 					type="button"
 45 | 					role="tab"
 46 | 					class="nav-tab"
 47 | 					aria-selected="false"
 48 | 					aria-controls="where-tab"
 49 | 					id="where"
 50 | 					tabindex="-1"><?php \esc_html_e( 'Display', 'duplicate-post' ); ?>
 51 | 			</button>
 52 | 		</header>
 53 | 
 54 | 		<section
 55 | 				tabindex="0"
 56 | 				role="tabpanel"
 57 | 				id="what-tab"
 58 | 				aria-labelledby="what">
 59 | 			<h2 class="hide-if-js"><?php \esc_html_e( 'What to copy', 'duplicate-post' ); ?></h2>
 60 | 			<table class="form-table" role="presentation">
 61 | 				<tr>
 62 | 					<th scope="row"><?php \esc_html_e( 'Post/page elements to copy', 'duplicate-post' ); ?></th>
 63 | 					<td>
 64 | 						<fieldset>
 65 | 							<legend class="screen-reader-text"><?php \esc_html_e( 'Post/page elements to copy', 'duplicate-post' ); ?></legend>
 66 | 							<?php
 67 | 							// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
 68 | 							echo $this->generate_tab_inputs( 'what-to-copy', 'elements-to-copy' );
 69 | 							?>
 70 | 						</fieldset>
 71 | 					</td>
 72 | 				</tr>
 73 | 				<tr>
 74 | 					<th scope="row">
 75 | 						<label for="duplicate-post-title-prefix"><?php \esc_html_e( 'Title prefix', 'duplicate-post' ); ?></label>
 76 | 					</th>
 77 | 					<td>
 78 | 						<?php
 79 | 						// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
 80 | 						echo $this->generate_input( 'duplicate_post_title_prefix' );
 81 | 						?>
 82 | 					</td>
 83 | 				</tr>
 84 | 				<tr>
 85 | 					<th scope="row">
 86 | 						<label for="duplicate-post-title-suffix"><?php \esc_html_e( 'Title suffix', 'duplicate-post' ); ?></label>
 87 | 					</th>
 88 | 					<td>
 89 | 						<?php
 90 | 						// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
 91 | 						echo $this->generate_input( 'duplicate_post_title_suffix' );
 92 | 						?>
 93 | 					</td>
 94 | 				</tr>
 95 | 				<tr>
 96 | 					<th scope="row">
 97 | 						<label for="duplicate-post-increase-menu-order-by"><?php \esc_html_e( 'Increase menu order by', 'duplicate-post' ); ?></label>
 98 | 					</th>
 99 | 					<td>
100 | 						<?php
101 | 						// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
102 | 						echo $this->generate_input( 'duplicate_post_increase_menu_order_by' );
103 | 						?>
104 | 
105 | 					</td>
106 | 				</tr>
107 | 				<tr>
108 | 					<th scope="row">
109 | 						<label for="duplicate-post-blacklist"><?php \esc_html_e( 'Do not copy these fields', 'duplicate-post' ); ?></label>
110 | 					</th>
111 | 					<td id="textfield">
112 | 						<?php
113 | 						// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
114 | 						echo $this->generate_input( 'duplicate_post_blacklist' );
115 | 						?>
116 | 					</td>
117 | 				</tr>
118 | 				<tr>
119 | 					<th scope="row">
120 | 						<?php \esc_html_e( 'Do not copy these taxonomies', 'duplicate-post' ); ?><br/>
121 | 					</th>
122 | 					<td>
123 | 						<fieldset>
124 | 							<legend class="screen-reader-text"><?php \esc_html_e( 'Do not copy these taxonomies', 'duplicate-post' ); ?></legend>
125 | 							<?php
126 | 							// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
127 | 							echo $this->generate_input( 'duplicate_post_taxonomies_blacklist' );
128 | 							?>
129 | 							<button type="button" class="button-link hide-if-no-js toggle-private-taxonomies"
130 | 									aria-expanded="false">
131 | 								<?php \esc_html_e( 'Show/hide private taxonomies', 'duplicate-post' ); ?>
132 | 							</button>
133 | 						</fieldset>
134 | 					</td>
135 | 				</tr>
136 | 			</table>
137 | 		</section>
138 | 		<section
139 | 				tabindex="0"
140 | 				role="tabpanel"
141 | 				id="who-tab"
142 | 				aria-labelledby="who"
143 | 				hidden="hidden">
144 | 			<h2 class="hide-if-js"><?php \esc_html_e( 'Permissions', 'duplicate-post' ); ?></h2>
145 | 			<table class="form-table" role="presentation">
146 | 				<?php if ( \current_user_can( 'promote_users' ) ) { ?>
147 | 					<tr>
148 | 						<th scope="row"><?php \esc_html_e( 'Roles allowed to copy', 'duplicate-post' ); ?></th>
149 | 						<td>
150 | 							<fieldset>
151 | 								<legend class="screen-reader-text"><?php \esc_html_e( 'Roles allowed to copy', 'duplicate-post' ); ?></legend>
152 | 								<?php
153 | 								// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
154 | 								echo $this->generate_input( 'duplicate_post_roles' );
155 | 								?>
156 | 								<p>
157 | 									<?php \esc_html_e( 'Warning: users will be able to copy, rewrite and republish all posts, even those of other users.', 'duplicate-post' ); ?>
158 | 									<br/>
159 | 									<?php \esc_html_e( 'Passwords and contents of password-protected posts may become visible to undesired users and visitors.', 'duplicate-post' ); ?>
160 | 								</p>
161 | 							</fieldset>
162 | 						</td>
163 | 					</tr>
164 | 				<?php } ?>
165 | 				<tr>
166 | 					<th scope="row"><?php \esc_html_e( 'Enable for these post types', 'duplicate-post' ); ?>
167 | 					</th>
168 | 					<td>
169 | 						<fieldset>
170 | 							<legend class="screen-reader-text"><?php \esc_html_e( 'Enable for these post types', 'duplicate-post' ); ?></legend>
171 | 							<?php
172 | 										// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
173 | 							echo $this->generate_input( 'duplicate_post_types_enabled' );
174 | 							?>
175 | 							<p>
176 | 								<?php \esc_html_e( 'Select the post types you want the plugin to be enabled for.', 'duplicate-post' ); ?>
177 | 								<br/>
178 | 								<?php \esc_html_e( 'Whether the links are displayed for custom post types registered by themes or plugins depends on their use of standard WordPress UI elements.', 'duplicate-post' ); ?>
179 | 							</p>
180 | 						</fieldset>
181 | 					</td>
182 | 				</tr>
183 | 			</table>
184 | 		</section>
185 | 		<section
186 | 				tabindex="0"
187 | 				role="tabpanel"
188 | 				id="where-tab"
189 | 				aria-labelledby="where"
190 | 				hidden="hidden">
191 | 			<h2 class="hide-if-js"><?php \esc_html_e( 'Display', 'duplicate-post' ); ?></h2>
192 | 			<table class="form-table" role="presentation">
193 | 				<tr>
194 | 					<th scope="row"><?php \esc_html_e( 'Show these links', 'duplicate-post' ); ?></th>
195 | 					<td>
196 | 						<fieldset>
197 | 							<?php
198 | 							// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
199 | 							echo $this->generate_tab_inputs( 'display', 'show-links' );
200 | 							?>
201 | 						</fieldset>
202 | 					</td>
203 | 				</tr>
204 | 
205 | 				<tr>
206 | 					<th scope="row"><?php \esc_html_e( 'Show links in', 'duplicate-post' ); ?></th>
207 | 					<td>
208 | 						<fieldset>
209 | 							<?php
210 | 							// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
211 | 							echo $this->generate_tab_inputs( 'display', 'show-links-in' );
212 | 							?>
213 | 						</fieldset>
214 | 						<p>
215 | 							<?php \esc_html_e( 'Whether the links are displayed for custom post types registered by themes or plugins depends on their use of standard WordPress UI elements.', 'duplicate-post' ); ?>
216 | 							<br/>
217 | 							<?php
218 | 							\printf(
219 | 								/* translators: 1: Code start tag, 2: Code closing tag, 3: Link start tag to the template tag documentation, 4: Link closing tag. */
220 | 								\esc_html__( 'You can also use the template tag %1$sduplicate_post_clone_post_link( $link, $before, $after, $id )%2$s. %3$sMore info on the template tag%4$s.', 'duplicate-post' ),
221 | 								'<code>',
222 | 								'</code>',
223 | 								'<a href="' . \esc_url( 'https://developer.yoast.com/duplicate-post/functions-template-tags#duplicate_post_clone_post_link' ) . '">',
224 | 								'</a>'
225 | 							);
226 | 							?>
227 | 						</p>
228 | 					</td>
229 | 				</tr>
230 | 				<tr>
231 | 					<th scope="row"><?php \esc_html_e( 'Show original item:', 'duplicate-post' ); ?></th>
232 | 					<td>
233 | 						<?php
234 | 						// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
235 | 						echo $this->generate_tab_inputs( 'display', 'show-original' );
236 | 						?>
237 | 					</td>
238 | 				</tr>
239 | 				<tr>
240 | 					<th scope="row"><?php \esc_html_e( 'Welcome notice', 'duplicate-post' ); ?></th>
241 | 					<td>
242 | 						<?php
243 | 						// phpcs:ignore WordPress.Security.EscapeOutput -- Already escapes correctly.
244 | 						echo $this->generate_input( 'duplicate_post_show_notice' );
245 | 						?>
246 | 					</td>
247 | 				</tr>
248 | 			</table>
249 | 		</section>
250 | 		<p class="submit">
251 | 			<input type="submit" class="button button-primary" value="<?php \esc_attr_e( 'Save changes', 'duplicate-post' ); ?>"/>
252 | 		</p>
253 | 	</form>
254 | </div>
255 | 


--------------------------------------------------------------------------------
/src/duplicate-post.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post;
 4 | 
 5 | use Yoast\WP\Duplicate_Post\Handlers\Handler;
 6 | use Yoast\WP\Duplicate_Post\UI\User_Interface;
 7 | use Yoast\WP\Duplicate_Post\Watchers\Watchers;
 8 | 
 9 | /**
10 |  * Duplicate Post main class.
11 |  *
12 |  * @since 4.0
13 |  */
14 | class Duplicate_Post {
15 | 
16 | 	/**
17 | 	 * Permissions_Helper object.
18 | 	 *
19 | 	 * @var Permissions_Helper
20 | 	 */
21 | 	protected $permissions_helper;
22 | 
23 | 	/**
24 | 	 * User_Interface object.
25 | 	 *
26 | 	 * @var User_Interface
27 | 	 */
28 | 	protected $user_interface;
29 | 
30 | 	/**
31 | 	 * Post_Duplicator object.
32 | 	 *
33 | 	 * @var Post_Duplicator
34 | 	 */
35 | 	protected $post_duplicator;
36 | 
37 | 	/**
38 | 	 * Handler object.
39 | 	 *
40 | 	 * @var Handler
41 | 	 */
42 | 	protected $handler;
43 | 
44 | 	/**
45 | 	 * Post_Republisher object.
46 | 	 *
47 | 	 * @var Post_Republisher
48 | 	 */
49 | 	protected $post_republisher;
50 | 
51 | 	/**
52 | 	 * Revisions_Migrator object.
53 | 	 *
54 | 	 * @var Revisions_Migrator
55 | 	 */
56 | 	protected $revisions_migrator;
57 | 
58 | 	/**
59 | 	 * Watchers object.
60 | 	 *
61 | 	 * @var Watchers
62 | 	 */
63 | 	protected $watchers;
64 | 
65 | 	/**
66 | 	 * Initializes the main class.
67 | 	 */
68 | 	public function __construct() {
69 | 		$this->permissions_helper = new Permissions_Helper();
70 | 		$this->user_interface     = new User_Interface( $this->permissions_helper );
71 | 		$this->post_duplicator    = new Post_Duplicator();
72 | 		$this->handler            = new Handler( $this->post_duplicator, $this->permissions_helper );
73 | 		$this->post_republisher   = new Post_Republisher( $this->post_duplicator, $this->permissions_helper );
74 | 		$this->revisions_migrator = new Revisions_Migrator();
75 | 		$this->watchers           = new Watchers( $this->permissions_helper );
76 | 
77 | 		$this->post_republisher->register_hooks();
78 | 		$this->revisions_migrator->register_hooks();
79 | 	}
80 | }
81 | 


--------------------------------------------------------------------------------
/src/handlers/bulk-handler.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Handlers;
  4 | 
  5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  6 | use Yoast\WP\Duplicate_Post\Post_Duplicator;
  7 | use Yoast\WP\Duplicate_Post\Utils;
  8 | 
  9 | /**
 10 |  * Duplicate Post handler class for duplication bulk actions.
 11 |  *
 12 |  * @since 4.0
 13 |  */
 14 | class Bulk_Handler {
 15 | 
 16 | 	/**
 17 | 	 * Post_Duplicator object.
 18 | 	 *
 19 | 	 * @var Post_Duplicator
 20 | 	 */
 21 | 	protected $post_duplicator;
 22 | 
 23 | 	/**
 24 | 	 * Holds the permissions helper.
 25 | 	 *
 26 | 	 * @var Permissions_Helper
 27 | 	 */
 28 | 	protected $permissions_helper;
 29 | 
 30 | 	/**
 31 | 	 * Initializes the class.
 32 | 	 *
 33 | 	 * @param Post_Duplicator    $post_duplicator    The Post_Duplicator object.
 34 | 	 * @param Permissions_Helper $permissions_helper The Permissions Helper object.
 35 | 	 */
 36 | 	public function __construct( Post_Duplicator $post_duplicator, Permissions_Helper $permissions_helper ) {
 37 | 		$this->post_duplicator    = $post_duplicator;
 38 | 		$this->permissions_helper = $permissions_helper;
 39 | 	}
 40 | 
 41 | 	/**
 42 | 	 * Adds hooks to integrate with WordPress.
 43 | 	 *
 44 | 	 * @return void
 45 | 	 */
 46 | 	public function register_hooks() {
 47 | 		\add_action( 'admin_init', [ $this, 'add_bulk_handlers' ] );
 48 | 	}
 49 | 
 50 | 	/**
 51 | 	 * Hooks the handler for the Rewrite & Republish action for all the selected post types.
 52 | 	 *
 53 | 	 * @return void
 54 | 	 */
 55 | 	public function add_bulk_handlers() {
 56 | 		$duplicate_post_types_enabled = $this->permissions_helper->get_enabled_post_types();
 57 | 
 58 | 		foreach ( $duplicate_post_types_enabled as $duplicate_post_type_enabled ) {
 59 | 			\add_filter( "handle_bulk_actions-edit-{$duplicate_post_type_enabled}", [ $this, 'bulk_action_handler' ], 10, 3 );
 60 | 		}
 61 | 	}
 62 | 
 63 | 	/**
 64 | 	 * Handles the bulk actions.
 65 | 	 *
 66 | 	 * @param string $redirect_to The URL to redirect to.
 67 | 	 * @param string $doaction    The action that has been called.
 68 | 	 * @param array  $post_ids    The array of marked post IDs.
 69 | 	 *
 70 | 	 * @return string The URL to redirect to.
 71 | 	 */
 72 | 	public function bulk_action_handler( $redirect_to, $doaction, $post_ids ) {
 73 | 		$redirect_to = $this->clone_bulk_action_handler( $redirect_to, $doaction, $post_ids );
 74 | 		return $this->rewrite_bulk_action_handler( $redirect_to, $doaction, $post_ids );
 75 | 	}
 76 | 
 77 | 	/**
 78 | 	 * Handles the bulk action for the Rewrite & Republish feature.
 79 | 	 *
 80 | 	 * @param string $redirect_to The URL to redirect to.
 81 | 	 * @param string $doaction    The action that has been called.
 82 | 	 * @param array  $post_ids    The array of marked post IDs.
 83 | 	 *
 84 | 	 * @return string The URL to redirect to.
 85 | 	 */
 86 | 	public function rewrite_bulk_action_handler( $redirect_to, $doaction, $post_ids ) {
 87 | 		if ( $doaction !== 'duplicate_post_bulk_rewrite_republish' ) {
 88 | 			return $redirect_to;
 89 | 		}
 90 | 
 91 | 		$counter = 0;
 92 | 		if ( \is_array( $post_ids ) ) {
 93 | 			foreach ( $post_ids as $post_id ) {
 94 | 				$post = \get_post( $post_id );
 95 | 				if ( ! empty( $post ) && $this->permissions_helper->should_rewrite_and_republish_be_allowed( $post ) ) {
 96 | 					$new_post_id = $this->post_duplicator->create_duplicate_for_rewrite_and_republish( $post );
 97 | 					if ( ! \is_wp_error( $new_post_id ) ) {
 98 | 						++$counter;
 99 | 					}
100 | 				}
101 | 			}
102 | 		}
103 | 		return \add_query_arg( 'bulk_rewriting', $counter, $redirect_to );
104 | 	}
105 | 
106 | 	/**
107 | 	 * Handles the bulk action for the Clone feature.
108 | 	 *
109 | 	 * @param string $redirect_to The URL to redirect to.
110 | 	 * @param string $doaction    The action that has been called.
111 | 	 * @param array  $post_ids    The array of marked post IDs.
112 | 	 *
113 | 	 * @return string The URL to redirect to.
114 | 	 */
115 | 	public function clone_bulk_action_handler( $redirect_to, $doaction, $post_ids ) {
116 | 		if ( $doaction !== 'duplicate_post_bulk_clone' ) {
117 | 			return $redirect_to;
118 | 		}
119 | 
120 | 		$counter = 0;
121 | 		if ( \is_array( $post_ids ) ) {
122 | 			foreach ( $post_ids as $post_id ) {
123 | 				$post = \get_post( $post_id );
124 | 				if ( ! empty( $post ) && ! $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
125 | 					if ( \intval( \get_option( 'duplicate_post_copychildren' ) !== 1 )
126 | 						|| ! \is_post_type_hierarchical( $post->post_type )
127 | 						|| ( \is_post_type_hierarchical( $post->post_type ) && ! Utils::has_ancestors_marked( $post, $post_ids ) )
128 | 					) {
129 | 						if ( ! \is_wp_error( \duplicate_post_create_duplicate( $post ) ) ) {
130 | 							++$counter;
131 | 						}
132 | 					}
133 | 				}
134 | 			}
135 | 		}
136 | 		return \add_query_arg( 'bulk_cloned', $counter, $redirect_to );
137 | 	}
138 | }
139 | 


--------------------------------------------------------------------------------
/src/handlers/check-changes-handler.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Handlers;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | use Yoast\WP\Duplicate_Post\Utils;
  8 | 
  9 | /**
 10 |  * Duplicate Post handler class for changes overview.
 11 |  *
 12 |  * Represents the handler for checking the changes between a copy and the original post.
 13 |  *
 14 |  * @since 4.0
 15 |  */
 16 | class Check_Changes_Handler {
 17 | 
 18 | 	/**
 19 | 	 * Holds the permissions helper.
 20 | 	 *
 21 | 	 * @var Permissions_Helper
 22 | 	 */
 23 | 	protected $permissions_helper;
 24 | 
 25 | 	/**
 26 | 	 * Holds the current post object.
 27 | 	 *
 28 | 	 * @var WP_Post
 29 | 	 */
 30 | 	private $post;
 31 | 
 32 | 	/**
 33 | 	 * Holds the original post object.
 34 | 	 *
 35 | 	 * @var WP_Post
 36 | 	 */
 37 | 	private $original;
 38 | 
 39 | 	/**
 40 | 	 * Initializes the class.
 41 | 	 *
 42 | 	 * @param Permissions_Helper $permissions_helper The Permissions Helper object.
 43 | 	 */
 44 | 	public function __construct( Permissions_Helper $permissions_helper ) {
 45 | 		$this->permissions_helper = $permissions_helper;
 46 | 	}
 47 | 
 48 | 	/**
 49 | 	 * Adds hooks to integrate with WordPress.
 50 | 	 *
 51 | 	 * @return void
 52 | 	 */
 53 | 	public function register_hooks() {
 54 | 		\add_action( 'admin_action_duplicate_post_check_changes', [ $this, 'check_changes_action_handler' ] );
 55 | 	}
 56 | 
 57 | 	/**
 58 | 	 * Handles the action for displaying the changes between a copy and the original.
 59 | 	 *
 60 | 	 * @return void
 61 | 	 */
 62 | 	public function check_changes_action_handler() {
 63 | 		global $wp_version;
 64 | 
 65 | 		if ( ! ( isset( $_GET['post'] ) || isset( $_POST['post'] )
 66 | 			|| ( isset( $_REQUEST['action'] ) && $_REQUEST['action'] === 'duplicate_post_check_changes' ) ) ) {
 67 | 			\wp_die(
 68 | 				\esc_html__( 'No post has been supplied!', 'duplicate-post' )
 69 | 			);
 70 | 			return;
 71 | 		}
 72 | 
 73 | 		$id = ( isset( $_GET['post'] ) ? \intval( \wp_unslash( $_GET['post'] ) ) : \intval( \wp_unslash( $_POST['post'] ) ) );
 74 | 
 75 | 		\check_admin_referer( 'duplicate_post_check_changes_' . $id );
 76 | 
 77 | 		$this->post = \get_post( $id );
 78 | 
 79 | 		if ( ! $this->post ) {
 80 | 			\wp_die(
 81 | 				\esc_html(
 82 | 					\sprintf(
 83 | 						/* translators: %s: post ID. */
 84 | 						\__( 'Changes overview failed, could not find post with ID %s.', 'duplicate-post' ),
 85 | 						$id
 86 | 					)
 87 | 				)
 88 | 			);
 89 | 			return;
 90 | 		}
 91 | 
 92 | 		$this->original = Utils::get_original( $this->post );
 93 | 
 94 | 		if ( ! $this->original ) {
 95 | 			\wp_die(
 96 | 				\esc_html(
 97 | 					\__( 'Changes overview failed, could not find original post.', 'duplicate-post' )
 98 | 				)
 99 | 			);
100 | 			return;
101 | 		}
102 | 		$post_edit_link = \get_edit_post_link( $this->post->ID );
103 | 
104 | 		$this->require_wordpress_header();
105 | 		?>
106 | 		<div class="wrap">
107 | 			<h1 class="long-header">
108 | 			<?php
109 | 				\printf(
110 | 					/* translators: %s: original item link (to view or edit) or title. */
111 | 					\esc_html__( 'Compare changes of duplicated post with the original (&#8220;%s&#8221;)', 'duplicate-post' ),
112 | 					Utils::get_edit_or_view_link( $this->original ) // phpcs:ignore WordPress.Security.EscapeOutput
113 | 				);
114 | 			?>
115 | 				</h1>
116 | 			<a href="<?php echo \esc_url( $post_edit_link ); ?>"><?php \esc_html_e( '&larr; Return to editor', 'duplicate-post' ); ?></a>
117 | 			<div class="revisions">
118 | 				<div class="revisions-control-frame">
119 | 					<div class="revisions-controls"></div>
120 | 				</div>
121 | 				<div class="revisions-diff-frame">
122 | 					<div class="revisions-diff">
123 | 						<div class="diff">
124 | 						<?php
125 | 						$fields = [
126 | 							'post_title'   => \__( 'Title', 'duplicate-post' ),
127 | 							'post_content' => \__( 'Content', 'duplicate-post' ),
128 | 							'post_excerpt' => \__( 'Excerpt', 'duplicate-post' ),
129 | 						];
130 | 
131 | 						$args = [
132 | 							'show_split_view' => true,
133 | 							'title_left'      => \__( 'Removed', 'duplicate-post' ),
134 | 							'title_right'     => \__( 'Added', 'duplicate-post' ),
135 | 						];
136 | 
137 | 						if ( \version_compare( $wp_version, '5.7' ) < 0 ) {
138 | 							unset( $args['title_left'] );
139 | 							unset( $args['title_right'] );
140 | 						}
141 | 
142 | 						$post_array = \get_post( $this->post, \ARRAY_A );
143 | 
144 | 						/** This filter is documented in wp-admin/includes/revision.php */
145 | 						// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- Reason: using WP core hook.
146 | 						$fields = \apply_filters( '_wp_post_revision_fields', $fields, $post_array );
147 | 
148 | 						foreach ( $fields as $field => $name ) {
149 | 							/** This filter is documented in wp-admin/includes/revision.php */
150 | 							// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- Reason: using WP core hook.
151 | 							$content_from = \apply_filters( "_wp_post_revision_field_{$field}", $this->original->$field, $field, $this->original, 'from' );
152 | 
153 | 							/** This filter is documented in wp-admin/includes/revision.php */
154 | 							// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- Reason: using WP core hook.
155 | 							$content_to = \apply_filters( "_wp_post_revision_field_{$field}", $this->post->$field, $field, $this->post, 'to' );
156 | 
157 | 							$diff = \wp_text_diff( $content_from, $content_to, $args );
158 | 
159 | 							if ( ! $diff && $field === 'post_title' ) {
160 | 								// It's a better user experience to still show the Title, even if it didn't change.
161 | 								$diff  = '<table class="diff"><colgroup><col class="content diffsplit left"><col class="content diffsplit middle"><col class="content diffsplit right"></colgroup><tbody><tr>';
162 | 								$diff .= '<td>' . \esc_html( $this->original->post_title ) . '</td><td></td><td>' . \esc_html( $this->post->post_title ) . '</td>';
163 | 								$diff .= '</tr></tbody>';
164 | 								$diff .= '</table>';
165 | 							}
166 | 
167 | 							if ( $diff ) {
168 | 								?>
169 | 								<h3><?php echo \esc_html( $name ); ?></h3>
170 | 								<?php
171 | 									echo $diff; // phpcs:ignore WordPress.Security.EscapeOutput
172 | 							}
173 | 						}
174 | 						?>
175 | 
176 | 						</div>
177 | 					</div>
178 | 				</div>
179 | 			</div>
180 | 		</div>
181 | 		<?php
182 | 		$this->require_wordpress_footer();
183 | 	}
184 | 
185 | 	/**
186 | 	 * Requires the WP admin header.
187 | 	 *
188 | 	 * @codeCoverageIgnore
189 | 	 *
190 | 	 * @return void
191 | 	 */
192 | 	public function require_wordpress_header() {
193 | 		global $post;
194 | 		\set_current_screen( 'revision' );
195 | 		// phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited -- The revision screen expects $post to be set.
196 | 		$post = $this->post;
197 | 		require_once \ABSPATH . 'wp-admin/admin-header.php';
198 | 	}
199 | 
200 | 	/**
201 | 	 * Requires the WP admin footer.
202 | 	 *
203 | 	 * @codeCoverageIgnore
204 | 	 *
205 | 	 * @return void
206 | 	 */
207 | 	public function require_wordpress_footer() {
208 | 		require_once \ABSPATH . 'wp-admin/admin-footer.php';
209 | 	}
210 | }
211 | 


--------------------------------------------------------------------------------
/src/handlers/handler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post\Handlers;
 4 | 
 5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
 6 | use Yoast\WP\Duplicate_Post\Post_Duplicator;
 7 | 
 8 | /**
 9 |  * Duplicate Post handler class for duplication actions.
10 |  *
11 |  * @since 4.0
12 |  */
13 | class Handler {
14 | 
15 | 	/**
16 | 	 * Post_Duplicator object.
17 | 	 *
18 | 	 * @var Post_Duplicator
19 | 	 */
20 | 	protected $post_duplicator;
21 | 
22 | 	/**
23 | 	 * Holds the permissions helper.
24 | 	 *
25 | 	 * @var Permissions_Helper
26 | 	 */
27 | 	protected $permissions_helper;
28 | 
29 | 	/**
30 | 	 * The bulk actions handler.
31 | 	 *
32 | 	 * @var Bulk_Handler
33 | 	 */
34 | 	protected $bulk_handler;
35 | 
36 | 	/**
37 | 	 * The link actions handler.
38 | 	 *
39 | 	 * @var Link_Handler
40 | 	 */
41 | 	protected $link_handler;
42 | 
43 | 	/**
44 | 	 * The save_post action handler.
45 | 	 *
46 | 	 * @var Save_Post_Handler
47 | 	 */
48 | 	protected $save_post_handler;
49 | 
50 | 	/**
51 | 	 * The link actions handler.
52 | 	 *
53 | 	 * @var Check_Changes_Handler
54 | 	 */
55 | 	protected $check_handler;
56 | 
57 | 	/**
58 | 	 * Initializes the class.
59 | 	 *
60 | 	 * @param Post_Duplicator    $post_duplicator    The Post_Duplicator object.
61 | 	 * @param Permissions_Helper $permissions_helper The Permissions Helper object.
62 | 	 */
63 | 	public function __construct( Post_Duplicator $post_duplicator, Permissions_Helper $permissions_helper ) {
64 | 		$this->post_duplicator    = $post_duplicator;
65 | 		$this->permissions_helper = $permissions_helper;
66 | 
67 | 		$this->bulk_handler      = new Bulk_Handler( $this->post_duplicator, $this->permissions_helper );
68 | 		$this->link_handler      = new Link_Handler( $this->post_duplicator, $this->permissions_helper );
69 | 		$this->check_handler     = new Check_Changes_Handler( $this->permissions_helper );
70 | 		$this->save_post_handler = new Save_Post_Handler( $this->permissions_helper );
71 | 
72 | 		$this->bulk_handler->register_hooks();
73 | 		$this->link_handler->register_hooks();
74 | 		$this->check_handler->register_hooks();
75 | 		$this->save_post_handler->register_hooks();
76 | 	}
77 | }
78 | 


--------------------------------------------------------------------------------
/src/handlers/link-handler.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Handlers;
  4 | 
  5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  6 | use Yoast\WP\Duplicate_Post\Post_Duplicator;
  7 | 
  8 | /**
  9 |  * Duplicate Post handler class for duplication actions from links.
 10 |  *
 11 |  * @since 4.0
 12 |  */
 13 | class Link_Handler {
 14 | 
 15 | 	/**
 16 | 	 * Post_Duplicator object.
 17 | 	 *
 18 | 	 * @var Post_Duplicator
 19 | 	 */
 20 | 	protected $post_duplicator;
 21 | 
 22 | 	/**
 23 | 	 * Holds the permissions helper.
 24 | 	 *
 25 | 	 * @var Permissions_Helper
 26 | 	 */
 27 | 	protected $permissions_helper;
 28 | 
 29 | 	/**
 30 | 	 * Initializes the class.
 31 | 	 *
 32 | 	 * @param Post_Duplicator    $post_duplicator    The Post_Duplicator object.
 33 | 	 * @param Permissions_Helper $permissions_helper The Permissions Helper object.
 34 | 	 */
 35 | 	public function __construct( Post_Duplicator $post_duplicator, Permissions_Helper $permissions_helper ) {
 36 | 		$this->post_duplicator    = $post_duplicator;
 37 | 		$this->permissions_helper = $permissions_helper;
 38 | 	}
 39 | 
 40 | 	/**
 41 | 	 * Adds hooks to integrate with WordPress.
 42 | 	 *
 43 | 	 * @return void
 44 | 	 */
 45 | 	public function register_hooks() {
 46 | 		\add_action( 'admin_action_duplicate_post_rewrite', [ $this, 'rewrite_link_action_handler' ] );
 47 | 		\add_action( 'admin_action_duplicate_post_clone', [ $this, 'clone_link_action_handler' ] );
 48 | 		\add_action( 'admin_action_duplicate_post_new_draft', [ $this, 'new_draft_link_action_handler' ] );
 49 | 	}
 50 | 
 51 | 	/**
 52 | 	 * Handles the action for copying a post to a new draft.
 53 | 	 *
 54 | 	 * @return void
 55 | 	 */
 56 | 	public function new_draft_link_action_handler() {
 57 | 		if ( ! $this->permissions_helper->is_current_user_allowed_to_copy() ) {
 58 | 			\wp_die( \esc_html__( 'Current user is not allowed to copy posts.', 'duplicate-post' ) );
 59 | 		}
 60 | 
 61 | 		if ( ! ( isset( $_GET['post'] ) || isset( $_POST['post'] )
 62 | 			|| ( isset( $_REQUEST['action'] ) && $_REQUEST['action'] === 'duplicate_post_new_draft' ) ) ) {
 63 | 			\wp_die( \esc_html__( 'No post to duplicate has been supplied!', 'duplicate-post' ) );
 64 | 		}
 65 | 
 66 | 		$id = ( isset( $_GET['post'] ) ? \intval( \wp_unslash( $_GET['post'] ) ) : \intval( \wp_unslash( $_POST['post'] ) ) );
 67 | 
 68 | 		\check_admin_referer( 'duplicate_post_new_draft_' . $id );
 69 | 
 70 | 		$post = \get_post( $id );
 71 | 
 72 | 		if ( ! $post ) {
 73 | 			\wp_die(
 74 | 				\esc_html(
 75 | 					\__( 'Copy creation failed, could not find original:', 'duplicate-post' ) . ' '
 76 | 					. $id
 77 | 				)
 78 | 			);
 79 | 		}
 80 | 
 81 | 		if ( $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
 82 | 			\wp_die(
 83 | 				\esc_html__( 'You cannot create a copy of a post which is intended for Rewrite & Republish.', 'duplicate-post' )
 84 | 			);
 85 | 		}
 86 | 
 87 | 		$new_id = \duplicate_post_create_duplicate( $post, 'draft' );
 88 | 
 89 | 		if ( \is_wp_error( $new_id ) ) {
 90 | 			\wp_die(
 91 | 				\esc_html__( 'Copy creation failed, could not create a copy.', 'duplicate-post' )
 92 | 			);
 93 | 		}
 94 | 
 95 | 		\wp_safe_redirect(
 96 | 			\add_query_arg(
 97 | 				[
 98 | 					'cloned' => 1,
 99 | 					'ids'    => $post->ID,
100 | 				],
101 | 				\admin_url( 'post.php?action=edit&post=' . $new_id . ( isset( $_GET['classic-editor'] ) ? '&classic-editor' : '' ) )
102 | 			)
103 | 		);
104 | 		exit();
105 | 	}
106 | 
107 | 	/**
108 | 	 * Handles the action for copying a post and redirecting to the post list.
109 | 	 *
110 | 	 * @return void
111 | 	 */
112 | 	public function clone_link_action_handler() {
113 | 		if ( ! $this->permissions_helper->is_current_user_allowed_to_copy() ) {
114 | 			\wp_die( \esc_html__( 'Current user is not allowed to copy posts.', 'duplicate-post' ) );
115 | 		}
116 | 
117 | 		if ( ! ( isset( $_GET['post'] ) || isset( $_POST['post'] )
118 | 			|| ( isset( $_REQUEST['action'] ) && $_REQUEST['action'] === 'duplicate_post_clone' ) ) ) {
119 | 			\wp_die( \esc_html__( 'No post to duplicate has been supplied!', 'duplicate-post' ) );
120 | 		}
121 | 
122 | 		$id = ( isset( $_GET['post'] ) ? \intval( \wp_unslash( $_GET['post'] ) ) : \intval( \wp_unslash( $_POST['post'] ) ) );
123 | 
124 | 		\check_admin_referer( 'duplicate_post_clone_' . $id );
125 | 
126 | 		$post = \get_post( $id );
127 | 
128 | 		if ( ! $post ) {
129 | 			\wp_die(
130 | 				\esc_html(
131 | 					\__( 'Copy creation failed, could not find original:', 'duplicate-post' ) . ' '
132 | 					. $id
133 | 				)
134 | 			);
135 | 		}
136 | 
137 | 		if ( $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
138 | 			\wp_die(
139 | 				\esc_html__( 'You cannot create a copy of a post which is intended for Rewrite & Republish.', 'duplicate-post' )
140 | 			);
141 | 		}
142 | 
143 | 		$new_id = \duplicate_post_create_duplicate( $post );
144 | 
145 | 		if ( \is_wp_error( $new_id ) ) {
146 | 			\wp_die(
147 | 				\esc_html__( 'Copy creation failed, could not create a copy.', 'duplicate-post' )
148 | 			);
149 | 		}
150 | 
151 | 		$post_type = $post->post_type;
152 | 		$sendback  = \wp_get_referer();
153 | 		if ( ! $sendback || \strpos( $sendback, 'post.php' ) !== false || \strpos( $sendback, 'post-new.php' ) !== false ) {
154 | 			if ( $post_type === 'attachment' ) {
155 | 				$sendback = \admin_url( 'upload.php' );
156 | 			}
157 | 			else {
158 | 				$sendback = \admin_url( 'edit.php' );
159 | 				if ( ! empty( $post_type ) ) {
160 | 					$sendback = \add_query_arg( 'post_type', $post_type, $sendback );
161 | 				}
162 | 			}
163 | 		}
164 | 		else {
165 | 			$sendback = \remove_query_arg( [ 'trashed', 'untrashed', 'deleted', 'cloned', 'ids' ], $sendback );
166 | 		}
167 | 
168 | 		// Redirect to the post list screen.
169 | 		\wp_safe_redirect(
170 | 			\add_query_arg(
171 | 				[
172 | 					'cloned' => 1,
173 | 					'ids'    => $post->ID,
174 | 				],
175 | 				$sendback
176 | 			)
177 | 		);
178 | 		exit();
179 | 	}
180 | 
181 | 	/**
182 | 	 * Handles the action for copying a post for the Rewrite & Republish feature.
183 | 	 *
184 | 	 * @return void
185 | 	 */
186 | 	public function rewrite_link_action_handler() {
187 | 		if ( ! $this->permissions_helper->is_current_user_allowed_to_copy() ) {
188 | 			\wp_die( \esc_html__( 'Current user is not allowed to copy posts.', 'duplicate-post' ) );
189 | 		}
190 | 
191 | 		if ( ! ( isset( $_GET['post'] ) || isset( $_POST['post'] )
192 | 			|| ( isset( $_REQUEST['action'] ) && $_REQUEST['action'] === 'duplicate_post_rewrite' ) ) ) {
193 | 			\wp_die( \esc_html__( 'No post to duplicate has been supplied!', 'duplicate-post' ) );
194 | 		}
195 | 
196 | 		$id = ( isset( $_GET['post'] ) ? \intval( \wp_unslash( $_GET['post'] ) ) : \intval( \wp_unslash( $_POST['post'] ) ) );
197 | 
198 | 		\check_admin_referer( 'duplicate_post_rewrite_' . $id );
199 | 
200 | 		$post = \get_post( $id );
201 | 
202 | 		if ( ! $post ) {
203 | 			\wp_die(
204 | 				\esc_html(
205 | 					\__( 'Copy creation failed, could not find original:', 'duplicate-post' ) . ' '
206 | 					. $id
207 | 				)
208 | 			);
209 | 		}
210 | 
211 | 		if ( ! $this->permissions_helper->should_rewrite_and_republish_be_allowed( $post ) ) {
212 | 			\wp_die(
213 | 				\esc_html__( 'You cannot create a copy for Rewrite & Republish if the original is not published or if it already has a copy.', 'duplicate-post' )
214 | 			);
215 | 		}
216 | 
217 | 		$new_id = $this->post_duplicator->create_duplicate_for_rewrite_and_republish( $post );
218 | 
219 | 		if ( \is_wp_error( $new_id ) ) {
220 | 			\wp_die(
221 | 				\esc_html__( 'Copy creation failed, could not create a copy.', 'duplicate-post' )
222 | 			);
223 | 		}
224 | 
225 | 		\wp_safe_redirect(
226 | 			\add_query_arg(
227 | 				[
228 | 					'rewriting' => 1,
229 | 					'ids'       => $post->ID,
230 | 				],
231 | 				\admin_url( 'post.php?action=edit&post=' . $new_id . ( isset( $_GET['classic-editor'] ) ? '&classic-editor' : '' ) )
232 | 			)
233 | 		);
234 | 		exit();
235 | 	}
236 | }
237 | 


--------------------------------------------------------------------------------
/src/handlers/save-post-handler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post\Handlers;
 4 | 
 5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
 6 | 
 7 | /**
 8 |  * Duplicate Post handler class for save_post action.
 9 |  *
10 |  * @since 4.0
11 |  */
12 | class Save_Post_Handler {
13 | 
14 | 	/**
15 | 	 * Holds the permissions helper.
16 | 	 *
17 | 	 * @var Permissions_Helper
18 | 	 */
19 | 	protected $permissions_helper;
20 | 
21 | 	/**
22 | 	 * Initializes the class.
23 | 	 *
24 | 	 * @param Permissions_Helper $permissions_helper The Permissions Helper object.
25 | 	 */
26 | 	public function __construct( Permissions_Helper $permissions_helper ) {
27 | 		$this->permissions_helper = $permissions_helper;
28 | 	}
29 | 
30 | 	/**
31 | 	 * Adds hooks to integrate with WordPress.
32 | 	 *
33 | 	 * @return void
34 | 	 */
35 | 	public function register_hooks() {
36 | 		if ( \intval( \get_option( 'duplicate_post_show_original_meta_box' ) ) === 1
37 | 			|| \intval( \get_option( 'duplicate_post_show_original_column' ) ) === 1 ) {
38 | 			\add_action( 'save_post', [ $this, 'delete_on_save_post' ] );
39 | 		}
40 | 	}
41 | 
42 | 	/**
43 | 	 * Deletes the custom field with the ID of the original post.
44 | 	 *
45 | 	 * @param int $post_id The current post ID.
46 | 	 *
47 | 	 * @return void
48 | 	 */
49 | 	public function delete_on_save_post( $post_id ) {
50 | 		if ( ( \defined( 'DOING_AUTOSAVE' ) && \DOING_AUTOSAVE )
51 | 			|| empty( $_POST['duplicate_post_remove_original'] )
52 | 			|| ! \current_user_can( 'edit_post', $post_id ) ) {
53 | 			return;
54 | 		}
55 | 
56 | 		$post = \get_post( $post_id );
57 | 		if ( ! $post ) {
58 | 			return;
59 | 		}
60 | 		if ( ! $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
61 | 			\delete_post_meta( $post_id, '_dp_original' );
62 | 		}
63 | 	}
64 | }
65 | 


--------------------------------------------------------------------------------
/src/permissions-helper.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post;
  4 | 
  5 | use WP_Post;
  6 | 
  7 | /**
  8 |  * Permissions helper for Duplicate Post.
  9 |  *
 10 |  * @since 4.0
 11 |  */
 12 | class Permissions_Helper {
 13 | 
 14 | 	/**
 15 | 	 * Returns the array of the enabled post types.
 16 | 	 *
 17 | 	 * @return array The array of post types.
 18 | 	 */
 19 | 	public function get_enabled_post_types() {
 20 | 		$enabled_post_types = \get_option( 'duplicate_post_types_enabled', [ 'post', 'page' ] );
 21 | 		if ( ! \is_array( $enabled_post_types ) ) {
 22 | 			$enabled_post_types = [ $enabled_post_types ];
 23 | 		}
 24 | 
 25 | 		if ( Utils::is_plugin_active( 'woocommerce/woocommerce.php' ) ) {
 26 | 			$enabled_post_types = \array_diff( $enabled_post_types, [ 'product' ] );
 27 | 		}
 28 | 
 29 | 		/**
 30 | 		 * Filters the list of post types for which the plugin is enabled.
 31 | 		 *
 32 | 		 * @param array $enabled_post_types The array of post type names for which the plugin is enabled.
 33 | 		 *
 34 | 		 * @return array The filtered array of post types names.
 35 | 		 */
 36 | 		return \apply_filters( 'duplicate_post_enabled_post_types', $enabled_post_types );
 37 | 	}
 38 | 
 39 | 	/**
 40 | 	 * Determines if post type is enabled to be copied.
 41 | 	 *
 42 | 	 * @param string $post_type The post type to check.
 43 | 	 *
 44 | 	 * @return bool Whether the post type is enabled to be copied.
 45 | 	 */
 46 | 	public function is_post_type_enabled( $post_type ) {
 47 | 		return \in_array( $post_type, $this->get_enabled_post_types(), true );
 48 | 	}
 49 | 
 50 | 	/**
 51 | 	 * Determines if the current user can copy posts.
 52 | 	 *
 53 | 	 * @return bool Whether the current user can copy posts.
 54 | 	 */
 55 | 	public function is_current_user_allowed_to_copy() {
 56 | 		return \current_user_can( 'copy_posts' );
 57 | 	}
 58 | 
 59 | 	/**
 60 | 	 * Determines if the post is a copy intended for Rewrite & Republish.
 61 | 	 *
 62 | 	 * @param WP_Post $post The post object.
 63 | 	 *
 64 | 	 * @return bool Whether the post is a copy intended for Rewrite & Republish.
 65 | 	 */
 66 | 	public function is_rewrite_and_republish_copy( WP_Post $post ) {
 67 | 		return ( \intval( \get_post_meta( $post->ID, '_dp_is_rewrite_republish_copy', true ) ) === 1 );
 68 | 	}
 69 | 
 70 | 	/**
 71 | 	 * Gets the Rewrite & Republish copy ID for the passed post.
 72 | 	 *
 73 | 	 * @param WP_Post $post The post object.
 74 | 	 *
 75 | 	 * @return int The Rewrite & Republish copy ID.
 76 | 	 */
 77 | 	public function get_rewrite_and_republish_copy_id( WP_Post $post ) {
 78 | 		return \get_post_meta( $post->ID, '_dp_has_rewrite_republish_copy', true );
 79 | 	}
 80 | 
 81 | 	/**
 82 | 	 * Gets the copy post object for the passed post.
 83 | 	 *
 84 | 	 * @param WP_Post $post The post to get the copy for.
 85 | 	 *
 86 | 	 * @return WP_Post|null The copy's post object or null if it doesn't exist.
 87 | 	 */
 88 | 	public function get_rewrite_and_republish_copy( WP_Post $post ) {
 89 | 		$copy_id = $this->get_rewrite_and_republish_copy_id( $post );
 90 | 
 91 | 		if ( empty( $copy_id ) ) {
 92 | 			return null;
 93 | 		}
 94 | 
 95 | 		return \get_post( $copy_id );
 96 | 	}
 97 | 
 98 | 	/**
 99 | 	 * Determines if the post has a copy intended for Rewrite & Republish.
100 | 	 *
101 | 	 * @param WP_Post $post The post object.
102 | 	 *
103 | 	 * @return bool Whether the post has a copy intended for Rewrite & Republish.
104 | 	 */
105 | 	public function has_rewrite_and_republish_copy( WP_Post $post ) {
106 | 		return ( ! empty( $this->get_rewrite_and_republish_copy_id( $post ) ) );
107 | 	}
108 | 
109 | 	/**
110 | 	 * Determines if the post has a copy intended for Rewrite & Republish which is scheduled to be published.
111 | 	 *
112 | 	 * @param WP_Post $post The post object.
113 | 	 *
114 | 	 * @return bool|WP_Post The scheduled copy if present, false if the post has no scheduled copy.
115 | 	 */
116 | 	public function has_scheduled_rewrite_and_republish_copy( WP_Post $post ) {
117 | 		$copy = $this->get_rewrite_and_republish_copy( $post );
118 | 
119 | 		if ( ! empty( $copy ) && $copy->post_status === 'future' ) {
120 | 			return $copy;
121 | 		}
122 | 
123 | 		return false;
124 | 	}
125 | 
126 | 	/**
127 | 	 * Determines whether the current screen is an edit post screen.
128 | 	 *
129 | 	 * @return bool Whether or not the current screen is editing an existing post.
130 | 	 */
131 | 	public function is_edit_post_screen() {
132 | 		if ( ! \is_admin() ) {
133 | 			return false;
134 | 		}
135 | 
136 | 		$current_screen = \get_current_screen();
137 | 
138 | 		return $current_screen->base === 'post' && $current_screen->action !== 'add';
139 | 	}
140 | 
141 | 	/**
142 | 	 * Determines whether the current screen is an new post screen.
143 | 	 *
144 | 	 * @return bool Whether or not the current screen is editing an new post.
145 | 	 */
146 | 	public function is_new_post_screen() {
147 | 		if ( ! \is_admin() ) {
148 | 			return false;
149 | 		}
150 | 
151 | 		$current_screen = \get_current_screen();
152 | 
153 | 		return $current_screen->base === 'post' && $current_screen->action === 'add';
154 | 	}
155 | 
156 | 	/**
157 | 	 * Determines if we are currently editing a post with Classic editor.
158 | 	 *
159 | 	 * @return bool Whether we are currently editing a post with Classic editor.
160 | 	 */
161 | 	public function is_classic_editor() {
162 | 		if ( ! $this->is_edit_post_screen() && ! $this->is_new_post_screen() ) {
163 | 			return false;
164 | 		}
165 | 
166 | 		$screen = \get_current_screen();
167 | 		if ( $screen->is_block_editor() ) {
168 | 			return false;
169 | 		}
170 | 
171 | 		return true;
172 | 	}
173 | 
174 | 	/**
175 | 	 * Determines if the original post has changed since the creation of the copy.
176 | 	 *
177 | 	 * @param WP_Post $post The post object.
178 | 	 *
179 | 	 * @return bool Whether the original post has changed since the creation of the copy.
180 | 	 */
181 | 	public function has_original_changed( WP_Post $post ) {
182 | 		if ( ! $this->is_rewrite_and_republish_copy( $post ) ) {
183 | 			return false;
184 | 		}
185 | 
186 | 		$original               = Utils::get_original( $post );
187 | 		$copy_creation_date_gmt = \get_post_meta( $post->ID, '_dp_creation_date_gmt', true );
188 | 
189 | 		if ( $original && $copy_creation_date_gmt ) {
190 | 			if ( \strtotime( $original->post_modified_gmt ) > \strtotime( $copy_creation_date_gmt ) ) {
191 | 				return true;
192 | 			}
193 | 		}
194 | 
195 | 		return false;
196 | 	}
197 | 
198 | 	/**
199 | 	 * Determines if duplicate links for the post can be displayed.
200 | 	 *
201 | 	 * @param WP_Post $post The post object.
202 | 	 *
203 | 	 * @return bool Whether the links can be displayed.
204 | 	 */
205 | 	public function should_links_be_displayed( WP_Post $post ) {
206 | 		/**
207 | 		 * Filter allowing displaying duplicate post links for current post.
208 | 		 *
209 | 		 * @param bool    $display_links Whether the duplicate links will be displayed.
210 | 		 * @param WP_Post $post          The post object.
211 | 		 *
212 | 		 * @return bool Whether or not to display the duplicate post links.
213 | 		 */
214 | 		$display_links = \apply_filters( 'duplicate_post_show_link', $this->is_current_user_allowed_to_copy() && $this->is_post_type_enabled( $post->post_type ), $post );
215 | 
216 | 		return ! $this->is_rewrite_and_republish_copy( $post ) && $display_links;
217 | 	}
218 | 
219 | 	/**
220 | 	 * Determines if the Rewrite & Republish link for the post should be displayed.
221 | 	 *
222 | 	 * @param WP_Post $post The post object.
223 | 	 *
224 | 	 * @return bool Whether the links should be displayed.
225 | 	 */
226 | 	public function should_rewrite_and_republish_be_allowed( WP_Post $post ) {
227 | 		return $post->post_status === 'publish'
228 | 			&& ! $this->is_rewrite_and_republish_copy( $post )
229 | 			&& ! $this->has_rewrite_and_republish_copy( $post );
230 | 	}
231 | 
232 | 	/**
233 | 	 * Determines whether the passed post type is public and shows an admin bar.
234 | 	 *
235 | 	 * @param string $post_type The post_type to copy.
236 | 	 *
237 | 	 * @return bool Whether or not the post can be copied to a new draft.
238 | 	 */
239 | 	public function post_type_has_admin_bar( $post_type ) {
240 | 		$post_type_object = \get_post_type_object( $post_type );
241 | 
242 | 		if ( empty( $post_type_object ) ) {
243 | 			return false;
244 | 		}
245 | 
246 | 		return $post_type_object->public && $post_type_object->show_in_admin_bar;
247 | 	}
248 | 
249 | 	/**
250 | 	 * Determines whether a Rewrite & Republish copy can be republished.
251 | 	 *
252 | 	 * @param WP_Post $post The post object.
253 | 	 *
254 | 	 * @return bool Whether the Rewrite & Republish copy can be republished.
255 | 	 */
256 | 	public function is_copy_allowed_to_be_republished( WP_Post $post ) {
257 | 		return \in_array( $post->post_status, [ 'dp-rewrite-republish', 'private' ], true );
258 | 	}
259 | 
260 | 	/**
261 | 	 * Determines if the post has a trashed copy intended for Rewrite & Republish.
262 | 	 *
263 | 	 * @param WP_Post $post The post object.
264 | 	 *
265 | 	 * @return bool Whether the post has a trashed copy intended for Rewrite & Republish.
266 | 	 */
267 | 	public function has_trashed_rewrite_and_republish_copy( WP_Post $post ) {
268 | 		$copy_id = \get_post_meta( $post->ID, '_dp_has_rewrite_republish_copy', true );
269 | 
270 | 		if ( ! $copy_id ) {
271 | 			return false;
272 | 		}
273 | 
274 | 		$copy = \get_post( $copy_id );
275 | 
276 | 		return ( $copy && $copy->post_status === 'trash' );
277 | 	}
278 | }
279 | 


--------------------------------------------------------------------------------
/src/revisions-migrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post;
 4 | 
 5 | /**
 6 |  * Duplicate Post class to migrate revisions from the Rewrite & Republish copy to the original post.
 7 |  *
 8 |  * @since 4.0
 9 |  */
10 | class Revisions_Migrator {
11 | 
12 | 	/**
13 | 	 * Adds hooks to integrate with the Post Republisher class.
14 | 	 *
15 | 	 * @return void
16 | 	 */
17 | 	public function register_hooks() {
18 | 		\add_action( 'duplicate_post_after_rewriting', [ $this, 'migrate_revisions' ], 10, 2 );
19 | 	}
20 | 
21 | 	/**
22 | 	 * Updates the revisions of the Rewrite & Republish copy to make them revisions of the original.
23 | 	 *
24 | 	 * It mimics the behaviour of wp_save_post_revision() in wp-includes/revision.php
25 | 	 * by deleting the revisions (except autosaves) exceeding the maximum allowed number.
26 | 	 *
27 | 	 * @param int $copy_id     The copy's ID.
28 | 	 * @param int $original_id The post's ID.
29 | 	 *
30 | 	 * @return void
31 | 	 */
32 | 	public function migrate_revisions( $copy_id, $original_id ) {
33 | 		$copy          = \get_post( $copy_id );
34 | 		$original_post = \get_post( $original_id );
35 | 
36 | 		if ( \is_null( $copy ) || \is_null( $original_post ) || ! \wp_revisions_enabled( $original_post ) ) {
37 | 			return;
38 | 		}
39 | 
40 | 		$copy_revisions = \wp_get_post_revisions( $copy );
41 | 		foreach ( $copy_revisions as $revision ) {
42 | 			$revision->post_parent = $original_post->ID;
43 | 			$revision->post_name   = "$original_post->ID-revision-v1";
44 | 			\wp_update_post( $revision );
45 | 		}
46 | 
47 | 		$revisions_to_keep = \wp_revisions_to_keep( $original_post );
48 | 		if ( $revisions_to_keep < 0 ) {
49 | 			return;
50 | 		}
51 | 
52 | 		$revisions = \wp_get_post_revisions( $original_post, [ 'order' => 'ASC' ] );
53 | 		$delete    = ( \count( $revisions ) - $revisions_to_keep );
54 | 		if ( $delete < 1 ) {
55 | 			return;
56 | 		}
57 | 
58 | 		$revisions = \array_slice( $revisions, 0, $delete );
59 | 
60 | 		for ( $i = 0; isset( $revisions[ $i ] ); $i++ ) {
61 | 			if ( \strpos( $revisions[ $i ]->post_name, 'autosave' ) !== false ) {
62 | 				continue;
63 | 			}
64 | 			\wp_delete_post_revision( $revisions[ $i ]->ID );
65 | 		}
66 | 	}
67 | }
68 | 


--------------------------------------------------------------------------------
/src/ui/admin-bar.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | use Yoast\WP\Duplicate_Post\Utils;
  8 | 
  9 | /**
 10 |  * Duplicate Post class to manage the admin bar.
 11 |  */
 12 | class Admin_Bar {
 13 | 
 14 | 	/**
 15 | 	 * Holds the object to create the action link to duplicate.
 16 | 	 *
 17 | 	 * @var Link_Builder
 18 | 	 */
 19 | 	protected $link_builder;
 20 | 
 21 | 	/**
 22 | 	 * Holds the permissions helper.
 23 | 	 *
 24 | 	 * @var Permissions_Helper
 25 | 	 */
 26 | 	protected $permissions_helper;
 27 | 
 28 | 	/**
 29 | 	 * Holds the asset manager.
 30 | 	 *
 31 | 	 * @var Asset_Manager
 32 | 	 */
 33 | 	protected $asset_manager;
 34 | 
 35 | 	/**
 36 | 	 * Initializes the class.
 37 | 	 *
 38 | 	 * @param Link_Builder       $link_builder       The link builder.
 39 | 	 * @param Permissions_Helper $permissions_helper The permissions helper.
 40 | 	 * @param Asset_Manager      $asset_manager      The asset manager.
 41 | 	 */
 42 | 	public function __construct( Link_Builder $link_builder, Permissions_Helper $permissions_helper, Asset_Manager $asset_manager ) {
 43 | 		$this->link_builder       = $link_builder;
 44 | 		$this->permissions_helper = $permissions_helper;
 45 | 		$this->asset_manager      = $asset_manager;
 46 | 	}
 47 | 
 48 | 	/**
 49 | 	 * Adds hooks to integrate with WordPress.
 50 | 	 *
 51 | 	 * @return void
 52 | 	 */
 53 | 	public function register_hooks() {
 54 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link_in', 'adminbar' ) ) === 1 ) {
 55 | 			\add_action( 'wp_before_admin_bar_render', [ $this, 'admin_bar_render' ] );
 56 | 			\add_action( 'wp_enqueue_scripts', [ $this, 'enqueue_styles' ] );
 57 | 			\add_action( 'admin_enqueue_scripts', [ $this, 'enqueue_styles' ] );
 58 | 		}
 59 | 	}
 60 | 
 61 | 	/**
 62 | 	 * Shows Rewrite & Republish link in the Toolbar.
 63 | 	 *
 64 | 	 * @global \WP_Admin_Bar $wp_admin_bar WP_Admin_Bar instance.
 65 | 	 *
 66 | 	 * @return void
 67 | 	 */
 68 | 	public function admin_bar_render() {
 69 | 		global $wp_admin_bar;
 70 | 
 71 | 		if ( ! \is_admin_bar_showing() ) {
 72 | 			return;
 73 | 		}
 74 | 
 75 | 		$post = $this->get_current_post();
 76 | 
 77 | 		if ( ! $post ) {
 78 | 			return;
 79 | 		}
 80 | 
 81 | 		$show_new_draft             = ( \intval( Utils::get_option( 'duplicate_post_show_link', 'new_draft' ) ) === 1 );
 82 | 		$show_rewrite_and_republish = ( \intval( Utils::get_option( 'duplicate_post_show_link', 'rewrite_republish' ) ) === 1 )
 83 | 									&& $this->permissions_helper->should_rewrite_and_republish_be_allowed( $post );
 84 | 
 85 | 		if ( $show_new_draft && $show_rewrite_and_republish ) {
 86 | 			$wp_admin_bar->add_menu(
 87 | 				[
 88 | 					'id'    => 'duplicate-post',
 89 | 					'title' => '<span class="ab-icon"></span><span class="ab-label">' . \__( 'Duplicate Post', 'duplicate-post' ) . '</span>',
 90 | 					'href'  => $this->link_builder->build_new_draft_link( $post ),
 91 | 				]
 92 | 			);
 93 | 			$wp_admin_bar->add_menu(
 94 | 				[
 95 | 					'id'     => 'new-draft',
 96 | 					'parent' => 'duplicate-post',
 97 | 					'title'  => \__( 'Copy to a new draft', 'duplicate-post' ),
 98 | 					'href'   => $this->link_builder->build_new_draft_link( $post ),
 99 | 				]
100 | 			);
101 | 			$wp_admin_bar->add_menu(
102 | 				[
103 | 					'id'     => 'rewrite-republish',
104 | 					'parent' => 'duplicate-post',
105 | 					'title'  => \__( 'Rewrite & Republish', 'duplicate-post' ),
106 | 					'href'   => $this->link_builder->build_rewrite_and_republish_link( $post ),
107 | 				]
108 | 			);
109 | 		}
110 | 		else {
111 | 			if ( $show_new_draft ) {
112 | 				$wp_admin_bar->add_menu(
113 | 					[
114 | 						'id'     => 'new-draft',
115 | 						'title'  => '<span class="ab-icon"></span><span class="ab-label">' . \__( 'Copy to a new draft', 'duplicate-post' ) . '</span>',
116 | 						'href'   => $this->link_builder->build_new_draft_link( $post ),
117 | 					]
118 | 				);
119 | 			}
120 | 
121 | 			if ( $show_rewrite_and_republish ) {
122 | 				$wp_admin_bar->add_menu(
123 | 					[
124 | 						'id'     => 'rewrite-republish',
125 | 						'title'  => '<span class="ab-icon"></span><span class="ab-label">' . \__( 'Rewrite & Republish', 'duplicate-post' ) . '</span>',
126 | 						'href'   => $this->link_builder->build_rewrite_and_republish_link( $post ),
127 | 					]
128 | 				);
129 | 			}
130 | 		}
131 | 	}
132 | 
133 | 	/**
134 | 	 * Links stylesheet for Toolbar link.
135 | 	 *
136 | 	 * @global \WP_Query $wp_the_query.
137 | 	 *
138 | 	 * @return void
139 | 	 */
140 | 	public function enqueue_styles() {
141 | 		if ( ! \is_admin_bar_showing() ) {
142 | 			return;
143 | 		}
144 | 
145 | 		$post = $this->get_current_post();
146 | 
147 | 		if ( ! $post ) {
148 | 			return;
149 | 		}
150 | 
151 | 		$this->asset_manager->enqueue_styles();
152 | 	}
153 | 
154 | 	/**
155 | 	 * Returns the current post object (both if it's displayed or being edited).
156 | 	 *
157 | 	 * @global \WP_Query $wp_the_query
158 | 	 *
159 | 	 * @return false|WP_Post The Post object, false if we are not on a post.
160 | 	 */
161 | 	public function get_current_post() {
162 | 		global $wp_the_query;
163 | 
164 | 		if ( \is_admin() ) {
165 | 			$post = \get_post();
166 | 		}
167 | 		else {
168 | 			$post = $wp_the_query->get_queried_object();
169 | 		}
170 | 
171 | 		if ( empty( $post ) || ! $post instanceof WP_Post ) {
172 | 			return false;
173 | 		}
174 | 
175 | 		if (
176 | 			( ! $this->permissions_helper->is_edit_post_screen() && ! \is_singular( $post->post_type ) )
177 | 			|| ! $this->permissions_helper->post_type_has_admin_bar( $post->post_type )
178 | 		) {
179 | 			return false;
180 | 		}
181 | 
182 | 		if ( ! $this->permissions_helper->should_links_be_displayed( $post ) ) {
183 | 			return false;
184 | 		}
185 | 
186 | 		return $post;
187 | 	}
188 | }
189 | 


--------------------------------------------------------------------------------
/src/ui/asset-manager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | use Yoast\WP\Duplicate_Post\Utils;
  6 | 
  7 | /**
  8 |  * Duplicate Post class to manage assets.
  9 |  */
 10 | class Asset_Manager {
 11 | 
 12 | 	/**
 13 | 	 * Adds hooks to integrate with WordPress.
 14 | 	 *
 15 | 	 * @return void
 16 | 	 */
 17 | 	public function register_hooks() {
 18 | 		\add_action( 'init', [ $this, 'register_styles' ] );
 19 | 		\add_action( 'init', [ $this, 'register_scripts' ] );
 20 | 	}
 21 | 
 22 | 	/**
 23 | 	 * Registers the styles.
 24 | 	 *
 25 | 	 * @return void
 26 | 	 */
 27 | 	public function register_styles() {
 28 | 		\wp_register_style( 'duplicate-post', \plugins_url( '/css/duplicate-post.css', \DUPLICATE_POST_FILE ), [], \DUPLICATE_POST_CURRENT_VERSION );
 29 | 		\wp_register_style( 'duplicate-post-options', \plugins_url( '/css/duplicate-post-options.css', \DUPLICATE_POST_FILE ), [], \DUPLICATE_POST_CURRENT_VERSION );
 30 | 	}
 31 | 
 32 | 	/**
 33 | 	 * Registers the scripts.
 34 | 	 *
 35 | 	 * @return void
 36 | 	 */
 37 | 	public function register_scripts() {
 38 | 		$flattened_version = Utils::flatten_version( \DUPLICATE_POST_CURRENT_VERSION );
 39 | 
 40 | 		\wp_register_script(
 41 | 			'duplicate_post_edit_script',
 42 | 			\plugins_url( \sprintf( 'js/dist/duplicate-post-edit-%s.js', $flattened_version ), \DUPLICATE_POST_FILE ),
 43 | 			[
 44 | 				'wp-components',
 45 | 				'wp-element',
 46 | 				'wp-i18n',
 47 | 			],
 48 | 			\DUPLICATE_POST_CURRENT_VERSION,
 49 | 			true
 50 | 		);
 51 | 		\wp_set_script_translations( 'duplicate_post_edit_script', 'duplicate-post' );
 52 | 
 53 | 		\wp_register_script(
 54 | 			'duplicate_post_strings',
 55 | 			\plugins_url( \sprintf( 'js/dist/duplicate-post-strings-%s.js', $flattened_version ), \DUPLICATE_POST_FILE ),
 56 | 			[
 57 | 				'wp-components',
 58 | 				'wp-element',
 59 | 				'wp-i18n',
 60 | 			],
 61 | 			\DUPLICATE_POST_CURRENT_VERSION,
 62 | 			true
 63 | 		);
 64 | 		\wp_set_script_translations( 'duplicate_post_strings', 'duplicate-post' );
 65 | 
 66 | 		\wp_register_script(
 67 | 			'duplicate_post_quick_edit_script',
 68 | 			\plugins_url( \sprintf( 'js/dist/duplicate-post-quick-edit-%s.js', $flattened_version ), \DUPLICATE_POST_FILE ),
 69 | 			[ 'jquery' ],
 70 | 			\DUPLICATE_POST_CURRENT_VERSION,
 71 | 			true
 72 | 		);
 73 | 
 74 | 		\wp_register_script(
 75 | 			'duplicate_post_options_script',
 76 | 			\plugins_url( \sprintf( 'js/dist/duplicate-post-options-%s.js', $flattened_version ), \DUPLICATE_POST_FILE ),
 77 | 			[ 'jquery' ],
 78 | 			\DUPLICATE_POST_CURRENT_VERSION,
 79 | 			true
 80 | 		);
 81 | 	}
 82 | 
 83 | 	/**
 84 | 	 * Enqueues the styles.
 85 | 	 *
 86 | 	 * @return void
 87 | 	 */
 88 | 	public function enqueue_styles() {
 89 | 		\wp_enqueue_style( 'duplicate-post' );
 90 | 	}
 91 | 
 92 | 	/**
 93 | 	 * Enqueues the styles for the options page.
 94 | 	 *
 95 | 	 * @return void
 96 | 	 */
 97 | 	public function enqueue_options_styles() {
 98 | 		\wp_enqueue_style( 'duplicate-post-options' );
 99 | 	}
100 | 
101 | 	/**
102 | 	 * Enqueues the script for the Block editor and passes object via localization.
103 | 	 *
104 | 	 * @param array $data_object The object to pass to the script.
105 | 	 *
106 | 	 * @return void
107 | 	 */
108 | 	public function enqueue_edit_script( $data_object = [] ) {
109 | 		$handle = 'duplicate_post_edit_script';
110 | 		\wp_enqueue_script( $handle );
111 | 		\wp_add_inline_script(
112 | 			$handle,
113 | 			'let duplicatePostNotices = {};',
114 | 			'before'
115 | 		);
116 | 		\wp_localize_script(
117 | 			$handle,
118 | 			'duplicatePost',
119 | 			$data_object
120 | 		);
121 | 	}
122 | 
123 | 	/**
124 | 	 * Enqueues the script for the Javascript strings and passes object via localization.
125 | 	 *
126 | 	 * @param array $data_object The object to pass to the script.
127 | 	 *
128 | 	 * @return void
129 | 	 */
130 | 	public function enqueue_strings_script( $data_object = [] ) {
131 | 		$handle = 'duplicate_post_strings';
132 | 		\wp_enqueue_script( $handle );
133 | 		\wp_localize_script(
134 | 			$handle,
135 | 			'duplicatePostStrings',
136 | 			$data_object
137 | 		);
138 | 	}
139 | 
140 | 	/**
141 | 	 * Enqueues the script for the Quick Edit.
142 | 	 *
143 | 	 * @return void
144 | 	 */
145 | 	public function enqueue_quick_edit_script() {
146 | 		\wp_enqueue_script( 'duplicate_post_quick_edit_script' );
147 | 	}
148 | 
149 | 	/**
150 | 	 * Enqueues the script for the Options page.
151 | 	 *
152 | 	 * @return void
153 | 	 */
154 | 	public function enqueue_options_script() {
155 | 		\wp_enqueue_script( 'duplicate_post_options_script' );
156 | 	}
157 | 
158 | 	/**
159 | 	 * Enqueues the script for the Elementor plugin.
160 | 	 *
161 | 	 * @param array $data_object The object to pass to the script.
162 | 	 *
163 | 	 * @return void
164 | 	 */
165 | 	public function enqueue_elementor_script( $data_object = [] ) {
166 | 		$flattened_version = Utils::flatten_version( \DUPLICATE_POST_CURRENT_VERSION );
167 | 		$handle            = 'duplicate_post_elementor_script';
168 | 
169 | 		\wp_register_script(
170 | 			$handle,
171 | 			\plugins_url( \sprintf( 'js/dist/duplicate-post-elementor-%s.js', $flattened_version ), \DUPLICATE_POST_FILE ),
172 | 			[ 'jquery' ],
173 | 			\DUPLICATE_POST_CURRENT_VERSION,
174 | 			true
175 | 		);
176 | 		\wp_enqueue_script( $handle );
177 | 		\wp_localize_script(
178 | 			$handle,
179 | 			'duplicatePost',
180 | 			$data_object
181 | 		);
182 | 	}
183 | }
184 | 


--------------------------------------------------------------------------------
/src/ui/block-editor.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | use Yoast\WP\Duplicate_Post\Utils;
  8 | 
  9 | /**
 10 |  * Duplicate Post class to manage the block editor UI.
 11 |  */
 12 | class Block_Editor {
 13 | 
 14 | 	/**
 15 | 	 * Holds the object to create the action link to duplicate.
 16 | 	 *
 17 | 	 * @var Link_Builder
 18 | 	 */
 19 | 	protected $link_builder;
 20 | 
 21 | 	/**
 22 | 	 * Holds the permissions helper.
 23 | 	 *
 24 | 	 * @var Permissions_Helper
 25 | 	 */
 26 | 	protected $permissions_helper;
 27 | 
 28 | 	/**
 29 | 	 * Holds the asset manager.
 30 | 	 *
 31 | 	 * @var Asset_Manager
 32 | 	 */
 33 | 	protected $asset_manager;
 34 | 
 35 | 	/**
 36 | 	 * Initializes the class.
 37 | 	 *
 38 | 	 * @param Link_Builder       $link_builder       The link builder.
 39 | 	 * @param Permissions_Helper $permissions_helper The permissions helper.
 40 | 	 * @param Asset_Manager      $asset_manager      The asset manager.
 41 | 	 */
 42 | 	public function __construct( Link_Builder $link_builder, Permissions_Helper $permissions_helper, Asset_Manager $asset_manager ) {
 43 | 		$this->link_builder       = $link_builder;
 44 | 		$this->permissions_helper = $permissions_helper;
 45 | 		$this->asset_manager      = $asset_manager;
 46 | 	}
 47 | 
 48 | 	/**
 49 | 	 * Adds hooks to integrate with WordPress.
 50 | 	 *
 51 | 	 * @return void
 52 | 	 */
 53 | 	public function register_hooks() {
 54 | 		\add_action( 'elementor/editor/after_enqueue_styles', [ $this, 'hide_elementor_post_status' ] );
 55 | 		\add_action( 'elementor/editor/before_enqueue_scripts', [ $this, 'enqueue_elementor_script' ], 9 );
 56 | 		\add_action( 'admin_enqueue_scripts', [ $this, 'should_previously_used_keyword_assessment_run' ], 9 );
 57 | 		\add_action( 'enqueue_block_editor_assets', [ $this, 'enqueue_block_editor_scripts' ] );
 58 | 		\add_filter( 'wpseo_link_suggestions_indexables', [ $this, 'remove_original_from_wpseo_link_suggestions' ], 10, 3 );
 59 | 	}
 60 | 
 61 | 	/**
 62 | 	 * Enqueues the necessary Elementor script for the current post.
 63 | 	 *
 64 | 	 * @return void
 65 | 	 */
 66 | 	public function enqueue_elementor_script() {
 67 | 		$post = \get_post();
 68 | 
 69 | 		if ( ! $post instanceof WP_Post ) {
 70 | 			return;
 71 | 		}
 72 | 
 73 | 		$edit_js_object = $this->generate_js_object( $post );
 74 | 		$this->asset_manager->enqueue_elementor_script( $edit_js_object );
 75 | 	}
 76 | 
 77 | 	/**
 78 | 	 * Hides the post status control if we're working on a Rewrite and Republish post.
 79 | 	 *
 80 | 	 * @return void
 81 | 	 */
 82 | 	public function hide_elementor_post_status() {
 83 | 		$post = \get_post();
 84 | 
 85 | 		if ( ! $post instanceof WP_Post || ! $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
 86 | 			return;
 87 | 		}
 88 | 		\wp_add_inline_style(
 89 | 			'elementor-editor',
 90 | 			'.elementor-control-post_status { display: none !important; }'
 91 | 		);
 92 | 	}
 93 | 
 94 | 	/**
 95 | 	 * Disables the Yoast SEO PreviouslyUsedKeyword assessment for Rewrite & Republish original and duplicate posts.
 96 | 	 *
 97 | 	 * @return void
 98 | 	 */
 99 | 	public function should_previously_used_keyword_assessment_run() {
100 | 		if ( $this->permissions_helper->is_edit_post_screen() || $this->permissions_helper->is_new_post_screen() ) {
101 | 
102 | 			$post = \get_post();
103 | 
104 | 			if (
105 | 				$post instanceof WP_Post
106 | 				&& (
107 | 					$this->permissions_helper->is_rewrite_and_republish_copy( $post )
108 | 					|| $this->permissions_helper->has_rewrite_and_republish_copy( $post )
109 | 				)
110 | 			) {
111 | 				\add_filter( 'wpseo_previously_used_keyword_active', '__return_false' );
112 | 			}
113 | 		}
114 | 	}
115 | 
116 | 	/**
117 | 	 * Enqueues the necessary JavaScript code for the block editor.
118 | 	 *
119 | 	 * @return void
120 | 	 */
121 | 	public function enqueue_block_editor_scripts() {
122 | 		if ( ! $this->permissions_helper->is_edit_post_screen() && ! $this->permissions_helper->is_new_post_screen() ) {
123 | 			return;
124 | 		}
125 | 
126 | 		$post = \get_post();
127 | 
128 | 		if ( ! $post instanceof WP_Post ) {
129 | 			return;
130 | 		}
131 | 
132 | 		$edit_js_object = $this->generate_js_object( $post );
133 | 		$this->asset_manager->enqueue_edit_script( $edit_js_object );
134 | 
135 | 		if ( $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
136 | 			$string_js_object = [
137 | 				'checkLink' => $this->get_check_permalink(),
138 | 			];
139 | 			$this->asset_manager->enqueue_strings_script( $string_js_object );
140 | 		}
141 | 	}
142 | 
143 | 	/**
144 | 	 * Generates a New Draft permalink for the current post.
145 | 	 *
146 | 	 * @return string The permalink. Returns empty if the post can't be copied.
147 | 	 */
148 | 	public function get_new_draft_permalink() {
149 | 		$post = \get_post();
150 | 
151 | 		if ( ! $post instanceof WP_Post || ! $this->permissions_helper->should_links_be_displayed( $post ) ) {
152 | 			return '';
153 | 		}
154 | 
155 | 		return $this->link_builder->build_new_draft_link( $post );
156 | 	}
157 | 
158 | 	/**
159 | 	 * Generates a Rewrite & Republish permalink for the current post.
160 | 	 *
161 | 	 * @return string The permalink. Returns empty if the post cannot be copied for Rewrite & Republish.
162 | 	 */
163 | 	public function get_rewrite_republish_permalink() {
164 | 		$post = \get_post();
165 | 
166 | 		if (
167 | 			! $post instanceof WP_Post
168 | 			|| $this->permissions_helper->is_rewrite_and_republish_copy( $post )
169 | 			|| $this->permissions_helper->has_rewrite_and_republish_copy( $post )
170 | 			|| ! $this->permissions_helper->should_links_be_displayed( $post )
171 | 		) {
172 | 			return '';
173 | 		}
174 | 
175 | 		return $this->link_builder->build_rewrite_and_republish_link( $post );
176 | 	}
177 | 
178 | 	/**
179 | 	 * Generates a Check Changes permalink for the current post, if it's intended for Rewrite & Republish.
180 | 	 *
181 | 	 * @return string The permalink. Returns empty if the post does not exist or it's not a Rewrite & Republish copy.
182 | 	 */
183 | 	public function get_check_permalink() {
184 | 		$post = \get_post();
185 | 
186 | 		if ( ! $post instanceof WP_Post || ! $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
187 | 			return '';
188 | 		}
189 | 
190 | 		return $this->link_builder->build_check_link( $post );
191 | 	}
192 | 
193 | 	/**
194 | 	 * Generates a URL to the original post edit screen.
195 | 	 *
196 | 	 * @return string The URL. Empty if the copy post doesn't have an original.
197 | 	 */
198 | 	public function get_original_post_edit_url() {
199 | 		$post = \get_post();
200 | 
201 | 		if ( ! $post instanceof WP_Post || ! $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
202 | 			return '';
203 | 		}
204 | 
205 | 		$original_post_id = Utils::get_original_post_id( $post->ID );
206 | 
207 | 		if ( ! $original_post_id ) {
208 | 			return '';
209 | 		}
210 | 
211 | 		return \add_query_arg(
212 | 			[
213 | 				'dprepublished' => 1,
214 | 				'dpcopy'        => $post->ID,
215 | 				'dpnonce'       => \wp_create_nonce( 'dp-republish' ),
216 | 			],
217 | 			\admin_url( 'post.php?action=edit&post=' . $original_post_id )
218 | 		);
219 | 	}
220 | 
221 | 	/**
222 | 	 * Generates an array of data to be passed as a localization object to JavaScript.
223 | 	 *
224 | 	 * @param WP_Post $post The current post object.
225 | 	 *
226 | 	 * @return array<string, mixed> The data to pass to JavaScript.
227 | 	 */
228 | 	protected function generate_js_object( WP_Post $post ) {
229 | 		$is_rewrite_and_republish_copy = $this->permissions_helper->is_rewrite_and_republish_copy( $post );
230 | 
231 | 		return [
232 | 			'newDraftLink'            => $this->get_new_draft_permalink(),
233 | 			'rewriteAndRepublishLink' => $this->get_rewrite_republish_permalink(),
234 | 			'showLinks'               => Utils::get_option( 'duplicate_post_show_link' ),
235 | 			'showLinksIn'             => Utils::get_option( 'duplicate_post_show_link_in' ),
236 | 			'rewriting'               => ( $is_rewrite_and_republish_copy ) ? 1 : 0,
237 | 			'originalEditURL'         => $this->get_original_post_edit_url(),
238 | 		];
239 | 	}
240 | 
241 | 	/**
242 | 	 * Filters the Yoast SEO Premium link suggestions.
243 | 	 *
244 | 	 * Removes the original post from the Yoast SEO Premium link suggestions
245 | 	 * displayed on the Rewrite & Republish copy.
246 | 	 *
247 | 	 * @param array  $suggestions An array of suggestion indexables that can be filtered.
248 | 	 * @param int    $object_id   The object id for the current indexable.
249 | 	 * @param string $object_type The object type for the current indexable.
250 | 	 *
251 | 	 * @return array The filtered array of suggestion indexables.
252 | 	 */
253 | 	public function remove_original_from_wpseo_link_suggestions( $suggestions, $object_id, $object_type ) {
254 | 		if ( $object_type !== 'post' ) {
255 | 			return $suggestions;
256 | 		}
257 | 
258 | 		// WordPress get_post already checks if the passed ID is valid and returns null if it's not.
259 | 		$post = \get_post( $object_id );
260 | 
261 | 		if ( ! $post instanceof WP_Post || ! $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
262 | 			return $suggestions;
263 | 		}
264 | 
265 | 		$original_post_id = Utils::get_original_post_id( $post->ID );
266 | 
267 | 		return \array_filter(
268 | 			$suggestions,
269 | 			static function ( $suggestion ) use ( $original_post_id ) {
270 | 				return $suggestion->object_id !== $original_post_id;
271 | 			}
272 | 		);
273 | 	}
274 | }
275 | 


--------------------------------------------------------------------------------
/src/ui/bulk-actions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post\UI;
 4 | 
 5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
 6 | use Yoast\WP\Duplicate_Post\Utils;
 7 | 
 8 | /**
 9 |  * Duplicate Post class to manage the bulk actions menu.
10 |  */
11 | class Bulk_Actions {
12 | 
13 | 	/**
14 | 	 * Holds the permissions helper.
15 | 	 *
16 | 	 * @var Permissions_Helper
17 | 	 */
18 | 	protected $permissions_helper;
19 | 
20 | 	/**
21 | 	 * Initializes the class.
22 | 	 *
23 | 	 * @param Permissions_Helper $permissions_helper The permissions helper.
24 | 	 */
25 | 	public function __construct( Permissions_Helper $permissions_helper ) {
26 | 		$this->permissions_helper = $permissions_helper;
27 | 	}
28 | 
29 | 	/**
30 | 	 * Adds hooks to integrate with WordPress.
31 | 	 *
32 | 	 * @return void
33 | 	 */
34 | 	public function register_hooks() {
35 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link_in', 'bulkactions' ) ) === 0 ) {
36 | 			return;
37 | 		}
38 | 
39 | 		\add_action( 'admin_init', [ $this, 'add_bulk_filters' ] );
40 | 	}
41 | 
42 | 	/**
43 | 	 * Hooks the function to add the Rewrite & Republish option in the bulk actions for the selected post types.
44 | 	 *
45 | 	 * @return void
46 | 	 */
47 | 	public function add_bulk_filters() {
48 | 		if ( ! $this->permissions_helper->is_current_user_allowed_to_copy() ) {
49 | 			return;
50 | 		}
51 | 
52 | 		$duplicate_post_types_enabled = $this->permissions_helper->get_enabled_post_types();
53 | 		foreach ( $duplicate_post_types_enabled as $duplicate_post_type_enabled ) {
54 | 			\add_filter( "bulk_actions-edit-{$duplicate_post_type_enabled}", [ $this, 'register_bulk_action' ] );
55 | 		}
56 | 	}
57 | 
58 | 	/**
59 | 	 * Adds 'Rewrite & Republish' to the bulk action dropdown.
60 | 	 *
61 | 	 * @param array $bulk_actions The bulk actions array.
62 | 	 *
63 | 	 * @return array The bulk actions array.
64 | 	 */
65 | 	public function register_bulk_action( $bulk_actions ) {
66 | 		$is_draft_or_trash = isset( $_REQUEST['post_status'] ) && \in_array( $_REQUEST['post_status'], [ 'draft', 'trash' ], true );
67 | 
68 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link', 'clone' ) ) === 1 ) {
69 | 			$bulk_actions['duplicate_post_bulk_clone'] = \esc_html__( 'Clone', 'duplicate-post' );
70 | 		}
71 | 
72 | 		if ( ! $is_draft_or_trash
73 | 			&& \intval( Utils::get_option( 'duplicate_post_show_link', 'rewrite_republish' ) ) === 1 ) {
74 | 			$bulk_actions['duplicate_post_bulk_rewrite_republish'] = \esc_html__( 'Rewrite & Republish', 'duplicate-post' );
75 | 		}
76 | 
77 | 		return $bulk_actions;
78 | 	}
79 | }
80 | 


--------------------------------------------------------------------------------
/src/ui/classic-editor.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | use Yoast\WP\Duplicate_Post\Utils;
  8 | 
  9 | /**
 10 |  * Duplicate Post class to manage the classic editor UI.
 11 |  */
 12 | class Classic_Editor {
 13 | 
 14 | 	/**
 15 | 	 * Holds the object to create the action link to duplicate.
 16 | 	 *
 17 | 	 * @var Link_Builder
 18 | 	 */
 19 | 	protected $link_builder;
 20 | 
 21 | 	/**
 22 | 	 * Holds the permissions helper.
 23 | 	 *
 24 | 	 * @var Permissions_Helper
 25 | 	 */
 26 | 	protected $permissions_helper;
 27 | 
 28 | 	/**
 29 | 	 * Holds the asset manager.
 30 | 	 *
 31 | 	 * @var Asset_Manager
 32 | 	 */
 33 | 	protected $asset_manager;
 34 | 
 35 | 	/**
 36 | 	 * Initializes the class.
 37 | 	 *
 38 | 	 * @param Link_Builder       $link_builder       The link builder.
 39 | 	 * @param Permissions_Helper $permissions_helper The permissions helper.
 40 | 	 * @param Asset_Manager      $asset_manager      The asset manager.
 41 | 	 */
 42 | 	public function __construct( Link_Builder $link_builder, Permissions_Helper $permissions_helper, Asset_Manager $asset_manager ) {
 43 | 		$this->link_builder       = $link_builder;
 44 | 		$this->permissions_helper = $permissions_helper;
 45 | 		$this->asset_manager      = $asset_manager;
 46 | 	}
 47 | 
 48 | 	/**
 49 | 	 * Adds hooks to integrate with WordPress.
 50 | 	 *
 51 | 	 * @return void
 52 | 	 */
 53 | 	public function register_hooks() {
 54 | 		\add_action( 'post_submitbox_misc_actions', [ $this, 'add_check_changes_link' ], 90 );
 55 | 
 56 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link_in', 'submitbox' ) ) === 1 ) {
 57 | 			if ( \intval( Utils::get_option( 'duplicate_post_show_link', 'new_draft' ) ) === 1 ) {
 58 | 				\add_action( 'post_submitbox_start', [ $this, 'add_new_draft_post_button' ] );
 59 | 			}
 60 | 
 61 | 			if ( \intval( Utils::get_option( 'duplicate_post_show_link', 'rewrite_republish' ) ) === 1 ) {
 62 | 				\add_action( 'post_submitbox_start', [ $this, 'add_rewrite_and_republish_post_button' ] );
 63 | 			}
 64 | 		}
 65 | 
 66 | 		\add_action( 'load-post.php', [ $this, 'hook_translations' ] );
 67 | 		\add_filter( 'post_updated_messages', [ $this, 'change_scheduled_notice_classic_editor' ] );
 68 | 
 69 | 		\add_action( 'admin_enqueue_scripts', [ $this, 'enqueue_classic_editor_scripts' ] );
 70 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link_in', 'submitbox' ) ) === 1 ) {
 71 | 			if ( \intval( Utils::get_option( 'duplicate_post_show_link', 'new_draft' ) ) === 1
 72 | 				|| \intval( Utils::get_option( 'duplicate_post_show_link', 'rewrite_republish' ) ) === 1 ) {
 73 | 				\add_action( 'admin_enqueue_scripts', [ $this, 'enqueue_classic_editor_styles' ] );
 74 | 			}
 75 | 		}
 76 | 
 77 | 		// Remove slug editing from Classic Editor.
 78 | 		\add_action( 'add_meta_boxes', [ $this, 'remove_slug_meta_box' ], 10, 2 );
 79 | 		\add_filter( 'get_sample_permalink_html', [ $this, 'remove_sample_permalink_slug_editor' ], 10, 5 );
 80 | 	}
 81 | 
 82 | 	/**
 83 | 	 * Hooks the functions to change the translations.
 84 | 	 *
 85 | 	 * @return void
 86 | 	 */
 87 | 	public function hook_translations() {
 88 | 			\add_filter( 'gettext', [ $this, 'change_republish_strings_classic_editor' ], 10, 3 );
 89 | 			\add_filter( 'gettext_with_context', [ $this, 'change_schedule_strings_classic_editor' ], 10, 4 );
 90 | 	}
 91 | 
 92 | 	/**
 93 | 	 * Enqueues the necessary JavaScript code for the Classic editor.
 94 | 	 *
 95 | 	 * @return void
 96 | 	 */
 97 | 	public function enqueue_classic_editor_scripts() {
 98 | 		if ( $this->permissions_helper->is_classic_editor() && isset( $_GET['post'] ) ) {
 99 | 			$id   = \intval( \wp_unslash( $_GET['post'] ) );
100 | 			$post = \get_post( $id );
101 | 
102 | 			if ( ! \is_null( $post ) && $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
103 | 				$this->asset_manager->enqueue_strings_script();
104 | 			}
105 | 		}
106 | 	}
107 | 
108 | 	/**
109 | 	 * Enqueues the necessary styles for the Classic editor.
110 | 	 *
111 | 	 * @return void
112 | 	 */
113 | 	public function enqueue_classic_editor_styles() {
114 | 		if ( $this->permissions_helper->is_classic_editor()
115 | 			&& isset( $_GET['post'] ) ) {
116 | 			$id   = \intval( \wp_unslash( $_GET['post'] ) );
117 | 			$post = \get_post( $id );
118 | 
119 | 			if ( ! \is_null( $post ) && $this->permissions_helper->should_links_be_displayed( $post ) ) {
120 | 				$this->asset_manager->enqueue_styles();
121 | 			}
122 | 		}
123 | 	}
124 | 
125 | 	/**
126 | 	 * Adds a button in the post/page edit screen to create a clone
127 | 	 *
128 | 	 * @param WP_Post|null $post The post object that's being edited.
129 | 	 *
130 | 	 * @return void
131 | 	 */
132 | 	public function add_new_draft_post_button( $post = null ) {
133 | 		if ( \is_null( $post ) ) {
134 | 			if ( isset( $_GET['post'] ) ) {
135 | 				$id   = \intval( \wp_unslash( $_GET['post'] ) );
136 | 				$post = \get_post( $id );
137 | 			}
138 | 		}
139 | 
140 | 		if ( $post instanceof WP_Post && $this->permissions_helper->should_links_be_displayed( $post ) ) {
141 | 			?>
142 | 			<div id="duplicate-action">
143 | 				<a class="submitduplicate duplication"
144 | 					href="<?php echo \esc_url( $this->link_builder->build_new_draft_link( $post ) ); ?>"><?php \esc_html_e( 'Copy to a new draft', 'duplicate-post' ); ?>
145 | 				</a>
146 | 			</div>
147 | 			<?php
148 | 		}
149 | 	}
150 | 
151 | 	/**
152 | 	 * Adds a button in the post/page edit screen to create a clone for Rewrite & Republish.
153 | 	 *
154 | 	 * @param WP_Post|null $post The post object that's being edited.
155 | 	 *
156 | 	 * @return void
157 | 	 */
158 | 	public function add_rewrite_and_republish_post_button( $post = null ) {
159 | 		if ( \is_null( $post ) ) {
160 | 			if ( isset( $_GET['post'] ) ) {
161 | 				$id   = \intval( \wp_unslash( $_GET['post'] ) );
162 | 				$post = \get_post( $id );
163 | 			}
164 | 		}
165 | 
166 | 		if (
167 | 			$post instanceof WP_Post
168 | 			&& $this->permissions_helper->should_rewrite_and_republish_be_allowed( $post )
169 | 			&& $this->permissions_helper->should_links_be_displayed( $post )
170 | 		) {
171 | 			?>
172 | 			<div id="rewrite-republish-action">
173 | 				<a class="submitduplicate duplication" href="<?php echo \esc_url( $this->link_builder->build_rewrite_and_republish_link( $post ) ); ?>"><?php \esc_html_e( 'Rewrite & Republish', 'duplicate-post' ); ?>
174 | 				</a>
175 | 			</div>
176 | 			<?php
177 | 		}
178 | 	}
179 | 
180 | 	/**
181 | 	 * Adds a message in the post/page edit screen to create a clone for Rewrite & Republish.
182 | 	 *
183 | 	 * @param WP_Post|null $post The post object that's being edited.
184 | 	 *
185 | 	 * @return void
186 | 	 */
187 | 	public function add_check_changes_link( $post = null ) {
188 | 		if ( \is_null( $post ) ) {
189 | 			if ( isset( $_GET['post'] ) ) {
190 | 				$id   = \intval( \wp_unslash( $_GET['post'] ) );
191 | 				$post = \get_post( $id );
192 | 			}
193 | 		}
194 | 
195 | 		if ( $post instanceof WP_Post && $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
196 | 			?>
197 | 				<div id="check-changes-action" class="misc-pub-section">
198 | 					<?php \esc_html_e( 'Do you want to compare your changes with the original version before merging? Please save any changes first.', 'duplicate-post' ); ?>
199 | 					<br><br>
200 | 					<a class='button' href=<?php echo \esc_url( $this->link_builder->build_check_link( $post ) ); ?>>
201 | 						<?php \esc_html_e( 'Compare', 'duplicate-post' ); ?>
202 | 					</a>
203 | 				</div>
204 | 				<?php
205 | 		}
206 | 	}
207 | 
208 | 	/**
209 | 	 * Changes the 'Publish' copies in the submitbox to 'Republish' if a post is intended for republishing.
210 | 	 *
211 | 	 * @param string $translation The translated text.
212 | 	 * @param string $text        The text to translate.
213 | 	 * @param string $domain      The translation domain.
214 | 	 *
215 | 	 * @return string The to-be-used copy of the text.
216 | 	 */
217 | 	public function change_republish_strings_classic_editor( $translation, $text, $domain ) {
218 | 		if ( $domain !== 'default' ) {
219 | 			return $translation;
220 | 		}
221 | 
222 | 		if ( $text === 'Publish'
223 | 			&& $this->should_change_rewrite_republish_copy( \get_post() ) ) {
224 | 				return \__( 'Republish', 'duplicate-post' );
225 | 		}
226 | 		elseif ( $text === 'Publish on: %s'
227 | 			&& $this->should_change_rewrite_republish_copy( \get_post() ) ) {
228 | 			/* translators: %s: Date on which the post is to be republished. */
229 | 			return \__( 'Republish on: %s', 'duplicate-post' );
230 | 		}
231 | 
232 | 		return $translation;
233 | 	}
234 | 
235 | 	/**
236 | 	 * Changes the 'Schedule' copy in the submitbox to 'Schedule republish' if a post is intended for republishing.
237 | 	 *
238 | 	 * @param string $translation The translated text.
239 | 	 * @param string $text        The text to translate.
240 | 	 * @param string $context     The translation context.
241 | 	 * @param string $domain      The translation domain.
242 | 	 *
243 | 	 * @return string The to-be-used copy of the text.
244 | 	 */
245 | 	public function change_schedule_strings_classic_editor( $translation, $text, $context, $domain ) {
246 | 		if ( $domain !== 'default' || $context !== 'post action/button label' ) {
247 | 			return $translation;
248 | 		}
249 | 
250 | 		if ( $text === 'Schedule'
251 | 			&& $this->should_change_rewrite_republish_copy( \get_post() ) ) {
252 | 			return \__( 'Schedule republish', 'duplicate-post' );
253 | 		}
254 | 
255 | 		return $translation;
256 | 	}
257 | 
258 | 	/**
259 | 	 * Changes the post-scheduled notice when a post or page intended for republishing is scheduled.
260 | 	 *
261 | 	 * @param array[] $messages Post updated messaged.
262 | 	 *
263 | 	 * @return array[] The to-be-used messages.
264 | 	 */
265 | 	public function change_scheduled_notice_classic_editor( $messages ) {
266 | 		$post = \get_post();
267 | 		if ( ! $this->should_change_rewrite_republish_copy( $post ) ) {
268 | 			return $messages;
269 | 		}
270 | 
271 | 		$permalink      = \get_permalink( $post->ID );
272 | 		$scheduled_date = \get_the_time( \get_option( 'date_format' ), $post );
273 | 		$scheduled_time = \get_the_time( \get_option( 'time_format' ), $post );
274 | 
275 | 		if ( $post->post_type === 'post' ) {
276 | 			$messages['post'][9] = \sprintf(
277 | 				/* translators: 1: The post title with a link to the frontend page, 2: The scheduled date and time. */
278 | 				\esc_html__(
279 | 					'This rewritten post %1$s is now scheduled to replace the original post. It will be published on %2$s.',
280 | 					'duplicate-post'
281 | 				),
282 | 				'<a href="' . $permalink . '">' . $post->post_title . '</a>',
283 | 				'<strong>' . $scheduled_date . ' ' . $scheduled_time . '</strong>'
284 | 			);
285 | 			return $messages;
286 | 		}
287 | 
288 | 		if ( $post->post_type === 'page' ) {
289 | 			$messages['page'][9] = \sprintf(
290 | 				/* translators: 1: The page title with a link to the frontend page, 2: The scheduled date and time. */
291 | 				\esc_html__(
292 | 					'This rewritten page %1$s is now scheduled to replace the original page. It will be published on %2$s.',
293 | 					'duplicate-post'
294 | 				),
295 | 				'<a href="' . $permalink . '">' . $post->post_title . '</a>',
296 | 				'<strong>' . $scheduled_date . ' ' . $scheduled_time . '</strong>'
297 | 			);
298 | 		}
299 | 
300 | 		return $messages;
301 | 	}
302 | 
303 | 	/**
304 | 	 * Determines if the Rewrite & Republish copies for the post should be used.
305 | 	 *
306 | 	 * @param WP_Post $post The current post object.
307 | 	 *
308 | 	 * @return bool True if the Rewrite & Republish copies should be used.
309 | 	 */
310 | 	public function should_change_rewrite_republish_copy( $post ) {
311 | 		global $pagenow;
312 | 		if ( ! \in_array( $pagenow, [ 'post.php', 'post-new.php' ], true ) ) {
313 | 			return false;
314 | 		}
315 | 
316 | 		if ( ! $post instanceof WP_Post ) {
317 | 			return false;
318 | 		}
319 | 
320 | 		return $this->permissions_helper->is_rewrite_and_republish_copy( $post );
321 | 	}
322 | 
323 | 	/**
324 | 	 * Removes the slug meta box in the Classic Editor when the post is a Rewrite & Republish copy.
325 | 	 *
326 | 	 * @param string  $post_type Post type.
327 | 	 * @param WP_Post $post      Post object.
328 | 	 *
329 | 	 * @return void
330 | 	 */
331 | 	public function remove_slug_meta_box( $post_type, $post ) {
332 | 		if ( $post instanceof WP_Post && $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
333 | 			\remove_meta_box( 'slugdiv', $post_type, 'normal' );
334 | 		}
335 | 	}
336 | 
337 | 	/**
338 | 	 * Removes the sample permalink slug editor in the Classic Editor when the post is a Rewrite & Republish copy.
339 | 	 *
340 | 	 * @param string  $html      Sample permalink HTML markup.
341 | 	 * @param int     $post_id   Post ID.
342 | 	 * @param string  $new_title New sample permalink title.
343 | 	 * @param string  $new_slug  New sample permalink slug.
344 | 	 * @param WP_Post $post      Post object.
345 | 	 *
346 | 	 * @return string The filtered HTML of the sample permalink slug editor.
347 | 	 */
348 | 	public function remove_sample_permalink_slug_editor( $html, $post_id, $new_title, $new_slug, $post ) {
349 | 		if ( ! $post instanceof WP_Post ) {
350 | 			return $html;
351 | 		}
352 | 
353 | 		if ( $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
354 | 			return '';
355 | 		}
356 | 
357 | 		return $html;
358 | 	}
359 | }
360 | 


--------------------------------------------------------------------------------
/src/ui/column.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | use Yoast\WP\Duplicate_Post\Utils;
  8 | 
  9 | /**
 10 |  * Duplicate Post class to manage the custom column + quick edit.
 11 |  */
 12 | class Column {
 13 | 
 14 | 	/**
 15 | 	 * Holds the permissions helper.
 16 | 	 *
 17 | 	 * @var Permissions_Helper
 18 | 	 */
 19 | 	protected $permissions_helper;
 20 | 
 21 | 	/**
 22 | 	 * Holds the asset manager.
 23 | 	 *
 24 | 	 * @var Asset_Manager
 25 | 	 */
 26 | 	protected $asset_manager;
 27 | 
 28 | 	/**
 29 | 	 * Initializes the class.
 30 | 	 *
 31 | 	 * @param Permissions_Helper $permissions_helper The permissions helper.
 32 | 	 * @param Asset_Manager      $asset_manager      The asset manager.
 33 | 	 */
 34 | 	public function __construct( Permissions_Helper $permissions_helper, Asset_Manager $asset_manager ) {
 35 | 		$this->permissions_helper = $permissions_helper;
 36 | 		$this->asset_manager      = $asset_manager;
 37 | 	}
 38 | 
 39 | 	/**
 40 | 	 * Adds hooks to integrate with WordPress.
 41 | 	 *
 42 | 	 * @return void
 43 | 	 */
 44 | 	public function register_hooks() {
 45 | 		if ( \intval( \get_option( 'duplicate_post_show_original_column' ) ) === 1 ) {
 46 | 			$enabled_post_types = $this->permissions_helper->get_enabled_post_types();
 47 | 			if ( \count( $enabled_post_types ) ) {
 48 | 				foreach ( $enabled_post_types as $enabled_post_type ) {
 49 | 					\add_filter( "manage_{$enabled_post_type}_posts_columns", [ $this, 'add_original_column' ] );
 50 | 					\add_action( "manage_{$enabled_post_type}_posts_custom_column", [ $this, 'show_original_item' ], 10, 2 );
 51 | 				}
 52 | 				\add_action( 'quick_edit_custom_box', [ $this, 'quick_edit_remove_original' ] );
 53 | 				\add_action( 'admin_enqueue_scripts', [ $this, 'admin_enqueue_scripts' ] );
 54 | 				\add_action( 'admin_enqueue_scripts', [ $this, 'admin_enqueue_styles' ] );
 55 | 			}
 56 | 		}
 57 | 	}
 58 | 
 59 | 	/**
 60 | 	 * Adds Original item column to the post list.
 61 | 	 *
 62 | 	 * @param array $post_columns The post columns array.
 63 | 	 *
 64 | 	 * @return array The updated array.
 65 | 	 */
 66 | 	public function add_original_column( $post_columns ) {
 67 | 		if ( \is_array( $post_columns ) ) {
 68 | 			$post_columns['duplicate_post_original_item'] = \__( 'Original item', 'duplicate-post' );
 69 | 		}
 70 | 		return $post_columns;
 71 | 	}
 72 | 
 73 | 	/**
 74 | 	 * Sets the text to be displayed in the Original item column for the current post.
 75 | 	 *
 76 | 	 * @param string $column_name The name for the current column.
 77 | 	 * @param int    $post_id     The ID for the current post.
 78 | 	 *
 79 | 	 * @return void
 80 | 	 */
 81 | 	public function show_original_item( $column_name, $post_id ) {
 82 | 		if ( $column_name === 'duplicate_post_original_item' ) {
 83 | 			$column_content = '-';
 84 | 			$data_attr      = ' data-no-original="1"';
 85 | 			$original_item  = Utils::get_original( $post_id );
 86 | 			if ( $original_item ) {
 87 | 				$post      = \get_post( $post_id );
 88 | 				$data_attr = '';
 89 | 
 90 | 				if ( $post instanceof WP_Post
 91 | 					&& $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
 92 | 					$data_attr = ' data-copy-is-for-rewrite-and-republish="1"';
 93 | 				}
 94 | 
 95 | 				$column_content = Utils::get_edit_or_view_link( $original_item );
 96 | 			}
 97 | 			\printf(
 98 | 				'<span class="duplicate_post_original_link"%s>%s</span>',
 99 | 				$data_attr, // phpcs:ignore WordPress.Security.EscapeOutput
100 | 				$column_content // phpcs:ignore WordPress.Security.EscapeOutput
101 | 			);
102 | 		}
103 | 	}
104 | 
105 | 	/**
106 | 	 * Adds original item checkbox + edit link in the Quick Edit.
107 | 	 *
108 | 	 * @param string $column_name The name for the current column.
109 | 	 *
110 | 	 * @return void
111 | 	 */
112 | 	public function quick_edit_remove_original( $column_name ) {
113 | 		if ( $column_name !== 'duplicate_post_original_item' ) {
114 | 			return;
115 | 		}
116 | 		\printf(
117 | 			'<fieldset class="inline-edit-col-left" id="duplicate_post_quick_edit_fieldset">
118 | 			<div class="inline-edit-col">
119 | 				<input type="checkbox"
120 | 				name="duplicate_post_remove_original"
121 | 				id="duplicate-post-remove-original"
122 | 				value="duplicate_post_remove_original"
123 | 				aria-describedby="duplicate-post-remove-original-description">
124 | 				<label for="duplicate-post-remove-original">
125 | 					<span class="checkbox-title">%s</span>
126 | 				</label>
127 | 				<span id="duplicate-post-remove-original-description" class="checkbox-title">%s</span>
128 | 			</div>
129 | 		</fieldset>',
130 | 			\esc_html__(
131 | 				'Delete reference to original item.',
132 | 				'duplicate-post'
133 | 			),
134 | 			\wp_kses(
135 | 				\__(
136 | 					'The original item this was copied from is: <span class="duplicate_post_original_item_title_span"></span>',
137 | 					'duplicate-post'
138 | 				),
139 | 				[
140 | 					'span' => [
141 | 						'class' => [],
142 | 					],
143 | 				]
144 | 			)
145 | 		);
146 | 	}
147 | 
148 | 	/**
149 | 	 * Enqueues the Javascript file to inject column data into the Quick Edit.
150 | 	 *
151 | 	 * @param string $hook The current admin page.
152 | 	 *
153 | 	 * @return void
154 | 	 */
155 | 	public function admin_enqueue_scripts( $hook ) {
156 | 		if ( $hook === 'edit.php' ) {
157 | 			$this->asset_manager->enqueue_quick_edit_script();
158 | 		}
159 | 	}
160 | 
161 | 	/**
162 | 	 * Enqueues the CSS file to for the Quick edit
163 | 	 *
164 | 	 * @param string $hook The current admin page.
165 | 	 *
166 | 	 * @return void
167 | 	 */
168 | 	public function admin_enqueue_styles( $hook ) {
169 | 		if ( $hook === 'edit.php' ) {
170 | 			$this->asset_manager->enqueue_styles();
171 | 		}
172 | 	}
173 | }
174 | 


--------------------------------------------------------------------------------
/src/ui/link-builder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post\UI;
 4 | 
 5 | use WP_Post;
 6 | 
 7 | /**
 8 |  * Duplicate Post link builder.
 9 |  */
10 | class Link_Builder {
11 | 
12 | 	/**
13 | 	 * Builds URL for duplication action for the Rewrite & Republish feature.
14 | 	 *
15 | 	 * @param int|WP_Post $post    The post object or ID.
16 | 	 * @param string      $context The context in which the URL will be used.
17 | 	 *
18 | 	 * @return string The URL for the link.
19 | 	 */
20 | 	public function build_rewrite_and_republish_link( $post, $context = 'display' ) {
21 | 		return $this->build_link( $post, $context, 'duplicate_post_rewrite' );
22 | 	}
23 | 
24 | 	/**
25 | 	 * Builds URL for the "Clone" action.
26 | 	 *
27 | 	 * @param int|WP_Post $post    The post object or ID.
28 | 	 * @param string      $context The context in which the URL will be used.
29 | 	 *
30 | 	 * @return string The URL for the link.
31 | 	 */
32 | 	public function build_clone_link( $post, $context = 'display' ) {
33 | 		return $this->build_link( $post, $context, 'duplicate_post_clone' );
34 | 	}
35 | 
36 | 	/**
37 | 	 * Builds URL for the "Copy to a new draft" action.
38 | 	 *
39 | 	 * @param int|WP_Post $post    The post object or ID.
40 | 	 * @param string      $context The context in which the URL will be used.
41 | 	 *
42 | 	 * @return string The URL for the link.
43 | 	 */
44 | 	public function build_new_draft_link( $post, $context = 'display' ) {
45 | 		return $this->build_link( $post, $context, 'duplicate_post_new_draft' );
46 | 	}
47 | 
48 | 	/**
49 | 	 * Builds URL for the "Check Changes" action.
50 | 	 *
51 | 	 * @param int|WP_Post $post    The post object or ID.
52 | 	 * @param string      $context The context in which the URL will be used.
53 | 	 *
54 | 	 * @return string The URL for the link.
55 | 	 */
56 | 	public function build_check_link( $post, $context = 'display' ) {
57 | 		return $this->build_link( $post, $context, 'duplicate_post_check_changes' );
58 | 	}
59 | 
60 | 	/**
61 | 	 * Builds URL for duplication action.
62 | 	 *
63 | 	 * @param int|WP_Post $post        The post object or ID.
64 | 	 * @param string      $context     The context in which the URL will be used.
65 | 	 * @param string      $action_name The action for the URL.
66 | 	 *
67 | 	 * @return string The URL for the link.
68 | 	 */
69 | 	public function build_link( $post, $context, $action_name ) {
70 | 		$post = \get_post( $post );
71 | 		if ( ! $post instanceof WP_Post ) {
72 | 			return '';
73 | 		}
74 | 
75 | 		if ( $context === 'display' ) {
76 | 			$action = '?action=' . $action_name . '&amp;post=' . $post->ID;
77 | 		}
78 | 		else {
79 | 			$action = '?action=' . $action_name . '&post=' . $post->ID;
80 | 		}
81 | 
82 | 		return \wp_nonce_url(
83 | 			/**
84 | 			 * Filter on the URL of the clone link
85 | 			 *
86 | 			 * @param string $url           The URL of the clone link.
87 | 			 * @param int    $ID            The ID of the post
88 | 			 * @param string $context       The context in which the URL is used.
89 | 			 * @param string $action_name   The action name.
90 | 			 *
91 | 			 * @return string
92 | 			 */
93 | 			\apply_filters( 'duplicate_post_get_clone_post_link', \admin_url( 'admin.php' . $action ), $post->ID, $context, $action_name ),
94 | 			$action_name . '_' . $post->ID
95 | 		);
96 | 	}
97 | }
98 | 


--------------------------------------------------------------------------------
/src/ui/metabox.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | use Yoast\WP\Duplicate_Post\Utils;
  8 | 
  9 | /**
 10 |  * Duplicate Post class to manage the metabox.
 11 |  */
 12 | class Metabox {
 13 | 
 14 | 	/**
 15 | 	 * Holds the permissions helper.
 16 | 	 *
 17 | 	 * @var Permissions_Helper
 18 | 	 */
 19 | 	protected $permissions_helper;
 20 | 
 21 | 	/**
 22 | 	 * Initializes the class.
 23 | 	 *
 24 | 	 * @param Permissions_Helper $permissions_helper The permissions helper.
 25 | 	 */
 26 | 	public function __construct( Permissions_Helper $permissions_helper ) {
 27 | 		$this->permissions_helper = $permissions_helper;
 28 | 	}
 29 | 
 30 | 	/**
 31 | 	 * Adds hooks to integrate with WordPress.
 32 | 	 *
 33 | 	 * @return void
 34 | 	 */
 35 | 	public function register_hooks() {
 36 | 		if ( \intval( \get_option( 'duplicate_post_show_original_meta_box' ) ) === 1 ) {
 37 | 			\add_action( 'add_meta_boxes', [ $this, 'add_custom_metabox' ], 10, 2 );
 38 | 		}
 39 | 	}
 40 | 
 41 | 	/**
 42 | 	 * Adds a metabox to Edit screen.
 43 | 	 *
 44 | 	 * @param string  $post_type The post type.
 45 | 	 * @param WP_Post $post      The current post object.
 46 | 	 *
 47 | 	 * @return void
 48 | 	 */
 49 | 	public function add_custom_metabox( $post_type, $post ) {
 50 | 		$enabled_post_types = $this->permissions_helper->get_enabled_post_types();
 51 | 
 52 | 		if ( \in_array( $post_type, $enabled_post_types, true )
 53 | 			&& $post instanceof WP_Post ) {
 54 | 			$original_item = Utils::get_original( $post );
 55 | 
 56 | 			if ( $original_item instanceof WP_Post ) {
 57 | 				\add_meta_box(
 58 | 					'duplicate_post_show_original',
 59 | 					\__( 'Duplicate Post', 'duplicate-post' ),
 60 | 					[ $this, 'custom_metabox_html' ],
 61 | 					$post_type,
 62 | 					'side',
 63 | 					'default',
 64 | 					[ 'original' => $original_item ]
 65 | 				);
 66 | 			}
 67 | 		}
 68 | 	}
 69 | 
 70 | 	/**
 71 | 	 * Outputs the HTML for the metabox.
 72 | 	 *
 73 | 	 * @param WP_Post $post    The current post.
 74 | 	 * @param array   $metabox The array containing the metabox data.
 75 | 	 *
 76 | 	 * @return void
 77 | 	 */
 78 | 	public function custom_metabox_html( $post, $metabox ) {
 79 | 		$original_item = $metabox['args']['original'];
 80 | 		if ( ! $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
 81 | 			?>
 82 | 		<p>
 83 | 			<input type="checkbox"
 84 | 				name="duplicate_post_remove_original"
 85 | 				id="duplicate-post-remove-original"
 86 | 				value="duplicate_post_remove_original"
 87 | 				aria-describedby="duplicate-post-remove-original-description">
 88 | 			<label for="duplicate-post-remove-original">
 89 | 				<?php \esc_html_e( 'Delete reference to original item.', 'duplicate-post' ); ?>
 90 | 			</label>
 91 | 		</p>
 92 | 			<?php
 93 | 		}
 94 | 		?>
 95 | 		<p id="duplicate-post-remove-original-description">
 96 | 			<?php
 97 | 			\printf(
 98 | 				\wp_kses(
 99 | 					/* translators: %s: post title */
100 | 					\__(
101 | 						'The original item this was copied from is: <span class="duplicate_post_original_item_title_span">%s</span>',
102 | 						'duplicate-post'
103 | 					),
104 | 					[
105 | 						'span' => [
106 | 							'class' => [],
107 | 						],
108 | 					]
109 | 				),
110 | 				Utils::get_edit_or_view_link( $original_item )  // phpcs:ignore WordPress.Security.EscapeOutput
111 | 			);
112 | 			?>
113 | 		</p>
114 | 		<?php
115 | 	}
116 | }
117 | 


--------------------------------------------------------------------------------
/src/ui/newsletter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | /**
  6 |  * Newsletter class.
  7 |  */
  8 | class Newsletter {
  9 | 
 10 | 	/**
 11 | 	 * Renders the newsletter signup form.
 12 | 	 *
 13 | 	 * @return string The HTML of the newsletter signup form (escaped).
 14 | 	 */
 15 | 	public static function newsletter_signup_form() {
 16 | 
 17 | 		$newsletter_form_response = self::newsletter_handle_form();
 18 | 
 19 | 		$copy = \sprintf(
 20 | 		/* translators: 1: Yoast */
 21 | 			\esc_html__(
 22 | 				'If you want to stay up to date about all the exciting developments around Duplicate Post, subscribe to the %1$s newsletter!',
 23 | 				'duplicate-post'
 24 | 			),
 25 | 			'Yoast'
 26 | 		);
 27 | 
 28 | 		$email_label = \esc_html__( 'Email address', 'duplicate-post' );
 29 | 
 30 | 		$copy_privacy_policy = \sprintf(
 31 | 			/* translators: %1$s and %2$s are replaced by opening and closing anchor tags. */
 32 | 			\esc_html__(
 33 | 				'Yoast respects your privacy. Read %1$sour privacy policy%2$s on how we handle your personal information.',
 34 | 				'duplicate-post'
 35 | 			),
 36 | 			'<a href="https://yoa.st/4jf" target="_blank">',
 37 | 			'</a>'
 38 | 		);
 39 | 
 40 | 		$response_html = '';
 41 | 		if ( \is_array( $newsletter_form_response ) ) {
 42 | 			$response_status  = $newsletter_form_response['status'];
 43 | 			$response_message = $newsletter_form_response['message'];
 44 | 
 45 | 			$response_html = '<div class="newsletter-response-' . $response_status . ' clear" id="newsletter-response" style="margin-top: 6px;">' . $response_message . '</div>';
 46 | 		}
 47 | 
 48 | 		$html = '
 49 | 		<!-- Begin Newsletter Signup Form -->
 50 | 		<form method="post" id="newsletter-subscribe-form" name="newsletter-subscribe-form" novalidate>
 51 | 		' . \wp_nonce_field( 'newsletter', 'newsletter_nonce', true, false ) . '
 52 | 		<p>' . $copy . '</p>
 53 | 		<div class="newsletter-field-group" style="display: flex; flex-direction: column">
 54 | 			<label for="newsletter-email" style="margin: 0 0 4px 0;"><strong>' . $email_label . '</strong></label>
 55 | 			<div>
 56 | 				<input type="email" value="" name="EMAIL" class="required email" id="newsletter-email" style="margin-right: 4px;">
 57 | 				<input type="submit" value="' . \esc_attr__( 'Subscribe', 'duplicate-post' ) . '" name="subscribe" id="newsletter-subscribe" class="button">
 58 | 			</div>
 59 | 			<p style="font-size: 10px;">' . $copy_privacy_policy . '</p>
 60 | 		</div>
 61 | 		' . $response_html . '
 62 | 		</form>
 63 | 		<!--End Newsletter Signup Form-->
 64 | 		';
 65 | 
 66 | 		return $html;
 67 | 	}
 68 | 
 69 | 	/**
 70 | 	 * Handles and validates Newsletter form.
 71 | 	 *
 72 | 	 * @return array<string, string>|null
 73 | 	 */
 74 | 	private static function newsletter_handle_form() {
 75 | 
 76 | 		//phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- Already sanitized.
 77 | 		if ( isset( $_POST['newsletter_nonce'] ) && ! \wp_verify_nonce( \wp_unslash( $_POST['newsletter_nonce'] ), 'newsletter' ) ) {
 78 | 			return [
 79 | 				'status'    => 'error',
 80 | 				'message'   => \esc_html__( 'Something went wrong. Please try again later.', 'duplicate-post' ),
 81 | 			];
 82 | 		}
 83 | 
 84 | 		$email = null;
 85 | 		if ( isset( $_POST['EMAIL'] ) ) {
 86 | 			$email = \sanitize_email( \wp_unslash( $_POST['EMAIL'] ) );
 87 | 		}
 88 | 
 89 | 		if ( $email === null ) {
 90 | 			return null;
 91 | 		}
 92 | 
 93 | 		if ( ! \is_email( $email ) ) {
 94 | 			return [
 95 | 				'status'    => 'error',
 96 | 				'message'   => \esc_html__( 'Please enter valid e-mail address.', 'duplicate-post' ),
 97 | 			];
 98 | 		}
 99 | 
100 | 		return self::newsletter_subscribe_to_mailblue( $email );
101 | 	}
102 | 
103 | 	/**
104 | 	 * Handles subscription request and provides feedback response.
105 | 	 *
106 | 	 * @param string $email Subscriber email.
107 | 	 *
108 | 	 * @return array<string, string> Feedback response.
109 | 	 */
110 | 	private static function newsletter_subscribe_to_mailblue( $email ) {
111 | 		$response = \wp_remote_post(
112 | 			'https://my.yoast.com/api/Mailing-list/subscribe',
113 | 			[
114 | 				'method'      => 'POST',
115 | 				'body'        => [
116 | 					'customerDetails' => [
117 | 						'email'     => $email,
118 | 						'firstName' => '',
119 | 					],
120 | 					'list'            => 'Yoast newsletter',
121 | 				],
122 | 			]
123 | 		);
124 | 
125 | 		$wp_remote_retrieve_response_code = \wp_remote_retrieve_response_code( $response );
126 | 
127 | 		if ( $wp_remote_retrieve_response_code <= 200 || $wp_remote_retrieve_response_code >= 300 ) {
128 | 			return [
129 | 				'status'    => 'error',
130 | 				'message'   => \esc_html__( 'Something went wrong. Please try again later.', 'duplicate-post' ),
131 | 			];
132 | 		}
133 | 
134 | 		return [
135 | 			'status'    => 'success',
136 | 			'message'   => \esc_html__( 'You have successfully subscribed to the newsletter. Please check your inbox.', 'duplicate-post' ),
137 | 		];
138 | 	}
139 | }
140 | 


--------------------------------------------------------------------------------
/src/ui/post-states.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post\UI;
 4 | 
 5 | use WP_Post;
 6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
 7 | use Yoast\WP\Duplicate_Post\Utils;
 8 | 
 9 | /**
10 |  * Duplicate Post class to manage the post states display.
11 |  */
12 | class Post_States {
13 | 
14 | 	/**
15 | 	 * Holds the permissions helper.
16 | 	 *
17 | 	 * @var Permissions_Helper
18 | 	 */
19 | 	protected $permissions_helper;
20 | 
21 | 	/**
22 | 	 * Initializes the class.
23 | 	 *
24 | 	 * @param Permissions_Helper $permissions_helper The Permissions helper object.
25 | 	 */
26 | 	public function __construct( Permissions_Helper $permissions_helper ) {
27 | 		$this->permissions_helper = $permissions_helper;
28 | 	}
29 | 
30 | 	/**
31 | 	 * Adds hooks to integrate with WordPress.
32 | 	 *
33 | 	 * @return void
34 | 	 */
35 | 	public function register_hooks() {
36 | 		\add_filter( 'display_post_states', [ $this, 'show_original_in_post_states' ], 10, 2 );
37 | 	}
38 | 
39 | 	/**
40 | 	 * Shows link to original post in the post states.
41 | 	 *
42 | 	 * @param array   $post_states The array of post states.
43 | 	 * @param WP_Post $post        The current post.
44 | 	 *
45 | 	 * @return array The updated post states array.
46 | 	 */
47 | 	public function show_original_in_post_states( $post_states, $post ) {
48 | 		if ( ! $post instanceof WP_Post
49 | 			|| ! \is_array( $post_states ) ) {
50 | 			return $post_states;
51 | 		}
52 | 
53 | 		$original_item = Utils::get_original( $post );
54 | 
55 | 		if ( ! $original_item ) {
56 | 			return $post_states;
57 | 		}
58 | 
59 | 		if ( $this->permissions_helper->is_rewrite_and_republish_copy( $post ) ) {
60 | 			/* translators: %s: Original item link (to view or edit) or title. */
61 | 			$post_states['duplicate_post_original_item'] = \sprintf( \esc_html__( 'Rewrite & Republish of %s', 'duplicate-post' ), Utils::get_edit_or_view_link( $original_item ) );
62 | 			return $post_states;
63 | 		}
64 | 
65 | 		if ( \intval( \get_option( 'duplicate_post_show_original_in_post_states' ) ) === 1 ) {
66 | 			/* translators: %s: Original item link (to view or edit) or title. */
67 | 			$post_states['duplicate_post_original_item'] = \sprintf( \__( 'Original: %s', 'duplicate-post' ), Utils::get_edit_or_view_link( $original_item ) );
68 | 		}
69 | 
70 | 		return $post_states;
71 | 	}
72 | }
73 | 


--------------------------------------------------------------------------------
/src/ui/row-actions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | use Yoast\WP\Duplicate_Post\Utils;
  8 | 
  9 | /**
 10 |  * Duplicate Post class to manage the row actions.
 11 |  */
 12 | class Row_Actions {
 13 | 
 14 | 	/**
 15 | 	 * Holds the object to create the action link to duplicate.
 16 | 	 *
 17 | 	 * @var Link_Builder
 18 | 	 */
 19 | 	protected $link_builder;
 20 | 
 21 | 	/**
 22 | 	 * Holds the permissions helper.
 23 | 	 *
 24 | 	 * @var Permissions_Helper
 25 | 	 */
 26 | 	protected $permissions_helper;
 27 | 
 28 | 	/**
 29 | 	 * Initializes the class.
 30 | 	 *
 31 | 	 * @param Link_Builder       $link_builder       The link builder.
 32 | 	 * @param Permissions_Helper $permissions_helper The permissions helper.
 33 | 	 */
 34 | 	public function __construct( Link_Builder $link_builder, Permissions_Helper $permissions_helper ) {
 35 | 		$this->link_builder       = $link_builder;
 36 | 		$this->permissions_helper = $permissions_helper;
 37 | 	}
 38 | 
 39 | 	/**
 40 | 	 * Adds hooks to integrate with WordPress.
 41 | 	 *
 42 | 	 * @return void
 43 | 	 */
 44 | 	public function register_hooks() {
 45 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link_in', 'row' ) ) === 0 ) {
 46 | 			return;
 47 | 		}
 48 | 
 49 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link', 'clone' ) ) === 1 ) {
 50 | 			\add_filter( 'post_row_actions', [ $this, 'add_clone_action_link' ], 10, 2 );
 51 | 			\add_filter( 'page_row_actions', [ $this, 'add_clone_action_link' ], 10, 2 );
 52 | 		}
 53 | 
 54 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link', 'new_draft' ) ) === 1 ) {
 55 | 			\add_filter( 'post_row_actions', [ $this, 'add_new_draft_action_link' ], 10, 2 );
 56 | 			\add_filter( 'page_row_actions', [ $this, 'add_new_draft_action_link' ], 10, 2 );
 57 | 		}
 58 | 
 59 | 		if ( \intval( Utils::get_option( 'duplicate_post_show_link', 'rewrite_republish' ) ) === 1 ) {
 60 | 			\add_filter( 'post_row_actions', [ $this, 'add_rewrite_and_republish_action_link' ], 10, 2 );
 61 | 			\add_filter( 'page_row_actions', [ $this, 'add_rewrite_and_republish_action_link' ], 10, 2 );
 62 | 		}
 63 | 	}
 64 | 
 65 | 	/**
 66 | 	 * Hooks in the `post_row_actions` and `page_row_actions` filters to add a 'Clone' link.
 67 | 	 *
 68 | 	 * @param array   $actions The array of actions from the filter.
 69 | 	 * @param WP_Post $post    The post object.
 70 | 	 *
 71 | 	 * @return array The updated array of actions.
 72 | 	 */
 73 | 	public function add_clone_action_link( $actions, $post ) {
 74 | 		if ( ! $post instanceof WP_Post
 75 | 			|| ! $this->permissions_helper->should_links_be_displayed( $post )
 76 | 			|| ! \is_array( $actions ) ) {
 77 | 			return $actions;
 78 | 		}
 79 | 
 80 | 		$title = \_draft_or_post_title( $post );
 81 | 
 82 | 		$actions['clone'] = '<a href="' . $this->link_builder->build_clone_link( $post->ID )
 83 | 			. '" aria-label="' . \esc_attr(
 84 | 				/* translators: Hidden accessibility text; %s: Post title. */
 85 | 				\sprintf( \__( 'Clone &#8220;%s&#8221;', 'duplicate-post' ), $title )
 86 | 			) . '">'
 87 | 			. \esc_html_x( 'Clone', 'verb', 'duplicate-post' ) . '</a>';
 88 | 
 89 | 		return $actions;
 90 | 	}
 91 | 
 92 | 	/**
 93 | 	 * Hooks in the `post_row_actions` and `page_row_actions` filters to add a 'New Draft' link.
 94 | 	 *
 95 | 	 * @param array   $actions The array of actions from the filter.
 96 | 	 * @param WP_Post $post    The post object.
 97 | 	 *
 98 | 	 * @return array The updated array of actions.
 99 | 	 */
100 | 	public function add_new_draft_action_link( $actions, $post ) {
101 | 		if ( ! $post instanceof WP_Post
102 | 			|| ! $this->permissions_helper->should_links_be_displayed( $post )
103 | 			|| ! \is_array( $actions ) ) {
104 | 			return $actions;
105 | 		}
106 | 
107 | 		$title = \_draft_or_post_title( $post );
108 | 
109 | 		$actions['edit_as_new_draft'] = '<a href="' . $this->link_builder->build_new_draft_link( $post->ID )
110 | 			. '" aria-label="' . \esc_attr(
111 | 				/* translators: Hidden accessibility text; %s: Post title. */
112 | 				\sprintf( \__( 'New draft of &#8220;%s&#8221;', 'duplicate-post' ), $title )
113 | 			) . '">'
114 | 			. \esc_html__( 'New Draft', 'duplicate-post' )
115 | 			. '</a>';
116 | 
117 | 		return $actions;
118 | 	}
119 | 
120 | 	/**
121 | 	 * Hooks in the `post_row_actions` and `page_row_actions` filters to add a 'Rewrite & Republish' link.
122 | 	 *
123 | 	 * @param array   $actions The array of actions from the filter.
124 | 	 * @param WP_Post $post    The post object.
125 | 	 *
126 | 	 * @return array The updated array of actions.
127 | 	 */
128 | 	public function add_rewrite_and_republish_action_link( $actions, $post ) {
129 | 		if (
130 | 			! $post instanceof WP_Post
131 | 			|| ! $this->permissions_helper->should_rewrite_and_republish_be_allowed( $post )
132 | 			|| ! $this->permissions_helper->should_links_be_displayed( $post )
133 | 			|| ! \is_array( $actions )
134 | 		) {
135 | 			return $actions;
136 | 		}
137 | 
138 | 		$title = \_draft_or_post_title( $post );
139 | 
140 | 		$actions['rewrite'] = '<a href="' . $this->link_builder->build_rewrite_and_republish_link( $post->ID )
141 | 			. '" aria-label="' . \esc_attr(
142 | 				/* translators: Hidden accessibility text; %s: Post title. */
143 | 				\sprintf( \__( 'Rewrite & Republish &#8220;%s&#8221;', 'duplicate-post' ), $title )
144 | 			) . '">'
145 | 			. \esc_html_x( 'Rewrite & Republish', 'verb', 'duplicate-post' ) . '</a>';
146 | 
147 | 		return $actions;
148 | 	}
149 | }
150 | 


--------------------------------------------------------------------------------
/src/ui/user-interface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\UI;
  4 | 
  5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  6 | 
  7 | /**
  8 |  * Duplicate Post user interface.
  9 |  */
 10 | class User_Interface {
 11 | 
 12 | 	/**
 13 | 	 * Holds the permissions helper.
 14 | 	 *
 15 | 	 * @var Permissions_Helper
 16 | 	 */
 17 | 	protected $permissions_helper;
 18 | 
 19 | 	/**
 20 | 	 * Holds the object to manage the row actions for the post.
 21 | 	 *
 22 | 	 * @var Row_Actions
 23 | 	 */
 24 | 	protected $row_actions;
 25 | 
 26 | 	/**
 27 | 	 * Holds the object to manage the classic editor UI.
 28 | 	 *
 29 | 	 * @var Classic_Editor
 30 | 	 */
 31 | 	protected $classic_editor;
 32 | 
 33 | 	/**
 34 | 	 * Holds the object to manage the block editor UI.
 35 | 	 *
 36 | 	 * @var Block_Editor
 37 | 	 */
 38 | 	protected $block_editor;
 39 | 
 40 | 	/**
 41 | 	 * Holds the object to manage the admin bar links.
 42 | 	 *
 43 | 	 * @var Admin_Bar
 44 | 	 */
 45 | 	protected $admin_bar;
 46 | 
 47 | 	/**
 48 | 	 * Holds the object to manage the bulk actions dropdown.
 49 | 	 *
 50 | 	 * @var Bulk_Actions
 51 | 	 */
 52 | 	protected $bulk_actions;
 53 | 
 54 | 	/**
 55 | 	 * Post states object.
 56 | 	 *
 57 | 	 * @var Post_States
 58 | 	 */
 59 | 	protected $post_states;
 60 | 
 61 | 	/**
 62 | 	 * Metabox object.
 63 | 	 *
 64 | 	 * @var Metabox
 65 | 	 */
 66 | 	protected $metabox;
 67 | 
 68 | 	/**
 69 | 	 * Newsletter object.
 70 | 	 *
 71 | 	 * @var Newsletter
 72 | 	 */
 73 | 	protected $newsletter;
 74 | 
 75 | 	/**
 76 | 	 * Column object.
 77 | 	 *
 78 | 	 * @var Column
 79 | 	 */
 80 | 	protected $column;
 81 | 
 82 | 	/**
 83 | 	 * Holds the object to create the action link to duplicate.
 84 | 	 *
 85 | 	 * @var Link_Builder
 86 | 	 */
 87 | 	protected $link_builder;
 88 | 
 89 | 	/**
 90 | 	 * Holds the object to create the action link to duplicate.
 91 | 	 *
 92 | 	 * @var Asset_Manager
 93 | 	 */
 94 | 	protected $asset_manager;
 95 | 
 96 | 	/**
 97 | 	 * Initializes the class.
 98 | 	 *
 99 | 	 * @param Permissions_Helper $permissions_helper The permissions helper object.
100 | 	 */
101 | 	public function __construct( Permissions_Helper $permissions_helper ) {
102 | 		$this->permissions_helper = $permissions_helper;
103 | 		$this->link_builder       = new Link_Builder();
104 | 		$this->asset_manager      = new Asset_Manager();
105 | 		$this->asset_manager->register_hooks();
106 | 
107 | 		$this->admin_bar      = new Admin_Bar( $this->link_builder, $this->permissions_helper, $this->asset_manager );
108 | 		$this->block_editor   = new Block_Editor( $this->link_builder, $this->permissions_helper, $this->asset_manager );
109 | 		$this->bulk_actions   = new Bulk_Actions( $this->permissions_helper );
110 | 		$this->column         = new Column( $this->permissions_helper, $this->asset_manager );
111 | 		$this->metabox        = new Metabox( $this->permissions_helper );
112 | 		$this->newsletter     = new Newsletter();
113 | 		$this->post_states    = new Post_States( $this->permissions_helper );
114 | 		$this->classic_editor = new Classic_Editor( $this->link_builder, $this->permissions_helper, $this->asset_manager );
115 | 		$this->row_actions    = new Row_Actions( $this->link_builder, $this->permissions_helper );
116 | 
117 | 		$this->admin_bar->register_hooks();
118 | 		$this->block_editor->register_hooks();
119 | 		$this->bulk_actions->register_hooks();
120 | 		$this->column->register_hooks();
121 | 		$this->metabox->register_hooks();
122 | 		$this->post_states->register_hooks();
123 | 		$this->classic_editor->register_hooks();
124 | 		$this->row_actions->register_hooks();
125 | 	}
126 | }
127 | 


--------------------------------------------------------------------------------
/src/utils.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post;
  4 | 
  5 | use WP_Post;
  6 | 
  7 | /**
  8 |  * Utility methods for Duplicate Post.
  9 |  *
 10 |  * @since 4.0
 11 |  */
 12 | class Utils {
 13 | 
 14 | 	/**
 15 | 	 * Flattens a version number for use in a filename.
 16 | 	 *
 17 | 	 * @param string $version The original version number.
 18 | 	 *
 19 | 	 * @return string The flattened version number.
 20 | 	 */
 21 | 	public static function flatten_version( $version ) {
 22 | 		$parts = \explode( '.', $version );
 23 | 
 24 | 		if ( \count( $parts ) === 2 && \preg_match( '/^\d+$/', $parts[1] ) === 1 ) {
 25 | 			$parts[] = '0';
 26 | 		}
 27 | 
 28 | 		return \implode( '', $parts );
 29 | 	}
 30 | 
 31 | 	/**
 32 | 	 * Adds slashes only to strings.
 33 | 	 *
 34 | 	 * @param mixed $value Value to slash only if string.
 35 | 	 *
 36 | 	 * @return string|mixed
 37 | 	 */
 38 | 	public static function addslashes_to_strings_only( $value ) {
 39 | 		return \is_string( $value ) ? \addslashes( $value ) : $value;
 40 | 	}
 41 | 
 42 | 	/**
 43 | 	 * Replaces faulty core wp_slash().
 44 | 	 *
 45 | 	 * Until WP 5.5 wp_slash() recursively added slashes not just to strings in array/objects, leading to errors.
 46 | 	 *
 47 | 	 * @param mixed $value What to add slashes to.
 48 | 	 *
 49 | 	 * @return mixed
 50 | 	 */
 51 | 	public static function recursively_slash_strings( $value ) {
 52 | 		return \map_deep( $value, [ self::class, 'addslashes_to_strings_only' ] );
 53 | 	}
 54 | 
 55 | 	/**
 56 | 	 * Gets the original post.
 57 | 	 *
 58 | 	 * @param int|WP_Post|null $post   Optional. Post ID or Post object.
 59 | 	 * @param string           $output Optional, default is Object. Either OBJECT, ARRAY_A, or ARRAY_N.
 60 | 	 *
 61 | 	 * @return WP_Post|null Post data if successful, null otherwise.
 62 | 	 */
 63 | 	public static function get_original( $post = null, $output = \OBJECT ) {
 64 | 		$post = \get_post( $post );
 65 | 		if ( ! $post ) {
 66 | 			return null;
 67 | 		}
 68 | 
 69 | 		$original_id = self::get_original_post_id( $post->ID );
 70 | 
 71 | 		if ( empty( $original_id ) ) {
 72 | 			return null;
 73 | 		}
 74 | 
 75 | 		return \get_post( $original_id, $output );
 76 | 	}
 77 | 
 78 | 	/**
 79 | 	 * Determines if the post has ancestors marked for copy.
 80 | 	 *
 81 | 	 * If we are copying children, and the post has already an ancestor marked for copy, we have to filter it out.
 82 | 	 *
 83 | 	 * @param WP_Post $post     The post object.
 84 | 	 * @param array   $post_ids The array of marked post IDs.
 85 | 	 *
 86 | 	 * @return bool Whether the post has ancestors marked for copy.
 87 | 	 */
 88 | 	public static function has_ancestors_marked( $post, $post_ids ) {
 89 | 		$ancestors_in_array = 0;
 90 | 		$parent             = \wp_get_post_parent_id( $post->ID );
 91 | 		while ( $parent ) {
 92 | 			if ( \in_array( $parent, $post_ids, true ) ) {
 93 | 				++$ancestors_in_array;
 94 | 			}
 95 | 			$parent = \wp_get_post_parent_id( $parent );
 96 | 		}
 97 | 		return ( $ancestors_in_array !== 0 );
 98 | 	}
 99 | 
100 | 	/**
101 | 	 * Returns a link to edit, preview or view a post, in accordance to user capabilities.
102 | 	 *
103 | 	 * @param WP_Post $post Post ID or Post object.
104 | 	 *
105 | 	 * @return string|null The link to edit, preview or view a post.
106 | 	 */
107 | 	public static function get_edit_or_view_link( $post ) {
108 | 		$post = \get_post( $post );
109 | 		if ( ! $post ) {
110 | 			return null;
111 | 		}
112 | 
113 | 		$can_edit_post    = \current_user_can( 'edit_post', $post->ID );
114 | 		$title            = \_draft_or_post_title( $post );
115 | 		$post_type_object = \get_post_type_object( $post->post_type );
116 | 
117 | 		if ( $can_edit_post && $post->post_status !== 'trash' ) {
118 | 			return \sprintf(
119 | 				'<a href="%s" aria-label="%s">%s</a>',
120 | 				\esc_url( \get_edit_post_link( $post->ID ) ),
121 | 				/* translators: Hidden accessibility text; %s: post title */
122 | 				\esc_attr( \sprintf( \__( 'Edit &#8220;%s&#8221;', 'duplicate-post' ), $title ) ),
123 | 				$title
124 | 			);
125 | 		}
126 | 		elseif ( \is_post_type_viewable( $post_type_object ) ) {
127 | 			if ( \in_array( $post->post_status, [ 'pending', 'draft', 'future' ], true ) ) {
128 | 				if ( $can_edit_post ) {
129 | 					$preview_link = \get_preview_post_link( $post );
130 | 					return \sprintf(
131 | 						'<a href="%s" rel="bookmark" aria-label="%s">%s</a>',
132 | 						\esc_url( $preview_link ),
133 | 						/* translators: Hidden accessibility text; %s: post title */
134 | 						\esc_attr( \sprintf( \__( 'Preview &#8220;%s&#8221;', 'duplicate-post' ), $title ) ),
135 | 						$title
136 | 					);
137 | 				}
138 | 			}
139 | 			elseif ( $post->post_status !== 'trash' ) {
140 | 				return \sprintf(
141 | 					'<a href="%s" rel="bookmark" aria-label="%s">%s</a>',
142 | 					\esc_url( \get_permalink( $post->ID ) ),
143 | 					/* translators: Hidden accessibility text; %s: post title */
144 | 					\esc_attr( \sprintf( \__( 'View &#8220;%s&#8221;', 'duplicate-post' ), $title ) ),
145 | 					$title
146 | 				);
147 | 			}
148 | 		}
149 | 
150 | 		return $title;
151 | 	}
152 | 
153 | 	/**
154 | 	 * Gets the ID of the original post intended to be rewritten with the copy for Rewrite & Republish.
155 | 	 *
156 | 	 * @param int $post_id The copy post ID.
157 | 	 *
158 | 	 * @return int The original post id of a copy for Rewrite & Republish.
159 | 	 */
160 | 	public static function get_original_post_id( $post_id ) {
161 | 		return (int) \get_post_meta( $post_id, '_dp_original', true );
162 | 	}
163 | 
164 | 	/**
165 | 	 * Gets the registered WordPress roles.
166 | 	 *
167 | 	 * @codeCoverageIgnore As this is a simple wrapper method for a built-in WordPress method, we don't have to test it.
168 | 	 *
169 | 	 * @return array The roles.
170 | 	 */
171 | 	public static function get_roles() {
172 | 		global $wp_roles;
173 | 
174 | 		return $wp_roles->get_names();
175 | 	}
176 | 
177 | 	/**
178 | 	 * Gets the default meta field names to be filtered out.
179 | 	 *
180 | 	 * @return array<string> The names of the meta fields to filter out by default.
181 | 	 */
182 | 	public static function get_default_filtered_meta_names() {
183 | 		return [
184 | 			'_edit_lock',
185 | 			'_edit_last',
186 | 			'_dp_original',
187 | 			'_dp_is_rewrite_republish_copy',
188 | 			'_dp_has_rewrite_republish_copy',
189 | 			'_dp_has_been_republished',
190 | 			'_dp_creation_date_gmt',
191 | 		];
192 | 	}
193 | 
194 | 	/**
195 | 	 * Gets a Duplicate Post option from the database.
196 | 	 *
197 | 	 * @param string $option The option to get.
198 | 	 * @param string $key    The key to retrieve, if the option is an array.
199 | 	 *
200 | 	 * @return mixed The option.
201 | 	 */
202 | 	public static function get_option( $option, $key = '' ) {
203 | 		$option = \get_option( $option );
204 | 
205 | 		if ( ! \is_array( $option ) || empty( $key ) ) {
206 | 			return $option;
207 | 		}
208 | 
209 | 		if ( ! \array_key_exists( $key, $option ) ) {
210 | 			return '';
211 | 		}
212 | 
213 | 		return $option[ $key ];
214 | 	}
215 | 
216 | 	/**
217 | 	 * Determines if a plugin is active.
218 | 	 *
219 | 	 * We can't use is_plugin_active because this must work on the frontend too.
220 | 	 *
221 | 	 * @param string $plugin Path to the plugin file relative to the plugins directory.
222 | 	 *
223 | 	 * @return bool Whether a plugin is currently active.
224 | 	 */
225 | 	public static function is_plugin_active( $plugin ) {
226 | 		if ( \in_array( $plugin, (array) \get_option( 'active_plugins', [] ), true ) ) {
227 | 			return true;
228 | 		}
229 | 
230 | 		if ( ! \is_multisite() ) {
231 | 			return false;
232 | 		}
233 | 
234 | 		$plugins = \get_site_option( 'active_sitewide_plugins' );
235 | 		return isset( $plugins[ $plugin ] );
236 | 	}
237 | }
238 | 


--------------------------------------------------------------------------------
/src/watchers/bulk-actions-watcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post\Watchers;
 4 | 
 5 | /**
 6 |  * Duplicate Post class to watch for the bulk actions and show notices.
 7 |  */
 8 | class Bulk_Actions_Watcher {
 9 | 
10 | 	/**
11 | 	 * Initializes the class.
12 | 	 */
13 | 	public function __construct() {
14 | 		$this->register_hooks();
15 | 	}
16 | 
17 | 	/**
18 | 	 * Adds hooks to integrate with WordPress.
19 | 	 *
20 | 	 * @return void
21 | 	 */
22 | 	public function register_hooks() {
23 | 		\add_filter( 'removable_query_args', [ $this, 'add_removable_query_args' ] );
24 | 		\add_action( 'admin_notices', [ $this, 'add_bulk_clone_admin_notice' ] );
25 | 		\add_action( 'admin_notices', [ $this, 'add_bulk_rewrite_and_republish_admin_notice' ] );
26 | 	}
27 | 
28 | 	/**
29 | 	 * Adds vars to the removable query args.
30 | 	 *
31 | 	 * @param array $removable_query_args Array of query args keys.
32 | 	 *
33 | 	 * @return array The updated array of query args keys.
34 | 	 */
35 | 	public function add_removable_query_args( $removable_query_args ) {
36 | 		if ( \is_array( $removable_query_args ) ) {
37 | 			$removable_query_args[] = 'bulk_cloned';
38 | 			$removable_query_args[] = 'bulk_rewriting';
39 | 		}
40 | 		return $removable_query_args;
41 | 	}
42 | 
43 | 	/**
44 | 	 * Shows a notice after the Clone bulk action has succeeded.
45 | 	 *
46 | 	 * @return void
47 | 	 */
48 | 	public function add_bulk_clone_admin_notice() {
49 | 		if ( ! empty( $_REQUEST['bulk_cloned'] ) ) {
50 | 			$copied_posts = \intval( $_REQUEST['bulk_cloned'] );
51 | 			\printf(
52 | 				'<div id="message" class="notice notice-success fade"><p>'
53 | 				. \esc_html(
54 | 					/* translators: %s: Number of posts copied. */
55 | 					\_n(
56 | 						'%s item copied.',
57 | 						'%s items copied.',
58 | 						$copied_posts,
59 | 						'duplicate-post'
60 | 					)
61 | 				) . '</p></div>',
62 | 				\esc_html( $copied_posts )
63 | 			);
64 | 		}
65 | 	}
66 | 
67 | 	/**
68 | 	 * Shows a notice after the Rewrite & Republish bulk action has succeeded.
69 | 	 *
70 | 	 * @return void
71 | 	 */
72 | 	public function add_bulk_rewrite_and_republish_admin_notice() {
73 | 		if ( ! empty( $_REQUEST['bulk_rewriting'] ) ) {
74 | 			$copied_posts = \intval( $_REQUEST['bulk_rewriting'] );
75 | 			\printf(
76 | 				'<div id="message" class="notice notice-success fade"><p>'
77 | 				. \esc_html(
78 | 					/* translators: %s: Number of posts copied. */
79 | 					\_n(
80 | 						'%s post duplicated. You can now start rewriting your post in the duplicate of the original post. Once you choose to republish it your changes will be merged back into the original post.',
81 | 						'%s posts duplicated. You can now start rewriting your posts in the duplicates of the original posts. Once you choose to republish them your changes will be merged back into the original post.',
82 | 						$copied_posts,
83 | 						'duplicate-post'
84 | 					)
85 | 				) . '</p></div>',
86 | 				\esc_html( $copied_posts )
87 | 			);
88 | 		}
89 | 	}
90 | }
91 | 


--------------------------------------------------------------------------------
/src/watchers/copied-post-watcher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Watchers;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | 
  8 | /**
  9 |  * Duplicate Post class to watch if the current post has a Rewrite & Republish copy.
 10 |  */
 11 | class Copied_Post_Watcher {
 12 | 
 13 | 	/**
 14 | 	 * Holds the permissions helper.
 15 | 	 *
 16 | 	 * @var Permissions_Helper
 17 | 	 */
 18 | 	protected $permissions_helper;
 19 | 
 20 | 	/**
 21 | 	 * Initializes the class.
 22 | 	 *
 23 | 	 * @param Permissions_Helper $permissions_helper The Permissions helper object.
 24 | 	 */
 25 | 	public function __construct( $permissions_helper ) {
 26 | 		$this->permissions_helper = $permissions_helper;
 27 | 
 28 | 		$this->register_hooks();
 29 | 	}
 30 | 
 31 | 	/**
 32 | 	 * Adds hooks to integrate with WordPress.
 33 | 	 *
 34 | 	 * @return void
 35 | 	 */
 36 | 	public function register_hooks() {
 37 | 		\add_action( 'admin_notices', [ $this, 'add_admin_notice' ] );
 38 | 		\add_action( 'enqueue_block_editor_assets', [ $this, 'add_block_editor_notice' ], 11 );
 39 | 	}
 40 | 
 41 | 	/**
 42 | 	 * Generates the translated text for the notice.
 43 | 	 *
 44 | 	 * @param WP_Post $post The current post object.
 45 | 	 *
 46 | 	 * @return string The translated text for the notice.
 47 | 	 */
 48 | 	public function get_notice_text( $post ) {
 49 | 		if ( $this->permissions_helper->has_trashed_rewrite_and_republish_copy( $post ) ) {
 50 | 			return \__(
 51 | 				'You can only make one Rewrite & Republish duplicate at a time, and a duplicate of this post already exists in the trash. Permanently delete it if you want to make a new duplicate.',
 52 | 				'duplicate-post'
 53 | 			);
 54 | 		}
 55 | 
 56 | 		$scheduled_copy = $this->permissions_helper->has_scheduled_rewrite_and_republish_copy( $post );
 57 | 		if ( ! $scheduled_copy ) {
 58 | 			return \__(
 59 | 				'A duplicate of this post was made. Please note that any changes you make to this post will be replaced when the duplicated version is republished.',
 60 | 				'duplicate-post'
 61 | 			);
 62 | 		}
 63 | 
 64 | 		return \sprintf(
 65 | 			/* translators: %1$s: scheduled date of the copy, %2$s: scheduled time of the copy. */
 66 | 			\__(
 67 | 				'A duplicate of this post was made, which is scheduled to replace this post on %1$s at %2$s.',
 68 | 				'duplicate-post'
 69 | 			),
 70 | 			\get_the_time( \get_option( 'date_format' ), $scheduled_copy ),
 71 | 			\get_the_time( \get_option( 'time_format' ), $scheduled_copy )
 72 | 		);
 73 | 	}
 74 | 
 75 | 	/**
 76 | 	 * Shows a notice on the Classic editor.
 77 | 	 *
 78 | 	 * @return void
 79 | 	 */
 80 | 	public function add_admin_notice() {
 81 | 		if ( ! $this->permissions_helper->is_classic_editor() ) {
 82 | 			return;
 83 | 		}
 84 | 
 85 | 		$post = \get_post();
 86 | 
 87 | 		if ( ! $post instanceof WP_Post ) {
 88 | 			return;
 89 | 		}
 90 | 
 91 | 		if ( $this->permissions_helper->has_rewrite_and_republish_copy( $post ) ) {
 92 | 			print '<div id="message" class="notice notice-warning is-dismissible fade"><p>'
 93 | 				. \esc_html( $this->get_notice_text( $post ) )
 94 | 				. '</p></div>';
 95 | 		}
 96 | 	}
 97 | 
 98 | 	/**
 99 | 	 * Shows a notice on the Block editor.
100 | 	 *
101 | 	 * @return void
102 | 	 */
103 | 	public function add_block_editor_notice() {
104 | 		$post = \get_post();
105 | 
106 | 		if ( ! $post instanceof WP_Post ) {
107 | 			return;
108 | 		}
109 | 
110 | 		if ( $this->permissions_helper->has_rewrite_and_republish_copy( $post ) ) {
111 | 
112 | 			$notice = [
113 | 				'text'          => $this->get_notice_text( $post ),
114 | 				'status'        => 'warning',
115 | 				'isDismissible' => true,
116 | 			];
117 | 
118 | 			\wp_add_inline_script(
119 | 				'duplicate_post_edit_script',
120 | 				'duplicatePostNotices.has_rewrite_and_republish_notice = ' . \wp_json_encode( $notice ) . ';',
121 | 				'before'
122 | 			);
123 | 		}
124 | 	}
125 | }
126 | 


--------------------------------------------------------------------------------
/src/watchers/link-actions-watcher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Watchers;
  4 | 
  5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  6 | 
  7 | /**
  8 |  * Duplicate Post class to watch for the link actions and show notices.
  9 |  */
 10 | class Link_Actions_Watcher {
 11 | 
 12 | 	/**
 13 | 	 * Holds the permissions helper.
 14 | 	 *
 15 | 	 * @var Permissions_Helper
 16 | 	 */
 17 | 	protected $permissions_helper;
 18 | 
 19 | 	/**
 20 | 	 * Initializes the class.
 21 | 	 *
 22 | 	 * @param Permissions_Helper $permissions_helper The Permissions helper object.
 23 | 	 */
 24 | 	public function __construct( Permissions_Helper $permissions_helper ) {
 25 | 		$this->permissions_helper = $permissions_helper;
 26 | 
 27 | 		$this->register_hooks();
 28 | 	}
 29 | 
 30 | 	/**
 31 | 	 * Adds hooks to integrate with WordPress.
 32 | 	 *
 33 | 	 * @return void
 34 | 	 */
 35 | 	public function register_hooks() {
 36 | 		\add_filter( 'removable_query_args', [ $this, 'add_removable_query_args' ], 10, 1 );
 37 | 		\add_action( 'admin_notices', [ $this, 'add_clone_admin_notice' ] );
 38 | 		\add_action( 'admin_notices', [ $this, 'add_rewrite_and_republish_admin_notice' ] );
 39 | 		\add_action( 'enqueue_block_editor_assets', [ $this, 'add_rewrite_and_republish_block_editor_notice' ] );
 40 | 	}
 41 | 
 42 | 	/**
 43 | 	 * Adds vars to the removable query args.
 44 | 	 *
 45 | 	 * @param array<string> $removable_query_args Array of query args keys.
 46 | 	 *
 47 | 	 * @return array<string> The updated array of query args keys.
 48 | 	 */
 49 | 	public function add_removable_query_args( $removable_query_args ) {
 50 | 		if ( \is_array( $removable_query_args ) ) {
 51 | 			$removable_query_args[] = 'cloned';
 52 | 			$removable_query_args[] = 'rewriting';
 53 | 		}
 54 | 		return $removable_query_args;
 55 | 	}
 56 | 
 57 | 	/**
 58 | 	 * Shows a notice after the Clone link action has succeeded.
 59 | 	 *
 60 | 	 * @return void
 61 | 	 */
 62 | 	public function add_clone_admin_notice() {
 63 | 		if ( ! empty( $_REQUEST['cloned'] ) ) {
 64 | 			if ( ! $this->permissions_helper->is_classic_editor() ) {
 65 | 				return;
 66 | 			}
 67 | 
 68 | 			$copied_posts = \intval( $_REQUEST['cloned'] );
 69 | 			\printf(
 70 | 				'<div id="message" class="notice notice-success fade"><p>'
 71 | 				. \esc_html(
 72 | 					/* translators: %s: Number of posts copied. */
 73 | 					\_n(
 74 | 						'%s item copied.',
 75 | 						'%s items copied.',
 76 | 						$copied_posts,
 77 | 						'duplicate-post'
 78 | 					)
 79 | 				) . '</p></div>',
 80 | 				\esc_html( $copied_posts )
 81 | 			);
 82 | 		}
 83 | 	}
 84 | 
 85 | 	/**
 86 | 	 * Shows a notice in Classic editor after the Rewrite & Republish action via link has succeeded.
 87 | 	 *
 88 | 	 * @return void
 89 | 	 */
 90 | 	public function add_rewrite_and_republish_admin_notice() {
 91 | 		if ( ! empty( $_REQUEST['rewriting'] ) ) {
 92 | 			if ( ! $this->permissions_helper->is_classic_editor() ) {
 93 | 				return;
 94 | 			}
 95 | 
 96 | 			print '<div id="message" class="notice notice-warning is-dismissible fade"><p>'
 97 | 				. \esc_html__(
 98 | 					'You can now start rewriting your post in this duplicate of the original post. If you click "Republish", your changes will be merged into the original post and you’ll be redirected there.',
 99 | 					'duplicate-post'
100 | 				) . '</p></div>';
101 | 		}
102 | 	}
103 | 
104 | 	/**
105 | 	 * Shows a notice on the Block editor after the Rewrite & Republish action via link has succeeded.
106 | 	 *
107 | 	 * @return void
108 | 	 */
109 | 	public function add_rewrite_and_republish_block_editor_notice() {
110 | 		if ( ! empty( $_REQUEST['rewriting'] ) ) {
111 | 			$notice = [
112 | 				'text'          => \__(
113 | 					'You can now start rewriting your post in this duplicate of the original post. If you click "Republish", this rewritten post will replace the original post.',
114 | 					'duplicate-post'
115 | 				),
116 | 				'status'        => 'warning',
117 | 				'isDismissible' => true,
118 | 			];
119 | 
120 | 			\wp_add_inline_script(
121 | 				'duplicate_post_edit_script',
122 | 				'duplicatePostNotices.rewriting_notice = ' . \wp_json_encode( $notice ) . ';',
123 | 				'before'
124 | 			);
125 | 		}
126 | 	}
127 | }
128 | 


--------------------------------------------------------------------------------
/src/watchers/original-post-watcher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Watchers;
  4 | 
  5 | use WP_Post;
  6 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  7 | 
  8 | /**
  9 |  * Duplicate Post Original post watcher class.
 10 |  *
 11 |  * Watches the original post for changes.
 12 |  *
 13 |  * @since 4.0
 14 |  */
 15 | class Original_Post_Watcher {
 16 | 
 17 | 	/**
 18 | 	 * Holds the permissions helper.
 19 | 	 *
 20 | 	 * @var Permissions_Helper
 21 | 	 */
 22 | 	protected $permissions_helper;
 23 | 
 24 | 	/**
 25 | 	 * Initializes the class.
 26 | 	 *
 27 | 	 * @param Permissions_Helper $permissions_helper The Permissions helper object.
 28 | 	 */
 29 | 	public function __construct( Permissions_Helper $permissions_helper ) {
 30 | 		$this->permissions_helper = $permissions_helper;
 31 | 
 32 | 		$this->register_hooks();
 33 | 	}
 34 | 
 35 | 	/**
 36 | 	 * Registers the hooks.
 37 | 	 *
 38 | 	 * @return void
 39 | 	 */
 40 | 	public function register_hooks() {
 41 | 		\add_action( 'admin_notices', [ $this, 'add_admin_notice' ] );
 42 | 		\add_action( 'enqueue_block_editor_assets', [ $this, 'add_block_editor_notice' ], 11 );
 43 | 	}
 44 | 
 45 | 	/**
 46 | 	 * Generates the translated text for the notice.
 47 | 	 *
 48 | 	 * @return string The translated text for the notice.
 49 | 	 */
 50 | 	public function get_notice_text() {
 51 | 		return \__(
 52 | 			'The original post has been edited in the meantime. If you click "Republish", this rewritten post will replace the original post.',
 53 | 			'duplicate-post'
 54 | 		);
 55 | 	}
 56 | 
 57 | 	/**
 58 | 	 * Shows a notice on the Classic editor.
 59 | 	 *
 60 | 	 * @return void
 61 | 	 */
 62 | 	public function add_admin_notice() {
 63 | 		if ( ! $this->permissions_helper->is_classic_editor() ) {
 64 | 			return;
 65 | 		}
 66 | 
 67 | 		$post = \get_post();
 68 | 
 69 | 		if ( ! $post instanceof WP_Post ) {
 70 | 			return;
 71 | 		}
 72 | 
 73 | 		if ( $this->permissions_helper->has_original_changed( $post ) ) {
 74 | 			print '<div id="message" class="notice notice-warning is-dismissible fade"><p>'
 75 | 				. \esc_html( $this->get_notice_text() )
 76 | 				. '</p></div>';
 77 | 		}
 78 | 	}
 79 | 
 80 | 	/**
 81 | 	 * Shows a notice on the Block editor.
 82 | 	 *
 83 | 	 * @return void
 84 | 	 */
 85 | 	public function add_block_editor_notice() {
 86 | 		$post = \get_post();
 87 | 
 88 | 		if ( ! $post instanceof WP_Post ) {
 89 | 			return;
 90 | 		}
 91 | 
 92 | 		if ( $this->permissions_helper->has_original_changed( $post ) ) {
 93 | 
 94 | 			$notice = [
 95 | 				'text'          => $this->get_notice_text(),
 96 | 				'status'        => 'warning',
 97 | 				'isDismissible' => true,
 98 | 			];
 99 | 
100 | 			\wp_add_inline_script(
101 | 				'duplicate_post_edit_script',
102 | 				'duplicatePostNotices.has_original_changed_notice = ' . \wp_json_encode( $notice ) . ';',
103 | 				'before'
104 | 			);
105 | 		}
106 | 	}
107 | }
108 | 


--------------------------------------------------------------------------------
/src/watchers/republished-post-watcher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yoast\WP\Duplicate_Post\Watchers;
  4 | 
  5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
  6 | 
  7 | /**
  8 |  * Duplicate Post class to watch if the post has been republished for Rewrite & Republish.
  9 |  *
 10 |  * @since 4.0
 11 |  */
 12 | class Republished_Post_Watcher {
 13 | 
 14 | 	/**
 15 | 	 * Holds the permissions helper.
 16 | 	 *
 17 | 	 * @var Permissions_Helper
 18 | 	 */
 19 | 	protected $permissions_helper;
 20 | 
 21 | 	/**
 22 | 	 * Initializes the class.
 23 | 	 *
 24 | 	 * @param Permissions_Helper $permissions_helper The Permissions helper object.
 25 | 	 */
 26 | 	public function __construct( Permissions_Helper $permissions_helper ) {
 27 | 		$this->permissions_helper = $permissions_helper;
 28 | 
 29 | 		$this->register_hooks();
 30 | 	}
 31 | 
 32 | 	/**
 33 | 	 * Adds hooks to integrate with WordPress.
 34 | 	 *
 35 | 	 * @return void
 36 | 	 */
 37 | 	public function register_hooks() {
 38 | 		\add_filter( 'removable_query_args', [ $this, 'add_removable_query_args' ] );
 39 | 		\add_action( 'admin_notices', [ $this, 'add_admin_notice' ] );
 40 | 		\add_action( 'enqueue_block_editor_assets', [ $this, 'add_block_editor_notice' ], 11 );
 41 | 	}
 42 | 
 43 | 	/**
 44 | 	 * Adds vars to the removable query args.
 45 | 	 *
 46 | 	 * @param array<string> $removable_query_args Array of query args keys.
 47 | 	 *
 48 | 	 * @return array<string> The updated array of query args keys.
 49 | 	 */
 50 | 	public function add_removable_query_args( $removable_query_args ) {
 51 | 		if ( \is_array( $removable_query_args ) ) {
 52 | 			$removable_query_args[] = 'dprepublished';
 53 | 			$removable_query_args[] = 'dpcopy';
 54 | 			$removable_query_args[] = 'dpnonce';
 55 | 		}
 56 | 		return $removable_query_args;
 57 | 	}
 58 | 
 59 | 	/**
 60 | 	 * Generates the translated text for the republished notice.
 61 | 	 *
 62 | 	 * @return string The translated text for the republished notice.
 63 | 	 */
 64 | 	public function get_notice_text() {
 65 | 		return \__(
 66 | 			'Your original post has been replaced with the rewritten post. You are now viewing the (rewritten) original post.',
 67 | 			'duplicate-post'
 68 | 		);
 69 | 	}
 70 | 
 71 | 	/**
 72 | 	 * Shows a notice on the Classic editor.
 73 | 	 *
 74 | 	 * @return void
 75 | 	 */
 76 | 	public function add_admin_notice() {
 77 | 		if ( ! $this->permissions_helper->is_classic_editor() ) {
 78 | 			return;
 79 | 		}
 80 | 
 81 | 		if ( ! empty( $_REQUEST['dprepublished'] ) ) {
 82 | 			echo '<div id="message" class="notice notice-success is-dismissible"><p>'
 83 | 				. \esc_html( $this->get_notice_text() )
 84 | 				. '</p></div>';
 85 | 		}
 86 | 	}
 87 | 
 88 | 	/**
 89 | 	 * Shows a notice on the Block editor.
 90 | 	 *
 91 | 	 * @return void
 92 | 	 */
 93 | 	public function add_block_editor_notice() {
 94 | 		if ( ! empty( $_REQUEST['dprepublished'] ) ) {
 95 | 			$notice = [
 96 | 				'text'          => $this->get_notice_text(),
 97 | 				'status'        => 'success',
 98 | 				'isDismissible' => true,
 99 | 			];
100 | 
101 | 			\wp_add_inline_script(
102 | 				'duplicate_post_edit_script',
103 | 				'duplicatePostNotices.republished_notice = ' . \wp_json_encode( $notice ) . ';',
104 | 				'before'
105 | 			);
106 | 		}
107 | 	}
108 | }
109 | 


--------------------------------------------------------------------------------
/src/watchers/watchers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yoast\WP\Duplicate_Post\Watchers;
 4 | 
 5 | use Yoast\WP\Duplicate_Post\Permissions_Helper;
 6 | 
 7 | /**
 8 |  * Duplicate Post user interface.
 9 |  */
10 | class Watchers {
11 | 
12 | 	/**
13 | 	 * Holds the permissions helper.
14 | 	 *
15 | 	 * @var Permissions_Helper
16 | 	 */
17 | 	protected $permissions_helper;
18 | 
19 | 	/**
20 | 	 * Holds the original post watcher.
21 | 	 *
22 | 	 * @var Original_Post_Watcher
23 | 	 */
24 | 	protected $original_post_watcher;
25 | 
26 | 	/**
27 | 	 * Holds the copied post watcher.
28 | 	 *
29 | 	 * @var Copied_Post_Watcher
30 | 	 */
31 | 	protected $copied_post_watcher;
32 | 
33 | 	/**
34 | 	 * Holds the bulk actions watcher.
35 | 	 *
36 | 	 * @var Bulk_Actions_Watcher
37 | 	 */
38 | 	protected $bulk_actions_watcher;
39 | 
40 | 	/**
41 | 	 * Holds the link actions watcher.
42 | 	 *
43 | 	 * @var Link_Actions_Watcher
44 | 	 */
45 | 	protected $link_actions_watcher;
46 | 
47 | 	/**
48 | 	 * Holds the republished post watcher.
49 | 	 *
50 | 	 * @var Republished_Post_Watcher
51 | 	 */
52 | 	protected $republished_post_watcher;
53 | 
54 | 	/**
55 | 	 * Initializes the class.
56 | 	 *
57 | 	 * @param Permissions_Helper $permissions_helper The permissions helper object.
58 | 	 */
59 | 	public function __construct( Permissions_Helper $permissions_helper ) {
60 | 		$this->permissions_helper       = $permissions_helper;
61 | 		$this->copied_post_watcher      = new Copied_Post_Watcher( $this->permissions_helper );
62 | 		$this->original_post_watcher    = new Original_Post_Watcher( $this->permissions_helper );
63 | 		$this->bulk_actions_watcher     = new Bulk_Actions_Watcher();
64 | 		$this->link_actions_watcher     = new Link_Actions_Watcher( $this->permissions_helper );
65 | 		$this->republished_post_watcher = new Republished_Post_Watcher( $this->permissions_helper );
66 | 	}
67 | }
68 | 


--------------------------------------------------------------------------------