vanilla-application-yaga/controllers/class.yagacontroller.php

<?php if(!defined('APPLICATION')) exit();
/* Copyright 2013 Zachary Doll */

/**
 * Manage the yaga application including configuration and import/export
 *
 * @since 1.0
 * @package Yaga
 */
class YagaController extends DashboardController {

  /**
   * @var array These objects will be created on instantiation and available via
   * $this->ObjectName
   */
  public $Uses = array('Form');

  /**
   * Make this look like a dashboard page and add the resources
   *
   * @since 1.0
   * @access public
   */
  public function Initialize() {
    parent::Initialize();
    $this->Application = 'Yaga';
    Gdn_Theme::Section('Dashboard');
    if($this->Menu) {
      $this->Menu->HighlightRoute('/yaga');
    }
    $this->AddSideMenu('yaga/settings');

    $this->AddCssFile('yaga.css');
  }

  /**
   * Redirect to settings by default
   */
  public function Index() {
    $this->Settings();
  }

  /**
   * This handles all the core settings for the gamification application.
   */
  public function Settings() {
    $this->Permission('Garden.Settings.Manage');
    $this->Title(T('Yaga.Settings'));

    // Get list of actions from the model and pass to the view
    $ConfigModule = new ConfigurationModule($this);

    $ConfigModule->Initialize(array(
        'Yaga.Reactions.Enabled' => array(
            'LabelCode' => 'Yaga.Reactions.Use',
            'Control' => 'Checkbox'
        ),
        'Yaga.Badges.Enabled' => array(
            'LabelCode' => 'Yaga.Badges.Use',
            'Control' => 'Checkbox'
        ),
        'Yaga.Ranks.Enabled' => array(
            'LabelCode' => 'Yaga.Ranks.Use',
            'Control' => 'Checkbox'
        ),
        'Yaga.LeaderBoard.Enabled' => array(
            'LabelCode' => 'Yaga.LeaderBoard.Use',
            'Control' => 'Checkbox'
        ),
        'Yaga.LeaderBoard.Limit' => array(
            'LabelCode' => 'Yaga.LeaderBoard.Max',
            'Control' => 'Textbox',
            'Options' => array(
                'Size' => 45,
                'class' => 'SmallInput'
            )
        )
    ));
    $this->ConfigurationModule = $ConfigModule;

    $this->Render();
  }

  /**
   * Import a Yaga transport file
   */
  public function Import() {
    $this->Title(T('Yaga.Import'));
    $this->SetData('TransportType', 'Import');
    
    if(!class_exists('ZipArchive')) {
      $this->Form->AddError(T('Yaga.Error.TransportRequirements'));
    }
    
    if($this->Form->IsPostBack() == TRUE) {
      // Handle the file upload
      $Upload = new Gdn_Upload();
      $TmpZip = $Upload->ValidateUpload('FileUpload', FALSE);

      $ZipFile = FALSE;
      if($TmpZip) {
        // Generate the target name
        $TargetFile = $Upload->GenerateTargetName(PATH_UPLOADS, 'zip');
        $BaseName = pathinfo($TargetFile, PATHINFO_BASENAME);

        // Save the uploaded zip
        $Parts = $Upload->SaveAs($TmpZip, $BaseName);
        $ZipFile = PATH_UPLOADS . DS . $Parts['SaveName'];
        $this->SetData('TransportPath', $ZipFile);
      }

      $Include = $this->_FindIncludes();
      if(count($Include)) {
        $Info = $this->_ExtractZip($ZipFile);
        $this->_ImportData($Info, $Include);
        Gdn_FileSystem::RemoveFolder(PATH_UPLOADS . DS . 'import' . DS . 'yaga');
      }
      else {
        $this->Form->AddError(T('Yaga.Error.Includes'));
      }
    }
    
    if($this->Form->ErrorCount() == 0 && $this->Form->IsPostBack()) {
      $this->Render('transport-success');
    }
    else {
      $this->Render();
    }
  }

  /**
   * Create a Yaga transport file
   */
  public function Export() {
    $this->Title(T('Yaga.Export'));
    $this->SetData('TransportType', 'Export');

    if(!class_exists('ZipArchive')) {
      $this->Form->AddError(T('Yaga.Error.TransportRequirements'));
    }

    if($this->Form->IsPostBack()) {
      $Include = $this->_FindIncludes();
      if(count($Include)) {
        $Filename = $this->_ExportData($Include);
        $this->SetData('TransportPath', $Filename);
      }
      else {
        $this->Form->AddError(T('Yaga.Error.Includes'));
      }
    }

    if($this->Form->ErrorCount() == 0 && $this->Form->IsPostBack()) {
      $this->Render('transport-success');
    }
    else {
      $this->Render();
    }
  }

  /**
   * This searches through the submitted checkboxes and constructs an array of
   * Yaga sections to be included in the transport file.
   * 
   * @return array
   */
  protected function _FindIncludes() {
    $FormValues = $this->Form->FormValues();
    $Sections = $FormValues['Checkboxes'];

    // Figure out which boxes were checked
    $Include = array();
    foreach($Sections as $Section) {
      $Include[$Section] = $FormValues[$Section];
    }
    return $Include;
  }
  
  /**
   * Creates a transport file for easily transferring Yaga configurations across
   * installs
   *
   * @param array An array containing the config areas to transfer
   * @param string Where to save the transport file
   * @return mixed False on failure, the path to the transport file on success
   */
  protected function _ExportData($Include = array(), $Path = NULL) {
    $StartTime = microtime(TRUE);
    $Info = new stdClass();
    $Info->Version = C('Yaga.Version', '?.?');
    $Info->StartDate = date('Y-m-d H:i:s');

    if(is_null($Path)) {
      $Path = PATH_UPLOADS . DS . 'export' . date('Y-m-d-His') . '.yaga.zip';
    }
    $FH = new ZipArchive();
    $Images = array();
    $Hashes = array();

    if($FH->open($Path, ZipArchive::CREATE) !== TRUE) {
      $this->Form->AddError(sprintf(T('Yaga.Error.ArchiveCreate'), $FH->getStatusString()));
      return FALSE;
    }

    // Add configuration items
    $Info->Config = 'configs.yaga';
    $Configs = Gdn::Config('Yaga', array());
    unset($Configs['Version']);
    $ConfigData = serialize($Configs);
    $FH->addFromString('configs.yaga', $ConfigData);
    $Hashes[] = md5($ConfigData);
    
    // Add actions
    if($Include['Action']) {
      $Info->Action = 'actions.yaga';
      $Actions = Yaga::ActionModel()->Get('Sort', 'asc');
      $this->SetData('ActionCount', count($Actions));
      $ActionData = serialize($Actions);
      $FH->addFromString('actions.yaga', $ActionData);
      $Hashes[] = md5($ActionData);
    }

    // Add ranks and associated image
    if($Include['Rank']) {
      $Info->Rank = 'ranks.yaga';
      $Ranks = Yaga::RankModel()->Get('Level', 'asc');
      $this->SetData('RankCount', count($Ranks));
      $RankData = serialize($Ranks);
      $FH->addFromString('ranks.yaga', $RankData);
      array_push($Images, C('Yaga.Ranks.Photo'), NULL);
      $Hashes[] = md5($RankData);
    }

    // Add badges and associated images
    if($Include['Badge']) {
      $Info->Badge = 'badges.yaga';
      $Badges = Yaga::BadgeModel()->Get();
      $this->SetData('BadgeCount', count($Badges));
      $BadgeData = serialize($Badges);
      $FH->addFromString('badges.yaga', $BadgeData);
      $Hashes[] = md5($BadgeData);
      foreach($Badges as $Badge) {
        array_push($Images, $Badge->Photo);
      }
    }

    // Add in any images
    $FilteredImages = array_filter($Images);
    $ImageCount = count($FilteredImages);
    $this->SetData('ImageCount', $ImageCount);
    if($ImageCount > 0) {
      $FH->addEmptyDir('images');
    }

    foreach($FilteredImages as $Image) {
      if($FH->addFile('.' . $Image, 'images/' . $Image) === FALSE) {
        $this->Form->AddError(sprintf(T('Yaga.Error.AddFile'), $FH->getStatusString()));
        //return FALSE;
      }
      $Hashes[] = md5_file('.' . $Image);
    }

    // Save all the hashes
    sort($Hashes);
    $Info->MD5 = md5(implode(',', $Hashes));
    $Info->EndDate = date('Y-m-d H:i:s');

    $EndTime = microtime(TRUE);
    $TotalTime = $EndTime - $StartTime;
    $m = floor($TotalTime / 60);
    $s = $TotalTime - ($m * 60);

    $Info->ElapsedTime = sprintf('%02d:%02.2f', $m, $s);

    $FH->setArchiveComment(serialize($Info));
    if($FH->close()) {
      return $Path;
    }
    else {
      $this->Form->AddError(sprintf(T('Yaga.Error.ArchiveSave'), $FH->getStatusString()));
      return FALSE;
    }
  }

  /**
   * Extract the transport file and validate
   *
   * @param string The transport file path
   * @return boolean Whether or not the transport file was extracted successfully
   */
  protected function _ExtractZip($Filename) {
    if(!file_exists($Filename)) {
      $this->Form->AddError(T('Yaga.Error.FileDNE'));
			return FALSE;
		}

    $ZipFile = new ZipArchive();
    $Result = $ZipFile->open($Filename);
    if($Result !== TRUE) {
      $this->Form->AddError(T('Yaga.Error.ArchiveOpen'));
      return FALSE;
    }

    // Get the metadata from the comment
    $Comment = $ZipFile->comment;
    $MetaData = unserialize($Comment);

    $Result = $ZipFile->extractTo(PATH_UPLOADS . DS . 'import' . DS . 'yaga');
    if($Result !== TRUE) {
      $this->Form->AddError(T('Yaga.Error.ArchiveExtract'));
      return FALSE;
    }

    $ZipFile->close();

    // Validate checksum
    if($this->_ValidateChecksum($MetaData) === TRUE) {
      return $MetaData;
    }
    else {
      $this->Form->AddError(T('Yaga.Error.ArchiveChecksum'));
      return FALSE;
    }
  }

  /**
   * Overwrites Yaga configurations, dumps Yaga db tables, inserts data via the 
   * model, and copies uploaded files to the server
   * 
   * @param stdClass The info object read in from the archive
   * @param array Which tables should be overwritten
   * @return bool Pass/Fail on the import being executed. Errors can exist on the
   * form with a passing return value.
   */
  protected function _ImportData($Info, $Include) {
    if(!$Info) {
      return FALSE;
    }
    
    // Import Configs
    $Configs = unserialize(file_get_contents(PATH_UPLOADS . DS . 'import' . DS . 'yaga' . DS . $Info->Config));
    $Configurations = $this->_NestedToDotNotation($Configs, 'Yaga');
    foreach($Configurations as $Name => $Value) {
      SaveToConfig($Name, $Value);
    }
    
    // Import model data
    foreach($Include as $Key => $Value) {
      if($Value) {
        $Data = unserialize(file_get_contents(PATH_UPLOADS . DS . 'import' . DS . 'yaga' . DS . $Info->$Key));
        Gdn::SQL()->EmptyTable($Key);
        $ModelName = $Key . 'Model';
        $Model = Yaga::$ModelName();
        foreach($Data as $Datum) {
          $Model->Insert((array)$Datum);
        }
        $this->SetData($Key . 'Count', $Model->GetCount());
      }
    }
    
    // Import uploaded files
    if(Gdn_FileSystem::Copy(PATH_UPLOADS . DS . 'import' . DS . 'yaga' . DS . 'images' . DS . 'uploads' . DS, PATH_UPLOADS . DS) === FALSE) {
      $this->Form->AddError(T('Yaga.Error.TransportCopy'));
    }
    
    return TRUE;
  }
  
  /**
   * Converted a nest config array into an array where indexes are the configuration
   * strings and the value is the value
   * 
   * @param array The nested array
   * @param string What should the configuration strings be prefixed with
   * @return array
   */
  protected function _NestedToDotNotation($Configs, $Prefix = '') {
    $ConfigStrings = array();
    
    foreach($Configs as $Name => $Value) {
      if(is_array($Value)) {
        $ConfigStrings = array_merge($ConfigStrings, $this->_NestedToDotNotation($Value, "$Prefix.$Name"));
      }
      else {
        $ConfigStrings["$Prefix.$Name"] = $Value;
      }
    }
    
    return $ConfigStrings;
  }

  /**
   * Inspects the Yaga transport files and calculates a checksum
   *
   * @param stdClass The metadata object read in from the transport file
   * @return boolean Whether or not the checksum is valid
   */
  protected function _ValidateChecksum($MetaData) {
    $Hashes = array();
    
    // Hash the config file
    $Hashes[] = md5_file(PATH_UPLOADS . DS . 'import' . DS . 'yaga' . DS . $MetaData->Config);
    
    // Hash the data files
    if(property_exists($MetaData, 'Action')) {
      $Hashes[] = md5_file(PATH_UPLOADS . DS . 'import' . DS . 'yaga' . DS . $MetaData->Action);
    }

    if(property_exists($MetaData, 'Badge')) {
      $Hashes[] = md5_file(PATH_UPLOADS . DS . 'import' . DS . 'yaga' . DS . $MetaData->Badge);
    }

    if(property_exists($MetaData, 'Rank')) {
      $Hashes[] = md5_file(PATH_UPLOADS . DS . 'import' . DS . 'yaga' . DS . $MetaData->Rank);
    }

    // Hash the image files
		$Files = $this->_GetFiles(PATH_UPLOADS . DS . 'import' . DS . 'yaga' . DS . 'images');
    $this->SetData('ImageCount', count($Files));
		foreach($Files as $File) {
			$Hashes[] = md5_file($File);
		}

    sort($Hashes);
		$CalculatedChecksum = md5(implode(',', $Hashes));
   
    if($CalculatedChecksum != $MetaData->MD5) {
      return FALSE;
		}
		else {
      return TRUE;
		}
  }

  /**
	 * Returns a list of all files in a directory, recursively (Thanks @businessdad)
	 *
	 * @param string Directory The directory to scan for files
	 * @return array A list of Files and, optionally, Directories.
	 */
	protected function _GetFiles($Directory) {
    $Files = array_diff(scandir($Directory), array('.', '..'));
    $Result = array();
    foreach($Files as $File) {
      $FileName = $Directory . '/' . $File;
      if(is_dir($FileName)) {
          $Result = array_merge($Result, $this->_GetFiles($FileName));
          continue;
      }
      $Result[] = $FileName;
    }
    return $Result;
  }

}