merge

www/analytics/plugins/UserSettings/API.php

@@ -0,0 +1,243 @@
+<?php
+/**
+ * Piwik - Open source web analytics
+ *
+ * @link http://piwik.org
+ * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
+ *
+ */
+namespace Piwik\Plugins\UserSettings;
+
+use Piwik\Archive;
+use Piwik\DataTable;
+use Piwik\Metrics;
+use Piwik\Piwik;
+
+/**
+ * @see plugins/UserSettings/functions.php
+ */
+require_once PIWIK_INCLUDE_PATH . '/plugins/UserSettings/functions.php';
+
+/**
+ * The UserSettings API lets you access reports about your Visitors technical settings: browsers, browser types (rendering engine),
+ * operating systems, plugins supported in their browser, Screen resolution and Screen types (normal, widescreen, dual screen or mobile).
+ *
+ * @method static \Piwik\Plugins\UserSettings\API getInstance()
+ */
+class API extends \Piwik\Plugin\API
+{
+    protected function getDataTable($name, $idSite, $period, $date, $segment)
+    {
+        Piwik::checkUserHasViewAccess($idSite);
+        $archive = Archive::build($idSite, $period, $date, $segment);
+        $dataTable = $archive->getDataTable($name);
+        $dataTable->filter('Sort', array(Metrics::INDEX_NB_VISITS));
+        $dataTable->queueFilter('ReplaceColumnNames');
+        $dataTable->queueFilter('ReplaceSummaryRowLabel');
+        return $dataTable;
+    }
+
+    public function getResolution($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getDataTable(Archiver::RESOLUTION_RECORD_NAME, $idSite, $period, $date, $segment);
+        return $dataTable;
+    }
+
+    public function getConfiguration($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getDataTable(Archiver::CONFIGURATION_RECORD_NAME, $idSite, $period, $date, $segment);
+        $dataTable->queueFilter('ColumnCallbackReplace', array('label', __NAMESPACE__ . '\getConfigurationLabel'));
+        return $dataTable;
+    }
+
+    public function getOS($idSite, $period, $date, $segment = false, $addShortLabel = true)
+    {
+        $dataTable = $this->getDataTable(Archiver::OS_RECORD_NAME, $idSite, $period, $date, $segment);
+        // these filters are applied directly so other API methods can use GroupBy on the result of this method
+        $dataTable->filter('ColumnCallbackAddMetadata', array('label', 'logo', __NAMESPACE__ . '\getOSLogo'));
+        if ($addShortLabel) {
+            $dataTable->filter(
+                'ColumnCallbackAddMetadata', array('label', 'shortLabel', __NAMESPACE__ . '\getOSShortLabel'));
+        }
+        $dataTable->filter('ColumnCallbackReplace', array('label', __NAMESPACE__ . '\getOSLabel'));
+        return $dataTable;
+    }
+
+    /**
+     * Gets a DataTable displaying number of visits by operating system family. The operating
+     * system families are listed in vendor piwik/device-detector.
+     */
+    public function getOSFamily($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getOS($idSite, $period, $date, $segment, $addShortLabel = false);
+        $dataTable->filter('GroupBy', array('label', __NAMESPACE__ . '\getOSFamily'));
+        $dataTable->queueFilter('ColumnCallbackReplace', array('label', array('\\Piwik\\Piwik','translate')));
+        return $dataTable;
+    }
+
+    /**
+     * Gets a DataTable displaying number of visits by device type (mobile vs. desktop).
+     */
+    public function getMobileVsDesktop($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getOS($idSite, $period, $date, $segment, $addShortLabel = false);
+        $dataTable->filter('GroupBy', array('label', __NAMESPACE__ . '\getDeviceTypeFromOS'));
+        $this->ensureDefaultRowsInTable($dataTable);
+
+        // set the logo metadata
+        $dataTable->queueFilter('MetadataCallbackReplace',
+            array('logo', __NAMESPACE__ . '\getDeviceTypeImg', null, array('label')));
+
+        // translate the labels
+        $dataTable->queueFilter('ColumnCallbackReplace', array('label', array('\\Piwik\\Piwik','translate')));
+
+        return $dataTable;
+    }
+
+    protected function ensureDefaultRowsInTable($dataTable)
+    {
+        $requiredRows = array(
+            'General_Desktop' => Metrics::INDEX_NB_VISITS,
+            'General_Mobile'  => Metrics::INDEX_NB_VISITS
+        );
+
+        $dataTables = array($dataTable);
+
+        if (!($dataTable instanceof DataTable\Map)) {
+            foreach ($dataTables AS $table) {
+                if ($table->getRowsCount() == 0) {
+                    continue;
+                }
+                foreach ($requiredRows AS $requiredRow => $key) {
+                    $row = $table->getRowFromLabel($requiredRow);
+                    if (empty($row)) {
+                        $table->addRowsFromSimpleArray(array(
+                                                            array('label' => $requiredRow, $key => 0)
+                                                       ));
+                    }
+                }
+            }
+        }
+    }
+
+    public function getBrowserVersion($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getBrowserTable($idSite, $period, $date, $segment);
+        $dataTable->filter('ColumnCallbackAddMetadata', array('label', 'shortLabel', __NAMESPACE__ . '\getBrowserShortLabel'));
+        return $dataTable;
+    }
+
+    protected function getBrowserTable($idSite, $period, $date, $segment)
+    {
+        $dataTable = $this->getDataTable(Archiver::BROWSER_RECORD_NAME, $idSite, $period, $date, $segment);
+        $dataTable->filter('ColumnCallbackAddMetadata', array('label', 'logo', __NAMESPACE__ . '\getBrowsersLogo'));
+        $dataTable->filter('ColumnCallbackReplace', array('label', __NAMESPACE__ . '\getBrowserLabel'));
+        return $dataTable;
+    }
+
+    /**
+     * Gets a DataTable displaying number of visits by browser (ie, Firefox, Chrome, etc.).
+     * The browser version is not included in this report.
+     */
+    public function getBrowser($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getBrowserTable($idSite, $period, $date, $segment);
+        $dataTable->filter('GroupBy', array('label', __NAMESPACE__ . '\getBrowserFromBrowserVersion'));
+        return $dataTable;
+    }
+
+    public function getBrowserType($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getDataTable(Archiver::BROWSER_TYPE_RECORD_NAME, $idSite, $period, $date, $segment);
+        $dataTable->queueFilter('ColumnCallbackAddMetadata', array('label', 'shortLabel', 'ucfirst'));
+        $dataTable->queueFilter('ColumnCallbackReplace', array('label', __NAMESPACE__ . '\getBrowserTypeLabel'));
+        return $dataTable;
+    }
+
+    public function getWideScreen($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getDataTable(Archiver::SCREEN_TYPE_RECORD_NAME, $idSite, $period, $date, $segment);
+        $dataTable->queueFilter('ColumnCallbackAddMetadata', array('label', 'logo', __NAMESPACE__ . '\getScreensLogo'));
+        $dataTable->queueFilter('ColumnCallbackReplace', array('label', 'ucfirst'));
+        return $dataTable;
+    }
+
+    public function getPlugin($idSite, $period, $date, $segment = false)
+    {
+        // fetch all archive data required
+        $dataTable = $this->getDataTable(Archiver::PLUGIN_RECORD_NAME, $idSite, $period, $date, $segment);
+        $browserTypes = $this->getDataTable(Archiver::BROWSER_TYPE_RECORD_NAME, $idSite, $period, $date, $segment);
+        $archive = Archive::build($idSite, $period, $date, $segment);
+        $visitsSums = $archive->getDataTableFromNumeric('nb_visits');
+
+        // check whether given tables are arrays
+        if ($dataTable instanceof DataTable\Map) {
+            $dataTableMap = $dataTable->getDataTables();
+            $browserTypesArray = $browserTypes->getDataTables();
+            $visitSumsArray = $visitsSums->getDataTables();
+        } else {
+            $dataTableMap = array($dataTable);
+            $browserTypesArray = array($browserTypes);
+            $visitSumsArray = array($visitsSums);
+        }
+
+        // walk through the results and calculate the percentage
+        foreach ($dataTableMap as $key => $table) {
+            // get according browserType table
+            foreach ($browserTypesArray AS $k => $browsers) {
+                if ($k == $key) {
+                    $browserType = $browsers;
+                }
+            }
+
+            // get according visitsSum
+            foreach ($visitSumsArray AS $k => $visits) {
+                if ($k == $key) {
+                    if (is_object($visits)) {
+                        if ($visits->getRowsCount() == 0) {
+                            $visitsSumTotal = 0;
+                        } else {
+                            $visitsSumTotal = (float)$visits->getFirstRow()->getColumn('nb_visits');
+                        }
+                    } else {
+                        $visitsSumTotal = (float)$visits;
+                    }
+                }
+            }
+
+            // Calculate percentage, but ignore IE users because plugin detection doesn't work on IE
+            $ieVisits = 0;
+
+            $ieStats = $browserType->getRowFromLabel('ie');
+            if ($ieStats !== false) {
+                $ieVisits = $ieStats->getColumn(Metrics::INDEX_NB_VISITS);
+            }
+
+            $visitsSum = $visitsSumTotal - $ieVisits;
+
+            // When Truncate filter is applied, it will call AddSummaryRow which tries to sum all rows.
+            // We tell the object to skip the column nb_visits_percentage when aggregating (since it's not correct to sum % values)
+            $columnAggregationOps = $table->getMetadata(DataTable::COLUMN_AGGREGATION_OPS_METADATA_NAME);
+            $columnAggregationOps['nb_visits_percentage'] = 'skip';
+            $table->setMetadata(DataTable::COLUMN_AGGREGATION_OPS_METADATA_NAME, $columnAggregationOps);
+
+            // The filter must be applied now so that the new column can
+            // be sorted by the generic filters (applied right after this loop exits)
+            $table->filter('ColumnCallbackAddColumnPercentage', array('nb_visits_percentage', Metrics::INDEX_NB_VISITS, $visitsSum, 1));
+            $table->filter('RangeCheck', array('nb_visits_percentage'));
+        }
+
+        $dataTable->queueFilter('ColumnCallbackAddMetadata', array('label', 'logo', __NAMESPACE__ . '\getPluginsLogo'));
+        $dataTable->queueFilter('ColumnCallbackReplace', array('label', 'ucfirst'));
+
+        return $dataTable;
+    }
+
+    public function getLanguage($idSite, $period, $date, $segment = false)
+    {
+        $dataTable = $this->getDataTable(Archiver::LANGUAGE_RECORD_NAME, $idSite, $period, $date, $segment);
+        $dataTable->filter('ColumnCallbackReplace', array('label', __NAMESPACE__ . '\languageTranslate'));
+        $dataTable->filter('ReplaceColumnNames');
+        return $dataTable;
+    }
+}

www/analytics/plugins/UserSettings/Archiver.php

@@ -0,0 +1,171 @@
+<?php
+/**
+ * Piwik - Open source web analytics
+ *
+ * @link http://piwik.org
+ * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
+ *
+ */
+
+namespace Piwik\Plugins\UserSettings;
+
+use Piwik\Common;
+use Piwik\DataAccess\LogAggregator;
+use Piwik\DataArray;
+use Piwik\DataTable;
+use Piwik\Metrics;
+
+require_once PIWIK_INCLUDE_PATH . '/plugins/UserSettings/functions.php';
+
+/**
+ * Archiver for UserSettings Plugin
+ *
+ * @see PluginsArchiver
+ */
+class Archiver extends \Piwik\Plugin\Archiver
+{
+    const LANGUAGE_RECORD_NAME = 'UserSettings_language';
+    const PLUGIN_RECORD_NAME = 'UserSettings_plugin';
+    const SCREEN_TYPE_RECORD_NAME = 'UserSettings_wideScreen';
+    const RESOLUTION_RECORD_NAME = 'UserSettings_resolution';
+    const BROWSER_RECORD_NAME = 'UserSettings_browser';
+    const BROWSER_TYPE_RECORD_NAME = 'UserSettings_browserType';
+    const OS_RECORD_NAME = 'UserSettings_os';
+    const CONFIGURATION_RECORD_NAME = 'UserSettings_configuration';
+
+    const LANGUAGE_DIMENSION = "log_visit.location_browser_lang";
+    const RESOLUTION_DIMENSION = "log_visit.config_resolution";
+    const BROWSER_VERSION_DIMENSION = "CONCAT(log_visit.config_browser_name, ';', log_visit.config_browser_version)";
+    const OS_DIMENSION = "log_visit.config_os";
+    const CONFIGURATION_DIMENSION = "CONCAT(log_visit.config_os, ';', log_visit.config_browser_name, ';', log_visit.config_resolution)";
+
+    /**
+     * Daily archive of User Settings report. Processes reports for Visits by Resolution,
+     * by Browser, Browser family, etc. Some reports are built from the logs, some reports
+     * are superset of an existing report (eg. Browser family is built from the Browser report)
+     */
+    public function aggregateDayReport()
+    {
+        $this->aggregateByConfiguration();
+        $this->aggregateByOs();
+        $this->aggregateByBrowser();
+        $this->aggregateByResolutionAndScreenType();
+        $this->aggregateByPlugin();
+        $this->aggregateByLanguage();
+    }
+
+    /**
+     * Period archiving: simply sums up daily archives
+     */
+    public function aggregateMultipleReports()
+    {
+        $dataTableRecords = array(
+            self::CONFIGURATION_RECORD_NAME,
+            self::OS_RECORD_NAME,
+            self::BROWSER_RECORD_NAME,
+            self::BROWSER_TYPE_RECORD_NAME,
+            self::RESOLUTION_RECORD_NAME,
+            self::SCREEN_TYPE_RECORD_NAME,
+            self::PLUGIN_RECORD_NAME,
+            self::LANGUAGE_RECORD_NAME,
+        );
+        $this->getProcessor()->aggregateDataTableRecords($dataTableRecords, $this->maximumRows);
+    }
+
+    protected function aggregateByConfiguration()
+    {
+        $metrics = $this->getLogAggregator()->getMetricsFromVisitByDimension(self::CONFIGURATION_DIMENSION)->asDataTable();
+        $this->insertTable(self::CONFIGURATION_RECORD_NAME, $metrics);
+    }
+
+    protected function aggregateByOs()
+    {
+        $metrics = $this->getLogAggregator()->getMetricsFromVisitByDimension(self::OS_DIMENSION)->asDataTable();
+        $this->insertTable(self::OS_RECORD_NAME, $metrics);
+    }
+
+    protected function aggregateByBrowser()
+    {
+        $tableBrowser = $this->aggregateByBrowserVersion();
+        $this->aggregateByBrowserType($tableBrowser);
+    }
+
+    protected function aggregateByBrowserVersion()
+    {
+        $tableBrowser = $this->getLogAggregator()->getMetricsFromVisitByDimension(self::BROWSER_VERSION_DIMENSION)->asDataTable();
+        $this->insertTable(self::BROWSER_RECORD_NAME, $tableBrowser);
+        return $tableBrowser;
+    }
+
+    protected function aggregateByBrowserType(DataTable $tableBrowser)
+    {
+        $tableBrowser->filter('GroupBy', array('label', __NAMESPACE__ . '\getBrowserFamily'));
+        $this->insertTable(self::BROWSER_TYPE_RECORD_NAME, $tableBrowser);
+    }
+
+    protected function aggregateByResolutionAndScreenType()
+    {
+        $resolutions = $this->aggregateByResolution();
+        $this->aggregateByScreenType($resolutions);
+    }
+
+    protected function aggregateByResolution()
+    {
+        $table = $this->getLogAggregator()->getMetricsFromVisitByDimension(self::RESOLUTION_DIMENSION)->asDataTable();
+        $table->filter('ColumnCallbackDeleteRow', array('label', function ($value) {
+            return strlen($value) <= 5;
+        }));
+        $this->insertTable(self::RESOLUTION_RECORD_NAME, $table);
+        return $table;
+    }
+
+    protected function aggregateByScreenType(DataTable $resolutions)
+    {
+        $resolutions->filter('GroupBy', array('label', __NAMESPACE__ . '\getScreenTypeFromResolution'));
+        $this->insertTable(self::SCREEN_TYPE_RECORD_NAME, $resolutions);
+    }
+
+    protected function aggregateByPlugin()
+    {
+        $selects = array(
+            "sum(case log_visit.config_pdf when 1 then 1 else 0 end) as pdf",
+            "sum(case log_visit.config_flash when 1 then 1 else 0 end) as flash",
+            "sum(case log_visit.config_java when 1 then 1 else 0 end) as java",
+            "sum(case log_visit.config_director when 1 then 1 else 0 end) as director",
+            "sum(case log_visit.config_quicktime when 1 then 1 else 0 end) as quicktime",
+            "sum(case log_visit.config_realplayer when 1 then 1 else 0 end) as realplayer",
+            "sum(case log_visit.config_windowsmedia when 1 then 1 else 0 end) as windowsmedia",
+            "sum(case log_visit.config_gears when 1 then 1 else 0 end) as gears",
+            "sum(case log_visit.config_silverlight when 1 then 1 else 0 end) as silverlight",
+            "sum(case log_visit.config_cookie when 1 then 1 else 0 end) as cookie"
+        );
+
+        $query = $this->getLogAggregator()->queryVisitsByDimension(array(), false, $selects, $metrics = array());
+        $data = $query->fetch();
+        $cleanRow = LogAggregator::makeArrayOneColumn($data, Metrics::INDEX_NB_VISITS);
+        $table = DataTable::makeFromIndexedArray($cleanRow);
+        $this->insertTable(self::PLUGIN_RECORD_NAME, $table);
+    }
+
+    protected function aggregateByLanguage()
+    {
+        $query = $this->getLogAggregator()->queryVisitsByDimension(array("label" => self::LANGUAGE_DIMENSION));
+        $languageCodes = array_keys(Common::getLanguagesList());
+        $metricsByLanguage = new DataArray();
+        while ($row = $query->fetch()) {
+            $code = Common::extractLanguageCodeFromBrowserLanguage($row['label'], $languageCodes);
+            $metricsByLanguage->sumMetricsVisits($code, $row);
+        }
+
+        $report = $metricsByLanguage->asDataTable();
+        $this->insertTable(self::LANGUAGE_RECORD_NAME, $report);
+    }
+
+    protected function insertTable($recordName, DataTable $table)
+    {
+        $report = $table->getSerialized($this->maximumRows, null, Metrics::INDEX_NB_VISITS);
+        return $this->getProcessor()->insertBlobRecord($recordName, $report);
+    }
+
+}
+

www/analytics/plugins/UserSettings/Controller.php

@@ -0,0 +1,89 @@
+<?php
+/**
+ * Piwik - Open source web analytics
+ *
+ * @link http://piwik.org
+ * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
+ *
+ */
+namespace Piwik\Plugins\UserSettings;
+
+use Piwik\View;
+use Piwik\ViewDataTable\Factory;
+
+/**
+ *
+ */
+class Controller extends \Piwik\Plugin\Controller
+{
+    public function index()
+    {
+        $view = new View('@UserSettings/index');
+
+        $view->dataTablePlugin = $this->getPlugin(true);
+        $view->dataTableResolution = $this->getResolution(true);
+        $view->dataTableConfiguration = $this->getConfiguration(true);
+        $view->dataTableOS = $this->getOS(true);
+        $view->dataTableBrowser = $this->getBrowser(true);
+        $view->dataTableBrowserType = $this->getBrowserType(true);
+        $view->dataTableMobileVsDesktop = $this->getMobileVsDesktop(true);
+        $view->dataTableBrowserLanguage = $this->getLanguage(true);
+
+        return $view->render();
+    }
+
+    public function getResolution()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getConfiguration()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getOS()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getOSFamily()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getMobileVsDesktop()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getBrowserVersion()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getBrowser()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getBrowserType()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getWideScreen()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getPlugin()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+
+    public function getLanguage()
+    {
+        return $this->renderReport(__FUNCTION__);
+    }
+}

www/analytics/plugins/UserSettings/UserSettings.php

@@ -0,0 +1,465 @@
+<?php
+/**
+ * Piwik - Open source web analytics
+ *
+ * @link http://piwik.org
+ * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
+ *
+ */
+namespace Piwik\Plugins\UserSettings;
+
+use Piwik\Menu\MenuMain;
+use Piwik\Piwik;
+use Piwik\Plugin\ViewDataTable;
+use Piwik\Plugins\CoreVisualizations\Visualizations\Graph;
+use Piwik\Plugins\CoreVisualizations\Visualizations\HtmlTable;
+use Piwik\Plugins\CoreVisualizations\Visualizations\JqplotGraph\Pie;
+use Piwik\WidgetsList;
+
+/**
+ *
+ */
+class UserSettings extends \Piwik\Plugin
+{
+    /**
+     * Mapping between the browser family shortcode and the displayed name
+     *
+     * @type array
+     */
+    static public $browserType_display = array(
+        'ie'     => 'Trident (IE)',
+        'gecko'  => 'Gecko (Firefox)',
+        'khtml'  => 'KHTML (Konqueror)',
+        'webkit' => 'WebKit (Safari, Chrome)',
+        'opera'  => 'Presto (Opera)',
+    );
+
+    /**
+     * Defines API reports.
+     * Also used to define Widgets.
+     *
+     * @type array
+     *
+     * Category, Report Name, API Module, API action, Translated column name,
+     * $segment, $sqlSegment, $acceptedValues, $sqlFilter
+     */
+    protected $reportMetadata = array(
+        array('UserSettings_VisitorSettings',
+              'UserSettings_WidgetResolutions',
+              'UserSettings',
+              'getResolution',
+              'UserSettings_ColumnResolution',
+              'resolution',
+              'log_visit.config_resolution',
+              '1280x1024, 800x600, etc.',
+              null,),
+
+        array('UserSettings_VisitorSettings',
+              'UserSettings_WidgetBrowsers',
+              'UserSettings',
+              'getBrowser',
+              'UserSettings_ColumnBrowser',
+              'browserCode',
+              'log_visit.config_browser_name',
+              'FF, IE, CH, SF, OP, etc.',
+              null,),
+
+        // browser version
+        array('UserSettings_VisitorSettings',
+              'UserSettings_WidgetBrowserVersion',
+              'UserSettings',
+              'getBrowserVersion',
+              'UserSettings_ColumnBrowserVersion',
+              'browserVersion',
+              'log_visit.config_browser_version',
+              '1.0, 8.0, etc.',
+              null,),
+
+        array('UserSettings_VisitorSettings',
+              'UserSettings_WidgetBrowserFamilies',
+              'UserSettings',
+              'getBrowserType',
+              'UserSettings_ColumnBrowserFamily',
+              null,
+              null,
+              null,
+              null,),
+
+        array('UserSettings_VisitorSettings',
+              'UserSettings_WidgetPlugins',
+              'UserSettings',
+              'getPlugin',
+              'General_Plugin',
+              null,
+              null,
+              null,
+              null,),
+
+        array('UserSettings_VisitorSettings',
+              'UserSettings_WidgetWidescreen',
+              'UserSettings',
+              'getWideScreen',
+              'UserSettings_ColumnTypeOfScreen',
+              null,
+              null,
+              null,
+              null,),
+
+        array('UserSettings_VisitorSettings',
+              'UserSettings_WidgetOperatingSystems',
+              'UserSettings',
+              'getOS',
+              'UserSettings_ColumnOperatingSystem',
+              'operatingSystemCode',
+              'log_visit.config_os',
+              'WXP, WI7, MAC, LIN, AND, IPD, etc.',
+              null,),
+
+        array('UserSettings_VisitorSettings',
+              'UserSettings_WidgetGlobalVisitors',
+              'UserSettings',
+              'getConfiguration',
+              'UserSettings_ColumnConfiguration',
+              null,
+              null,
+              null,
+              null),
+
+        // operating system family
+        array('UserSettings_VisitorSettings',
+              'UserSettings_OperatingSystemFamily',
+              'UserSettings',
+              'getOSFamily',
+              'UserSettings_OperatingSystemFamily',
+              null,
+              null,
+              null,
+              null),
+
+        // device type
+        array('UserSettings_VisitorSettings',
+              'UserSettings_MobileVsDesktop',
+              'UserSettings',
+              'getMobileVsDesktop',
+              'UserSettings_MobileVsDesktop',
+              null,
+              null,
+              null,
+              null),
+
+        // Browser language
+        array('UserSettings_VisitorSettings',
+              'UserSettings_BrowserLanguage',
+              'UserSettings',
+              'getLanguage',
+              'General_Language',
+              null,
+              null,
+              null,
+              null),
+    );
+
+    /**
+     * @see Piwik\Plugin::getListHooksRegistered
+     */
+    public function getListHooksRegistered()
+    {
+        $hooks = array(
+            'WidgetsList.addWidgets'          => 'addWidgets',
+            'Menu.Reporting.addItems'         => 'addMenu',
+            'API.getReportMetadata'           => 'getReportMetadata',
+            'API.getSegmentDimensionMetadata' => 'getSegmentsMetadata',
+            'ViewDataTable.configure'         => 'configureViewDataTable',
+            'ViewDataTable.getDefaultType'    => 'getDefaultTypeViewDataTable'
+        );
+        return $hooks;
+    }
+
+    public function getDefaultTypeViewDataTable(&$defaultViewTypes)
+    {
+        $defaultViewTypes['UserSettings.getBrowserType'] = Pie::ID;
+    }
+
+    public function configureViewDataTable(ViewDataTable $view)
+    {
+        switch ($view->requestConfig->apiMethodToRequestDataTable) {
+            case 'UserSettings.getResolution':
+                $this->configureViewForGetResolution($view);
+                break;
+            case 'UserSettings.getConfiguration':
+                $this->configureViewForGetConfiguration($view);
+                break;
+            case 'UserSettings.getOS':
+                $this->configureViewForGetOS($view);
+                break;
+            case 'UserSettings.getOSFamily':
+                $this->configureViewForGetOSFamily($view);
+                break;
+            case 'UserSettings.getBrowserVersion':
+                $this->configureViewForGetBrowserVersion($view);
+                break;
+            case 'UserSettings.getBrowser':
+                $this->configureViewForGetBrowser($view);
+                break;
+            case 'UserSettings.getBrowserType':
+                $this->configureViewForGetBrowserType($view);
+                break;
+            case 'UserSettings.getWideScreen':
+                $this->configureViewForGetWideScreen($view);
+                break;
+            case 'UserSettings.getMobileVsDesktop':
+                $this->configureViewForGetMobileVsDesktop($view);
+                break;
+            case 'UserSettings.getPlugin':
+                $this->configureViewForGetPlugin($view);
+                break;
+            case 'UserSettings.getLanguage':
+                $this->configureViewForGetLanguage($view);
+                break;
+        }
+    }
+
+    private function configureViewForGetResolution(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_ColumnResolution'));
+    }
+
+    private function configureViewForGetConfiguration(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_ColumnConfiguration'));
+
+        $view->requestConfig->filter_limit = 3;
+    }
+
+    private function configureViewForGetOS(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->title = Piwik::translate('UserSettings_OperatingSystems');
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_ColumnOperatingSystem'));
+        $view->config->addRelatedReports($this->getOsRelatedReports());
+    }
+
+    private function configureViewForGetOSFamily(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->title = Piwik::translate('UserSettings_OperatingSystemFamily');
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_OperatingSystemFamily'));
+        $view->config->addRelatedReports($this->getOsRelatedReports());
+    }
+
+    private function configureViewForGetBrowserVersion(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->title = Piwik::translate('UserSettings_ColumnBrowserVersion');
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_ColumnBrowserVersion'));
+        $view->config->addRelatedReports($this->getBrowserRelatedReports());
+
+        if ($view->isViewDataTableId(Graph::ID)) {
+            $view->config->max_graph_elements = 7;
+        }
+    }
+
+    private function configureViewForGetBrowser(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->title = Piwik::translate('UserSettings_Browsers');
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_ColumnBrowser'));
+        $view->config->addRelatedReports($this->getBrowserRelatedReports());
+
+        if ($view->isViewDataTableId(Graph::ID)) {
+            $view->config->max_graph_elements = 7;
+        }
+    }
+
+    private function configureViewForGetBrowserType(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_ColumnBrowserFamily'));
+        $view->config->show_offset_information = false;
+        $view->config->show_pagination_control = false;
+        $view->config->show_limit_control      = false;
+    }
+
+    private function configureViewForGetWideScreen(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->title = Piwik::translate('UserSettings_ColumnTypeOfScreen');
+        $view->config->show_offset_information = false;
+        $view->config->show_pagination_control = false;
+        $view->config->show_limit_control      = false;
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_ColumnTypeOfScreen'));
+        $view->config->addRelatedReports($this->getWideScreenDeviceTypeRelatedReports());
+    }
+
+    private function configureViewForGetMobileVsDesktop(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->title = Piwik::translate('UserSettings_MobileVsDesktop');
+        $view->config->addTranslation('label', Piwik::translate('UserSettings_MobileVsDesktop'));
+        $view->config->addRelatedReports($this->getWideScreenDeviceTypeRelatedReports());
+    }
+
+    private function configureViewForGetPlugin(ViewDataTable $view)
+    {
+        $this->getBasicUserSettingsDisplayProperties($view);
+
+        $view->config->addTranslations(array(
+            'label'                => Piwik::translate('General_Plugin'),
+            'nb_visits_percentage' =>
+            str_replace(' ', '&nbsp;', Piwik::translate('General_ColumnPercentageVisits'))
+        ));
+
+        $view->config->show_offset_information = false;
+        $view->config->show_pagination_control = false;
+        $view->config->show_limit_control      = false;
+        $view->config->show_all_views_icons    = false;
+        $view->config->show_table_all_columns  = false;
+        $view->config->columns_to_display  = array('label', 'nb_visits_percentage', 'nb_visits');
+        $view->config->show_footer_message = Piwik::translate('UserSettings_PluginDetectionDoesNotWorkInIE');
+
+        $view->requestConfig->filter_sort_column = 'nb_visits_percentage';
+        $view->requestConfig->filter_sort_order  = 'desc';
+        $view->requestConfig->filter_limit       = 10;
+    }
+
+    private function configureViewForGetLanguage(ViewDataTable $view)
+    {
+        $view->config->show_search = false;
+        $view->config->columns_to_display = array('label', 'nb_visits');
+        $view->config->show_exclude_low_population = false;
+        $view->config->addTranslation('label', Piwik::translate('General_Language'));
+
+        $view->requestConfig->filter_sort_column = 'nb_visits';
+        $view->requestConfig->filter_sort_order  = 'desc';
+    }
+
+    private function getWideScreenDeviceTypeRelatedReports()
+    {
+        return array(
+            'UserSettings.getMobileVsDesktop' => Piwik::translate('UserSettings_MobileVsDesktop'),
+            'UserSettings.getWideScreen'      => Piwik::translate('UserSettings_ColumnTypeOfScreen')
+        );
+    }
+
+    private function getBrowserRelatedReports()
+    {
+        return array(
+            'UserSettings.getBrowser'        => Piwik::translate('UserSettings_Browsers'),
+            'UserSettings.getBrowserVersion' => Piwik::translate('UserSettings_ColumnBrowserVersion')
+        );
+    }
+
+    private function getOsRelatedReports()
+    {
+        return array(
+            'UserSettings.getOSFamily' => Piwik::translate('UserSettings_OperatingSystemFamily'),
+            'UserSettings.getOS'       => Piwik::translate('UserSettings_OperatingSystems')
+        );
+    }
+
+    private function getBasicUserSettingsDisplayProperties(ViewDataTable $view)
+    {
+        $view->config->show_search = false;
+        $view->config->show_exclude_low_population = false;
+
+        $view->requestConfig->filter_limit = 5;
+
+        if ($view->isViewDataTableId(Graph::ID)) {
+            $view->config->max_graph_elements = 5;
+        }
+    }
+
+    /**
+     * Registers reports metadata
+     *
+     * @param array $reports
+     */
+    public function getReportMetadata(&$reports)
+    {
+        $i = 0;
+        foreach ($this->reportMetadata as $report) {
+            list($category, $name, $apiModule, $apiAction, $columnName) = $report;
+            if ($category == false) continue;
+
+            $report = array(
+                'category'  => Piwik::translate($category),
+                'name'      => Piwik::translate($name),
+                'module'    => $apiModule,
+                'action'    => $apiAction,
+                'dimension' => Piwik::translate($columnName),
+                'order'     => $i++
+            );
+
+            $translation = $name . 'Documentation';
+            $translated = Piwik::translate($translation, '<br />');
+            if ($translated != $translation) {
+                $report['documentation'] = $translated;
+            }
+
+            // getPlugin returns only a subset of metrics
+            if ($apiAction == 'getPlugin') {
+                $report['metrics'] = array(
+                    'nb_visits',
+                    'nb_visits_percentage' => Piwik::translate('General_ColumnPercentageVisits')
+                );
+                // There is no processedMetrics for this report
+                $report['processedMetrics'] = array();
+                // Always has same number of rows, 1 per plugin
+                $report['constantRowsCount'] = true;
+            }
+            $reports[] = $report;
+        }
+    }
+
+    /**
+     * Get segments meta data
+     */
+    public function getSegmentsMetadata(&$segments)
+    {
+        foreach ($this->reportMetadata as $report) {
+            @list($category, $name, $apiModule, $apiAction, $columnName, $segment, $sqlSegment, $acceptedValues) = $report;
+            if (empty($segment)) continue;
+            $segments[] = array(
+                'type'           => 'dimension',
+                'category'       => Piwik::translate('General_Visit'),
+                'name'           => $columnName,
+                'segment'        => $segment,
+                'acceptedValues' => $acceptedValues,
+                'sqlSegment'     => $sqlSegment
+            );
+        }
+    }
+
+    /**
+     * Adds the various User Settings widgets
+     */
+    function addWidgets()
+    {
+        // in this case, Widgets have same names as API reports
+        foreach ($this->reportMetadata as $report) {
+            list($category, $name, $controllerName, $controllerAction) = $report;
+            if ($category == false) continue;
+            WidgetsList::add($category, $name, $controllerName, $controllerAction);
+        }
+    }
+
+    /**
+     * Adds the User Settings menu
+     */
+    function addMenu()
+    {
+        MenuMain::getInstance()->add('General_Visitors', 'General_Settings', array('module' => 'UserSettings', 'action' => 'index'));
+    }
+
+}

www/analytics/plugins/UserSettings/functions.php

@@ -0,0 +1,270 @@
+<?php
+/**
+ * Piwik - Open source web analytics
+ *
+ * @link http://piwik.org
+ * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
+ *
+ */
+
+namespace Piwik\Plugins\UserSettings;
+
+use Piwik\Piwik;
+use Piwik\Tracker\Request;
+use UserAgentParser;
+
+/**
+ * @see libs/UserAgentParser/UserAgentParser.php
+ */
+require_once PIWIK_INCLUDE_PATH . '/libs/UserAgentParser/UserAgentParser.php';
+
+function getPluginsLogo($oldLabel)
+{
+    if ($oldLabel == Piwik::translate('General_Others')) {
+        return false;
+    }
+    return 'plugins/UserSettings/images/plugins/' . $oldLabel . '.gif';
+}
+
+function getOSLabel($osId)
+{
+    $osName = UserAgentParser::getOperatingSystemNameFromId($osId);
+    if ($osName !== false) {
+        return $osName;
+    }
+    if ($osId == 'UNK') {
+        return Piwik::translate('General_Unknown');
+    }
+    return $osId;
+}
+
+function getOSShortLabel($osId)
+{
+    $osShortName = UserAgentParser::getOperatingSystemShortNameFromId($osId);
+    if ($osShortName !== false) {
+        return $osShortName;
+    }
+    if ($osId == 'UNK') {
+        return Piwik::translate('General_Unknown');
+    }
+    return $osId;
+}
+
+
+function getOSFamily($osLabel)
+{
+    $osId = UserAgentParser::getOperatingSystemIdFromName($osLabel);
+    $osFamily = UserAgentParser::getOperatingSystemFamilyFromId($osId);
+
+    if ($osFamily == 'unknown') {
+        $osFamily = Piwik::translate('General_Unknown');
+    } else if ($osFamily == 'Gaming Console') {
+        $osFamily = Piwik::translate('UserSettings_GamingConsole');
+    }
+
+    return $osFamily;
+}
+
+function getDeviceTypeFromOS($osLabel)
+{
+    $osId = UserAgentParser::getOperatingSystemIdFromName($osLabel);
+    $osFamily = UserAgentParser::getOperatingSystemFamilyFromId($osId);
+
+    // NOTE: translations done in another filter
+    switch ($osFamily) {
+        case 'Windows':
+        case 'Linux':
+        case 'Mac':
+        case 'Unix':
+        case 'Other':
+        case 'Gaming Console':
+            return 'General_Desktop';
+        case 'iOS':
+        case 'Android':
+        case 'Windows Mobile':
+        case 'Other Mobile':
+        case 'Mobile Gaming Console':
+            return 'General_Mobile';
+        default:
+            return 'General_Unknown';
+    }
+}
+
+function getBrowserTypeLabel($oldLabel)
+{
+    if (isset(UserSettings::$browserType_display[$oldLabel])) {
+        return UserSettings::$browserType_display[$oldLabel];
+    }
+    if ($oldLabel == 'unknown') {
+        return Piwik::translate('General_Unknown');
+    }
+    return $oldLabel;
+}
+
+
+function getConfigurationLabel($str)
+{
+    if (strpos($str, ';') === false) {
+        return $str;
+    }
+    $values = explode(";", $str);
+
+    $os = getOSLabel($values[0]);
+    $name = $values[1];
+    $browser = UserAgentParser::getBrowserNameFromId($name);
+    if ($browser === false) {
+        $browser = Piwik::translate('General_Unknown');
+    }
+    $resolution = $values[2];
+    return $os . " / " . $browser . " / " . $resolution;
+}
+
+function getBrowserLabel($oldLabel)
+{
+    $browserId = getBrowserId($oldLabel);
+    $version = getBrowserVersion($oldLabel);
+    $browserName = UserAgentParser::getBrowserNameFromId($browserId);
+    if ($browserName !== false) {
+        return $browserName . " " . $version;
+    }
+    if ($browserId == 'UNK') {
+        return Piwik::translate('General_Unknown');
+    }
+    return $oldLabel;
+}
+
+function getBrowserShortLabel($oldLabel)
+{
+    $browserId = getBrowserId($oldLabel);
+    $version = getBrowserVersion($oldLabel);
+    $browserName = UserAgentParser::getBrowserShortNameFromId($browserId);
+    if ($browserName !== false) {
+        return $browserName . " " . $version;
+    }
+    if ($browserId == 'UNK') {
+        return Piwik::translate('General_Unknown');
+    }
+    return $oldLabel;
+}
+
+function getBrowserId($str)
+{
+    return substr($str, 0, strpos($str, ';'));
+}
+
+function getBrowserVersion($str)
+{
+    return substr($str, strpos($str, ';') + 1);
+}
+
+function getLogoImageFromId($dir, $id)
+{
+    $path = $dir . '/' . $id . '.gif';
+    if (file_exists(PIWIK_INCLUDE_PATH . '/' . $path)) {
+        return $path;
+    } else {
+        return $dir . '/UNK.gif';
+    }
+}
+
+function getBrowsersLogo($label)
+{
+    $id = getBrowserId($label);
+    // For aggregated row 'Others'
+    if (empty($id)) {
+        $id = 'UNK';
+    }
+    return getLogoImageFromId('plugins/UserSettings/images/browsers', $id);
+}
+
+function getOSLogo($label)
+{
+    // For aggregated row 'Others'
+    if (empty($label)) {
+        $label = 'UNK';
+    }
+    return getLogoImageFromId('plugins/UserSettings/images/os', $label);
+}
+
+function getScreensLogo($label)
+{
+    return 'plugins/UserSettings/images/screens/' . $label . '.gif';
+}
+
+function getDeviceTypeImg($oldOSImage, $osFamilyLabel)
+{
+    switch ($osFamilyLabel) {
+        case 'General_Desktop':
+            return 'plugins/UserSettings/images/screens/normal.gif';
+        case 'General_Mobile':
+            return 'plugins/UserSettings/images/screens/mobile.gif';
+        case 'General_Unknown':
+        default:
+            return 'plugins/UserSettings/images/os/UNK.gif';
+    }
+}
+
+function getScreenTypeFromResolution($resolution)
+{
+    if ($resolution === Request::UNKNOWN_RESOLUTION) {
+        return $resolution;
+    }
+
+    $width = intval(substr($resolution, 0, strpos($resolution, 'x')));
+    $height = intval(substr($resolution, strpos($resolution, 'x') + 1));
+    $ratio = Piwik::secureDiv($width, $height);
+
+    if ($width < 640) {
+        $name = 'mobile';
+    } elseif ($ratio < 1.4) {
+        $name = 'normal';
+    } else if ($ratio < 2) {
+        $name = 'wide';
+    } else {
+        $name = 'dual';
+    }
+    return $name;
+}
+
+function getBrowserFamily($browserLabel)
+{
+    $familyNameToUse = UserAgentParser::getBrowserFamilyFromId(substr($browserLabel, 0, 2));
+    return $familyNameToUse;
+}
+
+/**
+ * Extracts the browser name from a string with the browser name and version.
+ */
+function getBrowserFromBrowserVersion($browserWithVersion)
+{
+    if (preg_match("/(.+) [0-9]+(?:\.[0-9]+)?$/", $browserWithVersion, $matches) === 0) {
+        return $browserWithVersion;
+    }
+
+    return $matches[1];
+}
+
+/**
+ * Returns the given language code to translated language name
+ *
+ * @param $label
+ *
+ * @return string
+ */
+function languageTranslate($label)
+{
+    if ($label == '' || $label == 'xx') {
+        return Piwik::translate('General_Unknown');
+    }
+
+    $key = 'UserSettings_Language_' . $label;
+
+    $translation = Piwik::translate($key);
+
+    // Show language code if unknown code
+    if ($translation == $key) {
+        $translation = Piwik::translate('UserSettings_LanguageCode') . ' ' . $label;
+    }
+
+    return $translation;
+}