Skip to:
Content

BuddyPress.org

Changeset 10525


Ignore:
Timestamp:
02/05/2016 05:37:16 AM (11 years ago)
Author:
boonebgorges
Message:

Move bp-xprofile classes to their own files.

See #6870.

Location:
trunk/src/bp-xprofile
Files:
3 edited
3 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/bp-xprofile/bp-xprofile-admin.php

    r10434 r10525  
    1010// Exit if accessed directly.
    1111defined( 'ABSPATH' ) || exit;
     12
     13require dirname( __FILE__ ) . '/classes/class-bp-xprofile-user-admin.php';
    1214
    1315/**
    … …  
    671673}
    672674
    673 if ( ! class_exists( 'BP_XProfile_User_Admin' ) ) :
    674 
    675 /**
    676  * Load xProfile Profile admin area.
    677  *
    678  * @since 2.0.0
    679  */
    680 class BP_XProfile_User_Admin {
    681 
    682         /**
    683          * Setup xProfile User Admin.
    684          *
    685          * @since 2.0.0
    686          *
    687          * @uses buddypress() to get BuddyPress main instance.
    688          */
    689         public static function register_xprofile_user_admin() {
    690 
    691                 // Bail if not in admin.
    692                 if ( ! is_admin() ) {
    693                         return;
    694                 }
    695 
    696                 $bp = buddypress();
    697 
    698                 if ( empty( $bp->profile->admin ) ) {
    699                         $bp->profile->admin = new self;
    700                 }
    701 
    702                 return $bp->profile->admin;
    703         }
    704 
    705         /**
    706          * Constructor method.
    707          *
    708          * @since 2.0.0
    709          */
    710         public function __construct() {
    711                 $this->setup_actions();
    712         }
    713 
    714         /**
    715          * Set admin-related actions and filters.
    716          *
    717          * @since 2.0.0
    718          */
    719         private function setup_actions() {
    720                 // Enqueue scripts.
    721                 add_action( 'bp_members_admin_enqueue_scripts',  array( $this, 'enqueue_scripts'    ), 10, 1 );
    722 
    723                 // Register the metabox in Member's community admin profile.
    724                 add_action( 'bp_members_admin_xprofile_metabox', array( $this, 'register_metaboxes' ), 10, 3 );
    725 
    726                 // Saves the profile actions for user ( avatar, profile fields ).
    727                 add_action( 'bp_members_admin_update_user',      array( $this, 'user_admin_load'    ), 10, 4 );
    728         }
    729 
    730         /**
    731          * Enqueue needed scripts.
    732          *
    733          * @since 2.3.0
    734          *
    735          * @param int $screen_id Screen ID being displayed.
    736          */
    737         public function enqueue_scripts( $screen_id ) {
    738                 if ( ( false === strpos( $screen_id, 'users_page_bp-profile-edit' )
    739                         && false === strpos( $screen_id, 'profile_page_bp-profile-edit' ) )
    740                         || bp_core_get_root_option( 'bp-disable-avatar-uploads' )
    741                         || ! buddypress()->avatar->show_avatars
    742                         || ! bp_attachments_is_wp_version_supported() ) {
    743                         return;
    744                 }
    745 
    746                 /**
    747                  * Get Thickbox.
    748                  *
    749                  * We cannot simply use add_thickbox() here as WordPress is not playing
    750                  * nice with Thickbox width/height see https://core.trac.wordpress.org/ticket/17249
    751                  * Using media-upload might be interesting in the future for the send to editor stuff
    752                  * and we make sure the tb_window is wide enougth
    753                  */
    754                 wp_enqueue_style ( 'thickbox' );
    755                 wp_enqueue_script( 'media-upload' );
    756 
    757                 // Get Avatar Uploader.
    758                 bp_attachments_enqueue_scripts( 'BP_Attachment_Avatar' );
    759         }
    760 
    761         /**
    762          * Register the xProfile metabox on Community Profile admin page.
    763          *
    764          * @since 2.0.0
    765          *
    766          * @param int         $user_id       ID of the user being edited.
    767          * @param string      $screen_id     Screen ID to load the metabox in.
    768          * @param object|null $stats_metabox Context and priority for the stats metabox.
    769          */
    770         public function register_metaboxes( $user_id = 0, $screen_id = '', $stats_metabox = null ) {
    771 
    772                 // Set the screen ID if none was passed.
    773                 if ( empty( $screen_id ) ) {
    774                         $screen_id = buddypress()->members->admin->user_page;
    775                 }
    776 
    777                 // Setup a new metabox class if none was passed.
    778                 if ( empty( $stats_metabox ) ) {
    779                         $stats_metabox = new StdClass();
    780                 }
    781 
    782                 // Moving the Stats Metabox.
    783                 $stats_metabox->context  = 'side';
    784                 $stats_metabox->priority = 'low';
    785 
    786                 // Each Group of fields will have his own metabox.
    787                 $profile_args = array(
    788                         'fetch_fields' => false,
    789                         'user_id'      => $user_id,
    790                 );
    791 
    792                 if ( ! bp_is_user_spammer( $user_id ) && bp_has_profile( $profile_args ) ) {
    793 
    794                         // Loop through field groups and add a metabox for each one.
    795                         while ( bp_profile_groups() ) : bp_the_profile_group();
    796                                 add_meta_box(
    797                                         'bp_xprofile_user_admin_fields_' . sanitize_key( bp_get_the_profile_group_slug() ),
    798                                         esc_html( bp_get_the_profile_group_name() ),
    799                                         array( $this, 'user_admin_profile_metaboxes' ),
    800                                         $screen_id,
    801                                         'normal',
    802                                         'core',
    803                                         array( 'profile_group_id' => absint( bp_get_the_profile_group_id() ) )
    804                                 );
    805                         endwhile;
    806 
    807                 // If member is already a spammer, show a generic metabox.
    808                 } else {
    809                         add_meta_box(
    810                                 'bp_xprofile_user_admin_empty_profile',
    811                                 _x( 'User marked as a spammer', 'xprofile user-admin edit screen', 'buddypress' ),
    812                                 array( $this, 'user_admin_spammer_metabox' ),
    813                                 $screen_id,
    814                                 'normal',
    815                                 'core'
    816                         );
    817                 }
    818 
    819                 if ( buddypress()->avatar->show_avatars ) {
    820                         // Avatar Metabox.
    821                         add_meta_box(
    822                                 'bp_xprofile_user_admin_avatar',
    823                                 _x( 'Profile Photo', 'xprofile user-admin edit screen', 'buddypress' ),
    824                                 array( $this, 'user_admin_avatar_metabox' ),
    825                                 $screen_id,
    826                                 'side',
    827                                 'low'
    828                         );
    829                 }
    830         }
    831 
    832         /**
    833          * Save the profile fields in Members community profile page.
    834          *
    835          * Loaded before the page is rendered, this function is processing form
    836          * requests.
    837          *
    838          * @since 2.0.0
    839          *
    840          * @param string $doaction    Action being run.
    841          * @param int    $user_id     ID for the user whose profile is being saved.
    842          * @param array  $request     Request being made.
    843          * @param string $redirect_to Where to redirect user to.
    844          */
    845         public function user_admin_load( $doaction = '', $user_id = 0, $request = array(), $redirect_to = '' ) {
    846 
    847                 // Eventually delete avatar.
    848                 if ( 'delete_avatar' === $doaction ) {
    849 
    850                         check_admin_referer( 'delete_avatar' );
    851 
    852                         $redirect_to = remove_query_arg( '_wpnonce', $redirect_to );
    853 
    854                         if ( bp_core_delete_existing_avatar( array( 'item_id' => $user_id ) ) ) {
    855                                 $redirect_to = add_query_arg( 'updated', 'avatar', $redirect_to );
    856                         } else {
    857                                 $redirect_to = add_query_arg( 'error', 'avatar', $redirect_to );
    858                         }
    859 
    860                         bp_core_redirect( $redirect_to );
    861 
    862                 // Update profile fields.
    863                 } elseif ( isset( $_POST['field_ids'] ) ) {
    864 
    865                         // Check the nonce.
    866                         check_admin_referer( 'edit-bp-profile_' . $user_id );
    867 
    868                         // Check we have field ID's.
    869                         if ( empty( $_POST['field_ids'] ) ) {
    870                                 $redirect_to = add_query_arg( 'error', '1', $redirect_to );
    871                                 bp_core_redirect( $redirect_to );
    872                         }
    873 
    874                         /**
    875                          * Unlike front-end edit-fields screens, the wp-admin/profile
    876                          * displays all groups of fields on a single page, so the list of
    877                          * field ids is an array gathering for each group of fields a
    878                          * distinct comma separated list of ids.
    879                          *
    880                          * As a result, before using the wp_parse_id_list() function, we
    881                          * must ensure that these ids are "merged" into a single comma
    882                          * separated list.
    883                          */
    884                         $merge_ids = join( ',', $_POST['field_ids'] );
    885 
    886                         // Explode the posted field IDs into an array so we know which fields have been submitted.
    887                         $posted_field_ids = wp_parse_id_list( $merge_ids );
    888                         $is_required      = array();
    889 
    890                         // Loop through the posted fields formatting any datebox values then validate the field.
    891                         foreach ( (array) $posted_field_ids as $field_id ) {
    892                                 if ( ! isset( $_POST['field_' . $field_id ] ) ) {
    893                                         if ( ! empty( $_POST['field_' . $field_id . '_day'] ) && ! empty( $_POST['field_' . $field_id . '_month'] ) && ! empty( $_POST['field_' . $field_id . '_year'] ) ) {
    894 
    895                                                 // Concatenate the values.
    896                                                 $date_value =   $_POST['field_' . $field_id . '_day'] . ' ' . $_POST['field_' . $field_id . '_month'] . ' ' . $_POST['field_' . $field_id . '_year'];
    897 
    898                                                 // Turn the concatenated value into a timestamp.
    899                                                 $_POST['field_' . $field_id] = date( 'Y-m-d H:i:s', strtotime( $date_value ) );
    900                                         }
    901                                 }
    902 
    903                                 $is_required[ $field_id ] = xprofile_check_is_required_field( $field_id ) && ! bp_current_user_can( 'bp_moderate' );
    904                                 if ( $is_required[ $field_id ] && empty( $_POST['field_' . $field_id ] ) ) {
    905                                         $redirect_to = add_query_arg( 'error', '2', $redirect_to );
    906                                         bp_core_redirect( $redirect_to );
    907                                 }
    908                         }
    909 
    910                         // Set the errors var.
    911                         $errors = false;
    912 
    913                         // Now we've checked for required fields, let's save the values.
    914                         foreach ( (array) $posted_field_ids as $field_id ) {
    915 
    916                                 // Certain types of fields (checkboxes, multiselects) may come
    917                                 // through empty. Save them as an empty array so that they don't
    918                                 // get overwritten by the default on the next edit.
    919                                 $value = isset( $_POST['field_' . $field_id] ) ? $_POST['field_' . $field_id] : '';
    920 
    921                                 if ( ! xprofile_set_field_data( $field_id, $user_id, $value, $is_required[ $field_id ] ) ) {
    922                                         $errors = true;
    923                                 } else {
    924 
    925                                         /**
    926                                          * Fires after the saving of each profile field, if successful.
    927                                          *
    928                                          * @since 1.1.0
    929                                          *
    930                                          * @param int    $field_id ID of the field being updated.
    931                                          * @param string $value    Value that was saved to the field.
    932                                          */
    933                                         do_action( 'xprofile_profile_field_data_updated', $field_id, $value );
    934                                 }
    935 
    936                                 // Save the visibility level.
    937                                 $visibility_level = ! empty( $_POST['field_' . $field_id . '_visibility'] ) ? $_POST['field_' . $field_id . '_visibility'] : 'public';
    938                                 xprofile_set_field_visibility_level( $field_id, $user_id, $visibility_level );
    939                         }
    940 
    941                         /**
    942                          * Fires after all of the profile fields have been saved.
    943                          *
    944                          * @since 1.0.0
    945                          *
    946                          * @param int   $user_id          ID of the user whose data is being saved.
    947                          * @param array $posted_field_ids IDs of the fields that were submitted.
    948                          * @param bool  $errors           Whether or not errors occurred during saving.
    949                          */
    950                         do_action( 'xprofile_updated_profile', $user_id, $posted_field_ids, $errors );
    951 
    952                         // Set the feedback messages.
    953                         if ( ! empty( $errors ) ) {
    954                                 $redirect_to = add_query_arg( 'error',   '3', $redirect_to );
    955                         } else {
    956                                 $redirect_to = add_query_arg( 'updated', '1', $redirect_to );
    957                         }
    958 
    959                         bp_core_redirect( $redirect_to );
    960                 }
    961         }
    962 
    963         /**
    964          * Render the xprofile metabox for Community Profile screen.
    965          *
    966          * @since 2.0.0
    967          *
    968          * @param WP_User|null $user The WP_User object for the user being edited.
    969          * @param array        $args Aray of arguments for metaboxes.
    970          */
    971         public function user_admin_profile_metaboxes( $user = null, $args = array() ) {
    972 
    973                 // Bail if no user ID.
    974                 if ( empty( $user->ID ) ) {
    975                         return;
    976                 }
    977 
    978                 $r = bp_parse_args( $args['args'], array(
    979                         'profile_group_id' => 0,
    980                         'user_id'          => $user->ID
    981                 ), 'bp_xprofile_user_admin_profile_loop_args' );
    982 
    983                 // We really need these args.
    984                 if ( empty( $r['profile_group_id'] ) || empty( $r['user_id'] ) ) {
    985                         return;
    986                 }
    987 
    988                 // Bail if no profile fields are available.
    989                 if ( ! bp_has_profile( $r ) ) {
    990                         return;
    991                 }
    992 
    993                 // Loop through profile groups & fields.
    994                 while ( bp_profile_groups() ) : bp_the_profile_group(); ?>
    995 
    996                         <input type="hidden" name="field_ids[]" id="<?php echo esc_attr( 'field_ids_' . bp_get_the_profile_group_slug() ); ?>" value="<?php echo esc_attr( bp_get_the_profile_group_field_ids() ); ?>" />
    997 
    998                         <?php if ( bp_get_the_profile_group_description() ) : ?>
    999 
    1000                                 <p class="description"><?php bp_the_profile_group_description(); ?></p>
    1001 
    1002                         <?php endif; ?>
    1003 
    1004                         <?php while ( bp_profile_fields() ) : bp_the_profile_field(); ?>
    1005 
    1006                                 <div<?php bp_field_css_class( 'bp-profile-field' ); ?>>
    1007 
    1008                                         <?php
    1009 
    1010                                         $field_type = bp_xprofile_create_field_type( bp_get_the_profile_field_type() );
    1011                                         $field_type->edit_field_html( array( 'user_id' => $r['user_id'] ) );
    1012 
    1013                                         if ( bp_get_the_profile_field_description() ) : ?>
    1014 
    1015                                                 <p class="description"><?php bp_the_profile_field_description(); ?></p>
    1016 
    1017                                         <?php endif;
    1018 
    1019                                         /**
    1020                                          * Fires before display of visibility form elements for profile metaboxes.
    1021                                          *
    1022                                          * @since 1.7.0
    1023                                          */
    1024                                         do_action( 'bp_custom_profile_edit_fields_pre_visibility' );
    1025 
    1026                                         $can_change_visibility = bp_current_user_can( 'bp_xprofile_change_field_visibility' ); ?>
    1027 
    1028                                         <p class="field-visibility-settings-<?php echo $can_change_visibility ? 'toggle' : 'notoggle'; ?>" id="field-visibility-settings-toggle-<?php bp_the_profile_field_id(); ?>">
    1029 
    1030                                                 <?php
    1031                                                 printf(
    1032                                                         __( 'This field can be seen by: %s', 'buddypress' ),
    1033                                                         '<span class="current-visibility-level">' . bp_get_the_profile_field_visibility_level_label() . '</span>'
    1034                                                 );
    1035                                                 ?>
    1036 
    1037                                                 <?php if ( $can_change_visibility ) : ?>
    1038 
    1039                                                         <a href="#" class="button visibility-toggle-link"><?php esc_html_e( 'Change', 'buddypress' ); ?></a>
    1040 
    1041                                                 <?php endif; ?>
    1042                                         </p>
    1043 
    1044                                         <?php if ( $can_change_visibility ) : ?>
    1045 
    1046                                                 <div class="field-visibility-settings" id="field-visibility-settings-<?php bp_the_profile_field_id() ?>">
    1047                                                         <fieldset>
    1048                                                                 <legend><?php _e( 'Who can see this field?', 'buddypress' ); ?></legend>
    1049 
    1050                                                                 <?php bp_profile_visibility_radio_buttons(); ?>
    1051 
    1052                                                         </fieldset>
    1053                                                         <a class="button field-visibility-settings-close" href="#"><?php esc_html_e( 'Close', 'buddypress' ); ?></a>
    1054                                                 </div>
    1055 
    1056                                         <?php endif; ?>
    1057 
    1058                                         <?php
    1059 
    1060                                         /**
    1061                                          * Fires at end of custom profile field items on your xprofile screen tab.
    1062                                          *
    1063                                          * @since 1.1.0
    1064                                          */
    1065                                         do_action( 'bp_custom_profile_edit_fields' ); ?>
    1066 
    1067                                 </div>
    1068 
    1069                         <?php endwhile; // End bp_profile_fields(). ?>
    1070 
    1071                 <?php endwhile; // End bp_profile_groups.
    1072         }
    1073 
    1074         /**
    1075          * Render the fallback metabox in case a user has been marked as a spammer.
    1076          *
    1077          * @since 2.0.0
    1078          *
    1079          * @param WP_User|null $user The WP_User object for the user being edited.
    1080          */
    1081         public function user_admin_spammer_metabox( $user = null ) {
    1082         ?>
    1083                 <p><?php printf( __( '%s has been marked as a spammer. All BuddyPress data associated with the user has been removed', 'buddypress' ), esc_html( bp_core_get_user_displayname( $user->ID ) ) ) ;?></p>
    1084         <?php
    1085         }
    1086 
    1087         /**
    1088          * Render the Avatar metabox to moderate inappropriate images.
    1089          *
    1090          * @since 2.0.0
    1091          *
    1092          * @param WP_User|null $user The WP_User object for the user being edited.
    1093          */
    1094         public function user_admin_avatar_metabox( $user = null ) {
    1095 
    1096                 if ( empty( $user->ID ) ) {
    1097                         return;
    1098                 } ?>
    1099 
    1100                 <div class="avatar">
    1101 
    1102                         <?php echo bp_core_fetch_avatar( array(
    1103                                 'item_id' => $user->ID,
    1104                                 'object'  => 'user',
    1105                                 'type'    => 'full',
    1106                                 'title'   => $user->display_name
    1107                         ) ); ?>
    1108 
    1109                         <?php if ( bp_get_user_has_avatar( $user->ID ) ) :
    1110 
    1111                                 $query_args = array(
    1112                                         'user_id' => $user->ID,
    1113                                         'action'  => 'delete_avatar'
    1114                                 );
    1115 
    1116                                 if ( ! empty( $_REQUEST['wp_http_referer'] ) ) {
    1117                                         $query_args['wp_http_referer'] = urlencode( wp_unslash( $_REQUEST['wp_http_referer'] ) );
    1118                                 }
    1119 
    1120                                 $community_url = add_query_arg( $query_args, buddypress()->members->admin->edit_profile_url );
    1121                                 $delete_link   = wp_nonce_url( $community_url, 'delete_avatar' ); ?>
    1122 
    1123                                 <a href="<?php echo esc_url( $delete_link ); ?>" title="<?php esc_attr_e( 'Delete Profile Photo', 'buddypress' ); ?>" class="bp-xprofile-avatar-user-admin"><?php esc_html_e( 'Delete Profile Photo', 'buddypress' ); ?></a>
    1124 
    1125                         <?php endif;
    1126 
    1127                         // Load the Avatar UI templates if user avatar uploads are enabled and current WordPress version is supported.
    1128                         if ( ! bp_core_get_root_option( 'bp-disable-avatar-uploads' ) && bp_attachments_is_wp_version_supported() ) : ?>
    1129                                 <a href="#TB_inline?width=800px&height=400px&inlineId=bp-xprofile-avatar-editor" title="<?php esc_attr_e( 'Edit Profile Photo', 'buddypress' );?>" class="thickbox bp-xprofile-avatar-user-edit"><?php esc_html_e( 'Edit Profile Photo', 'buddypress' ); ?></a>
    1130                                 <div id="bp-xprofile-avatar-editor" style="display:none;">
    1131                                         <?php bp_attachments_get_template_part( 'avatars/index' ); ?>
    1132                                 </div>
    1133                         <?php endif; ?>
    1134 
    1135                 </div>
    1136                 <?php
    1137         }
    1138 
    1139 }
    1140 endif; // End class_exists check.
    1141 
    1142675// Load the xprofile user admin.
    1143676add_action( 'bp_init', array( 'BP_XProfile_User_Admin', 'register_xprofile_user_admin' ), 11 );

  • trunk/src/bp-xprofile/bp-xprofile-loader.php

    r10434 r10525  
    1414defined( 'ABSPATH' ) || exit;
    1515
    16 /**
    17  * Creates our XProfile component.
    18  */
    19 class BP_XProfile_Component extends BP_Component {
    20 
    21         /**
    22          * Profile field types.
    23          *
    24          * @since 1.5.0
    25          * @var array
    26          */
    27         public $field_types;
    28 
    29         /**
    30          * The acceptable visibility levels for xprofile fields.
    31          *
    32          * @see bp_xprofile_get_visibility_levels()
    33          * @since 1.6.0
    34          * @var array
    35          */
    36         public $visibility_levels = array();
    37 
    38         /**
    39          * Start the xprofile component creation process.
    40          *
    41          * @since 1.5.0
    42          */
    43         public function __construct() {
    44                 parent::start(
    45                         'xprofile',
    46                         _x( 'Extended Profiles', 'Component page <title>', 'buddypress' ),
    47                         buddypress()->plugin_dir,
    48                         array(
    49                                 'adminbar_myaccount_order' => 20
    50                         )
    51                 );
    52 
    53                 $this->setup_hooks();
    54         }
    55 
    56         /**
    57          * Include files.
    58          *
    59          * @param array $includes Array of files to include.
    60          */
    61         public function includes( $includes = array() ) {
    62                 $includes = array(
    63                         'cssjs',
    64                         'cache',
    65                         'actions',
    66                         'activity',
    67                         'screens',
    68                         'caps',
    69                         'classes',
    70                         'filters',
    71                         'settings',
    72                         'template',
    73                         'functions',
    74                         'notifications',
    75                 );
    76 
    77                 if ( is_admin() ) {
    78                         $includes[] = 'admin';
    79                 }
    80 
    81                 parent::includes( $includes );
    82         }
    83 
    84         /**
    85          * Setup globals.
    86          *
    87          * The BP_XPROFILE_SLUG constant is deprecated, and only used here for
    88          * backwards compatibility.
    89          *
    90          * @since 1.5.0
    91          *
    92          * @param array $args Array of globals to set up.
    93          */
    94         public function setup_globals( $args = array() ) {
    95                 $bp = buddypress();
    96 
    97                 // Define a slug, if necessary.
    98                 if ( !defined( 'BP_XPROFILE_SLUG' ) ) {
    99                         define( 'BP_XPROFILE_SLUG', 'profile' );
    100                 }
    101 
    102                 // Assign the base group and fullname field names to constants
    103                 // to use in SQL statements.
    104                 // Defined conditionally to accommodate unit tests.
    105                 if ( ! defined( 'BP_XPROFILE_BASE_GROUP_NAME' ) ) {
    106                         define( 'BP_XPROFILE_BASE_GROUP_NAME', stripslashes( bp_core_get_root_option( 'avatar_default' ) ) );
    107                 }
    108 
    109                 if ( ! defined( 'BP_XPROFILE_FULLNAME_FIELD_NAME' ) ) {
    110                         define( 'BP_XPROFILE_FULLNAME_FIELD_NAME', stripslashes( bp_core_get_root_option( 'bp-xprofile-fullname-field-name' ) ) );
    111                 }
    112 
    113                 /**
    114                  * Filters the supported field type IDs.
    115                  *
    116                  * @since 1.1.0
    117                  *
    118                  * @param array $value Array of IDs for the supported field types.
    119                  */
    120                 $this->field_types = apply_filters( 'xprofile_field_types', array_keys( bp_xprofile_get_field_types() ) );
    121 
    122                 // 'option' is a special case. It is not a top-level field, so
    123                 // does not have an associated BP_XProfile_Field_Type class,
    124                 // but it must be whitelisted.
    125                 $this->field_types[] = 'option';
    126 
    127                 // Register the visibility levels. See bp_xprofile_get_visibility_levels() to filter.
    128                 $this->visibility_levels = array(
    129                         'public' => array(
    130                                 'id'      => 'public',
    131                                 'label' => _x( 'Everyone', 'Visibility level setting', 'buddypress' )
    132                         ),
    133                         'adminsonly' => array(
    134                                 'id'      => 'adminsonly',
    135                                 'label' => _x( 'Only Me', 'Visibility level setting', 'buddypress' )
    136                         ),
    137                         'loggedin' => array(
    138                                 'id'      => 'loggedin',
    139                                 'label' => _x( 'All Members', 'Visibility level setting', 'buddypress' )
    140                         )
    141                 );
    142 
    143                 if ( bp_is_active( 'friends' ) ) {
    144                         $this->visibility_levels['friends'] = array(
    145                                 'id'    => 'friends',
    146                                 'label' => _x( 'My Friends', 'Visibility level setting', 'buddypress' )
    147                         );
    148                 }
    149 
    150                 // Tables.
    151                 $global_tables = array(
    152                         'table_name_data'   => $bp->table_prefix . 'bp_xprofile_data',
    153                         'table_name_groups' => $bp->table_prefix . 'bp_xprofile_groups',
    154                         'table_name_fields' => $bp->table_prefix . 'bp_xprofile_fields',
    155                         'table_name_meta'   => $bp->table_prefix . 'bp_xprofile_meta',
    156                 );
    157 
    158                 $meta_tables = array(
    159                         'xprofile_group' => $bp->table_prefix . 'bp_xprofile_meta',
    160                         'xprofile_field' => $bp->table_prefix . 'bp_xprofile_meta',
    161                         'xprofile_data'  => $bp->table_prefix . 'bp_xprofile_meta',
    162                 );
    163 
    164                 $globals = array(
    165                         'slug'                  => BP_XPROFILE_SLUG,
    166                         'has_directory'         => false,
    167                         'notification_callback' => 'xprofile_format_notifications',
    168                         'global_tables'         => $global_tables,
    169                         'meta_tables'           => $meta_tables,
    170                 );
    171 
    172                 parent::setup_globals( $globals );
    173         }
    174 
    175         /**
    176          * Set up navigation.
    177          *
    178          * @global BuddyPress $bp The one true BuddyPress instance
    179          *
    180          * @param array $main_nav Array of main nav items to set up.
    181          * @param array $sub_nav  Array of sub nav items to set up.
    182          */
    183         public function setup_nav( $main_nav = array(), $sub_nav = array() ) {
    184 
    185                 // Determine user to use.
    186                 if ( bp_displayed_user_domain() ) {
    187                         $user_domain = bp_displayed_user_domain();
    188                 } elseif ( bp_loggedin_user_domain() ) {
    189                         $user_domain = bp_loggedin_user_domain();
    190                 } else {
    191                         return;
    192                 }
    193 
    194                 $access       = bp_core_can_edit_settings();
    195                 $slug         = bp_get_profile_slug();
    196                 $profile_link = trailingslashit( $user_domain . $slug );
    197 
    198                 // Add 'Profile' to the main navigation.
    199                 $main_nav = array(
    200                         'name'                => _x( 'Profile', 'Profile header menu', 'buddypress' ),
    201                         'slug'                => $slug,
    202                         'position'            => 20,
    203                         'screen_function'     => 'xprofile_screen_display_profile',
    204                         'default_subnav_slug' => 'public',
    205                         'item_css_id'         => $this->id
    206                 );
    207 
    208                 // Add the subnav items to the profile.
    209                 $sub_nav[] = array(
    210                         'name'            => _x( 'View', 'Profile header sub menu', 'buddypress' ),
    211                         'slug'            => 'public',
    212                         'parent_url'      => $profile_link,
    213                         'parent_slug'     => $slug,
    214                         'screen_function' => 'xprofile_screen_display_profile',
    215                         'position'        => 10
    216                 );
    217 
    218                 // Edit Profile.
    219                 $sub_nav[] = array(
    220                         'name'            => _x( 'Edit','Profile header sub menu', 'buddypress' ),
    221                         'slug'            => 'edit',
    222                         'parent_url'      => $profile_link,
    223                         'parent_slug'     => $slug,
    224                         'screen_function' => 'xprofile_screen_edit_profile',
    225                         'position'        => 20,
    226                         'user_has_access' => $access
    227                 );
    228 
    229                 // Change Avatar.
    230                 if ( buddypress()->avatar->show_avatars ) {
    231                         $sub_nav[] = array(
    232                                 'name'            => _x( 'Change Profile Photo', 'Profile header sub menu', 'buddypress' ),
    233                                 'slug'            => 'change-avatar',
    234                                 'parent_url'      => $profile_link,
    235                                 'parent_slug'     => $slug,
    236                                 'screen_function' => 'xprofile_screen_change_avatar',
    237                                 'position'        => 30,
    238                                 'user_has_access' => $access
    239                         );
    240                 }
    241 
    242                 // Change Cover image.
    243                 if ( bp_displayed_user_use_cover_image_header() ) {
    244                         $sub_nav[] = array(
    245                                 'name'            => _x( 'Change Cover Image', 'Profile header sub menu', 'buddypress' ),
    246                                 'slug'            => 'change-cover-image',
    247                                 'parent_url'      => $profile_link,
    248                                 'parent_slug'     => $slug,
    249                                 'screen_function' => 'xprofile_screen_change_cover_image',
    250                                 'position'        => 40,
    251                                 'user_has_access' => $access
    252                         );
    253                 }
    254 
    255                 // The Settings > Profile nav item can only be set up after
    256                 // the Settings component has run its own nav routine.
    257                 add_action( 'bp_settings_setup_nav', array( $this, 'setup_settings_nav' ) );
    258 
    259                 parent::setup_nav( $main_nav, $sub_nav );
    260         }
    261 
    262         /**
    263          * Set up the Settings > Profile nav item.
    264          *
    265          * Loaded in a separate method because the Settings component may not
    266          * be loaded in time for BP_XProfile_Component::setup_nav().
    267          *
    268          * @since 2.1.0
    269          */
    270         public function setup_settings_nav() {
    271                 if ( ! bp_is_active( 'settings' ) ) {
    272                         return;
    273                 }
    274 
    275                 // Determine user to use.
    276                 if ( bp_displayed_user_domain() ) {
    277                         $user_domain = bp_displayed_user_domain();
    278                 } elseif ( bp_loggedin_user_domain() ) {
    279                         $user_domain = bp_loggedin_user_domain();
    280                 } else {
    281                         return;
    282                 }
    283 
    284                 // Get the settings slug.
    285                 $settings_slug = bp_get_settings_slug();
    286 
    287                 bp_core_new_subnav_item( array(
    288                         'name'            => _x( 'Profile Visibility', 'Profile settings sub nav', 'buddypress' ),
    289                         'slug'            => 'profile',
    290                         'parent_url'      => trailingslashit( $user_domain . $settings_slug ),
    291                         'parent_slug'     => $settings_slug,
    292                         'screen_function' => 'bp_xprofile_screen_settings',
    293                         'position'        => 30,
    294                         'user_has_access' => bp_core_can_edit_settings()
    295                 ) );
    296         }
    297 
    298         /**
    299          * Set up the Admin Bar.
    300          *
    301          * @param array $wp_admin_nav Admin Bar items.
    302          */
    303         public function setup_admin_bar( $wp_admin_nav = array() ) {
    304 
    305                 // Menus for logged in user.
    306                 if ( is_user_logged_in() ) {
    307 
    308                         // Profile link.
    309                         $profile_link = trailingslashit( bp_loggedin_user_domain() . bp_get_profile_slug() );
    310 
    311                         // Add the "Profile" sub menu.
    312                         $wp_admin_nav[] = array(
    313                                 'parent' => buddypress()->my_account_menu_id,
    314                                 'id'     => 'my-account-' . $this->id,
    315                                 'title'  => _x( 'Profile', 'My Account Profile', 'buddypress' ),
    316                                 'href'   => $profile_link
    317                         );
    318 
    319                         // View Profile.
    320                         $wp_admin_nav[] = array(
    321                                 'parent' => 'my-account-' . $this->id,
    322                                 'id'     => 'my-account-' . $this->id . '-public',
    323                                 'title'  => _x( 'View', 'My Account Profile sub nav', 'buddypress' ),
    324                                 'href'   => $profile_link
    325                         );
    326 
    327                         // Edit Profile.
    328                         $wp_admin_nav[] = array(
    329                                 'parent' => 'my-account-' . $this->id,
    330                                 'id'     => 'my-account-' . $this->id . '-edit',
    331                                 'title'  => _x( 'Edit', 'My Account Profile sub nav', 'buddypress' ),
    332                                 'href'   => trailingslashit( $profile_link . 'edit' )
    333                         );
    334 
    335                         // Edit Avatar.
    336                         if ( buddypress()->avatar->show_avatars ) {
    337                                 $wp_admin_nav[] = array(
    338                                         'parent' => 'my-account-' . $this->id,
    339                                         'id'     => 'my-account-' . $this->id . '-change-avatar',
    340                                         'title'  => _x( 'Change Profile Photo', 'My Account Profile sub nav', 'buddypress' ),
    341                                         'href'   => trailingslashit( $profile_link . 'change-avatar' )
    342                                 );
    343                         }
    344 
    345                         if ( bp_displayed_user_use_cover_image_header() ) {
    346                                 $wp_admin_nav[] = array(
    347                                         'parent' => 'my-account-' . $this->id,
    348                                         'id'     => 'my-account-' . $this->id . '-change-cover-image',
    349                                         'title'  => _x( 'Change Cover Image', 'My Account Profile sub nav', 'buddypress' ),
    350                                         'href'   => trailingslashit( $profile_link . 'change-cover-image' )
    351                                 );
    352                         }
    353                 }
    354 
    355                 parent::setup_admin_bar( $wp_admin_nav );
    356         }
    357 
    358         /**
    359          * Add custom hooks.
    360          *
    361          * @since 2.0.0
    362          */
    363         public function setup_hooks() {
    364                 add_filter( 'bp_settings_admin_nav', array( $this, 'setup_settings_admin_nav' ), 2 );
    365         }
    366 
    367         /**
    368          * Sets up the title for pages and <title>.
    369          */
    370         public function setup_title() {
    371 
    372                 if ( bp_is_profile_component() ) {
    373                         $bp = buddypress();
    374 
    375                         if ( bp_is_my_profile() ) {
    376                                 $bp->bp_options_title = _x( 'My Profile', 'Page title', 'buddypress' );
    377                         } else {
    378                                 $bp->bp_options_avatar = bp_core_fetch_avatar( array(
    379                                         'item_id' => bp_displayed_user_id(),
    380                                         'type'    => 'thumb',
    381                                         'alt'     => sprintf( _x( 'Profile picture of %s', 'Avatar alt', 'buddypress' ), bp_get_displayed_user_fullname() )
    382                                 ) );
    383                                 $bp->bp_options_title = bp_get_displayed_user_fullname();
    384                         }
    385                 }
    386 
    387                 parent::setup_title();
    388         }
    389 
    390         /**
    391          * Setup cache groups.
    392          *
    393          * @since 2.2.0
    394          */
    395         public function setup_cache_groups() {
    396 
    397                 // Global groups.
    398                 wp_cache_add_global_groups( array(
    399                         'bp_xprofile',
    400                         'bp_xprofile_data',
    401                         'bp_xprofile_fields',
    402                         'bp_xprofile_groups',
    403                         'xprofile_meta'
    404                 ) );
    405 
    406                 parent::setup_cache_groups();
    407         }
    408 
    409         /**
    410          * Adds "Settings > Profile" subnav item under the "Settings" adminbar menu.
    411          *
    412          * @since 2.0.0
    413          *
    414          * @param array $wp_admin_nav The settings adminbar nav array.
    415          * @return array
    416          */
    417         public function setup_settings_admin_nav( $wp_admin_nav ) {
    418 
    419                 // Setup the logged in user variables.
    420                 $settings_link = trailingslashit( bp_loggedin_user_domain() . bp_get_settings_slug() );
    421 
    422                 // Add the "Profile" subnav item.
    423                 $wp_admin_nav[] = array(
    424                         'parent' => 'my-account-' . buddypress()->settings->id,
    425                         'id'     => 'my-account-' . buddypress()->settings->id . '-profile',
    426                         'title'  => _x( 'Profile', 'My Account Settings sub nav', 'buddypress' ),
    427                         'href'   => trailingslashit( $settings_link . 'profile' )
    428                 );
    429 
    430                 return $wp_admin_nav;
    431         }
    432 }
     16require dirname( __FILE__ ) . '/classes/class-bp-xprofile-component.php';
    43317
    43418/**

  • trunk/src/bp-xprofile/bp-xprofile-template.php

    r10460 r10525  
    1111defined( 'ABSPATH' ) || exit;
    1212
    13 /**
    14  * The main profile template loop class.
    15  *
    16  * This is responsible for loading profile field, group, and data and displaying it.
    17  *
    18  * @since 1.0.0
    19  */
    20 class BP_XProfile_Data_Template {
    21 
    22         /**
    23          * The loop iterator.
    24          *
    25          * @since 1.5.0
    26          * @var int
    27          */
    28         public $current_group = -1;
    29 
    30         /**
    31          * The number of groups returned by the paged query.
    32          *
    33          * @since 1.5.0
    34          * @var int
    35          */
    36         public $group_count;
    37 
    38         /**
    39          * Array of groups located by the query.
    40          *
    41          * @since 1.5.0
    42          * @var array
    43          */
    44         public $groups;
    45 
    46         /**
    47          * The group object currently being iterated on.
    48          *
    49          * @since 1.5.0
    50          * @var object
    51          */
    52         public $group;
    53 
    54         /**
    55          * The current field.
    56          *
    57          * @since 1.5.0
    58          * @var int
    59          */
    60         public $current_field = -1;
    61 
    62         /**
    63          * The field count.
    64          *
    65          * @since 1.5.0
    66          * @var int
    67          */
    68         public $field_count;
    69 
    70         /**
    71          * Field has data.
    72          *
    73          * @since 1.5.0
    74          * @var bool
    75          */
    76         public $field_has_data;
    77 
    78         /**
    79          * The field.
    80          *
    81          * @since 1.5.0
    82          * @var int
    83          */
    84         public $field;
    85 
    86         /**
    87          * A flag for whether the loop is currently being iterated.
    88          *
    89          * @since 1.5.0
    90          * @var bool
    91          */
    92         public $in_the_loop;
    93 
    94         /**
    95          * The user ID.
    96          *
    97          * @since 1.5.0
    98          * @var int
    99          */
    100         public $user_id;
    101 
    102         /**
    103          * Get activity items, as specified by parameters.
    104          *
    105          * @see BP_XProfile_Group::get() for more details about parameters.
    106          *
    107          * @since 2.4.0 Introduced `$member_type` argument.
    108          *
    109          * @param array|string $args {
    110          *     An array of arguments. All items are optional.
    111          *
    112          *     @type int          $user_id                 Fetch field data for this user ID.
    113          *     @type string|array $member_type             Limit results to those matching member type(s).
    114          *     @type int          $profile_group_id        Field group to fetch fields & data for.
    115          *     @type int|bool     $hide_empty_groups       Should empty field groups be skipped.
    116          *     @type int|bool     $fetch_fields            Fetch fields for field group.
    117          *     @type int|bool     $fetch_field_data        Fetch field data for fields in group.
    118          *     @type array        $exclude_groups          Exclude these field groups.
    119          *     @type array        $exclude_fields          Exclude these fields.
    120          *     @type int|bool     $hide_empty_fields       Should empty fields be skipped.
    121          *     @type int|bool     $fetch_visibility_level  Fetch visibility levels.
    122          *     @type int|bool     $update_meta_cache       Should metadata cache be updated.
    123          * }
    124          */
    125         public function __construct( $args = '' ) {
    126 
    127                 // Backward compatibility with old method of passing arguments.
    128                 if ( ! is_array( $args ) || func_num_args() > 1 ) {
    129                         _deprecated_argument( __METHOD__, '2.3.0', sprintf( __( 'Arguments passed to %1$s should be in an associative array. See the inline documentation at %2$s for more details.', 'buddypress' ), __METHOD__, __FILE__ ) );
    130 
    131                         $old_args_keys = array(
    132                                 0 => 'user_id',
    133                                 1 => 'profile_group_id',
    134                                 2 => 'hide_empty_groups',
    135                                 3 => 'fetch_fields',
    136                                 4 => 'fetch_field_data',
    137                                 5 => 'exclude_groups',
    138                                 6 => 'exclude_fields',
    139                                 7 => 'hide_empty_fields',
    140                                 8 => 'fetch_visibility_level',
    141                                 9 => 'update_meta_cache'
    142                         );
    143 
    144                         $func_args = func_get_args();
    145                         $args      = bp_core_parse_args_array( $old_args_keys, $func_args );
    146                 }
    147 
    148                 $r = wp_parse_args( $args, array(
    149                         'profile_group_id'       => false,
    150                         'user_id'                => false,
    151                         'member_type'            => 'any',
    152                         'hide_empty_groups'      => false,
    153                         'hide_empty_fields'      => false,
    154                         'fetch_fields'           => false,
    155                         'fetch_field_data'       => false,
    156                         'fetch_visibility_level' => false,
    157                         'exclude_groups'         => false,
    158                         'exclude_fields'         => false,
    159                         'update_meta_cache'      => true
    160                 ) );
    161 
    162                 $this->groups      = bp_xprofile_get_groups( $r );
    163                 $this->group_count = count( $this->groups );
    164                 $this->user_id     = $r['user_id'];
    165         }
    166 
    167         /**
    168          * Whether or not the loop has field groups.
    169          *
    170          * @return bool
    171          */
    172         public function has_groups() {
    173                 if ( ! empty( $this->group_count ) ) {
    174                         return true;
    175                 }
    176 
    177                 return false;
    178         }
    179 
    180         /**
    181          * Increments to the next group of fields.
    182          *
    183          * @return object
    184          */
    185         public function next_group() {
    186                 $this->current_group++;
    187 
    188                 $this->group       = $this->groups[ $this->current_group ];
    189                 $this->field_count = 0;
    190 
    191                 if ( ! empty( $this->group->fields ) ) {
    192 
    193                         /**
    194                          * Filters the group fields for the next_group method.
    195                          *
    196                          * @since 1.1.0
    197                          *
    198                          * @param array $fields Array of fields for the group.
    199                          * @param int   $id     ID of the field group.
    200                          */
    201                         $this->group->fields = apply_filters( 'xprofile_group_fields', $this->group->fields, $this->group->id );
    202                         $this->field_count   = count( $this->group->fields );
    203                 }
    204 
    205                 return $this->group;
    206         }
    207 
    208         /**
    209          * Rewinds to the start of the groups list.
    210          */
    211         public function rewind_groups() {
    212                 $this->current_group = -1;
    213                 if ( $this->group_count > 0 ) {
    214                         $this->group = $this->groups[0];
    215                 }
    216         }
    217 
    218         /**
    219          * Kicks off the profile groups.
    220          *
    221          * @return bool
    222          */
    223         public function profile_groups() {
    224                 if ( $this->current_group + 1 < $this->group_count ) {
    225                         return true;
    226                 } elseif ( $this->current_group + 1 == $this->group_count ) {
    227 
    228                         /**
    229                          * Fires right before the rewinding of profile groups.
    230                          *
    231                          * @since 1.1.0
    232                          */
    233                         do_action( 'xprofile_template_loop_end' );
    234 
    235                         // Do some cleaning up after the loop.
    236                         $this->rewind_groups();
    237                 }
    238 
    239                 $this->in_the_loop = false;
    240                 return false;
    241         }
    242 
    243         /**
    244          * Sets up the profile group.
    245          */
    246         public function the_profile_group() {
    247                 global $group;
    248 
    249                 $this->in_the_loop = true;
    250                 $group = $this->next_group();
    251 
    252                 // Loop has just started.
    253                 if ( 0 === $this->current_group ) {
    254 
    255                         /**
    256                          * Fires if the current group is the first in the loop.
    257                          *
    258                          * @since 1.1.0
    259                          */
    260                         do_action( 'xprofile_template_loop_start' );
    261                 }
    262         }
    263 
    264         /** Fields ****************************************************************/
    265 
    266         /**
    267          * Increments to the next field.
    268          *
    269          * @return int
    270          */
    271         public function next_field() {
    272                 $this->current_field++;
    273 
    274                 $this->field = $this->group->fields[ $this->current_field ];
    275 
    276                 return $this->field;
    277         }
    278 
    279         /**
    280          * Rewinds to the start of the fields.
    281          */
    282         public function rewind_fields() {
    283                 $this->current_field = -1;
    284                 if ( $this->field_count > 0 ) {
    285                         $this->field = $this->group->fields[0];
    286                 }
    287         }
    288 
    289         /**
    290          * Whether or not the loop has fields.
    291          *
    292          * @return bool
    293          */
    294         public function has_fields() {
    295                 $has_data = false;
    296 
    297                 for ( $i = 0, $count = count( $this->group->fields ); $i < $count; ++$i ) {
    298                         $field = &$this->group->fields[ $i ];
    299 
    300                         if ( ! empty( $field->data ) && ( $field->data->value != null ) ) {
    301                                 $has_data = true;
    302                         }
    303                 }
    304 
    305                 return $has_data;
    306         }
    307 
    308         /**
    309          * Kick off the profile fields.
    310          *
    311          * @return bool
    312          */
    313         public function profile_fields() {
    314                 if ( $this->current_field + 1 < $this->field_count ) {
    315                         return true;
    316                 } elseif ( $this->current_field + 1 == $this->field_count ) {
    317                         // Do some cleaning up after the loop.
    318                         $this->rewind_fields();
    319                 }
    320 
    321                 return false;
    322         }
    323 
    324         /**
    325          * Set up the profile fields.
    326          */
    327         public function the_profile_field() {
    328                 global $field;
    329 
    330                 $field = $this->next_field();
    331 
    332                 // Valid field values of 0 or '0' get caught by empty(), so we have an extra check for these. See #BP5731.
    333                 if ( ! empty( $field->data ) && ( ! empty( $field->data->value ) || ( '0' === $field->data->value ) ) ) {
    334                         $value = maybe_unserialize( $field->data->value );
    335                 } else {
    336                         $value = false;
    337                 }
    338 
    339                 if ( ! empty( $value ) || ( '0' === $value ) ) {
    340                         $this->field_has_data = true;
    341                 } else {
    342                         $this->field_has_data = false;
    343                 }
    344         }
    345 }
     13require dirname( __FILE__ ) . '/classes/class-bp-xprofile-data-template.php';
    34614
    34715/**

  • trunk/src/bp-xprofile/classes/class-bp-xprofile-component.php

    r10515 r10525  
    431431        }
    432432}
    433 
    434 /**
    435  * Bootstrap the XProfile component.
    436  */
    437 function bp_setup_xprofile() {
    438         $bp = buddypress();
    439 
    440         if ( ! isset( $bp->profile->id ) ) {
    441                 $bp->profile = new BP_XProfile_Component();
    442         }
    443 }
    444 add_action( 'bp_setup_components', 'bp_setup_xprofile', 2 );

  • trunk/src/bp-xprofile/classes/class-bp-xprofile-data-template.php

    r10515 r10525  
    11<?php
    22/**
    3  * BuddyPress XProfile Template Tags.
     3 * BuddyPress XProfile Template Loop Class.
    44 *
    55 * @package BuddyPress
    6  * @subpackage XProfileTemplate
    7  * @since 1.5.0
     6 * @since 1.0.0
    87 */
    98
    … …  
    344343        }
    345344}
    346 
    347 /**
    348  * Query for XProfile groups and fields.
    349  *
    350  * @since 1.0.0
    351  *
    352  * @global object $profile_template
    353  * @see BP_XProfile_Group::get() for full description of `$args` array.
    354  *
    355  * @param array|string $args {
    356  *     Array of arguments. See BP_XProfile_Group::get() for full description. Those arguments whose defaults differ
    357  *     from that method are described here:
    358  *     @type string|array $member_type            Default: 'any'.
    359  *     @type bool         $hide_empty_groups      Default: true.
    360  *     @type bool         $hide_empty_fields      Defaults to true on the Dashboard, on a user's Edit Profile page,
    361  *                                                or during registration. Otherwise false.
    362  *     @type bool         $fetch_visibility_level Defaults to true when an admin is viewing a profile, or when a user is
    363  *                                                viewing her own profile, or during registration. Otherwise false.
    364  *     @type bool         $fetch_fields           Default: true.
    365  *     @type bool         $fetch_field_data       Default: true.
    366  * }
    367  *
    368  * @return bool
    369  */
    370 function bp_has_profile( $args = '' ) {
    371         global $profile_template;
    372 
    373         // Only show empty fields if we're on the Dashboard, or we're on a user's
    374         // profile edit page, or this is a registration page.
    375         $hide_empty_fields_default = ( ! is_network_admin() && ! is_admin() && ! bp_is_user_profile_edit() && ! bp_is_register_page() );
    376 
    377         // We only need to fetch visibility levels when viewing your own profile.
    378         if ( bp_is_my_profile() || bp_current_user_can( 'bp_moderate' ) || bp_is_register_page() ) {
    379                 $fetch_visibility_level_default = true;
    380         } else {
    381                 $fetch_visibility_level_default = false;
    382         }
    383 
    384         // Parse arguments.
    385         $r = bp_parse_args( $args, array(
    386                 'user_id'                => bp_displayed_user_id(),
    387                 'member_type'            => 'any',
    388                 'profile_group_id'       => false,
    389                 'hide_empty_groups'      => true,
    390                 'hide_empty_fields'      => $hide_empty_fields_default,
    391                 'fetch_fields'           => true,
    392                 'fetch_field_data'       => true,
    393                 'fetch_visibility_level' => $fetch_visibility_level_default,
    394                 'exclude_groups'         => false, // Comma-separated list of profile field group IDs to exclude.
    395                 'exclude_fields'         => false, // Comma-separated list of profile field IDs to exclude.
    396                 'update_meta_cache'      => true,
    397         ), 'has_profile' );
    398 
    399         // Populate the template loop global.
    400         $profile_template = new BP_XProfile_Data_Template( $r );
    401 
    402         /**
    403          * Filters whether or not a group has a profile to display.
    404          *
    405          * @since 1.1.0
    406          *
    407          * @param bool   $has_groups       Whether or not there are group profiles to display.
    408          * @param string $profile_template Current profile template being used.
    409          */
    410         return apply_filters( 'bp_has_profile', $profile_template->has_groups(), $profile_template );
    411 }
    412 
    413 /**
    414  * Start off the profile groups.
    415  *
    416  * @return mixed
    417  */
    418 function bp_profile_groups() {
    419         global $profile_template;
    420         return $profile_template->profile_groups();
    421 }
    422 
    423 /**
    424  * Set up the profile groups.
    425  *
    426  * @return mixed
    427  */
    428 function bp_the_profile_group() {
    429         global $profile_template;
    430         return $profile_template->the_profile_group();
    431 }
    432 
    433 /**
    434  * Whether or not the group has fields to display.
    435  *
    436  * @return mixed
    437  */
    438 function bp_profile_group_has_fields() {
    439         global $profile_template;
    440         return $profile_template->has_fields();
    441 }
    442 
    443 /**
    444  * Output the class attribute for a field.
    445  *
    446  * @since 1.0.0
    447  *
    448  * @param array|string $class Extra classes to append to class attribute.
    449  *                            Pass mutiple class names as an array or
    450  *                            space-delimited string.
    451  *
    452  * @return string
    453  */
    454 function bp_field_css_class( $class = false ) {
    455         echo bp_get_field_css_class( $class );
    456 }
    457 
    458         /**
    459          * Return the class attribute for a field.
    460          *
    461          * @param string|bool $class Extra classes to append to class attribute.
    462          * @return string
    463          */
    464         function bp_get_field_css_class( $class = false ) {
    465                 global $profile_template;
    466 
    467                 $css_classes = array();
    468 
    469                 if ( ! empty( $class ) ) {
    470                         if ( ! is_array( $class ) ) {
    471                                 $class = preg_split( '#\s+#', $class );
    472                         }
    473                         $css_classes = array_map( 'sanitize_html_class', $class );
    474                 }
    475 
    476                 // Set a class with the field ID.
    477                 $css_classes[] = 'field_' . $profile_template->field->id;
    478 
    479                 // Set a class with the field name (sanitized).
    480                 $css_classes[] = 'field_' . sanitize_title( $profile_template->field->name );
    481 
    482                 // Set a class indicating whether the field is required or optional.
    483                 if ( ! empty( $profile_template->field->is_required ) ) {
    484                         $css_classes[] = 'required-field';
    485                 } else {
    486                         $css_classes[] = 'optional-field';
    487                 }
    488 
    489                 // Add the field visibility level.
    490                 $css_classes[] = 'visibility-' . esc_attr( bp_get_the_profile_field_visibility_level() );
    491 
    492                 if ( $profile_template->current_field % 2 == 1 ) {
    493                         $css_classes[] = 'alt';
    494                 }
    495 
    496                 $css_classes[] = 'field_type_' . sanitize_title( $profile_template->field->type );
    497 
    498                 /**
    499                  * Filters the field classes to be applied to a field.
    500                  *
    501                  * @since 1.1.0
    502                  *
    503                  * @param array $css_classes Array of classes to be applied to field. Passed by reference.
    504                  */
    505                 $css_classes = apply_filters_ref_array( 'bp_field_css_classes', array( &$css_classes ) );
    506 
    507                 /**
    508                  * Filters the class HTML attribute to be used on a field.
    509                  *
    510                  * @since 1.1.0
    511                  *
    512                  * @param string $value class HTML attribute with imploded classes.
    513                  */
    514                 return apply_filters( 'bp_get_field_css_class', ' class="' . implode( ' ', $css_classes ) . '"' );
    515         }
    516 
    517 /**
    518  * Whether or not the XProfile field has data to display.
    519  *
    520  * @return mixed
    521  */
    522 function bp_field_has_data() {
    523         global $profile_template;
    524         return $profile_template->field_has_data;
    525 }
    526 
    527 /**
    528  * Whether or not the XProfile field has public data to display.
    529  *
    530  * @return bool
    531  */
    532 function bp_field_has_public_data() {
    533         global $profile_template;
    534 
    535         if ( ! empty( $profile_template->field_has_data ) ) {
    536                 return true;
    537         }
    538 
    539         return false;
    540 }
    541 
    542 /**
    543  * Output the XProfile group ID.
    544  */
    545 function bp_the_profile_group_id() {
    546         echo bp_get_the_profile_group_id();
    547 }
    548 
    549         /**
    550          * Return the XProfile group ID.
    551          *
    552          * @return mixed|void
    553          */
    554         function bp_get_the_profile_group_id() {
    555                 global $group;
    556 
    557                 /**
    558                  * Filters the XProfile group ID.
    559                  *
    560                  * @since 1.1.0
    561                  *
    562                  * @param int $id ID for the profile group.
    563                  */
    564                 return apply_filters( 'bp_get_the_profile_group_id', $group->id );
    565         }
    566 
    567 /**
    568  * Output the XProfile group name.
    569  */
    570 function bp_the_profile_group_name() {
    571         echo bp_get_the_profile_group_name();
    572 }
    573 
    574         /**
    575          * Return the XProfile group name.
    576          *
    577          * @return mixed|void
    578          */
    579         function bp_get_the_profile_group_name() {
    580                 global $group;
    581 
    582                 /**
    583                  * Filters the XProfile group name.
    584                  *
    585                  * @since 1.0.0
    586                  *
    587                  * @param string $name Name for the profile group.
    588                  */
    589                 return apply_filters( 'bp_get_the_profile_group_name', $group->name );
    590         }
    591 
    592 /**
    593  * Output the XProfile group slug.
    594  */
    595 function bp_the_profile_group_slug() {
    596         echo bp_get_the_profile_group_slug();
    597 }
    598 
    599         /**
    600          * Return the XProfile group slug.
    601          *
    602          * @return mixed|void
    603          */
    604         function bp_get_the_profile_group_slug() {
    605                 global $group;
    606 
    607                 /**
    608                  * Filters the XProfile group slug.
    609                  *
    610                  * @since 1.1.0
    611                  *
    612                  * @param string $value Slug for the profile group.
    613                  */
    614                 return apply_filters( 'bp_get_the_profile_group_slug', sanitize_title( $group->name ) );
    615         }
    616 
    617 /**
    618  * Output the XProfile group description.
    619  */
    620 function bp_the_profile_group_description() {
    621         echo bp_get_the_profile_group_description();
    622 }
    623 
    624         /**
    625          * Return the XProfile group description.
    626          *
    627          * @return mixed|void
    628          */
    629         function bp_get_the_profile_group_description() {
    630                 global $group;
    631 
    632                 /**
    633                  * Filters the XProfile group description.
    634                  *
    635                  * @since 1.0.0
    636                  *
    637                  * @param string $description Description for the profile group.
    638                  */
    639                 return apply_filters( 'bp_get_the_profile_group_description', $group->description );
    640         }
    641 
    642 /**
    643  * Output the XProfile group edit form action.
    644  */
    645 function bp_the_profile_group_edit_form_action() {
    646         echo bp_get_the_profile_group_edit_form_action();
    647 }
    648 
    649         /**
    650          * Return the XProfile group edit form action.
    651          *
    652          * @return mixed|void
    653          */
    654         function bp_get_the_profile_group_edit_form_action() {
    655                 global $group;
    656 
    657                 // Build the form action URL.
    658                 $form_action = trailingslashit( bp_displayed_user_domain() . bp_get_profile_slug() . '/edit/group/' . $group->id );
    659 
    660                 /**
    661                  * Filters the action for the XProfile group edit form.
    662                  *
    663                  * @since 1.1.0
    664                  *
    665                  * @param string $value URL for the action attribute on the
    666                  *                      profile group edit form.
    667                  */
    668                 return apply_filters( 'bp_get_the_profile_group_edit_form_action', $form_action );
    669         }
    670 
    671 /**
    672  * Output the XProfile group field IDs.
    673  */
    674 function bp_the_profile_group_field_ids() {
    675         echo bp_get_the_profile_group_field_ids();
    676 }
    677 
    678         /**
    679          * Return the XProfile group field IDs.
    680          *
    681          * @return string
    682          */
    683         function bp_get_the_profile_group_field_ids() {
    684                 global $group;
    685 
    686                 $field_ids = '';
    687 
    688                 if ( !empty( $group->fields ) ) {
    689                         foreach ( (array) $group->fields as $field ) {
    690                                 $field_ids .= $field->id . ',';
    691                         }
    692                 }
    693 
    694                 return substr( $field_ids, 0, -1 );
    695         }
    696 
    697 /**
    698  * Output a comma-separated list of field IDs that are to be submitted on profile edit.
    699  *
    700  * @since 2.1.0
    701  */
    702 function bp_the_profile_field_ids() {
    703         echo bp_get_the_profile_field_ids();
    704 }
    705         /**
    706          * Generate a comma-separated list of field IDs that are to be submitted on profile edit.
    707          *
    708          * @since 2.1.0
    709          *
    710          * @return string
    711          */
    712         function bp_get_the_profile_field_ids() {
    713                 global $profile_template;
    714 
    715                 $field_ids = array();
    716                 foreach ( $profile_template->groups as $group ) {
    717                         if ( ! empty( $group->fields ) ) {
    718                                 $field_ids = array_merge( $field_ids, wp_list_pluck( $group->fields, 'id' ) );
    719                         }
    720                 }
    721 
    722                 $field_ids = implode( ',', wp_parse_id_list( $field_ids ) );
    723 
    724                 /**
    725                  * Filters the comma-separated list of field IDs.
    726                  *
    727                  * @since 2.1.0
    728                  *
    729                  * @param string $field_ids Comma-separated field IDs.
    730                  */
    731                 return apply_filters( 'bp_get_the_profile_field_ids', $field_ids );
    732         }
    733 
    734 /**
    735  * Return the XProfile fields.
    736  *
    737  * @return mixed
    738  */
    739 function bp_profile_fields() {
    740         global $profile_template;
    741         return $profile_template->profile_fields();
    742 }
    743 
    744 /**
    745  * Sets up the XProfile field.
    746  *
    747  * @return mixed
    748  */
    749 function bp_the_profile_field() {
    750         global $profile_template;
    751         return $profile_template->the_profile_field();
    752 }
    753 
    754 /**
    755  * Output the XProfile field ID.
    756  */
    757 function bp_the_profile_field_id() {
    758         echo bp_get_the_profile_field_id();
    759 }
    760 
    761         /**
    762          * Return the XProfile field ID.
    763          * @return mixed|void
    764          */
    765         function bp_get_the_profile_field_id() {
    766                 global $field;
    767 
    768                 /**
    769                  * Filters the XProfile field ID.
    770                  *
    771                  * @since 1.1.0
    772                  *
    773                  * @param int $id ID for the profile field.
    774                  */
    775                 return apply_filters( 'bp_get_the_profile_field_id', $field->id );
    776         }
    777 
    778 /**
    779  * Outputs the XProfile field name.
    780  */
    781 function bp_the_profile_field_name() {
    782         echo bp_get_the_profile_field_name();
    783 }
    784 
    785         /**
    786          * Returns the XProfile field name.
    787          *
    788          * @return mixed|void
    789          */
    790         function bp_get_the_profile_field_name() {
    791                 global $field;
    792 
    793                 /**
    794                  * Filters the XProfile field name.
    795                  *
    796                  * @since 1.0.0
    797                  *
    798                  * @param string $name Name for the profile field.
    799                  */
    800                 return apply_filters( 'bp_get_the_profile_field_name', $field->name );
    801         }
    802 
    803 /**
    804  * Outputs the XProfile field value.
    805  */
    806 function bp_the_profile_field_value() {
    807         echo bp_get_the_profile_field_value();
    808 }
    809 
    810         /**
    811          * Returns the XProfile field value.
    812          *
    813          * @return mixed|void
    814          */
    815         function bp_get_the_profile_field_value() {
    816                 global $field;
    817 
    818                 $field->data->value = bp_unserialize_profile_field( $field->data->value );
    819 
    820                 /**
    821                  * Filters the XProfile field value.
    822                  *
    823                  * @since 1.0.0
    824                  *
    825                  * @param string $value Value for the profile field.
    826                  * @param string $type  Type for the profile field.
    827                  * @param int    $id    ID for the profile field.
    828                  */
    829                 return apply_filters( 'bp_get_the_profile_field_value', $field->data->value, $field->type, $field->id );
    830         }
    831 
    832 /**
    833  * Outputs the XProfile field edit value.
    834  */
    835 function bp_the_profile_field_edit_value() {
    836         echo bp_get_the_profile_field_edit_value();
    837 }
    838 
    839         /**
    840          * Returns the XProfile field edit value.
    841          *
    842          * @return mixed|void
    843          */
    844         function bp_get_the_profile_field_edit_value() {
    845                 global $field;
    846 
    847                 /**
    848                  * Check to see if the posted value is different, if it is re-display this
    849                  * value as long as it's not empty and a required field.
    850                  */
    851                 if ( ! isset( $field->data ) ) {
    852                         $field->data = new stdClass;
    853                 }
    854 
    855                 if ( ! isset( $field->data->value ) ) {
    856                         $field->data->value = '';
    857                 }
    858 
    859                 if ( isset( $_POST['field_' . $field->id] ) && $field->data->value != $_POST['field_' . $field->id] ) {
    860                         if ( ! empty( $_POST['field_' . $field->id] ) ) {
    861                                 $field->data->value = $_POST['field_' . $field->id];
    862                         } else {
    863                                 $field->data->value = '';
    864                         }
    865                 }
    866 
    867                 $field_value = isset( $field->data->value ) ? bp_unserialize_profile_field( $field->data->value ) : '';
    868 
    869                 /**
    870                  * Filters the XProfile field edit value.
    871                  *
    872                  * @since 1.1.0
    873                  *
    874                  * @param string $field_value Current field edit value.
    875                  * @param string $type        Type for the profile field.
    876                  * @param int    $id          ID for the profile field.
    877                  */
    878                 return apply_filters( 'bp_get_the_profile_field_edit_value', $field_value, $field->type, $field->id );
    879         }
    880 
    881 /**
    882  * Outputs the XProfile field type.
    883  */
    884 function bp_the_profile_field_type() {
    885         echo bp_get_the_profile_field_type();
    886 }
    887 
    888         /**
    889          * Returns the XProfile field type.
    890          *
    891          * @return mixed|void
    892          */
    893         function bp_get_the_profile_field_type() {
    894                 global $field;
    895 
    896                 /**
    897                  * Filters the XProfile field type.
    898                  *
    899                  * @since 1.1.0
    900                  *
    901                  * @param string $type Type for the profile field.
    902                  */
    903                 return apply_filters( 'bp_the_profile_field_type', $field->type );
    904         }
    905 
    906 /**
    907  * Outputs the XProfile field description.
    908  */
    909 function bp_the_profile_field_description() {
    910         echo bp_get_the_profile_field_description();
    911 }
    912 
    913         /**
    914          * Returns the XProfile field description.
    915          *
    916          * @return mixed|void
    917          */
    918         function bp_get_the_profile_field_description() {
    919                 global $field;
    920 
    921                 /**
    922                  * Filters the XProfile field description.
    923                  *
    924                  * @since 1.1.0
    925                  *
    926                  * @param string $description Description for the profile field.
    927                  */
    928                 return apply_filters( 'bp_get_the_profile_field_description', $field->description );
    929         }
    930 
    931 /**
    932  * Outputs the XProfile field input name.
    933  */
    934 function bp_the_profile_field_input_name() {
    935         echo bp_get_the_profile_field_input_name();
    936 }
    937 
    938         /**
    939          * Retursn the XProfile field input name.
    940          *
    941          * @return mixed|void
    942          */
    943         function bp_get_the_profile_field_input_name() {
    944                 global $field;
    945 
    946                 /**
    947                  * Filters the profile field input name.
    948                  *
    949                  * @since 1.1.0
    950                  *
    951                  * @param string $value Value used for the name attribute on an input.
    952                  */
    953                 return apply_filters( 'bp_get_the_profile_field_input_name', 'field_' . $field->id );
    954         }
    955 
    956 /**
    957  * Returns the action name for any signup errors related to this profile field.
    958  *
    959  * In the registration templates, signup errors are pulled from the global
    960  * object and rendered at actions that look like 'bp_field_12_errors'. This
    961  * function allows the action name to be easily concatenated and called in the
    962  * following fashion:
    963  *   do_action( bp_get_the_profile_field_errors_action() );
    964  *
    965  * @since 1.8.0
    966  *
    967  * @return string The _errors action name corresponding to this profile field.
    968  */
    969 function bp_get_the_profile_field_errors_action() {
    970         global $field;
    971         return 'bp_field_' . $field->id . '_errors';
    972 }
    973 
    974 /**
    975  * Displays field options HTML for field types of 'selectbox', 'multiselectbox',
    976  * 'radio', 'checkbox', and 'datebox'.
    977  *
    978  * @since 1.1.0
    979  *
    980  * @uses bp_get_the_profile_field_options()
    981  *
    982  * @param array $args Specify type for datebox. Allowed 'day', 'month', 'year'.
    983  */
    984 function bp_the_profile_field_options( $args = array() ) {
    985         echo bp_get_the_profile_field_options( $args );
    986 }
    987         /**
    988          * Retrieves field options HTML for field types of 'selectbox', 'multiselectbox', 'radio', 'checkbox', and 'datebox'.
    989          *
    990          * @since 1.1.0
    991          *
    992          * @uses BP_XProfile_Field::get_children()
    993          * @uses BP_XProfile_ProfileData::get_value_byid()
    994          *
    995          * @param array $args {
    996          *     Array of optional arguments.
    997          *     @type string|bool $type    Type of datebox. False if it's not a
    998          *                                datebox, otherwise 'day, 'month', or 'year'. Default: false.
    999          *     @type int         $user_id ID of the user whose profile values should be
    1000          *                                used when rendering options. Default: displayed user.
    1001          * }
    1002          *
    1003          * @return string $vaue Field options markup.
    1004          */
    1005         function bp_get_the_profile_field_options( $args = array() ) {
    1006                 global $field;
    1007 
    1008                 $args = bp_parse_args( $args, array(
    1009                         'type'    => false,
    1010                         'user_id' => bp_displayed_user_id(),
    1011                 ), 'get_the_profile_field_options' );
    1012 
    1013                 /**
    1014                  * In some cases, the $field global is not an instantiation of the BP_XProfile_Field class.
    1015                  * However, we have to make sure that all data originally in $field gets merged back in, after reinstantiation.
    1016                  */
    1017                 if ( ! method_exists( $field, 'get_children' ) ) {
    1018                         $field_obj = xprofile_get_field( $field->id );
    1019 
    1020                         foreach ( $field as $field_prop => $field_prop_value ) {
    1021                                 if ( ! isset( $field_obj->{$field_prop} ) ) {
    1022                                         $field_obj->{$field_prop} = $field_prop_value;
    1023                                 }
    1024                         }
    1025 
    1026                         $field = $field_obj;
    1027                 }
    1028 
    1029                 ob_start();
    1030                 $field->type_obj->edit_field_options_html( $args );
    1031                 $html = ob_get_contents();
    1032                 ob_end_clean();
    1033 
    1034                 return $html;
    1035         }
    1036 
    1037 /**
    1038  * Render whether or not a profile field is required.
    1039  */
    1040 function bp_the_profile_field_is_required() {
    1041         echo bp_get_the_profile_field_is_required();
    1042 }
    1043 
    1044         /**
    1045          * Return whether or not a profile field is required.
    1046          * @return mixed|void
    1047          */
    1048         function bp_get_the_profile_field_is_required() {
    1049                 global $field;
    1050 
    1051                 $retval = false;
    1052 
    1053                 if ( isset( $field->is_required ) ) {
    1054                         $retval = $field->is_required;
    1055                 }
    1056 
    1057                 /**
    1058                  * Filters whether or not a profile field is required.
    1059                  *
    1060                  * @since 1.1.0
    1061                  *
    1062                  * @param bool $retval Whether or not the field is required.
    1063                  */
    1064                 return apply_filters( 'bp_get_the_profile_field_is_required', (bool) $retval );
    1065         }
    1066 
    1067 /**
    1068  * Output the visibility level of this field.
    1069  */
    1070 function bp_the_profile_field_visibility_level() {
    1071         echo bp_get_the_profile_field_visibility_level();
    1072 }
    1073 
    1074         /**
    1075          * Return the visibility level of this field.
    1076          *
    1077          * @return mixed|void
    1078          */
    1079         function bp_get_the_profile_field_visibility_level() {
    1080                 global $field;
    1081 
    1082                 // On the registration page, values stored in POST should take
    1083                 // precedence over default visibility, so that submitted values
    1084                 // are not lost on failure.
    1085                 if ( bp_is_register_page() && ! empty( $_POST['field_' . $field->id . '_visibility'] ) ) {
    1086                         $retval = esc_attr( $_POST['field_' . $field->id . '_visibility'] );
    1087                 } else {
    1088                         $retval = ! empty( $field->visibility_level ) ? $field->visibility_level : 'public';
    1089                 }
    1090 
    1091                 /**
    1092                  * Filters the profile field visibility level.
    1093                  *
    1094                  * @since 1.6.0
    1095                  *
    1096                  * @param string $retval Field visibility level.
    1097                  */
    1098                 return apply_filters( 'bp_get_the_profile_field_visibility_level', $retval );
    1099         }
    1100 
    1101 /**
    1102  * Echo the visibility level label of this field.
    1103  */
    1104 function bp_the_profile_field_visibility_level_label() {
    1105         echo bp_get_the_profile_field_visibility_level_label();
    1106 }
    1107 
    1108         /**
    1109          * Return the visibility level label of this field.
    1110          *
    1111          * @return mixed|void
    1112          */
    1113         function bp_get_the_profile_field_visibility_level_label() {
    1114                 global $field;
    1115 
    1116                 // On the registration page, values stored in POST should take
    1117                 // precedence over default visibility, so that submitted values
    1118                 // are not lost on failure.
    1119                 if ( bp_is_register_page() && ! empty( $_POST['field_' . $field->id . '_visibility'] ) ) {
    1120                         $level = esc_html( $_POST['field_' . $field->id . '_visibility'] );
    1121                 } else {
    1122                         $level = ! empty( $field->visibility_level ) ? $field->visibility_level : 'public';
    1123                 }
    1124 
    1125                 $fields = bp_xprofile_get_visibility_levels();
    1126 
    1127                 /**
    1128                  * Filters the profile field visibility level label.
    1129                  *
    1130                  * @since 1.6.0
    1131                  *
    1132                  * @param string $retval Field visibility level label.
    1133                  */
    1134                 return apply_filters( 'bp_get_the_profile_field_visibility_level_label', $fields[ $level ]['label'] );
    1135         }
    1136 
    1137 /**
    1138  * Return unserialized profile field data.
    1139  *
    1140  * @param string $value Content to maybe unserialize.
    1141  * @return mixed|string
    1142  */
    1143 function bp_unserialize_profile_field( $value ) {
    1144         if ( is_serialized($value) ) {
    1145                 $field_value = maybe_unserialize($value);
    1146                 $field_value = implode( ', ', $field_value );
    1147                 return $field_value;
    1148         }
    1149 
    1150         return $value;
    1151 }
    1152 
    1153 /**
    1154  * Output XProfile field data.
    1155  *
    1156  * @param string|array $args Array of arguments for field data.
    1157  */
    1158 function bp_profile_field_data( $args = '' ) {
    1159         echo bp_get_profile_field_data( $args );
    1160 }
    1161 
    1162         /**
    1163          * Return XProfile field data.
    1164          *
    1165          * @param string|array $args Array of arguments for field data.
    1166          * @return mixed|void
    1167          */
    1168         function bp_get_profile_field_data( $args = '' ) {
    1169 
    1170                 $r = wp_parse_args( $args, array(
    1171                         'field'   => false, // Field name or ID.
    1172                         'user_id' => bp_displayed_user_id()
    1173                 ) );
    1174 
    1175                 /**
    1176                  * Filters the profile field data.
    1177                  *
    1178                  * @since 1.2.0
    1179                  *
    1180                  * @param mixed $value Profile data for a specific field for the user.
    1181                  */
    1182                 return apply_filters( 'bp_get_profile_field_data', xprofile_get_field_data( $r['field'], $r['user_id'] ) );
    1183         }
    1184 
    1185 /**
    1186  * Get all profile field groups.
    1187  *
    1188  * @since 2.1.0
    1189  *
    1190  * @return array $groups
    1191  */
    1192 function bp_profile_get_field_groups() {
    1193 
    1194         $groups = wp_cache_get( 'all', 'bp_xprofile_groups' );
    1195         if ( false === $groups ) {
    1196                 $groups = bp_xprofile_get_groups( array( 'fetch_fields' => true ) );
    1197                 wp_cache_set( 'all', $groups, 'bp_xprofile' );
    1198         }
    1199 
    1200         /**
    1201          * Filters all profile field groups.
    1202          *
    1203          * @since 2.1.0
    1204          *
    1205          * @param array $groups Array of available profile field groups.
    1206          */
    1207         return apply_filters( 'bp_profile_get_field_groups', $groups );
    1208 }
    1209 
    1210 /**
    1211  * Check if there is more than one group of fields for the profile being edited.
    1212  *
    1213  * @since 2.1.0
    1214  *
    1215  * @return bool True if there is more than one profile field group.
    1216  */
    1217 function bp_profile_has_multiple_groups() {
    1218         $has_multiple_groups = count( (array) bp_profile_get_field_groups() ) > 1;
    1219 
    1220         /**
    1221          * Filters if there is more than one group of fields for the profile being edited.
    1222          *
    1223          * @since 2.1.0
    1224          *
    1225          * @param bool $has_multiple_groups Whether or not there are multiple groups.
    1226          */
    1227         return (bool) apply_filters( 'bp_profile_has_multiple_groups', $has_multiple_groups );
    1228 }
    1229 
    1230 /**
    1231  * Output the tabs to switch between profile field groups.
    1232  *
    1233  * @since 1.0.0
    1234  */
    1235 function bp_profile_group_tabs() {
    1236         echo bp_get_profile_group_tabs();
    1237 
    1238         /**
    1239          * Fires at the end of the tab output for switching between profile field
    1240          * groups. This action is in a strange place for legacy reasons.
    1241          *
    1242          * @since 1.0.0
    1243          */
    1244         do_action( 'xprofile_profile_group_tabs' );
    1245 }
    1246 
    1247 /**
    1248  * Return the XProfile group tabs.
    1249  *
    1250  * @since 2.3.0
    1251  *
    1252  * @return string
    1253  */
    1254 function bp_get_profile_group_tabs() {
    1255 
    1256         // Get field group data.
    1257         $groups     = bp_profile_get_field_groups();
    1258         $group_name = bp_get_profile_group_name();
    1259         $tabs       = array();
    1260 
    1261         // Loop through field groups and put a tab-lst together.
    1262         for ( $i = 0, $count = count( $groups ); $i < $count; ++$i ) {
    1263 
    1264                 // Setup the selected class.
    1265                 $selected = '';
    1266                 if ( $group_name === $groups[ $i ]->name ) {
    1267                         $selected = ' class="current"';
    1268                 }
    1269 
    1270                 // Skip if group has no fields.
    1271                 if ( empty( $groups[ $i ]->fields ) ) {
    1272                         continue;
    1273                 }
    1274 
    1275                 // Build the profile field group link.
    1276                 $link   = trailingslashit( bp_displayed_user_domain() . bp_get_profile_slug() . '/edit/group/' . $groups[ $i ]->id );
    1277 
    1278                 // Add tab to end of tabs array.
    1279                 $tabs[] = sprintf(
    1280                         '<li %1$s><a href="%2$s">%3$s</a></li>',
    1281                         $selected,
    1282                         esc_url( $link ),
    1283                         esc_html( apply_filters( 'bp_get_the_profile_group_name', $groups[ $i ]->name ) )
    1284                 );
    1285         }
    1286 
    1287         /**
    1288          * Filters the tabs to display for profile field groups.
    1289          *
    1290          * @since 1.5.0
    1291          *
    1292          * @param array  $tabs       Array of tabs to display.
    1293          * @param array  $groups     Array of profile groups.
    1294          * @param string $group_name Name of the current group displayed.
    1295          */
    1296         $tabs = apply_filters( 'xprofile_filter_profile_group_tabs', $tabs, $groups, $group_name );
    1297 
    1298         return join( '', $tabs );
    1299 }
    1300 
    1301 /**
    1302  * Output the XProfile group name.
    1303  *
    1304  * @param bool $deprecated Deprecated boolean parameter.
    1305  * @return mixed|void
    1306  */
    1307 function bp_profile_group_name( $deprecated = true ) {
    1308         if ( !$deprecated ) {
    1309                 return bp_get_profile_group_name();
    1310         } else {
    1311                 echo bp_get_profile_group_name();
    1312         }
    1313 }
    1314 
    1315         /**
    1316          * Return the XProfile group name.
    1317          *
    1318          * @return mixed|void
    1319          */
    1320         function bp_get_profile_group_name() {
    1321 
    1322                 // Check action variable.
    1323                 $group_id = bp_action_variable( 1 );
    1324                 if ( empty( $group_id ) || ! is_numeric( $group_id ) ) {
    1325                         $group_id = 1;
    1326                 }
    1327 
    1328                 // Check for cached group.
    1329                 $group = new BP_XProfile_Group( $group_id );
    1330 
    1331                 /**
    1332                  * Filters the profile group name.
    1333                  *
    1334                  * @since 1.0.0
    1335                  *
    1336                  * @param string $name Name of the profile group.
    1337                  */
    1338                 return apply_filters( 'bp_get_profile_group_name', $group->name );
    1339         }
    1340 
    1341 /**
    1342  * Render a formatted string displaying when a profile was last updated.
    1343  */
    1344 function bp_profile_last_updated() {
    1345 
    1346         $last_updated = bp_get_profile_last_updated();
    1347 
    1348         if ( empty( $last_updated ) ) {
    1349                 _e( 'Profile not recently updated.', 'buddypress' );
    1350         } else {
    1351                 echo $last_updated;
    1352         }
    1353 }
    1354 
    1355         /**
    1356          * Return a formatted string displaying when a profile was last updated.
    1357          *
    1358          * @return bool|mixed|void
    1359          */
    1360         function bp_get_profile_last_updated() {
    1361 
    1362                 $last_updated = bp_get_user_meta( bp_displayed_user_id(), 'profile_last_updated', true );
    1363 
    1364                 if ( ! empty( $last_updated ) ) {
    1365 
    1366                         /**
    1367                          * Filters the formatted string used to display when a profile was last updated.
    1368                          *
    1369                          * @since 1.0.0
    1370                          *
    1371                          * @param string $value Formatted last updated indicator string.
    1372                          */
    1373                         return apply_filters( 'bp_get_profile_last_updated', sprintf( __( 'Profile updated %s', 'buddypress' ), bp_core_time_since( strtotime( $last_updated ) ) ) );
    1374                 }
    1375 
    1376                 return false;
    1377         }
    1378 
    1379 /**
    1380  * Display the current profile group ID.
    1381  */
    1382 function bp_current_profile_group_id() {
    1383         echo bp_get_current_profile_group_id();
    1384 }
    1385 
    1386         /**
    1387          * Return the current profile group ID.
    1388          *
    1389          * @since 1.1.0
    1390          *
    1391          * @return mixed|void
    1392          */
    1393         function bp_get_current_profile_group_id() {
    1394                 $profile_group_id = bp_action_variable( 1 );
    1395                 if ( empty( $profile_group_id ) ) {
    1396                         $profile_group_id = 1;
    1397                 }
    1398 
    1399                 /**
    1400                  * Filters the current profile group ID.
    1401                  *
    1402                  * Possible values are admin/profile/edit/[group-id].
    1403                  *
    1404                  * @since 1.1.0
    1405                  *
    1406                  * @param string $profile_group_id Current profile group ID.
    1407                  */
    1408                 return apply_filters( 'bp_get_current_profile_group_id', $profile_group_id );
    1409         }
    1410 
    1411 /**
    1412  * Render an avatar delete link.
    1413  */
    1414 function bp_avatar_delete_link() {
    1415         echo bp_get_avatar_delete_link();
    1416 }
    1417 
    1418         /**
    1419          * Return an avatar delete link.
    1420          *
    1421          * @since 1.1.0
    1422          * @return mixed|void
    1423          */
    1424         function bp_get_avatar_delete_link() {
    1425 
    1426                 /**
    1427                  * Filters the link used for deleting an avatar.
    1428                  *
    1429                  * @since 1.1.0
    1430                  *
    1431                  * @param string $value Nonced URL used for deleting an avatar.
    1432                  */
    1433                 return apply_filters( 'bp_get_avatar_delete_link', wp_nonce_url( bp_displayed_user_domain() . bp_get_profile_slug() . '/change-avatar/delete-avatar/', 'bp_delete_avatar_link' ) );
    1434         }
    1435 
    1436 /**
    1437  * Render an edit profile button.
    1438  */
    1439 function bp_edit_profile_button() {
    1440         bp_button( array(
    1441                 'id'                => 'edit_profile',
    1442                 'component'         => 'xprofile',
    1443                 'must_be_logged_in' => true,
    1444                 'block_self'        => true,
    1445                 'link_href'         => trailingslashit( bp_displayed_user_domain() . bp_get_profile_slug() . '/edit' ),
    1446                 'link_class'        => 'edit',
    1447                 'link_text'         => __( 'Edit Profile', 'buddypress' ),
    1448                 'link_title'        => __( 'Edit Profile', 'buddypress' ),
    1449         ) );
    1450 }
    1451 
    1452 /** Visibility ****************************************************************/
    1453 
    1454 /**
    1455  * Echo the field visibility radio buttons.
    1456  *
    1457  * @param array|string $args Args for the radio buttons.
    1458  */
    1459 function bp_profile_visibility_radio_buttons( $args = '' ) {
    1460         echo bp_profile_get_visibility_radio_buttons( $args );
    1461 }
    1462         /**
    1463          * Return the field visibility radio buttons.
    1464          *
    1465          * @param array|string $args Args for the radio buttons.
    1466          * @return string $retval
    1467          */
    1468         function bp_profile_get_visibility_radio_buttons( $args = '' ) {
    1469 
    1470                 // Parse optional arguments.
    1471                 $r = bp_parse_args( $args, array(
    1472                         'field_id'     => bp_get_the_profile_field_id(),
    1473                         'before'       => '<ul class="radio">',
    1474                         'after'        => '</ul>',
    1475                         'before_radio' => '<li class="%s">',
    1476                         'after_radio'  => '</li>',
    1477                         'class'        => 'bp-xprofile-visibility'
    1478                 ), 'xprofile_visibility_radio_buttons' );
    1479 
    1480                 // Empty return value, filled in below if a valid field ID is found.
    1481                 $retval = '';
    1482 
    1483                 // Only do-the-do if there's a valid field ID.
    1484                 if ( ! empty( $r['field_id'] ) ) :
    1485 
    1486                         // Start the output buffer.
    1487                         ob_start();
    1488 
    1489                         // Output anything before.
    1490                         echo $r['before']; ?>
    1491 
    1492                         <?php if ( bp_current_user_can( 'bp_xprofile_change_field_visibility' ) ) : ?>
    1493 
    1494                                 <?php foreach( bp_xprofile_get_visibility_levels() as $level ) : ?>
    1495 
    1496                                         <?php printf( $r['before_radio'], esc_attr( $level['id'] ) ); ?>
    1497 
    1498                                         <label for="<?php echo esc_attr( 'see-field_' . $r['field_id'] . '_' . $level['id'] ); ?>">
    1499                                                 <input type="radio" id="<?php echo esc_attr( 'see-field_' . $r['field_id'] . '_' . $level['id'] ); ?>" name="<?php echo esc_attr( 'field_' . $r['field_id'] . '_visibility' ); ?>" value="<?php echo esc_attr( $level['id'] ); ?>" <?php checked( $level['id'], bp_get_the_profile_field_visibility_level() ); ?> />
    1500                                                 <span class="field-visibility-text"><?php echo esc_html( $level['label'] ); ?></span>
    1501                                         </label>
    1502 
    1503                                         <?php echo $r['after_radio']; ?>
    1504 
    1505                                 <?php endforeach; ?>
    1506 
    1507                         <?php endif;
    1508 
    1509                         // Output anything after.
    1510                         echo $r['after'];
    1511 
    1512                         // Get the output buffer and empty it.
    1513                         $retval = ob_get_clean();
    1514                 endif;
    1515 
    1516                 /**
    1517                  * Filters the radio buttons for setting visibility.
    1518                  *
    1519                  * @since 1.6.0
    1520                  *
    1521                  * @param string $retval HTML output for the visibility radio buttons.
    1522                  * @param array  $r      Parsed arguments to be used with display.
    1523                  * @param array  $args   Original passed in arguments to be used with display.
    1524                  */
    1525                 return apply_filters( 'bp_profile_get_visibility_radio_buttons', $retval, $r, $args );
    1526         }
    1527 
    1528 /**
    1529  * Output the XProfile field visibility select list for settings.
    1530  *
    1531  * @since 2.0.0
    1532  *
    1533  * @param array|string $args Args for the select list.
    1534  */
    1535 function bp_profile_settings_visibility_select( $args = '' ) {
    1536         echo bp_profile_get_settings_visibility_select( $args );
    1537 }
    1538         /**
    1539          * Return the XProfile field visibility select list for settings.
    1540          *
    1541          * @since 2.0.0
    1542          *
    1543          * @param array|string $args Args for the select list.
    1544          * @return string $retval
    1545          */
    1546         function bp_profile_get_settings_visibility_select( $args = '' ) {
    1547 
    1548                 // Parse optional arguments.
    1549                 $r = bp_parse_args( $args, array(
    1550                         'field_id' => bp_get_the_profile_field_id(),
    1551                         'before'   => '',
    1552                         'after'    => '',
    1553                         'class'    => 'bp-xprofile-visibility'
    1554                 ), 'xprofile_settings_visibility_select' );
    1555 
    1556                 // Empty return value, filled in below if a valid field ID is found.
    1557                 $retval = '';
    1558 
    1559                 // Only do-the-do if there's a valid field ID.
    1560                 if ( ! empty( $r['field_id'] ) ) :
    1561 
    1562                         // Start the output buffer.
    1563                         ob_start();
    1564 
    1565                         // Output anything before.
    1566                         echo $r['before']; ?>
    1567 
    1568                         <?php if ( bp_current_user_can( 'bp_xprofile_change_field_visibility' ) ) : ?>
    1569 
    1570                                 <label for="<?php echo esc_attr( 'field_' . $r['field_id'] ) ; ?>_visibility" class="bp-screen-reader-text"><?php _e( 'Select visibility', 'buddypress' ); ?></label>
    1571                                 <select class="<?php echo esc_attr( $r['class'] ); ?>" name="<?php echo esc_attr( 'field_' . $r['field_id'] ) ; ?>_visibility" id="<?php echo esc_attr( 'field_' . $r['field_id'] ) ; ?>_visibility">
    1572 
    1573                                         <?php foreach ( bp_xprofile_get_visibility_levels() as $level ) : ?>
    1574 
    1575                                                 <option value="<?php echo esc_attr( $level['id'] ); ?>" <?php selected( $level['id'], bp_get_the_profile_field_visibility_level() ); ?>><?php echo esc_html( $level['label'] ); ?></option>
    1576 
    1577                                         <?php endforeach; ?>
    1578 
    1579                                 </select>
    1580 
    1581                         <?php else : ?>
    1582 
    1583                                 <span class="field-visibility-settings-notoggle" title="<?php esc_attr_e( "This field's visibility cannot be changed.", 'buddypress' ); ?>"><?php bp_the_profile_field_visibility_level_label(); ?></span>
    1584 
    1585                         <?php endif;
    1586 
    1587                         // Output anything after.
    1588                         echo $r['after'];
    1589 
    1590                         // Get the output buffer and empty it.
    1591                         $retval = ob_get_clean();
    1592                 endif;
    1593 
    1594                 /**
    1595                  * Filters the dropdown list for setting visibility.
    1596                  *
    1597                  * @since 2.0.0
    1598                  *
    1599                  * @param string $retval HTML output for the visibility dropdown list.
    1600                  * @param array  $r      Parsed arguments to be used with display.
    1601                  * @param array  $args   Original passed in arguments to be used with display.
    1602                  */
    1603                 return apply_filters( 'bp_profile_settings_visibility_select', $retval, $r, $args );
    1604         }
    1605 
    1606 /**
    1607  * Output the 'required' markup in extended profile field labels.
    1608  *
    1609  * @since 2.4.0
    1610  */
    1611 function bp_the_profile_field_required_label() {
    1612         echo bp_get_the_profile_field_required_label();
    1613 }
    1614 
    1615         /**
    1616          * Return the 'required' markup in extended profile field labels.
    1617          *
    1618          * @since 2.4.0
    1619          *
    1620          * @return string HTML for the required label.
    1621          */
    1622         function bp_get_the_profile_field_required_label() {
    1623                 $retval = '';
    1624 
    1625                 if ( bp_get_the_profile_field_is_required() ) {
    1626                         $translated_string = __( '(required)', 'buddypress' );
    1627 
    1628                         $retval = ' <span class="bp-required-field-label">';
    1629                         $retval .= apply_filters( 'bp_get_the_profile_field_required_label', $translated_string, bp_get_the_profile_field_id() );
    1630                         $retval .= '</span>';
    1631 
    1632                 }
    1633 
    1634                 return $retval;
    1635         }

  • trunk/src/bp-xprofile/classes/class-bp-xprofile-user-admin.php

    r10515 r10525  
    11<?php
    22/**
    3  * BuddyPress XProfile Admin.
     3 * BuddyPress XProfile Admin Class.
    44 *
    55 * @package BuddyPress
    6  * @subpackage XProfileAdmin
    7  * @since 1.0.0
     6 * @since 2.0.0
    87 */
    98
    109// Exit if accessed directly.
    1110defined( 'ABSPATH' ) || exit;
    12 
    13 /**
    14  * Creates the administration interface menus and checks to see if the DB
    15  * tables are set up.
    16  *
    17  * @uses bp_current_user_can() returns true if the current user is a site admin, false if not.
    18  * @uses add_users_page() Adds a submenu tab to a top level tab in the admin area.
    19  *
    20  * @return bool
    21  */
    22 function xprofile_add_admin_menu() {
    23 
    24         // Bail if current user cannot moderate community.
    25         if ( ! bp_current_user_can( 'bp_moderate' ) ) {
    26                 return false;
    27         }
    28 
    29         add_users_page( _x( 'Profile Fields', 'xProfile admin page title', 'buddypress' ), _x( 'Profile Fields', 'Admin Users menu', 'buddypress' ), 'manage_options', 'bp-profile-setup', 'xprofile_admin' );
    30 }
    31 add_action( bp_core_admin_hook(), 'xprofile_add_admin_menu' );
    32 
    33 /**
    34  * Handles all actions for the admin area for creating, editing and deleting
    35  * profile groups and fields.
    36  *
    37  * @param string $message Message to display.
    38  * @param string $type    Type of action to be displayed.
    39  */
    40 function xprofile_admin( $message = '', $type = 'error' ) {
    41 
    42         if ( isset( $_GET['mode'] ) && isset( $_GET['group_id'] ) && 'add_field' == $_GET['mode'] ) {
    43                 xprofile_admin_manage_field( $_GET['group_id'] );
    44 
    45         } elseif ( isset( $_GET['mode'] ) && isset( $_GET['group_id'] ) && isset( $_GET['field_id'] ) && 'edit_field' == $_GET['mode'] ) {
    46                 xprofile_admin_manage_field( $_GET['group_id'], $_GET['field_id'] );
    47 
    48         } elseif ( isset( $_GET['mode'] ) && isset( $_GET['field_id'] ) && 'delete_field' == $_GET['mode'] ) {
    49                 xprofile_admin_delete_field( $_GET['field_id'], 'field');
    50 
    51         } elseif ( isset( $_GET['mode'] ) && isset( $_GET['option_id'] ) && 'delete_option' == $_GET['mode'] ) {
    52                 xprofile_admin_delete_field( $_GET['option_id'], 'option' );
    53 
    54         } elseif ( isset( $_GET['mode'] ) && 'add_group' == $_GET['mode'] ) {
    55                 xprofile_admin_manage_group();
    56 
    57         } elseif ( isset( $_GET['mode'] ) && isset( $_GET['group_id'] ) && 'delete_group' == $_GET['mode'] ) {
    58                 xprofile_admin_delete_group( $_GET['group_id'] );
    59 
    60         } elseif ( isset( $_GET['mode'] ) && isset( $_GET['group_id'] ) && 'edit_group' == $_GET['mode'] ) {
    61                 xprofile_admin_manage_group( $_GET['group_id'] );
    62 
    63         } else {
    64                 xprofile_admin_screen( $message, $type );
    65         }
    66 }
    67 
    68 /**
    69  * Output the main XProfile management screen
    70  *
    71  * @since 2.3.0
    72  *
    73  * @param string $message Feedback message.
    74  * @param string $type    Feedback type.
    75  *
    76  * @todo Improve error message output
    77  */
    78 function xprofile_admin_screen( $message = '', $type = 'error' ) {
    79 
    80         // Validate type.
    81         $type = preg_replace( '|[^a-z]|i', '', $type );
    82 
    83         // Get all of the profile groups & fields.
    84         $groups = bp_xprofile_get_groups( array(
    85                 'fetch_fields' => true
    86         ) ); ?>
    87 
    88         <div class="wrap">
    89 
    90                 <h1>
    91                         <?php _ex( 'Profile Fields', 'Settings page header', 'buddypress'); ?>
    92                         <a id="add_group" class="add-new-h2" href="users.php?page=bp-profile-setup&amp;mode=add_group"><?php _e( 'Add New Field Group', 'buddypress' ); ?></a>
    93                 </h1>
    94 
    95                 <form action="" id="profile-field-form" method="post">
    96 
    97                         <?php
    98 
    99                         wp_nonce_field( 'bp_reorder_fields', '_wpnonce_reorder_fields'        );
    100                         wp_nonce_field( 'bp_reorder_groups', '_wpnonce_reorder_groups', false );
    101 
    102                         if ( !empty( $message ) ) :
    103                                 $type = ( $type == 'error' ) ? 'error' : 'updated'; ?>
    104 
    105                                 <div id="message" class="<?php echo $type; ?> fade">
    106                                         <p><?php echo esc_html( $message ); ?></p>
    107                                 </div>
    108 
    109                         <?php endif; ?>
    110 
    111                         <div id="tabs">
    112                                 <ul id="field-group-tabs">
    113 
    114                                         <?php if ( !empty( $groups ) ) : foreach ( $groups as $group ) : ?>
    115 
    116                                                 <li id="group_<?php echo esc_attr( $group->id ); ?>">
    117                                                         <a href="#tabs-<?php echo esc_attr( $group->id ); ?>" class="ui-tab">
    118                                                                 <?php
    119                                                                 /** This filter is documented in bp-xprofile/bp-xprofile-template.php */
    120                                                                 echo esc_html( apply_filters( 'bp_get_the_profile_group_name', $group->name ) );
    121                                                                 ?>
    122 
    123                                                                 <?php if ( !$group->can_delete ) : ?>
    124                                                                         <?php _e( '(Primary)', 'buddypress'); ?>
    125                                                                 <?php endif; ?>
    126 
    127                                                         </a>
    128                                                 </li>
    129 
    130                                         <?php endforeach; endif; ?>
    131 
    132                                 </ul>
    133 
    134                                 <?php if ( !empty( $groups ) ) : foreach ( $groups as $group ) : ?>
    135 
    136                                         <noscript>
    137                                                 <h3><?php
    138                                                 /** This filter is documented in bp-xprofile/bp-xprofile-template.php */
    139                                                 echo esc_html( apply_filters( 'bp_get_the_profile_group_name', $group->name ) );
    140                                                 ?></h3>
    141                                         </noscript>
    142 
    143                                         <div id="tabs-<?php echo esc_attr( $group->id ); ?>" class="tab-wrapper">
    144                                                 <div class="tab-toolbar">
    145                                                         <div class="tab-toolbar-left">
    146                                                                 <a class="button-primary" href="users.php?page=bp-profile-setup&amp;group_id=<?php echo esc_attr( $group->id ); ?>&amp;mode=add_field"><?php _e( 'Add New Field', 'buddypress' ); ?></a>
    147                                                                 <a class="button edit" href="users.php?page=bp-profile-setup&amp;mode=edit_group&amp;group_id=<?php echo esc_attr( $group->id ); ?>"><?php _e( 'Edit Group', 'buddypress' ); ?></a>
    148 
    149                                                                 <?php if ( $group->can_delete ) : ?>
    150 
    151                                                                         <div class="delete-button">
    152                                                                                 <a class="confirm submitdelete deletion ajax-option-delete" href="users.php?page=bp-profile-setup&amp;mode=delete_group&amp;group_id=<?php echo esc_attr( $group->id ); ?>"><?php _e( 'Delete Group', 'buddypress' ); ?></a>
    153                                                                         </div>
    154 
    155                                                                 <?php endif; ?>
    156 
    157                                                                 <?php
    158 
    159                                                                 /**
    160                                                                  * Fires at end of action buttons in xprofile management admin.
    161                                                                  *
    162                                                                  * @since 2.2.0
    163                                                                  *
    164                                                                  * @param BP_XProfile_Group $group BP_XProfile_Group object
    165                                                                  *                                 for the current group.
    166                                                                  */
    167                                                                 do_action( 'xprofile_admin_group_action', $group ); ?>
    168 
    169                                                         </div>
    170                                                 </div>
    171 
    172                                                 <?php if ( ! empty( $group->description ) ) : ?>
    173 
    174                                                         <p><?php
    175                                                         /** This filter is documented in bp-xprofile/bp-xprofile-template.php */
    176                                                         echo esc_html( apply_filters( 'bp_get_the_profile_group_description', $group->description ) );
    177                                                         ?></p>
    178 
    179                                                 <?php endif; ?>
    180 
    181                                                 <fieldset id="<?php echo esc_attr( $group->id ); ?>" class="connectedSortable field-group">
    182                                                         <legend class="screen-reader-text"><?php
    183                                                         /** This filter is documented in bp-xprofile/bp-xprofile-template.php */
    184                                                         printf( esc_html__( 'Fields for "%s" Group', 'buddypress' ), apply_filters( 'bp_get_the_profile_group_name', $group->name ) );
    185                                                         ?></legend>
    186 
    187                                                         <?php
    188 
    189                                                         if ( !empty( $group->fields ) ) :
    190                                                                 foreach ( $group->fields as $field ) {
    191 
    192                                                                         // Load the field.
    193                                                                         $field = xprofile_get_field( $field->id );
    194 
    195                                                                         $class = '';
    196                                                                         if ( empty( $field->can_delete ) ) {
    197                                                                                 $class = ' core nodrag';
    198                                                                         }
    199 
    200                                                                         /**
    201                                                                          * This function handles the WYSIWYG profile field
    202                                                                          * display for the xprofile admin setup screen.
    203                                                                          */
    204                                                                         xprofile_admin_field( $field, $group, $class );
    205 
    206                                                                 } // end for
    207 
    208                                                         else : // !$group->fields ?>
    209 
    210                                                                 <p class="nodrag nofields"><?php _e( 'There are no fields in this group.', 'buddypress' ); ?></p>
    211 
    212                                                         <?php endif; // End $group->fields. ?>
    213 
    214                                                 </fieldset>
    215 
    216                                                 <?php if ( empty( $group->can_delete ) ) : ?>
    217 
    218                                                         <p><?php esc_html_e( '* Fields in this group appear on the signup page.', 'buddypress' ); ?></p>
    219 
    220                                                 <?php endif; ?>
    221 
    222                                         </div>
    223 
    224                                 <?php endforeach; else : ?>
    225 
    226                                         <div id="message" class="error"><p><?php _e( 'You have no groups.', 'buddypress' ); ?></p></div>
    227                                         <p><a href="users.php?page=bp-profile-setup&amp;mode=add_group"><?php _e( 'Add New Group', 'buddypress' ); ?></a></p>
    228 
    229                                 <?php endif; ?>
    230 
    231                         </div>
    232                 </form>
    233         </div>
    234 
    235 <?php
    236 }
    237 
    238 /**
    239  * Handles the adding or editing of groups.
    240  *
    241  * @param int|null $group_id Group ID to manage.
    242  */
    243 function xprofile_admin_manage_group( $group_id = null ) {
    244         global $message, $type;
    245 
    246         // Get the field group.
    247         $group = new BP_XProfile_Group( $group_id );
    248 
    249         // Updating.
    250         if ( isset( $_POST['save_group'] ) ) {
    251 
    252                 // Validate $_POSTed data.
    253                 if ( BP_XProfile_Group::admin_validate() ) {
    254 
    255                         // Set the group name.
    256                         $group->name = $_POST['group_name'];
    257 
    258                         // Set the group description.
    259                         if ( ! empty( $_POST['group_description'] ) ) {
    260                                 $group->description = $_POST['group_description'];
    261                         } else {
    262                                 $group->description = '';
    263                         }
    264 
    265                         // Attempt to save the field group.
    266                         if ( false === $group->save() ) {
    267                                 $message = __( 'There was an error saving the group. Please try again.', 'buddypress' );
    268                                 $type    = 'error';
    269 
    270                         // Save successful.
    271                         } else {
    272                                 $message = __( 'The group was saved successfully.', 'buddypress' );
    273                                 $type    = 'success';
    274 
    275                                 // @todo remove these old options
    276                                 if ( 1 == $group_id ) {
    277                                         bp_update_option( 'bp-xprofile-base-group-name', $group->name );
    278                                 }
    279 
    280                                 /**
    281                                  * Fires at the end of the group adding/saving process, if successful.
    282                                  *
    283                                  * @since 1.0.0
    284                                  *
    285                                  * @param BP_XProfile_Group $group Current BP_XProfile_Group object.
    286                                  */
    287                                 do_action( 'xprofile_groups_saved_group', $group );
    288                         }
    289 
    290                         unset( $_GET['mode'] );
    291                         xprofile_admin( $message, $type );
    292 
    293                 } else {
    294                         $group->render_admin_form( $message );
    295                 }
    296         } else {
    297                 $group->render_admin_form();
    298         }
    299 }
    300 
    301 /**
    302  * Handles the deletion of profile data groups.
    303  *
    304  * @param int $group_id ID of the group to delete.
    305  */
    306 function xprofile_admin_delete_group( $group_id ) {
    307         global $message, $type;
    308 
    309         $group = new BP_XProfile_Group( $group_id );
    310 
    311         if ( !$group->delete() ) {
    312                 $message = __( 'There was an error deleting the group. Please try again.', 'buddypress' );
    313                 $type    = 'error';
    314         } else {
    315                 $message = __( 'The group was deleted successfully.', 'buddypress' );
    316                 $type    = 'success';
    317 
    318                 /**
    319                  * Fires at the end of group deletion process, if successful.
    320                  *
    321                  * @since 1.0.0
    322                  *
    323                  * @param BP_XProfile_Group $group Current BP_XProfile_Group object.
    324                  */
    325                 do_action( 'xprofile_groups_deleted_group', $group );
    326         }
    327 
    328         unset( $_GET['mode'] );
    329         xprofile_admin( $message, $type );
    330 }
    331 
    332 /**
    333  * Handles the adding or editing of profile field data for a user.
    334  *
    335  * @param int      $group_id ID of the group.
    336  * @param int|null $field_id ID of the field being managed.
    337  */
    338 function xprofile_admin_manage_field( $group_id, $field_id = null ) {
    339         global $wpdb, $message, $groups;
    340 
    341         $bp = buddypress();
    342 
    343         if ( is_null( $field_id ) ) {
    344                 $field = new BP_XProfile_Field();
    345         } else {
    346                 $field = xprofile_get_field( $field_id );
    347         }
    348 
    349         $field->group_id = $group_id;
    350 
    351         if ( isset( $_POST['saveField'] ) ) {
    352                 if ( BP_XProfile_Field::admin_validate() ) {
    353                         $field->is_required = $_POST['required'];
    354                         $field->type        = $_POST['fieldtype'];
    355                         $field->name        = $_POST['title'];
    356 
    357                         if ( ! empty( $_POST['description'] ) ) {
    358                                 $field->description = $_POST['description'];
    359                         } else {
    360                                 $field->description = '';
    361                         }
    362 
    363                         if ( ! empty( $_POST["sort_order_{$field->type}"] ) ) {
    364                                 $field->order_by = $_POST["sort_order_{$field->type}"];
    365                         }
    366 
    367                         $field->field_order = $wpdb->get_var( $wpdb->prepare( "SELECT field_order FROM {$bp->profile->table_name_fields} WHERE id = %d", $field_id ) );
    368                         if ( empty( $field->field_order ) || is_wp_error( $field->field_order ) ) {
    369                                 $field->field_order = (int) $wpdb->get_var( $wpdb->prepare( "SELECT max(field_order) FROM {$bp->profile->table_name_fields} WHERE group_id = %d", $group_id ) );
    370                                 $field->field_order++;
    371                         }
    372 
    373                         // For new profile fields, set the $field_id. For existing profile
    374                         // fields, this will overwrite $field_id with the same value.
    375                         $field_id = $field->save();
    376 
    377                         if ( empty( $field_id ) ) {
    378                                 $message = __( 'There was an error saving the field. Please try again.', 'buddypress' );
    379                                 $type    = 'error';
    380                         } else {
    381                                 $message = __( 'The field was saved successfully.', 'buddypress' );
    382                                 $type    = 'success';
    383 
    384                                 // @todo remove these old options
    385                                 if ( 1 == $field_id ) {
    386                                         bp_update_option( 'bp-xprofile-fullname-field-name', $field->name );
    387                                 }
    388 
    389                                 // Set member types.
    390                                 if ( isset( $_POST['has-member-types'] ) ) {
    391                                         $member_types = array();
    392                                         if ( isset( $_POST['member-types'] ) ) {
    393                                                 $member_types = stripslashes_deep( $_POST['member-types'] );
    394                                         }
    395 
    396                                         $field->set_member_types( $member_types );
    397                                 }
    398 
    399                                 // Validate default visibility.
    400                                 if ( ! empty( $_POST['default-visibility'] ) && in_array( $_POST['default-visibility'], wp_list_pluck( bp_xprofile_get_visibility_levels(), 'id' ) ) ) {
    401                                         bp_xprofile_update_field_meta( $field_id, 'default_visibility', $_POST['default-visibility'] );
    402                                 }
    403 
    404                                 // Validate custom visibility.
    405                                 if ( ! empty( $_POST['allow-custom-visibility'] ) && in_array( $_POST['allow-custom-visibility'], array( 'allowed', 'disabled' ) ) ) {
    406                                         bp_xprofile_update_field_meta( $field_id, 'allow_custom_visibility', $_POST['allow-custom-visibility'] );
    407                                 }
    408 
    409                                 // Validate signup.
    410                                 if ( ! empty( $_POST['signup-position'] ) ) {
    411                                         bp_xprofile_update_field_meta( $field_id, 'signup_position', (int) $_POST['signup-position'] );
    412                                 } else {
    413                                         bp_xprofile_delete_meta( $field_id, 'field', 'signup_position' );
    414                                 }
    415 
    416                                 /**
    417                                  * Fires at the end of the process to save a field for a user, if successful.
    418                                  *
    419                                  * @since 1.0.0
    420                                  *
    421                                  * @param BP_XProfile_Field $field Current BP_XProfile_Field object.
    422                                  */
    423                                 do_action( 'xprofile_fields_saved_field', $field );
    424 
    425                                 $groups = bp_xprofile_get_groups();
    426                         }
    427 
    428                         unset( $_GET['mode'] );
    429 
    430                         xprofile_admin( $message, $type );
    431 
    432                 } else {
    433                         $field->render_admin_form( $message );
    434                 }
    435         } else {
    436                 $field->render_admin_form();
    437         }
    438 }
    439 
    440 /**
    441  * Handles the deletion of a profile field (or field option).
    442  *
    443  * @since 1.0.0
    444  * @global string $message The feedback message to show.
    445  * @global $type The type of feedback message to show.
    446  *
    447  * @param int    $field_id    The field to delete.
    448  * @param string $field_type  The type of field being deleted.
    449  * @param bool   $delete_data Should the field data be deleted too.
    450  */
    451 function xprofile_admin_delete_field( $field_id, $field_type = 'field', $delete_data = false ) {
    452         global $message, $type;
    453 
    454         // Switch type to 'option' if type is not 'field'.
    455         // @todo trust this param.
    456         $field_type  = ( 'field' == $field_type ) ? __( 'field', 'buddypress' ) : __( 'option', 'buddypress' );
    457         $field       = xprofile_get_field( $field_id );
    458 
    459         if ( !$field->delete( (bool) $delete_data ) ) {
    460                 $message = sprintf( __( 'There was an error deleting the %s. Please try again.', 'buddypress' ), $field_type );
    461                 $type    = 'error';
    462         } else {
    463                 $message = sprintf( __( 'The %s was deleted successfully!', 'buddypress' ), $field_type );
    464                 $type    = 'success';
    465 
    466                 /**
    467                  * Fires at the end of the field deletion process, if successful.
    468                  *
    469                  * @since 1.0.0
    470                  *
    471                  * @param BP_XProfile_Field $field Current BP_XProfile_Field object.
    472                  */
    473                 do_action( 'xprofile_fields_deleted_field', $field );
    474         }
    475 
    476         unset( $_GET['mode'] );
    477         xprofile_admin( $message, $type );
    478 }
    479 
    480 /**
    481  * Handles the ajax reordering of fields within a group.
    482  *
    483  * @since 1.0.0
    484  */
    485 function xprofile_ajax_reorder_fields() {
    486 
    487         // Check the nonce.
    488         check_admin_referer( 'bp_reorder_fields', '_wpnonce_reorder_fields' );
    489 
    490         if ( empty( $_POST['field_order'] ) ) {
    491                 return false;
    492         }
    493 
    494         parse_str( $_POST['field_order'], $order );
    495 
    496         $field_group_id = $_POST['field_group_id'];
    497 
    498         foreach ( (array) $order['draggable_field'] as $position => $field_id ) {
    499                 xprofile_update_field_position( (int) $field_id, (int) $position, (int) $field_group_id );
    500         }
    501 }
    502 add_action( 'wp_ajax_xprofile_reorder_fields', 'xprofile_ajax_reorder_fields' );
    503 
    504 /**
    505  * Handles the reordering of field groups.
    506  *
    507  * @since 1.5.0
    508  */
    509 function xprofile_ajax_reorder_field_groups() {
    510 
    511         // Check the nonce.
    512         check_admin_referer( 'bp_reorder_groups', '_wpnonce_reorder_groups' );
    513 
    514         if ( empty( $_POST['group_order'] ) ) {
    515                 return false;
    516         }
    517 
    518         parse_str( $_POST['group_order'], $order );
    519 
    520         foreach ( (array) $order['group'] as $position => $field_group_id ) {
    521                 xprofile_update_field_group_position( (int) $field_group_id, (int) $position );
    522         }
    523 }
    524 add_action( 'wp_ajax_xprofile_reorder_groups', 'xprofile_ajax_reorder_field_groups' );
    525 
    526 /**
    527  * Handles the WYSIWYG display of each profile field on the edit screen.
    528  *
    529  * @since 1.5.0
    530  *
    531  * @param object $admin_field Admin field.
    532  * @param object $admin_group Admin group object.
    533  * @param string $class       Classes to append to output.
    534  */
    535 function xprofile_admin_field( $admin_field, $admin_group, $class = '' ) {
    536         global $field;
    537 
    538         $field = $admin_field; ?>
    539 
    540         <fieldset id="draggable_field_<?php echo esc_attr( $field->id ); ?>"class="sortable<?php echo ' ' . $field->type; if ( !empty( $class ) ) echo ' ' . $class; ?>">
    541                 <legend>
    542                         <span>
    543                                 <?php bp_the_profile_field_name(); ?>
    544 
    545                                 <?php if ( empty( $field->can_delete )                                    ) : ?><?php esc_html_e( '(Primary)',  'buddypress' ); endif; ?>
    546                                 <?php bp_the_profile_field_required_label(); ?>
    547                                 <?php if ( bp_xprofile_get_meta( $field->id, 'field', 'signup_position' ) ) : ?><?php esc_html_e( '(Sign-up)',  'buddypress' ); endif; ?>
    548                                 <?php if ( bp_get_member_types() ) : echo $field->get_member_type_label(); endif; ?>
    549 
    550                                 <?php
    551 
    552                                 /**
    553                                  * Fires at end of legend above the name field in base xprofile group.
    554                                  *
    555                                  * @since 2.2.0
    556                                  *
    557                                  * @param BP_XProfile_Field $field Current BP_XProfile_Field
    558                                  *                                 object being rendered.
    559                                  */
    560                                 do_action( 'xprofile_admin_field_name_legend', $field ); ?>
    561                         </span>
    562                 </legend>
    563                 <div class="field-wrapper">
    564 
    565                         <?php
    566                         if ( in_array( $field->type, array_keys( bp_xprofile_get_field_types() ) ) ) {
    567                                 $field_type = bp_xprofile_create_field_type( $field->type );
    568                                 $field_type->admin_field_html();
    569                         } else {
    570 
    571                                 /**
    572                                  * Fires after the input if the current field is not in default field types.
    573                                  *
    574                                  * @since 1.5.0
    575                                  *
    576                                  * @param BP_XProfile_Field $field Current BP_XProfile_Field
    577                                  *                                 object being rendered.
    578                                  * @param int               $value Integer 1.
    579                                  */
    580                                 do_action( 'xprofile_admin_field', $field, 1 );
    581                         }
    582                         ?>
    583 
    584                         <?php if ( $field->description ) : ?>
    585 
    586                                 <p class="description"><?php echo esc_attr( $field->description ); ?></p>
    587 
    588                         <?php endif; ?>
    589 
    590                         <div class="actions">
    591                                 <a class="button edit" href="users.php?page=bp-profile-setup&amp;group_id=<?php echo esc_attr( $admin_group->id ); ?>&amp;field_id=<?php echo esc_attr( $field->id ); ?>&amp;mode=edit_field"><?php _e( 'Edit', 'buddypress' ); ?></a>
    592 
    593                                 <?php if ( $field->can_delete ) : ?>
    594 
    595                                         <div class="delete-button">
    596                                                 <a class="confirm submit-delete deletion" href="users.php?page=bp-profile-setup&amp;field_id=<?php echo esc_attr( $field->id ); ?>&amp;mode=delete_field"><?php _e( 'Delete', 'buddypress' ); ?></a>
    597                                         </div>
    598 
    599                                 <?php endif; ?>
    600 
    601                                 <?php
    602 
    603                                 /**
    604                                  * Fires at end of field management links in xprofile management admin.
    605                                  *
    606                                  * @since 2.2.0
    607                                  *
    608                                  * @param BP_XProfile_Group $group BP_XProfile_Group object
    609                                  *                                 for the current group.
    610                                  */
    611                                 do_action( 'xprofile_admin_field_action', $field ); ?>
    612 
    613                         </div>
    614                 </div>
    615         </fieldset>
    616 
    617 <?php
    618 }
    619 
    620 /**
    621  * Print <option> elements containing the xprofile field types.
    622  *
    623  * @since 2.0.0
    624  *
    625  * @param string $select_field_type The name of the field type that should be selected.
    626  *                                  Will defaults to "textbox" if NULL is passed.
    627  */
    628 function bp_xprofile_admin_form_field_types( $select_field_type ) {
    629         $categories = array();
    630 
    631         if ( is_null( $select_field_type ) ) {
    632                 $select_field_type = 'textbox';
    633         }
    634 
    635         // Sort each field type into its category.
    636         foreach ( bp_xprofile_get_field_types() as $field_name => $field_class ) {
    637                 $field_type_obj = new $field_class;
    638                 $the_category   = $field_type_obj->category;
    639 
    640                 // Fallback to a catch-all if category not set.
    641                 if ( ! $the_category ) {
    642                         $the_category = _x( 'Other', 'xprofile field type category', 'buddypress' );
    643                 }
    644 
    645                 if ( isset( $categories[$the_category] ) ) {
    646                         $categories[$the_category][] = array( $field_name, $field_type_obj );
    647                 } else {
    648                         $categories[$the_category] = array( array( $field_name, $field_type_obj ) );
    649                 }
    650         }
    651 
    652         // Sort the categories alphabetically. ksort()'s SORT_NATURAL is only in PHP >= 5.4 :((.
    653         uksort( $categories, 'strnatcmp' );
    654 
    655         // Loop through each category and output form <options>.
    656         foreach ( $categories as $category => $fields ) {
    657                 printf( '<optgroup label="%1$s">', esc_attr( $category ) );  // Already i18n'd in each profile type class.
    658 
    659                 // Sort these fields types alphabetically.
    660                 uasort( $fields, create_function( '$a, $b', 'return strnatcmp( $a[1]->name, $b[1]->name );' ) );
    661 
    662                 foreach ( $fields as $field_type_obj ) {
    663                         $field_name     = $field_type_obj[0];
    664                         $field_type_obj = $field_type_obj[1];
    665 
    666                         printf( '<option value="%1$s" %2$s>%3$s</option>', esc_attr( $field_name ), selected( $select_field_type, $field_name, false ), esc_html( $field_type_obj->name ) );
    667                 }
    668 
    669                 printf( '</optgroup>' );
    670         }
    671 }
    67211
    67312if ( ! class_exists( 'BP_XProfile_User_Admin' ) ) :
    … …  
    1139478}
    1140479endif; // End class_exists check.
    1141 
    1142 // Load the xprofile user admin.
    1143 add_action( 'bp_init', array( 'BP_XProfile_User_Admin', 'register_xprofile_user_admin' ), 11 );
Note: See TracChangeset for help on using the changeset viewer.