KI\PonthubBundle\Helper\GlobalStatisticsHelper

Complexity

Total Complexity

30

Size/Duplication

Total Lines	290
Duplicated Lines	9.66 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	getGlobalDownloaders()	0	58	9
A	getGlobalDownloads()	0	31	2
A	getTotalDownloads()	0	9	1
A	getDownloads()	0	13	2
A	getGlobalPonthub()	0	20	1
A	getTotal()	0	9	2
B	getGlobalYears()	28	58	9
A	getGlobalTimeline()	0	35	3

<?php

namespace KI\PonthubBundle\Helper;

use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityRepository;
use KI\PonthubBundle\Entity\Episode;
use KI\PonthubBundle\Entity\Game;
use KI\PonthubBundle\Entity\Movie;
use KI\PonthubBundle\Entity\Other;
use KI\PonthubBundle\Entity\Software;

class GlobalStatisticsHelper
{
    protected $manager;
    protected $ponthubFileRepository;
    protected $ponthubFileUserRepository;

    public function __construct(EntityManager $manager, EntityRepository $ponthubFileRepository, EntityRepository $ponthubFileUserRepository)

You have injected the EntityManager via parameter $manager. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via getManager() each time you need it.

    {
        $this->manager                   = $manager;
        $this->ponthubFileRepository     = $ponthubFileRepository;
        $this->ponthubFileUserRepository = $ponthubFileUserRepository;
    }

    /**
     * Hall of fame (histogramme) des plus gros downloaders
     * @return array
     */
    public function getGlobalDownloaders()
    {
        // Recherche des plus gros downloaders
        $downloaderIds = $this->manager->createQuery('SELECT IDENTITY(e.user), SUM(f.size) AS compte
              FROM KI\PonthubBundle\Entity\PonthubFileUser e
              LEFT JOIN e.file f
              GROUP BY e.user
              ORDER BY compte DESC'
            )
            ->setMaxResults(10)
            ->getResult();

        // On regarde les détails sur chaque utilisateur
        $downloaderCategories = [];
        $downloaderSeries = [
            ['name' => 'Films',     'data' => []],
            ['name' => 'Séries',    'data' => []],
            ['name' => 'Jeux',      'data' => []],
            ['name' => 'Logiciels', 'data' => []],
            ['name' => 'Autres',    'data' => []]
        ];

        foreach ($downloaderIds as $key => $value) {
            $downloads = $this->ponthubFileUserRepository->findBy(['user' => $value[1]]);

            $user = $downloads[0]->getUser();
            $downloaderCategories[] = $user->getFirstName().' '.$user->getLastName();
            for ($i = 0; $i < 6; $i++) {
                $downloaderSeries[$i]['data'][] = 0;
            }

            foreach ($downloads as $download) {
                $file = $download->getFile();
                $size = round($file->getSize()/(1000*1000*1000), 5);

                if ($file instanceof Movie) {
                    $downloaderSeries[0]['data'][$key] += $size;
                }
                if ($file instanceof Episode) {
                    $downloaderSeries[1]['data'][$key] += $size;
                }
                if ($file instanceof Game) {
                    $downloaderSeries[3]['data'][$key] += $size;
                }
                if ($file instanceof Software) {
                    $downloaderSeries[4]['data'][$key] += $size;
                }
                if ($file instanceof Other) {
                    $downloaderSeries[5]['data'][$key] += $size;
                }
            }
        }

        return [
            'categories' => $downloaderCategories,
            'series'     => $downloaderSeries
        ];
    }

    /**
     * Fichiers les plus téléchargés (avec drilldown)
     * @return array
     */
    public function getGlobalDownloads()
    {
        // Recherche des fichiers les plus téléchargés
        $downloadSerie = [
            ['name' => 'Films', 'drilldown' => 1, 'y' => $this->getTotalDownloads('movie')],
            ['name' => 'Séries', 'drilldown' => 2, 'y' => $this->getTotalDownloads('episode')],
            ['name' => 'Jeux', 'drilldown' => 3, 'y' => $this->getTotalDownloads('game')],
            ['name' => 'Logiciels', 'drilldown' => 4, 'y' => $this->getTotalDownloads('software')],
            ['name' => 'Autres', 'drilldown' => 5, 'y' => $this->getTotalDownloads('other')]
        ];

        // Tri par ordre des downloads totaux
        $total = [];
        foreach ($downloadSerie as $key => $row) {
            $total[$key] = $row['y'];
        }
        array_multisort($total, SORT_DESC, $downloadSerie);

        $downloadDrilldown = [
            ['name' => 'Films', 'id' => 1, 'data' => $this->getDownloads('movie')],
            ['name' => 'Séries', 'id' => 2, 'data' => $this->getDownloads('episode')],
            ['name' => 'Jeux', 'id' => 3, 'data' => $this->getDownloads('game')],
            ['name' => 'Logiciels', 'id' => 4, 'data' => $this->getDownloads('software')],
            ['name' => 'Autres', 'id' => 5, 'data' => $this->getDownloads('other')]
        ];

        return [
            'serie' => $downloadSerie,
            'drilldown' => $downloadDrilldown
        ];
    }

    /**
     * Renvoie le nombre total de fichiers par catégorie
     * @param  string $category
     * @return integer
     */
    private function getTotalDownloads($category) {
        $connection = $this->manager->getConnection();
        $statement = $connection->prepare('SELECT COUNT(*) AS compte FROM PonthubFileUser LEFT JOIN Likeable ON Likeable.id = PonthubFileUser.file_id WHERE Likeable.type = :category');
        $statement->bindValue('category', $category);
        $statement->execute();
        $results = $statement->fetchAll();

        return (int)$results[0]['compte'];
    }

    /**
     * Renvoie les fichiers les plus téléchargés pour une categorie
     * @param  string $category
     * @return array
     */
    private function getDownloads($category) {
        $connection = $this->manager->getConnection();
        $statement = $connection->prepare('SELECT Likeable.name, COUNT(*) AS compte FROM PonthubFileUser LEFT JOIN Likeable ON Likeable.id = PonthubFileUser.file_id WHERE Likeable.type = :category GROUP BY PonthubFileUser.file_id ORDER BY compte DESC LIMIT 10');
        $statement->bindValue('category', $category);
        $statement->execute();
        $results = $statement->fetchAll();

        $return = [];
        foreach ($results as $result) {
            $return[] = [$result['name'], (int)$result['compte']];
        }
        return $return;
    }

    /**
     * Répartition des fichiers dans tous le catalogue
     * @return array
     */
    public function getGlobalPonthub()
    {
        // Construction de la tree map résumant les fichiers dispos sur Ponthub
        return [
            'Nombre de fichiers dispos' => [
                'Films' => $this->getTotal('Movie'),
                'Séries' => $this->getTotal('Episode'),
                'Jeux' => $this->getTotal('Game'),
                'Logiciels' => $this->getTotal('Software'),
                'Autres' => $this->getTotal('Other')
            ],
            'Volume de fichiers (Go)' => [
                'Films' => $this->getTotal('Movie', true),
                'Séries' => $this->getTotal('Episode', true),
                'Jeux' => $this->getTotal('Game', true),
                'Logiciels' => $this->getTotal('Software', true),
                'Autres' => $this->getTotal('Other', true)
            ]
        ];
    }

    /**
     * Retourne un total selon une catégorie de fichiers
     * @param  string  $category
     * @param  boolean $size     Si true, renvoie la taille totale, sinon le nombre total
     * @return integer
     */
    private function getTotal($category, $size = false) {
        if ($size) {
            $dql = 'SELECT SUM(e.size) FROM KI\PonthubBundle\Entity\\'.$category.' e';

'SELECT SUM(e.size) FROM KI\\PonthubBundle\\Entity\\' . $category . ' e' is used as a query on line 193. If $category can contain user-input, it is usually preferable to use a parameter placeholder like :paramName and pass the dynamic input via setParameter.

            return $this->manager->createQuery($dql)->getSingleScalarResult()/(1000*1000*1000);
        } else {
            $dql = 'SELECT COUNT(e.id) FROM KI\PonthubBundle\Entity\\'.$category.' e';

'SELECT COUNT(e.id) FROM KI\\PonthubBundle\\Entity\\' . $category . ' e' is used as a query on line 196. If $category can contain user-input, it is usually preferable to use a parameter placeholder like :paramName and pass the dynamic input via setParameter.

            return $this->manager->createQuery($dql)->getSingleScalarResult();
        }
    }

    /**
     * Histo en barres horizontales de répartition par années
     * @return array
     */
    public function getGlobalYears()
    {
        // Construction de l'arbre des années des films/jeux dispos
        $dql = 'SELECT e.year, COUNT(e.id) FROM KI\PonthubBundle\Entity\Movie e GROUP BY e.year';
        $movieYears = $this->manager->createQuery($dql)->getResult();
        $dql = 'SELECT e.year, COUNT(e.id) FROM KI\PonthubBundle\Entity\Game e GROUP BY e.year';
        $gameYears = $this->manager->createQuery($dql)->getResult();

        $yearCategories = [];
        $yearSeries = [
            ['name' => 'Films', 'data' => []],
            ['name' => 'Jeux', 'data' => []]
        ];

        // On rajoute l'année dans les catégories si elle n'y est pas déjà
        foreach ($movieYears as $key => $value) {
            if (!in_array((int)$value['year'], $yearCategories)) {
                $yearCategories[] = $value['year'];
                $yearSeries[0]['data'][] = 0;
                $yearSeries[1]['data'][] = 0;
            }
        }
        foreach ($gameYears as $key => $value) {
            if (!in_array((int)$value['year'], $yearCategories)) {
                $yearCategories[] = $value['year'];
                $yearSeries[0]['data'][] = 0;
                $yearSeries[1]['data'][] = 0;
            }
        }

        // On ordonne les années
        sort($yearCategories);

        // On répartit les entrées
        $maxPopMovie = 0;
        $maxPopGame = 0;
        foreach ($movieYears as $key => $value) {
            $id = array_search((int)$value['year'], $yearCategories);
            $yearSeries[0]['data'][$id] = -$value[1];

            if ($value[1] > $maxPopMovie)
                $maxPopMovie = (int)$value[1];
        }
        foreach ($gameYears as $key => $value) {
            $id = array_search((int)$value['year'], $yearCategories);
            $yearSeries[1]['data'][$id] = (int)$value[1];

            if ($value[1] > $maxPopGame)
                $maxPopGame = (int)$value[1];
        }

        return [
            'categories' => $yearCategories,
            'series' => $yearSeries,
            'min' => -$maxPopMovie,
            'max' => $maxPopGame
        ];
    }

    /**
     * Timeline avec camembert par promo et moyenne
     * @return array
     */
    public function getGlobalTimeline()
    {
        // Timeline répartition par promos par mois
        $dql = 'SELECT u.promo, MONTH(e.date) AS mois, SUM(f.size) AS taille
                FROM KI\PonthubBundle\Entity\PonthubFileUser e
                LEFT JOIN e.file f LEFT JOIN e.user u
                WHERE u.promo = \'016\' OR u.promo = \'017\' OR u.promo = \'018\' OR u.promo = \'019\'
                GROUP BY mois, u.promo';
        $results = $this->manager->createQuery($dql)->getResult();

        $timeline = [
            'promo016' => [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            'promo017' => [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            'promo018' => [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            'promo019' => [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            'average' => [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            'pie' => [
                'promo016' => 0,
                'promo017' => 0,
                'promo018' => 0,
                'promo019' => 0,
            ]
        ];
        // On répartit les données dans les tableaux suivants
        foreach ($results as $result) {
            $size = round($result['taille']/(1000*1000*1000), 1);
            $timeline['promo'.$result['promo']][$result['mois'] - 1] += $size;
            $timeline['pie']['promo'.$result['promo']] += $size;
        }
        // On calcule les moyennes
        for ($i = 0; $i < 12; $i++) {
            $timeline['average'][$i] = round(($timeline['promo016'][$i] + $timeline['promo017'][$i] + $timeline['promo018'][$i] + $timeline['promo019'][$i])/4, 1);
        }
        return $timeline;
    }
}