Gecko [ admjudic.com.br ]

Name	Size	Permission
fonts	[ DIR ]	drwxr-xr-x
html-purifier	[ DIR ]	drwxr-xr-x
scripts	[ DIR ]	drwxr-xr-x
styles	[ DIR ]	drwxr-xr-x
type-processors	[ DIR ]	drwxr-xr-x
LICENSE.txt	1.04 KB	-rw-r--r--
README.md	11.18 KB	-rw-r--r--
h5p-report-xapi-data.class.php	6.03 KB	-rw-r--r--
h5p-report.class.php	8.23 KB	-rw-r--r--

Code Editor : h5p-report.class.php

<?php

/**
 * Class H5PReport
 * @property  fillInProcessor
 */
class H5PReport {

private static $version = '1.1.0';

private static $processorMap = array(
    'compound' => 'CompoundProcessor',
    'fill-in' => 'FillInProcessor',
    'long-fill-in' => 'FillInProcessor',
    'true-false' => 'TrueFalseProcessor',
    'matching' => 'MatchingProcessor',
    'choice' => 'ChoiceProcessor',
    'long-choice' => 'LongChoiceProcessor',
  );

private static $versionExtension = 'https://h5p.org/x-api/h5p-reporting-version';
  private static $contentTypeExtension = 'https://h5p.org/x-api/h5p-machine-name';

public static $contentTypeProcessors = array(
    'H5P.DocumentationTool' => 'DocumentationToolProcessor',
    'H5P.GoalsPage' => 'GoalsPageProcessor',
    'H5P.GoalsAssessmentPage' => 'GoalsAssessmentPageProcessor',
    'H5P.StandardPage' => 'StandardPageProcessor',
    'H5P.FreeTextQuestion' => 'IVOpenEndedQuestionProcessor',
  );

private $processors = array();

/**
   * Generate the proper report depending on xAPI data.
   *
   * @param object $xapiData
   * @param string $forcedProcessor Force a processor type
   * @param bool $disableScoring Disables scoring for the report
   *
   * @return string A report
   */
  public function generateReport($xapiData, $forcedProcessor = null, $disableScoring = false) {
    $interactionType = $xapiData->interaction_type;
    if (!self::isSupportedVersion($xapiData)) {
      return self::renderUnsupportedVersionPage($xapiData);
    }

$contentTypeProcessor = self::getContentTypeProcessor($xapiData);
    if (isset($contentTypeProcessor)) {
      $interactionType = $contentTypeProcessor;
    }

if (isset($forcedProcessor)) {
      $interactionType = $forcedProcessor;
    }

if (!isset(self::$processorMap[$interactionType]) && !isset(self::$contentTypeProcessors[$interactionType])) {
      return ''; // No processor found
    }

if (!isset($this->processors[$interactionType])) {
      // Not used before. Initialize new processor
      if (array_key_exists($interactionType, self::$contentTypeProcessors)) {
        $this->processors[$interactionType] = new self::$contentTypeProcessors[$interactionType]();
      }
      else {
        $this->processors[$interactionType] = new self::$processorMap[$interactionType]();
      }
    }

// Generate and return report from xAPI data
    // Allow compound content types to have styles in case they are rendering gradable containers
    return $this->processors[$interactionType]
      ->generateReport($xapiData, $disableScoring, ($interactionType == "compound" ? true : false));
  }

/**
   * Generate the proper report for dynamically gradable content types depending on xAPI data.
   *
   * @param object $xapiData
   * @return string A report
   */
  public function generateGradableReports($xapiData) {
    $results = array();

foreach ($xapiData as $childData) {
     $interactionType = self::getContentTypeProcessor($childData);

if (!isset($this->processors[$interactionType])) {
       // Not used before. Initialize new processor
       if (array_key_exists($interactionType, self::$contentTypeProcessors)) {
         $this->processors[$interactionType] = new self::$contentTypeProcessors[$interactionType]();
       }
     }

if ($interactionType == 'H5P.FreeTextQuestion') {
       array_push($results, $childData);
     }
    }

if (count($results) > 0) {
      return self::buildContainer($results);
    }

// Return nothing if there are no reports
    return ' ';
  }

/**
   * Generate the wrapping element for a grading container
   *
   * @param object $results
   *
   * @return string HTML of the container and within it, gradable elements
   */
  private function buildContainer($results) {
    $container = '<div id="gradable-container" class="h5p-iv-open-ended-grading-container">';

foreach ($results as $index=>$child) {
      $container .= self::buildChild($child, $index);
    }

$container .= '</div>';

return $container;
  }

/**
   * Generate each of the gradable elements
   *
   * @param object $data
   * @param int $index
   *
   * @return string HTML of a gradable element
   */
  private function buildChild($data, $index) {
    // Generate and return report from xAPI data
    $interactionType = self::getContentTypeProcessor($data);
    return $this->processors[$interactionType]
      ->generateReport($data, false, true);
  }

/**
   * Removes gradable children from xAPI data
   *
   * @return array
   */
  public function stripGradableChildren($xapiData) {
    return array_filter($xapiData, function ($data) {
      $contentTypeProcessor = H5PReport::getContentTypeProcessor($data);
      $interactionType = $contentTypeProcessor;
      return $interactionType !== 'H5P.FreeTextQuestion';
    });
  }

/**
   * List of CSS stylesheets used by the processors when rendering the report.
   *
   * @return array
   */
  public function getStylesUsed() {
    $styles = array(
      'styles/shared-styles.css'
    );

// Fetch style used by each report processor
    foreach ($this->processors as $processor) {
      $style = $processor->getStyle();
      if (!empty($style)) {
        $styles[] = $style;
      }
    }

return $styles;
  }

/**
   * List of JS scripts to be used by the processors when rendering the report.
   *
   * @return array
   */
  public function getScriptsUsed() {
    $scripts = [];

// Fetch scripts used by each report processor
    foreach ($this->processors as $processor) {
      $script = $processor->getScript();
      if (!empty($script)) {
        $scripts[] = $script;
      }
    }

return $scripts;
  }

/**
   * Caches instance of report generator.
   * @return \H5PReport
   */
  public static function getInstance() {
    static $instance;

if (!$instance) {
      $instance = new H5PReport();
    }

return $instance;
  }

/**
   * Attempts to retrieve content type processor from xapi data
   * @param object $xapiData
   *
   * @return string|null Content type processor
   */
  public static function getContentTypeProcessor($xapiData) {
    if (!isset($xapiData->additionals)) {
      return null;
    }

$extras = json_decode($xapiData->additionals);

if (!isset($extras->extensions) || !isset($extras->extensions->{self::$contentTypeExtension})) {
      return null;
    }

$processor = $extras->extensions->{self::$contentTypeExtension};
    if (!array_key_exists($processor, self::$contentTypeProcessors)) {
      return null;
    }

return $processor;
  }

/**
     * Get required reporting module version from statement
     *
     * @param $xapiData
     *
     * @return string Defaults to 1.0.0
     */
  public static function getVersion($xapiData) {
    if (!isset($xapiData->additionals)) {
      return '1.0.0';
    }

$additionals = json_decode($xapiData->additionals);
    if (!isset($additionals->contextExtensions->{self::$versionExtension})) {
      return '1.0.0';
    }

return $additionals->contextExtensions->{self::$versionExtension};
  }

/**
     * Check is render report from statement is supported
     *
     * @param $xapiData
     *
     * @return bool
     */
  public static function isSupportedVersion($xapiData) {
    $reportingVersion = array_map('intval', explode('.', self::$version));
    $statementVersion = array_map('intval', explode('.', self::getVersion($xapiData)));

// Sanitation
    if (!count($statementVersion) === 3) {
      return false;
    }

// Check major version
    if ($reportingVersion[0] < $statementVersion[0]) {
      return false;
    }

// Check minor version
    $hasOutdatedMinorVersion = $reportingVersion[0] === $statementVersion[0]
                               && $reportingVersion[1] < $statementVersion[1];
    if ($hasOutdatedMinorVersion) {
      return false;
    }

// Patch versions are assumed to be compatible
    return true;
  }

/**
     * Display message saying that report could not be rendered
     *
     * @param $xapiData
     *
     * @return string
     */
  public static function renderUnsupportedVersionPage($xapiData) {
    $requiredVersion = self::getVersion($xapiData);
    $installedVersion = self::$version;
    return "<div>Version {$requiredVersion} of the reporting module is required to render this report. Currently installed: {$installedVersion}</div>";
  }
}

${this.title}

Code Editor : h5p-report.class.php