public function RepositoryLogin()
{
list($get, $post) = func_get_args();
if (isset($get['repository_id'])) {
$this->repo_model = WPRC_Loader::getModel('repositories');
$this->repository = $this->repo_model->getRepositoryByField('id', (int) $get['repository_id']);
if (empty($get['submit'])) {
//$nonce=$get['_wpnonce'];
if (!array_key_exists('_wpnonce', $get) || !wp_verify_nonce($get['_wpnonce'], 'installer-login-link')) {
die("Security check");
}
self::render();
} else {
//$nonce=$get['_wpnonce'];
if (!array_key_exists('_wpnonce', $get) || !wp_verify_nonce($get['_wpnonce'], 'installer-login-form')) {
die("Security check");
}
if (!array_key_exists('repository_id', $get) || !array_key_exists('username', $get) || !array_key_exists('password', $get)) {
die;
}
$login = $this->repo_model->testLogin($get['repository_id'], $get['username'], $get['password'], isset($get['_plain']) && $get['_plain'] == 'true' ? true : false);
if ($login != false && empty($login['error'])) {
echo json_encode(array('success' => 1, 'message' => $login['message']));
} else {
echo json_encode(array('success' => 0, 'message' => $login['message']));
}
exit;
}
}
}
public function skipUninstallReport($get, $post)
{
if (isset($post['uninstall_no_more_reports'])) {
$model_settings = WPRC_Loader::getModel('settings');
$model_settings->save(array());
}
// redirect to the deactivation page
$this->redirectToDeactivationPage();
}
/**
* Prepare report data from the post data
*
* @param array $post_data raw data
*
* @return array report
*/
public function prepareRequest(array $post_data)
{
// get key and type of extension that need to be checked
if (!array_key_exists('check_extension_name', $post_data) || !array_key_exists('check_extension_type', $post_data)) {
return false;
}
$check_extension_name = $post_data['check_extension_name'];
$check_extension_type = $post_data['check_extension_type'];
$check_extension_repository_url = $post_data['check_extension_repository_url'];
$check_extension_version = $post_data['check_extension_version'];
$check_extension_slug = $post_data['check_extension_slug'];
$extension_model = WPRC_Loader::getModel('extensions');
$extensions_tree = $extension_model->getFullExtensionsTree();
$extensions_tree['themes'] = $extension_model->changeExtensionsKey($extensions_tree['themes'], 'Name');
$typekeys = $extension_model->getExtensionTypeKeys();
$activetypekeys = $extension_model->getActiveExtensionTypeKeys();
// ---------- left extensions ------------
if (array_key_exists($check_extension_type, $extensions_tree) && is_array($check_extension)) {
$check_extension = $extensions_tree[$check_extension_type][$check_extension_name];
$left_extension = $this->prepareExtensionInfo($check_extension_name, $check_extension_type, $check_extension);
} else {
$left_extension = array('name' => $check_extension_name, 'type' => $check_extension_type, 'repository_url' => $check_extension_repository_url, 'version' => $check_extension_version, 'slug' => $check_extension_slug);
}
$left_extensions = array($check_extension_name => $left_extension);
// ---------- right extensions -----------
$active_extensions = $extension_model->getActiveExtensions();
// cycle on each extension type
if (count($active_extensions) == 0) {
return false;
}
$right_extensions = array();
foreach ($active_extensions as $extension_type => $extensions) {
for ($i = 0; $i < count($extensions); $i++) {
$key = $activetypekeys[$extension_type];
//$key=$typekeys[$extension_type];
$extension = $extension_model->findExtensionwithKey($extensions_tree, $extension_type, $key, $extensions[$i]);
if ($extension === false) {
continue;
}
//if (!isset($extensions_tree[$extension_type][$extensions[$i]])) continue;
//$extension = $extensions_tree[$extension_type][$extensions[$i]];
$right_extensions[$extension['Name']] = $this->prepareExtensionInfo($extensions[$i], $extension_type, $extension);
}
}
// prepare report data
$report_data = array('left_extensions' => $left_extensions, 'right_extensions' => $right_extensions);
$creport = $this->formRequestStructure($report_data);
//file_put_contents(WPRC_PLUGIN_PATH.'/debug_comp.txt',print_r($report_data,true),FILE_APPEND);
return $creport;
}
/**
* Save wprc settings
*
* @param array $_GET array
* @param array $_POST array
*/
public function save($get, $post)
{
$settings = array();
if (!array_key_exists('_wpnonce', $post) || !wp_verify_nonce($post['_wpnonce'], 'installer-settings-form')) {
die("Security check");
}
if (array_key_exists('settings', $post) && is_array($post['settings'])) {
$settings = $post['settings'];
}
$settings_model = WPRC_Loader::getModel('settings');
$res = $settings_model->save($settings);
$flag = 'failure';
if ($res) {
$flag = 'success';
}
$this->redirect_to_index($flag);
}
/**
* Form arguments for plugin_api function
*
* @param mixed arguments array
* @param string action
*/
public function extensionsApiArgs($args, $action)
{
switch ($action) {
case 'query_plugins':
$args = $this->extensionApiArgsQueryExtensions($args);
if (!isset($args->repositories)) {
if (isset($_REQUEST['repos']) && is_array($_REQUEST['repos'])) {
$args->repositories = (array) $_REQUEST['repos'];
} else {
$rm = WPRC_Loader::getModel('repositories');
$repos = $rm->getRepositoriesIds('enabled_repositories', 'plugins');
$args->repositories = (array) $repos;
}
}
break;
case 'plugin_information':
if (!isset($args->repositories)) {
if (array_key_exists('repository_id', $_REQUEST) && !empty($_REQUEST['repository_id'])) {
$args->repositories = array($_REQUEST['repository_id']);
} else {
$rm = WPRC_Loader::getModel('repositories');
if (isset($_GET['plugin'])) {
$repos = $rm->getRepositoryByExtension($_GET['plugin']);
}
if (isset($repos) && $repos !== false && count($repos) > 0) {
$args->repositories = array($repos[0]['id']);
} else {
$repo = $rm->getRepositoryByField('repository_endpoint_url', WPRC_WP_PLUGINS_REPO);
if (isset($repo) && $repo !== false) {
$args->repositories = array($repo->id);
}
}
}
}
//$args->slug=$_GET['plugin'];
break;
case 'hot_tags':
$rm = WPRC_Loader::getModel('repositories');
$args->repositories = $rm->getRepositoriesIds('enabled_repositories', 'plugins');
break;
}
$args = apply_filters('wprc_plugins_api_args_' . $action, $args);
return $args;
}
/**
* Form arguments for extensions_api function
*
* @param mixed arguments array
* @param string action
*/
public function extensionsApiArgs($args, $action)
{
switch ($action) {
case 'query_themes':
$args = $this->extensionApiArgsQueryExtensions($args, WPRC_THEMES_API_QUERY_THEMES_PER_PAGE);
if (!isset($args->repositories)) {
if (isset($_REQUEST['repos']) && is_array($_REQUEST['repos'])) {
$args->repositories = (array) $_REQUEST['repos'];
} else {
$rm = WPRC_Loader::getModel('repositories');
$repos = $rm->getRepositoriesIds('enabled_repositories', 'themes');
$args->repositories = (array) $repos;
}
}
break;
case 'theme_information':
if (!isset($args->repositories)) {
if (array_key_exists('repository_id', $_REQUEST) && !empty($_REQUEST['repository_id'])) {
$args->repositories = array($_REQUEST['repository_id']);
} else {
$rm = WPRC_Loader::getModel('repositories');
$repos = $rm->getRepositoryByExtension($_GET['theme']);
if (isset($repos) && $repos !== false && count($repos) > 0) {
$args->repositories = array($repos[0]['id']);
} else {
$repo = $rm->getRepositoryByField('repository_endpoint_url', WPRC_WP_THEMES_REPO);
if (isset($repo) && $repo !== false) {
$args->repositories = array($repo->id);
}
}
}
}
break;
case 'feature_list':
$rm = WPRC_Loader::getModel('repositories');
$args->repositories = $rm->getRepositoriesIds('enabled_repositories', 'themes');
break;
}
$args = apply_filters('wprc_themes_api_args_' . $action, $args);
return $args;
}
function installer_repositories_page_tabs($current = 'default')
{
if (isset($_GET['rtab'])) {
$current = $_GET['rtab'];
}
$repo_model = WPRC_Loader::getModel('repositories');
$not_delete_counts = count($repo_model->getAllRepositoriesNotDeleted());
$delete_counts = count($repo_model->getAllRepositoriesDeleted());
$tabs = array('default' => sprintf(__('Active repositories (%s)', 'installer'), $not_delete_counts), 'trash' => sprintf(__('Inactive repositories (%s)', 'installer'), $delete_counts));
$links = array();
foreach ($tabs as $tab => $name) {
if ($tab == $current) {
$links[] = '<a class="nav-tab nav-tab-active" href="?page=installer/pages/repositories.php&rtab=' . $tab . '">' . $name . '</a>';
} else {
$links[] = '<a class="nav-tab" href="?page=installer/pages/repositories.php&rtab=' . $tab . '">' . $name . '</a>';
}
}
echo '<div id="icon-repositories-installer" class="icon32"><br></div>';
echo '<h2 class="nav-tab-wrapper">';
foreach ($links as $link) {
echo $link;
}
echo '</h2>';
}
public function prepare_items()
{
$tab = $this->get_current_tab();
// replace search results tab only
if ($tab != 'search') {
parent::prepare_items();
exit;
}
include_once ABSPATH . 'wp-admin/includes/theme-install.php';
global $tabs, $tab, $paged, $type, $term, $theme_field_defaults;
wp_reset_vars(array('tab'));
$paged = $this->get_pagenum();
$repositories_ids = array();
if (!isset($_GET['repos'])) {
$rm = WPRC_Loader::getModel('repositories');
$repos = $rm->getRepositoriesIds('enabled_repositories', 'themes');
$repos_number = count($repos);
} else {
$repos_number = count($_GET['repos']);
}
$per_page = WPRC_THEMES_API_QUERY_THEMES_PER_PAGE;
// These are the tabs which are shown on the page,
$tabs = array();
$tabs['dashboard'] = __('Search', 'installer');
if ('search' == $tab) {
$tabs['search'] = __('Search Results', 'installer');
}
$tabs['upload'] = __('Upload', 'installer');
$tabs['featured'] = _x('Featured', 'Theme Installer', 'installer');
//$tabs['popular'] = _x( 'Popular','Theme Installer' );
$tabs['new'] = _x('Newest', 'Theme Installer', 'installer');
$tabs['updated'] = _x('Recently Updated', 'Theme Installer', 'installer');
$nonmenu_tabs = array('theme-information');
// Valid actions to perform which do not have a Menu item.
$tabs = apply_filters('install_themes_tabs', $tabs);
$nonmenu_tabs = apply_filters('install_themes_nonmenu_tabs', $nonmenu_tabs);
// If a non-valid menu tab has been selected, And its not a non-menu action.
if (empty($tab) || !isset($tabs[$tab]) && !in_array($tab, (array) $nonmenu_tabs)) {
$tab = key($tabs);
}
$args = array('page' => $paged, 'per_page' => $per_page, 'fields' => $theme_field_defaults);
switch ($tab) {
case 'search':
$type = isset($_REQUEST['type']) ? stripslashes($_REQUEST['type']) : '';
$term = isset($_REQUEST['s']) ? stripslashes($_REQUEST['s']) : '';
switch ($type) {
case 'tag':
$terms = explode(',', $term);
$terms = array_map('trim', $terms);
$terms = array_map('sanitize_title_with_dashes', $terms);
$args['tag'] = $terms;
break;
case 'author':
$args['author'] = $term;
break;
case 'term':
// make search term default in case type does not exist (wp34)
// make search term default in case type does not exist (wp34)
default:
$args['search'] = $term;
break;
}
if (isset($_REQUEST['features']) && (is_array($_REQUEST['features']) || !empty($_REQUEST['features']))) {
$terms = $_REQUEST['features'];
$terms = array_map('trim', $terms);
$terms = array_map('sanitize_title_with_dashes', $terms);
$args['tag'] = $terms;
$_REQUEST['s'] = implode(',', $terms);
$_REQUEST['type'] = 'tag';
//$args['type'] = 'tag';
//$args['search'] = $_REQUEST['search'];
}
add_action('install_themes_table_header', 'install_theme_search_form');
break;
case 'featured':
//case 'popular':
//case 'popular':
case 'new':
case 'updated':
$args['browse'] = $tab;
break;
default:
$args = false;
}
if (!$args) {
return;
}
$api = themes_api('query_themes', $args);
if (is_wp_error($api)) {
wp_die($api->get_error_message() . '</p> <p><a href="#" onclick="document.location.reload(); return false;">' . __('Try again', 'installer') . '</a>');
}
$repo_model = WPRC_Loader::getModel('repositories');
if (isset($_GET['repos'])) {
$repos = $_GET['repos'];
} else {
$rm = WPRC_Loader::getModel('repositories');
$repos = $rm->getRepositoriesIds('enabled_repositories', 'themes');
}
// Filtering by repository if is the case...
$this->repositories_tabs = array();
// Do we need tabs?
$this->results_per_repo = $api->results_per_repo;
$repo_results_gt_zero = 0;
foreach ($this->results_per_repo as $repo_results) {
if ($repo_results['results'] > 0) {
$repo_results_gt_zero++;
}
}
if ($api->info['results'] > WPRC_THEMES_API_QUERY_THEMES_PER_PAGE && count($repos) > 1 && $repo_results_gt_zero > 1) {
// We have too many results => we have to tab the results
// Ordering repos by ID so Wordpress.org plugins wil appear most of the time at first place
sort($repos);
$tmp = array();
foreach ($repos as $repo_id) {
if (isset($this->results_per_repo[$repo_id]) && $this->results_per_repo[$repo_id]['results'] == 0) {
continue;
}
// We need the name of the repo
$repo_info = $repo_model->getRepositoryByField('id', $repo_id);
if ($repo_info) {
$this->repositories_tabs[] = array('id' => $repo_info->id, 'name' => $repo_info->repository_name);
}
}
$filtered_api = new stdClass();
$filtered_api->info['results'] = $api->info['results'];
$filtered_api->info['page'] = $api->info['page'];
$filtered_api->themes = array();
// If we are currently on a tab, we'll show only those results
if (is_array($this->repositories_tabs) && count($this->repositories_tabs) > 0) {
$current_repo = isset($_GET['repo-tab']) ? $_GET['repo-tab'] : $this->repositories_tabs[0]['id'];
}
foreach ($api->themes as $theme) {
if ($theme->repository_id == $current_repo) {
$filtered_api->themes[] = $theme;
} else {
$filtered_api->info['results']--;
}
}
$filtered_api->info['results'] = $this->results_per_repo[$current_repo]['results'];
$filtered_api->info['total_pages'] = (int) ceil($filtered_api->info['results'] / WPRC_THEMES_API_QUERY_THEMES_PER_PAGE);
} else {
$filtered_api = $api;
}
$this->items = $filtered_api->themes;
//$this->items = $api;
$this->set_pagination_args(array('total_items' => $filtered_api->info['results'], 'per_page' => $per_page));
}
<?php
if (!defined('ABSPATH')) {
die('Security check');
}
if (!current_user_can('manage_options')) {
die('Access Denied');
}
// include needed files
WPRC_Loader::includeWPListTable();
$wp_list_table = WPRC_Loader::getListTable('deleted-repositories');
//Handle bulk deletes
$doaction = $wp_list_table->current_action();
if ($doaction) {
$repository_model = WPRC_Loader::getModel('repositories');
}
$url = admin_url() . 'admin.php?page=' . WPRC_PLUGIN_FOLDER . '/pages/deleted-repositories.php';
if ($doaction && isset($_REQUEST['checked'])) {
check_admin_referer('bulk-list-deleted-repositories');
if ('undelete' == $doaction) {
$bulklinks = (array) $_REQUEST['checked'];
foreach ($bulklinks as $id) {
$repository_id = (int) $id;
$repository_model->softundeleteRepository($repository_id);
}
}
} elseif ($doaction) {
switch ($doaction) {
case 'undelete':
if (!isset($_REQUEST['id'])) {
break;
/**
* Prepare uninstall data for the sending
*
* @param array array of posted data
*
* @return array associative array of specified format
*/
public function prepareRequest(array $post_array)
{
if (!array_key_exists('extension_keys', $post_array) || !array_key_exists('extension_type', $post_array) || !array_key_exists('uninstall_reason_code', $post_array)) {
return false;
}
if (!is_array($post_array['extension_keys'])) {
return false;
}
$extension_keys = $post_array['extension_keys'];
// disable request sending if several plugins were deactivated
if (count($extension_keys) > 1) {
//return false;
}
$extension_type = preg_match('/^(plugin|theme)$/', $post_array['extension_type']) ? $post_array['extension_type'] : '';
// set uninstall reason code
$uninstall_reason_code = $post_array['uninstall_reason_code'];
if (array_key_exists('uninstall_reason_code_child', $post_array) && $post_array['uninstall_reason_code_child'] != '') {
$uninstall_reason_code .= '-' . $post_array['uninstall_reason_code_child'];
}
// set uninstall reason description
$uninstall_reason_description = $this->filterText($post_array['uninstall_reason_description']);
// set uninstall reason items -------------------------------
$problem_array_name = '';
$unistall_reason_items_type = '';
switch ($uninstall_reason_code) {
case '3-1':
$problem_array_name = 'problem_themes';
$unistall_reason_items_type = 'theme';
break;
case '3-2':
$problem_array_name = 'problem_plugins';
$unistall_reason_items_type = 'plugin';
break;
}
$uninstall_reason_items_names = array();
$uninstall_reason_items = array();
if (isset($problem_array_name) && array_key_exists($problem_array_name, $post_array)) {
if (is_array($post_array[$problem_array_name]) && count($post_array[$problem_array_name]) > 0) {
$uninstall_reason_items_names = $post_array[$problem_array_name];
}
}
// get all extension data
$ext_model = WPRC_Loader::getModel('extensions');
$all_extensions = $ext_model->getFullExtensionsTree();
$all_extensions['themes'] = $ext_model->changeExtensionsKey($all_extensions['themes'], 'Name');
// form plural extension type name
$unistall_reason_items_type_plural = $unistall_reason_items_type . 's';
// set all information for uninstall reason items
$extension_path = '';
for ($i = 0; $i < count($uninstall_reason_items_names); $i++) {
$extension = $all_extensions[$unistall_reason_items_type_plural][$uninstall_reason_items_names[$i]];
if ($unistall_reason_items_type == 'plugin') {
$extension_path = $uninstall_reason_items_names[$i];
}
$uninstall_reason_items[$uninstall_reason_items_names[$i]] = array('name' => $extension['Name'], 'type' => $unistall_reason_items_type, 'path' => $extension_path, 'version' => $extension['Version'], 'slug' => $extension['extension_slug'], 'repository_url' => $extension['repository_endpoint_url']);
}
// set report data array ------------------------------------
$extensions = array();
// form plural extension type name
$extension_type_plural = $extension_type . 's';
$extension_path = '';
for ($i = 0; $i < count($extension_keys); $i++) {
if (!isset($all_extensions[$extension_type_plural][$extension_keys[$i]])) {
continue;
}
$extension = $all_extensions[$extension_type_plural][$extension_keys[$i]];
if ($extension_type == 'plugin') {
$extension_path = $extension_keys[$i];
}
$slug = '';
if (array_key_exists('extension_slug', $extension)) {
$slug = $extension['extension_slug'];
}
$repository_endpoint_url = '';
if (array_key_exists('repository_endpoint_url', $extension)) {
$repository_endpoint_url = $extension['repository_endpoint_url'];
}
$extensions[$extension_keys[$i]] = array('name' => $extension['Name'], 'type' => $extension_type, 'path' => $extension_path, 'version' => $extension['Version'], 'slug' => $slug, 'repository_url' => $repository_endpoint_url);
}
$report_data = array('extensions' => $extensions, 'uninstall_reason_code' => $uninstall_reason_code, 'uninstall_reason_description' => $uninstall_reason_description, 'uninstall_reason_items' => $uninstall_reason_items);
$report = $this->formRequestStructure($report_data);
//file_put_contents(WPRC_PLUGIN_PATH.'/debug_uninstall.txt',print_r($report_data,true),FILE_APPEND);
return $report;
}
/**
* Reset theme timer
*
* This method should be called on 'switch_theme' hook
*/
public function resetThemeTimer()
{
$extension_model = WPRC_Loader::getModel('extensions');
$swithed_theme = $extension_model->getSwitchedThemeName();
WPRC_Loader::includeExtensionTimer();
WPRC_ExtensionTimer::deleteTimer($swithed_theme);
}
public static function wprc_update_extensions_maps()
{
WPRC_Loader::getRepositoryConnector();
$url = WPRC_UPDATE_REPOS_URL;
$timestamp = 0;
$current = get_transient('wprc_update_extensions_maps');
if (isset($current) && $current != false) {
if (isset($current->last_checked)) {
$timestamp = $current->last_checked;
}
}
$args = array('action' => 'extensions_map', 'request' => array('timestamp' => $timestamp));
// get existing extensions list
$em = WPRC_Loader::getModel('extensions');
$ext = $em->getFullExtensionsTree();
$extensions = array();
$ext_map = array();
foreach (array('plugins', 'themes') as $etype) {
$extensions[$etype] = array();
foreach ($ext[$etype] as $exte) {
$tmp = (array) $exte;
if (isset($tmp['Name'])) {
$extensions[$etype][] = $tmp['Name'];
$ext_map[$etype][$tmp['Name']] = $tmp;
} elseif (isset($tmp['name'])) {
$extensions[$etype][] = $tmp['name'];
$ext_map[$etype][$tmp['name']] = $tmp;
}
}
$args['request'][$etype] = $extensions[$etype];
unset($extensions[$etype]);
unset($ext[$etype]);
}
// send request for info
$response = WPRC_RepositoryConnector::sendRequest('post', $url, $args);
if (isset($response) && $response != false && !is_wp_error($response)) {
if (isset($response->result)) {
if ($response->result == 'up_to_date') {
$current = new stdClass();
$current->last_checked = time();
$current->count = 0;
set_transient('wprc_update_extensions_maps', $current);
return false;
} else {
$repo_model = WPRC_Loader::getModel('repositories');
$installed_repos = $repo_model->getAllRepositories();
$repo_map = array();
foreach ($installed_repos as $repo) {
$repo_map[$repo->repository_endpoint_url] = $repo->id;
}
unset($installed_repos);
$ext_count = 0;
foreach (array('plugins', 'themes') as $etype) {
if (isset($response->{$etype})) {
$tmp = (array) $response->{$etype};
foreach ($tmp as $name => $einfo) {
$einfo = (array) $einfo;
if (isset($ext_map[$etype]) && isset($ext_map[$etype][$name])) {
if (isset($ext_map[$etype][$name]['repository_id'])) {
if (isset($repo_map[$einfo['repository_url']])) {
$type_id = $einfo['extension_type'] == 1 ? 1 : 2;
$data = array('extension_name' => $einfo['extension_name'], 'extension_type_id' => $type_id, 'extension_slug' => $einfo['extension_slug'], 'extension_path' => $einfo['extension_path'], 'repository_id' => $repo_map[$einfo['repository_url']], 'extension_was_installed' => 1);
$format = array('%s', '%d', '%s', '%s', '%d', '%d');
$where = array('extension_name' => $name);
$where_format = array('%s');
$em->updateExtension($data, $where, $format, $where_format);
$ext_count++;
}
} else {
if (isset($repo_map[$einfo['repository_url']])) {
$type_name = $einfo['extension_type'] == 1 ? 'plugins' : 'themes';
$em->addExtensionInstalled($name, $einfo['extension_slug'], $einfo['extension_path'], $type_name, $repo_map[$einfo['repository_url']], 1);
$ext_count++;
}
}
}
}
}
}
$current = new stdClass();
$current->last_checked = time();
$current->count = $ext_count;
set_transient('wprc_update_extensions_maps', $current);
return $ext_count;
}
}
}
}
}
$result = '';
$result_msg = '';
if (array_key_exists('result', $_GET)) {
$result = $_GET['result'];
switch ($result) {
case 'success':
$result_msg = __('Settings are saved', 'installer');
break;
case 'failure':
// $result_msg = __('Settings are not saved. Change a values of the settings please', 'installer');
$result_msg = __('Settings are saved', 'installer');
break;
}
}
$settings_model = WPRC_Loader::getModel('settings');
$settings = $settings_model->getSettings();
$show_msg = '';
if (array_key_exists('warning', $_GET)) {
$show_msg = $_GET['warning'];
}
$msg = '';
switch ($show_msg) {
case 'https_not_provided':
$msg = __('HTTPS is not provided by server. Please connect with your site administrator', 'installer');
break;
}
?>
<div class="wrap">
<h2><?php
public function clearLoginInfo($get, $post)
{
$msg = sprintf('Repositories clear login enter');
WPRC_Functions::log($msg, 'controller', 'controller.log');
if (isset($get['repository_id'])) {
//$nonce=$get['_wpnonce'];
if (!array_key_exists('_wpnonce', $get) || !wp_verify_nonce($get['_wpnonce'], 'installer-clear-link')) {
die("Security check");
}
if (!array_key_exists('repository_id', $get)) {
die;
}
$model = WPRC_Loader::getModel('repositories');
$result = $model->clearLogin(intval($get['repository_id']));
if ($result) {
// clear cache
$rmcache = WPRC_Loader::getModel('cached-requests');
$rmcache->cleanCache();
// clear updates
delete_site_transient('update_themes');
delete_site_transient('update_plugins');
}
echo json_encode(array('result' => $result));
}
$msg = sprintf('Repositories clear login completed');
WPRC_Functions::log($msg, 'controller', 'controller.log');
exit;
}
/**
* Search plugins in multiple repositories
* This method replaces 'plugins_api' and 'themes_api' function
*/
public function extensionsApi($state, $action, $args, $extension_type)
{
// default wp behaviour for tabs other than search
//if ($action=='hot_tags') return false;
if (isset($_GET['tab'])) {
if ($_GET['tab'] != 'dashboard' && $_GET['tab'] != 'search' && $_GET['tab'] != 'plugin-information' && $_GET['tab'] != 'theme-information') {
return false;
}
}
$rauth = true;
$rpass = '';
$ruser = '';
if (isset($_GET['repository_id']) && isset($_GET['user']) && isset($_GET['pass']) && ($action == 'plugin_information' || $action == 'theme_information')) {
$rm = WPRC_Loader::getModel('repositories');
$rid = $_GET['repository_id'];
$repository = $rm->getRepository($rid);
$ruser = rawurldecode($_GET['user']);
$rsalt = $repository->repository_authsalt;
$rpass = rawurldecode($_GET['pass']);
//WPRC_Security::decrypt($repository->repository_authsalt,rawurldecode($_GET['pass']));
$login = $rm->testLogin($rid, $ruser, $rpass);
if ($login != false && empty($login['error'])) {
$rauth = true;
} else {
$rauth = false;
}
}
$repositories_ids = array();
if (isset($args->repositories)) {
$repositories_ids = $args->repositories;
unset($args->repositories);
}
$rm = WPRC_Loader::getModel('repositories');
$repos = $rm->getRepositoriesByIds($repositories_ids);
$results = array();
// Remade per_page parameters in order to get consistent pagination
$per_page = 0;
$repos_number = count($repos);
if ($action == 'query_plugins') {
$per_page = WPRC_PLUGINS_API_QUERY_PLUGINS_PER_PAGE;
} elseif ($action == 'query_themes') {
$per_page = WPRC_THEMES_API_QUERY_THEMES_PER_PAGE;
}
$results_per_repo = array();
for ($i = 0; $i < $repos_number; $i++) {
$res = false;
$server_url = $repos[$i]->repository_endpoint_url;
$repository_name = $repos[$i]->repository_name;
$repository_username = $repos[$i]->repository_username;
$repository_password = $repos[$i]->repository_password;
$salt = $repos[$i]->repository_authsalt;
$rid = $repos[$i]->id;
$body_array = array('action' => $action);
if ($repository_username != '' && $repository_password != '') {
/*$args->username = $repository_username;
$args->password = $repository_password;*/
//$send_password=WPRC_Security::encrypt($salt,$repository_password);
$body_array['auth'] = array('user' => $repository_username, 'pass' => $repository_password, 'salt' => $salt);
//$body_array['auth'] = array('user'=>$repository_username,'pass'=>$repository_password,'salt'=>$salt);
} else {
unset($args->username);
unset($args->password);
}
$request_array = $args;
$request_array->per_page = $per_page;
$body_array['request'] = serialize($args);
if (isset($args->slug)) {
$body_array['slug'] = $args->slug;
}
// debug log
$reqargs = $body_array;
if (isset($reqargs['auth'])) {
$reqargs['auth'] = 'AUTH info';
}
$msg = sprintf("API Request to %s, request args: %s", $server_url, print_r($reqargs, true));
WPRC_Functions::log($msg, 'api', 'api.log');
unset($reqargs);
$cached_request_results = apply_filters('wprc_extensions_api_before_each_repository', $server_url, $action, $args);
if ($cached_request_results) {
$results[$server_url] = $cached_request_results;
// log
$msg = sprintf("API Request to %s, using cached results", $server_url);
WPRC_Functions::log($msg, 'api', 'api.log');
continue;
}
$request = wp_remote_post($server_url, array('timeout' => 15, 'body' => $body_array));
// log
$msg = sprintf("API Request to %s, timeout: %d, response: %s", $server_url, 15, print_r($request, true));
WPRC_Functions::log($msg, 'api', 'api.log');
if (is_wp_error($request)) {
$res = new WP_Error('extensions_api_failed', __('An unexpected HTTP Error occurred during the API request.', 'installer'), $request->get_error_message());
// log
$msg = sprintf("API Request to %s, response error: %s", $server_url, print_r($request->get_error_message(), true));
WPRC_Functions::log($msg, 'api', 'api.log');
} else {
$request_body = wp_remote_retrieve_body($request);
if (is_serialized($request_body)) {
$res = @unserialize($request_body);
}
if (false === $res) {
$res = new WP_Error('extensions_api_failed', __('An unknown error occurred.', 'installer'), wp_remote_retrieve_body($request));
// log
$msg = sprintf("API Request to %s, unknown error in response body: %s", $server_url, print_r($request_body, true));
WPRC_Functions::log($msg, 'api', 'api.log');
} else {
if (is_object($res) && isset($res->error)) {
$res = new WP_Error('extensions_api_failed', $res->error, wp_remote_retrieve_body($request));
// log
$msg = sprintf("API Request to %s, action not implemented error: %s", $server_url, print_r($res, true));
WPRC_Functions::log($msg, 'api', 'api.log');
} else {
if (is_array($res) && isset($res['error'])) {
$res = new WP_Error('extensions_api_failed', $res['error'], wp_remote_retrieve_body($request));
// log
$msg = sprintf("API Request to %s, action not implemented error: %s", $server_url, print_r($res, true));
WPRC_Functions::log($msg, 'api', 'api.log');
} else {
// add some custom info onto the results (like repository salt etc..)
if ($action == 'query_plugins') {
foreach ($res->plugins as $key => $extension) {
$res->plugins[$key]->salt = $salt;
$res->plugins[$key]->repository_id = $rid;
// strip non-serializable characters
$res->plugins[$key]->description = preg_replace('/[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x80-\\xFF]/u', '', $res->plugins[$key]->description);
}
} elseif ($action == 'query_themes') {
foreach ($res->themes as $key => $extension) {
$res->themes[$key]->salt = $salt;
$res->themes[$key]->repository_id = $rid;
// strip non-serializable characters
$res->themes[$key]->description = preg_replace('/[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x80-\\xFF]/u', '', $res->themes[$key]->description);
}
} elseif ($action == 'plugin_information' || $action == 'theme_information') {
if (is_object($res)) {
$res->rauth = $rauth;
$res->pass = $rpass;
$res->user = $ruser;
$res->salt = $salt;
$res->repository_id = $rid;
}
}
}
}
}
}
$cached_them = apply_filters('wprc_extensions_api_after_each_repository', $server_url, $action, $args, $res);
// log
$msg = sprintf("API Request to %s, results cached: %s", $server_url, $cached_them == false ? 'NO' : 'YES');
WPRC_Functions::log($msg, 'api', 'api.log');
// set source
$results[$server_url] = $res;
}
$general_results = new stdClass();
$general_results->results = $results;
return $general_results;
}
public static function wprc_plugin_update_row($file, $plugin_data)
{
$current = get_site_transient('update_plugins');
if (!isset($current->response[$file])) {
return false;
}
$r = $current->response[$file];
$plugins_allowedtags = array('a' => array('href' => array(), 'title' => array()), 'abbr' => array('title' => array()), 'acronym' => array('title' => array()), 'code' => array(), 'em' => array(), 'strong' => array());
$plugin_name = wp_kses($plugin_data['Name'], $plugins_allowedtags);
if (isset($r->repository_id)) {
$details_url = self_admin_url('plugin-install.php?tab=plugin-information&repository_id=' . $r->repository_id . '&plugin=' . $r->slug . '§ion=changelog&TB_iframe=true&width=640&height=484');
} else {
$details_url = self_admin_url('plugin-install.php?tab=plugin-information&plugin=' . $r->slug . '§ion=changelog&TB_iframe=true&width=640&height=484');
}
$wp_list_table = _get_list_table('WP_Plugins_List_Table');
if (is_network_admin() || !is_multisite()) {
echo '<tr class="plugin-update-tr"><td colspan="' . $wp_list_table->get_column_count() . '" class="plugin-update colspanchange"><div class="update-message">';
if (!current_user_can('update_plugins')) {
printf(__('There is a new version of %1$s available. <a href="%2$s" class="thickbox" title="%3$s">View version %4$s details</a>.', 'installer'), $plugin_name, esc_url($details_url), esc_attr($plugin_name), $r->new_version);
} else {
if (empty($r->package)) {
$ext_model = WPRC_Loader::getModel('extensions');
$repository = $ext_model->get_extension_repository($file);
$nonce_login = wp_create_nonce('installer-login-link');
if (!empty($repository)) {
printf(__('There is a new version of %1$s available. <a href="%2$s" class="thickbox" title="%3$s">View version %4$s details</a>. To update this plugin, first <a class="thickbox" href="%5$s">log-in to %6$s</a>.', 'installer'), $plugin_name, esc_url($details_url), esc_attr($plugin_name), $r->new_version, admin_url('admin.php?wprc_c=repository-login&wprc_action=RepositoryLogin&repository_id=' . $repository->id . '&_wpnonce=' . $nonce_login), $repository->repository_name);
} else {
printf(__('There is a new version of %1$s available. <a href="%2$s" class="thickbox" title="%3$s">View version %4$s details</a>. <em>Automatic update is unavailable for this plugin.</em>', 'installer'), $plugin_name, esc_url($details_url), esc_attr($plugin_name), $r->new_version);
}
} else {
printf(__('There is a new version of %1$s available. <a href="%2$s" class="thickbox" title="%3$s">View version %4$s details</a> or <a href="%5$s">update now</a>.', 'installer'), $plugin_name, esc_url($details_url), esc_attr($plugin_name), $r->new_version, wp_nonce_url(self_admin_url('update.php?action=upgrade-plugin&plugin=') . $file, 'upgrade-plugin_' . $file));
}
}
//if ( empty($r->package) )
//{
/*if (isset($r->message) && !empty($r->message))
{
echo '<br /> '.wp_kses($r->message, $plugins_allowedtags);
}*/
if (isset($r->message) && !empty($r->message)) {
$message = WPRC_Functions::formatMessage($r->message);
if (isset($r->message_type) && $r->message_type == 'notify') {
WPRC_AdminNotifier::addMessage('wprc-plugin-info-' . $r->slug, $message);
} else {
echo $message;
}
} else {
if (isset($r->repository_id) && isset($r->purchase) && !empty($r->purchase) && isset($r->price) && !empty($r->price)) {
echo '<br /> ';
$purl = WPRC_Functions::sanitizeURL($r->purchase);
$return_url = rawurlencode(admin_url('plugin-install.php?tab=plugin-information&repository_id=' . $r->repository_id . '&plugin=' . $r->slug));
$salt = rawurlencode($r->repository_salt);
if (strpos($purl, '?')) {
$url_glue = '&';
} else {
$url_glue = '?';
}
$purl .= $url_glue . 'return_to=' . $return_url . '&rsalt=' . $salt;
echo '<a href="' . $purl . '&TB_iframe=true&width=640&height=484' . '" class="thickbox" title="' . sprintf(__('Upgrade %s', 'installer'), '(' . $r->currency->symbol . $r->price . ' ' . $r->currency->name . ')') . '">' . sprintf(__('Upgrade %s', 'installer'), '(' . $r->currency->symbol . $r->price . ' ' . $r->currency->name . ')') . '</a>';
}
}
//}
do_action("in_plugin_update_message-{$file}", $plugin_data, $r);
echo '</div></td></tr>';
}
}
public function addExtensionInstalled($extension_name, $extension_slug, $extension_path, $extension_type, $repository_id, $ext_was_installed)
{
// get extension type id
$et_model = WPRC_Loader::getModel('extension-types');
$types = $et_model->getExtensionTypesList();
if (!array_key_exists($extension_type, $types)) {
return false;
}
$extension_type_id = $types[$extension_type]['id'];
$extension_exists = $this->isExtensionExists($extension_slug, $extension_type_id, $repository_id);
// insert extension
$insert_array = array('extension_name' => $extension_name, 'extension_slug' => $extension_slug, 'extension_path' => $extension_path, 'extension_type_id' => $extension_type_id, 'repository_id' => $repository_id, 'extension_was_installed' => $ext_was_installed);
$insert_format_array = array('%s', '%s', '%s', '%d', '%d', '%d');
$where = array('extension_name' => $extension_name);
$where_format = array('%s');
if ($extension_exists) {
return $this->wpdb->update($this->table_name, $insert_array, $where, $insert_format_array, $where_format);
}
return $this->wpdb->insert($this->table_name, $insert_array, $insert_format_array);
}
public static function wprc_update_themes()
{
global $wp_version;
$WP_UPDATE_THEMES_URL = WPRC_WP_THEMES_UPDATE_REPO;
//include ABSPATH . WPINC . '/version.php'; // include an unmodified $wp_version
if (defined('WP_INSTALLING')) {
return false;
}
//if ( !function_exists( 'get_themes' ) )
//require_once( ABSPATH . 'wp-includes/theme.php' );
//$installed_themes = get_themes( );
$last_update = get_site_transient('update_themes');
if (!is_object($last_update)) {
$last_update = new stdClass();
}
// Check for updated every 60 minutes if hitting update pages; else, check every 12 hours.
$timeout = in_array(current_filter(), array('load-themes.php', 'load-update.php', 'load-update-core.php')) ? 3600 : 43200;
$time_not_changed = isset($last_update->last_checked) && $timeout > time() - $last_update->last_checked;
//$themes = array();
$checked = array();
$exclude_fields = array('Template Files', 'Stylesheet Files', 'Status', 'Theme Root', 'Theme Root URI', 'Template Dir', 'Stylesheet Dir', 'Description', 'Tags', 'Screenshot');
// Put slug of current theme into request.
//$themes['current_theme'] = get_option( 'stylesheet' );
// get themes data from the DB
$extensions_model = WPRC_Loader::getModel('extensions');
$extensions = $extensions_model->getFullExtensionsTree();
$installed_themes = $extensions['themes'];
// arrange themes according to repository (if enabled)
$repos = array();
$current_theme = get_option('stylesheet');
foreach ($installed_themes as $key => $theme) {
$checked[$theme['Stylesheet']] = $theme['Version'];
$rkey = $theme['repository_endpoint_url'] === null ? WPRC_WP_THEMES_REPO : $theme['repository_endpoint_url'];
$sendtheme = $theme;
// remove unwanted fields from the theme that is going to be sent
unset($sendtheme['repository_endpoint_url']);
unset($sendtheme['repository_id']);
unset($sendtheme['repository_user']);
unset($sendtheme['repository_pass']);
unset($sendtheme['repository_salt']);
unset($sendtheme['repository_name']);
unset($sendtheme['repository_enabled']);
unset($sendtheme['repository_deleted']);
unset($sendtheme['extension_was_installed']);
unset($sendtheme['type_name']);
unset($sendtheme['extension_slug']);
foreach ((array) $theme as $key2 => $value) {
if (in_array($key2, $exclude_fields)) {
unset($sendtheme[$key2]);
}
}
if (!isset($repos[$rkey])) {
$repos[$rkey] = array('id' => $theme['repository_id'], 'url' => $rkey, 'user' => $theme['repository_user'], 'pass' => $theme['repository_pass'], 'salt' => $theme['repository_salt'], 'name' => $theme['repository_name'], 'themes' => array('current_theme' => $current_theme, $sendtheme['Stylesheet'] => $sendtheme));
// Wordpress uses different install repository URL from Update Repository URL so hardcode it
if ($rkey === WPRC_WP_THEMES_REPO) {
$repos[$rkey]['url'] = $WP_UPDATE_THEMES_URL;
}
} else {
$repos[$rkey]['themes'][$sendtheme['Stylesheet']] = $sendtheme;
}
}
$theme_changed = false;
foreach ($checked as $slug => $v) {
$update_request->checked[$slug] = $v;
if (!isset($last_update->checked[$slug]) || strval($last_update->checked[$slug]) !== strval($v)) {
$theme_changed = true;
}
}
if (isset($last_update->response) && is_array($last_update->response)) {
foreach ($last_update->response as $slug => $update_details) {
if (!isset($checked[$slug])) {
$theme_changed = true;
break;
}
}
}
if ($time_not_changed && !$theme_changed) {
return false;
}
// Update last_checked for current to prevent multiple blocking requests if request hangs
$last_update->last_checked = time();
set_site_transient('update_themes', $last_update);
$allresponses = array();
//WPRC_Loader::includeSecurity();
foreach ($repos as $repo) {
$to_send = $repo['themes'];
$server_url = $repo['url'];
$repository_username = $repo['user'];
$repository_password = $repo['pass'];
$repository_salt = $repo['salt'];
// action is themes-update by default
$body_array = array('action' => 'themes_update');
// add authorization if needed
if ($repository_username != '' && $repository_username != null && $repository_password != '' && $repository_password != null) {
//$sendpassword=WPRC_Security::encrypt($repository_salt,$repository_password);
$body_array['auth'] = array('user' => $repository_username, 'pass' => $repository_password, 'salt' => $repository_salt);
} else {
unset($body_array['auth']);
}
$body_array['themes'] = serialize($to_send);
if ($server_url === $WP_UPDATE_THEMES_URL) {
unset($body_array['action']);
}
$options = array('timeout' => defined('DOING_CRON') && DOING_CRON ? 30 : 3, 'body' => $body_array, 'user-agent' => 'WordPress/' . $wp_version . '; ' . get_bloginfo('url'));
// debug log
$reqargs = $body_array;
if (isset($reqargs['auth'])) {
$reqargs['auth'] = 'AUTH info';
}
$msg = sprintf("THEME UPDATE API Request to %s, timeout: %d, wpversion: %s, request args: %s", $server_url, $options['timeout'], $wp_version, print_r($reqargs, true));
WPRC_Functions::log($msg, 'api', 'api.log');
unset($reqargs);
// send request
$raw_response = wp_remote_post($server_url, $options);
// log
$msg = sprintf("THEME UPDATE API Request to %s, response: %s", $server_url, print_r($raw_response, true));
WPRC_Functions::log($msg, 'api', 'api.log');
if (is_wp_error($raw_response) || 200 != wp_remote_retrieve_response_code($raw_response)) {
// log
if (is_wp_error($raw_response)) {
$msg = sprintf("THEME UPDATE API Request to %s, response error: %s", $server_url, print_r($raw_response->get_error_message(), true));
WPRC_Functions::log($msg, 'api', 'api.log');
}
continue;
//return false;
}
$response = @unserialize(wp_remote_retrieve_body($raw_response));
// merge with other results
if (false === $response) {
// log
$msg = sprintf("THEME UPDATE API Request to %s, response unserialize failed: %s", $server_url, print_r(wp_remote_retrieve_body($raw_response), true));
WPRC_Functions::log($msg, 'api', 'api.log');
} else {
if (is_object($response) && isset($response->error)) {
$response = new WP_Error('extensions_api_failed', $response->error, wp_remote_retrieve_body($raw_response));
// log
$msg = sprintf("THEME UPDATE API Request to %s, action not implemented error: %s", $server_url, print_r($response, true));
WPRC_Functions::log($msg, 'api', 'api.log');
} else {
if (is_array($response) && isset($response['error'])) {
$response = new WP_Error('extensions_api_failed', $response['error'], wp_remote_retrieve_body($raw_response));
// log
$msg = sprintf("THEME UPDATE API Request to %s, action not implemented error: %s", $server_url, print_r($response, true));
WPRC_Functions::log($msg, 'api', 'api.log');
} else {
// add some info about repository id etc..
foreach ($response as $key => $them) {
if (is_object($response[$key])) {
$response[$key]->repository_id = $repo['id'];
$response[$key]->repository_salt = $repo['salt'];
} else {
if (is_array($response[$key])) {
$response[$key]['repository_id'] = $repo['id'];
$response[$key]['repository_salt'] = $repo['salt'];
}
}
$response[$key] = (array) $response[$key];
}
$allresponses = array_merge($allresponses, $response);
}
}
}
}
// update transients for themes
$new_update = new stdClass();
$new_update->last_checked = time();
$new_update->checked = $checked;
$new_update->response = $allresponses;
set_site_transient('update_themes', $new_update);
}
<?php
if (!defined('ABSPATH')) {
die('Security check');
}
// prepare fields values for the form in the template
$site_id = WPRC_Installer::getSiteId();
// get lists of extensions
$em = WPRC_Loader::getModel('extensions');
$extension_keys = array();
$bulk_deactivate = 0;
$bulk_data = array();
// get extenstions to deactivate
if (array_key_exists('checked', $_POST)) {
// bulk deactivation
// bulk deactivation accessible for plugins only
$extension_type = 'plugin';
$extension_keys = $_POST['checked'];
$bulk_deactivate = 1;
$bulk_data['_wpnonce'] = $_POST['_wpnonce'];
$bulk_data['_wp_http_referer'] = $_POST['_wp_http_referer'];
$bulk_data['checked'] = $_POST['checked'];
$bulk_data['action'] = $_POST['action'];
$bulk_data['action2'] = $_POST['action2'];
$url = admin_url('plugins.php');
} else {
// single extension deactivation
$url = $_SERVER['REQUEST_URI'];
$extension = WPRC_UrlAnalyzer::getExtensionFromUrl($url);
$extension_type = $extension['type'];
$extension_path = $extension['name'];
public function __construct()
{
$this->model = WPRC_Loader::getModel('cached-requests');
}
function testLogin($repository_id, $username, $password, $plain = false)
{
//$rm = $this->repo_model;//WPRC_Loader::getModel('repositories');
$repo = $this->getRepositoryByField('id', $repository_id);
$body_array = array('action' => 'repository_login');
$salt = $repo->repository_authsalt;
//WPRC_Loader::includeSecurity();
//$body_array['auth'] = array('user'=>$username,'pass'=>WPRC_Security::encrypt($salt,$password),'salt'=>$salt);
$body_array['auth'] = array('user' => $username, 'pass' => $password, 'salt' => $salt);
if ($plain) {
$body_array['auth']['_plain'] = 'true';
}
// log
if (!$plain) {
$msg = sprintf('Repository Login to %s with auth, timeout: %d, action: %s', $repo->repository_endpoint_url, 5, $body_array['action']);
} else {
$msg = sprintf('Repository Login to %s with auth plain, timeout: %d, action: %s', $repo->repository_endpoint_url, 5, $body_array['action']);
}
WPRC_Functions::log($msg, 'controller', 'controller.log');
$request = wp_remote_post($repo->repository_endpoint_url, array('timeout' => 15, 'body' => $body_array));
// log
$msg = sprintf('Repository Login to %s with auth, response: %s', $repo->repository_endpoint_url, print_r($request, true));
WPRC_Functions::log($msg, 'controller', 'controller.log');
if (is_wp_error($request)) {
$res = new WP_Error('repository_login_failed', __('An unexpected HTTP Error occurred during the API request.', 'installer'), $request->get_error_message());
// log
$msg = sprintf('Repository Login to %s with auth, response error: %s', $repo->repository_endpoint_url, print_r($request->get_error_message()));
WPRC_Functions::log($msg, 'controller', 'controller.log');
} else {
$request_body = wp_remote_retrieve_body($request);
if (is_serialized($request_body)) {
$res = @unserialize($request_body);
}
}
if (!isset($res) || $res == false || is_wp_error($res)) {
// log
$msg = sprintf('Repository Login to %s with auth, response unserialize error: %s', $repo->repository_endpoint_url, print_r(wp_remote_retrieve_body($request)));
WPRC_Functions::log($msg, 'controller', 'controller.log');
return false;
}
if (isset($res->error) && !isset($res->success)) {
$response = array('error' => 1, 'message' => $res->error);
} else {
$response = array('error' => 0, 'message' => $res->success);
$doupdate = false;
if ($plain && isset($res->pass) && $res->pass != '') {
$password = $res->pass;
$doupdate = true;
}
if (!$plain) {
$doupdate = true;
}
if ($doupdate) {
$this->updateRepositoryAuth($repository_id, $username, $password);
// clear cache
$rmcache = WPRC_Loader::getModel('cached-requests');
$rmcache->cleanCache();
// clear update data
delete_site_transient('update_plugins');
delete_site_transient('update_themes');
}
}
return $response;
}
