ClearingDecisionProcessor.php

<?php
/*
 SPDX-FileCopyrightText: © 2014-2015 Siemens AG
 
 SPDX-License-Identifier: GPL-2.0-only
*/
 
namespace Fossology\Lib\BusinessRules;
 
use Fossology\Lib\Dao\ClearingDao;
use Fossology\Lib\Data\Clearing\ClearingEventTypes;
use Fossology\Lib\Data\Clearing\ClearingResult;
use Fossology\Lib\Data\ClearingDecision;
use Fossology\Lib\Data\DecisionScopes;
use Fossology\Lib\Data\DecisionTypes;
use Fossology\Lib\Data\Tree\ItemTreeBounds;
use Fossology\Lib\Db\DbManager;
use Fossology\Lib\Exception;
 
class ClearingDecisionProcessor
{
  const NO_LICENSE_KNOWN_DECISION_TYPE = 2;
 
  private $clearingDao;
  private $agentLicenseEventProcessor;
  private $clearingEventProcessor;
  private $dbManager;
 
  public function __construct(ClearingDao $clearingDao, AgentLicenseEventProcessor $agentLicenseEventProcessor, ClearingEventProcessor $clearingEventProcessor, DbManager $dbManager)
  {
    $this->clearingDao = $clearingDao;
    $this->agentLicenseEventProcessor = $agentLicenseEventProcessor;
    $this->clearingEventProcessor = $clearingEventProcessor;
    $this->dbManager = $dbManager;
  }
 
  public function hasUnhandledScannerDetectedLicenses(ItemTreeBounds $itemTreeBounds, $groupId, $additionalEventIds = array(), $licenseMap=null)
  {
    if (!empty($licenseMap) && !($licenseMap instanceof LicenseMap)) {
      throw new Exception('invalid license map');
    }
    $userEvents = $this->clearingDao->getRelevantClearingEvents($itemTreeBounds, $groupId);
    $usageId = empty($licenseMap) ? LicenseMap::TRIVIAL : $licenseMap->getUsage();
    $scannerDetectedEvents = $this->agentLicenseEventProcessor->getScannerEvents($itemTreeBounds,$usageId);
    $eventLicenceIds = array();
    foreach (array_keys($userEvents) as $licenseId) {
      $eventLicenceIds[empty($licenseMap)? $licenseId: $licenseMap->getProjectedId($licenseId)] = $licenseId;
    }
    foreach (array_keys($additionalEventIds) as $licenseId) {
      $eventLicenceIds[empty($licenseMap)? $licenseId: $licenseMap->getProjectedId($licenseId)] = $licenseId;
    }
    foreach (array_keys($scannerDetectedEvents) as $licenseId) {
      if (!array_key_exists(empty($licenseMap)? $licenseId: $licenseMap->getProjectedId($licenseId), $eventLicenceIds)) {
        return true;
      }
    }
    return false;
  }
 
  private function insertClearingEventsForAgentFindings(ItemTreeBounds $itemBounds, $userId, $groupId, $remove = false, $type = ClearingEventTypes::AGENT, $removedIds = array())
  {
    $eventIds = array();
    foreach ($this->agentLicenseEventProcessor->getScannerEvents($itemBounds) as $licenseId => $scannerEvents) {
      if (array_key_exists($licenseId, $removedIds)) {
        continue;
      }
      $scannerLicenseRef = $scannerEvents[0]->getLicenseRef();
      $eventIds[$scannerLicenseRef->getId()] = $this->clearingDao->insertClearingEvent($itemBounds->getItemId(), $userId, $groupId, $scannerLicenseRef->getId(), $remove, $type);
    }
    return $eventIds;
  }
 
  private function clearingDecisionIsDifferentFrom(ClearingDecision $decision, $type, $scope, $clearingEventIds)
  {
    $clearingEvents = $decision->getClearingEvents();
    if (count($clearingEvents) != count($clearingEventIds)) {
      return true;
    }
 
    foreach ($clearingEvents as $clearingEvent) {
      if (false === array_search($clearingEvent->getEventId(), $clearingEventIds)) {
        return true;
      }
    }
    return ($type !== $decision->getType()) || ($scope !== $decision->getScope());
  }
 
  public function makeDecisionFromLastEvents(ItemTreeBounds $itemBounds, $userId, $groupId, $type, $global, $additionalEventIds = array())
  {
    if ($type < self::NO_LICENSE_KNOWN_DECISION_TYPE) {
      return;
    }
    $this->dbManager->begin();
 
    $itemId = $itemBounds->getItemId();
    $includeSubFolders = false;
    if (($global == DecisionScopes::REPO) && ($type != self::NO_LICENSE_KNOWN_DECISION_TYPE)) {
      $includeSubFolders = true;
    }
    $previousEvents = $this->clearingDao->getRelevantClearingEvents($itemBounds, $groupId, $includeSubFolders);
    if ($type === self::NO_LICENSE_KNOWN_DECISION_TYPE) {
      $type = DecisionTypes::IDENTIFIED;
      $clearingEventIds = $this->insertClearingEventsForAgentFindings($itemBounds, $userId, $groupId, true, ClearingEventTypes::USER);
      foreach ($previousEvents as $eventId => $clearingEvent) {
        if (!in_array($eventId, $clearingEventIds) && !$clearingEvent->isRemoved()) {
          $licenseId = $clearingEvent->getLicenseId();
          $newEventId = $this->clearingDao->insertClearingEvent($itemBounds->getItemId(), $userId, $groupId, $licenseId, true);
          $clearingEventIds[$licenseId] = $newEventId;
        }
      }
    } else {
      $clearingEventIds = $this->insertClearingEventsForAgentFindings($itemBounds, $userId, $groupId, false, ClearingEventTypes::AGENT, $previousEvents);
      foreach ($previousEvents as $clearingEvent) {
        $clearingEventIds[$clearingEvent->getLicenseId()] = $clearingEvent->getEventId();
      }
    }
 
    $currentDecision = $this->clearingDao->getRelevantClearingDecision($itemBounds, $groupId);
    $clearingEventIds = array_unique(array_merge($clearingEventIds, $additionalEventIds));
 
    $scope = $global ? DecisionScopes::REPO : DecisionScopes::ITEM;
    if (null === $currentDecision || $this->clearingDecisionIsDifferentFrom($currentDecision, $type, $scope, $clearingEventIds)) {
      $this->clearingDao->createDecisionFromEvents($itemBounds->getItemId(), $userId, $groupId, $type, $scope,
          $clearingEventIds);
    } else {
      $this->clearingDao->removeWipClearingDecision($itemId, $groupId);
    }
 
    $this->dbManager->commit();
  }
 
  public function getCurrentClearings(ItemTreeBounds $itemTreeBounds, $groupId, $usageId=LicenseMap::TRIVIAL)
  {
    $agentEvents = $this->agentLicenseEventProcessor->getScannerEvents($itemTreeBounds, $usageId);
    $events = $this->clearingDao->getRelevantClearingEvents($itemTreeBounds, $groupId);
 
    $addedResults = array();
    $removedResults = array();
 
    foreach (array_unique(array_merge(array_keys($events), array_keys($agentEvents))) as $licenseId) {
      $licenseDecisionEvent = array_key_exists($licenseId, $events) ? $events[$licenseId] : null;
      $agentClearingEvents = array_key_exists($licenseId, $agentEvents) ? $agentEvents[$licenseId] : array();
 
      if (($licenseDecisionEvent === null) && (count($agentClearingEvents) == 0)) {
        throw new Exception('not in merge');
      }
      $licenseDecisionResult = new ClearingResult($licenseDecisionEvent, $agentClearingEvents);
      if ($licenseDecisionResult->isRemoved()) {
        $removedResults[$licenseId] = $licenseDecisionResult;
      } else {
        $addedResults[$licenseId] = $licenseDecisionResult;
      }
    }
 
    return array($addedResults, $removedResults);
  }
}