Changeset 12729

Timestamp:

09/21/2020 01:21:21 AM (6 years ago)

Author:

imath

Message:

BP Types: merge BP Types saved in DB with the ones registered by code

• Introduces the bp_get_taxonomy_types() to merge types saved into the database with the types registered by code. It's now possible to edit all properties of the registered by code types except for the type's slug which needs to be unique.
• Caches these merged types.
• Introduces the bp_get_member_types_registered_by_code() to only get member types registered by code.
• Updates the test_bp_get_member_type_should_not_return_unregistered_types() unit test to test_bp_get_registered_by_code_member_type_should_not_return_unregistered_types() to check the previous point new function.
• Introduces the bp_update_type_metadata() function to update a type's metadata.

Props mercime, DJPaul, dcavins, boonebgorges, tw2113, sbrajesh

See #7179
See #7181

Location:

trunk

Files:

• src/bp-core/bp-core-cache.php (modified) (1 diff)
• src/bp-core/bp-core-functions.php (modified) (1 diff)
• src/bp-members/bp-members-functions.php (modified) (5 diffs)
• tests/phpunit/testcases/members/types.php (modified) (2 diffs)

trunk/src/bp-core/bp-core-cache.php

@@ -391 +391 @@
 add_action( 'bp_invitation_after_save', 'bp_invitations_reset_cache_incrementor' );
 add_action( 'bp_invitation_after_delete', 'bp_invitations_reset_cache_incrementor' );
+
+/**
+ * Add a cache group for Database object types.
+ *
+ * @since 7.0.0
+ */
+function bp_set_object_type_terms_cache_group() {
+        wp_cache_add_global_groups( 'bp_object_terms' );
+}
+add_action( 'bp_setup_cache_groups', 'bp_set_object_type_terms_cache_group' );
+
+/**
+ * Clear the Database object types cache.
+ *
+ * @since 7.0.0
+ *
+ * @param int $type_id The Type's term ID.
+ * @param string $taxonomy The Type's taxonomy name.
+ */
+function bp_clear_object_type_terms_cache( $type_id = 0, $taxonomy = '' ) {
+        wp_cache_delete( $taxonomy, 'bp_object_terms' );
+}
+add_action( 'bp_type_inserted', 'bp_clear_object_type_terms_cache' );
+add_action( 'bp_type_updated', 'bp_clear_object_type_terms_cache' );
+add_action( 'bp_type_deleted', 'bp_clear_object_type_terms_cache' );

trunk/src/bp-core/bp-core-functions.php

@@ -3144 +3144 @@
 }
 
+/**
+ * Update a list of metadata for a given type ID and a given taxonomy.
+ *
+ * @since 7.0.0
+ *
+ * @param  integer $type_id    The database ID of the BP Type.
+ * @param  string  $taxonomy   The BP Type taxonomy.
+ * @param  array   $type_metas An associative array (meta_key=>meta_value).
+ * @return boolean             False on failure. True otherwise.
+ */
+function bp_update_type_metadata( $type_id = 0, $taxonomy = '', $type_metas = array() ) {
+        if ( ! $type_id || ! $taxonomy || ! is_array( $type_metas ) ) {
+                return false;
+        }
+
+        foreach ( $type_metas as $meta_key => $meta_value ) {
+                if ( ! registered_meta_key_exists( 'term', $meta_key, $taxonomy ) ) {
+                        continue;
+                }
+
+                update_term_meta( $type_id, $meta_key, $meta_value );
+        }
+
+        return true;
+}
+
+/**
+ * Get types for a given BP Taxonomy.
+ *
+ * @since 7.0.0
+ *
+ * @param string $taxonomy The taxonomy to transform terms in types for.
+ * @param array  $types    Existing types to merge with the types found into the database.
+ *                         For instance this function is used internally to merge Group/Member
+ *                         types registered using code with the ones created by the administrator
+ *                         from the Group/Member types Administration screen. If not provided, only
+ *                         Types created by the administrator will be returned.
+ *                         Optional.
+ * @return array           The types of the given taxonomy.
+ */
+function bp_get_taxonomy_types( $taxonomy = '', $types = array() ) {
+        if ( ! $taxonomy ) {
+                return $types;
+        }
+
+        $db_types = wp_cache_get( $taxonomy, 'bp_object_terms' );
+
+        if ( ! $db_types ) {
+                $terms = bp_get_terms(
+                        array(
+                                'taxonomy' => $taxonomy,
+                        )
+                );
+
+                if ( ! is_array( $terms ) || ! $terms ) {
+                        return $types;
+                }
+
+                $type_metadata = array_keys( get_registered_meta_keys( 'term', $taxonomy ) );
+
+                foreach ( $terms as $term ) {
+                        $type_name                      = $term->name;
+                        $db_types[ $type_name ]         = new stdClass();
+                        $db_types[ $type_name ]->db_id  = $term->term_id;
+                        $db_types[ $type_name ]->labels = array();
+                        $db_types[ $type_name ]->name   = $type_name;
+
+                        if ( $type_metadata ) {
+                                foreach ( $type_metadata as $meta_key ) {
+                                        $type_key = str_replace( 'bp_type_', '', $meta_key );
+                                        if ( in_array( $type_key, array( 'name', 'singular_name' ), true ) ) {
+                                                $db_types[ $type_name ]->labels[ $type_key ] = get_term_meta( $term->term_id, $meta_key, true );
+                                        } else {
+                                                $db_types[ $type_name ]->{$type_key} = get_term_meta( $term->term_id, $meta_key, true );
+                                        }
+                                }
+                        }
+                }
+
+                wp_cache_set( $taxonomy, $db_types, 'bp_object_terms' );
+        }
+
+        if ( is_array( $db_types ) ) {
+                foreach ( $db_types as $db_type_name => $db_type ) {
+                        // Override props of registered by code types if customized by the admun user.
+                        if ( isset( $types[ $db_type_name ] ) && isset( $types[ $db_type_name ]->code ) && $types[ $db_type_name ]->code ) {
+                                // Merge Labels.
+                                if ( $db_type->labels ) {
+                                        foreach ( $db_type->labels as $key_label => $value_label ) {
+                                                if ( '' !== $value_label ) {
+                                                        $types[ $db_type_name ]->labels[ $key_label ] = $value_label;
+                                                }
+                                        }
+                                }
+
+                                // Merge other properties.
+                                foreach ( get_object_vars( $types[ $db_type_name ] ) as $key_prop => $value_prop ) {
+                                        if ( 'labels' === $key_prop || 'name' === $key_prop ) {
+                                                continue;
+                                        }
+
+                                        if ( isset( $db_type->{$key_prop} ) && '' !== $db_type->{$key_prop} ) {
+                                                $types[ $db_type_name  ]->{$key_prop} = $db_type->{$key_prop};
+                                        }
+                                }
+
+                                unset( $db_types[ $db_type_name ] );
+                        }
+                }
+        }
+
+        return array_merge( $types, (array) $db_types );
+}
+
 /** Email *****************************************************************/
 

trunk/src/bp-members/bp-members-functions.php

@@ -2764 +2764 @@
                 'labels'        => array(),
                 'has_directory' => true,
+                'code'          => true,
+                'db_id'         => 0,
         ), 'register_member_type' );
 
@@ -2863 +2865 @@
         $types = buddypress()->members->types;
 
+        // Merge with types available into the database.
+        if ( ! isset( $args['code'] ) || true !== $args['code'] ) {
+                $types = bp_get_taxonomy_types( bp_get_member_type_tax_name(), $types );
+        }
+
         $types = wp_filter_object_list( $types, $args, $operator );
 
@@ -2885 +2892 @@
         return $types;
 }
+
+/**
+ * Only gets the member types registered by code.
+ *
+ * @since 7.0.0
+ *
+ * @return array The member types registered by code.
+ */
+function bp_get_member_types_registered_by_code() {
+        return bp_get_member_types(
+                array(
+                        'code' => true,
+                ),
+                'objects'
+        );
+}
+add_filter( bp_get_member_type_tax_name() . '_registered_by_code', 'bp_get_member_types_registered_by_code' );
+
+/**
+ * Generates missing metadata for a type registered by code.
+ *
+ * @since 7.0.0
+ *
+ * @return array The member type metadata.
+ */
+function bp_set_registered_by_code_member_type_metadata( $metadata = array(), $type = '' ) {
+        $member_type = bp_get_member_type_object( $type );
+
+        foreach ( get_object_vars( $member_type ) as $object_key => $object_value ) {
+                if ( 'labels' === $object_key ) {
+                        foreach ( $object_value as $label_key => $label_value ) {
+                                $metadata[ 'bp_type_' . $label_key ] = $label_value;
+                        }
+                } elseif ( ! in_array( $object_key, array( 'name', 'code', 'db_id' ), true ) ) {
+                        $metadata[ 'bp_type_' . $object_key ] = $object_value;
+                }
+        }
+
+        /**
+         * Save metadata into database to avoid generating metadata
+         * each time a type is listed into the Types Admin screen.
+         */
+        if ( isset( $member_type->db_id ) && $member_type->db_id ) {
+                bp_update_type_metadata( $member_type->db_id, bp_get_member_type_tax_name(), $metadata );
+        }
+
+        return $metadata;
+}
+add_filter( bp_get_member_type_tax_name() . '_set_registered_by_code_metada', 'bp_set_registered_by_code_member_type_metadata', 10, 2 );
+
+/**
+ * Insert member types registered by code not yet saved into the database as WP Terms.
+ *
+ * @since 7.0.0
+ */
+function bp_insert_member_types_registered_by_code() {
+        $all_types     = bp_get_member_types( array(), 'objects' );
+        $unsaved_types = wp_filter_object_list( $all_types, array( 'db_id' => 0 ), 'and', 'name' );
+
+        if ( $unsaved_types ) {
+                foreach ( $unsaved_types as $type_name ) {
+                        bp_insert_term(
+                                $type_name,
+                                bp_get_member_type_tax_name(),
+                                array(
+                                        'slug' => $type_name,
+                                )
+                        );
+                }
+        }
+}
+add_action( bp_get_member_type_tax_name() . '_add_form', 'bp_insert_member_types_registered_by_code', 1 );
 
 /**
@@ -2969 +3048 @@
  *
  * @since 2.2.0
+ * @since 7.0.0 Adds the `$use_db` parameter.
  *
  * @param int  $user_id ID of the user.
  * @param bool $single  Optional. Whether to return a single type string. If multiple types are found
  *                      for the user, the oldest one will be returned. Default: true.
+ * @param bool $use_db  Optional. Whether to request all member types or only the ones registered by code.
+ *                      Default: true.
  * @return string|array|bool On success, returns a single member type (if $single is true) or an array of member
  *                           types (if $single is false). Returns false on failure.
  */
-function bp_get_member_type( $user_id, $single = true ) {
+function bp_get_member_type( $user_id, $single = true, $use_db = true ) {
         $types = wp_cache_get( $user_id, 'bp_member_member_type' );
 
@@ -2994 +3076 @@
                         wp_cache_set( $user_id, $types, 'bp_member_member_type' );
                 }
+        }
+
+        if ( false === $use_db && $types ) {
+                $registred_by_code = bp_get_member_types_registered_by_code();
+                $ctype_names       = wp_list_pluck( $registred_by_code, 'name' );
+                $types             = array_intersect( $types, $ctype_names );
         }
 

trunk/tests/phpunit/testcases/members/types.php

@@ -394 +394 @@
         }
 
-        public function test_bp_get_member_type_should_not_return_unregistered_types() {
+        public function test_bp_get_registered_by_code_member_type_should_not_return_unregistered_types() {
                 $u1 = self::factory()->user->create();
                 bp_register_member_type( 'foo' );
@@ -402 +402 @@
                 bp_set_object_terms( $u1, 'ugh', bp_get_member_type_tax_name(), true );
 
-                $type = bp_get_member_type( $u1, false );
+                $type = bp_get_member_type( $u1, false, false );
                 $this->assertEquals( array( 'foo' ), $type );
         }