elementor / includes / template-library / sources / local.php

local.php in Elementor Website Builder – more than just a page builder 3.22.2, at includes/template-library/sources/local.php

1,758 lines 48.2 KB

Raw Download Zip

1	<?php
2	namespace Elementor\TemplateLibrary;
3
4	use Elementor\Core\Admin\Menu\Admin_Menu_Manager;
5	use Elementor\Core\Base\Document;
6	use Elementor\Core\Editor\Editor;
7	use Elementor\Core\Utils\Collection;
8	use Elementor\DB;
9	use Elementor\Core\Settings\Manager as SettingsManager;
10	use Elementor\Core\Settings\Page\Model;
11	use Elementor\Includes\TemplateLibrary\Sources\AdminMenuItems\Add_New_Template_Menu_Item;
12	use Elementor\Includes\TemplateLibrary\Sources\AdminMenuItems\Saved_Templates_Menu_Item;
13	use Elementor\Includes\TemplateLibrary\Sources\AdminMenuItems\Templates_Categories_Menu_Item;
14	use Elementor\Modules\Library\Documents\Library_Document;
15	use Elementor\Plugin;
16	use Elementor\Utils;
17	use Elementor\User;
18
19	if ( ! defined( 'ABSPATH' ) ) {
20	exit; // Exit if accessed directly.
21	}
22
23	/**
24	* Elementor template library local source.
25	*
26	* Elementor template library local source handler class is responsible for
27	* handling local Elementor templates saved by the user locally on his site.
28	*
29	* @since 1.0.0
30	*/
31	class Source_Local extends Source_Base {
32
33	/**
34	* Elementor template-library post-type slug.
35	*/
36	const CPT = 'elementor_library';
37
38	/**
39	* Elementor template-library taxonomy slug.
40	*/
41	const TAXONOMY_TYPE_SLUG = 'elementor_library_type';
42
43	/**
44	* Elementor template-library category slug.
45	*/
46	const TAXONOMY_CATEGORY_SLUG = 'elementor_library_category';
47
48	/**
49	* Elementor template-library meta key.
50	*
51	* @deprecated 2.3.0 Use `Elementor\Core\Base\Document::TYPE_META_KEY` const instead.
52	*/
53	const TYPE_META_KEY = '_elementor_template_type';
54
55	/**
56	* Elementor template-library temporary files folder.
57	*/
58	const TEMP_FILES_DIR = 'elementor/tmp';
59
60	/**
61	* Elementor template-library bulk export action name.
62	*/
63	const BULK_EXPORT_ACTION = 'elementor_export_multiple_templates';
64
65	const ADMIN_MENU_SLUG = 'edit.php?post_type=elementor_library';
66
67	const ADMIN_MENU_PRIORITY = 10;
68
69	const ADMIN_SCREEN_ID = 'edit-elementor_library';
70
71	/**
72	* Template types.
73	*
74	* Holds the list of supported template types that can be displayed.
75	*
76	* @access private
77	* @static
78	*
79	* @var array
80	*/
81	private static $template_types = [];
82
83	/**
84	* Post type object.
85	*
86	* Holds the post type object of the current post.
87	*
88	* @access private
89	*
90	* @var \WP_Post_Type
91	*/
92	private $post_type_object;
93
94	/**
95	* @since 2.3.0
96	* @access public
97	* @static
98	* @return array
99	*/
100	public static function get_template_types() {
101	return self::$template_types;
102	}
103
104	/**
105	* Get local template type.
106	*
107	* Retrieve the template type from the post meta.
108	*
109	* @since 1.0.0
110	* @access public
111	* @static
112	*
113	* @param int $template_id The template ID.
114	*
115	* @return mixed The value of meta data field.
116	*/
117	public static function get_template_type( $template_id ) {
118	return get_post_meta( $template_id, Document::TYPE_META_KEY, true );
119	}
120
121	/**
122	* Is base templates screen.
123	*
124	* Whether the current screen base is edit and the post type is template.
125	*
126	* @since 1.0.0
127	* @access public
128	* @static
129	*
130	* @return bool True on base templates screen, False otherwise.
131	*/
132	public static function is_base_templates_screen() {
133	global $current_screen;
134
135	if ( ! $current_screen ) {
136	return false;
137	}
138
139	return 'edit' === $current_screen->base && self::CPT === $current_screen->post_type;
140	}
141
142	/**
143	* Add template type.
144	*
145	* Register new template type to the list of supported local template types.
146	*
147	* @since 1.0.3
148	* @access public
149	* @static
150	*
151	* @param string $type Template type.
152	*/
153	public static function add_template_type( $type ) {
154	self::$template_types[ $type ] = $type;
155	}
156
157	/**
158	* Remove template type.
159	*
160	* Remove existing template type from the list of supported local template
161	* types.
162	*
163	* @since 1.8.0
164	* @access public
165	* @static
166	*
167	* @param string $type Template type.
168	*/
169	public static function remove_template_type( $type ) {
170	if ( isset( self::$template_types[ $type ] ) ) {
171	unset( self::$template_types[ $type ] );
172	}
173	}
174
175	public static function get_admin_url( $relative = false ) {
176	$base_url = self::ADMIN_MENU_SLUG;
177	if ( ! $relative ) {
178	$base_url = admin_url( $base_url );
179	}
180
181	return add_query_arg( 'tabs_group', 'library', $base_url );
182	}
183
184	/**
185	* Get local template ID.
186	*
187	* Retrieve the local template ID.
188	*
189	* @since 1.0.0
190	* @access public
191	*
192	* @return string The local template ID.
193	*/
194	public function get_id() {
195	return 'local';
196	}
197
198	/**
199	* Get local template title.
200	*
201	* Retrieve the local template title.
202	*
203	* @since 1.0.0
204	* @access public
205	*
206	* @return string The local template title.
207	*/
208	public function get_title() {
209	return esc_html__( 'Local', 'elementor' );
210	}
211
212	/**
213	* Register local template data.
214	*
215	* Used to register custom template data like a post type, a taxonomy or any
216	* other data.
217	*
218	* The local template class registers a new `elementor_library` post type
219	* and an `elementor_library_type` taxonomy. They are used to store data for
220	* local templates saved by the user on his site.
221	*
222	* @since 1.0.0
223	* @access public
224	*/
225	public function register_data() {
226	$labels = [
227	'name' => esc_html_x( 'My Templates', 'Template Library', 'elementor' ),
228	'singular_name' => esc_html_x( 'Template', 'Template Library', 'elementor' ),
229	'add_new' => esc_html__( 'Add New Template', 'elementor' ),
230	'add_new_item' => esc_html__( 'Add New Template', 'elementor' ),
231	'edit_item' => esc_html__( 'Edit Template', 'elementor' ),
232	'new_item' => esc_html__( 'New Template', 'elementor' ),
233	'all_items' => esc_html__( 'All Templates', 'elementor' ),
234	'view_item' => esc_html__( 'View Template', 'elementor' ),
235	'search_items' => esc_html__( 'Search Template', 'elementor' ),
236	'not_found' => esc_html__( 'No Templates found', 'elementor' ),
237	'not_found_in_trash' => esc_html__( 'No Templates found in Trash', 'elementor' ),
238	'parent_item_colon' => esc_html__( 'Parent Template:', 'elementor' ),
239	'menu_name' => esc_html_x( 'Templates', 'Template Library', 'elementor' ),
240	];
241
242	$args = [
243	'labels' => $labels,
244	'public' => true,
245	'rewrite' => false,
246	'menu_icon' => 'dashicons-admin-page',
247	'show_ui' => true,
248	'show_in_menu' => true,
249	'show_in_nav_menus' => false,
250	'exclude_from_search' => true,
251	'capability_type' => 'post',
252	'hierarchical' => false,
253	'supports' => [ 'title', 'thumbnail', 'author', 'elementor' ],
254	];
255
256	/**
257	* Register template library post type args.
258	*
259	* Filters the post type arguments when registering elementor template library post type.
260	*
261	* @since 1.0.0
262	*
263	* @param array $args Arguments for registering a post type.
264	*/
265	$args = apply_filters( 'elementor/template_library/sources/local/register_post_type_args', $args );
266
267	$this->post_type_object = register_post_type( self::CPT, $args );
268
269	$args = [
270	'hierarchical' => false,
271	'show_ui' => false,
272	'show_in_nav_menus' => false,
273	'show_admin_column' => true,
274	'query_var' => is_admin(),
275	'rewrite' => false,
276	'public' => false,
277	'label' => esc_html_x( 'Type', 'Template Library', 'elementor' ),
278	];
279
280	/**
281	* Register template library taxonomy args.
282	*
283	* Filters the taxonomy arguments when registering elementor template library taxonomy.
284	*
285	* @since 1.0.0
286	*
287	* @param array $args Arguments for registering a taxonomy.
288	*/
289	$args = apply_filters( 'elementor/template_library/sources/local/register_taxonomy_args', $args );
290
291	$cpts_to_associate = [ self::CPT ];
292
293	/**
294	* Custom post types to associate.
295	*
296	* Filters the list of custom post types when registering elementor template library taxonomy.
297	*
298	* @since 1.0.0
299	*
300	* @param array $cpts_to_associate Custom post types. Default is `elementor_library` post type.
301	*/
302	$cpts_to_associate = apply_filters( 'elementor/template_library/sources/local/register_taxonomy_cpts', $cpts_to_associate );
303
304	register_taxonomy( self::TAXONOMY_TYPE_SLUG, $cpts_to_associate, $args );
305
306	/**
307	* Categories
308	*/
309	$args = [
310	'hierarchical' => true,
311	'show_ui' => true,
312	'show_in_nav_menus' => false,
313	'show_admin_column' => true,
314	'query_var' => is_admin(),
315	'rewrite' => false,
316	'public' => false,
317	'labels' => [
318	'name' => esc_html_x( 'Categories', 'Template Library', 'elementor' ),
319	'singular_name' => esc_html_x( 'Category', 'Template Library', 'elementor' ),
320	'all_items' => esc_html_x( 'All Categories', 'Template Library', 'elementor' ),
321	],
322	];
323
324	/**
325	* Register template library category args.
326	*
327	* Filters the category arguments when registering elementor template library category.
328	*
329	* @since 2.4.0
330	*
331	* @param array $args Arguments for registering a category.
332	*/
333	$args = apply_filters( 'elementor/template_library/sources/local/register_category_args', $args );
334
335	register_taxonomy( self::TAXONOMY_CATEGORY_SLUG, self::CPT, $args );
336	}
337
338	/**
339	* Remove Add New item from admin menu.
340	*
341	* Fired by `admin_menu` action.
342	*
343	* @since 2.4.0
344	* @access public
345	*/
346	private function admin_menu_reorder( Admin_Menu_Manager $admin_menu ) {
347	global $submenu;
348
349	if ( ! isset( $submenu[ static::ADMIN_MENU_SLUG ] ) ) {
350	return;
351	}
352
353	remove_submenu_page( static::ADMIN_MENU_SLUG, static::ADMIN_MENU_SLUG );
354
355	$add_new_slug = 'post-new.php?post_type=' . static::CPT;
356	$category_slug = 'edit-tags.php?taxonomy=' . static::TAXONOMY_CATEGORY_SLUG . '&post_type=' . static::CPT;
357
358	$library_submenu = new Collection( $submenu[ static::ADMIN_MENU_SLUG ] );
359
360	$add_new_item = $library_submenu->find( function ( $item ) use ( $add_new_slug ) {
361	return $add_new_slug === $item[2];
362	} );
363
364	$categories_item = $library_submenu->find( function ( $item ) use ( $category_slug ) {
365	return $category_slug === $item[2];
366	} );
367
368	if ( $add_new_item ) {
369	remove_submenu_page( static::ADMIN_MENU_SLUG, $add_new_slug );
370
371	$admin_menu->register( admin_url( static::ADMIN_MENU_SLUG . '#add_new' ), new Add_New_Template_Menu_Item() );
372	}
373
374	if ( $categories_item ) {
375	remove_submenu_page( static::ADMIN_MENU_SLUG, $category_slug );
376
377	$admin_menu->register( $category_slug, new Templates_Categories_Menu_Item() );
378	}
379	}
380
381	/**
382	* Add a `current` CSS class to the `Saved Templates` submenu page when it's active.
383	* It should work by default, but since we interfere with WordPress' builtin CPT menus it doesn't work properly.
384	*
385	* @return void
386	*/
387	private function admin_menu_set_current() {
388	global $submenu;
389
390	if ( $this->is_current_screen() ) {
391	$library_submenu = &$submenu[ static::ADMIN_MENU_SLUG ];
392	$library_title = $this->get_library_title();
393
394	foreach ( $library_submenu as &$item ) {
395	if ( $library_title === $item[0] ) {
396	if ( ! isset( $item[4] ) ) {
397	$item[4] = '';
398	}
399	$item[4] .= ' current';
400	}
401	}
402	}
403	}
404
405	private function register_admin_menu( Admin_Menu_Manager $admin_menu ) {
406	$admin_menu->register( static::get_admin_url( true ), new Saved_Templates_Menu_Item() );
407	}
408
409	public function admin_title( $admin_title, $title ) {
410	$library_title = $this->get_library_title();
411
412	if ( $library_title ) {
413	$admin_title = str_replace( $title, $library_title, $admin_title );
414	}
415
416	return $admin_title;
417	}
418
419	public function replace_admin_heading() {
420	$library_title = $this->get_library_title();
421
422	if ( $library_title ) {
423	global $post_type_object;
424
425	$post_type_object->labels->name = $library_title;
426	}
427	}
428
429	/**
430	* Get local templates.
431	*
432	* Retrieve local templates saved by the user on his site.
433	*
434	* @since 1.0.0
435	* @access public
436	*
437	* @param array $args Optional. Filter templates based on a set of
438	* arguments. Default is an empty array.
439	*
440	* @return array Local templates.
441	*/
442	public function get_items( $args = [] ) {
443	$template_types = array_values( self::$template_types );
444
445	if ( ! empty( $args['type'] ) ) {
446	$template_types = $args['type'];
447	unset( $args['type'] );
448	}
449
450	$defaults = [
451	'post_type' => self::CPT,
452	'post_status' => 'publish',
453	'posts_per_page' => -1,
454	'orderby' => 'title',
455	'order' => 'ASC',
456	'meta_query' => [
457	[
458	'key' => Document::TYPE_META_KEY,
459	'value' => $template_types,
460	],
461	],
462	];
463
464	$query_args = wp_parse_args( $args, $defaults );
465
466	$templates_query = new \WP_Query( $query_args );
467
468	$templates = [];
469
470	if ( $templates_query->have_posts() ) {
471	foreach ( $templates_query->get_posts() as $post ) {
472	$templates[] = $this->get_item( $post->ID );
473	}
474	}
475
476	return $templates;
477	}
478
479	/**
480	* Save local template.
481	*
482	* Save new or update existing template on the database.
483	*
484	* @since 1.0.0
485	* @access public
486	*
487	* @param array $template_data Local template data.
488	*
489	* @return \WP_Error\|int The ID of the saved/updated template, `WP_Error` otherwise.
490	*/
491	public function save_item( $template_data ) {
492	if ( ! current_user_can( $this->post_type_object->cap->edit_posts ) ) {
493	return new \WP_Error( 'save_error', esc_html__( 'Access denied.', 'elementor' ) );
494	}
495
496	$defaults = [
497	'title' => esc_html__( '(no title)', 'elementor' ),
498	'page_settings' => [],
499	];
500
501	$template_data = wp_parse_args( $template_data, $defaults );
502	$template_data['status'] = current_user_can( 'publish_posts' ) ? 'publish' : 'pending';
503
504	// BC: Allow importing any template type when using CLI
505	// to support users that rely on this mechanism.
506	$should_check_template_type = ! $this->is_wp_cli();
507
508	if (
509	$should_check_template_type &&
510	! $this->is_valid_template_type( $template_data['type'] )
511	) {
512	return new \WP_Error( 'invalid_template_type', esc_html__( 'Invalid template type.', 'elementor' ) );
513	}
514
515	$document = Plugin::$instance->documents->create(
516	$template_data['type'],
517	[
518	'post_title' => $template_data['title'],
519	'post_status' => $template_data['status'],
520	]
521	);
522
523	if ( is_wp_error( $document ) ) {
524	/**
525	* @var \WP_Error $document
526	*/
527	return $document;
528	}
529
530	if ( ! empty( $template_data['content'] ) ) {
531	$template_data['content'] = $this->replace_elements_ids( $template_data['content'] );
532	}
533
534	$document->save( [
535	'elements' => $template_data['content'],
536	'settings' => $template_data['page_settings'],
537	] );
538
539	$template_id = $document->get_main_id();
540
541	/**
542	* After template library save.
543	*
544	* Fires after Elementor template library was saved.
545	*
546	* @since 1.0.1
547	*
548	* @param int $template_id The ID of the template.
549	* @param array $template_data The template data.
550	*/
551	do_action( 'elementor/template-library/after_save_template', $template_id, $template_data );
552
553	/**
554	* After template library update.
555	*
556	* Fires after Elementor template library was updated.
557	*
558	* @since 1.0.1
559	*
560	* @param int $template_id The ID of the template.
561	* @param array $template_data The template data.
562	*/
563	do_action( 'elementor/template-library/after_update_template', $template_id, $template_data );
564
565	return $template_id;
566	}
567
568	protected function is_valid_template_type( $type ) {
569	$document_class = Plugin::$instance->documents->get_document_type( $type, false );
570
571	if ( ! $document_class ) {
572	return false;
573	}
574
575	$cpt = $document_class::get_property( 'cpt' );
576
577	if ( ! $cpt \|\| ! is_array( $cpt ) \|\| 1 !== count( $cpt ) ) {
578	return false;
579	}
580
581	return in_array( static::CPT, $cpt, true );
582	}
583
584	// For testing purposes only, in order to be able to mock the `WP_CLI` constant.
585	protected function is_wp_cli() {
586	return Utils::is_wp_cli();
587	}
588
589	/**
590	* Update local template.
591	*
592	* Update template on the database.
593	*
594	* @since 1.0.0
595	* @access public
596	*
597	* @param array $new_data New template data.
598	*
599	* @return \WP_Error\|true True if template updated, `WP_Error` otherwise.
600	*/
601	public function update_item( $new_data ) {
602	if ( ! current_user_can( $this->post_type_object->cap->edit_post, $new_data['id'] ) ) {
603	return new \WP_Error( 'save_error', esc_html__( 'Access denied.', 'elementor' ) );
604	}
605
606	$document = Plugin::$instance->documents->get( $new_data['id'] );
607
608	if ( ! $document ) {
609	return new \WP_Error( 'save_error', esc_html__( 'Template not exist.', 'elementor' ) );
610	}
611
612	$document->save( [
613	'elements' => $new_data['content'],
614	] );
615
616	/**
617	* After template library update.
618	*
619	* Fires after Elementor template library was updated.
620	*
621	* @since 1.0.0
622	*
623	* @param int $new_data_id The ID of the new template.
624	* @param array $new_data The new template data.
625	*/
626	do_action( 'elementor/template-library/after_update_template', $new_data['id'], $new_data );
627
628	return true;
629	}
630
631	/**
632	* Get local template.
633	*
634	* Retrieve a single local template saved by the user on his site.
635	*
636	* @since 1.0.0
637	* @access public
638	*
639	* @param int $template_id The template ID.
640	*
641	* @return array Local template.
642	*/
643	public function get_item( $template_id ) {
644	$post = get_post( $template_id );
645
646	$user = get_user_by( 'id', $post->post_author );
647
648	$page = SettingsManager::get_settings_managers( 'page' )->get_model( $template_id );
649
650	$page_settings = $page->get_data( 'settings' );
651
652	$date = strtotime( $post->post_date );
653
654	$data = [
655	'template_id' => $post->ID,
656	'source' => $this->get_id(),
657	'type' => self::get_template_type( $post->ID ),
658	'title' => $post->post_title,
659	'thumbnail' => get_the_post_thumbnail_url( $post ),
660	'date' => $date,
661	'human_date' => date_i18n( get_option( 'date_format' ), $date ),
662	'human_modified_date' => date_i18n( get_option( 'date_format' ), strtotime( $post->post_modified ) ),
663	'author' => $user->display_name,
664	'status' => $post->post_status,
665	'hasPageSettings' => ! empty( $page_settings ),
666	'tags' => [],
667	'export_link' => $this->get_export_link( $template_id ),
668	'url' => get_permalink( $post->ID ),
669	];
670
671	/**
672	* Get template library template.
673	*
674	* Filters the template data when retrieving a single template from the
675	* template library.
676	*
677	* @since 1.0.0
678	*
679	* @param array $data Template data.
680	*/
681	$data = apply_filters( 'elementor/template-library/get_template', $data );
682
683	return $data;
684	}
685
686	/**
687	* Get template data.
688	*
689	* Retrieve the data of a single local template saved by the user on his site.
690	*
691	* @since 1.5.0
692	* @access public
693	*
694	* @param array $args Custom template arguments.
695	*
696	* @return array Local template data.
697	*/
698	public function get_data( array $args ) {
699	$template_id = $args['template_id'];
700
701	$document = Plugin::$instance->documents->get( $template_id );
702	$content = [];
703
704	if ( $document ) {
705	// TODO: Validate the data (in JS too!).
706	if ( ! empty( $args['display'] ) ) {
707	$content = $document->get_elements_raw_data( null, true );
708	} else {
709	$content = $document->get_elements_data();
710	}
711
712	if ( ! empty( $content ) ) {
713	$content = $this->replace_elements_ids( $content );
714	}
715	}
716
717	$data = [
718	'content' => $content,
719	];
720
721	if ( ! empty( $args['with_page_settings'] ) ) {
722	$page = SettingsManager::get_settings_managers( 'page' )->get_model( $args['template_id'] );
723
724	$data['page_settings'] = $page->get_data( 'settings' );
725	}
726
727	return $data;
728	}
729
730	/**
731	* Delete local template.
732	*
733	* Delete template from the database.
734	*
735	* @since 1.0.0
736	* @access public
737	*
738	* @param int $template_id The template ID.
739	*
740	* @return \WP_Post\|\WP_Error\|false\|null Post data on success, false or null
741	* or 'WP_Error' on failure.
742	*/
743	public function delete_template( $template_id ) {
744	if ( ! current_user_can( $this->post_type_object->cap->delete_post, $template_id ) ) {
745	return new \WP_Error( 'template_error', esc_html__( 'Access denied.', 'elementor' ) );
746	}
747
748	return wp_delete_post( $template_id, true );
749	}
750
751	/**
752	* Export local template.
753	*
754	* Export template to a file.
755	*
756	* @since 1.0.0
757	* @access public
758	*
759	* @param int $template_id The template ID.
760	*
761	* @return \WP_Error WordPress error if template export failed.
762	*/
763	public function export_template( $template_id ) {
764	$file_data = $this->prepare_template_export( $template_id );
765
766	if ( is_wp_error( $file_data ) ) {
767	return $file_data;
768	}
769
770	$this->send_file_headers( $file_data['name'], strlen( $file_data['content'] ) );
771
772	// Clear buffering just in case.
773	@ob_end_clean();
774
775	flush();
776
777	// Output file contents.
778	// PHPCS - Export widget json
779	echo $file_data['content']; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
780
781	die;
782	}
783
784	/**
785	* Export multiple local templates.
786	*
787	* Export multiple template to a ZIP file.
788	*
789	* @since 1.6.0
790	* @access public
791	*
792	* @param array $template_ids An array of template IDs.
793	*
794	* @return \WP_Error WordPress error if export failed.
795	*/
796	public function export_multiple_templates( array $template_ids ) {
797	$files = [];
798
799	$wp_upload_dir = wp_upload_dir();
800
801	$temp_path = $wp_upload_dir['basedir'] . '/' . self::TEMP_FILES_DIR;
802
803	// Create temp path if it doesn't exist
804	wp_mkdir_p( $temp_path );
805
806	// Create all json files
807	foreach ( $template_ids as $template_id ) {
808	$file_data = $this->prepare_template_export( $template_id );
809
810	if ( is_wp_error( $file_data ) ) {
811	continue;
812	}
813
814	$complete_path = $temp_path . '/' . $file_data['name'];
815
816	$put_contents = file_put_contents( $complete_path, $file_data['content'] );
817
818	if ( ! $put_contents ) {
819	return new \WP_Error( '404', sprintf( 'Cannot create file "%s".', $file_data['name'] ) );
820	}
821
822	$files[] = [
823	'path' => $complete_path,
824	'name' => $file_data['name'],
825	];
826	}
827
828	if ( ! $files ) {
829	return new \WP_Error( 'empty_files', 'There is no files to export (probably all the requested templates are empty).' );
830	}
831
832	// Create temporary .zip file
833	$zip_archive_filename = 'elementor-templates-' . gmdate( 'Y-m-d' ) . '.zip';
834
835	$zip_archive = new \ZipArchive();
836
837	$zip_complete_path = $temp_path . '/' . $zip_archive_filename;
838
839	$zip_archive->open( $zip_complete_path, \ZipArchive::CREATE );
840
841	foreach ( $files as $file ) {
842	$zip_archive->addFile( $file['path'], $file['name'] );
843	}
844
845	$zip_archive->close();
846
847	foreach ( $files as $file ) {
848	unlink( $file['path'] );
849	}
850
851	$this->send_file_headers( $zip_archive_filename, filesize( $zip_complete_path ) );
852
853	@ob_end_flush();
854
855	@readfile( $zip_complete_path );
856
857	unlink( $zip_complete_path );
858
859	die;
860	}
861
862	/**
863	* Import local template.
864	*
865	* Import template from a file.
866	*
867	* @since 1.0.0
868	* @access public
869	*
870	* @param string $name - The file name
871	* @param string $path - The file path
872	* @return \WP_Error\|array An array of items on success, 'WP_Error' on failure.
873	*/
874	public function import_template( $name, $path ) {
875	if ( empty( $path ) ) {
876	return new \WP_Error( 'file_error', 'Please upload a file to import' );
877	}
878
879	// Set the Request's state as an Elementor upload request, in order to support unfiltered file uploads.
880	Plugin::$instance->uploads_manager->set_elementor_upload_state( true );
881
882	$items = [];
883
884	// If the import file is a Zip file with potentially multiple JSON files
885	if ( 'zip' === pathinfo( $name, PATHINFO_EXTENSION ) ) {
886	$extracted_files = Plugin::$instance->uploads_manager->extract_and_validate_zip( $path, [ 'json' ] );
887
888	if ( is_wp_error( $extracted_files ) ) {
889	// Delete the temporary extraction directory, since it's now not necessary.
890	Plugin::$instance->uploads_manager->remove_file_or_dir( $extracted_files['extraction_directory'] );
891
892	return $extracted_files;
893	}
894
895	foreach ( $extracted_files['files'] as $file_path ) {
896	$import_result = $this->import_single_template( $file_path );
897
898	if ( is_wp_error( $import_result ) ) {
899	// Delete the temporary extraction directory, since it's now not necessary.
900	Plugin::$instance->uploads_manager->remove_file_or_dir( $extracted_files['extraction_directory'] );
901
902	return $import_result;
903	}
904
905	$items[] = $import_result;
906	}
907
908	// Delete the temporary extraction directory, since it's now not necessary.
909	Plugin::$instance->uploads_manager->remove_file_or_dir( $extracted_files['extraction_directory'] );
910	} else {
911	// If the import file is a single JSON file
912	$import_result = $this->import_single_template( $path );
913
914	if ( is_wp_error( $import_result ) ) {
915	return $import_result;
916	}
917
918	$items[] = $import_result;
919	}
920
921	return $items;
922	}
923
924	/**
925	* Post row actions.
926	*
927	* Add an export link to the template library action links table list.
928	*
929	* Fired by `post_row_actions` filter.
930	*
931	* @since 1.0.0
932	* @access public
933	*
934	* @param array $actions An array of row action links.
935	* @param \WP_Post $post The post object.
936	*
937	* @return array An updated array of row action links.
938	*/
939	public function post_row_actions( $actions, \WP_Post $post ) {
940	if ( self::is_base_templates_screen() ) {
941	if ( $this->is_template_supports_export( $post->ID ) ) {
942	$actions['export-template'] = sprintf( '<a href="%1$s">%2$s</a>', $this->get_export_link( $post->ID ), esc_html__( 'Export Template', 'elementor' ) );
943	}
944	}
945
946	return $actions;
947	}
948
949	/**
950	* Admin import template form.
951	*
952	* The import form displayed in "My Library" screen in WordPress dashboard.
953	*
954	* The form allows the user to import template in json/zip format to the site.
955	*
956	* Fired by `admin_footer` action.
957	*
958	* @since 1.0.0
959	* @access public
960	*/
961	public function admin_import_template_form() {
962	if ( ! self::is_base_templates_screen() \|\| ! User::is_current_user_can_upload_json() ) {
963	return;
964	}
965
966	/** @var \Elementor\Core\Common\Modules\Ajax\Module $ajax */
967	$ajax = Plugin::$instance->common->get_component( 'ajax' );
968	?>
969	<div id="elementor-hidden-area">
970	<a id="elementor-import-template-trigger" class="page-title-action"><?php echo esc_html__( 'Import Templates', 'elementor' ); ?></a>
971	<div id="elementor-import-template-area">
972	<div id="elementor-import-template-title"><?php echo esc_html__( 'Choose an Elementor template JSON file or a .zip archive of Elementor templates, and add them to the list of templates available in your library.', 'elementor' ); ?></div>
973	<form id="elementor-import-template-form" method="post" action="<?php echo esc_url( admin_url( 'admin-ajax.php' ) ); ?>" enctype="multipart/form-data">
974	<input type="hidden" name="action" value="elementor_library_direct_actions">
975	<input type="hidden" name="library_action" value="direct_import_template">
976	<input type="hidden" name="_nonce" value="<?php Utils::print_unescaped_internal_string( $ajax->create_nonce() ); ?>">
977	<fieldset id="elementor-import-template-form-inputs">
978	<input type="file" name="file" accept=".json,application/json,.zip,application/octet-stream,application/zip,application/x-zip,application/x-zip-compressed" required>
979	<input id="e-import-template-action" type="submit" class="button" value="<?php echo esc_attr__( 'Import Now', 'elementor' ); ?>">
980	</fieldset>
981	</form>
982	</div>
983	</div>
984	<?php
985	}
986
987	/**
988	* Block template frontend
989	*
990	* Don't display the single view of the template library post type in the
991	* frontend, for users that don't have the proper permissions.
992	*
993	* Fired by `template_redirect` action.
994	*
995	* @since 1.0.0
996	* @access public
997	*/
998	public function block_template_frontend() {
999	if ( is_singular( self::CPT ) && ! current_user_can( Editor::EDITING_CAPABILITY ) ) {
1000	wp_safe_redirect( site_url(), 301 );
1001	die;
1002	}
1003	}
1004
1005	/**
1006	* Is template library supports export.
1007	*
1008	* whether the template library supports export.
1009	*
1010	* Template saved by the user locally on his site, support export by default
1011	* but this can be changed using a filter.
1012	*
1013	* @since 1.0.0
1014	* @access public
1015	*
1016	* @param int $template_id The template ID.
1017	*
1018	* @return bool Whether the template library supports export.
1019	*/
1020	public function is_template_supports_export( $template_id ) {
1021	$export_support = true;
1022
1023	/**
1024	* Is template library supports export.
1025	*
1026	* Filters whether the template library supports export.
1027	*
1028	* @since 1.0.0
1029	*
1030	* @param bool $export_support Whether the template library supports export.
1031	* Default is true.
1032	* @param int $template_id Post ID.
1033	*/
1034	$export_support = apply_filters( 'elementor/template_library/is_template_supports_export', $export_support, $template_id );
1035
1036	return $export_support;
1037	}
1038
1039	/**
1040	* Remove Elementor post state.
1041	*
1042	* Remove the 'elementor' post state from the display states of the post.
1043	*
1044	* Used to remove the 'elementor' post state from the template library items.
1045	*
1046	* Fired by `display_post_states` filter.
1047	*
1048	* @since 1.8.0
1049	* @access public
1050	*
1051	* @param array $post_states An array of post display states.
1052	* @param \WP_Post $post The current post object.
1053	*
1054	* @return array Updated array of post display states.
1055	*/
1056	public function remove_elementor_post_state_from_library( $post_states, $post ) {
1057	if ( self::CPT === $post->post_type && isset( $post_states['elementor'] ) ) {
1058	unset( $post_states['elementor'] );
1059	}
1060	return $post_states;
1061	}
1062
1063	/**
1064	* Get template export link.
1065	*
1066	* Retrieve the link used to export a single template based on the template
1067	* ID.
1068	*
1069	* @since 2.0.0
1070	* @access private
1071	*
1072	* @param int $template_id The template ID.
1073	*
1074	* @return string Template export URL.
1075	*/
1076	private function get_export_link( $template_id ) {
1077	// TODO: BC since 2.3.0 - Use `$ajax->create_nonce()`
1078	/** @var \Elementor\Core\Common\Modules\Ajax\Module $ajax */
1079	// $ajax = Plugin::$instance->common->get_component( 'ajax' );
1080
1081	return add_query_arg(
1082	[
1083	'action' => 'elementor_library_direct_actions',
1084	'library_action' => 'export_template',
1085	'source' => $this->get_id(),
1086	'_nonce' => wp_create_nonce( 'elementor_ajax' ),
1087	'template_id' => $template_id,
1088	],
1089	admin_url( 'admin-ajax.php' )
1090	);
1091	}
1092
1093	/**
1094	* On template save.
1095	*
1096	* Run this method when template is being saved.
1097	*
1098	* Fired by `save_post` action.
1099	*
1100	* @since 1.0.1
1101	* @access public
1102	*
1103	* @param int $post_id Post ID.
1104	* @param \WP_Post $post The current post object.
1105	*/
1106	public function on_save_post( $post_id, \WP_Post $post ) {
1107	if ( self::CPT !== $post->post_type ) {
1108	return;
1109	}
1110
1111	if ( self::get_template_type( $post_id ) ) { // It's already with a type
1112	return;
1113	}
1114
1115	// Don't save type on import, the importer will do it.
1116	if ( did_action( 'import_start' ) ) {
1117	return;
1118	}
1119
1120	$this->save_item_type( $post_id, 'page' );
1121	}
1122
1123	/**
1124	* Save item type.
1125	*
1126	* When saving/updating templates, this method is used to update the post
1127	* meta data and the taxonomy.
1128	*
1129	* @since 1.0.1
1130	* @access private
1131	*
1132	* @param int $post_id Post ID.
1133	* @param string $type Item type.
1134	*/
1135	private function save_item_type( $post_id, $type ) {
1136	update_post_meta( $post_id, Document::TYPE_META_KEY, $type );
1137
1138	wp_set_object_terms( $post_id, $type, self::TAXONOMY_TYPE_SLUG );
1139	}
1140
1141	/**
1142	* Bulk export action.
1143	*
1144	* Adds an 'Export' action to the Bulk Actions drop-down in the template
1145	* library.
1146	*
1147	* Fired by `bulk_actions-edit-elementor_library` filter.
1148	*
1149	* @since 1.6.0
1150	* @access public
1151	*
1152	* @param array $actions An array of the available bulk actions.
1153	*
1154	* @return array An array of the available bulk actions.
1155	*/
1156	public function admin_add_bulk_export_action( $actions ) {
1157	$actions[ self::BULK_EXPORT_ACTION ] = esc_html__( 'Export', 'elementor' );
1158
1159	return $actions;
1160	}
1161
1162	/**
1163	* Add bulk export action.
1164	*
1165	* Handles the template library bulk export action.
1166	*
1167	* Fired by `handle_bulk_actions-edit-elementor_library` filter.
1168	*
1169	* @since 1.6.0
1170	* @access public
1171	*
1172	* @param string $redirect_to The redirect URL.
1173	* @param string $action The action being taken.
1174	* @param array $post_ids The items to take the action on.
1175	*/
1176	public function admin_export_multiple_templates( $redirect_to, $action, $post_ids ) {
1177	if ( self::BULK_EXPORT_ACTION === $action ) {
1178	$result = $this->export_multiple_templates( $post_ids );
1179
1180	// If you reach this line, the export failed
1181	// PHPCS - Not user input.
1182	wp_die( $result->get_error_message() ); // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
1183	}
1184	}
1185
1186	/**
1187	* Print admin tabs.
1188	*
1189	* Used to output the template library tabs with their labels.
1190	*
1191	* Fired by `views_edit-elementor_library` filter.
1192	*
1193	* @since 2.0.0
1194	* @access public
1195	*
1196	* @param array $views An array of available list table views.
1197	*
1198	* @return array An updated array of available list table views.
1199	*/
1200	public function admin_print_tabs( $views ) {
1201	//phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Nonce is not required to retrieve the value.
1202	$current_type = Utils::get_super_global_value( $_REQUEST, self::TAXONOMY_TYPE_SLUG ) ?? '';
1203	$active_class = $current_type ? '' : ' nav-tab-active';
1204	$current_tabs_group = $this->get_current_tab_group();
1205
1206	$url_args = [
1207	'post_type' => self::CPT,
1208	'tabs_group' => $current_tabs_group,
1209	];
1210
1211	$baseurl = add_query_arg( $url_args, admin_url( 'edit.php' ) );
1212
1213	$filter = [
1214	'admin_tab_group' => $current_tabs_group,
1215	];
1216	$operator = 'and';
1217
1218	if ( empty( $current_tabs_group ) ) {
1219	// Don't include 'not-supported' or other templates that don't set their `admin_tab_group`.
1220	$operator = 'NOT';
1221	}
1222
1223	$doc_types = Plugin::$instance->documents->get_document_types( $filter, $operator );
1224
1225	if ( 1 >= count( $doc_types ) ) {
1226	return $views;
1227	}
1228
1229	?>
1230	<div id="elementor-template-library-tabs-wrapper" class="nav-tab-wrapper">
1231	<a class="nav-tab<?php echo esc_attr( $active_class ); ?>" href="<?php echo esc_url( $baseurl ); ?>">
1232	<?php
1233	$all_title = $this->get_library_title();
1234	if ( ! $all_title ) {
1235	$all_title = esc_html__( 'All', 'elementor' );
1236	}
1237	Utils::print_unescaped_internal_string( $all_title ); ?>
1238	</a>
1239	<?php
1240	foreach ( $doc_types as $type => $class_name ) :
1241	$active_class = '';
1242
1243	if ( $current_type === $type ) {
1244	$active_class = ' nav-tab-active';
1245	}
1246
1247	$type_url = esc_url( add_query_arg( self::TAXONOMY_TYPE_SLUG, $type, $baseurl ) );
1248	$type_label = $this->get_template_label_by_type( $type );
1249	Utils::print_unescaped_internal_string( "<a class='nav-tab{$active_class}' href='{$type_url}'>{$type_label}</a>" );
1250	endforeach;
1251	?>
1252	</div>
1253	<?php
1254	return $views;
1255	}
1256
1257	/**
1258	* Maybe render blank state.
1259	*
1260	* When the template library has no saved templates, display a blank admin page offering
1261	* to create the very first template.
1262	*
1263	* Fired by `manage_posts_extra_tablenav` action.
1264	*
1265	* @since 2.0.0
1266	* @access public
1267	*
1268	* @param string $which The location of the extra table nav markup: 'top' or 'bottom'.
1269	* @param array $args
1270	*/
1271	public function maybe_render_blank_state( $which, array $args = [] ) {
1272	global $post_type;
1273
1274	$args = wp_parse_args( $args, [
1275	'cpt' => self::CPT,
1276	'post_type' => get_query_var( 'elementor_library_type' ),
1277	] );
1278
1279	if ( $args['cpt'] !== $post_type \|\| 'bottom' !== $which ) {
1280	return;
1281	}
1282
1283	global $wp_list_table;
1284
1285	$total_items = $wp_list_table->get_pagination_arg( 'total_items' );
1286
1287	//phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Nonce is not required to retrieve the value.
1288	if ( ! empty( $total_items ) \|\| ! empty( $_REQUEST['s'] ) ) {
1289	return;
1290	}
1291
1292	$current_type = $args['post_type'];
1293
1294	$document_types = Plugin::instance()->documents->get_document_types();
1295
1296	if ( empty( $document_types[ $current_type ] ) ) {
1297	return;
1298	}
1299
1300	// TODO: Better way to exclude widget type.
1301	if ( 'widget' === $current_type ) {
1302	return;
1303	}
1304
1305	// TODO: This code maybe unreachable see if above `if ( empty( $document_types[ $current_type ] ) )`.
1306	if ( empty( $current_type ) ) {
1307	$counts = (array) wp_count_posts( self::CPT );
1308	unset( $counts['auto-draft'] );
1309	$count = array_sum( $counts );
1310
1311	if ( 0 < $count ) {
1312	return;
1313	}
1314
1315	$current_type = 'template';
1316
1317	$args['additional_inline_style'] = '#elementor-template-library-tabs-wrapper {display: none;}';
1318	}
1319
1320	$this->render_blank_state( $current_type, $args );
1321	}
1322
1323	private function render_blank_state( $current_type, array $args = [] ) {
1324	$current_type_label = $this->get_template_label_by_type( $current_type );
1325	$inline_style = '#posts-filter .wp-list-table, #posts-filter .tablenav.top, .tablenav.bottom .actions, .wrap .subsubsub { display:none;}';
1326
1327	$args = wp_parse_args( $args, [
1328	'additional_inline_style' => '',
1329	'href' => '',
1330	'description' => esc_html__( 'Add templates and reuse them across your website. Easily export and import them to any other project, for an optimized workflow.', 'elementor' ),
1331	] );
1332	$inline_style .= $args['additional_inline_style'];
1333	?>
1334	<style type="text/css"><?php Utils::print_unescaped_internal_string( $inline_style ); ?></style>
1335	<div class="elementor-template_library-blank_state">
1336	<?php $this->print_blank_state_template( $current_type_label, $args['href'], $args['description'] ); ?>
1337	</div>
1338	<?php
1339	}
1340
1341	/**
1342	* Print Blank State Template
1343	*
1344	* When the an entity (CPT, Taxonomy...etc) has no saved items, print a blank admin page offering
1345	* to create the very first item.
1346	*
1347	* This method is public because it needs to be accessed from outside the Source_Local
1348	*
1349	* @since 3.1.0
1350	* @access public
1351	*
1352	* @param string $current_type_label The Entity title
1353	* @param string $href The URL for the 'Add New' button
1354	* @param string $description The sub title describing the Entity (Post Type, Taxonomy, etc.)
1355	*/
1356	public function print_blank_state_template( $current_type_label, $href, $description ) {
1357	?>
1358	<div class="elementor-blank_state">
1359	<i class="eicon-folder"></i>
1360	<h3>
1361	<?php
1362	/* translators: %s: Template type label. */
1363	printf( esc_html__( 'Create Your First %s', 'elementor' ), esc_html( $current_type_label ) );
1364	?>
1365	</h3>
1366	<p><?php echo wp_kses_post( $description ); ?></p>
1367	<a id="elementor-template-library-add-new" class="elementor-button e-primary" href="<?php echo esc_url( $href ); ?>">
1368	<?php
1369	/* translators: %s: Template type label. */
1370	printf( esc_html__( 'Add New %s', 'elementor' ), esc_html( $current_type_label ) );
1371	?>
1372	</a>
1373	</div>
1374	<?php
1375	}
1376
1377	/**
1378	* Add filter by category.
1379	*
1380	* In the templates library, add a filter by Elementor library category.
1381	*
1382	* @access public
1383	*
1384	* @param string $post_type The post type slug.
1385	*/
1386	public function add_filter_by_category( $post_type ) {
1387	if ( self::CPT !== $post_type ) {
1388	return;
1389	}
1390
1391	$all_items = get_taxonomy( self::TAXONOMY_CATEGORY_SLUG )->labels->all_items;
1392	$dropdown_options = array(
1393	'show_option_all' => $all_items,
1394	'show_option_none' => $all_items,
1395	'hide_empty' => 0,
1396	'hierarchical' => 1,
1397	'show_count' => 0,
1398	'orderby' => 'name',
1399	'value_field' => 'slug',
1400	'taxonomy' => self::TAXONOMY_CATEGORY_SLUG,
1401	'name' => self::TAXONOMY_CATEGORY_SLUG,
1402	//phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Nonce is not required to retrieve the value.
1403	'selected' => Utils::get_super_global_value( $_GET, self::TAXONOMY_CATEGORY_SLUG ) ?? '',
1404	);
1405
1406	printf(
1407	'<label class="screen-reader-text" for="%1$s">%2$s</label>',
1408	esc_attr( self::TAXONOMY_CATEGORY_SLUG ),
1409	esc_html_x( 'Filter by category', 'Template Library', 'elementor' )
1410	);
1411	wp_dropdown_categories( $dropdown_options );
1412	}
1413
1414	/**
1415	* Import single template.
1416	*
1417	* Import template from a file to the database.
1418	*
1419	* @since 1.6.0
1420	* @access private
1421	*
1422	* @param string $file_path File name.
1423	*
1424	* @return \WP_Error\|int\|array Local template array, or template ID, or
1425	* `WP_Error`.
1426	*/
1427	private function import_single_template( $file_path ) {
1428	$data = json_decode( Utils::file_get_contents( $file_path ), true );
1429
1430	if ( empty( $data ) ) {
1431	return new \WP_Error( 'file_error', 'Invalid File' );
1432	}
1433
1434	$content = $data['content'];
1435
1436	if ( ! is_array( $content ) ) {
1437	return new \WP_Error( 'file_error', 'Invalid Content In File' );
1438	}
1439
1440	$content = $this->process_export_import_content( $content, 'on_import' );
1441
1442	$page_settings = [];
1443
1444	if ( ! empty( $data['page_settings'] ) ) {
1445	$page = new Model( [
1446	'id' => 0,
1447	'settings' => $data['page_settings'],
1448	] );
1449
1450	$page_settings_data = $this->process_element_export_import_content( $page, 'on_import' );
1451
1452	if ( ! empty( $page_settings_data['settings'] ) ) {
1453	$page_settings = $page_settings_data['settings'];
1454	}
1455	}
1456
1457	$template_id = $this->save_item( [
1458	'content' => $content,
1459	'title' => $data['title'],
1460	'type' => $data['type'],
1461	'page_settings' => $page_settings,
1462	] );
1463
1464	if ( is_wp_error( $template_id ) ) {
1465	return $template_id;
1466	}
1467
1468	return $this->get_item( $template_id );
1469	}
1470
1471	/**
1472	* Prepare template to export.
1473	*
1474	* Retrieve the relevant template data and return them as an array.
1475	*
1476	* @since 1.6.0
1477	* @access private
1478	*
1479	* @param int $template_id The template ID.
1480	*
1481	* @return \WP_Error\|array Exported template data.
1482	*/
1483	private function prepare_template_export( $template_id ) {
1484	$document = Plugin::$instance->documents->get( $template_id );
1485
1486	$template_data = $document->get_export_data();
1487
1488	if ( empty( $template_data['content'] ) ) {
1489	return new \WP_Error( 'empty_template', 'The template is empty' );
1490	}
1491
1492	$export_data = [
1493	'content' => $template_data['content'],
1494	'page_settings' => $template_data['settings'],
1495	'version' => DB::DB_VERSION,
1496	'title' => $document->get_main_post()->post_title,
1497	'type' => self::get_template_type( $template_id ),
1498	];
1499
1500	return [
1501	'name' => 'elementor-' . $template_id . '-' . gmdate( 'Y-m-d' ) . '.json',
1502	'content' => wp_json_encode( $export_data ),
1503	];
1504	}
1505
1506	/**
1507	* Send file headers.
1508	*
1509	* Set the file header when export template data to a file.
1510	*
1511	* @since 1.6.0
1512	* @access private
1513	*
1514	* @param string $file_name File name.
1515	* @param int $file_size File size.
1516	*/
1517	private function send_file_headers( $file_name, $file_size ) {
1518	header( 'Content-Type: application/octet-stream' );
1519	header( 'Content-Disposition: attachment; filename=' . $file_name );
1520	header( 'Expires: 0' );
1521	header( 'Cache-Control: must-revalidate' );
1522	header( 'Pragma: public' );
1523	header( 'Content-Length: ' . $file_size );
1524	}
1525
1526	/**
1527	* Get template label by type.
1528	*
1529	* Retrieve the template label for any given template type.
1530	*
1531	* @since 2.0.0
1532	* @access private
1533	*
1534	* @param string $template_type Template type.
1535	*
1536	* @return string Template label.
1537	*/
1538	private function get_template_label_by_type( $template_type ) {
1539	$document_types = Plugin::instance()->documents->get_document_types();
1540
1541	if ( isset( $document_types[ $template_type ] ) ) {
1542	$template_label = call_user_func( [ $document_types[ $template_type ], 'get_title' ] );
1543	} else {
1544	$template_label = ucwords( str_replace( [ '_', '-' ], ' ', $template_type ) );
1545	}
1546
1547	/**
1548	* Template label by template type.
1549	*
1550	* Filters the template label by template type in the template library .
1551	*
1552	* @since 2.0.0
1553	*
1554	* @param string $template_label Template label.
1555	* @param string $template_type Template type.
1556	*/
1557	$template_label = apply_filters( 'elementor/template-library/get_template_label_by_type', $template_label, $template_type );
1558
1559	return $template_label;
1560	}
1561
1562	/**
1563	* Filter template types in admin query.
1564	*
1565	* Update the template types in the main admin query.
1566	*
1567	* Fired by `parse_query` action.
1568	*
1569	* @since 2.4.0
1570	* @access public
1571	*
1572	* @param \WP_Query $query The `WP_Query` instance.
1573	*/
1574	public function admin_query_filter_types( \WP_Query $query ) {
1575	if ( ! $this->is_current_screen() \|\| ! empty( $query->query_vars['meta_key'] ) ) {
1576	return;
1577	}
1578
1579	$current_tabs_group = $this->get_current_tab_group();
1580
1581	if ( isset( $query->query_vars[ self::TAXONOMY_CATEGORY_SLUG ] ) && '-1' === $query->query_vars[ self::TAXONOMY_CATEGORY_SLUG ] ) {
1582	unset( $query->query_vars[ self::TAXONOMY_CATEGORY_SLUG ] );
1583	}
1584
1585	if ( empty( $current_tabs_group ) ) {
1586	return;
1587	}
1588
1589	$doc_types = Plugin::$instance->documents->get_document_types( [
1590	'admin_tab_group' => $current_tabs_group,
1591	] );
1592
1593	$query->query_vars['meta_key'] = Document::TYPE_META_KEY;
1594	$query->query_vars['meta_value'] = array_keys( $doc_types );
1595	}
1596
1597	/**
1598	* Add template library actions.
1599	*
1600	* Register filters and actions for the template library.
1601	*
1602	* @since 2.0.0
1603	* @access private
1604	*/
1605	private function add_actions() {
1606	if ( is_admin() ) {
1607	add_action( 'elementor/admin/menu/register', function ( Admin_Menu_Manager $admin_menu ) {
1608	$this->register_admin_menu( $admin_menu );
1609	}, static::ADMIN_MENU_PRIORITY );
1610
1611	add_action( 'elementor/admin/menu/register', function ( Admin_Menu_Manager $admin_menu ) {
1612	$this->admin_menu_reorder( $admin_menu );
1613	}, 800 );
1614
1615	add_action( 'elementor/admin/menu/after_register', function () {
1616	$this->admin_menu_set_current();
1617	} );
1618
1619	add_filter( 'admin_title', [ $this, 'admin_title' ], 10, 2 );
1620	add_action( 'all_admin_notices', [ $this, 'replace_admin_heading' ] );
1621	add_filter( 'post_row_actions', [ $this, 'post_row_actions' ], 10, 2 );
1622	add_action( 'admin_footer', [ $this, 'admin_import_template_form' ] );
1623	add_action( 'save_post', [ $this, 'on_save_post' ], 10, 2 );
1624	add_filter( 'display_post_states', [ $this, 'remove_elementor_post_state_from_library' ], 11, 2 );
1625
1626	add_action( 'parse_query', [ $this, 'admin_query_filter_types' ] );
1627
1628	// Template filter by category.
1629	add_action( 'restrict_manage_posts', [ $this, 'add_filter_by_category' ] );
1630
1631	// Template type column.
1632	add_action( 'manage_' . self::CPT . '_posts_columns', [ $this, 'admin_columns_headers' ] );
1633	add_action( 'manage_' . self::CPT . '_posts_custom_column', [ $this, 'admin_columns_content' ], 10, 2 );
1634
1635	// Template library bulk actions.
1636	add_filter( 'bulk_actions-edit-elementor_library', [ $this, 'admin_add_bulk_export_action' ] );
1637	add_filter( 'handle_bulk_actions-edit-elementor_library', [ $this, 'admin_export_multiple_templates' ], 10, 3 );
1638
1639	// Print template library tabs.
1640	add_filter( 'views_edit-' . self::CPT, [ $this, 'admin_print_tabs' ] );
1641
1642	// Show blank state.
1643	add_action( 'manage_posts_extra_tablenav', [ $this, 'maybe_render_blank_state' ] );
1644	}
1645
1646	add_action( 'template_redirect', [ $this, 'block_template_frontend' ] );
1647
1648	// Remove elementor library templates from WP Sitemap
1649	add_filter(
1650	'wp_sitemaps_post_types',
1651	function( $post_types ) {
1652	return $this->remove_elementor_cpt_from_sitemap( $post_types );
1653	}
1654	);
1655	}
1656
1657	/**
1658	* @since 2.0.6
1659	* @access public
1660	*/
1661	public function admin_columns_content( $column_name, $post_id ) {
1662	if ( 'elementor_library_type' === $column_name ) {
1663	/** @var Document $document */
1664	$document = Plugin::$instance->documents->get( $post_id );
1665
1666	if ( $document && $document instanceof Library_Document ) {
1667	$document->print_admin_column_type();
1668	}
1669	}
1670	}
1671
1672	/**
1673	* @since 2.0.6
1674	* @access public
1675	*/
1676	public function admin_columns_headers( $posts_columns ) {
1677	// Replace original column that bind to the taxonomy - with another column.
1678	unset( $posts_columns['taxonomy-elementor_library_type'] );
1679
1680	$offset = 2;
1681
1682	$posts_columns = array_slice( $posts_columns, 0, $offset, true ) + [
1683	'elementor_library_type' => esc_html__( 'Type', 'elementor' ),
1684	] + array_slice( $posts_columns, $offset, null, true );
1685
1686	return $posts_columns;
1687	}
1688
1689	public function get_current_tab_group( $default = '' ) {
1690	//phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Nonce verification is not required here.
1691	$current_tabs_group = Utils::get_super_global_value( $_REQUEST, 'tabs_group' ) ?? '';
1692	//phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Nonce verification is not required here.
1693	$type_slug = Utils::get_super_global_value( $_REQUEST, self::TAXONOMY_TYPE_SLUG );
1694
1695	if ( $type_slug ) {
1696	$doc_type = Plugin::$instance->documents->get_document_type( $type_slug, '' );
1697	if ( $doc_type ) {
1698	$current_tabs_group = $doc_type::get_property( 'admin_tab_group' );
1699	}
1700	}
1701	return $current_tabs_group;
1702	}
1703
1704	private function get_library_title() {
1705	$title = '';
1706
1707	if ( $this->is_current_screen() ) {
1708	$current_tab_group = $this->get_current_tab_group();
1709
1710	if ( $current_tab_group ) {
1711	$titles = [
1712	'library' => esc_html__( 'Saved Templates', 'elementor' ),
1713	'theme' => esc_html__( 'Theme Builder', 'elementor' ),
1714	'popup' => esc_html__( 'Popups', 'elementor' ),
1715	];
1716
1717	if ( ! empty( $titles[ $current_tab_group ] ) ) {
1718	$title = $titles[ $current_tab_group ];
1719	}
1720	}
1721	}
1722
1723	return $title;
1724	}
1725
1726	private function is_current_screen() {
1727	global $pagenow, $typenow;
1728
1729	return 'edit.php' === $pagenow && self::CPT === $typenow;
1730	}
1731
1732	/**
1733	* @param array $post_types
1734	*
1735	* @return array
1736	*/
1737	private function remove_elementor_cpt_from_sitemap( array $post_types ) {
1738	unset( $post_types[ self::CPT ] );
1739
1740	return $post_types;
1741	}
1742
1743	/**
1744	* Template library local source constructor.
1745	*
1746	* Initializing the template library local source base by registering custom
1747	* template data and running custom actions.
1748	*
1749	* @since 1.0.0
1750	* @access public
1751	*/
1752	public function __construct() {
1753	parent::__construct();
1754
1755	$this->add_actions();
1756	}
1757	}
1758