'. __('Hello,', 'siteseo-pro').'
';
$message .= ''. __('SiteSEO has detected important SEO issues on your website.', 'siteseo-pro').'
';
$message .= ''. __('Please review and resolve these issues as soon as possible.', 'siteseo-pro').'
';
$message .= '— '. __('SiteSEO', 'siteseo-pro').'
';
$headers = ['Content-Type: text/html; charset=UTF-8'];
// Email
if(!empty($recipients)){
wp_mail($recipients, $subject, $message, $headers);
}
// Slack
if(!empty($settings['webhook_url'])){
self::slack_notification($alerts, $settings['webhook_url']);
}
}
static function slack_notification($alerts, $webhook_url){
$attachments = [];
foreach($alerts as $alert){
$attachments[] = [
'color' => '#f44336',
'text' => $alert
];
}
$body = [
/* translators: %s: status code */
'text' => sprintf(__('⚠️ SEO Alert: Issues Found on [%s]', 'siteseo-pro'), get_bloginfo('name')),
'attachments' => $attachments
];
wp_remote_post($webhook_url, [
'body' => json_encode($body),
'headers' => ['Content-Type' => 'application/json']
]);
}
}PK ! ͔Һ67 67 main/gscsetup.phpnu [ 'PUT',
'headers' => [
'Authorization' => 'Bearer ' . $tokens['access_token'],
'Content-Type' => 'application/json',
],
'body' => '{}',
'timeout' => 30,
];
$response = wp_remote_request($api_url, $args);
if(is_wp_error($response)){
return $response;
}
$code = wp_remote_retrieve_response_code($response);
if($code < 200 || $code >= 300){
return new \WP_Error('api_error', wp_remote_retrieve_body($response));
}
return true;
}
// Get the token needed to verify the ownership of the website on Google search console.
// We are doing verification through meta tag method.
static function get_verification_token($site_url){
$tokens = \SiteSEOPro\GoogleConsole::get_tokens();
if(empty($tokens) || empty($tokens['access_token'])){
return new \WP_Error('no_token', __('Google access token not found.', 'siteseo-pro'));
}
$api_url = 'https://www.googleapis.com/siteVerification/v1/token';
$body = [
'site' => [
'type' => 'SITE',
'identifier' => $site_url,
],
'verificationMethod' => 'META',
];
$args = [
'method' => 'POST',
'headers' => [
'Authorization' => 'Bearer ' . $tokens['access_token'],
'Content-Type' => 'application/json',
],
'body' => json_encode($body),
'timeout' => 30,
];
$response = wp_remote_post($api_url, $args);
if(is_wp_error($response)){
return $response;
}
$code = wp_remote_retrieve_response_code($response);
$body = json_decode(wp_remote_retrieve_body($response), true);
if($code != 200 || empty($body['token'])){
return new \WP_Error('token_error', __('Failed to get verification token.', 'siteseo-pro'));
}
$allowed = [
'meta' => [
'name' => true,
'content' => true,
],
];
return wp_kses(wp_unslash($body['token']), $allowed);
}
// Setting the verification code we got through get_verification_token in Advanced settings google meta for verification.
static function save_verification_meta($token){
$token_meta = get_option('siteseo_advanced_option_name', []);
$token = \SiteSEO\Settings\Util::extract_content($token);
$token_meta['advanced_google'] = $token;
$saved = update_option('siteseo_advanced_option_name', $token_meta);
if($saved === false && get_option('siteseo_advanced_option_name') !== $token_meta){
return new \WP_Error('save_error', __( 'Failed to save verification meta.', 'siteseo-pro'));
}
return true;
}
// Requesting Google to verify the owenership using the html metatag method.
static function verify_property($site_url){
$tokens = \SiteSEOPro\GoogleConsole::get_tokens();
if(empty($tokens) || empty($tokens['access_token'])){
return new \WP_Error('no_token', __('Google access token not found.', 'siteseo-pro'));
}
$api_url = 'https://www.googleapis.com/siteVerification/v1/webResource?verificationMethod=META';
$body = [
'site' => [
'type' => 'SITE',
'identifier' => $site_url,
],
];
$args = [
'method' => 'POST',
'headers' => [
'Authorization' => 'Bearer ' . $tokens['access_token'],
'Content-Type' => 'application/json',
],
'body' => json_encode($body),
'timeout' => 30,
];
$response = wp_remote_post($api_url, $args);
if(is_wp_error($response)){
return $response;
}
$code = wp_remote_retrieve_response_code($response);
if($code != 200){
return new \WP_Error('verification_failed', __('Verification failed.', 'siteseo-pro'));
}
$body = json_decode(wp_remote_retrieve_body($response), true);
return $body;
}
static function submit_sitemap(){
$options = get_option('siteseo_xml_sitemap_option_name', []);
// Making sure Sitemaps are enabled.
if(empty($options['xml_sitemap_general_enable'])){
return new \WP_Error('sitemap_disabled', __('SiteSEO sitemap is disabled. Please enable it to submit sitemap automatically.', 'siteseo-pro'));
}
$site_url = \SiteSEOPro\GoogleConsole::get_site_url();
// Making sure the sitemap does not return 404 for newly created website
flush_rewrite_rules(false);
// If we are using the sc-domain, we need to extract just the host of the website.
if(strpos($site_url, 'sc-domain') === 0){
$sitemap_base = str_replace('sc-domain:', '', $site_url);
$sitemap_base = (is_ssl() ? 'https://': 'http://').$sitemap_base;
} else {
$sitemap_base = $site_url;
}
$sitemap_url = trailingslashit($sitemap_base) . 'sitemaps.xml';
$tokens = \SiteSEOPro\GoogleConsole::get_tokens();
// Getting list of sitemaps to submitted to Google already
// So that we dont end up sending the same sitemap again.
$list_endpoint = 'https://www.googleapis.com/webmasters/v3/sites/' . urlencode($site_url) . '/sitemaps';
$list_response = wp_remote_get($list_endpoint, [
'headers' => [
'Authorization' => 'Bearer ' . $tokens['access_token'],
],
]);
if(is_wp_error($list_response)){
return $list_response;
}
$body = json_decode(wp_remote_retrieve_body($list_response), true);
$existing_sitemaps = !empty($body['sitemap']) ? $body['sitemap'] : [];
foreach($existing_sitemaps as $sitemap){
if(isset($sitemap['path']) && $sitemap['path'] === $sitemap_url){
return; // current sitemap already exists so no need to go further.
}
}
// Submit sitemap if not found
$submit_endpoint = 'https://www.googleapis.com/webmasters/v3/sites/' . urlencode($site_url) . '/sitemaps/' . urlencode($sitemap_url);
$response = wp_remote_request($submit_endpoint, [
'method' => 'PUT',
'headers' => [
'Authorization' => 'Bearer ' . $tokens['access_token'],
'Content-Type' => 'application/json',
],
'body' => '{}',
]);
$body = json_decode(wp_remote_retrieve_body($response), true);
if(isset($body['error'])){
return new \WP_Error('sitemap_submission', $body['error']['message']);
}
}
static function get_pre_connected_sites(){
$tokens = \SiteSEOPro\GoogleConsole::get_tokens();
// Get sites from Google Search Console
$response = wp_remote_get('https://www.googleapis.com/webmasters/v3/sites', [
'headers' => [
'Authorization' => 'Bearer ' . $tokens['access_token'],
'Accept' => 'application/json',
],
'timeout' => 30
]);
if(is_wp_error($response)){
return ['error' => $response->get_error_message()];
}
$body = json_decode(wp_remote_retrieve_body($response), true);
if(isset($body['error'])){
return ['error' => $body['error']['message']];
}
if(!isset($body['siteEntry'])){
return [];
}
$sites = $body['siteEntry'];
// Current site domain
$current_site_url = get_site_url();
$current_host = wp_parse_url($current_site_url, PHP_URL_HOST);
$current_host_length = strlen($current_host) + 1; // the +1 is for a . at the start
$matched = [];
foreach($sites as $site){
if(!isset($site['siteUrl'])){
continue;
}
$site_host = wp_parse_url($site['siteUrl'], PHP_URL_HOST);
if(!$site_host){
continue;
}
// Check if same domain or sub-domain
if($site_host === $current_host || substr($site_host, - $current_host_length) === '.' . $current_host){
$matched[] = $site;
}
}
return $matched;
}
static function execute_setup_process(){
$site_url = trailingslashit(get_site_url());
self::save_site($site_url); // save site in db
$pre_connected_sites = self::get_pre_connected_sites();
$current_site_exists = false;
if(!empty($pre_connected_sites) && !isset($pre_connected_sites['error'])){
foreach($pre_connected_sites as $site){
if($site['siteUrl'] === $site_url){
$current_site_exists = true;
break;
}
}
}
// site exits then on gsc then don't create property again on gsc
if($current_site_exists){
$sitemap = self::submit_sitemap();
if(is_wp_error($sitemap)){
return $sitemap;
}
$analytics = \SiteSEOPro\GoogleConsole::get_all_analytics();
if(is_wp_error($analytics)){
return $analytics;
}
return true;
}
// Step 1: Create property
$property_result = self::create_property($site_url);
if(is_wp_error($property_result)){
return $property_result;
}
// Step 2: Get verification token
$verification_token = self::get_verification_token($site_url);
if(is_wp_error($verification_token)){
return $verification_token;
}
// Step 3: Save meta tag
$meta_saved = self::save_verification_meta($verification_token);
if(is_wp_error($meta_saved)){
return $meta_saved;
}
// Step 4: Verify property
$verification_result = self::verify_property($site_url);
if(is_wp_error($verification_result)){
return $verification_result;
}
// Step 5: Submit sitemap
$sitemap_result = self::submit_sitemap();
if(is_wp_error($sitemap_result)){
return $sitemap_result;
}
// Step 6: Fetch analytics data
$analytics_result = \SiteSEOPro\GoogleConsole::get_all_analytics();
if(is_wp_error($analytics_result)){
return $analytics_result;
}
return true;
}
static function wizard(){
$already_connected = \SiteSEOPro\GoogleConsole::is_connected();
if(!empty($already_connected)){
return;
}
$google_auth = isset($_GET['siteseo_auth_code']) ? sanitize_text_field(wp_unslash($_GET['siteseo_auth_code'])) : '';
if(!empty($google_auth)){
\SiteSEOPro\GoogleConsole::generate_tokens();
}
echo'
'.esc_attr($business_name).'
'.esc_attr($street).'
'.esc_attr($place_id).'
'.esc_attr($city).'
'.esc_attr($state).'
'.esc_attr($country).'
Phone: '.esc_attr($phone).'
';
if(!empty($latitude) && !empty($longitude) && !empty($place_id)){
$output .= '
' . __('View on Google Maps', 'siteseo-pro') . '';
$output .= '
';
}
// Opening hours
if(isset($siteseo->pro['opening_hours']) && is_array($siteseo->pro['opening_hours'])){
$output .= '
';
$days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
foreach($days as $key => $day){
$hours = $siteseo->pro['opening_hours'][$key];
if(!empty($hours['closed'])){
$output .= '
| ' . esc_html($day) . ' |
Closed |
';
} else{
$morning = '';
$afternoon = '';
if(!empty($hours['open_morning'])){
$morning = esc_html("{$hours['open_morning_start_hour']}:{$hours['open_morning_start_min']} - {$hours['open_morning_end_hour']}:{$hours['open_morning_end_min']}");
}
if(!empty($hours['open_afternoon'])){
$afternoon = esc_html("{$hours['open_afternoon_start_hour']}:{$hours['open_afternoon_start_min']} - {$hours['open_afternoon_end_hour']}:{$hours['open_afternoon_end_min']}");
}
$output .= '
| ' . $day . ' |
'.$morning .' |
'. $afternoon .' |
';
}
}
$output .= '
';
}
return $output;
}
// structured data schema
static function structured_data(){
global $siteseo;
if(empty($siteseo->pro['toggle_state_stru_data']) || empty($siteseo->pro['enable_structured_data'])){
return;
}
if(!is_front_page() || !is_home()){
return;
}
// Data load
$organization_logo = !empty($siteseo->pro['structured_data_image_url']) ? $siteseo->pro['structured_data_image_url'] : '';
$org_email_id = !empty($siteseo->pro['org_email']) ? $siteseo->pro['org_email'] : '';
$org_phone = !empty($siteseo->pro['org_phone_no']) ? $siteseo->pro['org_phone_no'] : '';
$org_name = !empty($siteseo->pro['org_name']) ? $siteseo->pro['org_name'] : '';
$org_legal_name = !empty($siteseo->pro['org_legal']) ? $siteseo->pro['org_legal'] : '';
$org_establish_date = !empty($siteseo->pro['establish_date']) ? $siteseo->pro['establish_date'] : '';
$org_no_emp = !empty($siteseo->pro['number_emp']) ? $siteseo->pro['number_emp'] : '';
$org_vat_id = !empty($siteseo->pro['vat_id']) ? $siteseo->pro['vat_id'] : '';
$org_tax_id = !empty($siteseo->pro['tax_id']) ? $siteseo->pro['tax_id'] : '';
$org_iso_code = !empty($siteseo->pro['iso_code']) ? $siteseo->pro['iso_code'] : '';
$org_lei_code = !empty($siteseo->pro['let_code']) ? $siteseo->pro['let_code'] : '';
$org_dnus_code = !empty($siteseo->pro['dnus_number']) ? $siteseo->pro['dnus_number'] : '';
$org_naics = !empty($siteseo->pro['naics_code']) ? $siteseo->pro['naics_code'] : '';
// JSON-LD
$json_ld = [
'@context' => 'https://schema.org',
'@type' => 'Organization',
'logo' => esc_url($organization_logo)
];
// Not empty
if(!empty($org_email_id)) $json_ld['email'] = esc_attr($org_email_id);
if(!empty($org_legal_name)) $json_ld['legalName'] = esc_attr($org_legal_name);
if(!empty($org_establish_date)) $json_ld['foundingDate'] = esc_attr($org_establish_date);
if(!empty($org_no_emp)) $json_ld['numberOfEmployees'] = esc_attr($org_no_emp);
if(!empty($org_vat_id)) $json_ld['VatID'] = esc_attr($org_vat_id);
if(!empty($org_tax_id)) $json_ld['taxID'] = esc_attr($org_tax_id);
if(!empty($org_iso_code)) $json_ld['iso6523Code'] = esc_attr($org_iso_code);
if(!empty($org_lei_code)) $json_ld['leiCode'] = esc_attr($org_lei_code);
if(!empty($org_dnus_code)) $json_ld['duns'] = esc_attr($org_dnus_code);
if(!empty($org_naics)) $json_ld['naics'] = esc_attr($org_naics);
if(!empty($org_email_id) && !empty($org_phone)){
$json_ld['contactPoint'] = [
'@type' => 'ContactPoint',
'contactType' => 'Customer Support',
'email' => $org_email_id,
'telephone' => $org_phone
];
}
// JSON-LD script
echo '';
}
static function load_data_local_business($attributes){
$data = \SiteSEOPro\Tags::local_business();
if(is_front_page() && !empty($attributes['displayOnHomepage'])){
return '
' . $data . '
';
}
if(!is_front_page() && empty($attributes['displayOnHomepage'])){
return '
' . $data . '
';
}
return '';
}
static function author_base(){
global $siteseo, $wp_rewrite;
if(empty($siteseo->titles_settings['author_base_url']) || empty($siteseo->setting_enabled['toggle-titles']) || $siteseo->titles_settings['author_base_url'] === 'author'){
return;
}
$wp_rewrite->author_base = sanitize_title_with_dashes($siteseo->titles_settings['author_base_url']);
}
}PK ! L L main/plugin-update-checker.phpnu [ metadataUrl = $metadataUrl;
$this->pluginAbsolutePath = $pluginFile;
$this->pluginFile = plugin_basename($this->pluginAbsolutePath);
$this->muPluginFile = $muPluginFile;
$this->slug = $slug;
$this->optionName = $optionName;
$this->debugMode = (bool)(constant('WP_DEBUG'));
//If no slug is specified, use the name of the main plugin file as the slug.
//For example, 'my-cool-plugin/cool-plugin.php' becomes 'cool-plugin'.
if ( empty($this->slug) ){
$this->slug = basename($this->pluginFile, '.php');
}
//Plugin slugs must be unique.
$slugCheckFilter = 'puc_is_slug_in_use-' . $this->slug;
$slugUsedBy = apply_filters($slugCheckFilter, false);
if ( $slugUsedBy ) {
$this->triggerError(sprintf(
'Plugin slug "%s" is already in use by %s. Slugs must be unique.',
htmlentities($this->slug),
htmlentities($slugUsedBy)
), E_USER_ERROR);
}
add_filter($slugCheckFilter, array($this, 'getAbsolutePath'));
if ( empty($this->optionName) ){
$this->optionName = 'external_updates-' . $this->slug;
}
//Backwards compatibility: If the plugin is a mu-plugin but no $muPluginFile is specified, assume
//it's the same as $pluginFile given that it's not in a subdirectory (WP only looks in the base dir).
if ( (strpbrk($this->pluginFile, '/\\') === false) && $this->isUnknownMuPlugin() ) {
$this->muPluginFile = $this->pluginFile;
}
$this->scheduler = $this->createScheduler($checkPeriod);
$this->upgraderStatus = new SiteSEO_PucUpgraderStatus_3_2();
$this->installHooks();
}
/**
* Create an instance of the scheduler.
*
* This is implemented as a method to make it possible for plugins to subclass the update checker
* and substitute their own scheduler.
*
* @param int $checkPeriod
* @return SiteSEO_PucScheduler_3_2
*/
protected function createScheduler($checkPeriod) {
return new SiteSEO_PucScheduler_3_2($this, $checkPeriod);
}
/**
* Install the hooks required to run periodic update checks and inject update info
* into WP data structures.
*
* @return void
*/
protected function installHooks(){
//Override requests for plugin information
add_filter('plugins_api', array($this, 'injectInfo'), 20, 3);
//Insert our update info into the update array maintained by WP.
add_filter('site_transient_update_plugins', array($this,'injectUpdate')); //WP 3.0+
add_filter('transient_update_plugins', array($this,'injectUpdate')); //WP 2.8+
add_filter('site_transient_update_plugins', array($this, 'injectTranslationUpdates'));
add_filter('plugin_row_meta', array($this, 'addCheckForUpdatesLink'), 10, 2);
add_action('admin_init', array($this, 'handleManualCheck'));
add_action('all_admin_notices', array($this, 'displayManualCheckResult'));
//Clear the version number cache when something - anything - is upgraded or WP clears the update cache.
add_filter('upgrader_post_install', array($this, 'clearCachedVersion'));
add_action('delete_site_transient_update_plugins', array($this, 'clearCachedVersion'));
//Clear translation updates when WP clears the update cache.
//This needs to be done directly because the library doesn't actually remove obsolete plugin updates,
//it just hides them (see getUpdate()). We can't do that with translations - too much disk I/O.
add_action('delete_site_transient_update_plugins', array($this, 'clearCachedTranslationUpdates'));
if ( did_action('plugins_loaded') ) {
$this->initDebugBarPanel();
} else {
add_action('plugins_loaded', array($this, 'initDebugBarPanel'));
}
//Rename the update directory to be the same as the existing directory.
add_filter('upgrader_source_selection', array($this, 'fixDirectoryName'), 10, 3);
//Enable language support (i18n).
load_plugin_textdomain('plugin-update-checker', false, plugin_basename(dirname(__FILE__)) . '/languages');
//Allow HTTP requests to the metadata URL even if it's on a local host.
$this->metadataHost = @parse_url($this->metadataUrl, PHP_URL_HOST);
add_filter('http_request_host_is_external', array($this, 'allowMetadataHost'), 10, 2);
}
/**
* Explicitly allow HTTP requests to the metadata URL.
*
* WordPress has a security feature where the HTTP API will reject all requests that are sent to
* another site hosted on the same server as the current site (IP match), a local host, or a local
* IP, unless the host exactly matches the current site.
*
* This feature is opt-in (at least in WP 4.4). Apparently some people enable it.
*
* That can be a problem when you're developing your plugin and you decide to host the update information
* on the same server as your test site. Update requests will mysteriously fail.
*
* We fix that by adding an exception for the metadata host.
*
* @param bool $allow
* @param string $host
* @return bool
*/
public function allowMetadataHost($allow, $host) {
if ( strtolower($host) === strtolower($this->metadataHost) ) {
return true;
}
return $allow;
}
/**
* Retrieve plugin info from the configured API endpoint.
*
* @uses wp_remote_get()
*
* @param array $queryArgs Additional query arguments to append to the request. Optional.
* @return SiteSEOInfo_3_2
*/
public function requestInfo($queryArgs = array()){
//Query args to append to the URL. Plugins can add their own by using a filter callback (see addQueryArgFilter()).
$installedVersion = $this->getInstalledVersion();
$queryArgs['installed_version'] = ($installedVersion !== null) ? $installedVersion : '';
$queryArgs = apply_filters('puc_request_info_query_args-'.$this->slug, $queryArgs);
//Various options for the wp_remote_get() call. Plugins can filter these, too.
$options = array(
'timeout' => 10, //seconds
'headers' => array(
'Accept' => 'application/json'
),
);
$options = apply_filters('puc_request_info_options-'.$this->slug, $options);
//The plugin info should be at 'http://your-api.com/url/here/$slug/info.json'
$url = $this->metadataUrl;
if ( !empty($queryArgs) ){
$url = add_query_arg($queryArgs, $url);
}
$result = wp_remote_get(
$url,
$options
);
//Try to parse the response
$status = $this->validateApiResponse($result);
$pluginInfo = null;
if ( !is_wp_error($status) ){
$pluginInfo = SiteSEOInfo_3_2::fromJson($result['body']);
if ( $pluginInfo !== null ) {
$pluginInfo->filename = $this->pluginFile;
$pluginInfo->slug = $this->slug;
}
} else {
$this->triggerError(
sprintf('The URL %s does not point to a valid plugin metadata file. ', $url)
. $status->get_error_message(),
E_USER_WARNING
);
}
$pluginInfo = apply_filters('puc_request_info_result-'.$this->slug, $pluginInfo, $result);
return $pluginInfo;
}
/**
* Check if $result is a successful update API response.
*
* @param array|WP_Error $result
* @return true|WP_Error
*/
private function validateApiResponse($result) {
if ( is_wp_error($result) ) { /** @var WP_Error $result */
return new WP_Error($result->get_error_code(), 'WP HTTP Error: ' . $result->get_error_message());
}
if ( !isset($result['response']['code']) ) {
return new WP_Error('puc_no_response_code', 'wp_remote_get() returned an unexpected result.');
}
if ( $result['response']['code'] !== 200 ) {
return new WP_Error(
'puc_unexpected_response_code',
'HTTP response code is ' . $result['response']['code'] . ' (expected: 200)'
);
}
if ( empty($result['body']) ) {
return new WP_Error('puc_empty_response', 'The metadata file appears to be empty.');
}
return true;
}
/**
* Retrieve the latest update (if any) from the configured API endpoint.
*
* @uses SiteSEOUpdateChecker::requestInfo()
*
* @return SiteSEOUpdate_3_2 An instance of SiteSEOUpdate, or NULL when no updates are available.
*/
public function requestUpdate(){
//For the sake of simplicity, this function just calls requestInfo()
//and transforms the result accordingly.
$pluginInfo = $this->requestInfo(array('checking_for_updates' => '1'));
if ( $pluginInfo == null ){
return null;
}
$update = SiteSEOUpdate_3_2::fromSiteSEOInfo($pluginInfo);
//Keep only those translation updates that apply to this site.
$update->translations = $this->filterApplicableTranslations($update->translations);
return $update;
}
/**
* Filter a list of translation updates and return a new list that contains only updates
* that apply to the current site.
*
* @param array $translations
* @return array
*/
private function filterApplicableTranslations($translations) {
$languages = array_flip(array_values(get_available_languages()));
$installedTranslations = wp_get_installed_translations('plugins');
if ( isset($installedTranslations[$this->slug]) ) {
$installedTranslations = $installedTranslations[$this->slug];
} else {
$installedTranslations = array();
}
$applicableTranslations = array();
foreach($translations as $translation) {
//Does it match one of the available core languages?
$isApplicable = array_key_exists($translation->language, $languages);
//Is it more recent than an already-installed translation?
if ( isset($installedTranslations[$translation->language]) ) {
$updateTimestamp = strtotime($translation->updated);
$installedTimestamp = strtotime($installedTranslations[$translation->language]['PO-Revision-Date']);
$isApplicable = $updateTimestamp > $installedTimestamp;
}
if ( $isApplicable ) {
$applicableTranslations[] = $translation;
}
}
return $applicableTranslations;
}
/**
* Get the currently installed version of the plugin.
*
* @return string Version number.
*/
public function getInstalledVersion(){
if ( isset($this->cachedInstalledVersion) ) {
return $this->cachedInstalledVersion;
}
$pluginHeader = $this->getPluginHeader();
if ( isset($pluginHeader['Version']) ) {
$this->cachedInstalledVersion = $pluginHeader['Version'];
return $pluginHeader['Version'];
} else {
//This can happen if the filename points to something that is not a plugin.
$this->triggerError(
sprintf(
"Can't to read the Version header for '%s'. The filename is incorrect or is not a plugin.",
$this->pluginFile
),
E_USER_WARNING
);
return null;
}
}
/**
* Get plugin's metadata from its file header.
*
* @return array
*/
protected function getPluginHeader() {
if ( !is_file($this->pluginAbsolutePath) ) {
//This can happen if the plugin filename is wrong.
$this->triggerError(
sprintf(
"Can't to read the plugin header for '%s'. The file does not exist.",
$this->pluginFile
),
E_USER_WARNING
);
return array();
}
if ( !function_exists('get_plugin_data') ){
/** @noinspection PhpIncludeInspection */
require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
}
return get_plugin_data($this->pluginAbsolutePath, false, false);
}
/**
* Check for plugin updates.
* The results are stored in the DB option specified in $optionName.
*
* @return SiteSEOUpdate_3_2|null
*/
public function checkForUpdates(){
$installedVersion = $this->getInstalledVersion();
//Fail silently if we can't find the plugin or read its header.
if ( $installedVersion === null ) {
$this->triggerError(
sprintf('Skipping update check for %s - installed version unknown.', $this->pluginFile),
E_USER_WARNING
);
return null;
}
$state = $this->getUpdateState();
if ( empty($state) ){
$state = new stdClass;
$state->lastCheck = 0;
$state->checkedVersion = '';
$state->update = null;
}
$state->lastCheck = time();
$state->checkedVersion = $installedVersion;
$this->setUpdateState($state); //Save before checking in case something goes wrong
$state->update = $this->requestUpdate();
$this->setUpdateState($state);
return $this->getUpdate();
}
/**
* Load the update checker state from the DB.
*
* @return stdClass|null
*/
public function getUpdateState() {
$state = get_site_option($this->optionName, null);
if ( empty($state) || !is_object($state)) {
$state = null;
}
if ( isset($state, $state->update) && is_object($state->update) ) {
$state->update = SiteSEOUpdate_3_2::fromObject($state->update);
}
return $state;
}
/**
* Persist the update checker state to the DB.
*
* @param StdClass $state
* @return void
*/
private function setUpdateState($state) {
if ( isset($state->update) && is_object($state->update) && method_exists($state->update, 'toStdClass') ) {
$update = $state->update; /** @var SiteSEOUpdate_3_2 $update */
$state->update = $update->toStdClass();
}
update_site_option($this->optionName, $state);
}
/**
* Reset update checker state - i.e. last check time, cached update data and so on.
*
* Call this when your plugin is being uninstalled, or if you want to
* clear the update cache.
*/
public function resetUpdateState() {
delete_site_option($this->optionName);
}
/**
* Intercept plugins_api() calls that request information about our plugin and
* use the configured API endpoint to satisfy them.
*
* @see plugins_api()
*
* @param mixed $result
* @param string $action
* @param array|object $args
* @return mixed
*/
public function injectInfo($result, $action = null, $args = null){
$relevant = ($action == 'plugin_information') && isset($args->slug) && (
($args->slug == $this->slug) || ($args->slug == dirname($this->pluginFile))
);
if ( !$relevant ) {
return $result;
}
$pluginInfo = $this->requestInfo();
$pluginInfo = apply_filters('puc_pre_inject_info-' . $this->slug, $pluginInfo);
if ( $pluginInfo ) {
return $pluginInfo->toWpFormat();
}
return $result;
}
/**
* Insert the latest update (if any) into the update list maintained by WP.
*
* @param StdClass $updates Update list.
* @return StdClass Modified update list.
*/
public function injectUpdate($updates){
//Is there an update to insert?
$update = $this->getUpdate();
//No update notifications for mu-plugins unless explicitly enabled. The MU plugin file
//is usually different from the main plugin file so the update wouldn't show up properly anyway.
if ( $this->isUnknownMuPlugin() ) {
$update = null;
}
if ( !empty($update) ) {
//Let plugins filter the update info before it's passed on to WordPress.
$update = apply_filters('puc_pre_inject_update-' . $this->slug, $update);
$updates = $this->addUpdateToList($updates, $update);
} else {
//Clean up any stale update info.
$updates = $this->removeUpdateFromList($updates);
}
return $updates;
}
/**
* @param StdClass|null $updates
* @param SiteSEOUpdate_3_2 $updateToAdd
* @return StdClass
*/
private function addUpdateToList($updates, $updateToAdd) {
if ( !is_object($updates) ) {
$updates = new stdClass();
$updates->response = array();
}
$wpUpdate = $updateToAdd->toWpFormat();
$pluginFile = $this->pluginFile;
if ( $this->isMuPlugin() ) {
//WP does not support automatic update installation for mu-plugins, but we can still display a notice.
$wpUpdate->package = null;
$pluginFile = $this->muPluginFile;
}
$updates->response[$pluginFile] = $wpUpdate;
return $updates;
}
/**
* @param stdClass|null $updates
* @return stdClass|null
*/
private function removeUpdateFromList($updates) {
if ( isset($updates, $updates->response) ) {
unset($updates->response[$this->pluginFile]);
if ( !empty($this->muPluginFile) ) {
unset($updates->response[$this->muPluginFile]);
}
}
return $updates;
}
/**
* Insert translation updates into the list maintained by WordPress.
*
* @param stdClass $updates
* @return stdClass
*/
public function injectTranslationUpdates($updates) {
$translationUpdates = $this->getTranslationUpdates();
if ( empty($translationUpdates) ) {
return $updates;
}
//Being defensive.
if ( !is_object($updates) ) {
$updates = new stdClass();
}
if ( !isset($updates->translations) ) {
$updates->translations = array();
}
//In case there's a name collision with a plugin hosted on wordpress.org,
//remove any preexisting updates that match our plugin.
$translationType = 'plugin';
$filteredTranslations = array();
foreach($updates->translations as $translation) {
if ( ($translation['type'] === $translationType) && ($translation['slug'] === $this->slug) ) {
continue;
}
$filteredTranslations[] = $translation;
}
$updates->translations = $filteredTranslations;
//Add our updates to the list.
foreach($translationUpdates as $update) {
$convertedUpdate = array_merge(
array(
'type' => $translationType,
'slug' => $this->slug,
'autoupdate' => 0,
//AFAICT, WordPress doesn't actually use the "version" field for anything.
//But lets make sure it's there, just in case.
'version' => isset($update->version) ? $update->version : ('1.' . strtotime($update->updated)),
),
(array)$update
);
$updates->translations[] = $convertedUpdate;
}
return $updates;
}
/**
* Rename the update directory to match the existing plugin directory.
*
* When WordPress installs a plugin or theme update, it assumes that the ZIP file will contain
* exactly one directory, and that the directory name will be the same as the directory where
* the plugin/theme is currently installed.
*
* GitHub and other repositories provide ZIP downloads, but they often use directory names like
* "project-branch" or "project-tag-hash". We need to change the name to the actual plugin folder.
*
* This is a hook callback. Don't call it from a plugin.
*
* @param string $source The directory to copy to /wp-content/plugins. Usually a subdirectory of $remoteSource.
* @param string $remoteSource WordPress has extracted the update to this directory.
* @param WP_Upgrader $upgrader
* @return string|WP_Error
*/
public function fixDirectoryName($source, $remoteSource, $upgrader) {
global $wp_filesystem; /** @var WP_Filesystem_Base $wp_filesystem */
//Basic sanity checks.
if ( !isset($source, $remoteSource, $upgrader, $upgrader->skin, $wp_filesystem) ) {
return $source;
}
//If WordPress is upgrading anything other than our plugin, leave the directory name unchanged.
if ( !$this->isPluginBeingUpgraded($upgrader) ) {
return $source;
}
//Rename the source to match the existing plugin directory.
$pluginDirectoryName = dirname($this->pluginFile);
if ( $pluginDirectoryName === '.' ) {
return $source;
}
$correctedSource = trailingslashit($remoteSource) . $pluginDirectoryName . '/';
if ( $source !== $correctedSource ) {
//The update archive should contain a single directory that contains the rest of plugin files. Otherwise,
//WordPress will try to copy the entire working directory ($source == $remoteSource). We can't rename
//$remoteSource because that would break WordPress code that cleans up temporary files after update.
if ( $this->isBadDirectoryStructure($remoteSource) ) {
return new WP_Error(
'puc-incorrect-directory-structure',
sprintf(
'The directory structure of the update is incorrect. All plugin files should be inside ' .
'a directory named
%s, not at the root of the ZIP file.',
htmlentities($this->slug)
)
);
}
/** @var WP_Upgrader_Skin $upgrader->skin */
$upgrader->skin->feedback(sprintf(
'Renaming %s to %s…',
'
' . basename($source) . '',
'
' . $pluginDirectoryName . ''
));
if ( $wp_filesystem->move($source, $correctedSource, true) ) {
$upgrader->skin->feedback('Plugin directory successfully renamed.');
return $correctedSource;
} else {
return new WP_Error(
'puc-rename-failed',
'Unable to rename the update to match the existing plugin directory.'
);
}
}
return $source;
}
/**
* Check for incorrect update directory structure. An update must contain a single directory,
* all other files should be inside that directory.
*
* @param string $remoteSource Directory path.
* @return bool
*/
private function isBadDirectoryStructure($remoteSource) {
global $wp_filesystem; /** @var WP_Filesystem_Base $wp_filesystem */
$sourceFiles = $wp_filesystem->dirlist($remoteSource);
if ( is_array($sourceFiles) ) {
$sourceFiles = array_keys($sourceFiles);
$firstFilePath = trailingslashit($remoteSource) . $sourceFiles[0];
return (count($sourceFiles) > 1) || (!$wp_filesystem->is_dir($firstFilePath));
}
//Assume it's fine.
return false;
}
/**
* Is there and update being installed RIGHT NOW, for this specific plugin?
*
* @param WP_Upgrader|null $upgrader The upgrader that's performing the current update.
* @return bool
*/
public function isPluginBeingUpgraded($upgrader = null) {
return $this->upgraderStatus->isPluginBeingUpgraded($this->pluginFile, $upgrader);
}
/**
* Get the details of the currently available update, if any.
*
* If no updates are available, or if the last known update version is below or equal
* to the currently installed version, this method will return NULL.
*
* Uses cached update data. To retrieve update information straight from
* the metadata URL, call requestUpdate() instead.
*
* @return SiteSEOUpdate_3_2|null
*/
public function getUpdate() {
$state = $this->getUpdateState(); /** @var StdClass $state */
//Is there an update available?
if ( isset($state, $state->update) ) {
$update = $state->update;
//Check if the update is actually newer than the currently installed version.
$installedVersion = $this->getInstalledVersion();
if ( ($installedVersion !== null) && version_compare($update->version, $installedVersion, '>') ){
$update->filename = $this->pluginFile;
return $update;
}
}
return null;
}
/**
* Get a list of available translation updates.
*
* This method will return an empty array if there are no updates.
* Uses cached update data.
*
* @return array
*/
public function getTranslationUpdates() {
$state = $this->getUpdateState();
if ( isset($state, $state->update, $state->update->translations) ) {
return $state->update->translations;
}
return array();
}
/**
* Remove all cached translation updates.
*
* @see wp_clean_update_cache
*/
public function clearCachedTranslationUpdates() {
$state = $this->getUpdateState();
if ( isset($state, $state->update, $state->update->translations) ) {
$state->update->translations = array();
$this->setUpdateState($state);
}
}
/**
* Add a "Check for updates" link to the plugin row in the "Plugins" page. By default,
* the new link will appear after the "Visit plugin site" link.
*
* You can change the link text by using the "puc_manual_check_link-$slug" filter.
* Returning an empty string from the filter will disable the link.
*
* @param array $pluginMeta Array of meta links.
* @param string $pluginFile
* @return array
*/
public function addCheckForUpdatesLink($pluginMeta, $pluginFile) {
$isRelevant = ($pluginFile == $this->pluginFile)
|| (!empty($this->muPluginFile) && $pluginFile == $this->muPluginFile);
if ( $isRelevant && current_user_can('update_plugins') ) {
$linkUrl = wp_nonce_url(
add_query_arg(
array(
'puc_check_for_updates' => 1,
'puc_slug' => $this->slug,
),
self_admin_url('plugins.php')
),
'puc_check_for_updates'
);
$linkText = apply_filters('puc_manual_check_link-' . $this->slug, __('Check for updates', 'siteseo-pro'));
if ( !empty($linkText) ) {
$final_link = sprintf('
%s', esc_attr($linkUrl), $linkText);
$pluginMeta[] = apply_filters('puc_manual_final_check_link-' . $this->slug, $final_link);
}
}
return $pluginMeta;
}
/**
* Check for updates when the user clicks the "Check for updates" link.
* @see self::addCheckForUpdatesLink()
*
* @return void
*/
public function handleManualCheck() {
$shouldCheck =
isset($_GET['puc_check_for_updates'], $_GET['puc_slug'])
&& $_GET['puc_slug'] == $this->slug
&& current_user_can('update_plugins')
&& check_admin_referer('puc_check_for_updates');
if ( $shouldCheck ) {
$update = $this->checkForUpdates();
$status = ($update === null) ? 'no_update' : 'update_available';
wp_redirect(add_query_arg(
array(
'puc_update_check_result' => $status,
'puc_slug' => $this->slug,
),
self_admin_url('plugins.php')
));
}
}
/**
* Display the results of a manual update check.
* @see self::handleManualCheck()
*
* You can change the result message by using the "puc_manual_check_message-$slug" filter.
*/
public function displayManualCheckResult() {
if ( isset($_GET['puc_update_check_result'], $_GET['puc_slug']) && ($_GET['puc_slug'] == $this->slug) ) {
$status = strval($_GET['puc_update_check_result']);
if ( $status == 'no_update' ) {
$message = __('This plugin is up to date.', 'siteseo-pro');
} else if ( $status == 'update_available' ) {
$message = __('A new version of this plugin is available.', 'siteseo-pro');
} else {
// Translators: %s is the status of the update checker.
$message = sprintf(__('Unknown update checker status "%s"', 'siteseo-pro'), htmlentities($status));
}
printf(
'
',
apply_filters('puc_manual_check_message-' . $this->slug, $message, $status)
);
}
}
/**
* Check if the plugin file is inside the mu-plugins directory.
*
* @return bool
*/
protected function isMuPlugin() {
static $cachedResult = null;
if ( $cachedResult === null ) {
//Convert both paths to the canonical form before comparison.
$muPluginDir = realpath(WPMU_PLUGIN_DIR);
$pluginPath = realpath($this->pluginAbsolutePath);
if(!empty($muPluginDir)){
$cachedResult = (strpos($pluginPath, $muPluginDir) === 0);
}else{
$cachedResult = false;
}
}
return $cachedResult;
}
/**
* MU plugins are partially supported, but only when we know which file in mu-plugins
* corresponds to this plugin.
*
* @return bool
*/
protected function isUnknownMuPlugin() {
return empty($this->muPluginFile) && $this->isMuPlugin();
}
/**
* Clear the cached plugin version. This method can be set up as a filter (hook) and will
* return the filter argument unmodified.
*
* @param mixed $filterArgument
* @return mixed
*/
public function clearCachedVersion($filterArgument = null) {
$this->cachedInstalledVersion = null;
return $filterArgument;
}
/**
* Get absolute path to the main plugin file.
*
* @return string
*/
public function getAbsolutePath() {
return $this->pluginAbsolutePath;
}
/**
* Register a callback for filtering query arguments.
*
* The callback function should take one argument - an associative array of query arguments.
* It should return a modified array of query arguments.
*
* @uses add_filter() This method is a convenience wrapper for add_filter().
*
* @param callable $callback
* @return void
*/
public function addQueryArgFilter($callback){
add_filter('puc_request_info_query_args-'.$this->slug, $callback);
}
/**
* Register a callback for filtering arguments passed to wp_remote_get().
*
* The callback function should take one argument - an associative array of arguments -
* and return a modified array or arguments. See the WP documentation on wp_remote_get()
* for details on what arguments are available and how they work.
*
* @uses add_filter() This method is a convenience wrapper for add_filter().
*
* @param callable $callback
* @return void
*/
public function addHttpRequestArgFilter($callback){
add_filter('puc_request_info_options-'.$this->slug, $callback);
}
/**
* Register a callback for filtering the plugin info retrieved from the external API.
*
* The callback function should take two arguments. If the plugin info was retrieved
* successfully, the first argument passed will be an instance of SiteSEOInfo. Otherwise,
* it will be NULL. The second argument will be the corresponding return value of
* wp_remote_get (see WP docs for details).
*
* The callback function should return a new or modified instance of SiteSEOInfo or NULL.
*
* @uses add_filter() This method is a convenience wrapper for add_filter().
*
* @param callable $callback
* @return void
*/
public function addResultFilter($callback){
add_filter('puc_request_info_result-'.$this->slug, $callback, 10, 2);
}
/**
* Register a callback for one of the update checker filters.
*
* Identical to add_filter(), except it automatically adds the "puc_" prefix
* and the "-$plugin_slug" suffix to the filter name. For example, "request_info_result"
* becomes "puc_request_info_result-your_plugin_slug".
*
* @param string $tag
* @param callable $callback
* @param int $priority
* @param int $acceptedArgs
*/
public function addFilter($tag, $callback, $priority = 10, $acceptedArgs = 1) {
add_filter('puc_' . $tag . '-' . $this->slug, $callback, $priority, $acceptedArgs);
}
/**
* Initialize the update checker Debug Bar plugin/add-on thingy.
*/
public function initDebugBarPanel() {
$debugBarPlugin = dirname(__FILE__) . '/debug-bar-plugin.php';
if ( class_exists('Debug_Bar', false) && file_exists($debugBarPlugin) ) {
/** @noinspection PhpIncludeInspection */
require_once $debugBarPlugin;
$this->debugBarPlugin = new SiteSEO_PucDebugBarPlugin_3_2($this);
}
}
/**
* Trigger a PHP error, but only when $debugMode is enabled.
*
* @param string $message
* @param int $errorType
*/
protected function triggerError($message, $errorType) {
if ( $this->debugMode ) {
trigger_error($message, $errorType);
}
}
}
endif;
if ( !class_exists('SiteSEOInfo_3_2', false) ):
/**
* A container class for holding and transforming various plugin metadata.
*
* @author Janis Elsts
* @copyright 2016
* @version 3.2
* @access public
*/
#[\AllowDynamicProperties]
class SiteSEOInfo_3_2 {
//Most fields map directly to the contents of the plugin's info.json file.
//See the relevant docs for a description of their meaning.
public $name;
public $slug;
public $version;
public $homepage;
public $sections = array();
public $banners;
public $translations = array();
public $download_url;
public $author;
public $author_homepage;
public $requires;
public $tested;
public $upgrade_notice;
public $rating;
public $num_ratings;
public $downloaded;
public $active_installs;
public $last_updated;
public $id = 0; //The native WP.org API returns numeric plugin IDs, but they're not used for anything.
public $filename; //Plugin filename relative to the plugins directory.
/**
* Create a new instance of SiteSEOInfo from JSON-encoded plugin info
* returned by an external update API.
*
* @param string $json Valid JSON string representing plugin info.
* @return SiteSEOInfo_3_2|null New instance of SiteSEOInfo, or NULL on error.
*/
public static function fromJson($json){
/** @var StdClass $apiResponse */
$apiResponse = json_decode($json);
if ( empty($apiResponse) || !is_object($apiResponse) ){
trigger_error(
"Failed to parse plugin metadata. Try validating your .json file with http://jsonlint.com/",
E_USER_NOTICE
);
return null;
}
$valid = self::validateMetadata($apiResponse);
if ( is_wp_error($valid) ){
trigger_error($valid->get_error_message(), E_USER_NOTICE);
return null;
}
$info = new self();
foreach(get_object_vars($apiResponse) as $key => $value){
$info->$key = $value;
}
//json_decode decodes assoc. arrays as objects. We want it as an array.
$info->sections = (array)$info->sections;
return $info;
}
/**
* Very, very basic validation.
*
* @param StdClass $apiResponse
* @return bool|WP_Error
*/
protected static function validateMetadata($apiResponse) {
if (
!isset($apiResponse->name, $apiResponse->version)
|| empty($apiResponse->name)
|| empty($apiResponse->version)
) {
return new WP_Error(
'puc-invalid-metadata',
"The plugin metadata file does not contain the required 'name' and/or 'version' keys."
);
}
return true;
}
/**
* Transform plugin info into the format used by the native WordPress.org API
*
* @return object
*/
public function toWpFormat(){
$info = new stdClass;
//The custom update API is built so that many fields have the same name and format
//as those returned by the native WordPress.org API. These can be assigned directly.
$sameFormat = array(
'name', 'slug', 'version', 'requires', 'tested', 'rating', 'upgrade_notice',
'num_ratings', 'downloaded', 'active_installs', 'homepage', 'last_updated',
);
foreach($sameFormat as $field){
if ( isset($this->$field) ) {
$info->$field = $this->$field;
} else {
$info->$field = null;
}
}
//Other fields need to be renamed and/or transformed.
$info->download_link = $this->download_url;
$info->author = $this->getFormattedAuthor();
$info->sections = array_merge(array('description' => ''), $this->sections);
if ( !empty($this->banners) ) {
//WP expects an array with two keys: "high" and "low". Both are optional.
//Docs: https://wordpress.org/plugins/about/faq/#banners
$info->banners = is_object($this->banners) ? get_object_vars($this->banners) : $this->banners;
$info->banners = array_intersect_key($info->banners, array('high' => true, 'low' => true));
}
return $info;
}
protected function getFormattedAuthor() {
if ( !empty($this->author_homepage) ){
return sprintf('
%s', $this->author_homepage, $this->author);
}
return $this->author;
}
}
endif;
if ( !class_exists('SiteSEOUpdate_3_2', false) ):
/**
* A simple container class for holding information about an available update.
*
* @author Janis Elsts
* @copyright 2016
* @version 3.2
* @access public
*/
#[\AllowDynamicProperties]
class SiteSEOUpdate_3_2 {
public $id = 0;
public $slug;
public $version;
public $homepage;
public $download_url;
public $upgrade_notice;
public $tested;
public $translations = array();
public $filename; //Plugin filename relative to the plugins directory.
private static $fields = array(
'id', 'slug', 'version', 'homepage', 'tested',
'download_url', 'upgrade_notice', 'filename',
'translations'
);
/**
* Create a new instance of SiteSEOUpdate from its JSON-encoded representation.
*
* @param string $json
* @return SiteSEOUpdate_3_2|null
*/
public static function fromJson($json){
//Since update-related information is simply a subset of the full plugin info,
//we can parse the update JSON as if it was a plugin info string, then copy over
//the parts that we care about.
$pluginInfo = SiteSEOInfo_3_2::fromJson($json);
if ( $pluginInfo != null ) {
return self::fromSiteSEOInfo($pluginInfo);
} else {
return null;
}
}
/**
* Create a new instance of SiteSEOUpdate based on an instance of SiteSEOInfo.
* Basically, this just copies a subset of fields from one object to another.
*
* @param SiteSEOInfo_3_2 $info
* @return SiteSEOUpdate_3_2
*/
public static function fromSiteSEOInfo($info){
return self::fromObject($info);
}
/**
* Create a new instance of SiteSEOUpdate by copying the necessary fields from
* another object.
*
* @param StdClass|SiteSEOInfo_3_2|SiteSEOUpdate_3_2 $object The source object.
* @return SiteSEOUpdate_3_2 The new copy.
*/
public static function fromObject($object) {
$update = new self();
$fields = self::$fields;
if ( !empty($object->slug) ) {
$fields = apply_filters('puc_retain_fields-' . $object->slug, $fields);
}
foreach($fields as $field){
if (property_exists($object, $field)) {
$update->$field = $object->$field;
}
}
return $update;
}
/**
* Create an instance of StdClass that can later be converted back to
* a SiteSEOUpdate. Useful for serialization and caching, as it avoids
* the "incomplete object" problem if the cached value is loaded before
* this class.
*
* @return StdClass
*/
public function toStdClass() {
$object = new stdClass();
$fields = self::$fields;
if ( !empty($this->slug) ) {
$fields = apply_filters('puc_retain_fields-' . $this->slug, $fields);
}
foreach($fields as $field){
if (property_exists($this, $field)) {
$object->$field = $this->$field;
}
}
return $object;
}
/**
* Transform the update into the format used by WordPress native plugin API.
*
* @return object
*/
public function toWpFormat(){
$update = new stdClass;
$update->id = $this->id;
$update->slug = $this->slug;
$update->new_version = $this->version;
$update->url = $this->homepage;
$update->package = $this->download_url;
$update->tested = $this->tested;
$update->plugin = $this->filename;
if ( !empty($this->upgrade_notice) ){
$update->upgrade_notice = $this->upgrade_notice;
}
return $update;
}
}
endif;
if ( !class_exists('SiteSEO_PucScheduler_3_2', false) ):
/**
* The scheduler decides when and how often to check for updates.
* It calls @see SiteSEOUpdateChecker::checkForUpdates() to perform the actual checks.
*
* @version 3.2
*/
class SiteSEO_PucScheduler_3_2 {
public $checkPeriod = 12; //How often to check for updates (in hours).
public $throttleRedundantChecks = false; //Check less often if we already know that an update is available.
public $throttledCheckPeriod = 72;
/**
* @var SiteSEOUpdateChecker_3_2
*/
protected $updateChecker;
private $cronHook = null;
/**
* Scheduler constructor.
*
* @param SiteSEOUpdateChecker_3_2 $updateChecker
* @param int $checkPeriod How often to check for updates (in hours).
*/
public function __construct($updateChecker, $checkPeriod) {
$this->updateChecker = $updateChecker;
$this->checkPeriod = $checkPeriod;
//Set up the periodic update checks
$this->cronHook = 'check_plugin_updates-' . $this->updateChecker->slug;
if ( $this->checkPeriod > 0 ){
//Trigger the check via Cron.
//Try to use one of the default schedules if possible as it's less likely to conflict
//with other plugins and their custom schedules.
$defaultSchedules = array(
1 => 'hourly',
12 => 'twicedaily',
24 => 'daily',
);
if ( array_key_exists($this->checkPeriod, $defaultSchedules) ) {
$scheduleName = $defaultSchedules[$this->checkPeriod];
} else {
//Use a custom cron schedule.
$scheduleName = 'every' . $this->checkPeriod . 'hours';
add_filter('cron_schedules', array($this, '_addCustomSchedule'));
}
if ( !wp_next_scheduled($this->cronHook) && !defined('WP_INSTALLING') ) {
wp_schedule_event(time(), $scheduleName, $this->cronHook);
}
add_action($this->cronHook, array($this, 'maybeCheckForUpdates'));
register_deactivation_hook($this->updateChecker->pluginFile, array($this, '_removeUpdaterCron'));
//In case Cron is disabled or unreliable, we also manually trigger
//the periodic checks while the user is browsing the Dashboard.
add_action( 'admin_init', array($this, 'maybeCheckForUpdates') );
//Like WordPress itself, we check more often on certain pages.
/** @see wp_update_plugins */
add_action('load-update-core.php', array($this, 'maybeCheckForUpdates'));
add_action('load-plugins.php', array($this, 'maybeCheckForUpdates'));
add_action('load-update.php', array($this, 'maybeCheckForUpdates'));
//This hook fires after a bulk update is complete.
add_action('upgrader_process_complete', array($this, 'maybeCheckForUpdates'), 11, 0);
} else {
//Periodic checks are disabled.
wp_clear_scheduled_hook($this->cronHook);
}
}
/**
* Check for updates if the configured check interval has already elapsed.
* Will use a shorter check interval on certain admin pages like "Dashboard -> Updates" or when doing cron.
*
* You can override the default behaviour by using the "puc_check_now-$slug" filter.
* The filter callback will be passed three parameters:
* - Current decision. TRUE = check updates now, FALSE = don't check now.
* - Last check time as a Unix timestamp.
* - Configured check period in hours.
* Return TRUE to check for updates immediately, or FALSE to cancel.
*
* This method is declared public because it's a hook callback. Calling it directly is not recommended.
*/
public function maybeCheckForUpdates(){
if ( empty($this->checkPeriod) ){
return;
}
$state = $this->updateChecker->getUpdateState();
$shouldCheck =
empty($state) ||
!isset($state->lastCheck) ||
( (time() - $state->lastCheck) >= $this->getEffectiveCheckPeriod() );
//Let plugin authors substitute their own algorithm.
$shouldCheck = apply_filters(
'puc_check_now-' . $this->updateChecker->slug,
$shouldCheck,
(!empty($state) && isset($state->lastCheck)) ? $state->lastCheck : 0,
$this->checkPeriod
);
if ( $shouldCheck ) {
$this->updateChecker->checkForUpdates();
}
}
/**
* Calculate the actual check period based on the current status and environment.
*
* @return int Check period in seconds.
*/
protected function getEffectiveCheckPeriod() {
$currentFilter = current_filter();
if ( in_array($currentFilter, array('load-update-core.php', 'upgrader_process_complete')) ) {
//Check more often when the user visits "Dashboard -> Updates" or does a bulk update.
$period = 60;
} else if ( in_array($currentFilter, array('load-plugins.php', 'load-update.php')) ) {
//Also check more often on the "Plugins" page and /wp-admin/update.php.
$period = 3600;
} else if ( $this->throttleRedundantChecks && ($this->updateChecker->getUpdate() !== null) ) {
//Check less frequently if it's already known that an update is available.
$period = $this->throttledCheckPeriod * 3600;
} else if ( defined('DOING_CRON') && constant('DOING_CRON') ) {
//WordPress cron schedules are not exact, so lets do an update check even
//if slightly less than $checkPeriod hours have elapsed since the last check.
$cronFuzziness = 20 * 60;
$period = $this->checkPeriod * 3600 - $cronFuzziness;
} else {
$period = $this->checkPeriod * 3600;
}
return $period;
}
/**
* Add our custom schedule to the array of Cron schedules used by WP.
*
* @param array $schedules
* @return array
*/
public function _addCustomSchedule($schedules){
if ( $this->checkPeriod && ($this->checkPeriod > 0) ){
$scheduleName = 'every' . $this->checkPeriod . 'hours';
$schedules[$scheduleName] = array(
'interval' => $this->checkPeriod * 3600,
'display' => sprintf('Every %d hours', $this->checkPeriod),
);
}
return $schedules;
}
/**
* Remove the scheduled cron event that the library uses to check for updates.
*
* @return void
*/
public function _removeUpdaterCron(){
wp_clear_scheduled_hook($this->cronHook);
}
/**
* Get the name of the update checker's WP-cron hook. Mostly useful for debugging.
*
* @return string
*/
public function getCronHookName() {
return $this->cronHook;
}
}
endif;
if ( !class_exists('SiteSEO_PucUpgraderStatus_3_2', false) ):
/**
* A utility class that helps figure out which plugin WordPress is upgrading.
*
* It may seem strange to have an separate class just for that, but the task is surprisingly complicated.
* Core classes like Plugin_Upgrader don't expose the plugin file name during an in-progress update (AFAICT).
* This class uses a few workarounds and heuristics to get the file name.
*/
#[\AllowDynamicProperties]
class SiteSEO_PucUpgraderStatus_3_2 {
private $upgradedPluginFile = null; //The plugin that is currently being upgraded by WordPress.
public function __construct() {
//Keep track of which plugin WordPress is currently upgrading.
add_filter('upgrader_pre_install', array($this, 'setUpgradedPlugin'), 10, 2);
add_filter('upgrader_package_options', array($this, 'setUpgradedPluginFromOptions'), 10, 1);
add_filter('upgrader_post_install', array($this, 'clearUpgradedPlugin'), 10, 1);
add_action('upgrader_process_complete', array($this, 'clearUpgradedPlugin'), 10, 1);
}
/**
* Is there and update being installed RIGHT NOW, for a specific plugin?
*
* Caution: This method is unreliable. WordPress doesn't make it easy to figure out what it is upgrading,
* and upgrader implementations are liable to change without notice.
*
* @param string $pluginFile The plugin to check.
* @param WP_Upgrader|null $upgrader The upgrader that's performing the current update.
* @return bool True if the plugin identified by $pluginFile is being upgraded.
*/
public function isPluginBeingUpgraded($pluginFile, $upgrader = null) {
if ( isset($upgrader) ) {
$upgradedPluginFile = $this->getPluginBeingUpgradedBy($upgrader);
if ( !empty($upgradedPluginFile) ) {
$this->upgradedPluginFile = $upgradedPluginFile;
}
}
return ( !empty($this->upgradedPluginFile) && ($this->upgradedPluginFile === $pluginFile) );
}
/**
* Get the file name of the plugin that's currently being upgraded.
*
* @param Plugin_Upgrader|WP_Upgrader $upgrader
* @return string|null
*/
private function getPluginBeingUpgradedBy($upgrader) {
if ( !isset($upgrader, $upgrader->skin) ) {
return null;
}
//Figure out which plugin is being upgraded.
$pluginFile = null;
$skin = $upgrader->skin;
if ( $skin instanceof Plugin_Upgrader_Skin ) {
if ( isset($skin->plugin) && is_string($skin->plugin) && ($skin->plugin !== '') ) {
$pluginFile = $skin->plugin;
}
} elseif ( isset($skin->plugin_info) && is_array($skin->plugin_info) ) {
//This case is tricky because Bulk_Plugin_Upgrader_Skin (etc) doesn't actually store the plugin
//filename anywhere. Instead, it has the plugin headers in $plugin_info. So the best we can
//do is compare those headers to the headers of installed plugins.
$pluginFile = $this->identifyPluginByHeaders($skin->plugin_info);
}
return $pluginFile;
}
/**
* Identify an installed plugin based on its headers.
*
* @param array $searchHeaders The plugin file header to look for.
* @return string|null Plugin basename ("foo/bar.php"), or NULL if we can't identify the plugin.
*/
private function identifyPluginByHeaders($searchHeaders) {
if ( !function_exists('get_plugins') ){
/** @noinspection PhpIncludeInspection */
require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
}
$installedPlugins = get_plugins();
$matches = array();
foreach($installedPlugins as $pluginBasename => $headers) {
$diff1 = array_diff_assoc($headers, $searchHeaders);
$diff2 = array_diff_assoc($searchHeaders, $headers);
if ( empty($diff1) && empty($diff2) ) {
$matches[] = $pluginBasename;
}
}
//It's possible (though very unlikely) that there could be two plugins with identical
//headers. In that case, we can't unambiguously identify the plugin that's being upgraded.
if ( count($matches) !== 1 ) {
return null;
}
return reset($matches);
}
/**
* @access private
*
* @param mixed $input
* @param array $hookExtra
* @return mixed Returns $input unaltered.
*/
public function setUpgradedPlugin($input, $hookExtra) {
if (!empty($hookExtra['plugin']) && is_string($hookExtra['plugin'])) {
$this->upgradedPluginFile = $hookExtra['plugin'];
} else {
$this->upgradedPluginFile = null;
}
return $input;
}
/**
* @access private
*
* @param array $options
* @return array
*/
public function setUpgradedPluginFromOptions($options) {
if (isset($options['hook_extra']['plugin']) && is_string($options['hook_extra']['plugin'])) {
$this->upgradedPluginFile = $options['hook_extra']['plugin'];
} else {
$this->upgradedPluginFile = null;
}
return $options;
}
/**
* @access private
*
* @param mixed $input
* @return mixed Returns $input unaltered.
*/
public function clearUpgradedPlugin($input = null) {
$this->upgradedPluginFile = null;
return $input;
}
}
endif;
if ( !class_exists('SiteSEO_PucFactory', false) ):
/**
* A factory that builds instances of other classes from this library.
*
* When multiple versions of the same class have been loaded (e.g. SiteSEOUpdateChecker 1.2
* and 1.3), this factory will always use the latest available version. Register class
* versions by calling {@link SiteSEO_PucFactory::addVersion()}.
*
* At the moment it can only build instances of the SiteSEOUpdateChecker class. Other classes
* are intended mainly for internal use and refer directly to specific implementations. If you
* want to instantiate one of them anyway, you can use {@link SiteSEO_PucFactory::getLatestClassVersion()}
* to get the class name and then create it with
new $class(...).
*/
#[\AllowDynamicProperties]
class SiteSEO_PucFactory {
protected static $classVersions = array();
protected static $sorted = false;
/**
* Create a new instance of SiteSEOUpdateChecker.
*
* @see SiteSEOUpdateChecker::__construct()
*
* @param $metadataUrl
* @param $pluginFile
* @param string $slug
* @param int $checkPeriod
* @param string $optionName
* @param string $muPluginFile
* @return SiteSEOUpdateChecker_3_2
*/
public static function buildUpdateChecker($metadataUrl, $pluginFile, $slug = '', $checkPeriod = 12, $optionName = '', $muPluginFile = '') {
$class = self::getLatestClassVersion('SiteSEOUpdateChecker');
return new $class($metadataUrl, $pluginFile, $slug, $checkPeriod, $optionName, $muPluginFile);
}
/**
* Get the specific class name for the latest available version of a class.
*
* @param string $class
* @return string|null
*/
public static function getLatestClassVersion($class) {
if ( !self::$sorted ) {
self::sortVersions();
}
if ( isset(self::$classVersions[$class]) ) {
return reset(self::$classVersions[$class]);
} else {
return null;
}
}
/**
* Sort available class versions in descending order (i.e. newest first).
*/
protected static function sortVersions() {
foreach ( self::$classVersions as $class => $versions ) {
uksort($versions, array(__CLASS__, 'compareVersions'));
self::$classVersions[$class] = $versions;
}
self::$sorted = true;
}
protected static function compareVersions($a, $b) {
return -version_compare($a, $b);
}
/**
* Register a version of a class.
*
* @access private This method is only for internal use by the library.
*
* @param string $generalClass Class name without version numbers, e.g. 'SiteSEOUpdateChecker'.
* @param string $versionedClass Actual class name, e.g. 'SiteSEOUpdateChecker_1_2'.
* @param string $version Version number, e.g. '1.2'.
*/
public static function addVersion($generalClass, $versionedClass, $version) {
if ( !isset(self::$classVersions[$generalClass]) ) {
self::$classVersions[$generalClass] = array();
}
self::$classVersions[$generalClass][$version] = $versionedClass;
self::$sorted = false;
}
}
endif;
//Register classes defined in this file with the factory.
SiteSEO_PucFactory::addVersion('SiteSEOUpdateChecker', 'SiteSEOUpdateChecker_3_2', '3.2');
SiteSEO_PucFactory::addVersion('SiteSEOUpdate', 'SiteSEOUpdate_3_2', '3.2');
SiteSEO_PucFactory::addVersion('SiteSEOInfo', 'SiteSEOInfo_3_2', '3.2');
SiteSEO_PucFactory::addVersion('SiteSEO_PucGitHubChecker', 'SiteSEO_PucGitHubChecker_3_2', '3.2');
PK ! +P( P( main/redirectmanager.phpnu [ pro['toggle_state_redirect_monitoring'])){
return;
}
// Disable
if(!empty($siteseo->pro['guess_redirect'])){
remove_filter('template_redirect', 'redirect_guess_404_permalink');
}
if(!is_404() || empty($siteseo->pro['enable_404_log'])){
return;
}
$log_limit = !empty($siteseo->pro['log_limits']) ? $siteseo->pro['log_limits'] : '';
$redirect_to = !empty($siteseo->pro['redirect_type']) ? $siteseo->pro['redirect_type'] : '';
$custom_url = !empty($siteseo->pro['custom_redirect_url']) ? $siteseo->pro['custom_redirect_url'] : '';
$status_code = !empty($siteseo->pro['status_code']) ? $siteseo->pro['status_code'] : '';
$disable_ip_logging = !empty($siteseo->pro['disable_ip_logging']) ? $siteseo->pro['disable_ip_logging'] : '';
$redirect_url = $redirect_to === 'homepage' ? home_url() : $custom_url;
$current_url = sanitize_url($_SERVER['REQUEST_URI']);
// TODO:: Need to make it more robust to make sure we always get an IP.
$current_request_ip = $_SERVER['REMOTE_ADDR'];
$current_request_ip = filter_var($current_request_ip, FILTER_VALIDATE_IP);
if($current_request_ip){
switch($disable_ip_logging){
case 'no_ip_logging':
$current_request_ip = null;
break;
case 'anonymize_the_last_part':
// TODO:: Handle IPv6
$ip_parts = explode('.', $current_request_ip);
$ip_parts[count($ip_parts) - 1] = 'xxx';
$current_request_ip = implode('.', $ip_parts);
break;
}
} else {
$current_request_ip = null;
}
if(!empty($siteseo->pro['enable_404_log'])){
\SiteSEOPro\Settings\Util::maybe_create_404_table();
$existing_record = $wpdb->get_row($wpdb->prepare("SELECT id, hit_count FROM `".$wpdb->prefix."siteseo_redirect_logs` WHERE url = %s", $current_url));
if($existing_record){
// hit count increase
$wpdb->update($wpdb->prefix.'siteseo_redirect_logs', ['hit_count' => intval($existing_record->hit_count + 1)], ['id' => $existing_record->id], ['%d'], ['%d']);
} else{
$current_records = $wpdb->get_var("SELECT COUNT(*) FROM `".$wpdb->prefix."siteseo_redirect_logs`");
if($current_records >= $log_limit){
$wpdb->query("DELETE FROM `".$wpdb->prefix."siteseo_redirect_logs` ORDER BY `timestamp` ASC LIMIT 1");
}
$user_agent = isset($_SERVER['HTTP_USER_AGENT']) ? sanitize_text_field($_SERVER['HTTP_USER_AGENT']) : '';
$referer = isset($_SERVER['HTTP_REFERER']) ? sanitize_url($_SERVER['HTTP_REFERER']) : '';
$wpdb->insert($wpdb->prefix .'siteseo_redirect_logs', ['url' => $current_url, 'ip_address' => $current_request_ip, 'user_agent' => $user_agent, 'referer' => $referer, 'hit_count' => 1,'timestamp' => current_time('mysql')], ['%s', '%s', '%s', '%s', '%d', '%s']);
}
}
// redirect here
if(!empty($redirect_url)){
wp_safe_redirect($redirect_url, intval($status_code));
exit;
}
}
static function setup_log_scheduled(){
global $siteseo;
if(empty($siteseo->pro['email_notify'])){
return;
}
if(!wp_next_scheduled('siteseo_send_404_report_email')){
wp_schedule_event(time(), 'weekly', 'siteseo_send_404_report_email');
}
}
static function send_weekly_report(){
global $siteseo, $wpdb;
if(empty($siteseo->pro['email_notify'])){
return;
}
$site_name = get_bloginfo('name');
$site_url = get_bloginfo('url');
$admin_email = get_option('admin_email');
$user_email = !empty($siteseo->pro['send_email_to']) ? $siteseo->pro['send_email_to'] : $admin_email;
$admin_user = get_user_by('email', $admin_email);
$admin_name = $admin_user ? $admin_user->display_name : 'Administrator';
if(empty($user_email)){
return;
}
$top_errors = $wpdb->get_results("SELECT url, hit_count, COUNT(*) as count FROM `{$wpdb->prefix}siteseo_redirect_logs` GROUP BY url ORDER BY hit_count DESC LIMIT 10");
$latest_errors = $wpdb->get_results("SELECT * FROM `{$wpdb->prefix}siteseo_redirect_logs` ORDER BY `timestamp` DESC LIMIT 10");
$subject = sprintf('404 Error Report for %s - Week of %s', $site_name, gmdate('F j, Y'));
$content = sprintf(
'
Hello %s,
Here\'s your weekly 404 error report for %s. We\'ve identified several broken links that may need your attention.
Weekly 404 Error Report for %s
Below are the most frequent and recent 404 errors detected on your site:
Top 404 Errors
| URL |
Hit Count |
',
esc_html($admin_name),
esc_html($site_name),
esc_html($site_name)
);
foreach($top_errors as $error){
$content .= sprintf(
'
| %s |
%d |
',
esc_url($site_url . $error->url),
esc_html($error->url),
intval($error->hit_count)
);
}
$content .= '
Latest 404 Errors
| URL |
Timestamp |
';
foreach($latest_errors as $error){
$content .= sprintf(
'
| %s |
%s |
',
esc_url($site_url . $error->url),
esc_html($error->url),
esc_html(gmdate('F j, Y g:i a', strtotime($error->timestamp)))
);
}
$content .= '
This report was automatically generated on '.gmdate('F j, Y').'
Powered by SiteSEO
';
// Html
$headers = array(
'Content-Type: text/html; charset=UTF-8',
'From: SiteSEO <'.get_option('admin_email').'>'
);
// Send email
return wp_mail($user_email, $subject, $content, $headers);
}
static function siteseo_pro_handle_redirection(){
global $siteseo;
// Toggle
if(empty($siteseo->pro['toggle_state_redirect_monitoring'])){
return;
}
$request_uri = sanitize_url(wp_unslash($_SERVER['REQUEST_URI']));
$home_path = wp_parse_url(home_url(), PHP_URL_PATH);
$url_path_raw = str_replace($home_path, '', $request_uri);
$current_url = ltrim(rawurldecode($url_path_raw), '/');
$current_url_canonical = ltrim(untrailingslashit(rawurldecode($url_path_raw)), '/');
$redirects = get_option('siteseo_auto_redirection', []);
if(empty($redirects)){
return;
}
foreach($redirects as $id => $rule){
$sources = isset($rule['sources']) ? $rule['sources'] : [];
$destination = isset($rule['destination_url']) ? $rule['destination_url'] : '';
$type = isset($rule['redirection_type']) ? $rule['redirection_type'] : '301_redirect';
$destination_path = wp_parse_url($destination, PHP_URL_PATH) ? wp_parse_url($destination, PHP_URL_PATH) : '';
if($home_path && $home_path !== '/'){
$destination_path = str_replace($home_path, '', $destination_path);
}
$final_destination_canonical = ltrim(untrailingslashit(rawurldecode($destination_path)), '/');
if($current_url_canonical === $final_destination_canonical){
// We are already at the destination. Stop to prevent loop.
continue;
}
foreach($sources as $source){
$final_url = $source['url'];
$match_type = isset($source['match']) ? $source['match'] : 'exact';
if($match_type === 'regex'){
$url_to_match = $current_url;
} else{
$url_to_match = $current_url_canonical;
$final_url = untrailingslashit($final_url);
}
if(self::siteseo_check_url_match($url_to_match, $final_url, $match_type)){
$current_count = isset($redirects[$id]['hit_count']) ? (int) $redirects[$id]['hit_count'] : 0;
$redirects[$id]['hit_count'] = $current_count + 1;
update_option('siteseo_auto_redirection', $redirects);
self::siteseo_execute_redirect($destination, $type);
exit;
}
}
}
}
static function siteseo_check_url_match($current_url, $rule_url, $match_type){
switch($match_type){
case 'exact':
return $current_url === $rule_url;
case 'contains':
return (strpos($current_url, $rule_url) !== false);
case 'starts_with':
return (strpos($current_url, $rule_url) === 0);
case 'end_with':
$length = strlen($rule_url);
if($length === 0) return true;
return (substr($current_url, -$length) === $rule_url);
case 'regex':
return @preg_match('~' . str_replace('~', '\~', $rule_url) . '~u', $current_url);
default:
return false;
}
}
static function siteseo_execute_redirect($destination, $type){
$code = (int) str_replace('_redirect', '', $type);
if(in_array($code, [410, 451])){
// Send the header
status_header($code);
nocache_headers();
if($code === 410){
echo '
410 Gone
The resource requested is no longer available.
';
} elseif ($code === 451){
echo '
451 Unavailable For Legal Reasons
';
}
exit;
}
if(!in_array($code, [301, 302, 307, 410, 451])){
$code = 301;
}
$target = esc_url_raw($destination);
wp_safe_redirect($target, $code);
exit;
}
}PK ! XMLC C main/settings/license.phpnu [ ';
if(function_exists('siteseo_admin_header')){
siteseo_admin_header();
}
if(isset($_REQUEST['save_siteseo_pro_license'])){
self::save();
}
echo '
| ' . esc_html__('Siteseo Version', 'siteseo-pro') . ' |
' . (defined('SITESEO_PRO_VERSION') ? esc_html(SITESEO_PRO_VERSION) . ' (Pro Version)' : 'N/A') . ' |
| ' . esc_html__('Siteseo License', 'siteseo-pro') . ' |
';
if(!empty($siteseo->license)){
$expires = $siteseo->license['expires'];
$expires = substr($expires, 0, 4) . '/' . substr($expires, 4, 2) . '/' . substr($expires, 6);
echo ' License Status : ' . (empty($siteseo->license['status_txt']) ? 'N.A.' : wp_kses_post($siteseo->license['status_txt'])) . '
' . ($siteseo->license['expires'] <= gmdate('Ymd') ? 'License Expires : ' . esc_attr($expires) . '' : (empty($siteseo->license['has_plid']) ? 'License Expires : ' . esc_html($expires) : '')) . ' ';
}
echo ' |
| URL |
' . esc_url(get_site_url()) . ' |
| Path |
' . esc_html(ABSPATH) . ' |
| Server\'s IP Address |
' . esc_html($_SERVER['SERVER_ADDR']) . ' |
| .htaccess is writable |
' . (is_writable(ABSPATH . '.htaccess') ? 'Yes' : 'No') . ' |
';
}
static function save(){
global $siteseo, $lic_resp;
if(!wp_verify_nonce($_POST['siteseo_pro_license_nonce'], 'siteseo_pro_license')){
echo '
';
echo esc_html__('Security Check Failed', 'siteseo-pro');
echo '
';
return;
}
$license = sanitize_text_field(wp_unslash($_POST['siteseo_pro_license']));
if(empty($license)){
echo '
';
echo esc_html__('The license key was not submitted', 'siteseo-pro');
echo '
';
return;
}
siteseo_pro_load_license($license);
if(is_wp_error($lic_resp) || 200 !== wp_remote_retrieve_response_code($lic_resp)){
if(is_wp_error($lic_resp)){
echo '
';
echo esc_html($lic_resp->get_error_message());
echo '
';
return;
} else{
echo '
';
echo esc_html__('An error occurred, please try again. Response code: ', 'siteseo-pro') . esc_attr(wp_remote_retrieve_response_code($lic_resp));
echo '
';
return;
}
} else {
$tmp = json_decode(wp_remote_retrieve_body($lic_resp), true);
if(empty($tmp)){
echo '
';
echo esc_html__('The license key is invalid', 'siteseo-pro');
echo '
';
return;
}
echo'
'. esc_html__('Your license has been successfully activated!', 'siteseo-pro').'
';
}
}
}PK ! u0_) _) main/settings/pro.phpnu [ ';
if(function_exists('siteseo_admin_header')){
siteseo_admin_header();
}
$current_tab = isset($_GET['tab']) ? sanitize_key($_GET['tab']) : 'tab_siteseopro_woocommerce'; // Default tab
$structure_data_toggle = !empty($siteseo->pro['toggle_state_stru_data']) ? true : '';
$siteseopro_settings_tabs = [
'tab_siteseopro_woocommerce' => !defined('SITEPAD') ? esc_html__('WooCommerce', 'siteseo-pro') : esc_html__('Kkart', 'siteseo-pro'),
'tab_siteseopro_pagespeed_insights' => esc_html__('PageSpeed Insights', 'siteseo-pro'),
'tab_siteseopro_dublin_core' => esc_html__('Dublin Core', 'siteseo-pro'),
'tab_siteseopro_local_business' => esc_html__('Local Business', 'siteseo-pro'),
'tab_siteseopro_structured_data' => esc_html__('Structured Data Types', 'siteseo-pro'),
'tab_siteseopro_breadcrumbs' => esc_html__('Breadcrumbs','siteseo-pro'),
'tab_siteseopro_robots_txt' => esc_html__('robots.txt','siteseo-pro'),
'siteseopro_tab_redirect_monitor' => esc_html__('Redirections / 404 monitoring', 'siteseo-pro'),
];
if(!empty($structure_data_toggle)){
$siteseopro_settings_tabs['tab_auto_schema'] = esc_html__('Global Schema', 'siteseo-pro');
$siteseopro_settings_tabs['tab_podcast'] = esc_html__('Podcasts', 'siteseo-pro');
}
$siteseopro_settings_tabs['tab_llm_txt'] = esc_html__('LLMs txt', 'siteseo-pro');
if (!defined('SITEPAD')) {
$siteseopro_settings_tabs['tab_siteseopro_easydigital_downloads'] = esc_html__('Easy Digital Downloads', 'siteseo-pro');
$siteseopro_settings_tabs['tab_siteseopro_htaccess'] = esc_html__('htaccess','siteseo-pro');
}
$siteseopro_settings_tabs['tab_seo_alerts'] = esc_html__('SEO Alerts', 'siteseo-pro');
$siteseopro_settings_tabs['tab_siteseopro_external_links'] = esc_html__('External Links Manager', 'siteseo-pro');
echo'
';
}
static function woocommerce_tab(){
global $siteseo;
if(!empty($_POST['submit'])){
self::save_settings();
}
$options = $siteseo->pro;
// Check if settings are enable
$cart_page = !empty($options['woocommerce_cart_page_no_index']);
$checkout_page = !empty($options['woocommerce_checkout_page_no_index']);
$account_page = !empty($options['woocommerce_customer_account_page_no_index']);
$woo_og_price = !empty($options['woocommerce_product_og_price']);
$woo_og_currency = !empty($options['woocommerce_product_og_currency']);
$woo_meta_generator = !empty($options['woocommerce_meta_generator']);
$schema_output = !empty($options['woocommerce_schema_output']);
$schema_breadcrumbs = !empty($options['woocommerce_schema_breadcrumbs_output']);
$toggle_state_woocommerce = !empty($options['toggle_state_woocommerce']) ? $options['toggle_state_woocommerce'] : '';
$nonce = wp_create_nonce('siteseo_pro_toggle_nonce');
echo''.esc_html__('Check your site performance with Google PageSpeed Insights.', 'siteseo-pro').'
'.esc_html__('Learn how your site has performed, based on data from your actual users around the world.', 'siteseo-pro').'
';
$page_speed = get_option('siteseo_pro_page_speed', []);
if(!empty($page_speed['mobile']) && !empty($page_speed['desktop'])){
PageSpeed::analysis();
}
echo'