AgentLicenseEventProcessor.php

<?php
/*
Copyright (C) 2014-2015, Siemens AG

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/

namespace Fossology\Lib\BusinessRules;

use Fossology\Lib\Dao\AgentDao;
use Fossology\Lib\Dao\LicenseDao;
use Fossology\Lib\Data\Clearing\AgentClearingEvent;
use Fossology\Lib\Data\LicenseMatch;
use Fossology\Lib\Data\LicenseRef;
use Fossology\Lib\Data\Tree\ItemTreeBounds;
use Fossology\Lib\Proxy\LatestScannerProxy;

class AgentLicenseEventProcessor
{
  private $latestAgentMapCache = array();
  private $licenseDao;
  private $agentDao;

  public function __construct(LicenseDao $licenseDao, AgentDao $agentDao)
  {
    $this->licenseDao = $licenseDao;
    $this->agentDao = $agentDao;
  }

  public function getScannerDetectedLicenses(ItemTreeBounds $itemTreeBounds, $usageId=LicenseMap::TRIVIAL)
  {
    $details = $this->getScannerDetectedLicenseDetails($itemTreeBounds, $usageId);

    return $this->getScannedLicenses($details);
  }

  protected function getScannerDetectedLicenseDetails(ItemTreeBounds $itemTreeBounds, $usageId=LicenseMap::TRIVIAL)
  {
    $agentDetectedLicenses = array();

    $licenseFileMatches = $this->licenseDao->getAgentFileLicenseMatches($itemTreeBounds, $usageId);

    foreach ($licenseFileMatches as $licenseMatch) {
      $licenseRef = $licenseMatch->getLicenseRef();
      $licenseId = $licenseRef->getId();
      if ($licenseRef->getShortName() === "No_license_found") {
        continue;
      }
      $agentRef = $licenseMatch->getAgentRef();
      $agentName = $agentRef->getAgentName();
      $agentId = $agentRef->getAgentId();

      $agentDetectedLicenses[$agentName][$agentId][$licenseId][] = array(
          'id' => $licenseId,
          'licenseRef' => $licenseRef,
          'agentRef' => $agentRef,
          'matchId' => $licenseMatch->getLicenseFileId(),
          'percentage' => $licenseMatch->getPercentage()
      );
    }

    return $this->filterLatestScannerDetectedMatches($agentDetectedLicenses, $itemTreeBounds->getUploadId());
  }

  public function getLatestScannerDetectedMatches(ItemTreeBounds $itemTreeBounds)
  {
    $agentDetectedLicenses = array();

    $licenseFileMatches = $this->licenseDao->getAgentFileLicenseMatches($itemTreeBounds);

    foreach ($licenseFileMatches as $licenseMatch) {
      $licenseRef = $licenseMatch->getLicenseRef();
      $licenseId = $licenseRef->getId();
      if ($licenseRef->getShortName() === "No_license_found") {
        continue;
      }
      $agentRef = $licenseMatch->getAgentRef();
      $agentName = $agentRef->getAgentName();
      $agentId = $agentRef->getAgentId();

      $agentDetectedLicenses[$agentName][$agentId][$licenseId][] = $licenseMatch;
    }

    return $this->filterLatestScannerDetectedMatches($agentDetectedLicenses, $itemTreeBounds->getUploadId());
  }

  protected function filterLatestScannerDetectedMatches($agentDetectedLicenses, $uploadId)
  {
    $agentNames = array_keys($agentDetectedLicenses);
    if (empty($agentNames)) {
      return array();
    }

    $latestAgentIdPerAgent = $this->getLatestAgentIdPerAgent($uploadId, $agentNames);
    $latestAgentDetectedLicenses = $this->filterDetectedLicenses($agentDetectedLicenses, $latestAgentIdPerAgent);
    return $latestAgentDetectedLicenses;
  }

  private function getLatestAgentIdPerAgent($uploadId, $agentNames)
  {
    if (!array_key_exists($uploadId,$this->latestAgentMapCache)
            || count(array_diff_key($agentNames, $this->latestAgentMapCache[$uploadId]))>0) {
      $latestScannerProxy = new LatestScannerProxy($uploadId, $agentNames, "latest_scanner$uploadId");
      $latestAgentIdPerAgent = $latestScannerProxy->getNameToIdMap();
      foreach ($latestAgentIdPerAgent as $agentName=>$agentMap) {
        $this->latestAgentMapCache[$uploadId][$agentName] = $agentMap;
      }
    }
    if (array_key_exists($uploadId, $this->latestAgentMapCache)) {
      return $this->latestAgentMapCache[$uploadId];
    } else {
      return array();
    }
  }

  protected function filterDetectedLicenses($agentDetectedLicenses, $agentLatestMap)
  {
    $latestAgentDetectedLicenses = array();

    foreach ($agentDetectedLicenses as $agentName => $licensesFoundPerAgentId) {
      if (!array_key_exists($agentName, $agentLatestMap)) {
        continue;
      }
      $latestAgentId = $agentLatestMap[$agentName];
      if (!array_key_exists($latestAgentId, $licensesFoundPerAgentId)) {
        continue;
      }
      foreach ($licensesFoundPerAgentId[$latestAgentId] as $licenseId => $properties) {
        $latestAgentDetectedLicenses[$licenseId][$agentName] = $properties;
      }
    }

    return $latestAgentDetectedLicenses;
  }

  public function getScannedLicenses($details)
  {
    $licenses = array();

    foreach ($details as $licenseId => $agentEntries) {
      foreach ($agentEntries as $matchProperties) {
        $licenses[$licenseId] = $matchProperties[0]['licenseRef'];
        break;
      }
    }

    return $licenses;
  }

  public function getScannerEvents(ItemTreeBounds $itemTreeBounds, $usageId=LicenseMap::TRIVIAL)
  {
    $agentDetails = $this->getScannerDetectedLicenseDetails($itemTreeBounds, $usageId);

    $result = array();
    foreach ($agentDetails as $licenseId => $properties) {
      $agentClearingEvents = array();
      foreach ($properties as $licenseProperties) {
        foreach ($licenseProperties as $licenseProperty) {
          $agentClearingEvents[] = $this->createAgentClearingEvent($licenseProperty);
        }
      }

      $result[$licenseId] = $agentClearingEvents;
    }
    return $result;
  }

  private function createAgentClearingEvent($licenseProperty)
  {
    return new AgentClearingEvent(
        $licenseProperty['licenseRef'],
        $licenseProperty['agentRef'],
        $licenseProperty['matchId'],
        array_key_exists('percentage', $licenseProperty) ? $licenseProperty['percentage'] : null
    );
  }
}