Controllers/SimfileController.php

   1 <?php
   2
   3 namespace Controllers;
   4
   5 use Controllers\IDivineController;
   6 use Services\Http\IHttpResponse;
   7 use Services\Uploads\IUploadManager;
   8 use Services\IUserSession;
   9 use Services\IZipParser;
  10 use Services\ISMOMatcher;
  11 use DataAccess\StepMania\ISimfileRepository;
  12 use DataAccess\StepMania\IPackRepository;
  13 use DataAccess\IFileRepository;
  14 use Domain\Entities\StepMania\ISimfile;
  15 use Domain\Entities\IFile;
  16 use Domain\Util;
  17
  18 class SimfileController implements IDivineController
  19 {
  20     private $_simfileRepository;
  21     private $_packRepository;
  22     private $_fileRepository;
  23     private $_response;
  24     private $_uploadManager;
  25     private $_zipParser;
  26     private $_smoMatcher;
  27
  28     public function __construct(
  29         IHttpResponse $response,
  30         IUploadManager $uploadManager,
  31         ISimfileRepository $simfileRepository,
  32         IPackRepository $packRepository,
  33         IFileRepository $fileRepository,
  34         IUserSession $userSession,
  35         IZipParser $zipParser,
  36         ISMOMatcher $smoMatcher
  37     ) {
  38         $this->_response = $response;
  39         $this->_uploadManager = $uploadManager;
  40         $this->_simfileRepository = $simfileRepository;
  41         $this->_packRepository = $packRepository;
  42         $this->_fileRepository = $fileRepository;
  43         $this->_zipParser = $zipParser;
  44         $this->_smoMatcher = $smoMatcher;
  45     }
  46
  47     public function indexAction() {
  48         ;
  49     }
  50
  51     // list simfiles
  52     public function listAction()
  53     {
  54         /* @var $simfile Domain\Entities\StepMania\ISimfile */
  55         $simfiles = $this->_simfileRepository->findAll();
  56         $packs = $this->_packRepository->findAll();
  57         $simfileArray = array();
  58         $packArray = array();
  59
  60         foreach($simfiles as $simfile)
  61         {
  62             $simfileArray[] = $this->simfileToArray($simfile);
  63         }
  64
  65         foreach($packs as $pack)
  66         {
  67             $packSimfiles = array();
  68             foreach($pack->getSimfiles() as $simfile)
  69             {
  70                 $packSimfiles[] = $this->simfileToArray($simfile);
  71             }
  72
  73             $packMirrors = array();
  74
  75             if($pack->getFile())
  76             {
  77                 $packMirrors[] = array('source' => 'DivinElegy', 'uri' => 'files/pack/' . $pack->getFile()->getHash());
  78             }
  79
  80             if($pack->getFile()->getMirrors())
  81             {
  82                 foreach($pack->getFile()->getMirrors() as $mirror)
  83                 {
  84                     $packMirrors[] = array('source' => $mirror->getSource(), 'uri' => $mirror->getUri());
  85                 }
  86             }
  87
  88             $packArray[] = array(
  89                 'title'=> $pack->getTitle(),
  90                 'contributors' => $pack->getContributors(),
  91                 'simfiles' => $packSimfiles,
  92                 'banner' => $pack->getBanner() ? 'files/banner/' . $pack->getBanner()->getHash() : 'files/banner/default',
  93                 'mirrors' => $packMirrors,
  94                 'size' => $pack->getFile() ? Util::bytesToHumanReadable($pack->getFile()->getSize()) : null
  95             );
  96         }
  97
  98         $returnArray = array('simfiles' => $simfileArray, 'packs' => $packArray);
  99
 100         $this->_response->setHeader('Content-Type', 'application/json')
 101                         ->setBody(json_encode($returnArray))
 102                         ->sendResponse();
 103     }
 104
 105     public function uploadAction()
 106     {
 107         //TODO: Put directory in config ?
 108         $files = $this->_uploadManager->setFilesDirectory('../files')
 109                                       ->setDestination('StepMania/')
 110                                       ->process();
 111
 112         foreach($files as $file)
 113         {
 114             $zipParser = $this->_zipParser;
 115             $zipParser->parse($file);
 116
 117             //save the actual zip in the db
 118             $this->findAndAddSmoMirror($file);
 119             $this->_fileRepository->save($file);
 120
 121             if($zipParser->isPack())
 122             {
 123                 //XXX: Tricky! pack() uses packbuilder and so returns a new pack each time.
 124                 //I tried to be clever and call pack() multiple times thinking I was getting the same
 125                 //object. Should I cache it in zipparser?
 126                 $pack = $zipParser->pack();
 127                 $packBanner = $pack->getBanner() ? $this->_fileRepository->save($pack->getBanner()) : null;
 128                 $this->_packRepository->save($pack);
 129             }
 130
 131             foreach($zipParser->simfiles() as $simfile)
 132             {
 133                 $banner = $simfile->getBanner() ? $this->_fileRepository->save($simfile->getBanner()) : null;
 134                 $simfileZip = $simfile->getSimfile() ? $this->_fileRepository->save($simfile->getSimfile()) : null;
 135
 136                 if(isset($pack)) $simfile->addToPack($pack);
 137                 $this->_simfileRepository->save($simfile);
 138             }
 139         }
 140     }
 141
 142     private function findAndAddSmoMirror(IFile $file)
 143     {
 144         $basename = pathinfo($file->getFilename(), PATHINFO_FILENAME);
 145         $match = $this->_smoMatcher->match($basename, $file->getSize());
 146
 147         //XXX: Direct instantiation of FileMirror bad?
 148         if($match && $match['confidence'] > 90)
 149         {
 150             $file->addMirror(new \Domain\VOs\FileMirror($match['href'], 'Stepmania Online'));
 151         }
 152     }
 153
 154     private function simfileToArray(ISimfile $simfile)
 155     {
 156         $singleSteps = array();
 157         $doubleSteps = array();
 158
 159         foreach($simfile->getSteps() as $steps)
 160         {
 161             $stepDetails = array(
 162                 'artist' => $steps->getArtist()->getTag(),
 163                 'difficulty' => $steps->getDifficulty()->getITGName(),
 164                 'rating' => $steps->getRating()
 165             );
 166
 167             if($steps->getMode()->getPrettyName() == 'Single')
 168             {
 169                 $singleSteps[] = $stepDetails;
 170             } else {
 171                 $doubleSteps[] = $stepDetails;
 172             }
 173         }
 174
 175         return array(
 176             'title' => $simfile->getTitle(),
 177             'artist' => $simfile->getArtist()->getName(),
 178             'steps' => array(
 179                 'single' => $singleSteps,
 180                 'double' => $doubleSteps
 181             ),
 182             'bgChanges' => $simfile->hasBgChanges() ? 'Yes' : 'No',
 183             'fgChanges' => $simfile->hasFgChanges() ? 'Yes' : 'No',
 184             'bpmChanges' => $simfile->hasBPMChanges() ? 'Yes' : 'No',
 185             'banner' => $simfile->getBanner() ? 'files/banner/' . $simfile->getBanner()->getHash() : 'files/banner/default',
 186             'download' => $simfile->getSimfile() ?  'files/simfile/' . $simfile->getSimfile()->getHash() : null,
 187             'size' => $simfile->getSimfile() ? Util::bytesToHumanReadable($simfile->getSimfile()->getSize()) : null
 188         );
 189     }
 190 }