create_admin_optimal_settings_page();
}
/**
* Global Options page callback
*/
public function create_admin_global_settings_page()
{
Metasync_Admin_Pages::get_instance($this)->create_admin_global_settings_page();
}
/**
* Common Meta Options page callback
*/
public function create_admin_common_meta_settings_page()
{
Metasync_Admin_Pages::get_instance($this)->create_admin_common_meta_settings_page();
}
/**
* Social meta page callback
*/
public function create_admin_social_meta_page()
{
Metasync_Admin_Pages::get_instance($this)->create_admin_social_meta_page();
}
/**
* Indexation Control page callback
*/
public function create_admin_seo_controls_page()
{
Metasync_Admin_Pages::get_instance($this)->create_admin_seo_controls_page();
}
/**
* Site Optimal Settings page callback
*/
public function optimization_settings_options()
{
Metasync_Admin_Pages::get_instance($this)->optimization_settings_options();
}
/**
* redirection page callback with tabs
*/
public function create_admin_redirections_page()
{
Metasync_Redirections_Admin::get_instance($this->db_redirection, $this)->create_admin_redirections_page();
}
/**
* Display transient error/success messages for redirections
*/
public function display_redirection_messages()
{
Metasync_Redirections_Admin::get_instance($this->db_redirection, $this)->display_redirection_messages();
}
/**
* AJAX handler for updating database structure
*/
public function ajax_update_db_structure()
{
Metasync_Admin_Ajax::instance()->ajax_update_db_structure();
}
/**
* AJAX handler to save wizard progress
*
* @since 1.0.0
*/
public function ajax_save_wizard_progress()
{
Metasync_Admin_Ajax::instance()->ajax_save_wizard_progress();
}
/**
* AJAX handler to complete wizard
*
* @since 1.0.0
*/
public function ajax_complete_wizard()
{
Metasync_Admin_Ajax::instance()->ajax_complete_wizard();
}
/**
* AJAX handler to validate robots.txt content
*/
public function ajax_validate_robots()
{
Metasync_Admin_Ajax::instance()->ajax_validate_robots();
}
/**
* AJAX handler to get default robots.txt content
*/
public function ajax_get_default_robots()
{
Metasync_Admin_Ajax::instance()->ajax_get_default_robots();
}
/**
* AJAX handler to preview robots.txt backup content
*/
public function ajax_preview_robots_backup()
{
Metasync_Admin_Ajax::instance()->ajax_preview_robots_backup();
}
/**
* AJAX handler to delete robots.txt backup
*/
public function ajax_delete_robots_backup()
{
Metasync_Admin_Ajax::instance()->ajax_delete_robots_backup();
}
/**
* AJAX handler to restore robots.txt backup
*/
public function ajax_restore_robots_backup()
{
Metasync_Admin_Ajax::instance()->ajax_restore_robots_backup();
}
public function ajax_create_redirect_from_404()
{
Metasync_Admin_Ajax::instance()->ajax_create_redirect_from_404();
}
/**
* AJAX handler for testing host blocking with GET request
*/
public function ajax_test_host_blocking_get()
{
Metasync_Admin_Ajax::instance()->ajax_test_host_blocking_get();
}
/**
* AJAX handler for testing host blocking with POST request
*/
public function ajax_test_host_blocking_post()
{
Metasync_Admin_Ajax::instance()->ajax_test_host_blocking_post();
}
/**
* Register REST API endpoint for ping
*/
public function register_ping_rest_endpoint()
{
register_rest_route('metasync/v1', '/ping', array(
'methods' => array('GET', 'POST'),
'callback' => array($this, 'handle_ping_rest_endpoint'),
'permission_callback' => '__return_true', // Allow public access
'args' => array(
'test' => array(
'description' => 'Optional test parameter',
'type' => 'string',
'sanitize_callback' => 'sanitize_text_field',
),
),
));
}
/**
* Handle REST API ping endpoint
*/
public function handle_ping_rest_endpoint($request)
{
// Get request method
$method = $request->get_method();
// Prepare response data
$response_data = array(
'response' => 'pong',
'method' => $method,
'timestamp' => current_time('mysql'),
'site_url' => home_url(),
'plugin_version' => METASYNC_VERSION
);
// Add request data for POST requests
if ($method === 'POST') {
$body = $request->get_body();
if (!empty($body)) {
$response_data['received_data'] = json_decode($body, true);
}
// Add any query parameters
$params = $request->get_params();
if (!empty($params)) {
$response_data['query_params'] = $params;
}
}
// Add test parameter if provided
$test_param = $request->get_param('test');
if (!empty($test_param)) {
$response_data['test_param'] = $test_param;
}
return new WP_REST_Response($response_data, 200);
}
/**
* Site error logs page callback
*/
public function create_admin_error_logs_page()
{
Metasync_Admin_Pages::get_instance($this)->create_admin_error_logs_page();
}
/**
* Compatibility page callback
*/
public function create_admin_compatibility_page()
{
Metasync_Compatibility_Checker::instance()->create_admin_compatibility_page($this);
}
/**
* Sync Log page callback
*/
public function create_admin_sync_log_page()
{
Metasync_Admin_Pages::get_instance($this)->create_admin_sync_log_page();
}
/**
* Build filter query string for pagination
*/
private function build_filter_query_string($filters)
{
$query_parts = [];
foreach ($filters as $key => $value) {
if (!empty($value)) {
$query_parts[] = $key . '=' . urlencode($value);
}
}
return !empty($query_parts) ? '&' . implode('&', $query_parts) : '';
}
/**
* Handle AJAX requests for sync log data
*/
private function handle_sync_log_ajax()
{
// This can be used for future AJAX functionality like real-time updates
wp_die();
}
/**
* Render compatibility sections
*/
private function render_compatibility_sections()
{
Metasync_Compatibility_Checker::instance()->render_compatibility_sections();
}
/**
* Render Page Builders section
*/
private function render_page_builders_section()
{
Metasync_Compatibility_Checker::instance()->render_page_builders_section();
}
/**
* Render SEO Plugins section
*/
private function render_seo_plugins_section()
{
Metasync_Compatibility_Checker::instance()->render_seo_plugins_section();
}
/**
* Render Cache Plugins section
*/
private function render_cache_plugins_section()
{
Metasync_Compatibility_Checker::instance()->render_cache_plugins_section();
}
/**
* Render Lock Section button for protected tabs
*
* @param string $tab The tab identifier (general, whitelabel, advanced)
*/
private function render_lock_button($tab)
{
Metasync_Compatibility_Checker::instance()->render_lock_button($tab);
}
/**
* Get Page Builders compatibility information
*/
private function get_page_builders_compatibility()
{
return Metasync_Compatibility_Checker::instance()->get_page_builders_compatibility();
}
/**
* Get SEO Plugins compatibility information
*/
private function get_seo_plugins_compatibility()
{
return Metasync_Compatibility_Checker::instance()->get_seo_plugins_compatibility();
}
/**
* Get Cache Plugins compatibility information
*/
private function get_cache_plugins_compatibility()
{
return Metasync_Compatibility_Checker::instance()->get_cache_plugins_compatibility();
}
/**
* Check if a plugin is installed and active
* @deprecated Use get_plugin_status() instead
*/
private function is_plugin_installed($plugin_file)
{
return Metasync_Compatibility_Checker::instance()->is_plugin_installed($plugin_file);
}
/**
* Get detailed plugin status (installed and/or active)
* Checks multiple plugin file paths (e.g., free and premium versions)
*
* @param array $plugin_files Array of plugin file paths to check (e.g., ['free/plugin.php', 'pro/plugin.php'])
* @param bool $is_core Whether this is a WordPress core feature (always installed/active)
* @param string $theme_name Optional theme name to check if it's a theme instead of plugin
* @return array ['is_installed' => bool, 'is_active' => bool, 'active_version' => string|null]
*/
private function get_plugin_status($plugin_files, $is_core = false, $theme_name = null)
{
return Metasync_Compatibility_Checker::instance()->get_plugin_status($plugin_files, $is_core, $theme_name);
}
/**
* Get plugin logo URL (optimized for performance)
*/
private function get_plugin_logo($plugin_key, $type)
{
return Metasync_Compatibility_Checker::instance()->get_plugin_logo($plugin_key, $type);
}
public function creat_error_Logs_List()
{
Metasync_Admin_Pages::get_instance($this)->creat_error_Logs_List();
}
/**
* Site error logs page callback
*/
public function create_admin_heartbeat_error_logs_page()
{
Metasync_Admin_Pages::get_instance($this)->create_admin_heartbeat_error_logs_page();
}
/**
* Handle session management early for whitelabel functionality
*/
private function handle_session_management_early()
{
Metasync_Connect_Manager::instance()->handle_session_management_early();
}
/**
* @deprecated 2.5.12 Use Metasync_Auth_Manager instead of sessions for authentication
*/
private function safe_session_start() {
// This method is deprecated and no longer used
// Authentication now uses Metasync_Auth_Manager with WordPress transients and user meta
_deprecated_function(__METHOD__, '2.5.12', 'Metasync_Auth_Manager');
return Metasync_Session_Helper::safe_start();
}
private function handle_whitelabel_session_logic()
{
Metasync_Connect_Manager::instance()->handle_whitelabel_session_logic();
}
private function handle_whitelabel_password_early()
{
Metasync_Connect_Manager::instance()->handle_whitelabel_password_early();
}
/**
* Get accordion sections configuration for General Settings
*
* @return array Accordion sections with field IDs, icons, and descriptions
*/
private function get_accordion_sections_config() {
return Metasync_Settings_Fields::instance()->get_accordion_sections_config();
}
/**
* Get accordion sections configuration for Advanced Settings Tab
*
* @return array Accordion sections configuration
*/
private function get_advanced_accordion_config() {
return Metasync_Settings_Fields::instance()->get_advanced_accordion_config();
}
/**
* Render accordion sections for Advanced Settings Tab
*/
public function render_advanced_accordion() {
Metasync_Settings_Fields::instance()->render_advanced_accordion();
}
/**
* Render reset settings section for Advanced tab accordion
*/
private function render_reset_settings_section() {
Metasync_Settings_Fields::instance()->render_reset_settings_section();
}
/**
* Render Google Index API section for Indexation Control page
*/
public function render_google_index_section() {
Metasync_Settings_Fields::instance()->render_google_index_section();
}
/**
* Render Bing Index (IndexNow) section
*
* @since 2.6.0
* @return void
*/
public function render_bing_index_section() {
Metasync_Settings_Fields::instance()->render_bing_index_section();
}
/**
* Render Plugin Access Roles section for Advanced tab accordion
*/
private function render_plugin_access_roles_section() {
Metasync_Settings_Fields::instance()->render_plugin_access_roles_section();
}
/**
* Check if the current user has access to the plugin based on role settings
* Wrapper method that delegates to the common Metasync::current_user_has_plugin_access()
* but also requires manage_options capability for admin area access
*
* @return bool True if user has access, false otherwise
*/
public function current_user_has_plugin_access() {
return Metasync::current_user_has_plugin_access();
}
/**
* Get default execution settings
*
* @return array Default execution settings
*/
private function get_default_execution_settings() {
return Metasync_Settings_Fields::instance()->get_default_execution_settings();
}
/**
* Get execution setting value
*
* @param string $key Setting key
* @param mixed $default Default value if setting doesn't exist
* @return mixed Setting value or default
*/
public function get_execution_setting($key, $default = null) {
return Metasync_Settings_Fields::instance()->get_execution_setting($key, $default);
}
/**
* Get all execution settings
*
* @return array All execution settings with defaults merged
*/
public function get_all_execution_settings() {
return Metasync_Settings_Fields::instance()->get_all_execution_settings();
}
/**
* Check if server allows changing memory limit
* Tests if ini_set('memory_limit') is allowed
*
* @return bool True if memory limit can be changed, false otherwise
*/
private function can_change_memory_limit() {
return Metasync_Settings_Fields::instance()->can_change_memory_limit();
}
/**
* Get PHP server limits for display
*
* @return array Server limits (execution_time, memory_limit, can_change_memory)
*/
private function get_server_limits() {
return Metasync_Settings_Fields::instance()->get_server_limits();
}
/**
* Apply memory limit from execution settings
* Only applies if server allows changing memory limit
*
* @return bool True if memory limit was applied, false otherwise
*/
public function apply_memory_limit() {
return Metasync_Settings_Fields::instance()->apply_memory_limit();
}
/**
* Parse memory limit string to MB
*
* @param string $memory_limit Memory limit string (e.g., "256M", "1G")
* @return int Memory limit in MB
*/
private function parse_memory_limit_to_mb($memory_limit) {
return Metasync_Settings_Fields::instance()->parse_memory_limit_to_mb($memory_limit);
}
/**
* Render Execution Settings section for Advanced tab accordion
*/
private function render_execution_settings_section() {
Metasync_Settings_Fields::instance()->render_execution_settings_section();
}
/**
* Get tooltip content for settings fields
*
* @return array Field ID => Tooltip text mapping
*/
private function get_field_tooltips() {
return Metasync_Settings_Fields::instance()->get_field_tooltips();
}
/**
* Get the section key for a given field ID
*
* @param string $field_id The settings field ID
* @return string|null Section key or null if not found
*/
private function get_field_section($field_id) {
return Metasync_Settings_Fields::instance()->get_field_section($field_id);
}
/**
* Render accordion sections for General Settings
*
* @param string $page The settings page slug
*/
public function render_accordion_sections($page) {
Metasync_Settings_Fields::instance()->render_accordion_sections($page);
}
/**
* Register and add settings
*/
public function settings_page_init()
{
Metasync_Settings_Registration::instance()->settings_page_init();
}
/**
* Sanitize each setting field as needed
*
* @param array $input Contains all settings fields as array keys
*/
public function sanitize($input)
{
return Metasync_Settings_Registration::instance()->sanitize($input);
}
public function metasync_settings_genkey_callback()
{
Metasync_Settings_Fields::instance()->metasync_settings_genkey_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function linkgraph_token_callback()
{
Metasync_Settings_Fields::instance()->linkgraph_token_callback();
}
private function time_elapsed_string($datetime, $full = false)
{
return Metasync_Settings_Fields::instance()->time_elapsed_string($datetime, $full);
}
/**
* Get the settings option array and print one of its values
*/
public function searchatlas_api_key_callback()
{
Metasync_Settings_Fields::instance()->searchatlas_api_key_callback();
}
/**
* Site Verification Tools
*
* Bing Site Verification
* Baidu Site Verification
* Alexa Site Verification
* Yandex Site Verification
* Google Site Verification
* Pinterest Site Verification
* Norton Safe Web Site Verification
*/
/**
* Get the settings option array and print one of its values
*/
public function bing_site_verification_callback()
{
Metasync_Settings_Fields::instance()->bing_site_verification_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function yandex_site_verification_callback()
{
Metasync_Settings_Fields::instance()->yandex_site_verification_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function google_site_verification_callback()
{
Metasync_Settings_Fields::instance()->google_site_verification_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function pinterest_site_verification_callback()
{
Metasync_Settings_Fields::instance()->pinterest_site_verification_callback();
}
/**
* Local SEO for business and person
*
*/
/**
* Get the settings option array and print one of its values
*/
public function local_seo_person_organization_callback()
{
Metasync_Settings_Fields::instance()->local_seo_person_organization_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_name_callback()
{
Metasync_Settings_Fields::instance()->local_seo_name_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_logo_callback()
{
Metasync_Settings_Fields::instance()->local_seo_logo_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_url_callback()
{
Metasync_Settings_Fields::instance()->local_seo_url_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_email_callback()
{
Metasync_Settings_Fields::instance()->local_seo_email_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_phone_callback()
{
Metasync_Settings_Fields::instance()->local_seo_phone_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_address_callback()
{
Metasync_Settings_Fields::instance()->local_seo_address_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_business_type_callback()
{
Metasync_Settings_Fields::instance()->local_seo_business_type_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_opening_hours_callback()
{
Metasync_Settings_Fields::instance()->local_seo_opening_hours_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_phone_numbers_callback()
{
Metasync_Settings_Fields::instance()->local_seo_phone_numbers_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_price_range_callback()
{
Metasync_Settings_Fields::instance()->local_seo_price_range_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_about_page_callback()
{
Metasync_Settings_Fields::instance()->local_seo_about_page_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_contact_page_callback()
{
Metasync_Settings_Fields::instance()->local_seo_contact_page_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_map_key_callback()
{
Metasync_Settings_Fields::instance()->local_seo_map_key_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function local_seo_geo_coordinates_callback()
{
Metasync_Settings_Fields::instance()->local_seo_geo_coordinates_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function header_snippets_callback()
{
Metasync_Settings_Fields::instance()->header_snippets_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function footer_snippets_callback()
{
Metasync_Settings_Fields::instance()->footer_snippets_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function no_index_posts_callback()
{
Metasync_Settings_Fields::instance()->no_index_posts_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function no_follow_links_callback()
{
Metasync_Settings_Fields::instance()->no_follow_links_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function open_external_links_callback()
{
Metasync_Settings_Fields::instance()->open_external_links_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function add_alt_image_tags_callback()
{
Metasync_Settings_Fields::instance()->add_alt_image_tags_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function add_title_image_tags_callback()
{
Metasync_Settings_Fields::instance()->add_title_image_tags_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function site_type_callback()
{
Metasync_Settings_Fields::instance()->site_type_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function site_business_type_callback()
{
Metasync_Settings_Fields::instance()->site_business_type_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function site_company_name_callback()
{
Metasync_Settings_Fields::instance()->site_company_name_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function site_google_logo_callback()
{
Metasync_Settings_Fields::instance()->site_google_logo_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function site_social_share_image_callback()
{
Metasync_Settings_Fields::instance()->site_social_share_image_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function common_robot_meta_tags_callback()
{
Metasync_Settings_Fields::instance()->common_robot_meta_tags_callback();
}
/**
* Backward compatibility alias for common_robot_mata_tags_callback
* @deprecated Use common_robot_meta_tags_callback() instead
*/
public function common_robot_mata_tags_callback()
{
Metasync_Settings_Fields::instance()->common_robot_mata_tags_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function advance_robot_meta_tags_callback()
{
Metasync_Settings_Fields::instance()->advance_robot_meta_tags_callback();
}
/**
* Backward compatibility alias for advance_robot_mata_tags_callback
* @deprecated Use advance_robot_meta_tags_callback() instead
*/
public function advance_robot_mata_tags_callback()
{
Metasync_Settings_Fields::instance()->advance_robot_mata_tags_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function global_twitter_card_type_callback()
{
Metasync_Settings_Fields::instance()->global_twitter_card_type_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function global_open_graph_meta_callback()
{
Metasync_Settings_Fields::instance()->global_open_graph_meta_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function global_facebook_meta_callback()
{
Metasync_Settings_Fields::instance()->global_facebook_meta_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function global_twitter_meta_callback()
{
Metasync_Settings_Fields::instance()->global_twitter_meta_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function facebook_page_url_callback()
{
Metasync_Settings_Fields::instance()->facebook_page_url_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function facebook_authorship_callback()
{
Metasync_Settings_Fields::instance()->facebook_authorship_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function facebook_admin_callback()
{
Metasync_Settings_Fields::instance()->facebook_admin_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function facebook_app_callback()
{
Metasync_Settings_Fields::instance()->facebook_app_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function facebook_secret_callback()
{
Metasync_Settings_Fields::instance()->facebook_secret_callback();
}
/**
* Get the settings option array and print one of its values
*/
public function twitter_username_callback()
{
Metasync_Settings_Fields::instance()->twitter_username_callback();
}
/**
* Get business types as choices in local business.
*
* @return array
*/
public static function get_business_types()
{
return Metasync_Settings_Fields::get_business_types();
}
/**
* Display a dashboard warning when using the plain permalink structure.
* @param $data An array of data passed.
*/
public function permalink_structure_dashboard_warning() {
$current_permalink_structure = get_option('permalink_structure');
# Get the plugin name using centralized method
$plugin_name = Metasync::get_effective_plugin_name();
$current_rewrite_rules = get_option('rewrite_rules');
# Check if the current permalink structure is set to "Plain"
if (($current_permalink_structure == '/%post_id%/' || $current_permalink_structure == '') && $current_rewrite_rules == '') {
# Show admin notice with plugin name included in the message
printf(
'
Warning from %s
To ensure compatibility, please update your permalink structure to any option other than "Plain".
For any inquiries, contact support.
',
esc_html($plugin_name)
);
}
flush_rewrite_rules();
}
/**
* Display update warning banner if plugin update is available
* Checks WordPress update API to see if a newer version is available
*
* @since 1.0.0
*/
public function display_update_warning_banner() {
// Get the installed version from database
$installed_version = get_option('metasync_version', '0.0.0');
// Get plugin basename for WordPress update API check
// This is the plugin file path relative to plugins directory (e.g., 'metasync/metasync.php')
$plugin_file = plugin_basename(plugin_dir_path(dirname(__FILE__)) . 'metasync.php');
// Get WordPress update plugins transient (contains available updates)
$update_plugins = get_site_transient('update_plugins');
// Check if update information exists and if our plugin has an update available
if ($update_plugins && isset($update_plugins->response) && isset($update_plugins->response[$plugin_file])) {
$update_info = $update_plugins->response[$plugin_file];
$latest_version = isset($update_info->new_version) ? $update_info->new_version : '';
// Compare installed version with latest available version
if ($latest_version && version_compare($installed_version, $latest_version, '<')) {
// Get the plugin name using centralized method
$plugin_name = Metasync::get_effective_plugin_name();
// Show admin notice with plugin name included in the message
printf(
'
Warning from %s
A new version of %s is available. Please update to the latest version to ensure compatibility and access new features.
For any inquiries, contact support.
',
esc_html($plugin_name),
esc_html($plugin_name)
);
}
}
}
/*
Method to handle Ajax request from "Indexation Control" page
*/
public function meta_sync_save_seo_controls() {
Metasync_Settings_Registration::instance()->meta_sync_save_seo_controls();
}
/**
* Schedule transient cleanup cron job
* Runs daily to clean up expired transients and reduce database load
*/
public function schedule_transient_cleanup_cron()
{
// Clear any existing scheduled event first
$this->unschedule_transient_cleanup_cron();
// Schedule new cron job daily
if (!wp_next_scheduled('metasync_cleanup_transients')) {
$scheduled = wp_schedule_event(time(), 'metasync_daily_cleanup', 'metasync_cleanup_transients');
if (!$scheduled) {
error_log('MetaSync: Failed to schedule transient cleanup cron job');
}
}
}
/**
* Unschedule transient cleanup cron job
*/
public function unschedule_transient_cleanup_cron()
{
$timestamp = wp_next_scheduled('metasync_cleanup_transients');
if ($timestamp) {
wp_unschedule_event($timestamp, 'metasync_cleanup_transients');
error_log('MetaSync: Transient cleanup cron job unscheduled');
}
}
/**
* Maybe schedule transient cleanup cron job
* Called on init hook - always schedules for database maintenance
*/
public function maybe_schedule_transient_cleanup_cron()
{
if (!wp_next_scheduled('metasync_cleanup_transients')) {
$this->schedule_transient_cleanup_cron();
}
}
/**
* Schedule hidden post manager cron job (runs every 7 days)
* Called on init hook - always schedules for template checking
*/
public function maybe_schedule_hidden_post_check()
{
if (!wp_next_scheduled('metasync_hidden_post_check')) {
$scheduled = wp_schedule_event(time(), 'metasync_weekly', 'metasync_hidden_post_check');
if ($scheduled) {
error_log('MetaSync: Hidden post manager cron job scheduled successfully (runs every 7 days)');
} else {
error_log('MetaSync: Failed to schedule hidden post manager cron job');
}
}
}
/**
* Schedule OTTO 404 exclusion recheck cron job (runs daily)
* Rechecks URLs auto-excluded due to 404 after 7 days; removes from exclusion if now available
*/
public function maybe_schedule_otto_recheck_404_cron()
{
if (!wp_next_scheduled('metasync_otto_recheck_404_exclusions')) {
$scheduled = wp_schedule_event(time(), 'metasync_daily_cleanup', 'metasync_otto_recheck_404_exclusions');
if ($scheduled) {
error_log('MetaSync: OTTO 404 recheck cron job scheduled successfully (runs daily)');
} else {
error_log('MetaSync: Failed to schedule OTTO 404 recheck cron job');
}
}
}
/**
* Execute transient cleanup cron job
* Cleans up expired transients and plugin-specific transients to reduce database load
*/
public function execute_transient_cleanup()
{
Metasync_Admin_Ajax::instance()->execute_transient_cleanup();
}
/**
* Control plugin auto-updates based on user setting
*
* @param bool $update Whether to update
* @param object $item Update offer
* @return bool Whether to allow auto-update
*/
public function control_plugin_auto_updates($update, $item)
{
# Check if the item object has the slug property
if (!isset($item->slug)) {
return $update;
}
// Check if this is our plugin
if ($item->slug === 'metasync') {
$general_settings = Metasync::get_option('general') ?? [];
$enable_auto_updates = $general_settings['enable_auto_updates'] ?? false;
// Return the user's preference (true = allow auto-updates, false = prevent)
return $enable_auto_updates === 'true' || $enable_auto_updates === true;
}
// For other plugins, don't interfere with their auto-update settings
return $update;
}
/**
* AJAX handler to add excluded URL for OTTO
*/
public function ajax_otto_add_excluded_url()
{
Metasync_Otto_Cache_Manager::instance()->ajax_otto_add_excluded_url();
}
/**
* AJAX handler to delete excluded URL for OTTO
*/
public function ajax_otto_delete_excluded_url()
{
Metasync_Otto_Cache_Manager::instance()->ajax_otto_delete_excluded_url();
}
/**
* AJAX handler to recheck if an excluded URL is now available
* Used for "Recheck" action on Excluded URLs list
*/
public function ajax_otto_recheck_excluded_url()
{
Metasync_Otto_Cache_Manager::instance()->ajax_otto_recheck_excluded_url();
}
/**
* AJAX handler to get excluded URLs with pagination
*/
public function ajax_otto_get_excluded_urls()
{
Metasync_Otto_Cache_Manager::instance()->ajax_otto_get_excluded_urls();
}
/**
* AJAX handler for submitting issue reports to Sentry
*
* @since 2.5.10
* @return void Sends JSON response and exits
*/
public function ajax_submit_issue_report()
{
Metasync_Admin_Ajax::instance()->ajax_submit_issue_report();
}
/**
* Format duration seconds into human-readable label
*
* @since 2.5.11
* @param int $seconds Duration in seconds
* @return string Human-readable duration
*/
private function format_duration_label($seconds)
{
$labels = array(
3600 => '1 hour',
14400 => '4 hours',
28800 => '8 hours',
86400 => '24 hours',
172800 => '48 hours',
604800 => '7 days',
1209600 => '14 days',
2592000 => '30 days'
);
if (isset($labels[$seconds])) {
return $labels[$seconds];
}
# Calculate hours if not a standard duration
$hours = round($seconds / 3600);
return $hours . ' hours';
}
/**
* AJAX handler for password recovery
* Sends the whitelabel settings password to the configured recovery email
*/
public function ajax_recover_password()
{
Metasync_Admin_Ajax::instance()->ajax_recover_password();
}
/**
* AJAX handler for saving theme preference
* Saves the user's theme choice (light/dark) to WordPress options
*/
public function ajax_save_theme()
{
Metasync_Admin_Ajax::instance()->ajax_save_theme();
}
/**
* AJAX handler for tracking 1-click activation in Mixpanel
*/
public function ajax_track_one_click_activation()
{
Metasync_Admin_Ajax::instance()->ajax_track_one_click_activation();
}
/**
* Handler for exporting whitelabel settings to a zip file
* Uses admin-post action for file downloads
*/
public function handle_export_whitelabel_settings()
{
Metasync_Admin_Ajax::instance()->handle_export_whitelabel_settings();
}
/**
* Add custom column to posts/pages list for HTML-converted pages
*
* @param array $columns Existing columns
* @return array Modified columns
*/
public function add_html_converted_column($columns)
{
// Add column after the title column
$new_columns = array();
foreach ($columns as $key => $value) {
$new_columns[$key] = $value;
if ($key === 'title') {
$new_columns['metasync_html_source'] = __('Source', 'metasync');
}
}
return $new_columns;
}
/**
* Render content for the HTML-converted column
*
* @param string $column_name Name of the column
* @param int $post_id Post ID
*/
public function render_html_converted_column($column_name, $post_id)
{
if ($column_name !== 'metasync_html_source') {
return;
}
// Check if this is an HTML-converted page
$has_raw_html = get_post_meta($post_id, '_metasync_raw_html_enabled', true);
$has_custom_css = get_post_meta($post_id, '_metasync_custom_css', true);
// If page has raw HTML or custom CSS from conversion, show badge
if ($has_raw_html || !empty($has_custom_css)) {
$label = $this->get_html_source_label();
$tooltip = sprintf(
__('This page was created using %s HTML-to-Builder converter', 'metasync'),
$label
);
echo sprintf(
'⚡%s',
esc_attr($tooltip),
esc_html($label)
);
}
}
/**
* Get the label for HTML-converted pages (respects whitelabel settings)
*
* @return string Label to display
*/
private function get_html_source_label()
{
$whitelabel_company = Metasync::get_whitelabel_company_name();
if (!empty($whitelabel_company)) {
return $whitelabel_company . ' AI';
}
return 'SearchAtlas AI';
}
/**
* Add source notice banner in the page editor
*
* @param WP_Post $post Current post object
*/
public function add_editor_source_notice($post)
{
if (!$post || !in_array($post->post_type, array('post', 'page'))) {
return;
}
$has_raw_html = get_post_meta($post->ID, '_metasync_raw_html_enabled', true);
$has_custom_css = get_post_meta($post->ID, '_metasync_custom_css', true);
if ($has_raw_html || !empty($has_custom_css)) {
$label = $this->get_html_source_label();
$message = sprintf(
__('This page was created using %s HTML-to-Builder converter. The design is preserved with custom CSS and inline styles.', 'metasync'),
'' . esc_html($label) . ''
);
echo sprintf(
'
⚡%s
%s
',
esc_html($label),
$message
);
}
}
/**
* Add source display in quick edit panel
*
* @param string $column_name Column name
* @param string $post_type Post type
*/
public function add_quick_edit_source_display($column_name, $post_type)
{
if ($column_name !== 'metasync_html_source') {
return;
}
if (!in_array($post_type, array('post', 'page'))) {
return;
}
?>
get_html_source_label();
$widget_title = sprintf(__('%s Pages', 'metasync'), $label);
wp_add_dashboard_widget(
'metasync_html_pages_widget',
$widget_title,
array($this, 'render_html_pages_dashboard_widget')
);
}
/**
* Render the dashboard widget content
*/
public function render_html_pages_dashboard_widget()
{
Metasync_Admin_Ajax::instance()->render_html_pages_dashboard_widget();
}
/**
* Bot Statistics page callback
* Displays bot detection statistics and logs
*/
public function create_admin_bot_statistics_page()
{
require_once plugin_dir_path(dirname(__FILE__)) . 'views/metasync-otto-bot-statistics.php';
}
/**
* AJAX handler for resetting bot statistics
*/
public function ajax_reset_bot_stats()
{
check_ajax_referer('metasync_reset_bot_stats', 'nonce');
if (!Metasync::current_user_has_plugin_access()) {
wp_send_json_error(['message' => 'Insufficient permissions.']);
}
require_once plugin_dir_path(dirname(__FILE__)) . 'otto/class-metasync-otto-bot-statistics-database.php';
$db = Metasync_Otto_Bot_Statistics_Database::get_instance();
$result = $db->reset_statistics();
if ($result) {
wp_send_json_success(['message' => 'Statistics reset successfully.']);
} else {
wp_send_json_error(['message' => 'Failed to reset statistics.']);
}
}
/**
* AJAX handler for sending URLs to Google Instant Indexing API
*
* @since 2.6.0
* @return void Sends JSON response and exits
*/
public function ajax_send_giapi()
{
$post_data = metasync_sanitize_input_array($_POST);
if (!isset($post_data['metasync_giapi_url'])) {
return;
}
// Parse URLs from textarea input (one per line)
$urls = array_values(array_filter(array_map('trim', explode("\n", sanitize_textarea_field(wp_unslash($post_data['metasync_giapi_url']))))));
if (empty($urls)) {
return;
}
if (!isset($post_data['metasync_giapi_action'])) {
return;
}
$action = sanitize_title($post_data['metasync_giapi_action']);
// Map form action values to google_index_direct action values
if ($action === 'remove') {
$action = 'delete';
}
header('Content-type: application/json');
$result_data = [];
foreach ($urls as $i => $url) {
$url = esc_url_raw($url);
if (empty($url)) {
continue;
}
if ($action === 'status') {
$result = google_index_direct()->get_url_status($url);
} else {
$result = google_index_direct()->index_url($url, $action);
}
$key = 'url-' . $i;
if (!empty($result['success'])) {
$result_data[$key] = $result['data'];
} else {
$result_data[$key] = (object) [
'error' => (object) [
'code' => isset($result['error']['code']) ? $result['error']['code'] : 400,
'message' => isset($result['error']['message']) ? $result['error']['message'] : 'Unknown error',
]
];
}
}
// For single URL, unwrap from the batch format (matches old behavior)
if (count($result_data) === 1) {
$result_data = reset($result_data);
}
wp_send_json($result_data);
wp_die();
}
/**
* AJAX handler for sending URLs to Bing via IndexNow API
*
* @since 2.6.0
* @return void Sends JSON response and exits
*/
public function ajax_send_bing_indexnow()
{
require_once plugin_dir_path(dirname(__FILE__)) . 'bing-index/class-metasync-bing-instant-index.php';
$bing_instant_index = new Metasync_Bing_Instant_Index();
$bing_instant_index->send();
}
/**
* Save instant indexing settings (Google and Bing)
*
* @since 2.6.0
* @return void
*/
public function save_instant_indexing_settings()
{
// Check if this is a settings submission
if (!isset($_POST['submit'])) {
return;
}
// Save Google Instant Indexing settings
if (isset($_POST['metasync_google_json_key'])) {
$post_data = metasync_sanitize_input_array($_POST);
$settings = get_option('metasync_options_instant_indexing', ['json_key' => '', 'post_types' => []]);
// Get JSON key from textarea or file upload
$json = sanitize_textarea_field(wp_unslash($post_data['metasync_google_json_key']));
if (isset($_FILES['metasync_google_json_file']) && !empty($_FILES['metasync_google_json_file']['tmp_name']) && file_exists($_FILES['metasync_google_json_file']['tmp_name'])) {
$json = wp_unslash(file_get_contents($_FILES['metasync_google_json_file']['tmp_name']));
}
$post_types = isset($post_data['metasync_post_types']) && is_array($post_data['metasync_post_types']) && !empty($json) ? array_map('sanitize_title', $post_data['metasync_post_types']) : [];
$new_settings = [
'json_key' => $json,
'post_types' => array_values($post_types),
];
$settings = array_merge($settings, $new_settings);
if (!empty($settings)) {
update_option('metasync_options_instant_indexing', $settings);
}
// Also save parsed credentials to google_index_direct for native API usage
if (!empty($json) && function_exists('google_index_direct')) {
$decoded = json_decode($json, true);
if (json_last_error() === JSON_ERROR_NONE && is_array($decoded)) {
google_index_direct()->save_service_account_config($decoded);
}
}
}
// Note: Bing Instant Indexing settings are saved via AJAX in save_bing_inline_settings_ajax()
}
/**
* Save Bing instant indexing settings from inline form (Indexation Control page)
*
* @since 2.6.0
* @return bool True on success, false on failure
*/
private function save_bing_inline_settings_ajax() {
return Metasync_Settings_Registration::instance()->save_bing_inline_settings_ajax();
}
/**
* Add instant indexing action links to post/page rows
*
* @since 2.6.0
* @param array $actions Current actions
* @param WP_Post $post Current post object
* @return array Modified actions
*/
public function add_instant_indexing_post_actions($actions, $post)
{
// Add Google Instant Indexing links
$options = get_option('metasync_options_instant_indexing', ['json_key' => '', 'post_types' => []]);
$post_types = isset($options['post_types']) && is_array($options['post_types']) ? $options['post_types'] : [];
if (in_array($post->post_type, $post_types) && $post->post_status == 'publish') {
$link = get_permalink($post);
// Get menu slug (support white label)
$general_options = Metasync::get_option('general') ?? [];
$menu_slug = !empty($general_options['white_label_plugin_menu_slug']) ? $general_options['white_label_plugin_menu_slug'] : 'searchatlas';
$page_slug = $menu_slug . '-google-console';
$actions['index-update'] = 'Update Google Index';
$actions['index-status'] = 'Status Google Index';
}
// Add Bing Instant Indexing links
require_once plugin_dir_path(dirname(__FILE__)) . 'bing-index/class-metasync-bing-instant-index.php';
$bing_instant_index = new Metasync_Bing_Instant_Index();
$actions = $bing_instant_index->bing_instant_index_post_link($actions, $post);
return $actions;
}
/**
* Auto-submit post to instant indexing services when published
*
* @since 2.6.0
* @param int $post_id Post ID
* @param WP_Post $post Post object
* @param bool $update Whether this is an update
* @return void
*/
public function auto_submit_to_instant_indexing($post_id, $post, $update)
{
// Google Instant Indexing auto-submit is not yet implemented via google_index_direct().
// The previous implementation was also a no-op for Google.
// TODO: Implement async auto-submit via WP-Cron or Action Scheduler in a future phase.
// Auto-submit to Bing Instant Indexing
require_once plugin_dir_path(dirname(__FILE__)) . 'bing-index/class-metasync-bing-instant-index.php';
$bing_instant_index = new Metasync_Bing_Instant_Index();
$bing_instant_index->auto_submit_on_publish($post_id, $post, $update);
}
}