WordPress Development Stack Exchange is a question and answer site for WordPress developers and administrators. It's 100% free, no registration required.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I hope someone can help out with this as it is very frustrating...

I am trying to build a property site in Wordpress and would like to link two custom post types together -

One would be development areas and the other would be individual properties within that development area

I understand that I can create a CPT called 'Developments' and another called 'Properties' but how would I go about linking them together?.. for example if I created a property and tried to attach it to a development how would this work if they are separate custom post types?

I read a similar question - How to connect different CPTs together? and the answer by Scuba Kay was almost what I needed but I don't know how you would query a certain property which belongs to a certain Development

Thanks in advance!

share|improve this question

If I understand what you are doing, you are looking to set up a one to many relationship between development areas and properties.

Here is a class that, if loaded and then instantiated, will:

  • create a meta box for a post type named development_area which contains a check box list of all available properties so that one can update the relationship between the two easily.
  • create a meta box for a post type named property which contains a select box to choose the related development area for a property.
  • ensure that there is a 1 to many relationship between development areas and properties, meaning that a development area can be related to many different properties but any property will only have one related development area.

Note:

This code illustrates how to do this. While I have checked it for stupid errors and double checked the logic, you may well have to tweak things as I've not tested it at runtime. I do this all the time and it works very nicely.

Following the class is an example of how to make it work and then a couple of examples on how to use the relationships that the class sets up.

class One_To_Many_Linker {

    protected $_already_saved = false;  # Used to avoid saving twice

    public function __construct() {
        $this->do_initialize();
    }

Setting up the meta boxes and save functionality

    protected function do_initialize() {

        add_action(
            'save_post',
            array( $this, 'save_meta_box_data' ),
            10,
            2
        );

        add_action(
            "add_meta_boxes_for_development_area",
            array( $this, 'setup_development_area_boxes' )
        );

        add_action(
            "add_meta_boxes_for_property",
            array( $this, 'setup_property_boxes' )
        );

    }

Creating our needed meta box Other metaboxes could easily be set up here as well.

    # Development area post type
    # - this post type can have multiple related properties posts
    public function setup_development_area_boxes( \WP_Post $post ) {
        add_meta_box(
            'area_related_properties_box',
            __('Related Properties', 'language'),
            array( $this, 'draw_area_related_properties_box' ),
            $post->post_type,
            'advanced',
            'default'
        );
    }

Drawing the Related Properties This code draws out the related properties as a series of check boxes.

    public function draw_area_related_properties_box( \WP_Post $post ) {

        $all_properties = $this->get_all_of_post_type( 'property' );

        $linked_property_ids = $this->get_linked_property_ids( $post->ID );

        if ( 0 == count($all_properties) ) {
            $choice_block = '<p>No properties currently in system.</p>';
        } else {
            $choices = array();
            foreach ( $all_properties as $property ) {
                $checked = ( in_array( $property->ID, $linked_property_ids ) ) ? ' checked="checked"' : '';

                $display_name = esc_attr( $property->post_title );
                $choices[] = <<<HTML
<label><input type="checkbox" name="property_ids[]" value="{$property->ID}" {$checked}/> {$display_name}</label>
HTML;

            }
            $choice_block = implode("\r\n", $choices);
        }

        # Make sure the user intended to do this.
        wp_nonce_field(
            "updating_{$post->post_type}_meta_fields",
            $post->post_type . '_meta_nonce'
        );

        echo $choice_block;
    }

Getting lists of posts This grabs all posts of a specific type. If you use sticky posts, you will want to unset the sticky flag in the args argument.

    # Grab all posts of the specified type
    # Returns an array of post objects
    protected function get_all_of_post_type( $type_name = '') {
        $items = array();
        if ( !empty( $type_name ) ) {
            $args = array(
                'post_type' => "{$type_name}",
                'posts_per_page' => -1,
                'order' => 'ASC',
                'orderby' => 'title'
            );
            $results = new \WP_Query( $args );
            if ( $results->have_posts() ) {
                while ( $results->have_posts() ) {
                    $items[] = $results->next_post();
                }
            }
        }
        return $items;
    }

Getting linked property ids for a development area

Given a development area id, this will return an array of all linked property post ids.

    protected function get_linked_property_ids( $area_id = 0 ) {
        $ids = array();
        if ( 0 < $area_id ) {
            $args = array(
                'post_type' => 'property',
                'posts_per_page' => -1,
                'order' => 'ASC',
                'orderby' => 'title',
                'meta_query' => array(
                    array(
                        'key' => '_development_area_id',
                        'value' => (int)$area_id,
                        'type' => 'NUMERIC',
                        'compare' => '='
                    )
                )
            );
            $results = new \WP_Query( $args );
            if ( $results->have_posts() ) {
                while ( $results->have_posts() ) {
                    $item = $results->next_post();
                    $ids[] = $item->ID;
                }
            }
        }
        return $ids;
    }

Setting up the Property meta boxes

You could easily add more meta boxes here if wanted.

    # Post type metabox setup
    public function setup_property_boxes( \WP_Post $post ) {
        add_meta_box(
            'property_linked_area_box',
            __('Related Development Area', 'language'),
            array( $this, 'draw_property_linked_area_box' ),
            $post->post_type,
            'advanced',
            'default'
        );
    }

Drawing the Property editor meta box

This draws a select element (drop down box) that lets the user choose which development area the property relates to. We use a select box to ensure that only one property can be specified, but a list of radio boxes would work also.

    public function draw_property_linked_area_box( \WP_Post $post ) {

        $all_areas = $this->get_all_of_post_type('development_area');

        $related_area_id = $this->get_property_linked_area_id( $post->ID );

        if ( 0 == $all_areas ) {
            $choice_block = '<p>No development areas to choose from yet.</p>';
        } else {
            $choices = array();
            $selected = ( 0 == $related_area_id )? ' selected="selected"':'';
            $choices[] = '<option value=""' . $selected . '> -- None -- </option>';
            foreach ( $all_areas as $area ) {
                $selected = ( $area->ID == (int)$related_area_id ) ? ' selected="selected"' : '';

                $display_name = esc_attr( $area->post_title );
                $choices[] = <<<HTML
<option value="{$area->ID}" {$selected}>{$display_name}</option>
HTML;

            }
            $choice_list = implode("\r\n" . $choices);
            $choice_block = <<<HTML
<select name="development_area_id">
{$choice_list}
</select>
HTML;

        }

        wp_nonce_field(
            "updating_{$post->post_type}_meta_fields",
            $post->post_type . '_meta_nonce'
        );

        echo $choice_block;
    }

The method of linking

Note that we establish our links by setting a _development_area_id key on each property.

  • development areas can query properties with this key to display them
  • properties can pull their own meta or have their query filtered to pull development data

    protected function get_property_linked_area_id( $property_id = 0 ) {
        $area_id = 0;
        if ( 0 < $property_id ) {
            $area_id = (int) get_post_meta( $property_id, '_development_area_id', true );
        }
        return $area_id;
    }
    

Saving the meta data

We take pains to only save when necessary and proper. See code comments.

    public function save_meta_box_data( $post_id = 0, \WP_Post $post = null ) {

        $do_save = true;

        $allowed_post_types = array(
            'development_area',
            'property'
        );

        # Do not save if we have already saved our updates
        if ( $this->_already_saved ) {
            $do_save = false;
        }

        # Do not save if there is no post id or post
        if ( empty($post_id) || empty( $post ) ) {
            $do_save = false;
        } else if ( ! in_array( $post->post_type, $allowed_post_types ) ) {
            $do_save = false;
        }

        # Do not save for revisions or autosaves
        if (
            defined('DOING_AUTOSAVE')
            && (
                is_int( wp_is_post_revision( $post ) )
                || is_int( wp_is_post_autosave( $post ) )
            )
        ) {
            $do_save = false;
        }

        # Make sure proper post is being worked on
        if ( !array_key_exists('post_ID', $_POST) || $post_id != $_POST['post_ID'] ) {
            $do_save = false;
        }

        # Make sure we have the needed permissions to save [ assumes both types use edit_post ]
        if ( ! current_user_can( 'edit_post', $post_id ) ) {
            $do_save = false;
        }

        # Make sure the nonce and referrer check out.
        $nonce_field_name = $post->post_type . '_meta_nonce';
        if ( ! array_key_exists( $nonce_field_name, $_POST) ) {
            $do_save = false;
        } else if ( ! wp_verify_nonce( $_POST["{$nonce_field_name}"], "updating_{$post->post_type}_meta_fields" ) ) {
            $do_save = false;
        } else if ( ! check_admin_referer( "updating_{$post->post_type}_meta_fields", $nonce_field_name ) ) {
            $do_save = false;
        }

        if ( $do_save ) {
            switch ( $post->post_type ) {
                case "development_area":
                    $this->handle_development_area_meta_changes( $post_id, $_POST );
                    break;
                case "property":
                    $this->handle_property_meta_changes( $post_id, $_POST );
                    break;
                default:
                    # We do nothing about other post types
                    break;
            }

            # Note that we saved our data
            $this->_already_saved = true;
        }
        return;
    }

Updating Development Properties

We read the list of checked property post types, grab the list of currently related property post types, and then use those lists to determine what to update.

Notice: We are updating meta data on property post types here, not on our edited development area.

    # Development areas can link to multiple properties
    # but each property can only link to a single development area
    protected function handle_development_area_meta_changes( $post_id = 0, $data = array() ) {

        # Get the currently linked property ids for this development area
        $linked_property_ids = $this->get_linked_property_ids( $post_id );

        # Get the list of property ids checked when the user saved changes
        if ( array_key_exists('property_ids', $data) && is_array( $data['property_ids'] ) ) {
            $chosen_property_ids = $data['property_ids'];
        } else {
            $chosen_property_ids = array();
        }

        # Build a list of properties to be linked or unlinked from this area
        $to_remove = array();
        $to_add = array();

        if ( 0 < count( $chosen_property_ids ) ) {
            # The user chose at least one property to link to
            if ( 0 < count( $linked_property_ids ) ) {
                # We already had at least one property linked

                # Cycle through existing and note any that the user did not have checked
                foreach ( $linked_property_ids as $property_id ) {
                    if ( ! in_array( $property_id, $chosen_property_ids ) ) {
                        # Currently linked, but not chosen. Remove it.
                        $to_remove[] = $property_id;
                    }
                }

                # Cycle through checked and note any that are not currently linked
                foreach ( $chosen_property_ids as $property_id ) {
                    if ( ! in_array( $property_id, $linked_property_ids ) ) {
                        # Chosen but not in currently linked. Add it.
                        $to_add[] = $property_id;
                    }
                }

            } else {
                # No previously chosen ids, simply add them all
                $to_add = $chosen_property_ids;
            }

        } else if ( 0 < count( $linked_property_ids ) ) {
            # No properties chosen to be linked. Remove all currently linked.
            $to_remove = $linked_property_ids;
        }

        if ( 0 < count($to_add) ) {
            foreach ( $to_add as $property_id ) {
                # This will overwrite any existing value for the linking key
                # to ensure we maintain only one dev area linked by each property.
                update_post_meta( $property_id, '_development_area_id', $post_id );
            }
        }

        if ( 0 < count( $to_remove ) ) {
            foreach ( $to_remove as $property_id ) {
                # This will delete all existing linked areas for the property
                # to ensure we only ever have one linked area per property
                delete_post_meta( $property_id, '_development_area_id' );
            }
        }
    }

Saving our Property Changes

Since our meta key is on each property, we simply update our meta data if necessary. As reading is almost always faster in mysql than writing, we only update if absolutely necessary.

    # Properties only relate to a single development area
    protected function handle_property_meta_changes( $post_id = 0, $data = array() ) {

        # Get any currently linked development area
        $linked_area_id = $this->get_property_linked_area_id( $post_id );
        if ( empty($linked_area_id) ) {
            $linked_area_id = 0;
        }

        if ( array_key_exists( 'development_area_id', $data ) && !empty($data['development_area_id'] ) ) {
            $received_area_id = (int)$data['development_area_id'];
        } else {
            $received_area_id = 0;
        }

        if ( $received_area_id != $linked_area_id ) {
            # This will overwrite any and all existing copies of our meta key
            # so we can ensure we only have one linked area per property
            update_post_meta( $post_id, '_development_area_id', $received_area_id );
        }
    }
}

How To Use The Class

Provided you load the class in your theme functions file or in a plugin, you can use the following to make things work:

if ( is_admin() ) {
    new One_To_Many_Linker();
}

Some Use Cases Follow Below, I've provided a couple of front end use cases.

  • Displaying all properties for the current development area
  • Displaying the development area for a property on an archive or single property

Showing all properties related to the currently displayed development area

global $wp_query;
$area_id = $wp_query->get_queried_object_id();
$args = array(
    'post_type' => 'property',
    'posts_per_page' => -1,
    'meta_query' => array(
        array(
            'key' => '_development_area_id',
            'value' => $area_id,
            'compare' => '=',
            'type' => 'NUMERIC'
        )
    )
);
$properties = new \WP_Query( $args );
if ( $properties->have_posts() ) {
    while( $properties->have_posts() ) {
        $property = $properties->next_post();
        # do something with the property
        $property_link = get_permalink( $property->ID );
        $property_name = esc_attr( $property->post_title );
        echo '<a href="' . $property_link . '">' . $property_name . '</a>';
    }
}

Showing Linked Development Areas

Method 1: Grabbing the post meta, loading the area, and using the data

  • works on pages where is_singular('property') is true
  • works on pages where is_post_type_archive('property') is true

global $post;
while ( have_posts() ) {
    the_post();
    $post_id = get_the_ID(); # could use $post->ID

    $dev_area_id = get_post_meta( $post_id, '_development_area_id', true);
    if ( !empty( $dev_area_id ) ) {
        $development_area = get_post( $dev_area_id );
        # do something...
        $dev_area_link = get_permalink ( $development_area->ID );
        $dev_area_title = $development_area->post_title;
        $dev_area_content = $development_area->post_content;
        echo '<a href="' . $dev_area_link . '">' . $dev_area_title . '</a><br />' . $dev_area_content;
    }
}

Method 2: Using a query filter

  • works on pages where is_singular('property') is true
  • works on pages where is_post_type_archive('property') is true

Notice that this avoids having to pull the post type meta and doing an extra query for the development area data. As you show more properties on a single page, this saves you more and more processing power.

Where to put the following code:

  • In a new plugin that you create recommended
  • In your theme functions.php file

add_filter('posts_clauses', 'do_my_maybe_modify_queries', 10, 2);
function do_my_maybe_modify_queries( $pieces, \WP_Query $wp_query ) {

    if ( !is_admin() && $wp_query->is_main_query() ) {
        # We are not in the admin panels and we are the primary query for the template

        if ( array_key_exists('post_type', $wp_query->query_vars) ) {
            # A post type of some kind was queried.
            # Grab it as an array of the types specified
            $value = $wp_query->query_vars['post_type'];
            if ( !is_array( $value ) ) {
                if ( empty( $value ) ) {
                    $post_types = array();
                } else {
                    $post_types = array( $value );
                }
            } else {
                $post_types = $value;
            }

            if ( in_array('property', $post_types) ) {
                # We were asked for a property
                if ( $wp_query->is_post_type_archive || $wp_query->is_singular ) {
                    # Showing the property post type archive or a singular property.
                    # We want to add our development area id, title, and content to the returned fields
                    global $wpdb;

                    # Link the development post to each property through its postmeta key
                    # Since there is only 1 development area per property, this works fine
                    $pieces['join'] .= <<<SQL
 LEFT JOIN {$wpdb->prefix}postmeta AS dev_pm ON {$wpdb->prefix}posts.ID = dev_pm.post_id AND dev_pm.meta_key = '_development_area_id'
    LEFT JOIN {$wpdb->prefix}posts AS dev_post ON dev_post.ID = dev_pm.meta_value 
SQL;

                    # Add our wanted development post fields to those returned by the query
                    $pieces['fields'] .= ", IFNULL( dev_pm.meta_value, 0 ) as development_area_id";
                    $pieces['fields'] .= ", IFNULL( dev_post.post_title, '') as development_area_title";
                    $pieces['fields'] .= ", IFNULL( dev_post.post_content, '') as development_area_content";

                }
            }
        }
    }
    return $pieces;
}

With the above in place, you can now access the data as follows on a single property page or property archive. I leave doing this for taxonomies related to properties as an exercise to the reader.

if ( have_posts() ) {
    global $post;
    while ( have_posts() ) {
        the_post();
        if ( property_exists( $post, 'development_area_id' ) ) {
            $dev_area_id = $post->development_area_id;
            $dev_area_title = $post->development_area_title;
            $dev_area_content = $post->development_area_content;
            $dev_area_link = get_permalink( $dev_area_id );
            echo '<a href="' . $dev_area_link . '">' . $dev_area_title . '</a><br />' . $dev_area_content;
        }
    }
}

Method 3: Filtering WP_Query

Like the filter method above, but usable for custom queries using WP_Query. Great if you want to write a short code or widget that displays a bunch of properties.

First, we create our filter (very similar to that shown on method 2)

function add_dev_data_to_wp_query( $pieces, \WP_Query $wp_query ) {
    global $wpdb;

    if ( !is_admin() && !$wp_query->is_main_query() ) {
        # Link the development post to each property through its postmeta key
        # Since there is only 1 development area per property, this works fine
        $pieces['join'] .= <<<SQL
 LEFT JOIN {$wpdb->prefix}postmeta AS dev_pm ON {$wpdb->prefix}posts.ID = dev_pm.post_id AND dev_pm.meta_key = '_development_area_id'
    LEFT JOIN {$wpdb->prefix}posts AS dev_post ON dev_post.ID = dev_pm.meta_value 
SQL;

        # Add our wanted development post fields to those returned by the query
        $pieces['fields'] .= ", IFNULL( dev_pm.meta_value, 0 ) as development_area_id";
        $pieces['fields'] .= ", IFNULL( dev_post.post_title, '') as development_area_title";
        $pieces['fields'] .= ", IFNULL( dev_post.post_content, '') as development_area_content";
    }
    return $pieces;
}

Next, we apply our filter before we create the query and remove it right afterwards to ensure we do not alter other queries.

$args = array(
    'post_type' => 'property',
    'posts_per_page' => -1
);

# Apply our filter
add_filter('posts_clauses', 'add_dev_data_to_wp_query', 10, 2);

# Run the query
$properties = new \WP_Query( $args );

# Remove our filter
remove_filter('posts_clauses', 'add_dev_data_to_wp_query', 10);

if ( $properties->have_posts() ) {
    while( $properties->have_posts() ) {
        $property = $properties->next_post();

        # Do stuff with your properties
        echo '<p>The property name is ' . $property->post_title . '</p>';

        # Do stuff with related development areas if that data is available
        if ( property_exists( $property, 'development_area_id' ) ) {
            echo '<p>Part of the development area named ' . $property->development_area_title . '</p>';
        }
    }
}

While it takes a little more work up front to do things like this, it provides a couple of nice benefits

  • You are doing just 1 query instead of 2 to 3 queries to display related information. This adds up fast.
  • Once you are comfortable with it, you can use with relationships to multiple objects which will save you multiple extra queries each
  • Using a variation on this, you can do the same to add titles (and view and edit links) to the editor listing columns. For example with the above scenario you might list the development for each property in the properties list in the admin.

Of course, this is already long enough.

share|improve this answer

You can use the fantastic and free Advanced Custom Fields plugin, which allows you to create a Relationship custom field, that relates one post to another post.

Anyway, first of all you should make sure you really need two custom post types, and you cannot use taxonomies or just custom fields. For example, an individual Property may be a post type, and the Development Area they belong to, may be a Taxonomy or a Custom Field containing the name of that Development Area... It basically depends on how much information you need to keep about both Development Areas and Properties...

share|improve this answer

I would keep it simple and simply make the properties found within a development into child posts of the parent development post. You could also use the standard category taxonomy and mark each "sub" property as part of the larger development. You could just have to input these developments as categories in the taxonomy. This way you keep all the properties in one long and easy to manage list. You can include or exclude whatever you need when you call this list by using the depth parameter or the taxonomy.

share|improve this answer
    
Thanks for your help, how would I go about making the properties found within a development into child posts of the parent development post? – Kieran May 5 '14 at 21:50
    
First make the parent (development) page/post. Then add a new page and on the right hand side of the editor you should see a page attributes box and one of the fields is called Parent with a drop down box. Use that to select the development. That should do it! – campatsky May 6 '14 at 15:52

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.