ScanOptions.php

Go to the documentation of this file.

<?php
/*
 SPDX-FileCopyrightText: © 2017 Siemens AG
 SPDX-FileCopyrightText: © 2021 Orange by Piotr Pszczola <piotr.pszczola@orange.com>
 SPDX-FileCopyrightText: © 2025 Tiyasa Kundu <tiyasakundu20@gmail.com>
 
 SPDX-License-Identifier: GPL-2.0-only
*/
namespace Fossology\UI\Api\Models;
 
use Fossology\Lib\Auth\Auth;
use Fossology\UI\Api\Exceptions\HttpForbiddenException;
use Fossology\UI\Api\Exceptions\HttpNotFoundException;
use Fossology\UI\Api\Models\ApiVersion;
use Symfony\Component\HttpFoundation\Request;
 
if (!class_exists("AgentAdder", false)) {
  require_once dirname(__DIR__, 2) . "/agent-add.php";
}
require_once dirname(__DIR__, 4) . "/lib/php/common-folders.php";
 
class ScanOptions
{
  private $analysis;
  private $reuse;
  private $decider;
  private $scancode;
  public function __construct($analysis, $reuse, $decider, $scancode)
  {
    $this->analysis = $analysis;
    $this->reuse = $reuse;
    $this->decider = $decider;
    $this->scancode = $scancode;
  }
 
  public function getArray()
  {
    return [
      "analysis"  => $this->analysis,
      "reuse"     => $this->reuse,
      "decide"    => $this->decider,
      "scancode"  => $this->scancode
    ];
  }
 
  public function scheduleAgents($folderId, $uploadId , $newUpload = true)
  {
    $uploadsAccessible = FolderListUploads_perm($folderId, Auth::PERM_WRITE);
 
    if (! $newUpload) {
      $found = false;
      foreach ($uploadsAccessible as $singleUpload) {
        if ($singleUpload['upload_pk'] == $uploadId) {
          $found = true;
          break;
        }
      }
      if ($found === false) {
        throw new HttpNotFoundException(
          "Folder id $folderId does not have upload id " .
          "$uploadId or you do not have write access to the folder.");
      }
    }
 
    $paramAgentRequest = new Request();
    $agentsToAdd = $this->prepareAgents($paramAgentRequest);
    $this->prepareReuser($paramAgentRequest);
    $this->prepareDecider($paramAgentRequest);
    $this->prepareScancode($paramAgentRequest);
    $returnStatus = (new \AgentAdder())->scheduleAgents($uploadId, $agentsToAdd, $paramAgentRequest);
    if (is_numeric($returnStatus)) {
      return new Info(201, $returnStatus, InfoType::INFO);
    } else {
      throw new HttpForbiddenException($returnStatus);
    }
  }
 
  private function prepareAgents(Request &$request)
  {
    $agentsToAdd = [];
 
    $apiVersion = ApiVersion::getVersionFromUri();
 
    if ($apiVersion == ApiVersion::V2) {
      foreach ($this->analysis->getArray($apiVersion) as $agent => $set) {
        if ($set === true) {
          if ($agent == "copyrightEmailAuthor") {
            $agentsToAdd[] = "agent_copyright";
            $request->request->set("Check_agent_copyright", 1);
          } elseif ($agent == "ipra") {
            $agentsToAdd[] = "agent_ipra";
            $request->request->set("Check_agent_ipra", 1);
          } elseif ($agent == "pkgagent") {
            $agentsToAdd[] = "agent_pkgagent";
            $request->request->set("Check_agent_pkgagent", 1);
          } elseif ($agent == "softwareHeritage") {
            $agentsToAdd[] = "agent_shagent";
            $request->request->set("Check_agent_shagent", 1);
          } elseif ($agent == "kotoba") {
            $agentsToAdd[] = "agent_kotoba";
            $request->request->set("Check_agent_kotoba", 1);
          } else {
            $agentsToAdd[] = "agent_$agent";
            $request->request->set("Check_agent_$agent", 1);
          }
        }
      }
    } else {
      foreach ($this->analysis->getArray($apiVersion) as $agent => $set) {
        if ($set === true) {
          if ($agent == "copyright_email_author") {
            $agentsToAdd[] = "agent_copyright";
            $request->request->set("Check_agent_copyright", 1);
          } elseif ($agent == "patent") {
            $agentsToAdd[] = "agent_ipra";
            $request->request->set("Check_agent_ipra", 1);
          } elseif ($agent == "package") {
            $agentsToAdd[] = "agent_pkgagent";
            $request->request->set("Check_agent_pkgagent", 1);
          } elseif ($agent == "heritage") {
            $agentsToAdd[] = "agent_shagent";
            $request->request->set("Check_agent_shagent", 1);
          } elseif ($agent == "kotoba_bulk") {
            $agentsToAdd[] = "agent_kotoba";
            $request->request->set("Check_agent_kotoba", 1);
          } else {
            $agentsToAdd[] = "agent_$agent";
            $request->request->set("Check_agent_$agent", 1);
          }
        }
      }
    }
    return $agentsToAdd;
  }
 
  private function prepareReuser(Request &$request)
  {
    $reuseUploads = $this->reuse->getReuseUploads();
    $reuseUploads = array_filter($reuseUploads, function ($id) {
      return $id > 0;
    });
    if (empty($reuseUploads)) {
      return;
    }
    foreach ($reuseUploads as $reuseUploadId) {
      if (!$GLOBALS['container']->get("dao.upload")->isAccessible($reuseUploadId, Auth::getGroupId())) {
        throw new HttpForbiddenException("Upload $reuseUploadId is not accessible for reuse");
      }
    }
    $reuserRules = [];
    if ($this->reuse->getReuseMain() === true) {
      $reuserRules[] = 'reuseMain';
    }
    if ($this->reuse->getReuseEnhanced() === true) {
      $reuserRules[] = 'reuseEnhanced';
    }
    if ($this->reuse->getReuseReport() === true) {
      $reuserRules[] = 'reuseConf';
    }
    if ($this->reuse->getReuseCopyright() === true) {
      $reuserRules[] = 'reuseCopyright';
    }
    $userDao = $GLOBALS['container']->get("dao.user");
    $groupId = $userDao->getGroupIdByName($this->reuse->getReuseGroup());
    $reuserSelectors = [];
    foreach ($reuseUploads as $uploadId) {
      $reuserSelectors[] = $uploadId . "," . $groupId;
    }
    if (count($reuserSelectors) === 1) {
      $request->request->set('uploadToReuse', $reuserSelectors[0]);
    } else {
      $request->request->set('uploadToReuse', $reuserSelectors);
    }
    $request->request->set('reuseMode', $reuserRules);
  }
 
  private function prepareDecider(Request &$request)
  {
    $deciderRules = [];
    if ($this->decider->getNomosMonk() === true) {
      $deciderRules[] = 'nomosInMonk';
    }
    if ($this->decider->getBulkReused() === true) {
      $deciderRules[] = 'reuseBulk';
    }
    if ($this->decider->getNewScanner() === true) {
      $deciderRules[] = 'wipScannerUpdates';
    }
    if ($this->decider->getOjoDecider() === true) {
      $deciderRules[] = 'ojoNoContradiction';
    }
    if ($this->decider->getCopyrightDeactivation() === true) {
      $deciderRules[] = 'copyrightDeactivation';
    }
    if ($this->decider->getCopyrightClutterRemoval() === true) {
      $deciderRules[] = 'copyrightDeactivationClutterRemoval';
    }
    if (! empty($this->decider->getConcludeLicenseType())) {
      $deciderRules[] = 'licenseTypeConc';
      $request->request->set('licenseTypeConc',
          $this->decider->getConcludeLicenseType());
    }
    $request->request->set('deciderRules', $deciderRules);
    if ($this->analysis->getNomos()) {
      $request->request->set('Check_agent_nomos', 1);
    }
  }
 
  private function prepareScancode(Request &$request)
  {
    $scancodeRules = [];
    if ($this->scancode->getScanLicense() === true) {
      $scancodeRules[] = 'license';
    }
    if ($this->scancode->getScanCopyright() === true) {
      $scancodeRules[] = 'copyright';
    }
    if ($this->scancode->getScanEmail() === true) {
      $scancodeRules[] = 'email';
    }
    if ($this->scancode->getScanUrl() === true) {
      $scancodeRules[] = 'url';
    }
    $request->request->set('scancodeFlags', $scancodeRules);
  }
}