FileSearchController.php

Go to the documentation of this file.

<?php
/*
 SPDX-FileCopyrightText: © 2020 Siemens AG
 Author: Gaurav Mishra <mishra.gaurav@siemens.com>
 
 SPDX-License-Identifier: GPL-2.0-only
*/
namespace Fossology\UI\Api\Controllers;
 
use Fossology\Lib\Dao\ClearingDao;
use Fossology\Lib\Dao\LicenseDao;
use Fossology\UI\Api\Helper\FileHelper;
use Fossology\UI\Api\Helper\ResponseHelper;
use Fossology\UI\Api\Models\File;
use Fossology\UI\Api\Models\Findings;
use Fossology\UI\Api\Models\Hash;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ServerRequestInterface;
 
class FileSearchController extends RestController
{
  private $fileHelper;
 
  private $clearingDao;
 
  private $licenseDao;
 
  public function __construct($container)
  {
    parent::__construct($container);
    $this->fileHelper = $this->container->get('helper.fileHelper');
    $this->clearingDao = $this->container->get('dao.clearing');
    $this->licenseDao = $this->container->get('dao.license');
  }
 
  public function getFiles($request, $response, $args)
  {
    $fileListJSON = $this->getParsedBody($request);
    $inputFileList = File::parseFromArray($fileListJSON);
    $existsList = [];
    $nonExistsList = [];
 
    foreach ($inputFileList as $inputFile) {
      if ($inputFile->getMessage() == File::INVALID) {
        $nonExistsList[] = $inputFile;
        continue;
      }
 
      $pfileId = $this->getPfileId($inputFile);
      if ($pfileId !== false) {
        $existsList[$pfileId] = $inputFile;
      } else {
        $inputFile->setMessage(File::NOT_FOUND);
        $nonExistsList[] = $inputFile;
      }
    }
 
    $this->getInfoForFiles($existsList);
    $existsList = array_values($existsList);
 
    foreach ($nonExistsList as $file) {
      $existsList[] = $file;
    }
    return $response->withJson(array_map(function ($file) {
        return $file->getArray();
    }, $existsList), 200);
  }
 
  private function getPfileId(&$file)
  {
    $hash = $file->getHash();
    $pfile = $this->fileHelper->getPfile($hash);
    if ($pfile === null) {
      return false;
    }
    $newHash = new Hash($pfile['pfile_sha1'], $pfile['pfile_md5'],
      $pfile['pfile_sha256'], $pfile['pfile_size']);
    $file->setHash($newHash);
    return intval($pfile['pfile_pk']);
  }
 
  private function getInfoForFiles(&$inputFileList)
  {
    foreach ($inputFileList as $pfileId => $file) {
      $uploads = $this->getPackageUpload($pfileId);
      if (! empty($uploads)) {
        $scannerFindings = [];
        $copyright = [];
        $conclusions = $this->getMainLicenses($uploads);
      } else {
        $scannerFindings = $this->getFileFindings($pfileId);
        $conclusions = $this->getFileConclusions($pfileId);
        $copyright = $this->getFileCopyright($pfileId);
      }
      $findings = new Findings();
      $findings->setScanner($scannerFindings);
      $findings->setConclusion($conclusions);
      $findings->setCopyright($copyright);
      $inputFileList[$pfileId]->setFindings($findings);
      $inputFileList[$pfileId]->setUploads($uploads);
    }
  }
 
  private function getFileFindings($pfileId)
  {
    return $this->fileHelper->pfileScannerFindings($pfileId);
  }
 
  private function getFileConclusions($pfileId)
  {
    return $this->fileHelper->pfileConclusions($this->restHelper->getGroupId(),
      $pfileId);
  }
 
  private function getFileCopyright($pfileId)
  {
    return $this->fileHelper->pfileCopyright($pfileId);
  }
 
  private function getPackageUpload($pfileId)
  {
    return $this->filterAccessibleUploads(
      $this->fileHelper->getPackageUpload($pfileId));
  }
 
  private function filterAccessibleUploads($uploads)
  {
    if (empty($uploads)) {
      return [];
    }
    return array_filter($uploads, function ($upload) {
      return $this->restHelper->getUploadDao()->isAccessible($upload,
        $this->restHelper->getGroupId());
    });
  }
 
  private function getMainLicenses($uploads)
  {
    $mainLicenses = array();
    foreach ($uploads as $upload) {
      $licenses = $this->clearingDao->getMainLicenseIds($upload,
        $this->restHelper->getGroupId());
      foreach ($licenses as $licenseId) {
        $license = $this->licenseDao->getLicenseById($licenseId,
          $this->restHelper->getGroupId());
        if ($license !== null) {
          $mainLicenses[$license->getId()] = $license->getShortName();
        }
      }
    }
    natcasesort($mainLicenses);
    return array_values($mainLicenses);
  }
}