24683125413

Committed 20 Apr 2026 06:22PM UTC coverage: 57.497% (-3.0%) from 60.51%

Build # 24683125413

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1315 from equalizedigital/william/pro-286-update-the-free-plugin-to-be-able-to-handle-licence

Add support for registering sites with myDot and exchanging a jwt token that can be used to share site stats

Coverage Stats

440 of 1210 new or added lines in 9 files covered. (36.36%)

2 existing lines in 2 files now uncovered.

5426 of 9437 relevant lines covered (57.5%)

4.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.71

/admin/class-scans-stats.php

<?php
/**
 * Class file for scans stats
 *
 * @package Accessibility_Checker
 */

namespace EDAC\Admin;

use EqualizeDigital\AccessibilityCheckerPro\Admin\Scans;

/**
 * Class that handles calculating scans stats
 */
class Scans_Stats {

        /**
         * Number of seconds to return results from cache.
         *
         * @var integer
         */
        private $cache_time = 0;

        /**
         * Max number of issues to consider for results.
         *
         * @var integer
         */
        private $record_limit = 100000;

        /**
         * Total number of rules that are run on each page during a scan
         *
         * @var integer
         */
        private $rule_count;

        /**
         * Prefix used cache name
         *
         * @var string
         */
        private $cache_name_prefix;

        /**
         * Constructor
         *
         * @param integer $cache_time number of seconds to return the results from cache.
         */
        public function __construct( $cache_time = 60 * 60 * 24 ) {

                $this->cache_time        = $cache_time;
                $this->cache_name_prefix = 'edac_scans_stats_' . EDAC_VERSION . '_' . $this->record_limit;
                $this->rule_count        = count( edac_register_rules() );
        }

        /**
         * Load all stats into the cache. Should be called by a background scheduled.
         *
         * @return void
         */
        public function load_cache() {

                // Cache the summary.
                $this->summary();

                // Cache the post_types.
                $scannable_post_types = Settings::get_scannable_post_types();

                $post_types = get_post_types(
                        [
                                'public' => true,
                        ]
                );

                unset( $post_types['attachment'] );

                foreach ( $post_types as $post_type ) {
                        if ( in_array( $post_type, $scannable_post_types, true ) ) {
                                $this->issues_summary_by_post_type( $post_type );
                        }
                }
        }

        /**
         * Clear the summary and post type scans stats that have been cached
         *
         * @return void
         */
        public function clear_cache() {

                // Delete the cached summary stats.
                $transient_name = $this->cache_name_prefix . '_summary';
                delete_transient( $transient_name );

                // Delete the cached post_type stats.
                $post_types = get_post_types(
                        [
                                'public' => true,
                        ]
                );
                unset( $post_types['attachment'] );
                foreach ( $post_types as $post_type ) {
                        $transient_name = $this->cache_name_prefix . '_issues_summary_by_post_type_' . $post_type;
                        delete_transient( $transient_name );
                }
        }

        /**
         * Gets summary information about all scans
         *
         * @param  boolean $skip_cache whether to skip the cache.
         * @return array
         */
        public function summary( $skip_cache = false ) {

                global $wpdb;

                $transient_name = $this->cache_name_prefix . '_summary';

                $cache = get_transient( $transient_name );

                if ( ! $skip_cache && ( $this->cache_time && $cache ) ) {

                        if ( $cache['expires_at'] >= time() && $cache['cached_at'] + $this->cache_time >= time()
                        ) {

                                $full_scan_completed_at = (int) get_option( 'edacp_fullscan_completed_at' );
                                if ( $full_scan_completed_at <= $cache['cached_at'] ) {
                                        // There hasn't been a full scan completed since we've cached, so return these results.
                                        $cache['cache_hit'] = true;
                                        return $cache;
                                }
                        }
                }

                $data = [];

                $scannable_posts_count = Settings::get_scannable_posts_count();
                $tests_count           = $scannable_posts_count * $this->rule_count;
                $siteid                = get_current_blog_id();

                $data['scannable_posts_count']      = (int) $scannable_posts_count;
                $data['rule_count']                 = (int) $this->rule_count;
                $data['tests_count']                = (int) $tests_count;
                $data['scannable_post_types_count'] = (int) count( Settings::get_scannable_post_types( true ) );

                $post_types = get_post_types(
                        [
                                'public' => true,
                        ]
                );
                unset( $post_types['attachment'] );

                $data['public_post_types_count'] = (int) count( $post_types );

                $issues_query = new Issues_Query( [], $this->record_limit, Issues_Query::FLAG_INCLUDE_ALL_POST_TYPES );

                // Count total unique meta values from postmeta table where the meta_key is _edac_issue_density.
                // This will give us the total number of posts that have been scanned.
                $data['posts_scanned'] = (int) $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Using direct query for adding data to database, caching not required for one time operation.
                        $wpdb->prepare(
                                'SELECT COUNT(DISTINCT %i) FROM %i WHERE meta_key = %s',
                                'post_id',
                                $wpdb->postmeta,
                                '_edac_issue_density'
                        )
                );


                $data['is_truncated']      = $issues_query->has_truncated_results();
                $data['posts_with_issues'] = (int) $issues_query->distinct_posts_count();
                $data['rules_failed']      = 0;

                // Get a count of rules that are not in the issues table.
                $rule_slugs = array_map(
                        function ( $item ) {
                                return $item['slug'];
                        },
                        edac_register_rules()
                );

                foreach ( $rule_slugs as $rule_slug ) {
                        $rule_query = new Issues_Query(
                                [
                                        'rule_slugs' => [ $rule_slug ],
                                        'post_types' => Settings::get_scannable_post_types(),
                                ],
                                1
                        );

                        if ( $rule_query->count() ) {
                                        ++$data['rules_failed'];
                        }
                }
                $data['rules_passed'] = $this->rule_count - $data['rules_failed'];

                $data['passed_percentage'] = 'N/A';
                $scannable_post_types      = Settings::get_scannable_post_types();
                if ( ! empty( $scannable_post_types ) && $data['posts_scanned'] > 0 && $tests_count > 0 ) {
                        $data['passed_percentage'] = round( ( $data['rules_passed'] / $this->rule_count ) * 100, 2 );
                }

                $warning_issues_query      = new Issues_Query(
                        [
                                'post_types' => Settings::get_scannable_post_types(),
                                'rule_types' => [ Issues_Query::RULETYPE_WARNING ],
                        ],
                        $this->record_limit
                );
                $data['warnings']          = (int) $warning_issues_query->count();
                $data['distinct_warnings'] = (int) $warning_issues_query->distinct_count();

                $contrast_issues_query = new Issues_Query(
                        [
                                'post_types' => Settings::get_scannable_post_types(),
                                'rule_types' => [ Issues_Query::RULETYPE_COLOR_CONTRAST ],
                        ],
                        $this->record_limit
                );

                $data['contrast_errors']          = (int) $contrast_issues_query->count();
                $data['distinct_contrast_errors'] = (int) $contrast_issues_query->distinct_count();

                $error_issues_query      = new Issues_Query(
                        [
                                'post_types' => Settings::get_scannable_post_types(),
                                'rule_types' => [ Issues_Query::RULETYPE_ERROR ],
                        ],
                        $this->record_limit
                );
                $data['errors']          = (int) $error_issues_query->count();
                $data['distinct_errors'] = (int) $error_issues_query->distinct_count();

                $data['errors_without_contrast']          = $data['errors'] - $data['contrast_errors'];
                $data['distinct_errors_without_contrast'] = $data['distinct_errors'] - $data['distinct_contrast_errors'];

                $ignored_issues_query         = new Issues_Query(
                        [
                                'post_types' => Settings::get_scannable_post_types(),
                        ],
                        $this->record_limit,
                        Issues_Query::FLAG_ONLY_IGNORED
                );
                $data['ignored']              = (int) $ignored_issues_query->count();
                $data['distinct_ignored']     = (int) $ignored_issues_query->distinct_count();
                $data['posts_without_issues'] = 0;
                $data['avg_issues_per_post']  = 0;

                if ( $data['posts_scanned'] > 0
                        && ! empty( Settings::get_scannable_post_types() )
                        && ! empty( Settings::get_scannable_post_statuses() )
                ) {
                        $ac_table_name = $wpdb->prefix . 'accessibility_checker';

                        $posts_without_issues = "
                                SELECT COUNT({$wpdb->posts}.ID) FROM {$wpdb->posts}
                                LEFT JOIN " . $wpdb->prefix . "accessibility_checker ON {$wpdb->posts}.ID = " .
                                $wpdb->prefix . 'accessibility_checker.postid WHERE ' .
                                $wpdb->prefix . 'accessibility_checker.postid IS NULL
                                AND post_type IN(' .
                                        Helpers::array_to_sql_safe_list(
                                                Settings::get_scannable_post_types()
                                        ) . ')
                                AND post_status IN(' .
                                        Helpers::array_to_sql_safe_list(
                                                Settings::get_scannable_post_statuses()
                                        ) . ')';

                        // give me sql that will find all post ids in the accessibility_checker table
                        // where ALL issues with that ID are eiter ignored or globally ignored.
                        $posts_with_just_ignored_issues = $wpdb->prepare(
                                'SELECT COUNT( DISTINCT postid )
                                FROM %i
                                WHERE siteid = %d
                                AND postid NOT IN (
                                          SELECT postid
                                          FROM %i
                                          WHERE ignre=0 AND ignre_global=0
                                )',
                                [ $ac_table_name, $siteid, $ac_table_name ]
                        );

                        // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Using direct query for adding data to database, caching not required for one time operation.
                        $data['posts_without_issues'] = $wpdb->get_var( $posts_without_issues ) + $wpdb->get_var( $posts_with_just_ignored_issues );
                        $data['avg_issues_per_post']  = round( ( $data['warnings'] + $data['errors'] ) / $data['posts_scanned'], 2 );

                        // Show "< 1" only when there are issues but the average is less than 1 (excluding exactly 0).
                        if ( $data['avg_issues_per_post'] < 1 && $data['avg_issues_per_post'] > 0 ) {
                                $data['avg_issues_per_post'] = '< 1';
                        }
                }

                // Average issue density percentage is the sum of all post densities divided by the number of posts scanned.
                $data['avg_issue_density_percentage'] =
                        $wpdb->get_var( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Using direct query for adding data to database, caching not required for one time operation.
                                $wpdb->prepare(
                                        'SELECT AVG(meta_value)
                                        FROM ' . $wpdb->postmeta . '
                                        JOIN (
                                                SELECT DISTINCT postid
                                                FROM ' . $wpdb->prefix . 'accessibility_checker
                                                WHERE ignre=%d AND ignre_global=%d
                                        ) AS distinct_posts ON ' . $wpdb->postmeta . '.post_id = distinct_posts.postid
                                        WHERE meta_key = %s',
                                        [ 0, 0, '_edac_issue_density' ]
                                )
                        );

                if ( null === $data['avg_issue_density_percentage'] ) {
                        $data['avg_issue_density_percentage'] = 'N/A';
                } else {
                        $data['avg_issue_density_percentage'] = round( $data['avg_issue_density_percentage'], 2 );
                }

                $data['fullscan_running']      = false;
                $data['fullscan_state']        = '';
                $data['fullscan_completed_at'] = 0;

                // For back compat reasons the old class_exists is kept and moved to an else block.
                // After a few releases the else should be removed.
                if ( class_exists( '\EqualizeDigital\AccessibilityCheckerPro\Admin\Scans' ) ) {
                        $scans      = new Scans();
                        $scan_state = $scans->scan_state();

                        $data['fullscan_state'] = $scan_state;
                        if ( Scans::SCAN_STATE_PHP_SCAN_RUNNING === $scan_state
                                || Scans::SCAN_STATE_JS_SCAN_RUNNING === $scan_state
                        ) {
                                $data['fullscan_running'] = true;
                        }
                        $data['fullscan_completed_at'] = $scans->scan_date( 'php' );
                } elseif ( class_exists( '\EDACP\Scans' ) ) {
                        $scans      = new \EDACP\Scans();
                        $scan_state = $scans->scan_state();

                        $data['fullscan_state'] = $scan_state;
                        if ( \EDACP\Scans::SCAN_STATE_PHP_SCAN_RUNNING === $scan_state
                                || \EDACP\Scans::SCAN_STATE_JS_SCAN_RUNNING === $scan_state
                        ) {
                                $data['fullscan_running'] = true;
                        }
                        $data['fullscan_completed_at'] = $scans->scan_date( 'php' );

                }

                // Get top 5 posts with issues.
                $data['top_pages_with_issues']    = $this->get_top_pages_with_issues( 5 );
                $data['top_issues_found_on_site'] = $this->get_top_issues_found_on_site( 10 );

                $data['cache_id']   = $transient_name;
                $data['cached_at']  = time();
                $data['expires_at'] = time() + $this->cache_time;
                $data['cache_hit']  = false;

                // Handle formatting. Assumes all are numbers except for those listed in exceptions.
                $formatting            = [];
                $formatting_exceptions = [
                        'is_truncated',
                        'passed_percentage',
                        'avg_issue_density_percentage',
                        'fullscan_running',
                        'fullscan_state',
                        'fullscan_completed_at',
                        'cache_id',
                        'cached_at',
                        'expires_at',
                        'cache_hit',
                        'top_pages_with_issues',
                ];

                foreach ( $data as $key => $value ) {
                        if ( ! in_array( $key, $formatting_exceptions, true ) ) {
                                $formatting[ $key . '_formatted' ] = Helpers::format_number( $value );
                        }
                }

                // Handle exceptions.
                $formatting['fullscan_completed_at_formatted'] = 'N/A';
                if ( $data['fullscan_completed_at'] > 0 ) {
                        $formatting['fullscan_completed_at_formatted'] = Helpers::format_date( $data['fullscan_completed_at'], true );
                }
                $formatting['passed_percentage_formatted'] = Helpers::format_percentage( $data['passed_percentage'] );

                // The density should already a percentage value, just add the sign. If not an integer, just return the value which will be 'N/A'.
                $formatting['avg_issue_density_percentage_formatted'] = is_int( $data['avg_issue_density_percentage'] ) ? $data['avg_issue_density_percentage'] . '%' : $data['avg_issue_density_percentage'];

                $formatting['cached_at_formatted'] = Helpers::format_date( $data['cached_at'], true );

                $data = array_merge( $data, $formatting );

                if ( $data['posts_scanned'] > 0 ) {
                        set_transient( $transient_name, $data, $this->cache_time );
                } else {
                        // no posts have been scanned, so clear any previously cache results.
                        $this->clear_cache();
                }

                return $data;
        }

        /**
         * Gets issues summary information about a post type
         *
         * @param  string $post_type post type.
         * @return array .
         */
        public function issues_summary_by_post_type( $post_type ) {

                $transient_name = $this->cache_name_prefix . '_issues_summary_by_post_type_' . $post_type;

                $cache = get_transient( $transient_name );

                if ( $this->cache_time && $cache ) {

                        if ( $cache['expires_at'] >= time() && $cache['cached_at'] + $this->cache_time >= time()
                        ) {

                                $full_scan_completed_at = (int) get_option( 'edacp_fullscan_completed_at' );
                                if ( $full_scan_completed_at <= $cache['cached_at'] ) {
                                        // There hasn't been a full scan completed since we've cached, so return these results.
                                        $cache['cache_hit'] = true;
                                        return $cache;
                                }
                        }
                }

                $data = [];

                $error_issues_query      = new Issues_Query(
                        [
                                'rule_types' => [ Issues_Query::RULETYPE_ERROR ],
                                'post_types' => [ $post_type ],
                        ],
                        $this->record_limit
                );
                $data['errors']          = $error_issues_query->count();
                $data['distinct_errors'] = $error_issues_query->distinct_count();

                $warning_issues_query      = new Issues_Query(
                        [
                                'rule_types' => [ Issues_Query::RULETYPE_WARNING ],
                                'post_types' => [ $post_type ],
                        ],
                        $this->record_limit
                );
                $data['warnings']          = $warning_issues_query->count();
                $data['distinct_warnings'] = $warning_issues_query->distinct_count();

                $color_contrast_issues_query      = new Issues_Query(
                        [
                                'rule_types' => [ Issues_Query::RULETYPE_COLOR_CONTRAST ],
                                'post_types' => [ $post_type ],
                        ],
                        $this->record_limit
                );
                $data['contrast_errors']          = $color_contrast_issues_query->count();
                $data['distinct_contrast_errors'] = $color_contrast_issues_query->distinct_count();

                $data['errors_without_contrast']          = $data['errors'] - $data['contrast_errors'];
                $data['distinct_errors_without_contrast'] = $data['distinct_errors'] - $data['distinct_contrast_errors'];

                foreach ( $data as $key => $val ) {
                        $data[ $key . '_formatted' ] = Helpers::format_number( $val );
                }

                $data['cache_id']   = $transient_name;
                $data['cached_at']  = time();
                $data['expires_at'] = time() + $this->cache_time;
                $data['cache_hit']  = false;

                set_transient( $transient_name, $data, $this->cache_time );

                return $data;
        }

        /**
         * Get top N posts with the most issues.
         *
         * @param int $limit Number of posts to return (default 5).
         * @return array Array of arrays with post_title, post_url, and issue_count.
         */
        private function get_top_pages_with_issues( int $limit = 5 ) {
                global $wpdb;

                $limit = max( 0, $limit );
                if ( 0 === $limit ) {
                        return [];
                }

                $ac_table_name = $wpdb->prefix . 'accessibility_checker';
                $siteid        = get_current_blog_id();

                // Get scannable post types and statuses to match site scope.
                $post_types    = Settings::get_scannable_post_types();
                $post_statuses = Settings::get_scannable_post_statuses();

                // Return empty array if no scannable content is configured.
                if ( empty( $post_types ) || empty( $post_statuses ) ) {
                        return [];
                }

                // Build SQL-safe lists for IN clauses (these are sanitized by the helper).
                $post_types_list    = Helpers::array_to_sql_safe_list( $post_types );
                $post_statuses_list = Helpers::array_to_sql_safe_list( $post_statuses );

                // Build the SQL query with siteid and post filters.
                // phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- post_types_list and post_statuses_list are sanitized by Helpers::array_to_sql_safe_list().
                $sql = $wpdb->prepare(
                        "SELECT %i.ID, %i.post_title, COUNT(%i.id) as issue_count
                        FROM %i
                        INNER JOIN %i ON %i.ID = %i.postid
                        WHERE %i.siteid = %d
                        AND %i.ignre = 0
                        AND %i.ignre_global = 0
                        AND %i.post_type IN({$post_types_list})
                        AND %i.post_status IN({$post_statuses_list})
                        GROUP BY %i.ID
                        ORDER BY issue_count DESC
                        LIMIT %d",
                        $wpdb->posts,
                        $wpdb->posts,
                        $ac_table_name,
                        $wpdb->posts,
                        $ac_table_name,
                        $wpdb->posts,
                        $ac_table_name,
                        $ac_table_name,
                        $siteid,
                        $ac_table_name,
                        $ac_table_name,
                        $wpdb->posts,
                        $wpdb->posts,
                        $wpdb->posts,
                        $limit
                );
                // phpcs:enable WordPress.DB.PreparedSQL.InterpolatedNotPrepared

                // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.NotPrepared -- Direct query for stats calculation, SQL is prepared above.
                $posts = $wpdb->get_results( $sql );

                $result = [];
                if ( $posts ) {
                        foreach ( $posts as $post ) {
                                $result[] = [
                                        'post_title'  => esc_html( $post->post_title ),
                                        'post_url'    => esc_url( get_permalink( $post->ID ) ),
                                        'issue_count' => (int) $post->issue_count,
                                ];
                        }
                }

                return $result;
        }

        /**
         * Get top N issues found on the site.
         *
         * @param int $limit Number of issues to return (default 10).
         * @return array Array of arrays with rule_slug and issue_count.
         */
        private function get_top_issues_found_on_site( int $limit = 10 ) {
                global $wpdb;

                $limit = max( 0, $limit );
                if ( 0 === $limit ) {
                        return [];
                }

                $ac_table_name = $wpdb->prefix . 'accessibility_checker';
                $siteid        = get_current_blog_id();

                $rules_raw     = edac_register_rules();
                $rules_parsed  = [];
                $severity_case = '0';

                foreach ( $rules_raw as $rule ) {
                        if ( ! isset( $rule['slug'] ) ) {
                                continue;
                        }

                        $slug                  = (string) $rule['slug'];
                        $rules_parsed[ $slug ] = $rule;
                        $severity              = isset( $rule['severity'] ) ? (int) $rule['severity'] : 0;
                        $severity_case        .= $wpdb->prepare( ' + (CASE WHEN rule = %s THEN %d ELSE 0 END)', $slug, $severity );
                }

                // Build the SQL query to get top issues by severity, then count.
                // phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared -- No user input, and table name is properly escaped, severity cases is prepared above.
                $sql = $wpdb->prepare(
                        'SELECT rule, COUNT(id) AS issue_count, (' . $severity_case . ') AS severity
                        FROM %i
                        WHERE siteid = %d
                        AND ignre = 0
                        AND ignre_global = 0
                        GROUP BY rule
                        ORDER BY severity DESC, issue_count DESC, rule ASC
                        LIMIT %d',
                        $ac_table_name,
                        $siteid,
                        $limit
                );
                // phpcs:enable WordPress.DB.PreparedSQL.InterpolatedNotPrepared

                // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.NotPrepared -- Direct query for stats calculation, SQL is prepared above.
                $issues = $wpdb->get_results( $sql );

                if ( ! $issues ) {
                        return [];
                }

                return array_map(
                        function ( $issue ) use ( $rules_parsed ) {
                                $rule = $rules_parsed[ $issue->rule ] ?? [];

                                return [
                                        'rule_nicename' => sanitize_text_field( $rule['title'] ?? $issue->rule ),
                                        'rule_slug'     => sanitize_text_field( $rule['slug'] ?? $issue->rule ),
                                        'issue_count'   => (int) $issue->issue_count,
                                        'severity'      => isset( $rule['severity'] ) ? (int) $rule['severity'] : (int) $issue->severity,
                                ];
                        },
                        $issues
                );
        }
}

equalizedigital / accessibility-checker / 24683125413

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous