:sparkles: fixing up related posts in endpoint plugin | making content optional in endpoint plugin | displaying related posts in frontend | moved data loading in single template

plugins/cia-endpoints/includes/class.make-endpoint.php

 
         // https://developer.wordpress.org/reference/functions/get_posts/
         foreach( get_posts($args) as $item ) {
-            $filtered = default_post_format( $item );
+            $filtered = default_post_format( $item, false );
 
             // Get those Block!
             $filtered[blocks] = get_rearrange_blocks(
             // For your hero URL
             $filtered[hero] = get_post_meta( $item->ID, 'hero_header', true );
 
-            $filtered[credits] = get_post_meta( $item->ID, 'credits', true );
-
             $filtered[relatedto] = p2p_related_to( $item->ID, $item->post_type );
 
             $collection[$item->ID] = $filtered;
 
         // https://developer.wordpress.org/reference/functions/get_posts/
         foreach( get_posts($args) as $item ) {
-            $filtered = default_post_format( $item );
+            $filtered = default_post_format( $item, true );
 
             // Find all image info
             $filtered[attached] = $this->_getAttachments( $item, $filtered[galleries] );

plugins/cia-endpoints/includes/class.make-sortby.php

             ),
         ]);
     }
-    
+
     public function by_alpha( $request ) {
         global $wpdb;
         $res = $wpdb->get_results($wpdb->prepare(
-            "SELECT DISTINCT wp_posts.*, 
+            "SELECT DISTINCT wp_posts.*,
             IFNULL(wp_postmeta.meta_value, SUBSTRING_INDEX(wp_posts.post_title, ' ', -1)) AS sort_name
-            FROM wp_posts LEFT JOIN wp_postmeta 
-            ON (wp_postmeta.post_id = wp_posts.ID AND wp_postmeta.meta_key='artist-sort-name') 
+            FROM wp_posts LEFT JOIN wp_postmeta
+            ON (wp_postmeta.post_id = wp_posts.ID AND wp_postmeta.meta_key='artist-sort-name')
             WHERE wp_posts.post_type='artist' AND wp_posts.post_status='publish'
             ORDER BY sort_name",
             $this->post_type
         ));
         wp_reset_postdata();
-        
+
         return new WP_REST_Response( $this->prepare_items_for_reponse($res), 200 );
     }
 
         // !: Make this a real query
         $res = $wpdb->get_results($wpdb->prepare(
             "SELECT * FROM wp_posts
-            WHERE post_type = %s 
+            WHERE post_type = %s
             AND post_status='publish'",
             $this->post_type
         ));
 
     public function prepare_items_for_reponse( $items ) {
         $collection = array();
-        forEach( $items as $key => $item ) $collection[$key] = default_post_format($item);
+        forEach( $items as $key => $item ) $collection[$key] = default_post_format($item, true);
         return $collection;
     }
 }

plugins/cia-endpoints/includes/formats.php

 }
 
 
-function default_post_format( $item ) {
-    $filtered = array();
+function default_post_format( $item, $omit_content ) {
+    $filtered = [];
     $filtered[id] = $item->ID;
     $filtered[slug] = $item->post_name;
     $filtered[type] = $item->post_type;
     $filtered[title] = $item->post_title;
     $filtered[excerpt] = $item->post_excerpt;
     $filtered[date] = $item->post_date;
-    $filtered[content] = $item->post_content;
+
+    if($include_content) $filtered[content] = $item->post_content;
+
     $filtered[featured] = get_the_post_thumbnail_url($item);
 
 
     $posts_with_type = ['artist', 'exhbition', 'event'];
     if( in_array($item->post_type, $posts_with_type) ) {
         $filtered[materials] = make_taxonomy_endpoint_for( get_the_terms( $item, 'material' ) );
-        $filtered[type] = make_taxonomy_endpoint_for( get_the_terms( $item, $item->post_type . '_type' ) );
+        $filtered[subtypes] = make_taxonomy_endpoint_for( get_the_terms( $item, $item->post_type . '_type' ) );
     }
 
     // Custom fields endpoint
+    if($item->post_type === 'episode') $filtered[credits] = get_post_meta( $item->ID, 'credits', true );
+
     if($item->post_type === 'artist') $filtered[sortname] = get_post_meta( $item->ID, 'artist-sort-name', true );
 
     if($item->post_type === 'event') {

plugins/cia-endpoints/includes/related-items.php

 include(formats.php);
 
 function grab_ids_related_to_and_from($id_to_remove, $p2p_res) {
-    $related_to_ids = array_map(function($post) { 
+    $related_to_ids = array_map(function($post) {
         return (int)$post->p2p_to;
     }, $p2p_res);
-    $related_from_ids = array_map(function($post) { 
+    $related_from_ids = array_map(function($post) {
         return (int)$post->p2p_from;
     }, $p2p_res);
 
 function prepare_related_items($args) {
     // Rearrange what fields get shown
     $collection = array();
-    forEach( get_posts($args) as $item ) $collection[$item->ID] = default_post_format($item);
+    forEach( get_posts($args) as $item ) {
+        $collection[$item->ID] = default_post_format($item, true);
+    }
     return $collection;
 }
 
         OR p2p_to = %d",
         $id, $id
     ));
-    
+
     $related_posts_ids = grab_ids_related_to_and_from($id, $res);
 
     // Use IDs to get posts from the wpdb
         'include' => $related_posts_ids
     );
     wp_reset_postdata();
+
     return prepare_related_items($args);
 }
 

vue-theme/src/components/sidebars/sidebar.vue

 <template lang="pug">
 aside.sidebar
     section
-        .shadow(v-if="type === 'artists'")
+        .shadow(v-if="type === 'artists' && layout !== 'single'")
             h1.t-up sort {{ type }} by
             ul
                 li(v-for="option in sortOptions")
     props: {
         type: {
             type: String
+        },
+        layout: {
+            type: String
         }
     },
     data() {

vue-theme/src/pages/single.vue

             h1 {{ type }}:{{ $route.params.slug }} {{ post.title }}
             p(v-if="post.categories") categories: {{ post.categories }}
             p(v-if="post.type") type: {{ post.type }}
+            p(v-if="post.subtypes") subtypes: {{ post.subtypes }}
 
             .date-info(v-if="type === 'events' || post.type === 'exhibitions'")
                 p start: {{ dateFrom(post.start) }}
 
         credits(v-if="type === 'episodes'" :post="post")
 
-    sidebar(v-if="sidebar" :type="`${type}`")
-        .shadow
-            h1.t-up single slot
-            div
-                p body whatever
+    sidebar(v-if="sidebar" :type="`${type}`" layout="single")
+        .shadow(v-if="Object.keys(p2pPostsByType).length" v-for="p2pPostType in Object.keys(p2pPostsByType)")
+            h3.t-up related {{ p2pPostType }}s
+            ul
+                li(v-for="relatedPost in p2pPostsByType[p2pPostType]")
+                    router-link(v-if="relatedPost" :to="`/${relatedPost.type}s/${relatedPost.slug}`")
+                        p {{ relatedPost.title }}
 </template>
 
 <script>
         },
         activeImageIndex() {
             return Object.keys(this.imagesInGallery).indexOf(this.activeImageID.toString())
+        },
+        p2pPostsByType() {
+            return this.post ? Object.values(this.post.relatedto).reduce((byType, relatedPost) => {
+                if(!byType[relatedPost.type]) byType[relatedPost.type] = []
+                byType[relatedPost.type].push(relatedPost)
+                return byType
+            }, {}) : {}
         }
     },
     methods: {
         dateFrom(unix) {
             return new Date( parseInt(unix) * 1000 )
         },
+
+        async loadPostData() {
+            /**
+             * Conditionally load based on post type
+             * which is derived from the route
+             * !: posts watcher fires when this finishes
+             */
+            let type = convertTitleCase(this.type)
+            let allPostsOfType = this.$store.state[this.type].all
+
+            /**
+             * Load posts if they're not already in state
+             */
+            if(!this[`all${type}Loaded`] && allPostsOfType.length < 1) {
+                const res = await this.$store.dispatch(`getAll${type}`)
+                allPostsOfType = res
+                console.log(`reloaded ${type}...`)
+            }
+            const singlePostData = Object.values(allPostsOfType).filter(post => post.slug == this.$route.params.slug)[0]
+
+            if(!singlePostData) return
+            await this.$store.dispatch(`getSingle${dePluralize(type)}`, singlePostData.id)
+        }
     },
     watch: {
         post(newVal, oldVal) {
             this.checkAndSetHero(newVal)
+        },
+        $route(newVal, oldVal) {
+            console.log('route changed...')
+            this.loadPostData()
         }
     },
     async created() {
-        /**
-         * Conditionally load based on post type
-         * which is derived from the route
-         * !: posts watcher fires when this finishes
-         */
-        let type = convertTitleCase(this.type)
-        let allPostsOfType = this.$store.state[this.type].all
-
-        /**
-         * Load posts if they're not already in state
-         */
-        if(!this[`all${type}Loaded`] && allPostsOfType.length < 1) {
-            const res = await this.$store.dispatch(`getAll${type}`)
-            allPostsOfType = res
-            console.log(`reloaded ${type}...`)
-        }
-        const singlePostData = Object.values(allPostsOfType).filter(post => post.slug == this.$route.params.slug)[0]
-
-        await this.$store.dispatch(`getSingle${dePluralize(type)}`, singlePostData.id)
+        this.loadPostData()
     }
 }
 </script>