<?php
/**
 * This class allows you to work with the Google Analytics Service in a very
 * confortable manner.
 * 
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 * 
 * Author: Felix Geisendörfer (thinkingphp.org / fg-webdesign.de)
 * 
 * Google Analytics is a trademark of the Google Corporation.
 * 
 */
require_once APP.'web_model.php';

// Available Report Formats (Google Analytics (28-05-2006))
define('GA_FORMAT_TABSEPERATED', '1');
define('GA_FORMAT_CSV', '3');
define('GA_FORMAT_XML', '7');
define('GA_FORMAT_CUSTOM_ARRAY', '23'); // This is a custom format introduced by this class and not part of Google Analytics

// Available Filter Modes
define('GA_FILTER_DONT_MATCH', '1');
define('GA_FILTER_MATCH', '2');

// Sorting Values
define('GA_SORT_DESC', '1');
define('GA_SORT_ASC', '2');

/**
 * Important note about Languages in general: Google does only determine the language
 * to be used by the setting made in "My Account" when beeing logged in. When you change
 * it, the results of this Class change regardless of your language setting made on login.
 * 
 * So it seems like I need to write a method to change the language in the profile. But as
 * long as City and Country names are returned in English (no matter what interface language you
 * use) I'll not bother to write a function to change the interface language.
 *
 */

// Available Languages for Google Analytics (28-05-2006)
define('GA_LANGUAGE_ENGLISH_US', 'en-US');
define('GA_LANGUAGE_ENGLISH_GB', 'en-GB');
define('GA_LANGUAGE_GERMAN', 'de-DE');
define('GA_LANGUAGE_FRENCH', 'fr-FR');
define('GA_LANGUAGE_ITALIAN', 'it-IT');
define('GA_LANGUAGE_SPANISH', 'es-ES');
define('GA_LANGUAGE_DUTCH', 'nl-NL');
define('GA_LANGUAGE_JAPANESE', 'ja-JP');
define('GA_LANGUAGE_PORTUGUESE_BRAZIL', 'pt-BR');
define('GA_LANGUAGE_DANISH', 'da-DK');
define('GA_LANGUAGE_FINISH', 'fi-FI');
define('GA_LANGUAGE_NORWEGIAN', 'no-NO');
define('GA_LANGUAGE_SWEDISH', 'sv-SE');
define('GA_LANGUAGE_CHINESE_1', 'zh-TW');
define('GA_LANGUAGE_CHINESE_2', 'zh-CN');
define('GA_LANGUAGE_KOREAN', 'ko-KR');
define('GA_LANGUAGE_RUSSIAN', 'ru-RU');


// A list of all reports available from Google (28-05-2006)
// Generated using the GoogleAnalytics::__getReportTypes() function
define('GA_REPORT_EXECUTIVE_OVERVIEW', '2001');
define('GA_REPORT_CONVERSION_SUMMARY_1', '2003');
define('GA_REPORT_CONVERSION_SUMMARY_2', '2108');
define('GA_REPORT_MARKETING_SUMMARY_1', '2004');
define('GA_REPORT_MARKETING_SUMMARY_2', '2102');
define('GA_REPORT_CONTENT_SUMMARY_1', '2005');
define('GA_REPORT_CONTENT_SUMMARY_2', '2202');
define('GA_REPORT_SITE_OVERLAY_1', '2007');
define('GA_REPORT_SITE_OVERLAY_2', '2109');
define('GA_REPORT_SITE_OVERLAY_3', '1312');
define('GA_REPORT_SITE_OVERLAY_4', '1351');
define('GA_REPORT_MARKETER_OVERVIEW', '2101');
define('GA_REPORT_CPC_PROGRAM_ANALYSIS_1', '2103');
define('GA_REPORT_CPC_PROGRAM_ANALYSIS_2', '1220');
define('GA_REPORT_CPC_VS_ORGANIC_CONVERSION_1', '2104');
define('GA_REPORT_CPC_VS_ORGANIC_CONVERSION_2', '1222');
define('GA_REPORT_OVERALL_KEYWORD_CONVERSION_1', '2105');
define('GA_REPORT_OVERALL_KEYWORD_CONVERSION_2', '1221');
define('GA_REPORT_KEYWORD_CONSIDERATIONS_1', '2106');
define('GA_REPORT_KEYWORD_CONSIDERATIONS_2', '1223');
define('GA_REPORT_CAMPAIGN_CONVERSION_1', '2107');
define('GA_REPORT_CAMPAIGN_CONVERSION_2', '1213');
define('GA_REPORT_DEFINED_FUNNEL_NAVIGATION_1', '2110');
define('GA_REPORT_DEFINED_FUNNEL_NAVIGATION_2', '2203');
define('GA_REPORT_DEFINED_FUNNEL_NAVIGATION_3', '1318');
define('GA_REPORT_ENTRANCE_BOUNCE_RATES_1', '2111');
define('GA_REPORT_ENTRANCE_BOUNCE_RATES_2', '2204');
define('GA_REPORT_ENTRANCE_BOUNCE_RATES_3', '1310');
define('GA_REPORT_WEBMASTER_OVERVIEW', '2201');
define('GA_REPORT_GOAL_TRACKING_1', '2205');
define('GA_REPORT_GOAL_TRACKING_2', '1315');
define('GA_REPORT_CONTENT_BY_TITLES_1', '2206');
define('GA_REPORT_CONTENT_BY_TITLES_2', '1306');
define('GA_REPORT_BROWSER_VERSIONS_1', '2207');
define('GA_REPORT_BROWSER_VERSIONS_2', '1321');
define('GA_REPORT_PLATFORM_VERSIONS_1', '2208');
define('GA_REPORT_PLATFORM_VERSIONS_2', '1322');
define('GA_REPORT_BROWSER_AND_PLATFORM_COMBOS_1', '2209');
define('GA_REPORT_BROWSER_AND_PLATFORM_COMBOS_2', '1323');
define('GA_REPORT_SCREEN_RESOLUTIONS_1', '2210');
define('GA_REPORT_SCREEN_RESOLUTIONS_2', '1324');
define('GA_REPORT_SCREEN_COLORS_1', '2211');
define('GA_REPORT_SCREEN_COLORS_2', '1325');
define('GA_REPORT_LANGUAGES_1', '2312');
define('GA_REPORT_LANGUAGES_2', '1326');
define('GA_REPORT_JAVA_ENABLED_1', '2213');
define('GA_REPORT_JAVA_ENABLED_2', '1327');
define('GA_REPORT_FLASH_VERSION_1', '2215');
define('GA_REPORT_FLASH_VERSION_2', '1329');
define('GA_REPORT_CONNECTION_SPEED_1', '2216');
define('GA_REPORT_CONNECTION_SPEED_2', '1330');
define('GA_REPORT_HOSTNAMES_1', '2217');
define('GA_REPORT_HOSTNAMES_2', '1331');
define('GA_REPORT_DAILY_VISITORS', '1201');
define('GA_REPORT_VISITS_AND_PAGEVIEW_TRACKING', '1202');
define('GA_REPORT_GOAL_CONVERSION_TRACKING', '1203');
define('GA_REPORT_ABSOLUTE_UNIQUE_VISITORS', '1204');
define('GA_REPORT_VISITOR_LOYALTY', '1205');
define('GA_REPORT_VISITOR_RECENCY', '1206');
define('GA_REPORT_NEW_VS_RETURNING', '1207');
define('GA_REPORT_REFERRING_SOURCE_', '1208');
define('GA_REPORT_GEO_LOCATION', '1209');
define('GA_REPORT_GEO_MAP_OVERLAY', '1227');
define('GA_REPORT_NETWORK_LOCATION', '1210');
define('GA_REPORT_LANGUAGE', '1211');
define('GA_REPORT_USER-DEFINED', '1212');
define('GA_REPORT_DOMAINS', '1231');
define('GA_REPORT_SOURCE_CONVERSION', '1214');
define('GA_REPORT_MEDIUM_CONVERSION', '1215');
define('GA_REPORT_REFERRAL_CONVERSION', '1216');
define('GA_REPORT_CAMPAIGN_ROI', '1217');
define('GA_REPORT_SOURCE_ROI', '1218');
define('GA_REPORT_MEDIUM_ROI', '1219');
define('GA_REPORT_OVERALL_AD_A/B_TESTING', '1301');
define('GA_REPORT_SOURCE_SPECIFIC_TESTING_', '1302');
define('GA_REPORT_KEYWORD_SPECIFIC_TESTING', '1303');
define('GA_REPORT_TOP_CONTENT', '1304');
define('GA_REPORT_CONTENT_DRILLDOWN', '1305');
define('GA_REPORT_DYNAMIC_CONTENT', '1307');
define('GA_REPORT_DEPTH_OF_VISIT', '1308');
define('GA_REPORT_LENGTH_OF_VISIT_', '1309');
define('GA_REPORT_TOP_EXIT_POINTS', '1311');
define('GA_REPORT_INITIAL_NAVIGATION', '1313');
define('GA_REPORT_ALL_NAVIGATION', '1314');
define('GA_REPORT_GOAL_CONVERSION', '1316');
define('GA_REPORT_DEFINED_FUNNEL_ABANDONMENT', '1317');
define('GA_REPORT_REVERSE_GOAL_PATH', '1319');
define('GA_REPORT_GOAL_VERIFICATION', '1320');

// Error messages returned by this Class
define('GA_ERROR_TIMEOUT', '-1');
define('GA_ERROR_ACCESS_DENIED', '-2');

class GoogleAnalytics extends WebModel 
{
    var $name = 'GoogleAnalytics';      // Name of the Model
    var $connection_timeout = '30';     // Time in seconds after a request times out    
    var $tmpFolder = null;              // Path to the tmp folder relative from TMP.'cache'.DS, defaults to 'analytics'.DS
    var $language;                      // Language used on login (right now pretty useless)
    
    var $__lastCachedFile = null;       // Path to the last file that was cached

    
    /**
     * The __construct() function for this class. Checks if our tmpFolder exists, if not creates it
     *
     * @param unknown_type $id
     * @param unknown_type $table
     * @param unknown_type $ds
     */
    function __construct($id = false, $table = null, $ds = null)
    {        
        parent::__construct($id, $table, $ds);
        
        if (empty($this->tmpFolder))
            $this->tmpFolder = 'analytics'.DS;
            
        if (!is_dir(TMP.'cache'.DS.$this->tmpFolder))
            mkdir(TMP.'cache'.DS.$this->tmpFolder);
    }
    
    /**
     * This allows you to login to a Google Analytics Account via https Post.
     * In return you get a path to a cookie file that's like your ConnectionId
     * when working with a MySql Database -> You'll need to remember it
     * 
     * If the Login fails, this function will return an Error constant. See
     * GA_ERROR_... for more Information.
     *
     * @param string $email             The E-Mail Adress to be used for Login
     * @param string $pass              The Password to be used for Login
     * @param string $language          The language to use for the login (check GA_LANGUAGE_...). Right now this does not seem to have any effect so!
     * @param mixed $loginExpires       Unix Timestamp or strtotime() compatible format stating when the Login expires
     * @return string                   Returns a path to a cookie file
     */
    function login($email, $pass, $language = GA_LANGUAGE_ENGLISH_US, $loginExpires = '+2 hours')
    {        
        $url = 'https://www.google.com/accounts/ServiceLoginBoxAuth';        
        $vars= array('continue' =>        'http://www.google.com/analytics/home/?et=reset&hl='.$language,
                     'service' =>         'analytics',
                     'nui' =>	          'hidden',
                     'hl' =>              $language,
                     'GA3T'	=>	          'ouVrvynQwUs',
                     'Email' =>           $email,
                     'PersistentCookie'=> 'yes',
                     'Passwd' =>          $pass);
                

        $cookiePath = TMP.'cache'.DS.$this->__createCachePath('.cookies.txt', $url, $vars);                     
        $cachePath = $this->__createCachePath('.login-data.txt', $url, $vars);
        
        $this->__lastCachedFile = $cachePath;
                
        $loginData = cache($cachePath, null, $loginExpires);
        
        if (empty($loginData))
        {            
            if (file_exists($cookiePath))
                unlink($cookiePath);
            
            $loginData = cache($cachePath, utf8_encode($this->httpPost($url, $vars, null, $cookiePath)), $loginExpires);
        }
        
        $this->language = $language;
        
        // Check if no data has been returned (most likely a Connection Timeout)
        if (empty($loginData))
        {
            $cookiePath = GA_ERROR_TIMEOUT;
            return $cookiePath;
        }
        
        // Check if Access has been denied
        $regex = '/Username and password do not match/iUs';
        if (preg_match($regex, $loginData))
        {            
            $cookiePath = GA_ERROR_ACCESS_DENIED;
            return $cookiePath;
        }        
        
        
        return $cookiePath;       
    }
    
    /**
     * Creates an array listing all Profiles available for this acccount
     *
     * @param string $cookiePath    The file path where the Cookies for this Session are stored (returned by the Login function)
     * @param mixed $cacheExpires   Unix timestamp or strtotime() compatible format for the time this Result cache expires. Set to 0 for no cache
     * @return array
     */
    function listProfiles($cookiePath, $cacheExpires = '+2 hours')
    {                
        $url = 'https://www.google.com/analytics/home/';        
        $vars = array('et' => 'reset', 'hl' => $this->language);
        
        $cachePath = $this->__createCachePath('.profiles.txt', $url, $vars, $cookiePath);
        $this->__lastCachedFile = $cachePath;
        
        $profilesData = cache($cachePath, null, $cacheExpires);        
        
        if (empty($profilesData))           
            $profilesData = cache($cachePath, utf8_encode($this->httpGet($url, $vars, null, $cookiePath)), $cacheExpires);                               
        
        if (empty($profilesData))       // No Data - Propably a Connection timeout
            return GA_ERROR_TIMEOUT;
            
        $regex = '/\<option value="([0-9]+)" >(.+)\<\/option\>/iUs';
        preg_match_all($regex, $profilesData, $profileMatches, PREG_SET_ORDER);
        
        $profiles = array();
        foreach($profileMatches as $profile)
        {
            $profiles[] = array('id' => $profile[1],
                                'name' => $profile[2]);
        }
                   
        return $profiles;
    }
    
    /**
     * This function get's a report from Google and returns it in the desired format
     *
     * @param string $cookiePath        The file path where the Cookies for this Session are stored (returned by the Login function)
     * @param number $profileId         The Numeric ID of the Profile you want to get a report of (see listProfiles)
     * @param number $report            Use the constants defined on top of this Document starting with GA_REPORT_... to select the report you want
     * @param mixed $fromTime           Unix timestamp or strtotime() compatible format
     * @param mixed $toTime             Unix timestamp or strtotime() compatible format
     * @param number $limit             Maximum results to be returned (not working most of the time, seems a Google Analytics issue)
     * @param numner $format            The format you want the data to be returned. Check the GA_FORMAT... constants defined on top of this document
     * @param mixed $filter             You can filter the results by giving a string to match or not match (see $filterMode)
     * @param number $filterMode        Use GA_FILTER_DONT_MATCH or GA_FILTER_MATCH to control the behavior of the $filter parameter
     * @param number $sortColumn        The number of the column you want to sort by, default is Column 2
     * @param number $sortOrder         Use GA_SORT_ASC or GA_SORT_DESC for controlling the order your results are returned (also see $sortColumn)
     * @param mixed $cacheExpires       Unix timestamp or strtotime() compatible format for the time this Result cache expires. Set to 0 for no cache
     * @return mixed                    Results are returned in XML, CSV or tab seperated format(see $format)
     */
    function getReport($cookiePath, $profileId, $report = GA_REPORT_EXECUTIVE_OVERVIEW, $fromTime = '-7 days', $toTime = 'yesterday', 
                       $limit = 10, $format = GA_FORMAT_CUSTOM_ARRAY, $filter = null, $filterMode = GA_FILTER_MATCH, 
                       $sortColumn = 2, $sortOrder = GA_SORT_DESC, $cacheExpires = '+2 hours')
    {    
        // If people Skip parameters by setting them null go back to default values
        if ($report===null) $report = GA_REPORT_EXECUTIVE_OVERVIEW;
        if ($format===null) $format = GA_FORMAT_CUSTOM_ARRAY;
        if ($filterMode===null) $filterMode = GA_FILTER_MATCH;
        if ($sortOrder===null) $sortOrder = GA_SORT_DESC;
        if ($sortColumn===null) $sortColumn = 2;
    
        
        if ($format==GA_FORMAT_CUSTOM_ARRAY)
        {
            $format = GA_FORMAT_XML;
            $returnArray = true;
        }
        else 
            $returnArray = false;
        
		if (!is_numeric($fromTime)) 
			$fromTime = strtotime($fromTime);

		if (!is_numeric($toTime)) 
			$toTime = strtotime($toTime);			
    
		$fromTime = date('Ymd', $fromTime);
		$toTime = date('Ymd', $toTime);
			
        $url = 'https://www.google.com/analytics/home/report';
        
        // I don't know what all of the parameters are for, but the ones I've figured out you can set
        // via Parameter in the function call:       
        $vars = array('rid' => $profileId, 
                      'user' => '',
                      'vid' => $report,
                      'bd' => $fromTime,
                      'ed' => $toTime,
                      'ns' => $limit,
                      'ss' => '0',
                      'fd' => $filter,
                      'ft' => $filterMode,
                      'sf' => $sortColumn,
                      'sb' => $sortOrder,
                      'dow' => '0',
                      'dt' => '3',
                      'dtc' => '2',
                      'dcomp' => '0',
                      'xd' => '1',
                      'x' => $format);                      
        
            
        $cachePath = $this->__createCachePath('.report.txt', $url, $vars, $cookiePath);
        $this->__lastCachedFile = $cachePath;
        
        $reportData = cache($cachePath, null, $cacheExpires);
        
        if (empty($reportData))                       
            $reportData = cache($cachePath, utf8_encode($this->httpGet($url, $vars, null, $cookiePath)), $cacheExpires);  
            
        if (empty($reportData))       // No Data - Propably a Connection timeout
            return GA_ERROR_TIMEOUT;
            
            
        if ($returnArray==true)
            $reportData = $this->xmlReportToArray($reportData);
            
        return $reportData;
    }
    
    /**
     * Converts a Google Analytics Xml Report into a neat little Array to play around with
     *
     * @param string $xmlReport
     * @return array
     */
    function xmlReportToArray($xmlReport)
    {        
        $regex = '/\<dataset id="([0-9]+)"\>.+\<title\>(.+)\<\/title\>(.+)\<\/dataset\>/iUs';
        preg_match_all($regex, $xmlReport, $dataSets, PREG_SET_ORDER);
        
        foreach ($dataSets as $dataSet)
        {
            $setId = $dataSet[1];
            $name = $dataSet[2];
            $dataSetXml = $dataSet[3];
            
            $columnsRegex = '/\<column([0-9]+)>(.+)\<\/column\\1\>/iUs';
            preg_match_all($columnsRegex, $dataSetXml, $columns, PREG_SET_ORDER);
            
            $recordsRegex = '/\<record id="([0-9]+)">(.+)\<\/record\>/iUs';
            preg_match_all($recordsRegex, $dataSetXml, $records, PREG_SET_ORDER);            
            
            $items = array();
            foreach ($records as $record)
            {
                $recordId = $record[1];
                $fieldsRegex = '/\<(.+)>(.+)\<\/\\1\>/iUs';
                preg_match_all($fieldsRegex, $record[2], $fields, PREG_SET_ORDER);            
                
                $item = array();
                foreach ($fields as $fieldNum => $field)
                {
                    $value = $field[2];
                    $column = $columns[$fieldNum][2];
                 
                    $item[$column] = $value;
                }
                $items[] = $item;
            }
            
            $arrayReport[$setId] = array('Name' => $name,
                                         'Items' => $items);
        }
        
        return $arrayReport;
    }
    
    /**
     * Returns the cache age of the last Query made to this class
     *
     * @return number   Return value is in seconds
     */
    function lastQueryCacheAge()
    {
        if (empty($this->__lastCachedFile))
            return false;

        if (!file_exists(TMP.'cache'.DS.$this->__lastCachedFile))
            return false;

        return time() - @filemtime(TMP.'cache'.DS.$this->__lastCachedFile);
    }
           
    /**
     * This cleans up the entire cache folder by looking for files older then $expires
     *
     * @param mixed $expires    Unix timestamp or strtotime() compatible format for files to be deleted
     * @param mixed $pattern    A Regex pattern you can apply to only delete report data for example.
     */
    function cleanUpCacheFolder($expires = '+2 hours', $pattern = '.*')
    {
        uses('Folder');
        $path = TMP.'cache'.DS.$this->tmpFolder;
                
        $folder =& new Folder($path);        
        $tmpFiles = $folder->find();
        
		if (!is_numeric($expires)) {
			$expires = strtotime($expires);
		}        
        
        foreach ($tmpFiles as $tmpFile)
        {
            if (preg_match('/'.$pattern.'/iUs', $tmpFile))
            {
                $age = time() - @filemtime($path.$tmpFile);            
                $maxAge = $expires - time();            
                
                if ($age >= $maxAge)
                {
                    // Well R.I.P. dear cache file ; )
                    @unlink($path.$tmpFile);                
                }
            }
        }
    }
    
    /**
     * If Google would ever update their reportTypeId's you can use this function to generate a new
     * list of them. Just go to the "Executive Overview" page of one of your profiles, save the HTML to
     * a file and call this function with a path to this file.
     * 
     * This function will return PHP code containing GA_REPORT_... defines to include on top of this page.
     *
     * @param string $indexFile    Path to the file to extract the information from
     * @return string
     */
    function __getReportDefines($indexFile)
    {
        $data = file_get_contents($indexFile);
        $regex = '/\<div class="unav_olink[0-9]?" id="i\|([0-9]+)".+title="(.+)"\>/iUs';
        
        preg_match_all($regex, $data, $matches, PREG_SET_ORDER);
        
        $reportTypes = array();
        
        foreach($matches as $match)
        {
            $id = $match[1];
            
            // Make those Google Names for the reports beautiful php constants ... ; )
            $name = strtoupper($match[2]);
            $name = str_replace(' ', '_', $name);
            $name = str_replace('&', 'AND', $name);
            
            $reportTypes[$name][] = $id;
        }

        // Some manual addtions that can't be extracted from the Executive Overview page (afaik)
        $reportTypes['SITE_OVERLAY'][] = '1351';
                
        $defines = array();
        
        foreach ($reportTypes as $name => $idList)
        {  
            if (count($idList)>1)
            {
                foreach ($idList as $num => $id)
                {
                    $defines[] = "define('GA_REPORT_".$name."_".($num+1)."', '".$id."');";
                }
            }
            else 
            {
                $defines[] = "define('GA_REPORT_".$name."', '".$idList[0]."');";                
            }
        }        

        return $defines;
    }
    
    /**
     * Creates a unique cache file path by combining all parameters given to a unique MD5 hash
     *
     * @param string $ext   The extension for the cache file
     * @return string       Returns a unique file path
     */
    function __createCachePath($ext = '.txt')
    {
        $args = func_get_args();
        return $this->tmpFolder.call_user_func_array(array(&$this, '__createCacheHash'), $args);
    }    
}

?>