AgentLicenseEventProcessor.php

<?php
/*
 SPDX-FileCopyrightText: © 2014-2015 Siemens AG
 
 SPDX-License-Identifier: GPL-2.0-only
*/
 
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
    );
  }
}