CompatibilityDao.php

<?php
/*
 SPDX-FileCopyrightText: © 2024 Siemens AG
 
 SPDX-License-Identifier: GPL-2.0-only
*/
 
namespace Fossology\Lib\Dao;
 
use Fossology\Lib\Auth\Auth;
use Fossology\Lib\Data\Tree\ItemTreeBounds;
use Fossology\Lib\Db\DbManager;
use Fossology\Lib\Exceptions\InvalidAgentStageException;
use Fossology\Lib\Proxy\ScanJobProxy;
use Monolog\Logger;
 
class CompatibilityDao
{
  const RULE_SELECT = "SELECT lr_pk, first_rf_fk, second_rf_fk,
      lrf.rf_shortname AS first_rf_shortname,
      lrs.rf_shortname AS second_rf_shortname, first_type, second_type,
      comment, compatibility
    FROM license_rules
      LEFT JOIN license_ref lrf ON lrf.rf_pk = first_rf_fk
      LEFT JOIN license_ref lrs ON lrs.rf_pk = second_rf_fk";
 
  private $dbManager;
  private $logger;
  private $licenseDao;
  private $agentDao;
  private $defaultCompatibility;
  private $agentName;
 
  public function __construct(DbManager $dbManager, Logger $logger,LicenseDao $licenseDao, AgentDao $agentDao)
  {
    $this->dbManager = $dbManager;
    $this->logger = $logger;
    $this->licenseDao = $licenseDao;
    $this->agentDao = $agentDao;
    $this->agentName = "compatibility";
    $sql = "SELECT compatibility FROM license_rules
                     WHERE first_rf_fk IS NULL AND second_rf_fk IS NULL
                     AND first_type IS NULL AND second_type IS NULL;";
    $result = $this->dbManager->getSingleRow($sql, [], __METHOD__ .
      "defaultComp");
    if (!empty($result) && array_key_exists("compatibility", $result)) {
      $this->defaultCompatibility = $result["compatibility"];
    } else {
      $this->defaultCompatibility = false;
    }
  }
 
  public function getCompatibilityForFile($itemTreeBounds, $shortname)
  {
    $uploadTreeTableName = $itemTreeBounds->getUploadTreeTableName();
    $uploadTreePk = $itemTreeBounds->getItemId();
    $stmt = __METHOD__.$uploadTreeTableName;
    $sql = "SELECT pfile_fk FROM $uploadTreeTableName UT      
            WHERE UT.uploadtree_pk = $1";
    $result = $this->dbManager->getSingleRow($sql, [$uploadTreePk], $stmt);
    $pfileId = $result["pfile_fk"];
    $uploadId = $itemTreeBounds->getUploadId();
    $scanJobProxy = new ScanJobProxy($this->agentDao, $uploadId);
    $scanJobProxy->createAgentStatus([$this->agentName]);
    $selectedScanners = $scanJobProxy->getLatestSuccessfulAgentIds();
    if (!array_key_exists($this->agentName, $selectedScanners)) {
      throw new InvalidAgentStageException("Agent " . $this->agentName .
        " has not been scheduled/completed on the upload.");
    }
    $latestAgentId = $selectedScanners[$this->agentName];
    $license = $this->licenseDao->getLicenseByShortName($shortname, $groupId=null);
    if ($license === null) {
      return true;
    }
    $licenseId = $license->getId();
    $stmt = __METHOD__ . "getCompResult";
    $sql = "SELECT result FROM comp_result
            WHERE pfile_fk = $1 AND agent_fk= $2 AND result = FALSE AND
            (first_rf_fk = $3 OR second_rf_fk = $3);";
    $res = $this->dbManager->getSingleRow($sql,
      [$pfileId, $latestAgentId, $licenseId], $stmt);
    return empty($res); // If not empty, there is at least 1 false result.
  }
 
  public function getAllRules($limit = 10, $offset = 0, $searchTerm = '')
  {
    $stmt = __METHOD__;
    $params = [];
    $sql = self::RULE_SELECT;
    if (!empty($searchTerm)) {
      $params[] = $searchTerm;
      $sql .= ' WHERE comment ILIKE $' . count($params);
      $stmt .= '.search';
    }
    $params[] = $limit;
    $sql .= ' ORDER BY lr_pk LIMIT $' . count($params);
    $params[] = $offset;
    $sql .= ' OFFSET $' . count($params) . ';';
    return $this->dbManager->getRows($sql, $params, $stmt);
  }
 
  public function getRuleById($rulePk)
  {
    $row = $this->dbManager->getSingleRow(self::RULE_SELECT .
      ' WHERE lr_pk = $1;', [$rulePk], __METHOD__);
    return empty($row) ? null : $row;
  }
 
  public function getTotalRulesCount($searchTerm = '')
  {
    $stmt = __METHOD__;
    $params = [];
    $query = "SELECT COUNT(*) as count FROM license_rules";
    if (!empty($searchTerm)) {
      $params[] = $searchTerm;
      $query .= ' WHERE comment ILIKE $' . count($params);
      $stmt .= '.search';
    }
    $count = $this->dbManager->getSingleRow($query, $params, $stmt);
    return $count ? intval($count['count']) : 0;
  }
 
  public function insertEmptyRule()
  {
    if (!Auth::isAdmin()) {
      return -1;
    }
    $params = [
      'first_rf_fk' => null,
      'second_rf_fk' => null,
      'first_type' => null,
      'second_type' => null,
      'comment' => '',
      'compatibility' => false
    ];
 
    $statement = __METHOD__ . ".insertEmptyLicCompatibilityRule";
    $returning = "lr_pk";
    $returnVal = -1;
 
    try {
      $returnVal = $this->dbManager->insertTableRow("license_rules", $params, $statement, $returning);
    } catch (\Exception $_) {
      $returnVal = -2;
    }
    return $returnVal;
  }
 
  function insertRule($firstName, $secondName, $firstType, $secondType, $comment,
                      $result)
  {
    if (! Auth::isAdmin()) {
      // Only admins can add rules.
      return -1;
    }
    $comment = trim($comment);
    if (empty($comment)) {
      // Cannot insert empty fields.
      return -1;
    }
    $params = [
      'first_rf_fk' => $firstName,
      'second_rf_fk' => $secondName,
      'first_type' => $firstType,
      'second_type' => $secondType,
      'comment' => $comment,
      'compatibility' => $result
    ];
    $statement = __METHOD__ . ".insertNewLicCompatibilityRule";
    $returning = "lr_pk";
    $returnVal = -1;
    try {
      $returnVal = $this->dbManager->insertTableRow("license_rules",
        $params, $statement, $returning);
    } catch (\Exception $_) {
      $returnVal = -2;
    }
    return $returnVal;
  }
 
  function updateRuleFromArray($ruleArray)
  {
    if (!Auth::isAdmin()) {
      // Only admins can update the rules.
      return -1;
    }
    $updated = 0;
    foreach ($ruleArray as $rulePk => $rule) {
      if (count($rule) < 1) {
        throw new \UnexpectedValueException("Rule has no values");
      }
      $this->isRuleIdValid($rulePk);
      $statement = __METHOD__;
      $params = [$rulePk];
      $updateStatement = [];
      if (array_key_exists("firstLic", $rule)) {
        $params[] = $rule["firstLic"];
        $updateStatement[] = "first_rf_fk = $" . count($params);
        $statement .= ".first_rf_fk";
      }
      if (array_key_exists("secondLic", $rule)) {
        $params[] = $rule["secondLic"];
        $updateStatement[] = "second_rf_fk = $" . count($params);
        $statement .= ".second_rf_fk";
      }
      if (array_key_exists("firstType", $rule)) {
        $params[] = $rule["firstType"];
        $updateStatement[] = "first_type = $" . count($params);
        $statement .= ".first_type";
      }
      if (array_key_exists("secondType", $rule)) {
        $params[] = $rule["secondType"];
        $updateStatement[] = "second_type = $" . count($params);
        $statement .= ".second_type";
      }
      if (array_key_exists("comment", $rule)) {
        $params[] = $rule["comment"];
        $updateStatement[] = "comment = $" . count($params);
        $statement .= ".comment";
      }
      if (array_key_exists("result", $rule)) {
        // Booleans are not casted by the driver, unlike on insert.
        $params[] = is_bool($rule["result"]) ?
          $this->dbManager->booleanToDb($rule["result"]) : $rule["result"];
        $updateStatement[] = "compatibility = $" . count($params);
        $statement .= ".compatibility";
      }
      $sql = "UPDATE license_rules " .
             "SET " . join(",", $updateStatement) .
             " WHERE lr_pk = $1 " .
             "RETURNING 1 AS updated;";
      $retVal = $this->dbManager->getSingleRow($sql, $params, $statement);
      $updated += intval($retVal["updated"]);
    }
    return $updated;
  }
 
  private function isRuleIdValid($rulePk)
  {
    if (! is_int($rulePk)) {
      throw new \UnexpectedValueException("Invalid rule id $rulePk");
    }
    $sql = "SELECT count(*) AS cnt FROM license_rules " .
           "WHERE lr_pk = $1;";
 
    $ruleCount = $this->dbManager->getSingleRow($sql, [$rulePk]);
    if ($ruleCount['cnt'] < 1) {
      // Invalid rule id
      throw new \UnexpectedValueException("Invalid rule id $rulePk");
    }
  }
 
  function deleteRule($rulePk)
  {
    if (!Auth::isAdmin()) {
      // Only admins can delete the rules.
      return false;
    }
 
    $stmt = __METHOD__ . "DeletionOfRule";
    $sql = "DELETE FROM license_rules " .
           "WHERE lr_pk = $1 " .
           "RETURNING lr_pk;";
 
    $retVal = $this->dbManager->getSingleRow($sql, [$rulePk], $stmt);
    if ($retVal["lr_pk"] == $rulePk) {
      return true;
    } else {
      return false;
    }
  }
 
  public function getDefaultCompatibility()
  {
    return $this->defaultCompatibility;
  }
}