Collect API calls from multiple instances of a WordPress plugin

Question

I've written a plugin which retrieves product info from the Amazon Product Advertising API via shortcode. When I retrieve the results from Amazon, I'm storing each individual product in a transient so that I don't need to make that particular call again. On most pages of my site which use this shortcode, it's only for a single product. But but in the case of one particular page I’m getting a TooManyRequests response because I'm using the shortcode 20 or 30 times.

The Amazon API allows me to pass in multiple products at a time, but I’m not sure how I could do that given I’m using multiple occurrences of a plugin.

Here's an example of how I'm calling the plugin right now.

[mm-productlinking id="1" template="image"]

Is there any way to collect multiple shortcode uses before execution, then call all of them at the same time? Perhaps something like this?

[mm-productlinking-group]
    some html code here
    [mm-productlinking id="1" template="image"]
    more html code here
    [mm-productlinking id="2" template="image"]
    and even more html code
[/mm-productlinking-group]

If I did something like this, I'd want it to be optional so that I wasn't forced to include the mm-productlinking-group outer shortcode.

Thoughts?

Answer 1

Thanks to Emiel for the direction, this is what I came up with.

<?php

class Group {

    function __construct() {
        add_shortcode('group', array($this, 'run'));
    }

    function get_attribute_from_child_shortcode($content, $attribute) {
        // returns the post ID from each child shortcode contained in Group
    }

    function get_asins($post_ids) {
        // retrieves Amazon ASIN ID from post meta, for posts referenced in a child shortcode
    }

    function run($attributes = [], $content) {
        // only run when nested shortcodes are found
        if ($content) {
            $post_ids = $this->get_attribute_from_child_shortcode($content, 'id');
            $asins = $this->get_asins($post_ids);
    
            foreach (array_chunk($asins, 10) as $asin_group) {
                $amazon_results = $this->amazon_api->get_items($asin_group);
            }
    
            return do_shortcode($content);
        }
    }
}

class Linking {
    function __construct() {
        add_shortcode('mm-productlinking', array($this, 'run'));
    }

    function run($attributes = []) {
        $data_attributes = array_merge($data_attributes,[
            'product_info' => $this->amazon_api->get_item($game_meta['asin']),
        ]);
        return $data_attributes;
    }
}

It can be called like this

[mm-productlinking-group]
    some html
    [mm-productlinking id="276357"]
    more html
    [mm-productlinking id="276784"]
    even more html
    [mm-productlinking id="279208"]
    html at the end
[/mm-productlinking-group]

In which case I do the following:

• Grab the ID from each shortcode
• Look up the associated Amazon ID associated with that post ID
• Chunk the resulting Amazon IDs into groups of 10
• Call the Amazon API, store the results in a transient

It can also be called like this in which case the group functionality is not used.

[mm-productlinking id="277880"]

I'd love some thoughts on this approach as I've never done it before.

Answer 2

The solution I'm presenting is in many ways similar to @commadelimited's answer, but with a different approach to the structure and responsibilities.

AmazonAdStorage class

I'd create a singleton which can be accessed from anywhere within the code. This class will function as a controller which is repsonsible for getting and storing the Amazon API data. Both the mm-productlinking-group and mm-productlinking shortcodes will use this class to fetch the items and get the items that have been fetched.

<?php

class AmazonAdStorage {
  private static $_instance = null;

  public static function get_instance()
  {
    if (self::$_instance === null) {
      self::$_instance = new self();
    }

    return self::$_instance;
  }

  private $amazon_api = new AmazonAPI(); // Replace this with the actual API

  // Storage for found items
  private $items = [];

  public function get_asins($ids) {
    // retrieves Amazon ASIN ID from post meta.
  }

  public fetch_items($ids)
  {
    $asins = $this->get_asins($ids);
    $results = $this->amazon_api->get_items($asins);
    array_merge($this->items, $results);
  }

  public fetch_item($id)
  {
    $asin = $this->get_asins($id);
    return $this->amazon_api->get_item($asin);
  }

  public get_stored_item($id)
  {
    if (!isset($this->$items[$id])) {
      return null;
    }

    return $this->$items[$id];
  }
}

function get_amazon_ad_storage()
{
  return AmazonAdStorage::get_instance();
}

mm-productlinking-group

The group will have the responsibility of pre-fetching the ids that the children will be using. In contrast to your own solution, this implementation expects that the ids are passed as attributes. It will then fetch the ids and store them in the class.

<?php

add_shortcode('mm-productlinking-group', function ($atts, $content = null) {
  $atts = shortcode_atts([
    'ids' => '',
  ], $atts);

  $ids = explode(',', $atts['ids']);

  if (count($ids) === 0) {
    return $content;
  }

  $storage = get_amazon_ad_storage();
  $storage->fetch_items($ids);

  return do_shortcode($content);
});

mm-productlinking

The child shortcode will access the same class and check if the id is found within the stored items in the class. If it is, use that result. If not, fetch the item from the API and then render the shortcode. This allows the mm-productlinking shortcode to function independently if needed.

<?php

add_shortcode('mm-productlinking', function ($atts, $content = null) {
  $atts = shortcode_atts([
    'id' => '',
    'template' => 'image'
  ], $atts);

  $id = $atts['id'];

  if ($id === '') {
    return '';
  }

  // Check if the id has been fetched and stored yet.
  $storage = get_amazon_ad_storage();
  $item = $storage->get_item($id);

  // No item has been found, fetch it manually.
  if ($item === null) {
    $item = $storage->fetch_item($id);
  }

  return '<div>' . $item['name'] . '</div>';
});

Implementation

The usage should look like this:

[mm-productlinking-group ids="276357,276784,279208"]
  some html
  [mm-productlinking id="276357"]
  more html
  [mm-productlinking id="276784"]
  even more html
  [mm-productlinking id="279208"]
  html at the end
[/mm-productlinking-group]

Sidenote

I haven't been able to test the above and expect it needs some modification for it to work properly, like an actual implementation of the Amazon API.