Yoast_GA_Dashboards_Collector

Dashboards collector.

Defined (1)

The class is defined in the following location(s).

/admin/dashboards/class-admin-dashboards-collector.php  
  1. class Yoast_GA_Dashboards_Collector { 
  2.  
  3.     /** 
  4.      * @var boolean $api API storage 
  5.      */ 
  6.     public $api; 
  7.  
  8.     /** 
  9.      * @var array $active_metrics Store the active metrics 
  10.      */ 
  11.     public $active_metrics; 
  12.  
  13.     /** 
  14.      * Store the dimensions 
  15.      * 
  16.      * @var array 
  17.      */ 
  18.     private $dimensions = array(); 
  19.  
  20.     /** 
  21.      * Store the valid metrics, which should be 
  22.      * 
  23.      * @var array 
  24.      */ 
  25.     private $valid_metrics = array(); 
  26.  
  27.     /** 
  28.      * @var integer $ga_profile_id Store the GA Profile ID 
  29.      */ 
  30.     public $ga_profile_id; 
  31.  
  32.     /** 
  33.      * Construct on the dashboards class for GA 
  34.      * 
  35.      * @param int   $ga_profile_id 
  36.      * @param array $active_metrics 
  37.      * @param array $valid_metrics 
  38.      */ 
  39.     public function __construct( $ga_profile_id, $active_metrics, $valid_metrics ) { 
  40.         $this->ga_profile_id = $ga_profile_id; 
  41.  
  42.         $active_metrics = $this->filter_metrics_to_dimensions( $active_metrics ); 
  43.         $this->active_metrics = $active_metrics; 
  44.  
  45.         add_filter( 'ga_dashboards_dimensions', array( $this, 'filter_dimensions' ), 10, 1 ); 
  46.  
  47.         $this->options = Yoast_GA_Dashboards_Api_Options::get_instance(); 
  48.  
  49.         $this->init_shutdown_hook(); 
  50.     } 
  51.  
  52.     /** 
  53.      * Fetch the data from Google Analytics and store it 
  54.      */ 
  55.     public function aggregate_data() { 
  56.         if ( is_numeric( $this->ga_profile_id ) ) { 
  57.             // ProfileID is set 
  58.  
  59.             /** 
  60.              * Implement the metric data first 
  61.              */ 
  62.             if ( is_array( $this->active_metrics ) && count( $this->active_metrics ) >= 1 ) { 
  63.                 $this->aggregate_metrics( $this->active_metrics ); 
  64.             } 
  65.  
  66.             /** 
  67.              * Now implement the dimensions that are set 
  68.              */ 
  69.             if ( is_array( $this->dimensions ) && count( $this->dimensions ) >= 1 ) { 
  70.                 $this->aggregate_dimensions( $this->dimensions ); 
  71.             } 
  72.         } 
  73.         else { 
  74.             // Failure on authenticating, please reauthenticate 
  75.         } 
  76.     } 
  77.  
  78.     /** 
  79.      * This hook runs on the shutdown to fetch data from GA 
  80.      */ 
  81.     private function init_shutdown_hook() { 
  82.         $this->api = Yoast_Api_Libs::load_api_libraries( array( 'oauth', 'googleanalytics' ) ); 
  83.  
  84.         // Hook the WP cron event 
  85.         add_action( 'wp', array( $this, 'setup_wp_cron_aggregate' ) ); 
  86.  
  87.         // Hook our function to the WP cron event the fetch data daily 
  88.         add_action( 'yst_ga_aggregate_data', array( $this, 'aggregate_data' ) ); 
  89.  
  90.         // Check if the WP cron did run on time 
  91.         if ( isset( $_GET['page'] ) && ( $_GET['page'] === 'yst_ga_dashboard' || $_GET['page'] === 'yst_ga_settings' ) ) { 
  92.             add_action( 'shutdown', array( $this, 'check_api_call_hook' ) ); 
  93.         } 
  94.     } 
  95.  
  96.     /** 
  97.      * Check if we scheduled the WP cron event, if not, do so. 
  98.      */ 
  99.     public function setup_wp_cron_aggregate() { 
  100.         if ( ! wp_next_scheduled( 'yst_ga_aggregate_data' ) ) { 
  101.             // Set the next event of fetching data 
  102.             wp_schedule_event( strtotime( date( 'Y-m-d', strtotime( 'tomorrow' ) ) . ' 00:05:00 ' ), 'daily', 'yst_ga_aggregate_data' ); 
  103.         } 
  104.     } 
  105.  
  106.     /** 
  107.      * Check if the WP cron did run yesterday. If not, we need to run it form here 
  108.      */ 
  109.     public function check_api_call_hook() { 
  110.         $last_run = $this->get_last_aggregate_run(); 
  111.  
  112.  
  113.         /** 
  114.          * Transient doesn't exists, so we need to run the 
  115.          * hook (This function runs already on Shutdown so 
  116.          * we can call it directly from now on) or the last run has ben more than 24 hours 
  117.          */ 
  118.         if ( $last_run === false || Yoast_GA_Utils::hours_between( strtotime( $last_run ), time() ) >= 24 ) { 
  119.             $this->aggregate_data(); 
  120.         } 
  121.     } 
  122.  
  123.  
  124.     /** 
  125.      * Get the datetime when the aggregate data function was succesful 
  126.      * 
  127.      * @return mixed 
  128.      */ 
  129.     private function get_last_aggregate_run() { 
  130.         return get_option( 'yst_ga_last_wp_run' ); 
  131.     } 
  132.  
  133.     /** 
  134.      * Remove metrics and set them as a dimension if needed 
  135.      * 
  136.      * @param array $metrics 
  137.      * 
  138.      * @return mixed 
  139.      */ 
  140.     private function filter_metrics_to_dimensions( $metrics ) { 
  141.         $filter_metrics = $this->get_filter_metrics(); 
  142.  
  143.         foreach ( $metrics as $key => $metric_name ) { 
  144.             if ( isset( $filter_metrics[ $metric_name ] ) ) { 
  145.                 // Add and set the dimension 
  146.                 $dimension = array( $filter_metrics[ $metric_name ] ); 
  147.                 $this->dimensions = array_merge( $this->dimensions, $dimension ); 
  148.  
  149.                 // Remove it from the metrics after we've added it into dimensions 
  150.                 unset( $metrics[ $key ] ); 
  151.             } 
  152.         } 
  153.  
  154.         return $metrics; 
  155.     } 
  156.  
  157.     /** 
  158.      * Get array with metrics which we need to filter as a dimension 
  159.      * 
  160.      * @return array 
  161.      */ 
  162.     private function get_filter_metrics() { 
  163.         return array( 
  164.             'source' => array( 
  165.                 'metric' => 'sessions',  
  166.                 'dimension' => 'source',  
  167.                 'storage_name' => 'source',  
  168.  ),  
  169.             'top_pageviews' => array( 
  170.                 'metric' => 'pageViews',  
  171.                 'dimension' => 'pagePath',  
  172.                 'storage_name' => 'top_pageviews',  
  173.  ),  
  174.             'top_countries' => array( 
  175.                 'metric' => 'sessions',  
  176.                 'dimension' => 'country',  
  177.                 'storage_name' => 'top_countries',  
  178.  ),  
  179.  ); 
  180.     } 
  181.  
  182.     /** 
  183.      * Filter function for adding dimensions 
  184.      * 
  185.      * @filter ga_dashboards_dimensions 
  186.      * 
  187.      * @param array $dimensions 
  188.      * 
  189.      * @return array 
  190.      */ 
  191.     public function filter_dimensions( $dimensions = array() ) { 
  192.         if ( is_array( $dimensions ) && count( $dimensions ) >= 1 ) { 
  193.             $dimensions = array_merge( $this->dimensions, $dimensions ); 
  194.             $this->dimensions = $dimensions; 
  195.         } 
  196.  
  197.         return $this->dimensions; 
  198.     } 
  199.  
  200.     /** 
  201.      * Get the start and and date for aggregation functionality 
  202.      * 
  203.      * @return array 
  204.      */ 
  205.     private function get_date_range() { 
  206.         /** 
  207.          * Filter: 'yst-ga-filter-api-end-date' - Allow people to change the end date for the dashboard 
  208.          * data. Default: yesterday. 
  209.          * 
  210.          * @api string Date (Y-m-d) 
  211.          */ 
  212.         return array( 
  213.             'start' => date( 'Y-m-d', strtotime( '-1 month' ) ),  
  214.             'end' => apply_filters( 'yst-ga-filter-api-end-date', date( 'Y-m-d', strtotime( 'yesterday' ) ) ),  
  215.  ); 
  216.     } 
  217.  
  218.     /** 
  219.      * Aggregate metrics from GA. This function should be called in the shutdown function. 
  220.      * 
  221.      * @param array $metrics 
  222.      */ 
  223.     private function aggregate_metrics( $metrics ) { 
  224.         $dates = $this->get_date_range(); 
  225.  
  226.         foreach ( $metrics as $metric ) { 
  227.             $this->execute_call( $metric, $dates['start'], $dates['end'] ); 
  228.         } 
  229.     } 
  230.  
  231.     /** 
  232.      * Aggregate dimensions from GA. This function should be called in the shutdown function. 
  233.      * 
  234.      * @param array $dimensions 
  235.      */ 
  236.     private function aggregate_dimensions( $dimensions ) { 
  237.         $dates = $this->get_date_range(); 
  238.  
  239.         foreach ( $dimensions as $dimension ) { 
  240.             if ( isset( $dimension['metric'] ) ) { 
  241.                 if ( isset( $dimension['id'] ) ) { 
  242.                     $this->execute_call( $dimension['metric'], $dates['start'], $dates['end'], 'ga:dimension' . $dimension['id'] ); 
  243.                 } 
  244.                 elseif ( isset( $dimension['dimension'] ) ) { 
  245.                     if ( isset( $dimension['storage_name'] ) ) { 
  246.                         $this->execute_call( $dimension['metric'], $dates['start'], $dates['end'], 'ga:' . $dimension['dimension'], $dimension['storage_name'] ); 
  247.                     } 
  248.                     else { 
  249.                         $this->execute_call( $dimension['metric'], $dates['start'], $dates['end'], 'ga:' . $dimension['dimension'] ); 
  250.                     } 
  251.                 } 
  252.             } 
  253.         } 
  254.     } 
  255.  
  256.     /** 
  257.      * Execute an API call to Google Analytics and store the data in the dashboards data class 
  258.      * 
  259.      * @param string $metric 
  260.      * @param string $start_date   2014-10-16 
  261.      * @param string $end_date     2014-11-20 
  262.      * @param string $dimensions   ga:date 
  263.      * @param string $storage_name auto 
  264.      * 
  265.      * @return bool 
  266.      */ 
  267.     private function execute_call( $metric, $start_date, $end_date, $dimensions = 'ga:date', $storage_name = 'auto' ) { 
  268.         $dimensions = $this->prepare_dimensions( $dimensions, $metric ); 
  269.         $params = $this->build_params_for_call( $start_date, $end_date, $dimensions, $metric ); 
  270.         $storage_type = $this->get_storage_type( $dimensions ); 
  271.  
  272.         $response = Yoast_Google_Analytics::get_instance()->do_request( 'https://www.googleapis.com/analytics/v3/data/ga?' . $params ); 
  273.  
  274.         if ( isset( $response['response']['code'] ) && $response['response']['code'] == 200 ) { 
  275.  
  276.             // Delete option api_fail because there it's successful now 
  277.             delete_option( 'yst_ga_api_call_fail' ); 
  278.  
  279.             // Success, set a transient which stores the latest runtime 
  280.             update_option( 'yst_ga_last_wp_run', date( 'Y-m-d' ) ); 
  281.  
  282.             $response = Yoast_Googleanalytics_Reporting::get_instance()->parse_response( $response, $storage_type, $start_date, $end_date ); 
  283.         } 
  284.         else { 
  285.             // When response is failing, we should count the number of 
  286.             $this->save_api_failure(); 
  287.  
  288.             return false; 
  289.         } 
  290.  
  291.         if ( strpos( 'ga:date', $dimensions ) !== false ) { 
  292.             return $this->handle_response( $response, $metric, $dimensions, $start_date, $end_date, 'datelist', $storage_name ); 
  293.         } 
  294.         else { 
  295.             return $this->handle_response( $response, $metric, $dimensions, $start_date, $end_date, 'table', $storage_name ); 
  296.         } 
  297.     } 
  298.  
  299.     /** 
  300.      * When the API isn't able to get a successful response (code 200), we have to save that the call has failed 
  301.      */ 
  302.     private function save_api_failure() { 
  303.         update_option( 'yst_ga_api_call_fail', true ); 
  304.     } 
  305.  
  306.     /** 
  307.      * Get the storage type from dimensions 
  308.      * 
  309.      * @param string $dimensions 
  310.      * 
  311.      * @return string 
  312.      */ 
  313.     private function get_storage_type( $dimensions ) { 
  314.         if ( strpos( 'ga:date', $dimensions ) !== false ) { 
  315.             return 'datelist'; 
  316.         } 
  317.         else { 
  318.             return 'table'; 
  319.         } 
  320.     } 
  321.  
  322.     /** 
  323.      * Prepare dimensions before adding them as a parameter in a call 
  324.      * 
  325.      * @param array $dimensions 
  326.      * @param array $metric 
  327.      * 
  328.      * @return array 
  329.      */ 
  330.     private function prepare_dimensions( $dimensions, $metric ) { 
  331.         $filter_metrics = $this->get_filter_metrics(); 
  332.  
  333.         // Check if the dimensions param is an array, if so, glue it with implode to a comma separated string. 
  334.         if ( is_array( $dimensions ) ) { 
  335.             $dimensions = implode( ', ', $dimensions ); 
  336.         } 
  337.  
  338.         if ( in_array( $metric, $this->valid_metrics ) ) { 
  339.             $dimensions = 'ga:date, ' . $dimensions; 
  340.         } 
  341.         elseif ( isset( $filter_metrics[ str_replace( 'ga:', '', $dimensions ) ] ) ) { 
  342.             // Make sure we don't have a ga:date property here 
  343.             $dimensions = str_replace( 'ga:date', '', $dimensions ); 
  344.         } 
  345.  
  346.         return $dimensions; 
  347.     } 
  348.  
  349.     /** 
  350.      * Build the params for a call to Google Analytics, return them prepared for a http query 
  351.      * 
  352.      * @param string $start_date 
  353.      * @param string $end_date 
  354.      * @param string $dimensions 
  355.      * @param string $metric 
  356.      * 
  357.      * @return string 
  358.      */ 
  359.     private function build_params_for_call( $start_date, $end_date, $dimensions, $metric ) { 
  360.         /** 
  361.          * Filter: 'yst-ga-filter-api-limit' - Allow people to change the max results value in the API 
  362.          * calls. Default value is 1000 results per call. 
  363.          * 
  364.          * @api int 1000 
  365.          */ 
  366.         $api_call_limit = apply_filters( 'yst-ga-filter-api-limit', 1000 ); 
  367.  
  368.         $params = array( 
  369.             'ids' => 'ga:' . $this->ga_profile_id,  
  370.             'start-date' => $start_date,  
  371.             'end-date' => $end_date,  
  372.             'dimensions' => $dimensions,  
  373.             'metrics' => 'ga:' . $metric,  
  374.             'max-results' => $api_call_limit,  
  375.  ); 
  376.  
  377.         $params = $this->add_sort_direction( $params, $dimensions, $metric ); 
  378.         $params = http_build_query( $params ); 
  379.  
  380.         return $params; 
  381.     } 
  382.  
  383.     /** 
  384.      * Add a sort direction if we need to (Especially on dimensions which are 
  385.      * listed in $this->get_filter_metrics()) 
  386.      * 
  387.      * @param array  $params 
  388.      * @param string $dimensions 
  389.      * @param string $metric 
  390.      * 
  391.      * @return array 
  392.      */ 
  393.     private function add_sort_direction( $params, $dimensions, $metric ) { 
  394.         $filter_dimensions = $this->get_filter_metrics(); 
  395.  
  396.         foreach ( $filter_dimensions as $dimension ) { 
  397.             if ( str_replace( 'ga:', '', $dimensions ) == $dimension['dimension'] && str_replace( 'ga:', '', $metric ) == $dimension['metric'] ) { 
  398.                 $params['sort'] = '-ga:' . $dimension['metric']; 
  399.             } 
  400.         } 
  401.  
  402.         return $params; 
  403.     } 
  404.  
  405.     /** 
  406.      * Handle the response from the Google Analytics api. 
  407.      * 
  408.      * @param array|boolean $response 
  409.      * @param string        $metric 
  410.      * @param array         $dimensions 
  411.      * @param string        $start_date 
  412.      * @param string        $end_date 
  413.      * @param string        $store_as 
  414.      * @param string        $storage_name 
  415.      * 
  416.      * @return bool 
  417.      */ 
  418.     private function handle_response( $response, $metric, $dimensions, $start_date, $end_date, $store_as = 'table', $storage_name = 'auto' ) { 
  419.         if ( is_array( $response ) ) { 
  420.             // Success, store this data 
  421.             $filter_metrics = $this->get_filter_metrics(); 
  422.             $extracted = str_replace( 'ga:', '', str_replace( 'ga:date, ', '', $dimensions ) ); 
  423.  
  424.             if ( isset( $filter_metrics[ $extracted ] ) ) { 
  425.                 $name = $extracted; 
  426.             } 
  427.             else { 
  428.                 $name = $metric; 
  429.             } 
  430.  
  431.             if ( $dimensions !== 'ga:date' && ! isset( $filter_metrics[ $extracted ] ) ) { 
  432.                 $name = str_replace( 'ga:date, ', '', $dimensions ); 
  433.             } 
  434.  
  435.             // Overwrite the name if we have a defined one 
  436.             if ( $storage_name != 'auto' ) { 
  437.                 $name = $storage_name; 
  438.             } 
  439.  
  440.             return Yoast_GA_Dashboards_Data::set( $name, $response, strtotime( $start_date ), strtotime( $end_date ), $store_as ); 
  441.         } 
  442.         else { 
  443.             // Failure on API call try to log it 
  444.             $this->log_error( print_r( $response, true ) ); 
  445.  
  446.             return false; 
  447.         } 
  448.     } 
  449.  
  450.     /** 
  451.      * Log an error while calling the Google Analytics API 
  452.      * 
  453.      * @param string $error 
  454.      */ 
  455.     private function log_error( $error ) { 
  456.         if ( true == WP_DEBUG ) { 
  457.             if ( function_exists( 'error_log' ) ) { 
  458.                 error_log( 'Google Analytics by Yoast (Dashboard API): ' . $error ); 
  459.             } 
  460.         } 
  461.     } 
  462.  
  463. }