:recycle: adding alts in the image parser

plugins/cia-endpoints/cia-end-points.php

 if ( ! defined( 'WPINC' ) ) { die; }
 
 require_once('includes/all-types.php');
+require_once('includes/class.make-oneofeach.php');
 require_once('includes/class.make-endpoint.php');
 require_once('includes/class.make-terms.php');
 require_once('includes/class.make-sticky.php');
     $sticky_controller = new Make_Sticky_Endpoint();
     $sticky_controller->register_custom_route('sticky');
     
+    /**
+     * OneEach endpoint
+     */
+    $oneeach_controller = new Make_One_Each_Endpoint();
+    $oneeach_controller->register_custom_route('oneofeach');
+    
     /**
      * Terms endpoint
      */

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

+<?php
+// include('formats.php');
+
+class Make_One_Each_Endpoint extends WP_REST_Controller {
+    /**
+     * Register the routes for the objects of the controller.
+     */
+    public function register_custom_route($route) {
+        $version = '2';
+        $namespace = 'craft/v' . $version;
+
+        register_rest_route( $namespace, '/' . $route, [
+            array(
+                'methods'  => WP_REST_Server::READABLE,
+                'callback' => array( $this, 'get_all_items' )
+            ),
+        ]);
+    }
+    public function get_all_items( $request ) {
+        $args = array(
+            'numberposts' => 1,
+        );
+
+        return new WP_REST_Response( $this->prepare_all_items_for_response($args), 200 );
+    }
+    public function prepare_all_items_for_response( $args ) {
+        $collection = array();
+        $types = [
+            'artist',
+            'episode',
+            'event',
+            'exhibition',
+            'guide',
+            'object',
+            'publication',
+            'technique',
+            'short',
+            'post',
+        ];
+
+        $q = [];
+        foreach($types as $post_type) {
+            array_push($q, new WP_Query(array(
+                'numberposts' => 1,
+                'post_type' => $post_type,
+                'post_status' => ['publish'],
+            )));
+            array_push($q, $post_type);
+            
+            $found_post = $q[0]->get_posts();
+
+            $formatted = default_post_format( $found_post, false );
+            $formatted['tried'] = $q[1];
+            array_push($collection, $formatted);
+        }
+        wp_reset_postdata();
+
+        return $collection;
+        // return $types;
+    }
+}
+
+?>

plugins/cia-endpoints/includes/reformat-blocks.php

         $parsed_blocks = array();
         foreach ($blocks as $block) {
             if($block[blockName] === "core/gallery") {
+                // Fix for new style gallery blocks
                 if(count($block[attrs][ids]) < 1) {
                     $gallery_imgs_ids = [];
                     foreach($block[innerBlocks] as $inner) {
                         $inner_id = $inner[attrs][id];
                         array_push($gallery_imgs_ids, $inner_id);
                     }
-                    $block[attrs]['zzz'] = $gallery_imgs_ids;
                     $block[attrs][ids] = $gallery_imgs_ids;
                 } 
                 array_push($parsed_blocks, $block[attrs]);
 
         foreach ($images as $image) {
             if($image->getAttribute('data-id')) {
-                $parse_images[$image->getAttribute('data-id')] = $image->getAttribute('src');
+                $id = $image->getAttribute('data-id');
             } else {
                 $class_pieces = explode("-", $image->getAttribute('class'));
-                $parse_images[end($class_pieces)] = $image->getAttribute('src');
+                $id = end($class_pieces);
             }
+            // Format for lightbox wants an object
+            $parse_images[$id] = [
+                'src' => $image->getAttribute('src'),
+                'title' => $image->getAttribute('alt'),
+            ];
         }
         return $parse_images;
     }

vue-theme/src/pages/index.vue

             // Limit the amount of posts because we
             // only need the most recent
             const params = { limit: 1 }
-            
+
             // We try and fetch EVERYTHING except
             // for EVENTS and EXHIBITIONS
             if (['event', 'exhibition'].includes(type)) {
                 // Only grab the current or upcoming on load
-                const eventsOrExhibitions = await this.$store.dispatch(
-                    action,
-                    { 
-                        sortType: sortTypes.currentAndUpcoming,
-                        params
-                    }
-                )
+                const eventsOrExhibitions = await this.$store.dispatch(action, {
+                    sortType: sortTypes.currentAndUpcoming,
+                    params,
+                })
                 // If no current or upcoming, get past events
                 // to fill in the blanks
                 if (eventsOrExhibitions.length < 1) {
-                    this.$store.dispatch(action, { sortType: sortTypes.past, params })
+                    this.$store.dispatch(action, {
+                        sortType: sortTypes.past,
+                        params,
+                    })
                 }
-            }
-            else if (!omit.includes(type)){
+            } else if (!omit.includes(type)) {
                 this.$store.dispatch(action, { sortType: null, params })
             }
         }
         if (!this['allPagesLoaded']) {
-            await this.$store.dispatch('getAllPages', { sortType: null, params: null })
+            await this.$store.dispatch('getAllPages', {
+                sortType: null,
+                params: null,
+            })
         }
         await this.checkAndSetHero('welcome')
-        await this.$store.dispatch('getRandomPosts', ['artist', 'guide', 'object', 'technique', 'publication', 'post'])
+        await this.$store.dispatch('getRandomPosts', [
+            'artist',
+            'guide',
+            'object',
+            'technique',
+            'publication',
+            'post',
+        ])
     },
     methods: {
         firstPostOfType(type) {
             // We always set a hero no matter what
             // Because the hero component will deal
             // with how to render based on hero.url
-            if(!this.allPages) return console.warn('no pages in state', this)
-            const page = this.allPages.filter(
-                page => page.slug == type,
-            )[0]
-            if(!page) return console.warn(`no page for ${type} found`)
+            if (!this.allPages) return console.warn('no pages in state', this)
+            const page = this.allPages.filter(page => page.slug == type)[0]
+            if (!page) return console.warn(`no page for ${type} found`)
 
             this.$store.commit('SET_HERO', this._setHeroInfo(page))
         },

vue-theme/src/pages/single.vue

             }
         },
         async singlePost(post) {
-            console.log('---')
             if (!this.$el) return
             const section = this.$el.children[0].querySelector('section')
             await nextTick()
                         const activeGallery =
                             post.galleries[this.activeGalleryIndex]
 
-                        console.log(post.galleries)
-                        console.log(activeGallery)
-
                         if (!activeGallery.ids) return
 
                         this.activeImageIndex = activeGallery.ids.indexOf(
                             parseInt(e.target.dataset.id),
                         )
-                        console.log(
-                            `opening gallery: ${this.activeGalleryIndex}.${this.activeImageIndex}`,
-                        )
-                        console.log(e.target.dataset)
                     })
                 })
             })

vue-theme/src/utils/api.js

                 cb(e)
             })
     },
+    async getOneOfEach(types, cb, random = false) {
+        let posts = []
+        let get = `oneofeach?types=${types.split(',')}`
+        if (random) {
+            get = get + '&orderby=rand'
+        }
+        await axios.get(SETTINGS.API_BASE_PATH + get).then(response => {
+            posts = [...response.data]
+        })
+        cb(posts)
+    },
     async getRandom(types, cb) {
         let randomPosts = []
         for (let type of types) {