function jquery_install_remaining_sites($user)
{
$domains = jquery_domains();
$default_options = jquery_default_site_options();
$default_options['admin_email'] = $user->user_email;
foreach ($domains as $domain => $details) {
if (1 !== $details['blog_id']) {
$blog_id = insert_blog(JQUERY_STAGING_PREFIX . $domain, '/', 1);
if ($blog_id != $details['blog_id']) {
wp_die("Something went very wrong when trying to install {$domain} as site {$blog_id}-{$details['blog_id']}. Find nacin.");
}
switch_to_blog($blog_id);
install_blog($blog_id, $details['options']['blogname']);
add_user_to_blog($blog_id, $user->ID, 'administrator');
}
$options = array_merge($default_options, $details['options']);
foreach ($options as $option => $value) {
update_option($option, $value);
}
// Work around a superficial bug in install_blog(), fixed in WP r21172.
$home = untrailingslashit(get_option('home'));
$siteurl = untrailingslashit(get_option('siteurl'));
update_option('home', 'http://example.com');
// Please just don't ask.
update_option('siteurl', 'http://example.com');
update_option('home', $home);
update_option('siteurl', $siteurl);
flush_rewrite_rules();
restore_current_blog();
}
}
function jquery_install_site($site, $user)
{
$sites = jquery_sites();
$details = $sites[$site];
if (strpos($site, '/')) {
list($domain, $path) = explode('/', $site, 2);
$path = '/' . trim($path, '/') . '/';
} else {
$domain = $site;
$path = '/';
}
$default_options = jquery_default_site_options();
$default_options['admin_email'] = $user->user_email;
if (1 !== $details['blog_id']) {
$blog_id = insert_blog(JQUERY_STAGING_PREFIX . $domain, $path, 1);
if ($blog_id != $details['blog_id']) {
wp_die("Something went very wrong when trying to install {$domain} as site {$blog_id}-{$details['blog_id']}. Find nacin.");
}
switch_to_blog($blog_id);
install_blog($blog_id, $details['options']['blogname']);
add_user_to_blog($blog_id, $user->ID, 'administrator');
}
$options = array_merge($default_options, $details['options']);
foreach ($options as $option => $value) {
update_option($option, $value);
}
delete_option('rewrite_rules');
restore_current_blog();
}
function maybe_import_post($guid, $post_arr)
{
$results = array();
if ($this->post_exists($guid)) {
$results[] = "<p>{$guid} already exists</p>";
} else {
$results[] = "<p>{$guid} does not alread exist</p>";
$post_title = $post_arr['title'];
$post_content = $post_arr['content'];
$author_exists = $this->author_exists($post_arr['author']);
if (!$author_exists) {
$results[] = "<p>{$guid} author does not already exist</p>";
$author_id = $this->import_author($post_arr['author']);
if (!empty($author_id)) {
$results[] = "<p>{$guid} author added as author_id {$author_id}</p>";
}
} else {
$results[] = "<p>{$guid} author already exists as id {$author_exists}</p>";
$author_id = $author_exists;
add_user_to_blog(get_current_blog_id(), $author_id, 'subscriber');
}
$post_excerpt = $post_arr['description'];
$args = array('post_title' => $post_title, 'post_content' => $post_content, 'post_author' => $author_id, 'post_excerpt' => $post_excerpt);
$new_post_id = wp_insert_post($args);
if (!empty($new_post_id)) {
$results[] = "<p>{$guid} was inserted as post ID {$new_post_id}</p>";
add_post_meta($new_post_id, SJF_GF . "-guid", $guid, TRUE);
} else {
$results[] = "<p>{$guid} could not be inserted</p>";
}
}
return $results;
}
/**
* @ticket 38355
*/
public function test_get_active_blog_for_user_with_spam_site()
{
$current_site_id = get_current_blog_id();
$site_id = self::factory()->blog->create(array('user_id' => self::$user_id, 'meta' => array('spam' => 1)));
add_user_to_blog($site_id, self::$user_id, 'subscriber');
update_user_meta(self::$user_id, 'primary_blog', $site_id);
$result = get_active_blog_for_user(self::$user_id);
wpmu_delete_blog($site_id, true);
$this->assertEquals($current_site_id, $result->id);
}
function on_activate_user($user_id, $password, $meta)
{
$default_role = get_option('default_role');
$blogid = empty($meta['register_blog_id']) ? 1 : intval($meta['register_blog_id']);
add_user_to_blog(1, $user_id, $default_role);
add_user_to_blog($blogid, $user_id, $default_role);
if ($this->debug) {
$this->write_to_log('Activate:' . print_r($meta, true));
}
}
static function join_site()
{
global $current_user, $blog_id;
$jmm_options = get_option('helfjmm_options');
if (!is_user_logged_in()) {
return false;
}
if (!is_user_member_of_blog()) {
add_user_to_blog($blog_id, $current_user->ID, $jmm_options['role']);
}
}
/**
* On author pages, the queried object should only be set
* to a user that's not a member of the blog if they
* have at least one published post. This matches core behavior.
*
* @see https://core.trac.wordpress.org/changeset/27290
*/
function test_author_queried_object_fix()
{
global $wp_rewrite, $coauthors_plus;
/**
* Set up
*/
$author1 = $this->factory->user->create(array('user_login' => 'msauthor1'));
$author2 = $this->factory->user->create(array('user_login' => 'msauthor2'));
$blog2 = $this->factory->blog->create(array('user_id' => $author1));
switch_to_blog($blog2);
$wp_rewrite->init();
$blog2_post1 = $this->factory->post->create(array('post_status' => 'publish', 'post_content' => rand_str(), 'post_title' => rand_str(), 'post_author' => $author1));
/**
* Author 1 is an author on the blog
*/
$this->go_to(get_author_posts_url($author1));
$this->assertQueryTrue('is_author', 'is_archive');
/**
* Author 2 is not yet an author on the blog
*/
$this->go_to(get_author_posts_url($author2));
$this->assertQueryTrue('is_404');
// Add the user to the blog
add_user_to_blog($blog2, $author2, 'author');
/**
* Author 2 is now on the blog, but not yet published
*/
$this->go_to(get_author_posts_url($author2));
$this->assertQueryTrue('is_author', 'is_archive');
// Add the user as an author on the original post
$author2_obj = get_user_by('id', $author2);
$coauthors_plus->add_coauthors($blog2_post1, array($author2_obj->user_login), true);
/**
* Author 2 is now on the blog, and published
*/
$this->go_to(get_author_posts_url($author2));
$this->assertQueryTrue('is_author', 'is_archive');
// Remove the user from the blog
remove_user_from_blog($author2, $blog2);
/**
* Author 2 was removed from the blog, but still a published author
*/
$this->go_to(get_author_posts_url($author2));
$this->assertQueryTrue('is_author', 'is_archive');
// Delete the user from the network
wpmu_delete_user($author2);
/**
* Author 2 is no more
*/
$this->go_to(get_author_posts_url($author2));
$this->assertQueryTrue('is_404');
$this->assertEquals(false, get_user_by('id', $author2));
restore_current_blog();
}
/**
* @ticket 39065
*/
public function test_get_dashboard_url_for_administrator_of_different_site()
{
if (!is_multisite()) {
$this->markTestSkipped('Test only runs in multisite.');
}
$site_id = self::factory()->blog->create(array('user_id' => self::$user_id));
remove_user_from_blog(self::$user_id, get_current_blog_id());
$expected = get_admin_url($site_id);
$result = get_dashboard_url(self::$user_id);
remove_user_from_blog(self::$user_id, $site_id);
add_user_to_blog(get_current_blog_id(), self::$user_id, 'administrator');
wpmu_delete_blog($site_id, true);
$this->assertEquals($expected, $result);
}
/**
* Create / Add users
*/
function ns_wp_add_user($target_id, $useremail, $username, $userpass = '', $userrole = 'administrator', $logfile = false)
{
global $ns_cloner;
ns_log_write("ENTER ns_wp_add_user - target_id:{$target_id}, useremail:{$useremail}, username:{$username}, userrole:{$userrole}", $logfile);
$useremail = stripslashes($useremail);
$username = stripslashes($username);
$userpass = stripslashes($userpass);
$user_by_email = get_user_by('email', $useremail);
$user_by_username = get_user_by('username', $username);
// check for existing user by email
if (!empty($user_by_email)) {
$user_id = $user_by_email->ID;
ns_log_write("Found user with email '{$useremail}' (id={$user_id})", $logfile);
} elseif (!empty($user_by_username)) {
$user_id = $user_by_username->ID;
ns_log_write("Found user with username '{$username}' (id={$user_id})", $logfile);
} else {
if (empty($userpass) || $userpass == strtolower('null')) {
$userpass = wp_generate_password();
}
$user_id = wpmu_create_user($username, $userpass, $useremail);
if ($user_id != false) {
ns_log_write("Created new user '{$username}' with email '{$useremail}'", $logfile);
// send notification to new users if the option is set
if (isset($ns_cloner->request['do_user_notify'])) {
wpmu_welcome_notification($target_id, $user_id, $userpass, 'New Site with ID: ' . $target_id);
ns_log_write("Sent welcome email to new user '{$username}' with email '{$useremail}'", $logfile);
}
} else {
ns_log_write("Failed creating user '{$username}' with email '{$useremail}' - that username or email is probably already taken for a different user.", $logfile);
}
}
// we now have a user id (or should) - give them privileges on this blog
if (!empty($target_id) && !empty($user_id) && !empty($userrole)) {
$result = add_user_to_blog($target_id, $user_id, $userrole);
if ($result === true) {
ns_log_write("Successfully added user with id {$user_id} to blog {$target_id}", $logfile);
} else {
$error_message = $result->get_error_message();
ns_log_write("Failed adding user to blog. WP error: {$error_message}", $logfile);
}
return $result;
} else {
$error_message = "Target id, user id, or user role were empty";
ns_log_write("Failed adding user to blog. {$error_message}", $logfile);
return new WP_Error(false, $error_message);
}
}
function wpms_add_user_to_main_site($user_id = null)
{
global $wpdb;
if (!is_multisite()) {
return;
}
if (!$user_id) {
$user_id = get_current_user_id();
}
if (defined('BLOG_ID_CURRENT_SITE')) {
$main_site = BLOG_ID_CURRENT_SITE;
} else {
$main_site = 1;
}
add_user_to_blog($main_site, $user_id, 'subscriber');
}
/**
* Impose some state data onto a region
*
* @param string $key Site slug
* @param array $value Site data
* @return true|WP_Error
*/
public function impose($key, $value)
{
$site = $this->get_site($key);
if (!$site) {
$site = $this->create_site($key, $value);
if (is_wp_error($site)) {
return $site;
}
}
switch_to_blog($site['blog_id']);
foreach ($value as $field => $single_value) {
switch ($field) {
case 'title':
case 'description':
$map = array('title' => 'blogname', 'description' => 'blogdescription');
update_option($map[$field], $single_value);
break;
case 'active_theme':
if ($single_value !== get_option('stylesheet')) {
switch_theme($single_value);
}
break;
case 'active_plugins':
foreach ($single_value as $plugin) {
if (!is_plugin_active($plugin)) {
activate_plugin($plugin);
}
}
break;
case 'users':
foreach ($single_value as $user_login => $role) {
$user = get_user_by('login', $user_login);
if (!$user) {
continue;
}
add_user_to_blog($site['blog_id'], $user->ID, $role);
}
break;
}
}
restore_current_blog();
return true;
}
function widget_suscribe()
{
global $wpdb, $current_user;
$options = get_option('widget_suscribe');
$before_widget = "<li id='subscribe'>";
$before_title = "<h2>";
$title = empty($options['title']) ? 'Suscríbete a este blog' : $options['title'];
$after_title = "</h2>";
$content = "";
$after_widget = "</li>";
//error_log("[widget subscribe] current blog: ". $wpdb->blogid);
//error_log("[widget subscribe] current user: "******"[widget subscribe] is blog user");
// User wants to unsubscribe
if (isset($_POST['unsuscribe'])) {
//error_log("[widget subscribe] POST[unsuscribe]");
remove_user_from_blog($current_user->ID, $wpdb->blogid);
$content .= '<p>Te has desuscrito de este blog</p>';
$content .= widget_subscribe_form();
} elseif ($current_user->has_cap('subscriber')) {
//error_log("[widget subscribe] has_cap('subscriber')");
$content .= widget_unsubscribe_form();
} elseif ($current_user->has_cap('edit_posts')) {
$content .= "<p>Este blog tiene activado el widget de suscripción</p>";
}
} else {
//error_log("[widget subscribe] not in log");
// User wants to subscribe
if (isset($_POST['suscribe'])) {
//error_log("[widget subscribe] POST[suscribe]");
add_user_to_blog($wpdb->blogid, $current_user->ID, 'subscriber');
$content .= '<p>Te has suscrito a este blog</p>';
$content .= widget_unsubscribe_form();
} else {
//error_log("[widget subscribe] subscribe form");
$content .= widget_subscribe_form();
}
}
echo $before_widget . $before_title . $title . $after_title . $content . $after_widget;
}
/**
* @ticket 22993
* @group multisite
*/
public function test_get_users_with_no_role_multisite_is_accurate()
{
if (!is_multisite()) {
$this->markTestSkipped('Test requires multisite');
}
// Setup users
$admin = self::factory()->user->create(array('role' => 'administrator'));
$editor = self::factory()->user->create(array('role' => 'editor'));
$nobody = self::factory()->user->create(array('role' => ''));
// Setup blogs
$blog_1 = (int) self::factory()->blog->create(array('user_id' => $editor));
// Add users to blogs
add_user_to_blog($blog_1, $editor, 'editor');
// Test users on root site
$users = wp_get_users_with_no_role();
$this->assertSame(array(), $users);
// Test users counts on blog 1
switch_to_blog($blog_1);
$users = wp_get_users_with_no_role();
restore_current_blog();
// Test users on root site
$this->assertSame(array(), $users);
}
public function test_sends_stats_data_on_heartbeat_on_multisite()
{
global $wpdb;
if (!is_multisite()) {
$this->markTestSkipped('Run it in multi site mode');
}
$user_id = $this->factory->user->create();
$mu_blog_user_id = $this->factory->user->create();
// create a different blog
$suppress = $wpdb->suppress_errors();
$other_blog_id = wpmu_create_blog('foo.com', '', "My Blog", $user_id);
$wpdb->suppress_errors($suppress);
// create a user from within that blog (won't be synced)
switch_to_blog($other_blog_id);
add_user_to_blog($other_blog_id, $mu_blog_user_id, 'administrator');
$heartbeat = Jetpack_Heartbeat::init();
$heartbeat->cron_exec();
$this->sender->do_sync();
$action = $this->server_event_storage->get_most_recent_event('jetpack_sync_heartbeat_stats');
restore_current_blog();
$this->assertEquals(JETPACK__VERSION, $action->args[0]['version']);
$this->assertFalse(isset($action->args[0]['users']));
}
/**
* @ticket 22993
* @group multisite
*
* @dataProvider data_count_users_strategies
*/
public function test_count_users_multisite_is_accurate($strategy)
{
if (!is_multisite()) {
$this->markTestSkipped('Test requires multisite');
}
// Setup users
$admin = self::factory()->user->create(array('role' => 'administrator'));
$editor = self::factory()->user->create(array('role' => 'editor'));
$author = self::factory()->user->create(array('role' => 'author'));
$contributor = self::factory()->user->create(array('role' => 'contributor'));
$subscriber = self::factory()->user->create(array('role' => 'subscriber'));
$none = self::factory()->user->create(array('role' => ''));
$nobody = self::factory()->user->create(array('role' => ''));
// Setup blogs
$blog_1 = (int) self::factory()->blog->create(array('user_id' => $editor));
$blog_2 = (int) self::factory()->blog->create(array('user_id' => $author));
// Add users to blogs
add_user_to_blog($blog_1, $subscriber, 'editor');
add_user_to_blog($blog_2, $none, 'contributor');
// Test users counts on root site
$count = count_users($strategy);
$this->assertEquals(8, $count['total_users']);
$this->assertEquals(array('administrator' => 2, 'editor' => 1, 'author' => 1, 'contributor' => 1, 'subscriber' => 1, 'none' => 0), $count['avail_roles']);
// Test users counts on blog 1
switch_to_blog($blog_1);
$count = count_users($strategy);
restore_current_blog();
$this->assertEquals(2, $count['total_users']);
$this->assertEquals(array('administrator' => 1, 'editor' => 1, 'none' => 0), $count['avail_roles']);
// Test users counts on blog 2
switch_to_blog($blog_2);
$count = count_users($strategy);
restore_current_blog();
$this->assertEquals(2, $count['total_users']);
$this->assertEquals(array('administrator' => 1, 'contributor' => 1, 'none' => 0), $count['avail_roles']);
}
/**
* Import users from a CSV file.
*
* ## OPTIONS
*
* <file>
* : The local or remote CSV file of users to import.
*
* [--send-email]
* : Send an email to new users with their account details.
*
* [--skip-update]
* : Don't update users that already exist.
*
* ## EXAMPLES
*
* # Import users from local CSV file
* $ wp user import-csv /path/to/users.csv
* Success: bobjones created
* Success: newuser1 created
* Success: existinguser created
*
* # Import users from remote CSV file
* $ wp user import-csv http://example.com/users.csv
*
* Sample users.csv file:
*
* user_login,user_email,display_name,role
* bobjones,bobjones@example.com,Bob Jones,contributor
* newuser1,newuser1@example.com,New User,author
* existinguser,existinguser@example.com,Existing User,administrator
*
* @subcommand import-csv
*/
public function import_csv($args, $assoc_args)
{
$blog_users = get_users();
$filename = $args[0];
if (0 === stripos($filename, 'http://') || 0 === stripos($filename, 'https://')) {
$response = wp_remote_head($filename);
$response_code = (string) wp_remote_retrieve_response_code($response);
if (in_array($response_code[0], array(4, 5))) {
WP_CLI::error("Couldn't access remote CSV file (HTTP {$response_code} response).");
}
} else {
if (!file_exists($filename)) {
WP_CLI::error(sprintf("Missing file: %s", $filename));
}
}
foreach (new \WP_CLI\Iterators\CSV($filename) as $i => $new_user) {
$defaults = array('role' => get_option('default_role'), 'user_pass' => wp_generate_password(), 'user_registered' => strftime("%F %T", time()), 'display_name' => false);
$new_user = array_merge($defaults, $new_user);
$secondary_roles = array();
if (!empty($new_user['roles'])) {
$roles = array_map('trim', explode(',', $new_user['roles']));
$invalid_role = false;
foreach ($roles as $role) {
if (is_null(get_role($role))) {
WP_CLI::warning("{$new_user['user_login']} has an invalid role.");
$invalid_role = true;
break;
}
}
if ($invalid_role) {
continue;
}
$new_user['role'] = array_shift($roles);
$secondary_roles = $roles;
} else {
if ('none' === $new_user['role']) {
$new_user['role'] = false;
} elseif (is_null(get_role($new_user['role']))) {
WP_CLI::warning("{$new_user['user_login']} has an invalid role.");
continue;
}
}
// User already exists and we just need to add them to the site if they aren't already there
$existing_user = get_user_by('email', $new_user['user_email']);
if (!$existing_user) {
$existing_user = get_user_by('login', $new_user['user_login']);
}
if ($existing_user && \WP_CLI\Utils\get_flag_value($assoc_args, 'skip-update')) {
WP_CLI::log("{$existing_user->user_login} exists and has been skipped.");
continue;
} else {
if ($existing_user) {
$new_user['ID'] = $existing_user->ID;
$user_id = wp_update_user($new_user);
if (!in_array($existing_user->user_login, wp_list_pluck($blog_users, 'user_login')) && is_multisite() && $new_user['role']) {
add_user_to_blog(get_current_blog_id(), $existing_user->ID, $new_user['role']);
WP_CLI::log("{$existing_user->user_login} added as {$new_user['role']}.");
}
// Create the user
} else {
unset($new_user['ID']);
// Unset else it will just return the ID
if (is_multisite()) {
$ret = wpmu_validate_user_signup($new_user['user_login'], $new_user['user_email']);
if (is_wp_error($ret['errors']) && !empty($ret['errors']->errors)) {
WP_CLI::warning($ret['errors']);
continue;
}
$user_id = wpmu_create_user($new_user['user_login'], $new_user['user_pass'], $new_user['user_email']);
if (!$user_id) {
WP_CLI::warning("Unknown error creating new user.");
continue;
}
$new_user['ID'] = $user_id;
$user_id = wp_update_user($new_user);
if (is_wp_error($user_id)) {
WP_CLI::warning($user_id);
continue;
}
} else {
$user_id = wp_insert_user($new_user);
}
if (\WP_CLI\Utils\get_flag_value($assoc_args, 'send-email')) {
self::wp_new_user_notification($user_id, $new_user['user_pass']);
}
}
}
if (is_wp_error($user_id)) {
WP_CLI::warning($user_id);
continue;
} else {
if ($new_user['role'] === false) {
delete_user_option($user_id, 'capabilities');
delete_user_option($user_id, 'user_level');
}
}
$user = get_user_by('id', $user_id);
foreach ($secondary_roles as $secondary_role) {
$user->add_role($secondary_role);
}
if (!empty($existing_user)) {
WP_CLI::success($new_user['user_login'] . " updated.");
} else {
WP_CLI::success($new_user['user_login'] . " created.");
}
}
}
function lti_parse_request_OLD($wp)
{
if (!is_basic_lti_request()) {
$good_message_type = $_REQUEST[LTI_MESSAGE_TYPE] == LTI_MESSAGE_TYPE_VALUE;
$good_lti_version = $_REQUEST[LTI_VERSION] == LTI_VERSION_VALUE;
$resource_link_id = $_REQUEST[RESOURCE_LINK_ID];
if ($good_message_type && $good_lti_version && !isset($resource_link_id)) {
$launch_presentation_return_url = $_REQUEST[LAUNCH_PRESENTATION_URL];
if (isset($launch_presentation_return_url)) {
header('Location: ' . $launch_presentation_return_url);
exit;
}
}
return;
}
// See if we get a context, do not set session, do not redirect
$secret = lti_get_secret_from_consumer_key();
$context = new bltiUocWrapper(false, false, null, $secret);
if (!$context->valid) {
//var_dump($_POST);
echo "<hr>OAuthUtil::urldecode_rfc3986('%2B') " . OAuthUtil::urldecode_rfc3986('%2B') . "<br>";
echo "<hr>OAuthUtil::urldecode_rfc3986('%5C') " . OAuthUtil::urldecode_rfc3986('%5C') . "<br>";
wp_die("BASIC LTI Authentication Failed, not valid request (make sure that consumer is authorized and secret is correct) " . $context->message);
return;
}
$error = is_lti_error_data($context);
if ($error !== FALSE) {
$launch_presentation_return_url = $_REQUEST[LAUNCH_PRESENTATION_URL];
if (isset($launch_presentation_return_url)) {
$error = '<p>' . $error . '</p><p>Return to site <a href="' . $launch_presentation_return_url . '">' . $launch_presentation_return_url . '</a></p>';
}
wp_die($error, '');
}
$blogType = new blogTypeLoader($context);
if ($blogType->error < 0) {
wp_die("BASIC LTI loading Types Aula Failed " . $blogType->error_miss);
return;
}
// Set up the user...
$userkey = getUserkeyLTI($context);
$userkey = apply_filters('pre_user_login', $userkey);
$userkey = trim($userkey);
if (empty($userkey)) {
wp_die('<p>Empty username</p><p>Cannot create a user without username</p>');
}
$uinfo = get_user_by('login', $userkey);
if (isset($uinfo) && $uinfo != false) {
// og LTI: set the user_login and user_nicename to the same value,
// , because we want the wordpress-login cookie to have the username
// otherwise caching won't work properly!
$ret_id = wp_insert_user(array('ID' => $uinfo->ID, 'user_login' => $userkey, 'user_nicename' => $userkey, 'first_name' => $context->getUserFirstName(), 'last_name' => $context->getUserLastName(), 'user_email' => $context->getUserEmail(), 'user_url' => 'http://b', 'display_name' => $context->getUserName(), 'role' => get_option('default_role')));
//error_log("og old role is set");
if (is_object($ret_id) && isset($ret_id->errors)) {
$msg = '';
foreach ($ret_id->errors as $key => $error) {
$msg .= "<p><b>{$key}</b> ";
foreach ($error as $erroMsg) {
$msg .= "<p> {$erroMsg}</p>";
}
$msg .= "</p>";
}
wp_die($msg);
}
} else {
// new user!!!!
$ret_id = wp_insert_user(array('user_login' => $userkey, 'user_nicename' => $context->getUserName(), 'first_name' => $context->getUserFirstName(), 'last_name' => $context->getUserLastName(), 'user_email' => $context->getUserEmail(), 'user_url' => 'http://c', 'display_name' => $context->getUserName()));
if (is_object($ret_id) && isset($ret_id->errors)) {
$msg = '';
foreach ($ret_id->errors as $key => $error) {
$msg .= "<p><b>{$key}</b> ";
foreach ($error as $erroMsg) {
$msg .= "<p> {$erroMsg}</p>";
}
$msg .= "</p>";
}
wp_die($msg);
}
$uinfo = get_user_by('login', $userkey);
}
//Eliminem del blog Principal (si no es admin) http://jira.uoc.edu/jira/browse/BLOGA-218
if (!$is_admin) {
$user = new WP_User($uinfo->ID);
$user->remove_all_caps();
}
$_SERVER['REMOTE_USER'] = $userkey;
$password = md5($uinfo->user_pass);
// User is now authorized; force WordPress to use the generated password
//login, set cookies, and set current user
wp_authenticate($userkey, $password);
wp_set_auth_cookie($user->ID, false);
wp_set_current_user($user->ID, $userkey);
$siteUrl = substr(get_option("siteurl"), 7);
// - "http://"
$siteUrlArray = explode("/", $siteUrl);
$domain = $siteUrlArray[0];
unset($siteUrlArray[0]);
//error_log("og LTI domain: ". $domain);
$course = $blogType->getCoursePath($context, $siteUrlArray, $domain);
if (isset($context->info[RESOURCE_LINK_ID]) && $context->info[RESOURCE_LINK_ID]) {
$course .= '-' . $context->info[RESOURCE_LINK_ID];
}
$course = sanitize_user($course, true);
//Bug wordpress doesn't get stye sheet if has a dot
$course = str_replace('.', '_', $course);
$path_base = "/" . implode("/", $siteUrlArray) . "/" . $course;
$path_base = str_replace('//', '/', $path_base);
$path = $path_base . "/";
$path = str_replace('//', '/', $path);
$blog_created = false;
$overwrite_plugins_theme = isset($context->info[OVERWRITE_PLUGINS_THEME]) ? $context->info[OVERWRITE_PLUGINS_THEME] == 1 : false;
$overwrite_roles = isset($context->info[OVERWRITE_ROLES]) ? $context->info[OVERWRITE_ROLES] == 1 : false;
$blog_id = domain_exists($domain, $path);
$blog_is_new = false;
if (!isset($blog_id)) {
$title = __("Blog ") . $blogType->getCourseName($context);
$blog_is_new = true;
$meta = $blogType->getMetaBlog($context);
$old_site_language = get_site_option('WPLANG');
$blogType->setLanguage($context);
$blog_id = wpmu_create_blog($domain, $path, $title, $user_id, $meta);
update_site_option('WPLANG', $old_site_language);
$blogType->checkErrorCreatingBlog($blog_id, $path);
$blog_created = true;
}
// Connect the user to the blog
if (isset($blog_id)) {
switch_to_blog($blog_id);
ob_start();
if ($overwrite_plugins_theme || $blog_created) {
$blogType->loadPlugins();
$blogType->changeTheme();
}
//Agafem el rol anterior
$old_role = null;
if (!$blog_created && !$overwrite_roles) {
$old_role_array = get_usermeta($user->id, 'wp_' . $blog_id . '_capabilities');
if (count($old_role_array) > 0) {
foreach ($old_role_array as $key => $value) {
if ($value == true) {
$old_role = $key;
}
}
}
}
remove_user_from_blog($uinfo->ID, $blog_id);
$obj = new stdClass();
$obj->blog_id = $blog_id;
$obj->userkey = $userkey;
$obj->path_base = $path_base;
$obj->domain = $domain;
$obj->context = $context;
$obj->uinfoID = $uinfo->ID;
$obj->blog_is_new = $blog_is_new;
if ($overwrite_roles || $old_role == null) {
$obj->role = $blogType->roleMapping($context->info[FIELD_ROLE_UOC_CAMPUS], $context->info);
} else {
$obj->role = $old_role;
}
$blogType->postActions($obj);
add_user_to_blog($blog_id, $uinfo->ID, $obj->role);
//Si posem el restore_current_blog ens va al principi
// restore_current_blog();
ob_end_clean();
}
$redirecturl = get_option("siteurl");
//error_log("og LTI redirect URL: ".$redirecturl);
$redirecturl = str_replace("http://", "https://", $redirecturl);
//error_log("og LTI new redirect URL: ".$redirecturl);
wp_redirect($redirecturl);
exit;
}
}
if (is_array($_POST['user']) == false) {
wp_die(__('Cannot create an empty user.'));
}
$user = $_POST['user'];
if (empty($user['username']) && empty($user['email'])) {
wp_die(__('Missing username and email.'));
} elseif (empty($user['username'])) {
wp_die(__('Missing username.'));
} elseif (empty($user['email'])) {
wp_die(__('Missing email.'));
}
$password = wp_generate_password();
$user_id = wpmu_create_user(esc_html(strtolower($user['username'])), $password, esc_html($user['email']));
if (false == $user_id) {
wp_die(__('Duplicated username or email address.'));
} else {
wp_new_user_notification($user_id, $password);
}
if (get_site_option('dashboard_blog') == false) {
add_user_to_blog($current_site->blog_id, $user_id, get_site_option('default_user_role', 'subscriber'));
} else {
add_user_to_blog(get_site_option('dashboard_blog'), $user_id, get_site_option('default_user_role', 'subscriber'));
}
wp_redirect(add_query_arg(array('updated' => 'true', 'action' => 'add'), wp_get_referer()));
exit;
break;
default:
wp_redirect(admin_url('ms-admin.php'));
break;
}
/**
* Validate the login using CAS
*/
function validate_login($null, $username, $password)
{
if (!$this->cas_configured) {
die('Error. Cas not configured and I was unable to redirect you to wp-login. Use define("WPCAS_BYPASS",true); in your wp-config.php
to bypass wpCAS');
}
phpCAS::forceAuthentication();
// might as well be paranoid
if (!phpCAS::isAuthenticated()) {
exit;
}
$username = phpCAS::getUser();
$password = md5($username . 'wpCASAuth!"#$"!$!"%$#"%#$' . rand() . $this->generateRandomString(20));
$user = get_user_by('login', $username);
if ($user) {
if (is_multisite()) {
if ($this->canUserRegister($username) && !is_user_member_of_blog($user->ID, get_current_blog_id())) {
$nextrole = $this->canUserRegister($username);
add_user_to_blog(get_current_blog_id(), $user->ID, $nextrole);
}
}
return $user;
}
/** Register a new user, if it is allowed */
if ($user_role = $this->canUserRegister($username)) {
$user_email = '';
$email_registration = $this->settings['e-mail_registration'];
//How does the site is configured to get the email?
switch ($email_registration) {
case 2:
//Using sufix
$user_email = $username . '@' . $this->settings['email_suffix'];
break;
case 3:
//Using LDAP
/*fetch user email from ldap*/
$ds = ldap_connect($this->settings['ldap_server']);
ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, $this->settings['ldap_protocol']);
ldap_set_option($ds, LDAP_OPT_RESTART, TRUE);
$r = ldap_bind($ds, $this->settings['ldap_username_rdn'], $this->settings['ldap_password']);
$list = ldap_list($ds, $this->settings['ldap_basedn'], "uid={$username}");
if ($list !== FALSE) {
$result = ldap_get_entries($ds, $list);
if ($result['count'] > 0) {
$result = $result[0];
if (isset($result['mail']) && is_array($result['mail'])) {
$user_email = $result['mail'][0];
}
if (isset($result['displayname']) && is_array($result['displayname'])) {
$user_realname = $result['displayname'][0];
$exploded_name = explode(' ', $user_realname);
$firstname = $exploded_name[0];
$lastname = end($exploded_name);
}
}
}
break;
default:
//No email predition
break;
}
$user_info = array();
$user_info['user_pass'] = $password;
$user_info['user_email'] = $user_email;
$user_info['user_login'] = $username;
$user_info['display_name'] = $user_realname;
$user_info['first_name'] = $firstname;
$user_info['last_name'] = $lastname;
//Verify if we need to add user to a specified role
if (!is_bool($user_role)) {
$user_info['role'] = $user_role;
}
if (!is_wp_error(wp_insert_user($user_info))) {
$send_user = !empty($user_info['user_email']);
//False, if user has no email
if (!isset($user_info['role']) && $this->settings['wait_mail']['send_user']) {
//If user has no role and is allowed to send wait mail to user
$this->processMailing(WPCAS_WAITACCESS_MAIL, $user_info, $send_user);
} else {
if (!isset($user_info['role']) && !$this->settings['wait_mail']['send_user']) {
//Otherwise, if has no role and we don't want a wait for access mail, send the welcome mail
$this->processMailing(WPCAS_WELCOME_MAIL, $user_info, $send_user);
} else {
//In any other case, send a Welcome Mail
$this->processMailing(WPCAS_WELCOME_MAIL, $user_info, $send_user);
}
}
$user = get_user_by('login', $username);
if (!isset($user_info['user_role'])) {
update_user_meta($user->ID, '_wpcas_waiting', true);
}
return $user;
}
} else {
$caserror_file = get_template_directory() . '/cas_error.php';
include file_exists($caserror_file) ? $caserror_file : "cas_error.php";
exit;
}
}
/**
* Add a newly created user to the appropriate blog
*
* To add a user in general, use add_user_to_blog(). This function
* is specifically hooked into the wpmu_activate_user action.
*
* @since MU
* @see add_user_to_blog()
*
* @param int $user_id
* @param mixed $password Ignored.
* @param array $meta
*/
function add_new_user_to_blog($user_id, $password, $meta)
{
if (!empty($meta['add_to_blog'])) {
$blog_id = $meta['add_to_blog'];
$role = $meta['new_role'];
remove_user_from_blog($user_id, get_current_site()->blog_id);
// remove user from main blog.
add_user_to_blog($blog_id, $user_id, $role);
update_user_meta($user_id, 'primary_blog', $blog_id);
}
}
} else {
wp_new_user_notification($user_id, $password);
add_user_to_blog($id, $user_id, $_POST['new_role']);
$update = 'newuser';
}
}
break;
case 'adduser':
check_admin_referer('add-user', '_wpnonce_add-user');
if (!empty($_POST['newuser'])) {
$update = 'adduser';
$newuser = $_POST['newuser'];
$user = get_user_by('login', $newuser);
if ($user && $user->exists()) {
if (!is_user_member_of_blog($user->ID, $id)) {
add_user_to_blog($id, $user->ID, $_POST['new_role']);
} else {
$update = 'err_add_member';
}
} else {
$update = 'err_add_notfound';
}
} else {
$update = 'err_add_notfound';
}
break;
case 'remove':
if (!current_user_can('remove_users')) {
die(__('You can’t remove users.'));
}
check_admin_referer('bulk-users');
/**
* @ticket 20601
*/
function test_user_member_of_blog() {
global $wp_rewrite;
$this->factory->blog->create();
$user_id = $this->factory->user->create();
$this->factory->blog->create( array( 'user_id' => $user_id ) );
$blogs = get_blogs_of_user( $user_id );
$this->assertCount( 2, $blogs );
$first = reset( $blogs )->userblog_id;
remove_user_from_blog( $user_id, $first );
$blogs = get_blogs_of_user( $user_id );
$second = reset( $blogs )->userblog_id;
$this->assertCount( 1, $blogs );
switch_to_blog( $first );
$wp_rewrite->init();
$this->go_to( get_author_posts_url( $user_id ) );
$this->assertQueryTrue( 'is_404' );
switch_to_blog( $second );
$wp_rewrite->init();
$this->go_to( get_author_posts_url( $user_id ) );
$this->assertQueryTrue( 'is_author', 'is_archive' );
add_user_to_blog( $first, $user_id, 'administrator' );
$blogs = get_blogs_of_user( $user_id );
$this->assertCount( 2, $blogs );
switch_to_blog( $first );
$wp_rewrite->init();
$this->go_to( get_author_posts_url( $user_id ) );
$this->assertQueryTrue( 'is_author', 'is_archive' );
}
/**
* Adds the user to the networked blog they are currently visiting
*
* @since 1.0.9
* @param $user_id
* @return true, wp_error object
*/
public function multisite_setup($user_id = null)
{
$added_to_blog = add_user_to_blog(get_current_blog_id(), $user_id, apply_filters('ajax_login_register_default_role', get_option('default_role')));
return $added_to_blog;
}
/**
* @ticket 32250
*/
public function test_has_published_posts_should_respect_blog_id()
{
if (!is_multisite()) {
$this->markTestSkipped(__METHOD__ . ' requires multisite.');
}
$users = $this->factory->user->create_many(3);
$blogs = $this->factory->blog->create_many(2);
add_user_to_blog($blogs[0], $users[0], 'author');
add_user_to_blog($blogs[0], $users[1], 'author');
add_user_to_blog($blogs[1], $users[0], 'author');
add_user_to_blog($blogs[1], $users[1], 'author');
switch_to_blog($blogs[0]);
$this->factory->post->create(array('post_author' => $users[0], 'post_status' => 'publish', 'post_type' => 'post'));
restore_current_blog();
switch_to_blog($blogs[1]);
$this->factory->post->create(array('post_author' => $users[1], 'post_status' => 'publish', 'post_type' => 'post'));
restore_current_blog();
$q = new WP_User_Query(array('has_published_posts' => array('post'), 'blog_id' => $blogs[1]));
$found = wp_list_pluck($q->get_results(), 'ID');
$expected = array($users[1]);
$this->assertEqualSets($expected, $found);
}
/**
* Add a newly created user to the appropriate blog
*
* @since MU
*
* @param int $user_id
* @param string $email
* @param array $meta
*/
function add_new_user_to_blog($user_id, $email, $meta)
{
global $current_site;
if (!empty($meta['add_to_blog'])) {
$blog_id = $meta['add_to_blog'];
$role = $meta['new_role'];
remove_user_from_blog($user_id, $current_site->blog_id);
// remove user from main blog.
add_user_to_blog($blog_id, $user_id, $role);
update_user_meta($user_id, 'primary_blog', $blog_id);
}
}
/**
* @ticket 22212
* @ticket 21119
*/
public function test_calling_prepare_query_a_second_time_should_not_add_another_cap_query_on_multisite()
{
if (!is_multisite()) {
$this->markTestSkipped(__METHOD__ . ' requires Multisite.');
}
$site_id = get_current_blog_id();
add_user_to_blog($site_id, self::$author_ids[0], 'author');
$q = new WP_User_Query(array('include' => self::$author_ids[0]));
$r1 = $q->request;
$q->prepare_query(array('include' => self::$author_ids[0]));
$r2 = $q->request;
$q->prepare_query(array('include' => self::$author_ids[0]));
$r3 = $q->request;
$this->assertSame($r1, $r2);
$this->assertSame($r1, $r3);
}
/**
* Process the login form.
*/
public static function process_login()
{
$nonce_value = isset($_POST['_wpnonce']) ? $_POST['_wpnonce'] : '';
$nonce_value = isset($_POST['woocommerce-login-nonce']) ? $_POST['woocommerce-login-nonce'] : $nonce_value;
if (!empty($_POST['login']) && wp_verify_nonce($nonce_value, 'woocommerce-login')) {
try {
$creds = array('user_password' => $_POST['password'], 'remember' => isset($_POST['rememberme']));
$username = trim($_POST['username']);
$validation_error = new WP_Error();
$validation_error = apply_filters('woocommerce_process_login_errors', $validation_error, $_POST['username'], $_POST['password']);
if ($validation_error->get_error_code()) {
throw new Exception('<strong>' . __('Error:', 'woocommerce') . '</strong> ' . $validation_error->get_error_message());
}
if (empty($username)) {
throw new Exception('<strong>' . __('Error:', 'woocommerce') . '</strong> ' . __('Username is required.', 'woocommerce'));
}
if (empty($_POST['password'])) {
throw new Exception('<strong>' . __('Error:', 'woocommerce') . '</strong> ' . __('Password is required.', 'woocommerce'));
}
if (is_email($username) && apply_filters('woocommerce_get_username_from_email', true)) {
$user = get_user_by('email', $username);
if (isset($user->user_login)) {
$creds['user_login'] = $user->user_login;
} else {
throw new Exception('<strong>' . __('Error:', 'woocommerce') . '</strong> ' . __('A user could not be found with this email address.', 'woocommerce'));
}
} else {
$creds['user_login'] = $username;
}
// On multisite, ensure user exists on current site, if not add them before allowing login.
if (is_multisite()) {
$user_data = get_user_by('login', $username);
if ($user_data && !is_user_member_of_blog($user_data->ID, get_current_blog_id())) {
add_user_to_blog(get_current_blog_id(), $user_data->ID, 'customer');
}
}
// Perform the login
$user = wp_signon(apply_filters('woocommerce_login_credentials', $creds), is_ssl());
if (is_wp_error($user)) {
$message = $user->get_error_message();
$message = str_replace('<strong>' . esc_html($creds['user_login']) . '</strong>', '<strong>' . esc_html($username) . '</strong>', $message);
throw new Exception($message);
} else {
if (!empty($_POST['redirect'])) {
$redirect = $_POST['redirect'];
} elseif (wp_get_referer()) {
$redirect = wp_get_referer();
} else {
$redirect = wc_get_page_permalink('myaccount');
}
wp_redirect(apply_filters('woocommerce_login_redirect', $redirect, $user));
exit;
}
} catch (Exception $e) {
wc_add_notice(apply_filters('login_errors', $e->getMessage()), 'error');
do_action('woocommerce_login_failed');
}
}
}
/**
* Checks for a template to use, and if it exists, copies the templated settings to the new blog
*
* @param mixed $blog_id
* @param mixed $user_id
*
* @since 1.0
*/
function set_blog_defaults($blog_id, $user_id, $_passed_domain = false, $_passed_path = false, $_passed_site_id = false, $_passed_meta = false)
{
global $wpdb, $multi_dm;
/* Start special Multi-Domain feature */
if (!empty($multi_dm)) {
$bloginfo = get_blog_details((int) $blog_id, false);
foreach ($multi_dm->domains as $multi_domain) {
if (strpos($bloginfo->domain, $multi_domain['domain_name'])) {
if (isset($multi_domain['blog_template']) && !empty($this->options['templates'][$multi_domain['blog_template']])) {
$default = $this->options['templates'][$multi_domain['blog_template']];
}
}
}
}
/* End special Multi-Domain feature */
if (empty($default) && isset($this->options['default']) && is_numeric($this->options['default'])) {
// select global default
$default = isset($this->options['templates'][$this->options['default']]) ? $this->options['templates'][$this->options['default']] : false;
}
$template = '';
// Check $_POST first for passed template and use that, if present.
// Otherwise, check passed meta from blog signup.
// Lastly, apply the default.
if (isset($_POST['blog_template']) && is_numeric($_POST['blog_template'])) {
//If they've chosen a template, use that. For some reason, when PHP gets 0 as a posted var, it doesn't recognize it as is_numeric, so test for that specifically
$template = $this->options['templates'][$_POST['blog_template']];
} else {
if ($_passed_meta && isset($_passed_meta['blog_template']) && is_numeric($_passed_meta['blog_template'])) {
// Do we have a template in meta?
$template = $this->options['templates'][$_passed_meta['blog_template']];
// Why, yes. Yes, we do. Use that.
} else {
if ($default) {
//If they haven't chosen a template, use the default if it exists
$template = $default;
}
}
}
$template = apply_filters('blog_templates-blog_template', $template, $blog_id, $user_id, $this);
if (!$template || 'none' == $template) {
return;
}
//No template, lets leave
//Begin the transaction
$wpdb->query("BEGIN;");
switch_to_blog($blog_id);
//Switch to the blog that was just created
//Get the prefixes, so we don't have to worry about regex, or changes to WP's naming conventions
$new_prefix = $wpdb->prefix;
//Don't forget to get the template blog's prefix
switch_to_blog($template['blog_id']);
$template_prefix = $wpdb->prefix;
//Now, go back to the new blog that was just created
restore_current_blog();
foreach ($template['to_copy'] as $value) {
switch ($value) {
case 'settings':
//We can't use the helper functions here, because we need to save some of the settings
$exclude_settings = apply_filters('blog_template_exclude_settings', "`option_name` != 'siteurl' AND `option_name` != 'blogname' AND `option_name` != 'admin_email' AND `option_name` != 'new_admin_email' AND `option_name` != 'home' AND `option_name` != 'upload_path' AND `option_name` != 'db_version' AND `option_name` != 'secret' AND `option_name` != 'fileupload_url' AND `option_name` != 'nonce_salt'");
//Delete the current options, except blog-specific options
$wpdb->query("DELETE FROM {$wpdb->options} WHERE {$exclude_settings}");
if (!$wpdb->last_error) {
//No error. Good! Now copy over the old settings
//Switch to the template blog, then grab the settings/plugins/templates values from the template blog
switch_to_blog($template['blog_id']);
$templated = $wpdb->get_results("SELECT * FROM {$wpdb->options} WHERE {$exclude_settings}");
restore_current_blog();
//Switch back to the newly created blog
//Now, insert the templated settings into the newly created blog
foreach ($templated as $row) {
//Make sure none of the options are using wp_X_ convention, and if they are, replace the value with the new blog ID
$row->option_name = str_replace($template_prefix, $new_prefix, $row->option_name);
if ('sidebars_widgets' != $row->option_name) {
/* <-- Added this to prevent unserialize() call choking on badly formatted widgets pickled array */
$row->option_value = str_replace($template_prefix, $new_prefix, $row->option_value);
}
//To prevent duplicate entry errors, since we're not deleting ALL of the options, there could be an ID collision
unset($row->option_id);
// For template blogs with deprecated DB schema (WP3.4+)
if (!(defined('NBT_TIGHT_ROW_DUPLICATION') && NBT_TIGHT_ROW_DUPLICATION)) {
unset($row->blog_id);
}
// Add further processing for options row
$row = apply_filters('blog_templates-copy-options_row', $row, $template, $blog_id, $user_id);
if (!$row) {
continue;
}
// Prevent empty row insertion
//Insert the row
$wpdb->insert($wpdb->options, (array) $row);
//Check for errors
if (!empty($wpdb->last_error)) {
$error = '<div id="message" class="error"><p>' . sprintf(__('Insertion Error: %s - The template was not applied. (New Blog Templates - While inserting templated settings)', $this->localization_domain), $wpdb->last_error) . '</p></div>';
$wpdb->query("ROLLBACK;");
//We've rolled it back and thrown an error, we're done here
restore_current_blog();
wp_die($error);
}
}
do_action('blog_templates-copy-options', $template);
} else {
$error = '<div id="message" class="error"><p>' . sprintf(__('Deletion Error: %s - The template was not applied. (New Blog Templates - While removing auto-generated settings)', $this->localization_domain), $wpdb->last_error) . '</p></div>';
$wpdb->query("ROLLBACK;");
restore_current_blog();
//Switch back to our current blog
wp_die($error);
}
break;
case 'posts':
$this->clear_table($wpdb->posts);
$this->copy_table($template['blog_id'], "posts");
do_action('blog_templates-copy-posts', $template, $blog_id, $user_id);
$this->clear_table($wpdb->postmeta);
$this->copy_table($template['blog_id'], "postmeta");
do_action('blog_templates-copy-postmeta', $template, $blog_id, $user_id);
break;
case 'terms':
$this->clear_table($wpdb->links);
$this->copy_table($template['blog_id'], "links");
do_action('blog_templates-copy-links', $template, $blog_id, $user_id);
$this->clear_table($wpdb->terms);
$this->copy_table($template['blog_id'], "terms");
do_action('blog_templates-copy-terms', $template, $blog_id, $user_id);
$this->clear_table($wpdb->term_relationships);
$this->copy_table($template['blog_id'], "term_relationships");
do_action('blog_templates-copy-term_relationships', $template, $blog_id, $user_id);
$this->clear_table($wpdb->term_taxonomy);
$this->copy_table($template['blog_id'], "term_taxonomy");
do_action('blog_templates-copy-term_taxonomy', $template, $blog_id, $user_id);
break;
case 'users':
//Copy over the users to this blog
$users = $wpdb->get_results("SELECT * FROM {$wpdb->usermeta} WHERE user_id != {$user_id} AND meta_key REGEXP '^" . mysql_escape_string($template_prefix) . "[^0-9]'");
if (empty($users)) {
continue;
}
//If there are no users to copy, just leave. We don't want to leave this blog without any users
//Delete the auto user from the blog, to prevent duplicates or erroneous users
$wpdb->query("DELETE FROM {$wpdb->usermeta} WHERE user_id != {$user_id} AND meta_key LIKE '" . mysql_escape_string($new_prefix) . "%'");
if (!empty($wpdb->last_error)) {
$error = '<div id="message" class="error"><p>' . sprintf(__('Deletion Error: %s - The template was not applied. (New Blog Templates - While removing auto-generated users)', $this->localization_domain), $wpdb->last_error) . '</p></div>';
$wpdb->query("ROLLBACK;");
//We've rolled it back and thrown an error, we're done here
restore_current_blog();
wp_die($error);
}
$postprocess_add_new_user_action = false;
//Now, insert the templated settings into the newly created blog
foreach ($users as $user) {
// Check if the user ID from email entered via the New Blog form has been added, and if not, add them after the foreach loop...
if (!$postprocess_add_new_user_action && $user->user_id != $user_id) {
$postprocess_add_new_user_action = true;
}
if ($user->user_id == $user_id) {
continue;
}
// Carry on...
$user->meta_key = str_replace($template_prefix, $new_prefix, $user->meta_key);
unset($user->umeta_id);
//Remove the umeta_id field, let it autoincrement
// Further user entry processing
$user = apply_filters('blog_templates-copy-user_entry', $user, $template, $blog_id, $user_id);
if (!$user) {
continue;
}
// Skip empty user objects
//Insert the user
$wpdb->insert($wpdb->usermeta, (array) $user);
//Check for errors
if (!empty($wpdb->last_error)) {
$error = '<div id="message" class="error"><p>' . sprintf(__('Insertion Error: %s - The template was not applied. (New Blog Templates - While inserting templated users)', $this->localization_domain), $wpdb->last_error) . '</p></div>';
$wpdb->query("ROLLBACK;");
//We've rolled it back and thrown an error, we're done here
restore_current_blog();
wp_die($error);
}
}
if ($postprocess_add_new_user_action) {
add_user_to_blog($blog_id, $user_id, 'administrator');
}
do_action('blog_templates-copy-users', $template, $blog_id, $user_id);
break;
case 'files':
global $wp_filesystem;
$dir_to_copy = $this->_get_files_fs_path($template['blog_id']);
//ABSPATH . 'wp-content/blogs.dir/' . $template['blog_id'] . '/files';
$dir_to_copy = apply_filters('blog_templates-copy-source_directory', $dir_to_copy, $template, $blog_id, $user_id);
$dir_to_copy_into = $this->_get_files_fs_path($blog_id);
//ABSPATH .'wp-content/blogs.dir/' . $blog_id . '/files';
$dir_to_copy_into = apply_filters('blog_templates-copy-target_directory', $dir_to_copy_into, $template, $blog_id, $user_id);
if (is_dir($dir_to_copy)) {
if (wp_mkdir_p($dir_to_copy_into)) {
require_once ABSPATH . 'wp-admin/includes/class-wp-filesystem-base.php';
require_once ABSPATH . 'wp-admin/includes/class-wp-filesystem-direct.php';
if (isset($wp_filesystem)) {
$orig_filesystem = wp_clone($wp_filesystem);
}
$wp_filesystem = new WP_Filesystem_Direct(false);
if (!defined('FS_CHMOD_DIR')) {
define('FS_CHMOD_DIR', 0755);
}
if (!defined('FS_CHMOD_FILE')) {
define('FS_CHMOD_FILE', 0644);
}
copy_dir($dir_to_copy, $dir_to_copy_into);
unset($wp_filesystem);
if (isset($orig_filesystem)) {
$wp_filesystem = wp_clone($orig_filesystem);
}
if (@file_exists($dir_to_copy_into . '/sitemap.xml')) {
@unlink($dir_to_copy_into . '/sitemap.xml');
}
} else {
$error = '<div id="message" class="error"><p>' . sprintf(__('File System Error: Unable to create directory %s. (New Blog Templates - While copying files)', $this->localization_domain), $dir_to_copy_into) . '</p></div>';
$wpdb->query('ROLLBACK;');
restore_current_blog();
wp_die($error);
}
}
break;
}
}
//Are there any additional tables we need to copy?
/*error_log('Begin Additional Tables code');
echo 'Before additional tables code<br/>';*/
if (isset($template['additional_tables']) && is_array($template['additional_tables'])) {
//echo 'is array<br/>';
foreach ($template['additional_tables'] as $add) {
$add = mysql_escape_string($add);
//Just in case
$result = $wpdb->get_results("SHOW TABLES LIKE '" . str_replace($template_prefix, $new_prefix, $add) . "'", ARRAY_N);
if (!empty($result)) {
//Is the table present? Clear it, then copy
//echo ("table exists: $add<br/>");
$this->clear_table($add);
//Copy the DB
$this->copy_table($template['blog_id'], str_replace($template_prefix, '', $add));
} else {
//The table's not present, add it and copy the data from the old one
//echo ('table doesn\'t exist<br/>');
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
// Changed
if (class_exists("m_wpdb")) {
$conns = $wpdb->dbh_connections;
//$multi_db = $conns['global']['name'] . '.';
unset($conns['global']);
$current = current($conns);
$current_db = $current['name'] . '.';
$add_table = explode('.', $add);
$add_table = $add_table[1];
} else {
$multi_db = $current_db = '';
$add_table = $add;
}
$wpdb->query("CREATE TABLE IF NOT EXISTS {$current_db}" . str_replace($template_prefix, $new_prefix, $add_table) . " LIKE {$add}");
$wpdb->query("INSERT {$current_db}" . str_replace($template_prefix, $new_prefix, $add_table) . " SELECT * FROM {$add}");
// End changed
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
if (!empty($wpdb->last_error)) {
$error = '<div id="message" class="error"><p>' . sprintf(__('Insertion Error: %s - The template was not applied. (New Blog Templates - With CREATE TABLE query for Additional Tables)', $this->localization_domain), $wpdb->last_error) . '</p></div>';
$wpdb->query("ROLLBACK;");
//We've rolled it back and thrown an error, we're done here
restore_current_blog();
wp_die($error);
}
}
}
}
//error_log('Finished Successfully');
$wpdb->query("COMMIT;");
//If we get here, everything's fine. Commit the transaction
do_action("blog_templates-copy-after_copying", $template, $blog_id, $user_id);
restore_current_blog();
//Switch back to our current blog
}
public static function create_wp_user($wp_user_data)
{
if (self::is_multisite_install()) {
//MS install
global $blog_id;
if ($wp_user_id = email_exists($wp_user_data['user_email'])) {
// if user exists then just add him to current blog.
add_existing_user_to_blog(array('user_id' => $wp_user_id, 'role' => 'subscriber'));
return $wp_user_id;
}
$wp_user_id = wpmu_create_user($wp_user_data['user_login'], $wp_user_data['password'], $wp_user_data['user_email']);
$role = 'subscriber';
//TODO - add user as a subscriber first. The subsequent update user role function to update the role to the correct one
add_user_to_blog($blog_id, $wp_user_id, $role);
} else {
//Single site install
$wp_user_id = email_exists($wp_user_data['user_email']);
if ($wp_user_id) {
return $wp_user_id;
}
$wp_user_id = wp_create_user($wp_user_data['user_login'], $wp_user_data['password'], $wp_user_data['user_email']);
}
$wp_user_data['ID'] = $wp_user_id;
wp_update_user($wp_user_data);
$user_info = get_userdata($wp_user_id);
$user_cap = isset($user_info->wp_capabilities) && is_array($user_info->wp_capabilities) ? array_keys($user_info->wp_capabilities) : array();
if (!in_array('administrator', $user_cap)) {
SwpmUtils::update_wp_user_Role($wp_user_id, $wp_user_data['role']);
}
return $wp_user_id;
}
public function facebook_login_callback()
{
global $rm_env_requirements;
if (!($rm_env_requirements & RM_REQ_EXT_CURL)) {
return;
}
global $rm_fb_sdk_req;
$gopts = new RM_Options();
$fb_app_id = $gopts->get_value_of('facebook_app_id');
$fb_app_secret = $gopts->get_value_of('facebook_app_secret');
if (!$fb_app_id || !$fb_app_secret) {
return;
}
if ($rm_fb_sdk_req === RM_FB_SDK_REQ_OK) {
$fb = new Facebook\Facebook(array('app_id' => $fb_app_id, 'app_secret' => $fb_app_secret, 'default_graph_version' => 'v2.2'));
$helper = $fb->getRedirectLoginHelper();
try {
$accessToken = $helper->getAccessToken();
} catch (Facebook\Exceptions\FacebookResponseException $e) {
// When Graph returns an error
echo 'Graph returned an error: ' . $e->getMessage();
exit;
} catch (Facebook\Exceptions\FacebookSDKException $e) {
// When validation fails or other local issues
echo 'Facebook SDK returned an error: ' . $e->getMessage();
exit;
}
if (!isset($accessToken)) {
if ($helper->getError()) {
header('HTTP/1.0 401 Unauthorized');
echo "Error: " . $helper->getError() . "\n";
echo "Error Code: " . $helper->getErrorCode() . "\n";
echo "Error Reason: " . $helper->getErrorReason() . "\n";
echo "Error Description: " . $helper->getErrorDescription() . "\n";
} else {
header('HTTP/1.0 400 Bad Request');
echo 'Bad request';
}
exit;
}
// Logged in
// echo '<h3>Access Token</h3>';
//var_dump($accessToken->getValue());
// The OAuth 2.0 client handler helps us manage access tokens
$oAuth2Client = $fb->getOAuth2Client();
// Get the access token metadata from /debug_token
$tokenMetadata = $oAuth2Client->debugToken($accessToken);
//echo '<h3>Metadata</h3>';
//var_dump($tokenMetadata);
// Validation (these will throw FacebookSDKException's when they fail)
$tokenMetadata->validateAppId($fb_app_id);
// Replace {app-id} with your app id
// If you know the user ID this access token belongs to, you can validate it here
//$tokenMetadata->validateUserId('123');
$tokenMetadata->validateExpiration();
if (!$accessToken->isLongLived()) {
// Exchanges a short-lived access token for a long-lived one
try {
$accessToken2 = $oAuth2Client->getLongLivedAccessToken($accessToken);
} catch (Facebook\Exceptions\FacebookSDKException $e) {
echo "<p>Error getting long-lived access token: " . $helper->getMessage() . "</p>\n\n";
exit;
}
//echo '<h3>Long-lived</h3>';
//var_dump($accessToken2->getValue());
}
//$_SESSION['fb_access_token'] = (string) $accessToken;
try {
// Returns a `Facebook\FacebookResponse` object
$response = $fb->get('/me?fields=id,name,email,first_name,last_name', (string) $accessToken);
} catch (Facebook\Exceptions\FacebookResponseException $e) {
echo 'Graph returned an error: ' . $e->getMessage();
exit;
} catch (Facebook\Exceptions\FacebookSDKException $e) {
echo 'Facebook SDK returned an error: ' . $e->getMessage();
exit;
}
$user = $response->getGraphUser();
//var_dump($user->getFirstName());
$user_name = $user->getName();
$user_email = $user->getEmail();
$user_name = $user->getName();
$user_fname = $user->getFirstName();
$user_lname = $user->getLastName();
$redirection_post = $gopts->get_value_of('post_submission_redirection_url');
if (email_exists($user_email)) {
// user is a member
$user = get_user_by('email', $user_email);
$user_id = $user->ID;
wp_set_auth_cookie($user_id, true);
} else {
// this user is a guest
$random_password = wp_generate_password(10, false);
$user_id = wp_create_user($user_email, $random_password, $user_email);
if (!is_wp_error($user_id)) {
if (function_exists('is_multisite') && is_multisite()) {
add_user_to_blog(get_current_blog_id(), $user_id, 'subscriber');
}
update_user_meta($user_id, 'avatar_image', 'https://graph.facebook.com/' . $user->getId() . '/picture?type=large');
wp_update_user(array('ID' => $user_id, 'display_name' => $user_name, 'first_name' => $user_fname, 'last_name' => $user_lname));
wp_set_auth_cookie($user_id, true);
}
}
} else {
$fb = new Facebook(array('appId' => $fb_app_id, 'secret' => $fb_app_secret));
$user = $fb->getUser();
if ($user) {
$user_profile = $fb->api('/me?fields=id,name,email,first_name,last_name');
if (isset($user_profile['email'])) {
$user_email = $user_profile['email'];
$redirection_post = $gopts->get_value_of('post_submission_redirection_url');
if (email_exists($user_email)) {
// user is a member
$user = get_user_by('email', $user_email);
$user_id = $user->ID;
wp_set_auth_cookie($user_id, true);
} else {
// this user is a guest
$random_password = wp_generate_password(10, false);
$user_id = wp_create_user($user_email, $random_password, $user_email);
if (!is_wp_error($user_id)) {
if (function_exists('is_multisite') && is_multisite()) {
add_user_to_blog(get_current_blog_id(), $user_id, 'subscriber');
}
update_user_meta($user_id, 'avatar_image', 'https://graph.facebook.com/' . $user_profile['id'] . '/picture?type=large');
wp_update_user(array('ID' => $user_id, 'display_name' => $user_profile['name'], 'first_name' => $user_profile['first_name'], 'last_name' => $user_profile['last_name']));
wp_set_auth_cookie($user_id, true);
}
}
} else {
die('Error: Unable to fetch email address from Facebbok.');
}
}
}
if ($redirection_post > 0) {
$after_login_url = get_permalink($redirection_post);
} else {
$after_login_url = home_url();
}
RM_Utilities::redirect($after_login_url);
}
