public static function get_role_title($role_name, $args = array())
{
global $wp_roles, $pp_role_defs, $pp_cap_caster;
$defaults = array('plural' => false, 'slug_fallback' => true, 'include_warnings' => false);
$args = array_merge($defaults, $args);
extract($args, EXTR_SKIP);
pp_init_cap_caster();
if (strpos($role_name, ':')) {
$arr_name = explode(':', $role_name);
if (!empty($arr_name[2])) {
$caption_prop = $plural ? 'name' : 'singular_name';
$warning = '';
if (isset($pp_role_defs->pattern_roles[$arr_name[0]])) {
$role_caption = $pp_role_defs->pattern_roles[$arr_name[0]]->labels->{$caption_prop};
if ($include_warnings && isset($wp_roles->role_names[$arr_name[0]]) && !$pp_cap_caster->is_valid_pattern_role($arr_name[0])) {
$warning = '<span class="pp-red"> ' . sprintf(__('(using default capabilities due to invalid %s definition)', 'pp'), $wp_roles->role_names[$arr_name[0]]) . '</span>';
}
} elseif ($slug_fallback) {
$role_caption = $arr_name[0];
} else {
return '';
}
$type_caption = '';
if ($type_obj = pp_get_type_object($arr_name[1], $arr_name[2])) {
$type_caption = $type_obj->labels->singular_name;
} else {
return $slug_fallback ? $role_name : '';
}
$cond_caption = '';
if (isset($arr_name[4])) {
$cond_caption = apply_filters('pp_condition_caption', ucwords(str_replace('_', ' ', $arr_name[4])), $arr_name[3], $arr_name[4]);
}
if ($cond_caption) {
return trim(sprintf(__('%1$s %2$s <span class="pp_nolink">- %3$s</span>%4$s', 'pp'), $type_caption, str_replace(' ', ' ', $role_caption), str_replace(' ', ' ', $cond_caption), $warning));
} else {
return trim(sprintf(__('%1$s %2$s %3$s', 'pp'), $type_caption, $role_caption, $warning));
}
}
} elseif (isset($wp_roles->role_names[$role_name])) {
return $wp_roles->role_names[$role_name];
} else {
return apply_filters('pp_role_title', $role_name, $args);
}
}
function get_metagroup_caps($default)
{
global $wpdb;
if (defined('PPC_VERSION')) {
$pp_supplemental_roles = $wpdb->get_col("SELECT role_name FROM {$wpdb->ppc_roles} AS r INNER JOIN {$wpdb->pp_groups} AS g ON g.ID = r.agent_id AND r.agent_type = 'pp_group' WHERE g.metagroup_type = 'wp_role' AND g.metagroup_id = '{$default}'");
} else {
$pp_supplemental_roles = $wpdb->get_col("SELECT role_name FROM {$wpdb->pp_roles} AS r INNER JOIN {$wpdb->pp_groups} AS g ON g.ID = r.group_id AND r.group_type = 'pp_group' AND r.scope = 'site' WHERE g.metagroup_type = 'wp_role' AND g.metagroup_id = '{$default}'");
}
$pp_filtered_types = pp_get_enabled_types('post');
$pp_metagroup_caps = array();
$pp_cap_caster = pp_init_cap_caster();
foreach ($pp_supplemental_roles as $_role_name) {
$role_specs = explode(':', $_role_name);
if (empty($role_specs[2]) || !in_array($role_specs[2], $pp_filtered_types)) {
continue;
}
// add all type-specific caps whose base property cap is included in this pattern role
// i.e. If 'edit_posts' is in the pattern role, grant $type_obj->cap->edit_posts
$pp_metagroup_caps = array_merge($pp_metagroup_caps, array_fill_keys($pp_cap_caster->get_typecast_caps($_role_name, 'site'), true));
}
return $pp_metagroup_caps;
}
function get_role_caps($role_name)
{
pp_init_cap_caster();
global $wp_roles, $pp_cap_caster, $pp_role_defs;
if (isset($pp_cap_caster->typecast_role_caps[$role_name])) {
return $pp_cap_caster->typecast_role_caps[$role_name];
} elseif (strpos($role_name, ':')) {
$arr_name = explode(':', $role_name);
if (!empty($arr_name[2])) {
$pp_cap_caster->typecast_role_caps[$role_name] = $pp_cap_caster->get_typecast_caps($role_name);
return $pp_cap_caster->typecast_role_caps[$role_name];
}
} elseif (isset($wp_roles->role_objects[$role_name])) {
return array_keys($wp_roles->role_objects[$role_name]->capabilities);
} elseif (isset($pp_role_defs->dynamic_role_caps[$role_name])) {
return $pp_cap_caster->dynamic_role_caps[$role_name];
} else {
return apply_filters('pp_role_caps', array(), $role_name);
}
}
function pp_supplement_user_allcaps(&$user)
{
global $pp_cap_helper;
if (pp_is_content_administrator()) {
// give content administrators (users with pp_administer_content capability in WP role) all PP-defined caps and type-specific post caps
$user->allcaps = apply_filters('pp_administrator_caps', array_merge($user->allcaps, $pp_cap_helper->all_type_caps));
} else {
if (!$user->ID) {
global $pp_role_defs;
$user->allcaps = array_merge($user->allcaps, array_fill_keys($pp_role_defs->anon_user_caps, true));
} else {
global $wp_roles, $wp_post_types, $wpdb;
// merge in caps from supplemental direct role assignments
foreach (array_keys($user->site_roles) as $role_name) {
if (isset($wp_roles->role_objects[$role_name])) {
$user->allcaps = array_merge($user->allcaps, $wp_roles->role_objects[$role_name]->capabilities);
} elseif (!strpos($role_name, ':')) {
$user->allcaps = array_merge($user->allcaps, array_fill_keys(apply_filters('pp_role_caps', array(), $role_name), true));
}
}
if (PP_MULTISITE && !is_user_member_of_blog() && empty($user->allcaps)) {
$user->allcaps['read'] = true;
}
}
// merge in caps from typecast WP role assignments (and also clear false-valued allcaps entries)
$pp_cap_caster = pp_init_cap_caster();
$user->allcaps = array_merge(array_diff($user->allcaps, array(false, 0)), $pp_cap_caster->get_user_typecast_caps($user));
}
}
function _pp_get_type_roles($for_item_source, $for_item_type, $require_caps = false)
{
global $pp_role_defs;
$type_roles = array();
if (empty($pp_role_defs->disabled_pattern_role_types[$for_item_type]) && post_type_exists($for_item_type)) {
if ($require_caps) {
$pp_cap_caster = pp_init_cap_caster();
if (empty($pp_cap_caster->pattern_role_type_caps)) {
$pp_cap_caster->define_pattern_caps();
}
$check_prop = taxonomy_exists($for_item_type) ? $pp_cap_caster->pattern_role_taxonomy_caps : $pp_cap_caster->pattern_role_type_caps;
} else {
$check_prop = array();
}
foreach ($pp_role_defs->pattern_roles as $role_name => $pattern_role) {
if (!$check_prop || !empty($check_prop[$role_name])) {
$type_roles["{$role_name}:{$for_item_source}:{$for_item_type}"] = $pattern_role->labels->singular_name;
}
}
}
// Consider WP roles which are enabled for direct supplemental assignment,
// but only if they have at least one type-defined capability and are not disabled for the object type
static $wp_type_roles = array();
if (!isset($wp_type_roles[$for_item_source]) || !isset($wp_type_roles[$for_item_source][$for_item_type])) {
$wp_type_roles[$for_item_source][$for_item_type] = array();
if ($pp_role_defs->direct_roles) {
global $wp_roles;
if ('-1' === $for_item_type) {
foreach (array_keys($pp_role_defs->direct_roles) as $role_name) {
$wp_type_roles[$for_item_source][$for_item_type][$role_name] = $pp_role_defs->direct_roles[$role_name]->labels->singular_name;
}
} elseif ($type_obj = pp_get_type_object($for_item_source, $for_item_type)) {
$type_caps = (array) $type_obj->cap;
$check_type_caps = array_diff_key(array_fill_keys($type_caps, true), array('read' => true));
$cap_caster = pp_init_cap_caster();
$cap_caster->define_pattern_caps();
foreach (array_keys($pp_role_defs->direct_roles) as $role_name) {
if (array_intersect_key($check_type_caps, $wp_roles->role_objects[$role_name]->capabilities) || !empty($cap_caster->pattern_role_arbitrary_caps[$role_name])) {
$wp_type_roles[$for_item_source][$for_item_type][$role_name] = $pp_role_defs->direct_roles[$role_name]->labels->singular_name;
}
}
}
}
}
$type_roles = array_merge($type_roles, $wp_type_roles[$for_item_source][$for_item_type]);
return apply_filters('pp_get_type_roles', $type_roles, $for_item_source, $for_item_type);
}
