templately / includes / Core / Platform / Gutenberg.php

Gutenberg.php in Templately – Elementor & Gutenberg Template Library: 6500+ Free & Pro Ready Templates And Cloud! 3.7.2, at includes/Core/Platform/Gutenberg.php

290 lines 9.2 KB

Raw Download Zip

1	<?php
2	namespace Templately\Core\Platform;
3
4	use Templately\API\Import;
5	use Templately\Core\Importer\Utils\Utils;
6	use Templately\Core\Platform;
7	use Templately\Core\Module;
8	use Templately\Utils\Helper;
9	use Templately\Utils\Options;
10
11	use WP_Error;
12	use function get_permalink;
13	use function get_edit_post_link;
14	use function wp_insert_post;
15	use function wp_slash;
16	use function wp_unslash;
17	use function wp_update_post;
18	use function json_decode;
19
20	class Gutenberg extends Platform {
21	/**
22	* Platform ID
23	* @var string
24	*/
25	private $id = 'gutenberg';
26
27	/**
28	* Is gutenberg is active or not
29	* @var boolean
30	*/
31	public $is_gutenberg_active = false;
32
33	/**
34	* Initializing the platform and add it to module.
35	*/
36	public function __construct(){
37	Module::get_instance()->add( (object) [
38	'id' => $this->id,
39	'object' => $this
40	]);
41
42	$this->hooks();
43	}
44
45	/**
46	* Initializing Hooks
47	* @return void
48	*/
49	public function hooks(){
50	add_action( 'enqueue_block_editor_assets', [ $this, 'scripts' ] );
51	add_action( 'admin_footer', [ $this, 'print_admin_js_template' ] );
52	add_action( 'wp_ajax_update_gutenberg_hide_buttons', [ $this, 'update_gutenberg_hide_buttons' ] ); // Register AJAX action
53	}
54
55	/**
56	* Assets Enqueueing
57	* @return void
58	*/
59	public function scripts(){
60	$this->is_gutenberg_active = true;
61	templately()->assets->enqueue( 'templately-gutenberg', 'css/gutenberg.css' );
62	templately()->assets->enqueue( 'templately-tailwind', 'css/tailwind.css', ['templately-gutenberg'] );
63	templately()->assets->enqueue( 'templately-gutenberg', 'js/gutenberg.js' );
64	templately()->admin->scripts( 'gutenberg' );
65	}
66
67	/**
68	* Templately Button and Wrapper for Gutenberg
69	*
70	* @since 2.0.0
71	*
72	* @return void
73	*/
74	public function print_admin_js_template() {
75	if ( ! $this->is_gutenberg_active ) {
76	return;
77	}
78	$post_type = apply_filters( 'templately_cloud_push_post_type', get_post_type());
79
80	?>
81	<div id="templately-gutenberg"></div>
82	<script id="templately-gutenberg-button-switch-mode" type="text/html">
83	<div id="templately-gutenberg-buttons">
84	<button id="templately-gutenberg-button" type="button" class="button button-primary button-large gutenberg-add-templately-button">
85	<i class="templately-icon" aria-hidden="true"></i>
86	<?php echo esc_html__( 'Templately', 'templately' ); ?>
87	</button>
88	<button id="templately-cloud-push" type="button" class="button button-primary button-large">
89	<i class="templately-cloud-icon" aria-hidden="true"></i>
90	<?php echo sprintf( __( 'Save %s in Templately', 'templately' ), $post_type ); ?>
91	</button>
92	</div>
93	</script>
94	<?php
95	}
96
97	/**
98	* Determine Active UI Theme
99	* @return string
100	*/
101	public function ui_theme(){
102	return 'light';
103	}
104
105	/**
106	* Creating a gutenberg page
107	*
108	* @param integer $id
109	* @param string $title
110	* @param Import $importer
111	*
112	* @since 2.0.0
113	*
114	* @return array\|WP_Error array on success, WP_Error on failure.
115	*/
116	public function create_page( $id, $title, $importer = null, $settings = [] ){
117	$post_data = $inserted_ID = $importer->get_content( $id, 'gutenberg' );
118
119	if( is_wp_error( $inserted_ID ) ) {
120	return $inserted_ID;
121	}
122
123	if ( ! empty( $settings ) && ! empty( $inserted_ID['content'] ) && is_string( $inserted_ID['content'] ) ) {
124	$inserted_ID['content'] = \Templately\Core\Importer\Utils\GutenbergSettingsMerger::merge( $inserted_ID['content'], $settings );
125	$post_data['content'] = $inserted_ID['content'];
126	}
127
128	if ( ! empty( $inserted_ID['content'] ) ) {
129	$inserted_ID = wp_insert_post( array (
130	'post_status' => 'draft',
131	'post_type' => 'page',
132	'post_title' => $title,
133	'post_content' => wp_slash($inserted_ID['content']),
134	) );
135	}
136
137	if ( is_wp_error( $inserted_ID ) ) {
138	return Helper::error(
139	'import_failed',
140	$inserted_ID->get_error_message(),
141	'import/page',
142	$inserted_ID->get_error_code()
143	);
144	}
145
146	if($inserted_ID){
147	$post_data['content'] = Utils::import_and_replace_attachments($post_data['content'], $inserted_ID);
148
149	// Update the post content with the processed images
150	$updated_post = array(
151	'ID' => $inserted_ID,
152	'post_content' => wp_slash($post_data['content']),
153	);
154	wp_update_post($updated_post);
155	}
156
157	return [
158	'post_id' => $inserted_ID,
159	'edit_link' => get_edit_post_link( $inserted_ID, 'internal' ),
160	'visit' => get_permalink( $inserted_ID )
161	];
162	}
163
164	/**
165	* Inserts a template into the Gutenberg editor.
166	*
167	* @param mixed $data
168	* @param int $postId
169	* @param array $settings
170	* @return array
171	*/
172	public function insert($data, $postId = 0, $settings = []) {
173	if ( ! empty( $settings ) && is_array( $settings ) && ! empty( $data['content'] ) && is_string( $data['content'] ) ) {
174	$data['content'] = \Templately\Core\Importer\Utils\GutenbergSettingsMerger::merge( $data['content'], $settings );
175	}
176
177	$data['content'] = Utils::import_and_replace_attachments(
178	$data['content'],
179	$postId,
180	[
181	'attachment_timeout' => 8,
182	'attachment_retries' => 0,
183	'attachment_deadline' => microtime( true ) + 20,
184	]
185	);
186	return $data;
187	}
188
189	/**
190	* Import template to Templately Library
191	*
192	* @param integer $id
193	* @param Import $importer
194	* @param array $settings
195	*
196	* @return array\|WP_Error array on success, WP_Error on failure.
197	*/
198	public function import_in_library( $id, $importer = null, $settings = [], $template_type = '', $item_type = '' ) {
199	$template_data = $importer->get_content( $id, 'gutenberg', 'remote' );
200
201	if ( is_wp_error( $template_data ) ) {
202	return $template_data;
203	}
204
205	if ( ! empty( $settings ) && ! empty( $template_data['content'] ) && is_string( $template_data['content'] ) ) {
206	$template_data['content'] = \Templately\Core\Importer\Utils\GutenbergSettingsMerger::merge( $template_data['content'], $settings );
207	}
208
209	// Handle attachment replacements before saving
210	$template_data['content'] = Utils::import_and_replace_attachments( $template_data['content'], 0 );
211
212	// Frontend-provided template_type (from item details API) takes precedence over
213	// whatever the fetched content JSON reports.
214	if ( ! empty( $template_type ) ) {
215	$template_data['template_type'] = $template_type;
216	}
217
218	// Resolve the correct Builder Type using template_type before passing to the importer.
219	try {
220	$type = static::resolve_library_type( $template_data );
221	} catch ( \InvalidArgumentException $e ) {
222	return Helper::error( 'unsupported_template_type', $e->getMessage(), 'import', 400 );
223	}
224
225	$factory = new \Templately\Builder\Factory\TemplateFactory( 'gutenberg' );
226
227	$template = $factory->create( $type, [
228	'post_title' => $template_data['title'],
229	'post_status' => 'publish',
230	'post_type' => 'templately_library',
231	] );
232
233	if ( is_wp_error( $template ) ) {
234	return $template;
235	}
236
237	$template->import( array_merge( $template_data, [
238	'import_settings' => [
239	'title' => $template_data['title'],
240	'type' => $type,
241	]
242	] ) );
243
244	$post_id = $template->get_main_id();
245
246	// Companion content for archive/fluent types — same side effects (Shop page,
247	// page_for_posts, LearnDash courses slug, fluent single-page template) the FSI
248	// Templates runner performs when importing these template types.
249	Utils::create_companion_content( $type, $template_data['title'] ?? '', 'gutenberg' );
250
251	// Mark user as having imported a template
252	Options::get_instance()->set( 'has_imported_template', true );
253
254	return [
255	'post_id' => $post_id,
256	'edit_link' => get_edit_post_link( $post_id, 'internal' ),
257	'visit' => get_permalink( $post_id ),
258	];
259	}
260
261	/**
262	* AJAX handler to update the option `templately-gutenberg-hide-buttons`
263	*/
264	public function update_gutenberg_hide_buttons() {
265	// Check nonce for security
266	check_ajax_referer( 'templately_nonce', 'nonce' );
267
268	// The nonce alone is not authorization: `templately_nonce` is handed to
269	// every user who loads a Templately-enqueued screen, so without this any
270	// logged-in user could write the option. It toggles buttons in the block
271	// editor, so the people who use that editor are exactly the right gate.
272	if ( ! current_user_can( 'edit_posts' ) ) {
273	wp_send_json_error( [ 'message' => __( 'Insufficient permissions', 'templately' ) ], 403 );
274	}
275
276	// Get the new value from the AJAX request
277	$hide_buttons = isset($_GET['hide_buttons']) ? sanitize_text_field($_GET['hide_buttons']) : '';
278
279	// Update the option
280	update_option('templately-gutenberg-hide-buttons', $hide_buttons);
281
282	$hide_buttons = get_option('templately-gutenberg-hide-buttons', 'no');
283	$hide_buttons = $hide_buttons === 'yes' ? 'yes' : 'no';
284	// Send a response back to the JavaScript
285	wp_send_json_success([
286	'hide_buttons' => $hide_buttons,
287	]);
288	}
289	}
290