You are here

Home » API reference » Share Buttons, Related Posts, Content Analytics - Shareaholic 8 » utilities.php

class ShareaholicUtilities in Share Buttons, Related Posts, Content Analytics - Shareaholic 8

Same name and namespace in other branches
  1. 7.3 utilities.php \ShareaholicUtilities

Hierarchy

Expanded class hierarchy of ShareaholicUtilities

File

./utilities.php, line 11

View source 
class ShareaholicUtilities {
  const MODULE_VERSION = '7.x-3.31';
  const URL = 'https://www.shareaholic.com';
  const API_URL = 'https://web.shareaholic.com';
  const CM_API_URL = 'https://cm-web.shareaholic.com';

  /**
   * Returns whether the user has accepted our terms of service.
   * If the user has accepted, return true otherwise return NULL
   *
   * @return mixed (true or NULL)
   */
  public static function has_accepted_terms_of_service() {
    return variable_get('shareaholic_has_accepted_tos');
  }

  /**
   * Accepts the terms of service by setting the variable to true
   */
  public static function accept_terms_of_service() {
    variable_set('shareaholic_has_accepted_tos', true);
    ShareaholicUtilities::log_event('AcceptedToS');
  }

  /**
   * Returns the defaults for shareaholic settings
   *
   * @return array
   */
  private static function defaults() {
    return array(
      'disable_internal_share_counts_api' => 'on',
      'api_key' => '',
      'verification_key' => '',
    );
  }

  /**
   * Just a wrapper around variable_get to
   * get the shareaholic settings. If the settings
   * have not been set it will return an array of defaults.
   *
   * @return array
   */
  public static function get_settings() {
    return variable_get('shareaholic_settings', self::defaults());
  }

  /**
   * Wrapper for wordpress's get_option: for Drupal
   *
   * @param string $option
   *
   * @return mixed
   */
  public static function get_option($option) {
    $settings = self::get_settings();
    return isset($settings[$option]) ? $settings[$option] : array();
  }

  /**
   * Update multiple keys of the settings object
   * Works like the Wordpress function for Shareaholic
   *
   * @param  array $array an array of options to update
   * @return bool
   */
  public static function update_options($array) {
    $old_settings = self::get_settings();
    $new_settings = self::array_merge_recursive_distinct($old_settings, $array);
    variable_set('shareaholic_settings', $new_settings);
  }

  /**
   * Deletes the settings option
   */
  public static function destroy_settings() {

    // Delete cloud site id
    ShareaholicUtilities::delete_api_key();

    // Delete local Drupal site id
    variable_del('shareaholic_settings');
  }

  /**
   * Set the settings option
   */
  public static function set_settings($settings) {
    variable_set('shareaholic_settings', $settings);
  }

  /**
   * Returns the site's url stripped of protocol.
   *
   * @return string
   */
  public static function site_url() {
    return preg_replace('/https?:\\/\\//', '', $GLOBALS['base_url']);
  }

  /**
   * Returns the site's name
   *
   * @return string
   */
  public static function site_name() {
    return variable_get('site_name', $GLOBALS['base_url']);
  }

  /**
   * Returns the site's primary locale / language
   *
   * @return string
   */
  public static function site_language() {
    $language_id_map = array(
      "ar" => 1,
      // Arabic
      "bg" => 2,
      // Bulgarian
      "zh-hans" => 3,
      // Chinese (Simplified)
      "zh-hant" => 4,
      // Chinese (Traditional)
      "hr" => 5,
      // Croatian
      "cs" => 6,
      // Czech
      "da" => 7,
      // Danish
      "nl" => 8,
      // Netherlands
      "en" => 9,
      // English
      "et" => 10,
      // Estonian
      "fi" => 11,
      // Finnish
      "fr" => 12,
      // French
      "de" => 13,
      // German
      "el" => 14,
      // Greek
      "he" => 15,
      // Hebrew
      "hu" => 16,
      // Hungarian
      "id" => 17,
      // Indonesian
      "it" => 18,
      // Italian
      "ja" => 19,
      // Japanese
      "ko" => 20,
      // Korean
      "lv" => 21,
      // Lativan
      "lt" => 22,
      // Lithuanian
      "nn" => 23,
      // Norwegian
      "pl" => 24,
      // Poland
      "pt-pt" => 25,
      // Portuguese
      "ro" => 26,
      // Romanian
      "ru" => 27,
      // Russian
      "sr" => 28,
      // Serbian
      "sk" => 29,
      // Slovak
      "sl" => 30,
      // Slovenian
      "es" => 31,
      // Spanish
      "sv" => 32,
      // Swedish
      "th" => 33,
      // Thai
      "tr" => 34,
      // Turkish
      "uk" => 35,
      // Ukrainian
      "vi" => 36,
    );
    $language = $GLOBALS['language']->language;
    return isset($language_id_map[$language]) ? $language_id_map[$language] : NULL;
  }

  /**
   * Returns the api key or creates a new one.
   *
   * It first checks the database. If the key is not
   * found (or is an empty string or empty array or
   * anything that evaluates to false) then we will
   * attempt to make a new one by POSTing to the
   * anonymous configuration endpoint
   *
   * @return string
   */
  public static function get_or_create_api_key() {
    $api_key = self::get_option('api_key');

    // ensure api key set is atleast 30 characters, if not, retry to set new api key
    if ($api_key && strlen($api_key) > 30) {
      return $api_key;
    }

    // destroy the shareaholic settings except certain flags
    $old_settings = self::get_settings();
    self::destroy_settings();

    // restore any old settings that should be preserved between resets
    if (isset($old_settings['share_counts_connect_check'])) {
      self::update_options(array(
        'share_counts_connect_check' => $old_settings['share_counts_connect_check'],
      ));
    }
    $verification_key = md5(mt_rand());
    $page_types = self::page_types();
    $turned_on_recommendations_locations = self::get_default_rec_on_locations();
    $turned_off_recommendations_locations = self::get_default_rec_off_locations();
    $turned_on_share_buttons_locations = self::get_default_sb_on_locations();
    $turned_off_share_buttons_locations = self::get_default_sb_off_locations();
    $share_buttons_attributes = array_merge($turned_on_share_buttons_locations, $turned_off_share_buttons_locations);
    $recommendations_attributes = array_merge($turned_on_recommendations_locations, $turned_off_recommendations_locations);
    $post_data = array(
      'configuration_publisher' => array(
        'verification_key' => $verification_key,
        'site_name' => self::site_name(),
        'domain' => self::site_url(),
        'platform_id' => '2',
        'language_id' => self::site_language(),
        'shortener' => 'shrlc',
        'recommendations_attributes' => array(
          'locations_attributes' => $recommendations_attributes,
        ),
        'share_buttons_attributes' => array(
          'locations_attributes' => $share_buttons_attributes,
        ),
      ),
    );
    $response = drupal_http_request(self::API_URL . '/publisher_tools/anonymous', array(
      'method' => 'POST',
      'headers' => array(
        'Content-Type' => 'application/json',
      ),
      'data' => json_encode($post_data),
    ));
    if (self::has_bad_response($response, 'FailedToCreateApiKey', true)) {
      return NULL;
    }
    $response = (array) $response;
    $json_response = json_decode($response['data'], true);
    self::update_options(array(
      'version' => self::get_version(),
      'api_key' => $json_response['api_key'],
      'verification_key' => $verification_key,
      'location_name_ids' => $json_response['location_name_ids'],
    ));
    if (isset($json_response['location_name_ids']) && is_array($json_response['location_name_ids']) && isset($json_response['location_name_ids']['recommendations']) && isset($json_response['location_name_ids']['share_buttons'])) {
      self::set_default_location_settings($json_response['location_name_ids']);
      ShareaholicContentManager::single_domain_worker();
    }
    else {
      ShareaholicUtilities::log_event('FailedToCreateApiKey', array(
        'reason' => 'no location name ids the response was: ' . $response['data'],
      ));
    }
  }

  /**
   * Get share buttons locations that should be turned on by default
   *
   * @return {Array}
   */
  public static function get_default_sb_on_locations() {
    $page_types = self::page_types();
    $turned_on_share_buttons_locations = array();
    foreach ($page_types as $key => $page_type) {
      $page_type_name = $page_type->type;
      $turned_on_share_buttons_locations[] = array(
        'name' => $page_type_name . '_below_content',
      );
    }
    return $turned_on_share_buttons_locations;
  }

  /**
   * Get share buttons locations that should be turned off by default
   *
   * @return {Array}
   */
  public static function get_default_sb_off_locations() {
    $page_types = self::page_types();
    $turned_off_share_buttons_locations = array();
    foreach ($page_types as $key => $page_type) {
      $page_type_name = $page_type->type;
      $turned_off_share_buttons_locations[] = array(
        'name' => $page_type_name . '_above_content',
      );
    }
    return $turned_off_share_buttons_locations;
  }

  /**
   * Get recommendations locations that should be turned on by default
   *
   * @return {Array}
   */
  public static function get_default_rec_on_locations() {
    $page_types = self::page_types();
    $turned_on_recommendations_locations = array();
    foreach ($page_types as $key => $page_type) {
      $page_type_name = $page_type->type;
      if ($page_type_name === 'article' || $page_type_name === 'page') {
        $turned_on_recommendations_locations[] = array(
          'name' => $page_type_name . '_below_content',
        );
      }
    }
    return $turned_on_recommendations_locations;
  }

  /**
   * Get recommendations locations that should be turned off by default
   *
   * @return {Array}
   */
  public static function get_default_rec_off_locations() {
    $page_types = self::page_types();
    $turned_off_recommendations_locations = array();
    foreach ($page_types as $key => $page_type) {
      $page_type_name = $page_type->type;
      if ($page_type_name !== 'article' && $page_type_name !== 'page') {
        $turned_off_recommendations_locations[] = array(
          'name' => $page_type_name . '_below_content',
        );
      }
    }
    return $turned_off_recommendations_locations;
  }

  /**
   * Given an object, set the default on/off locations
   * for share buttons and recommendations
   *
   */
  public static function set_default_location_settings($location_name_ids) {
    $turned_on_share_buttons_locations = self::get_default_sb_on_locations();
    $turned_off_share_buttons_locations = self::get_default_sb_off_locations();
    $turned_on_recommendations_locations = self::get_default_rec_on_locations();
    $turned_off_recommendations_locations = self::get_default_rec_off_locations();
    $turned_on_share_buttons_keys = array();
    foreach ($turned_on_share_buttons_locations as $loc) {
      $turned_on_share_buttons_keys[] = $loc['name'];
    }
    $turned_on_recommendations_keys = array();
    foreach ($turned_on_recommendations_locations as $loc) {
      $turned_on_recommendations_keys[] = $loc['name'];
    }
    $turned_off_share_buttons_keys = array();
    foreach ($turned_off_share_buttons_locations as $loc) {
      $turned_off_share_buttons_keys[] = $loc['name'];
    }
    $turned_off_recommendations_keys = array();
    foreach ($turned_off_recommendations_locations as $loc) {
      $turned_off_recommendations_keys[] = $loc['name'];
    }
    $turn_on = array(
      'share_buttons' => self::associative_array_slice($location_name_ids['share_buttons'], $turned_on_share_buttons_keys),
      'recommendations' => self::associative_array_slice($location_name_ids['recommendations'], $turned_on_recommendations_keys),
    );
    $turn_off = array(
      'share_buttons' => self::associative_array_slice($location_name_ids['share_buttons'], $turned_off_share_buttons_keys),
      'recommendations' => self::associative_array_slice($location_name_ids['recommendations'], $turned_off_recommendations_keys),
    );
    ShareaholicUtilities::turn_on_locations($turn_on, $turn_off);
  }

  /**
   * Restore the plugin settings
   *
   */
  public static function reset_settings() {
    $settings = self::get_settings();
    $api_key = self::get_option('api_key');
    $response = drupal_http_request(self::API_URL . '/publisher_tools/' . $api_key . '/reset/', array(
      'method' => 'POST',
      'headers' => array(
        'Content-Type' => 'application/json',
      ),
      'data' => json_encode($settings),
    ));

    // set the location on/off back to their defaults
    if (isset($settings['location_name_ids']) && is_array($settings['location_name_ids'])) {
      self::set_default_location_settings($settings['location_name_ids']);
    }
  }

  /**
   * Deletes the api key
   *
   */
  public static function delete_api_key() {
    $payload = array(
      'site_id' => self::get_option('api_key'),
      'verification_key' => self::get_option('verification_key'),
    );
    $response = drupal_http_request(self::API_URL . '/integrations/plugin/delete', array(
      'method' => 'POST',
      'headers' => array(
        'Content-Type' => 'application/json',
      ),
      'data' => json_encode($payload),
    ));
  }

  /**
   * Checks bad response and logs errors if any
   *
   * @return boolean
   */
  public static function has_bad_response($response, $type, $json_parse = FALSE) {
    if (!$response) {
      ShareaholicUtilities::log_event($type, array(
        'reason' => 'there was no response',
      ));
      return true;
    }
    $response = (array) $response;
    if (isset($response['error'])) {
      $error_message = print_r($response['error'], true);
      ShareaholicUtilities::log_event($type, array(
        'reason' => 'there was an error: ' . $error_message,
      ));
      return true;
    }
    if (!preg_match('/20*/', $response['code'])) {
      ShareaholicUtilities::log_event($type, array(
        'reason' => 'the server responded with code ' . $response['code'],
      ));
      return true;
    }
    if ($json_parse && json_decode($response['data']) === NULL) {
      ShareaholicUtilities::log_event($type, array(
        'reason' => 'could not parse JSON. The response was: ' . $response['data'],
      ));
      return true;
    }
    return false;
  }

  /**
   * Log the errors in the database if debug flag is set to true
   *
   */
  public static function log($message) {
    if (defined('SHAREAHOLIC_DEBUG') && SHAREAHOLIC_DEBUG) {
      watchdog('Shareaholic', print_r($message, true));
    }
  }

  /**
   * Direct copy of the wordpress util function
   * If the two arrays have the same key, the value from array2 overrides
   * the value on array1
   *
   * @param  array $array1
   * @param  array $array2
   * @return array
   */
  public static function array_merge_recursive_distinct(array &$array1, array &$array2) {
    $merged = $array1;
    foreach ($array2 as $key => &$value) {
      if (is_array($value) && isset($merged[$key]) && is_array($merged[$key])) {
        if (empty($value)) {
          $merged[$key] = array();
        }
        else {
          $merged[$key] = self::array_merge_recursive_distinct($merged[$key], $value);
        }
      }
      else {
        $merged[$key] = $value;
      }
    }
    return $merged;
  }

  /**
   * Returns the appropriate asset path for something from our
   * rails app based on environment.
   *
   * @param string $asset
   * @return string
   */
  public static function asset_url($asset) {
    $env = self::get_env();
    if ($env === 'development') {
      return 'http://spreadaholic.com:8080/' . $asset;
    }
    elseif ($env === 'staging') {
      return '//d2062rwknz205x.cloudfront.net/' . $asset;
    }
    else {
      return '//cdn.shareaholic.net/' . $asset;
    }
  }

  /**
   * Returns the appropriate environment based on URL constant
   *
   * @return string
   */
  public static function get_env() {
    if (preg_match('/spreadaholic/', self::URL)) {
      return 'development';
    }
    elseif (preg_match('/stageaholic/', self::URL)) {
      return 'staging';
    }
    else {
      return 'production';
    }
  }

  /**
   * Check if the installation has accepted ToS and we created an apikey
   *
   */
  public static function has_tos_and_apikey() {
    return ShareaholicUtilities::has_accepted_terms_of_service() && ShareaholicUtilities::get_option('api_key');
  }

  /**
   * Gets the current version of this module
   */
  public static function get_version() {
    return self::MODULE_VERSION;
  }

  /**
   * Sets the current version of this module in the database
   */
  public static function set_version($version) {
    self::update_options(array(
      'version' => $version,
    ));
  }

  /**
   * Checks if the current page is an admin page
   * @return mixed: returns 1 if matched, 0 if no match, false if error occurs
   */
  public static function is_admin_page() {
    return path_is_admin(current_path());
  }

  /**
   * Checks if the current page is the settings page
   * @return Boolean (actually 1, 0, or FALSE)
   */
  public static function is_shareaholic_settings_page() {
    return preg_match('/admin\\/config\\/shareaholic\\//', request_uri());
  }

  /**
   * Cleans the string to be HTML safe
   *
   * Given a string, it will:
   * - Encode the string
   * - Trim the string
   * - lower case the string
   *
   * @return String the cleaned string
   */
  public static function clean_string($word) {
    return trim(trim(strtolower(trim(htmlspecialchars(htmlspecialchars_decode($word), ENT_QUOTES))), ","));
  }

  /**
   * Give back only the request keys from an array. The first
   * argument is the array to be sliced, and after that it can
   * either be a variable-length list of keys or one array of keys.
   *
   * @param  array $array
   * @param  Mixed ... can be either one array or many keys
   * @return array
   */
  public static function associative_array_slice($array) {
    $keys = array_slice(func_get_args(), 1);
    if (func_num_args() == 2 && is_array($keys[0])) {
      $keys = $keys[0];
    }
    $result = array();
    foreach ($keys as $key) {
      $result[$key] = $array[$key];
    }
    return $result;
  }

  /**
   * Passed an array of location names mapped to ids per app.
   *
   * @param array $array
   */
  public static function turn_on_locations($array, $turn_off_array = array()) {
    if (is_array($array)) {
      foreach ($array as $app => $ids) {
        if (is_array($ids)) {
          foreach ($ids as $name => $id) {
            self::update_options(array(
              $app => array(
                $name => 'on',
              ),
            ));
          }
        }
      }
    }
    if (is_array($turn_off_array)) {
      foreach ($turn_off_array as $app => $ids) {
        if (is_array($ids)) {
          foreach ($ids as $name => $id) {
            self::update_options(array(
              $app => array(
                $name => 'off',
              ),
            ));
          }
        }
      }
    }
  }

  /**
   * Get all the available page types
   * Insert the teaser mode as a page type
   *
   * @return Array list of page types
   */
  public static function page_types() {
    $page_types = node_type_get_types();
    $teaser = new stdClass();
    $teaser->name = 'Teaser';
    $teaser->type = 'teaser';
    $page_types['shareaholic_custom_type'] = $teaser;
    return $page_types;
  }

  /**
   * Checks whether the api key has been verified
   * using the rails endpoint. Once the key has
   * been verified, we store that away so that we
   * don't have to check again.
   *
   * @return bool
   */
  public static function api_key_verified() {
    $settings = self::get_settings();
    if (isset($settings['api_key_verified']) && $settings['api_key_verified']) {
      return true;
    }
    $api_key = $settings['api_key'];
    if (!$api_key) {
      return false;
    }
    $response = drupal_http_request(self::API_URL . '/publisher_tools/' . $api_key . '/verified', array(
      'method' => 'GET',
    ));
    if (self::has_bad_response($response, 'FailedApiKeyVerified')) {
      return false;
    }
    $response = (array) $response;
    $result = $response['data'];
    if ($result == 'true') {
      ShareaholicUtilities::update_options(array(
        'api_key_verified' => true,
      ));
      return true;
    }
    return false;
  }

  /**
   * Clears Facebook Open Graph cache for provided node
   *
   * @param Object $node
   */
  public static function clear_fb_opengraph($node) {
    if ($node->status !== NODE_PUBLISHED) {
      return;
    }
    $page_link = url('node/' . $node->nid, array(
      'absolute' => TRUE,
    ));
    if (isset($page_link)) {
      $fb_graph_url = "https://graph.facebook.com/?id=" . urlencode($page_link) . "&scrape=true";
      $options = array(
        'method' => 'POST',
        'timeout' => 5,
      );
      $result = drupal_http_request($fb_graph_url, $options);
    }
  }

  /**
   * This is a wrapper for the Event API
   *
   * @param string $event_name    the name of the event
   * @param array  $extra_params  any extra data points to be included
   */
  public static function log_event($event_name = 'Default', $extra_params = false) {
    $event_metadata = array(
      'plugin_version' => self::get_version(),
      'api_key' => self::get_option('api_key'),
      'domain' => $GLOBALS['base_url'],
      'language' => $GLOBALS['language']->language,
      'stats' => self::get_stats(),
      'diagnostics' => array(
        'php_version' => phpversion(),
        'drupal_version' => self::get_drupal_version(),
        'theme' => variable_get('theme_default', $GLOBALS['theme']),
        'active_plugins' => module_list(),
      ),
      'features' => array(
        'share_buttons' => self::get_option('share_buttons'),
        'recommendations' => self::get_option('recommendations'),
      ),
    );
    if ($extra_params) {
      $event_metadata = array_merge($event_metadata, $extra_params);
    }
    $event_api_url = self::API_URL . '/api/events';
    $event_params = array(
      'name' => "Drupal:" . $event_name,
      'data' => json_encode($event_metadata),
    );
    $options = array(
      'method' => 'POST',
      'headers' => array(
        'Content-Type' => 'application/json',
      ),
      'body' => $event_params,
    );
    ShareaholicHttp::send($event_api_url, $options, true);
  }

  /**
   * Get the total number of comments for this site
   *
   * @return integer The total number of comments
   */
  public static function total_comments() {
    if (!db_table_exists('comment')) {
      return array();
    }
    return db_query("SELECT count(cid) FROM {comment}")
      ->fetchField();
  }

  /**
   * Get the stats for this website
   * Stats include: total number of pages by type, total comments, total users
   *
   * @return array an associative array of stats => counts
   */
  public static function get_stats() {
    $stats = array();

    // Query the database for content types and add to stats
    $result = db_query("SELECT type, count(*) as count FROM {node} GROUP BY type");
    foreach ($result as $record) {
      $stats[$record->type . '_total'] = $record->count;
    }

    // Get the total comments
    $stats['comments_total'] = self::total_comments();
    return $stats;
  }

  /**
   * Get the drupal version via VERSION constant if it exists
   */
  public static function get_drupal_version() {
    if (defined('VERSION')) {
      return VERSION;
    }
    return '7';
  }

  /**
   * Server Connectivity check
   *
   */
  public static function connectivity_check() {
    $health_check_url = self::API_URL . "/haproxy_health_check";
    $response = ShareaholicHttp::send($health_check_url, array(
      'method' => 'GET',
    ), true);
    if (is_array($response) && array_key_exists('body', $response)) {
      $response_code = $response['response']['code'];
      if ($response_code == "200") {
        return "SUCCESS";
      }
      else {
        return "FAIL";
      }
    }
    else {
      return "FAIL";
    }
  }

  /**
   * Locate and require a template, and extract some variables
   * to be used in that template.
   *
   * @param string $template  the name of the template
   * @param array  $vars      any variables to be extracted into the template
   */
  public static function load_template($template, $vars = array()) {

    // you cannot let locate_template to load your template
    // because WP devs made sure you can't pass
    // variables to your template :(
    $template_path = SHAREAHOLIC_DIR . '/templates/' . $template . '.php';

    // load it
    extract($vars);
    require $template_path;
  }

  /**
   * Share Counts API Connectivity check
   *
   */
  public static function share_counts_api_connectivity_check() {

    // if we already checked and it is successful, then do not call the API again
    $share_counts_connect_check = self::get_option('share_counts_connect_check');
    if (isset($share_counts_connect_check) && $share_counts_connect_check == 'SUCCESS') {
      return $share_counts_connect_check;
    }
    $services_config = ShareaholicSeqShareCount::get_services_config();
    $services = array_keys($services_config);
    $param_string = implode('&services[]=', $services);
    $share_counts_api_url = url('shareaholic/api/share_counts/v1', array(
      'absolute' => TRUE,
    )) . '?action=shareaholic_share_counts_api&url=https%3A%2F%2Fwww.google.com%2F&services[]=' . $param_string;
    $cache_key = 'share_counts_api_connectivity_check';

    // fetch cached response if it exists or has not expired
    $response = ShareaholicCache::get($cache_key);
    if (!$response) {
      $response = ShareaholicHttp::send($share_counts_api_url, array(
        'method' => 'GET',
      ), true);
    }
    $response_status = self::get_share_counts_api_status($response);

    // if this was the first time we are doing this and it failed, disable
    // the share counts API
    if (empty($share_counts_connect_check) && $response_status == 'FAIL') {
      self::update_options(array(
        'disable_internal_share_counts_api' => 'on',
      ));
    }
    if ($response_status == 'SUCCESS') {
      ShareaholicCache::set($cache_key, $response, SHARE_COUNTS_CHECK_CACHE_LENGTH);
    }
    self::update_options(array(
      'share_counts_connect_check' => $response_status,
    ));
    return $response_status;
  }

  /**
   * Check the share counts API for empty response or missing services
   */
  public static function get_share_counts_api_status($response) {
    if (!$response || !isset($response['body'])) {
      return 'FAIL';
    }
    $response['body'] = json_decode($response['body'], TRUE);
    if (!is_array($response['body'])) {
      return 'FAIL';
    }

    // Did it return at least 6 services?
    $has_majority_services = count(array_keys($response['body']['data'])) >= 5 ? true : false;
    $has_important_services = true;

    // Does it have counts for fb, pinterest?
    foreach (array(
      'facebook',
      'pinterest',
    ) as $service) {
      if (!isset($response['body']['data'][$service]) || !is_numeric($response['body']['data'][$service])) {
        $has_important_services = false;
      }
    }
    if (!$has_majority_services || !$has_important_services) {
      return 'FAIL';
    }
    return 'SUCCESS';
  }

  /**
   * Return host domain of Drupal install
   *
   * @return string
   */
  public static function get_host() {
    $parse = parse_url($GLOBALS['base_url']);
    return $parse['host'];
  }

}

Members

Namesort descending Modifiers Type Description Overrides
ShareaholicUtilities::accept_terms_of_service public static function Accepts the terms of service by setting the variable to true
ShareaholicUtilities::api_key_verified public static function Checks whether the api key has been verified using the rails endpoint. Once the key has been verified, we store that away so that we don't have to check again.
ShareaholicUtilities::API_URL constant
ShareaholicUtilities::array_merge_recursive_distinct public static function Direct copy of the wordpress util function If the two arrays have the same key, the value from array2 overrides the value on array1
ShareaholicUtilities::asset_url public static function Returns the appropriate asset path for something from our rails app based on environment.
ShareaholicUtilities::associative_array_slice public static function Give back only the request keys from an array. The first argument is the array to be sliced, and after that it can either be a variable-length list of keys or one array of keys.
ShareaholicUtilities::clean_string public static function Cleans the string to be HTML safe
ShareaholicUtilities::clear_fb_opengraph public static function Clears Facebook Open Graph cache for provided node
ShareaholicUtilities::CM_API_URL constant
ShareaholicUtilities::connectivity_check public static function Server Connectivity check
ShareaholicUtilities::defaults private static function Returns the defaults for shareaholic settings
ShareaholicUtilities::delete_api_key public static function Deletes the api key
ShareaholicUtilities::destroy_settings public static function Deletes the settings option
ShareaholicUtilities::get_default_rec_off_locations public static function Get recommendations locations that should be turned off by default
ShareaholicUtilities::get_default_rec_on_locations public static function Get recommendations locations that should be turned on by default
ShareaholicUtilities::get_default_sb_off_locations public static function Get share buttons locations that should be turned off by default
ShareaholicUtilities::get_default_sb_on_locations public static function Get share buttons locations that should be turned on by default
ShareaholicUtilities::get_drupal_version public static function Get the drupal version via VERSION constant if it exists
ShareaholicUtilities::get_env public static function Returns the appropriate environment based on URL constant
ShareaholicUtilities::get_host public static function Return host domain of Drupal install
ShareaholicUtilities::get_option public static function Wrapper for wordpress's get_option: for Drupal
ShareaholicUtilities::get_or_create_api_key public static function Returns the api key or creates a new one.
ShareaholicUtilities::get_settings public static function Just a wrapper around variable_get to get the shareaholic settings. If the settings have not been set it will return an array of defaults.
ShareaholicUtilities::get_share_counts_api_status public static function Check the share counts API for empty response or missing services
ShareaholicUtilities::get_stats public static function Get the stats for this website Stats include: total number of pages by type, total comments, total users
ShareaholicUtilities::get_version public static function Gets the current version of this module
ShareaholicUtilities::has_accepted_terms_of_service public static function Returns whether the user has accepted our terms of service. If the user has accepted, return true otherwise return NULL
ShareaholicUtilities::has_bad_response public static function Checks bad response and logs errors if any
ShareaholicUtilities::has_tos_and_apikey public static function Check if the installation has accepted ToS and we created an apikey
ShareaholicUtilities::is_admin_page public static function Checks if the current page is an admin page
ShareaholicUtilities::is_shareaholic_settings_page public static function Checks if the current page is the settings page
ShareaholicUtilities::load_template public static function Locate and require a template, and extract some variables to be used in that template.
ShareaholicUtilities::log public static function Log the errors in the database if debug flag is set to true
ShareaholicUtilities::log_event public static function This is a wrapper for the Event API
ShareaholicUtilities::MODULE_VERSION constant
ShareaholicUtilities::page_types public static function Get all the available page types Insert the teaser mode as a page type
ShareaholicUtilities::reset_settings public static function Restore the plugin settings
ShareaholicUtilities::set_default_location_settings public static function Given an object, set the default on/off locations for share buttons and recommendations
ShareaholicUtilities::set_settings public static function Set the settings option
ShareaholicUtilities::set_version public static function Sets the current version of this module in the database
ShareaholicUtilities::share_counts_api_connectivity_check public static function Share Counts API Connectivity check
ShareaholicUtilities::site_language public static function Returns the site's primary locale / language
ShareaholicUtilities::site_name public static function Returns the site's name
ShareaholicUtilities::site_url public static function Returns the site's url stripped of protocol.
ShareaholicUtilities::total_comments public static function Get the total number of comments for this site
ShareaholicUtilities::turn_on_locations public static function Passed an array of location names mapped to ids per app.
ShareaholicUtilities::update_options public static function Update multiple keys of the settings object Works like the Wordpress function for Shareaholic
ShareaholicUtilities::URL constant