public function get_form()
{
$users = Users::get_all();
$users = Utils::array_map_field($users, 'username', 'id');
$form = new FormUI('sudo');
$form->append(new FormControlSelect('userlist', 'null:null', 'Become User:'******'submit', 'Submit'));
$form->set_option('form_action', URL::get('sudo'));
$form->onsubmit = 'return dosudo.setuser();';
return $form;
}
public function action_form_publish_proposal($form, $post)
{
$users = Users::get_all();
$client_options = array();
foreach ($users as $user) {
if ($user->client) {
$client_options[$user->id] = $user->client->title . ' : ' . $user->displayname;
}
}
$form->insert('content', new FormControlSelect('client_contact', $post, 'Client Contact', $client_options, 'admincontrol_select'));
$group = UserGroups::get(array('id' => Options::get('staff__group'), 'fetch_fn' => 'get_row'));
$user_options = array();
foreach ($group->users as $user) {
$user_options[$user->id] = $user->displayname;
}
$form->insert('content', new FormControlSelect('staff', $post, 'Staff', $user_options, 'admincontrol_select'));
}
/**
* Handles GET requests for a group's page.
*/
public function get_group()
{
$group = UserGroup::get_by_id($this->handler_vars['id']);
if (null == $group) {
Utils::redirect(URL::get('admin', 'page=groups'));
} else {
$tokens = ACL::all_tokens('id');
$access_names = ACL::$access_names;
$access_names[] = 'deny';
// attach access bitmasks to the tokens
foreach ($tokens as $token) {
$token->access = ACL::get_group_token_access($group->id, $token->id);
}
// separate tokens into groups
$grouped_tokens = array();
foreach ($tokens as $token) {
$grouped_tokens[$token->token_group][$token->token_type ? 'crud' : 'bool'][] = $token;
}
$group = UserGroup::get_by_id($this->handler_vars['id']);
$potentials = array();
$users = Users::get_all();
$users[] = User::anonymous();
$members = $group->members;
$jsusers = array();
foreach ($users as $user) {
$jsuser = new StdClass();
$jsuser->id = $user->id;
$jsuser->username = $user->username;
$jsuser->member = in_array($user->id, $members);
$jsusers[$user->id] = $jsuser;
}
$this->theme->potentials = $potentials;
$this->theme->users = $users;
$this->theme->members = $members;
$js = '$(function(){groupManage.init(' . json_encode($jsusers) . ');});';
Stack::add('admin_header_javascript', $js, 'groupmanage', 'admin');
$this->theme->access_names = $access_names;
$this->theme->grouped_tokens = $grouped_tokens;
$this->theme->groups = UserGroups::get_all();
$this->theme->group = $group;
$this->theme->id = $group->id;
$this->theme->wsse = Utils::WSSE();
$this->display('group');
}
}
/**
* Invalidates (expires) the cache entries for the give list of URLs.
*
* @param array $urls An array of urls to clear
*/
public function cache_invalidate(array $urls)
{
// account for annonymous user (id=0)
$user_ids = array_map(create_function('$a', 'return $a->id;'), Users::get_all()->getArrayCopy());
array_push($user_ids, "0");
// expire the urls for each user id
foreach ($user_ids as $user_id) {
foreach ($urls as $url) {
$request_id = self::get_request_id($user_id, $url);
if (Cache::has(array(self::GROUP_NAME, $request_id))) {
Cache::expire(array(self::GROUP_NAME, $request_id));
EventLog::log('Clearing request ID: ' . $request_id, 'info', 'plugin', 'StaticCache');
}
}
}
}
<?php
namespace Habari;
if (!defined('HABARI_PATH')) {
die('No direct access');
}
?>
<ul>
<?php
foreach (Users::get_all() as $user) {
if ($user->username == $currentuser->username) {
$url = Url::get('own_user_profile');
} else {
$url = Url::get('user_profile', array('user' => $user->username));
}
?>
<li class="item">
<div>
<span class="checkbox"><span><input type="checkbox" class="checkbox select_user" value="<?php
echo $user->id;
?>
"></span></span>
<span class="user"><a href="<?php
echo $url;
?>
" title="<?php
printf(_t('Open %s\'s user page'), $user->displayname);
?>
"><?php
public function save_mainmenu($form)
{
$base_url = Site::get_url('habari', true);
$start_url = $form->mainmenus->value;
/* Strip out the base URL from the requested URL */
/* but only if the base URL isn't / */
if ('/' != $base_url) {
$start_url = str_replace($base_url, '', $start_url);
}
/* Trim off any leading or trailing slashes */
$start_url = trim($start_url, '/');
/* Remove the querystring from the URL */
if (strpos($start_url, '?') !== FALSE) {
list($start_url, $query_string) = explode('?', $start_url);
}
/* Allow plugins to rewrite the stub before it's passed through the rules */
$start_url = Plugins::filter('rewrite_request', $start_url);
$stub = $start_url;
/* Grab the URL filtering rules from DB */
$matched_rule = URL::parse($stub);
if ($matched_rule === FALSE) {
print 'error, cant find rule';
// error!!!!
}
/* Return $_GET values to their proper place */
$args = array();
if (!empty($query_string)) {
parse_str($query_string, $args);
}
$rule = $matched_rule->name;
$args = array_merge($matched_rule->named_arg_values, $args);
if (User::identify()->can('super_user') && $form->affect_all->value == true) {
foreach (Users::get_all() as $user) {
$user->info->admindetour_real = array('rule' => $rule, 'args' => $args);
$user->update();
}
} else {
User::identify()->info->admindetour_real = array('rule' => $rule, 'args' => $args);
}
$_POST[$form->mainmenus->field] = URL::get($rule, $args);
$form->save();
}
<?php
if (isset($_SESSION['user'])) {
$usr = new Users();
$usr = $usr->get($_SESSION['user']);
if (!$usr) {
header('HTTP/1.0 302 Found');
header("Location: index.php?map=login&page=index");
exit;
}
}
$users = new Users();
$leden = $users->get_all();
?>
<div class="page-header">
<h3>
<i class="fa fa-fw fa-users"></i> Leden <small>Overzicht</small>
</h3>
</div>
<div class="row">
<div class="col-md-12">
<div class="box box-primary">
<div class="box-body">
<table class="table table-striped">
<thead>
<tr>
<th>Naam</th>
<th>Band</th>
<th>Fan</th>
/**
* Assign values needed to display the users listing
*
*/
private function fetch_users($params = null)
{
// prepare the WSSE tokens
$this->theme->wsse = Utils::WSSE();
// Get author list
$author_list = Users::get_all();
$authors[0] = _t('nobody');
foreach ($author_list as $author) {
$authors[$author->id] = $author->displayname;
}
$this->theme->authors = $authors;
}
/**
* filter: fireeagle_refresh
*
* @access public
* @param boolean $result
* @return boolean
*/
public function filter_fireeagle_refresh($result)
{
$users = Users::get_all();
foreach ($users as $user) {
$location = $this->update((int) $user->id);
if (!$location) {
continue;
}
}
$result = true;
return $result;
}
private function upgrade_db_post_3030()
{
// Create the admin group
$group = UserGroup::create(array('name' => 'admin'));
if (!$group) {
return false;
}
// Add the default tokens
ACL::create_default_tokens();
// Give admin group access to the super_user token
$group->grant('super_user');
// Until now, all users were admins, restore that
$all_users = Users::get_all();
foreach ($all_users as $user) {
$group->add($user);
}
// Create the anonymous group
$this->create_anonymous_group();
}
/**
* Get users created by this module.
* @param integer $num number of users to get, or all if not specified.
* @return array users found.
*/
private function populate_users_get($num = null)
{
// get all tokens
$allusers = Users::get_all();
// internal loop to get only our users.
$users = array();
$count = 0;
foreach ($allusers as $id => $user) {
if (strpos($user->username, 'opulate_')) {
$users[] = $user;
if (isset($num) && $num == ++$count) {
break;
}
}
}
return $users;
}
/**
* Reset premissions to their default state
*/
public static function rebuild_permissions($user = null)
{
// Clear out all permission-related values
DB::query('DELETE FROM {tokens}');
DB::query('DELETE FROM {group_token_permissions}');
//DB::query( 'DELETE FROM {groups}' );
DB::query('DELETE FROM {post_tokens}');
DB::query('DELETE FROM {user_token_permissions}');
//DB::query('DELETE FROM {users_groups}');
// Create initial groups if they don't already exist
$admin_group = UserGroup::get_by_name(_t('admin'));
if (!$admin_group instanceof UserGroup) {
$admin_group = UserGroup::create(array('name' => _t('admin')));
}
$anonymous_group = UserGroup::get_by_name(_t('anonymous'));
if (!$anonymous_group instanceof UserGroup) {
$anonymous_group = UserGroup::create(array('name' => _t('anonymous')));
}
// Add all users or the passed user to the admin group
if (empty($user)) {
$users = Users::get_all();
$ids = array();
foreach ($users as $user) {
$ids[] = $user->id;
}
$admin_group->add($ids);
} else {
$admin_group->add($user);
}
// create default permissions
self::create_default_tokens();
// Make the admin group all superusers
$admin_group->grant('super_user');
// Add entry and page read access to the anonymous group
$anonymous_group->grant('post_entry', 'read');
$anonymous_group->grant('post_page', 'read');
$anonymous_group->grant('comment');
$anonymous_group->deny('post_unpublished');
// Add the anonymous user to the anonymous group
$anonymous_group->add(0);
// Create the default authenticated group
$authenticated_group = UserGroup::get_by_name(_t('authenticated'));
if (!$authenticated_group instanceof UserGroup) {
$authenticated_group = UserGroup::create(array('name' => _t('authenticated')));
}
$authenticated_group->grant('post_entry', 'read');
$authenticated_group->grant('post_page', 'read');
$authenticated_group->grant('comment');
}
/**
* Handles GET requests for a group's page.
*/
public function get_group()
{
$group = UserGroup::get_by_id(Controller::get_var('id'));
if (null == $group) {
Utils::redirect(URL::get('display_groups', 'page=groups'));
} else {
$tokens = ACL::all_tokens('id');
$tokens = Plugins::filter('token_list_display', $tokens);
array_walk($tokens, function (&$value, $key) {
$value->description = Plugins::filter('token_description_display', $value->name);
$value->token_group = Plugins::filter('token_group_display', $value->token_group);
});
$access_names = ACL::access_names();
$access_names[] = 'deny';
$access_display = array();
foreach ($access_names as $name) {
$access_display[$name] = Plugins::filter('permission_display', $name);
}
$bool_access_display['allow'] = Plugins::filter('permission_display', 'allow');
$bool_access_display['deny'] = Plugins::filter('permission_display', 'deny');
// attach access bitmasks to the tokens
foreach ($tokens as $token) {
$token->access = ACL::get_group_token_access($group->id, $token->id);
}
// separate tokens into groups
$grouped_tokens = array();
foreach ($tokens as $token) {
$grouped_tokens[$token->token_group][$token->token_type ? 'crud' : 'bool'][] = $token;
}
$potentials = array();
$users = Users::get_all();
$users[] = User::anonymous();
$members = $group->members;
$jsusers = array();
foreach ($users as $user) {
$jsuser = new \StdClass();
$jsuser->id = $user->id;
$jsuser->username = $user->username;
$jsuser->member = in_array($user->id, $members);
$jsusers[$user->id] = $jsuser;
}
$this->theme->potentials = $potentials;
$this->theme->users = $users;
$this->theme->members = $members;
$js = '$(function(){groupManage.init(' . json_encode($jsusers) . ');});';
Stack::add('admin_header_javascript', $js, 'groupmanage', 'admin-js');
$this->theme->access_names = $access_names;
$this->theme->grouped_tokens = $grouped_tokens;
$this->theme->access_display = $access_display;
$this->theme->bool_access_display = $bool_access_display;
$this->theme->groups = UserGroups::get_all();
$this->theme->group = $group;
$this->theme->id = $group->id;
$this->theme->wsse = Utils::WSSE();
$this->display('group');
}
}
/**
* Create the UI for stage two of the WP import process
*
* This stage verifies the initial configuration values and then
* proceeds to gather information about the potentially imported
* data and display some confirmation information. If missing or
* invalid information was given, this method returns the output
* from stage1()
*
* @return string The UI for the second stage of the import process
*/
private function stage2()
{
$valid_fields = array('db_name', 'db_host', 'db_port', 'db_user', 'db_pass', 'db_prefix', 's9y_version', 's9y_root_web', 's9y_input_version', 'category_import', 'comments_ignore_unapproved', 'rewrites_import');
$inputs = $this->get_valid_inputs($valid_fields);
extract($inputs);
/* Verify required and expected values from input */
if (isset($comments_ignore_unapproved)) {
$comments_ignore_unapproved = 1;
}
if (isset($category_import)) {
$category_import = 1;
}
if (isset($rewrites_import)) {
$rewrites_import = 1;
}
if (empty($s9y_input_version) && empty($s9y_root_web)) {
/*
* We need either the version or the config file
* location to determine version of DB
*/
$this->warning = 'Please enter either a location to find the s9y configuration file (root web directory for s9y) OR the version of s9y to import';
return $this->stage1();
}
if (empty($db_host)) {
$this->warning = 'Please enter a value for the database host.';
return $this->stage1();
}
if (empty($db_name)) {
$this->warning = 'Please enter a name for the database to import.';
return $this->stage1();
}
if (empty($db_user)) {
$this->warning = 'Please enter a database username.';
return $this->stage1();
}
if (FALSE == ($s9ydb = $this->s9y_connect($db_host, $db_name, $db_user, $db_pass, $db_prefix, $db_port))) {
$this->warning = 'A connection to the specified database could not be created. Please check the values you provided.';
return $this->stage1();
}
/*
* OK, now calculate some information about the imported data that
* we can show to the user in the confirmation screen
*/
$num_imported_posts = $s9ydb->get_value("SELECT COUNT(*) FROM `{$db_prefix}entries`");
$comment_where = '';
if ($comments_ignore_unapproved == 1) {
$comment_where = "WHERE status = 'Approved' ";
}
$num_imported_comments = $s9ydb->get_value("SELECT COUNT(*) FROM `{$db_prefix}comments`" . $comment_where);
/*
* Users are important during import. We want to show the importer that
* we have identified X number of posting users (authors) and give the importer
* the ability to choose which authors they wish to import. During this
* step, let's try to map an incoming (imported) author to an existing Habari
* user...
*/
$user_sql = <<<ENDOFSQL
SELECT e.authorid, e.author, a.realname, a.username, a.email,COUNT(*) as num_posts
FROM `{$db_prefix}entries` e
INNER JOIN `{$db_prefix}authors` a
ON e.authorid = a.authorid
GROUP BY e.authorid, e.author
ENDOFSQL;
$imported_users = $s9ydb->get_results($user_sql);
$num_imported_users = count($imported_users);
/* Grab the categories from s9y to use as tags in Habari */
$num_imported_tags = 0;
if ($category_import == 1) {
$num_imported_tags = $s9ydb->get_value("SELECT COUNT(*) FROM `{$db_prefix}category`");
}
$output = <<<WP_IMPORT_STAGE2
\t\t\t<h3>To be imported</h3>
\t\t\t<p>
\t\t\tWe have identified information that will be imported into Habari. Please review
\t\t\tthe information below and continue with the import.
\t\t\t</p>
\t\t\t<div><strong>Found authors to be imported:</strong> {$num_imported_users}
WP_IMPORT_STAGE2;
if ($num_imported_users > 0) {
$output .= <<<WP_IMPORT_STAGE2
\t\t\t\t<div style="margin-left: 20px; padding 10px;">
\t\t\t\t<p>Check which users (and their posts) you wish to import</p>
\t\t\t\t<table>
\t\t\t\t<tr><th>Import?</th><th>Author Name</th><th>Email</th><th>Num Posts</th><th>Match in Habari?</th></tr>
WP_IMPORT_STAGE2;
foreach ($imported_users as $user) {
$output .= "<tr><td><input type='checkbox' name='import_user[{$user->authorid}]' value='1' checked='true' /></td>" . "<td>{$user->realname}</td><td>{$user->email}</td><td>{$user->num_posts}</td><td> ";
$user_table_name = DB::table('users');
$match_sql = <<<ENDOFSQL
SELECT id, username, email
FROM {$user_table_name}
WHERE email = ? OR username = ?
ENDOFSQL;
$match_params = array($user->email, $user->username);
$habari_matched_users = DB::get_results($match_sql, $match_params, 'User');
if (count($habari_matched_users) > 0) {
$output .= "<strong>Match found for habari user:</strong> ";
$matched_user = $habari_matched_users[0];
/* Just take the first match... */
$output .= $matched_user->username . "<input type=\"hidden\" name=\"merge_user_matched[{$user->authorid}]\" value=\"{$matched_user->id}\" />";
} else {
/* No matches. Allow importer to select a merged user account */
$all_habari_users = Users::get_all();
if (isset($all_habari_user_select)) {
$output .= $all_habari_user_select;
} else {
$all_habari_user_select = "<select name='merge_user[{$user->authorid}]'>";
$all_habari_user_select .= "<option value='__new_user' selected='true'>Create a new user</option>";
foreach ($all_habari_users as $habari_user) {
$all_habari_user_select .= "<option value='{$habari_user->id}'>Merge with {$habari_user->username}</option>";
}
$output .= $all_habari_user_select;
}
}
$output .= "</td></tr>";
}
$output .= "</table></div>";
} else {
/* No authors found to import. Display nothing to import and stop process */
$output .= "</div>";
return $output;
}
$output .= <<<WP_IMPORT_STAGE2
\t\t\t</div>
\t\t\t<div><strong>Found Blog Posts to be imported:</strong> {$num_imported_posts}</div>
\t\t\t<div><strong>Comments to be imported:</strong> {$num_imported_comments}</div>
WP_IMPORT_STAGE2;
if ($category_import == 1) {
$output .= <<<WP_IMPORT_STAGE2
\t\t\t<div><strong>Tags to be imported:</strong> {$num_imported_tags}</div>
WP_IMPORT_STAGE2;
}
if ($rewrites_import == 1) {
$output .= <<<WP_IMPORT_STAGE2
\t\t\t<div><strong>Porting Rewrites.</strong></div>
WP_IMPORT_STAGE2;
}
foreach ($inputs as $key => $value) {
$output .= "<input type='hidden' name='{$key}' value='" . htmlentities($value) . "' />";
}
$output .= <<<WP_IMPORT_STAGE2
\t\t\t<input type="hidden" name="stage" id="stage" value="2">
\t\t\t<p class="submit">
\t\t\t<input type="submit" name="import" value="Continue Import >>" /></p>
WP_IMPORT_STAGE2;
return $output;
}
/**
* Handles GET requests of the users page.
*/
public function get_users()
{
// Get author list
$author_list = Users::get_all();
$authors[0] = _t('nobody');
foreach ($author_list as $author) {
$authors[$author->id] = $author->displayname;
}
$this->theme->authors = $authors;
$this->theme->currentuser = User::identify();
$this->theme->add_user_form = FormUI::build('add_user', 'add_user')->get();
$this->theme->delete_users_form = FormUI::build('delete_users', 'delete_users')->get();
$this->theme->display('users');
}
