UploadHelper.php

Go to the documentation of this file.

<?php
namespace Fossology\UI\Api\Helper;

use Psr\Http\Message\ServerRequestInterface;
use Fossology\UI\Api\Helper\UploadHelper\HelperToUploadFilePage;
use Fossology\UI\Api\Helper\UploadHelper\HelperToUploadVcsPage;
use Fossology\UI\Api\Helper\UploadHelper\HelperToUploadUrlPage;
use Fossology\UI\Api\Helper\UploadHelper\HelperToUploadSrvPage;
use Fossology\UI\Api\Models\UploadSummary;
use Fossology\Lib\Db\DbManager;
use Fossology\Lib\Proxy\ScanJobProxy;
use Fossology\Lib\Dao\AgentDao;

class UploadHelper
{
  private $uploadFilePage;

  private $uploadVcsPage;

  private $uploadUrlPage;

  private $uploadSrvPage;

  const VALID_VCS_TYPES = array(
    "git",
    "svn"
  );

  const VALID_UPLOAD_TYPES = array(
    "vcs",
    "url",
    "server"
  );

  public function __construct()
  {
    $this->uploadFilePage = new HelperToUploadFilePage();
    $this->uploadVcsPage = new HelperToUploadVcsPage();
    $this->uploadUrlPage = new HelperToUploadUrlPage();
    $this->uploadSrvPage = new HelperToUploadSrvPage();
  }

  public function createNewUpload(ServerRequestInterface $request, $folderId,
    $fileDescription, $isPublic, $ignoreScm, $uploadType)
  {
    $uploadedFile = $request->getUploadedFiles();
    $body = $request->getParsedBody();

    if (! empty($ignoreScm) && ($ignoreScm == "true" || $ignoreScm)) {
      // If SCM should be ignored
      $ignoreScm = 1;
    } else {
      $ignoreScm = 0;
    }
    if (empty($uploadedFile) ||
      ! isset($uploadedFile[$this->uploadFilePage::FILE_INPUT_NAME])) {
      if (empty($uploadType)) {
        return array(false, "Missing 'uploadType' header",
          "Send file with parameter " . $this->uploadFilePage::FILE_INPUT_NAME .
          " or define 'uploadType' header with appropriate body.",
          - 1
        );
      }
      return $this->handleUpload($body, $uploadType, $folderId,
        $fileDescription, $isPublic, $ignoreScm);
    } else {
      $uploadedFile = $uploadedFile[$this->uploadFilePage::FILE_INPUT_NAME];
      return $this->createFileUpload($uploadedFile, $folderId,
        $fileDescription, $isPublic, $ignoreScm);
    }
  }

  private function createFileUpload($uploadedFile, $folderId, $fileDescription,
    $isPublic, $ignoreScm = 0)
  {
    $path = $uploadedFile->file;
    $originalName = $uploadedFile->getClientFilename();
    $originalMime = $uploadedFile->getClientMediaType();
    $originalError = $uploadedFile->getError();
    $symfonyFile = new \Symfony\Component\HttpFoundation\File\UploadedFile(
      $path, $originalName, $originalMime, $originalError);
    $symfonyRequest = new \Symfony\Component\HttpFoundation\Request();
    $symfonySession = $GLOBALS['container']->get('session');
    $symfonySession->set(
      $this->uploadFilePage::UPLOAD_FORM_BUILD_PARAMETER_NAME, "restUpload");

    $symfonyRequest->request->set($this->uploadFilePage::FOLDER_PARAMETER_NAME,
      $folderId);
    $symfonyRequest->request->set($this->uploadFilePage::DESCRIPTION_INPUT_NAME,
      $fileDescription);
    $symfonyRequest->files->set($this->uploadFilePage::FILE_INPUT_NAME,
      $symfonyFile);
    $symfonyRequest->setSession($symfonySession);
    $symfonyRequest->request->set(
      $this->uploadFilePage::UPLOAD_FORM_BUILD_PARAMETER_NAME, "restUpload");
    $symfonyRequest->request->set('public', $isPublic);
    $symfonyRequest->request->set('scm', $ignoreScm);

    return $this->uploadFilePage->handleRequest($symfonyRequest);
  }

  private function handleUpload($body, $uploadType, $folderId, $fileDescription,
    $isPublic, $ignoreScm = 0)
  {
    $sanity = false;
    switch ($uploadType) {
      case "vcs":
        $sanity = $this->sanitizeVcsData($body);
        break;
      case "url":
        $sanity = $this->sanitizeUrlData($body);
        break;
      case "server":
        $sanity = $this->sanitizeSrvData($body);
        break;
      default:
        $message = "Invalid 'uploadType'";
        $statusDescription = "uploadType should be any of (" .
          implode(",", self::VALID_UPLOAD_TYPES) . ")";
        $code = 400;
        $sanity = array(false, $message, $statusDescription, $code);
    }
    if ($sanity !== true) {
      return $sanity;
    }
    $uploadResponse = false;
    switch ($uploadType) {
      case "vcs":
        $uploadResponse = $this->generateVcsUpload($body, $folderId,
          $fileDescription, $isPublic, $ignoreScm);
        break;
      case "url":
        $uploadResponse = $this->generateUrlUpload($body, $folderId,
          $fileDescription, $isPublic, $ignoreScm);
        break;
      case "server":
        $uploadResponse = $this->generateSrvUpload($body, $folderId,
          $fileDescription, $isPublic, $ignoreScm);
        break;
    }
    return $uploadResponse;
  }

  private function sanitizeVcsData(&$vcsData)
  {
    $message = "";
    $statusDescription = "";
    $code = 0;

    if (! array_key_exists("vcsType", $vcsData) ||
      ! in_array($vcsData["vcsType"], self::VALID_VCS_TYPES)) {
      $message = "Missing vcsType";
      $statusDescription = "vcsType should be any of (" .
        implode(", ", self::VALID_VCS_TYPES) . ")";
      $code = 400;
    }
    $vcsType = "";
    if ($vcsData["vcsType"] == "git") {
      $vcsType = "Git";
    } else {
      $vcsType = "SVN";
    }

    if (! array_key_exists("vcsUrl", $vcsData)) {
      $message = "Missing vcsUrl";
      $statusDescription = "vcsUrl should be passed.";
      $code = 400;
    }

    if (! array_key_exists("vcsName", $vcsData)) {
      $vcsData["vcsName"] = "";
    }
    if (! array_key_exists("vcsUsername", $vcsData)) {
      $vcsData["vcsUsername"] = "";
    }
    if (! array_key_exists("vcsPassword", $vcsData)) {
      $vcsData["vcsPassword"] = "";
    }
    if (! array_key_exists("vcsBranch", $vcsData)) {
      $vcsData["vcsBranch"] = "";
    }
    $vcsData["vcsType"] = $vcsType;
    if ($code !== 0) {
      return array(false, $message, $statusDescription, $code);
    } else {
      return true;
    }
  }

  private function sanitizeUrlData(&$urlData)
  {
    $message = "";
    $statusDescription = "";
    $code = 0;

    if (! array_key_exists("url", $urlData)) {
      $message = "Missing url";
      $statusDescription = "Missing upload url from request";
      $code = 400;
    }

    if (! array_key_exists("name", $urlData)) {
      $urlData["name"] = "";
    }
    if (! array_key_exists("accept", $urlData)) {
      $urlData["accept"] = "";
    }
    if (! array_key_exists("reject", $urlData)) {
      $urlData["reject"] = "";
    }
    if (! array_key_exists("maxRecursionDepth", $urlData)) {
      $urlData["maxRecursionDepth"] = "";
    }
    if ($code !== 0) {
      return array(false, $message, $statusDescription, $code);
    } else {
      return true;
    }
  }

  private function sanitizeSrvData(&$srvData)
  {
    $message = "";
    $statusDescription = "";
    $code = 0;

    if (! array_key_exists("path", $srvData)) {
      $message = "Missing path";
      $statusDescription = "Missing upload path from request";
      $code = 400;
    }

    if (! array_key_exists("name", $srvData)) {
      $srvData["name"] = "";
    }
    if ($code !== 0) {
      return array(false, $message, $statusDescription, $code);
    } else {
      return true;
    }
  }

  private function generateVcsUpload($vcsData, $folderId, $fileDescription,
    $isPublic, $ignoreScm)
  {
    $vcsType = $vcsData["vcsType"];
    $vcsUrl = $vcsData["vcsUrl"];
    $vcsName = $vcsData["vcsName"];
    $vcsUsername = $vcsData["vcsUsername"];
    $vcsPasswd = $vcsData["vcsPassword"];
    $vcsBranch = $vcsData["vcsBranch"];

    $symfonySession = $GLOBALS['container']->get('session');
    $symfonySession->set($this->uploadVcsPage::UPLOAD_FORM_BUILD_PARAMETER_NAME,
      "restUpload");

    $symfonyRequest = new \Symfony\Component\HttpFoundation\Request();
    $symfonyRequest->setSession($symfonySession);

    $symfonyRequest->request->set($this->uploadVcsPage::FOLDER_PARAMETER_NAME,
      $folderId);
    $symfonyRequest->request->set($this->uploadVcsPage::DESCRIPTION_INPUT_NAME,
      $fileDescription);
    $symfonyRequest->request->set($this->uploadVcsPage::GETURL_PARAM, $vcsUrl);
    $symfonyRequest->request->set(
      $this->uploadVcsPage::UPLOAD_FORM_BUILD_PARAMETER_NAME, "restUpload");
    $symfonyRequest->request->set('public', $isPublic);
    $symfonyRequest->request->set('name', $vcsName);
    $symfonyRequest->request->set('vcstype', $vcsType);
    $symfonyRequest->request->set('username', $vcsUsername);
    $symfonyRequest->request->set('passwd', $vcsPasswd);
    $symfonyRequest->request->set('branch', $vcsBranch);
    $symfonyRequest->request->set('scm', $ignoreScm);

    return $this->uploadVcsPage->handleRequest($symfonyRequest);
  }

  private function generateUrlUpload($urlData, $folderName, $fileDescription,
    $isPublic, $ignoreScm)
  {
    $url = $urlData["url"];
    $name = $urlData["name"];
    $accept = $urlData["accept"];
    $reject = $urlData["reject"];
    $maxRecursionDepth = $urlData["maxRecursionDepth"];

    $symfonySession = $GLOBALS['container']->get('session');
    $symfonySession->set($this->uploadUrlPage::UPLOAD_FORM_BUILD_PARAMETER_NAME,
      "restUpload");

    $symfonyRequest = new \Symfony\Component\HttpFoundation\Request();
    $symfonyRequest->setSession($symfonySession);

    $symfonyRequest->request->set($this->uploadUrlPage::FOLDER_PARAMETER_NAME,
      $folderName);
    $symfonyRequest->request->set($this->uploadUrlPage::DESCRIPTION_INPUT_NAME,
      $fileDescription);
    $symfonyRequest->request->set(
      $this->uploadUrlPage::UPLOAD_FORM_BUILD_PARAMETER_NAME, "restUpload");
    $symfonyRequest->request->set('public', $isPublic);
    $symfonyRequest->request->set($this->uploadUrlPage::NAME_PARAM, $name);
    $symfonyRequest->request->set($this->uploadUrlPage::ACCEPT_PARAM, $accept);
    $symfonyRequest->request->set($this->uploadUrlPage::REJECT_PARAM, $reject);
    $symfonyRequest->request->set($this->uploadUrlPage::GETURL_PARAM, $url);
    $symfonyRequest->request->set($this->uploadUrlPage::LEVEL_PARAM,
      $maxRecursionDepth);
    $symfonyRequest->request->set('scm', $ignoreScm);

    return $this->uploadUrlPage->handleRequest($symfonyRequest);
  }

  private function generateSrvUpload($srvData, $folderName, $fileDescription,
    $isPublic, $ignoreScm)
  {
    $path = $srvData["path"];
    $name = $srvData["name"];

    $symfonySession = $GLOBALS['container']->get('session');
    $symfonySession->set($this->uploadSrvPage::UPLOAD_FORM_BUILD_PARAMETER_NAME,
      "restUpload");

    $symfonyRequest = new \Symfony\Component\HttpFoundation\Request();
    $symfonyRequest->setSession($symfonySession);

    $symfonyRequest->request->set($this->uploadSrvPage::FOLDER_PARAMETER_NAME,
      $folderName);
    $symfonyRequest->request->set($this->uploadSrvPage::DESCRIPTION_INPUT_NAME,
      $fileDescription);
    $symfonyRequest->request->set(
      $this->uploadSrvPage::UPLOAD_FORM_BUILD_PARAMETER_NAME, "restUpload");
    $symfonyRequest->request->set('public', $isPublic);
    $symfonyRequest->request->set($this->uploadSrvPage::SOURCE_FILES_FIELD,
      $path);
    $symfonyRequest->request->set($this->uploadSrvPage::NAME_PARAM, $name);
    $symfonyRequest->request->set('scm', $ignoreScm);

    return $this->uploadSrvPage->handleRequest($symfonyRequest);
  }

  public function generateUploadSummary($uploadId, $groupId)
  {
    global $container;
    $restHelper = $container->get('helper.restHelper');
    $uploadDao = $restHelper->getUploadDao();
    $dbManager = $restHelper->getDbHelper()->getDbManager();
    $clearingDao = $container->get('dao.clearing');
    $copyrightDao = $container->get('dao.copyright');
    $agentDao = $container->get('dao.agent');

    $agentName = "copyright";

    $totalClearings = $clearingDao->getTotalDecisionCount($uploadId, $groupId);
    $clearingCount = $clearingDao->getClearingDecisionsCount($uploadId,
      $groupId);
    $uploadTreeTableName = $uploadDao->getUploadtreeTableName($uploadId);
    $itemTreeBounds = $uploadDao->getParentItemBounds($uploadId,
      $uploadTreeTableName);
    $scanProx = new ScanJobProxy($agentDao, $uploadId);
    $scanProx->createAgentStatus([$agentName]);
    $agents = $scanProx->getLatestSuccessfulAgentIds();
    $copyrightCount = 0;
    if (array_key_exists($agentName, $agents) && ! empty($agents[$agentName])) {
      $copyrightCount = count(
        $copyrightDao->getAllEntriesReport($agentName, $uploadId,
          $uploadTreeTableName, null, false, null, "C.agent_fk = " .
          $agents[$agentName], $groupId));
    }

    $mainLicenses = $this->getMainLicenses($dbManager, $uploadId, $groupId);

    $uiLicense = $restHelper->getPlugin("license");
    $hist = $uiLicense->getUploadHist($itemTreeBounds);

    $summary = new UploadSummary();
    $summary->setUploadId($uploadId);
    $summary->setUploadName($uploadDao->getUpload($uploadId)->getFilename());
    if ($mainLicenses !== null) {
      $summary->setMainLicense(implode(",", $mainLicenses));
    }
    $summary->setUniqueLicenses($hist['uniqueLicenseCount']);
    $summary->setTotalLicenses($hist['scannerLicenseCount']);
    $summary->setUniqueConcludedLicenses($hist['editedUniqueLicenseCount']);
    $summary->setTotalConcludedLicenses($hist['editedLicenseCount']);
    $summary->setFilesToBeCleared($totalClearings - $clearingCount);
    $summary->setFilesCleared($clearingCount);
    $summary->setClearingStatus($uploadDao->getStatus($uploadId, $groupId));
    $summary->setCopyrightCount($copyrightCount);
    return $summary;
  }

  private function getMainLicenses($dbManager, $uploadId, $groupId)
  {
    $sql = "SELECT rf_shortname FROM upload_clearing_license ucl, license_ref"
         . " WHERE ucl.group_fk=$1 AND upload_fk=$2 AND ucl.rf_fk=rf_pk;";
    $stmt = __METHOD__.'.collectMainLicenses';
    $rows = $dbManager->getRows($sql, array($groupId, $uploadId), $stmt);
    if (empty($rows)) {
      return null;
    }
    $mainLicenses = [];
    foreach ($rows as $row) {
      array_push($mainLicenses, $row['rf_shortname']);
    }
    return $mainLicenses;
  }

  public function getUploadLicenseList($uploadId, $agents, $printContainers)
  {
    global $container;
    $restHelper = $container->get('helper.restHelper');
    $uploadDao = $restHelper->getUploadDao();
    $agentDao = $container->get('dao.agent');

    $uploadTreeTableName = $uploadDao->getUploadtreeTableName($uploadId);
    $parent = $uploadDao->getParentItemBounds($uploadId, $uploadTreeTableName);

    $scanProx = new ScanJobProxy($agentDao, $uploadId);
    $scanProx->createAgentStatus($agents);
    $agent_ids = $scanProx->getLatestSuccessfulAgentIds();

    $licenseListObj = $restHelper->getPlugin('export-list');
    $licenseList = $licenseListObj->createListOfLines($uploadTreeTableName,
      $parent->getItemId(), $agent_ids, -1, true, '', !$printContainers);
    if (array_key_exists("warn", $licenseList)) {
      unset($licenseList["warn"]);
    }
    return $licenseList;
  }
}