ui-export-list.php

Go to the documentation of this file.

<?php
/*
 SPDX-FileCopyrightText: © 2014-2017, 2020 Siemens AG
 SPDX-FileCopyrightText: © 2021 LG Electronics Inc.
 
 SPDX-License-Identifier: GPL-2.0-only
*/
 
use Fossology\Lib\Auth\Auth;
use Fossology\Lib\BusinessRules\ClearingDecisionFilter;
use Fossology\Lib\Dao\ClearingDao;
use Fossology\Lib\Dao\CopyrightDao;
use Fossology\Lib\Dao\LicenseDao;
use Fossology\Lib\Dao\TreeDao;
use Fossology\Lib\Dao\UploadDao;
use Fossology\Lib\Data\AgentRef;
use Fossology\Lib\Data\Tree\ItemTreeBounds;
use Fossology\Lib\Proxy\ScanJobProxy;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use Symfony\Component\HttpFoundation\Response;
 
class UIExportList extends FO_Plugin
{
  private $uploadDao;
 
  private $licenseDao;
 
  private $clearingDao;
 
  private $copyrightDao;
 
  private $clearingFilter;
 
  private $treeDao;
 
  protected $delimiter = ',';
 
  protected $enclosure = '"';
 
  function __construct()
  {
    $this->Name = "export-list";
    $this->Title = _("Export Lists");
    $this->Dependency = array("browse");
    $this->DBaccess = PLUGIN_DB_READ;
    $this->LoginFlag = 0;
    $this->NoHeader = 0;
    parent::__construct();
    $this->uploadDao = $GLOBALS['container']->get('dao.upload');
    $this->licenseDao = $GLOBALS['container']->get('dao.license');
    $this->clearingDao = $GLOBALS['container']->get('dao.clearing');
    $this->copyrightDao = $GLOBALS['container']->get('dao.copyright');
    $this->treeDao = $GLOBALS['container']->get('dao.tree');
    $this->clearingFilter = $GLOBALS['container']->get('businessrules.clearing_decision_filter');
  }
 
  public function setDelimiter($delimiter=',')
  {
    $this->delimiter = substr($delimiter, 0, 1);
  }
 
  public function setEnclosure($enclosure='"')
  {
    $this->enclosure = substr($enclosure, 0, 1);
  }
 
  function RegisterMenus()
  {
    // For all other menus, permit coming back here.
    $URI = $this->Name . Traceback_parm_keep(array(
                "show",
                "format",
                "page",
                "upload",
                "item",
    ));
    $MenuDisplayString = _("Export List");
    $Item = GetParm("item", PARM_INTEGER);
    $Upload = GetParm("upload", PARM_INTEGER);
    if (empty($Item) || empty($Upload)) {
      return;
    }
    if (GetParm("mod", PARM_STRING) == $this->Name) {
      menu_insert("Browse::$MenuDisplayString", 1);
    } else {
      menu_insert("Browse::$MenuDisplayString", 1, $URI, $MenuDisplayString);
      /* bobg - This is to use a select list in the micro menu to replace the above List
        and Download, but put this select list in a form
        $LicChoices = array("Lic Download" => "Download", "Lic display" => "Display");
        $LicChoice = Array2SingleSelect($LicChoices, $SLName="LicDL");
        menu_insert("Browse::Nomos License List Download2", 1, $URI . "&output=dltext", NULL,NULL, $LicChoice);
       */
    }
  }
 
  function getAgentPksFromRequest($upload_pk)
  {
    $agents = array_keys(AgentRef::AGENT_LIST);
    $agent_pks = array();
 
    foreach ($agents as $agent) {
      if (GetParm("agentToInclude_".$agent, PARM_STRING)) {
        /* get last nomos agent_pk that has data for this upload */
        $AgentRec = AgentARSList($agent."_ars", $upload_pk, 1);
        if (!empty($AgentRec)) {
          $agent_pks[$agent] = $AgentRec[0]["agent_fk"];
        } else {
          $agent_pks[$agent] = false;
        }
      }
    }
    return $agent_pks;
  }
 
  public function createListOfLines($uploadtreeTablename, $uploadtree_pk,
    $agent_pks, $NomostListNum, $includeSubfolder, $exclude, $ignore)
  {
     $licensesPerFileName = array();
    $itemTreeBounds = $this->uploadDao->getItemTreeBounds($uploadtree_pk,
      $uploadtreeTablename);
    $allDecisions = $this->clearingDao->getFileClearingsFolder($itemTreeBounds,
      Auth::getGroupId());
    $editedMappedLicenses = $this->clearingFilter->filterCurrentClearingDecisionsForLicenseList($allDecisions);
    $licensesPerFileName = $this->licenseDao->getLicensesPerFileNameForAgentId($itemTreeBounds,
      $agent_pks, $includeSubfolder, $exclude, $ignore, $editedMappedLicenses,
      true);
    /* how many lines of data do you want to display */
    $currentNum = 0;
    $lines = [];
    foreach ($licensesPerFileName as $fileName => $licenseNames) {
      if ($licenseNames !== false && count($licenseNames) > 0) {
        if ($NomostListNum > -1 && ++$currentNum > $NomostListNum) {
          $lines["warn"] = _("<br><b>Warning: Only the first $NomostListNum " .
            "lines are displayed.  To see the whole list, run " .
            "fo_nomos_license_list from the command line.</b><br>");
          // TODO: the following should be done using a "LIMIT" statement in the sql query
          break;
        }
 
        $row = array();
        $row['filePath'] = $fileName;
        if (array_key_exists('scanResults', $licenseNames)) {
          $row['agentFindings'] = $licenseNames['scanResults'];
        } else {
          $row['agentFindings'] = null;
        }
        $row['conclusions'] = null;
        $row['uploadtree_pk'] = $licenseNames['uploadtree_pk'][0];
        if (array_key_exists('concludedResults', $licenseNames) && !empty($licenseNames['concludedResults'])) {
          $row['conclusions'] = $this->consolidateConclusions($licenseNames['concludedResults']);
        }
        $lines[] = $row;
      }
      if (!$ignore && $licenseNames === false) {
        $row = array();
        $row['filePath'] = $fileName;
        $row['agentFindings'] = null;
        $row['conclusions'] = null;
        $lines[] = $row;
      }
    }
    return $lines;
  }
 
  public function getTemplateName()
  {
    return "ui-export-list.html.twig";
  }
 
  function Output()
  {
    global $PG_CONN;
    global $SysConf;
    $formVars = array();
    if (!$PG_CONN) {
      echo _("NO DB connection");
    }
 
    if ($this->State != PLUGIN_STATE_READY) {
      return (0);
    }
    $uploadtree_pk = GetParm("item", PARM_INTEGER);
    if (empty($uploadtree_pk)) {
      return;
    }
 
    $upload_pk = GetParm("upload", PARM_INTEGER);
    if (empty($upload_pk)) {
      return;
    }
    if (!$this->uploadDao->isAccessible($upload_pk, Auth::getGroupId())) {
      $text = _("Permission Denied");
      return "<h2>$text</h2>";
    }
    $uploadtreeTablename = GetUploadtreeTableName($upload_pk);
 
    $warnings = array();
    $exportCopyright = GetParm('export_copy', PARM_STRING);
    if (!empty($exportCopyright) && $exportCopyright == "yes") {
      $exportCopyright = true;
      $copyrightType = GetParm('copyright_type', PARM_STRING);
      $formVars["export_copy"] = "1";
      if ($copyrightType == "all") {
        $formVars["copy_type_all"] = 1;
      } else {
        $formVars["copy_type_nolic"] = 1;
      }
    } else {
      $exportCopyright = false;
      $agent_pks_dict = $this->getAgentPksFromRequest($upload_pk);
      $agent_pks = array();
      foreach ($agent_pks_dict as $agent_name => $agent_pk) {
        if ($agent_pk === false) {
          $warnings[] = _("No information for agent: $agent_name");
        } else {
          $agent_pks[] = $agent_pk;
          $formVars["agentToInclude_".$agent_name] = "1";
        }
      }
    }
 
    // Make sure all copyrights is selected in the form be default
    if (!(array_key_exists('copy_type_all', $formVars) ||
      array_key_exists('copy_type_nolic', $formVars))) {
      $formVars["copy_type_all"] = 1;
    }
 
    $dltext = (GetParm("output", PARM_STRING) == 'dltext');
    $formVars["dltext"] = $dltext;
    $dlspreadsheet = (GetParm("output", PARM_STRING) == 'dlspreadsheet');
    $formVars["dlspreadsheet"] = $dlspreadsheet;
    if (!$dltext&&!$dlspreadsheet) {
      $formVars["noDownload"] = true;
    } else {
      $formVars["noDownload"] = false;
    }
 
    $NomostListNum = @$SysConf['SYSCONFIG']['NomostListNum'];
    $formVars["NomostListNum"] = $NomostListNum;
 
    $includeSubfolder = (GetParm("doNotIncludeSubfolder", PARM_STRING) !== "yes");
    $formVars["includeSubfolder"] = $includeSubfolder;
 
    $ignore = (GetParm("showContainers", PARM_STRING) !== "yes");
    $formVars["showContainers"] = !$ignore;
    $exclude = GetParm("exclude", PARM_STRING);
    $formVars["exclude"] = $exclude;
 
    $consolidateLicenses = (GetParm("consolidate", PARM_STRING) == "perFile");
    $formVars["perFile"] = $consolidateLicenses;
    $consolidatePerDirectory = (GetParm("consolidate", PARM_STRING) == "perDirectory");
    $formVars["perDirectory"] = $consolidatePerDirectory;
    if (!$consolidateLicenses&&!$consolidatePerDirectory) {
      $formVars["rawResult"] = true;
    } else {
      $formVars["rawResult"] = false;
    }
 
    $this->vars = array_merge($this->vars, $formVars);
 
    if ($exportCopyright) {
      $lines = $this->getCopyrights($upload_pk, $uploadtree_pk,
        $uploadtreeTablename, $NomostListNum, $exclude, $copyrightType);
    } else {
      $lines = $this->createListOfLines($uploadtreeTablename, $uploadtree_pk,
        $agent_pks, $NomostListNum, $includeSubfolder, $exclude, $ignore);
    }
 
    $this->vars['warnings'] = array();
    if (array_key_exists("warn",$lines)) {
      $warnings[] = $lines["warn"];
      unset($lines["warn"]);
    }
    foreach ($warnings as $warning) {
      $this->vars['warnings'][] = "<br><b>$warning</b><br>";
    }
    if (empty($lines)) {
      $this->vars['warnings'][] = "<br /><b>Result empty</b><br />";
    }
 
    if ($consolidateLicenses||$consolidatePerDirectory) {
      $lines = $this->consolidateResult($lines);
    }
    if ($consolidatePerDirectory) {
      $lines = $this->consolidateFindingsPerDirectory($lines);
    }
 
    if ($dltext) {
      return $this->printCSV($lines, $uploadtreeTablename, $exportCopyright);
    } elseif ($dlspreadsheet) {
      return $this->printSpreadsheet($lines, $uploadtreeTablename);
    } else {
      $this->vars['listoutput'] = $this->printLines($lines, $exportCopyright);
      return;
    }
  }
 
  public function getCopyrights($uploadId, $uploadtree_pk, $uploadTreeTableName,
    $NomostListNum, $exclude, $copyrightType = "all")
  {
    $agentName = array('copyright', 'reso');
    $scanJobProxy = new ScanJobProxy($GLOBALS['container']->get('dao.agent'),
      $uploadId);
    $scanJobProxy->createAgentStatus($agentName);
    $selectedScanners = $scanJobProxy->getLatestSuccessfulAgentIds();
    if (!array_key_exists($agentName[0], $selectedScanners)) {
      return array();
    }
    $latestAgentIds[] = $selectedScanners[$agentName[0]];
    if (array_key_exists($agentName[1], $selectedScanners)) {
      $latestAgentIds[] = $selectedScanners[$agentName[1]];
    }
    $ids = implode(',', $latestAgentIds);
    $agentFilter = ' AND C.agent_fk IN ('.$ids.')';
 
    $itemTreeBounds = $this->uploadDao->getItemTreeBounds($uploadtree_pk,
      $uploadTreeTableName);
    $extrawhere = "UT.lft BETWEEN " . $itemTreeBounds->getLeft() . " AND " .
      $itemTreeBounds->getRight();
    if (! empty($exclude)) {
      $extrawhere .= " AND UT.ufile_name NOT LIKE '%$exclude%'";
    }
    $lines = [];
    $uploadtreePkToFilePath = [];
 
    $copyrights =  $this->copyrightDao->getScannerEntries($agentName[0],
      $uploadTreeTableName, $uploadId, null, $extrawhere . $agentFilter);
    $this->updateCopyrightList($lines, $uploadtreePkToFilePath, $copyrights,
      $NomostListNum, $uploadTreeTableName, "content");
 
    $copyrights = $this->copyrightDao->getEditedEntries('copyright_decision',
      $uploadTreeTableName, $uploadId, [], $extrawhere);
    $this->updateCopyrightList($lines, $uploadtreePkToFilePath, $copyrights,
      $NomostListNum, $uploadTreeTableName, "textfinding");
 
    if ($copyrightType != "all") {
      $agentList = [];
      foreach (AgentRef::AGENT_LIST as $agentname => $value) {
        $AgentRec = AgentARSList($agentname."_ars", $uploadId, 1);
        if (!empty($AgentRec)) {
          $agentList[] = $AgentRec[0]["agent_fk"];
        }
      }
      $this->removeCopyrightWithLicense($lines, $uploadtreePkToFilePath,
        $itemTreeBounds, $agentList, $exclude);
    }
    return $this->reduceCopyrightLines($lines);
  }
 
  private function updateCopyrightList(&$list, &$uploadtreePkToFilePath,
    $newCopyrights, $NomostListNum, $uploadTreeTableName, $key)
  {
    foreach ($newCopyrights as $copyright) {
      if ($NomostListNum > -1 && count($list) >= $NomostListNum) {
        $list["warn"] = _("<br><b>Warning: Only the first $NomostListNum lines
 are displayed. To see the whole list, run fo_nomos_license_list from the
 command line.</b><br>");
        break;
      }
      $row = [];
      $row["content"] = $copyright[$key];
      $row["filePath"] = $this->treeDao->getFullPath($copyright["uploadtree_pk"],
        $uploadTreeTableName);
      $uploadtreePkToFilePath[$copyright["uploadtree_pk"]] = $row["filePath"];
      $list[$row["filePath"]][] = $row;
    }
  }
 
  private function removeCopyrightWithLicense(&$lines,
    $uploadtreePkToFilePath, $itemTreeBounds, $agentList, $exclude)
  {
    $licensesPerFileName = array();
    $allDecisions = $this->clearingDao->getFileClearingsFolder($itemTreeBounds,
      Auth::getGroupId());
    $editedMappedLicenses = $this->clearingFilter->filterCurrentClearingDecisionsForCopyrightList(
      $allDecisions);
    $licensesPerFileName = $this->licenseDao->getLicensesPerFileNameForAgentId(
      $itemTreeBounds, $agentList, true, $exclude, true, $editedMappedLicenses,
      true);
    foreach ($licensesPerFileName as $licenseNames) {
      if ($licenseNames !== false && count($licenseNames) > 0) {
        $shouldRemove = false;
        if (array_key_exists('concludedResults', $licenseNames)) {
          $conclusions = $this->consolidateConclusions($licenseNames['concludedResults']);
          if (in_array("Void", $conclusions)) {
            // File has all licenses removed or irrelevant decision
            continue;
          }
          // File has license conclusions
          $shouldRemove = true;
        }
        if ((! empty($licenseNames['scanResults'])) &&
          ! (in_array("No_license_found", $licenseNames['scanResults']) ||
          in_array("Void", $licenseNames['scanResults']))) {
          $shouldRemove = true;
        }
        if ($shouldRemove) {
          $this->removeCopyrightByUploadtreePk($lines, $uploadtreePkToFilePath,
            $licenseNames['uploadtree_pk']);
        }
      }
    }
  }
 
  private function consolidateConclusions($conclusions)
  {
    $consolidatedConclusions = array();
    foreach ($conclusions as $conclusion) {
      $consolidatedConclusions = array_merge($consolidatedConclusions,
        $conclusion);
    }
    return array_unique($consolidatedConclusions);
  }
 
  private function removeCopyrightByUploadtreePk(&$lines,
    $uploadtreePkToFilePath, $uploadtreePks)
  {
    foreach ($uploadtreePks as $uploadtreePk) {
      if (array_key_exists($uploadtreePk, $uploadtreePkToFilePath)) {
        unset($lines[$uploadtreePkToFilePath[$uploadtreePk]]);
      }
    }
  }
 
  private function printLines($lines, $copyright=false)
  {
    $V = '';
    if ($copyright) {
      foreach ($lines as $row) {
        $V .= $row['filePath'] . ": " . htmlentities($row['content']) . "\n";
      }
    } else {
      foreach ($lines as $row) {
        $V .= $row['filePath'];
        if ($row['agentFindings'] !== null) {
          $V .= ": " . implode(' ', $row['agentFindings']);
          if ($row['conclusions'] !== null) {
            $V .= ", " . implode(' ', $row['conclusions']);
          }
        }
        $V .= "\n";
      }
    }
    return $V;
  }
 
  private function consolidateResult($lines)
  {
    $newLines = [];
    foreach ($lines as $row) {
      $consolidatedLicenses = array();
      if ($row['agentFindings'] == null) {
        continue;
      }
      if ($row['conclusions'] !== null) {
        $row['agentFindings'] = array();
        foreach ($row['conclusions'] as $key => $value) {
          $row['agentFindings'][$key] = $row['conclusions'][$key];
        }
        $row['conclusions'] = null;
      } elseif ($row['agentFindings'] == null) {
        continue;
      } else {
        foreach ($row['agentFindings'] as $key => $value) {
          if ($value == "No_license_found") {
            unset($row['agentFindings'][$key]);
          } else {
            $consolidatedLicenses[] = $row['agentFindings'][$key];
          }
        }
        $consolidatedLicenses = array_unique($consolidatedLicenses);
        foreach ($row['agentFindings'] as $key => $value) {
          if (array_key_exists($key, $consolidatedLicenses) && $consolidatedLicenses[$key] !== null) {
            $row['agentFindings'][$key] = $consolidatedLicenses[$key];
          } else {
            unset($row['agentFindings'][$key]);
          }
        }
      }
      $newLines[] = $row;
    }
 
    return $newLines;
  }
 
  private function consolidateFindingsPerDirectory($lines)
  {
    $newLines = [];
    $consolidatedByDirectory = [];
    foreach ($lines as $row) {
      $path_parts = pathinfo($row['filePath']);
      sort($row['agentFindings']);
      if (array_key_exists($path_parts['dirname'], $consolidatedByDirectory)) {
        if (in_array($row['agentFindings'], $consolidatedByDirectory[$path_parts['dirname']])) {
          continue;
        } else {
          $consolidatedByDirectory[$path_parts['dirname']][] = $row['agentFindings'];
        }
      } else {
        $consolidatedByDirectory[$path_parts['dirname']][] = $row['agentFindings'];
      }
    }
    foreach ($consolidatedByDirectory as $key => $value) {
      foreach ($consolidatedByDirectory[$key] as $newKey => $newValue) {
        $newRow = [];
        $newRow['filePath'] = $key . "/";
        $newRow['agentFindings'] = $newValue;
        $newRow['conclusions'] = null;
        $newLines[] = $newRow;
      }
    }
    return $newLines;
  }
 
 
  private function printCSV($lines, $uploadtreeTablename, $copyright = false)
  {
    $request = $this->getRequest();
    $itemId = intval($request->get('item'));
    $path = Dir2Path($itemId, $uploadtreeTablename);
    $fileName = $path[count($path) - 1]['ufile_name']."-".date("Ymd");
    if ($copyright) {
      $fileName .= "-copyrights";
    } else {
      $fileName .= "-licenses";
    }
 
    $out = fopen('php://output', 'w');
    ob_start();
    if (!$copyright) {
      $head = array('file path', 'scan results', 'concluded results');
    } else {
      $head = array('file path', 'copyright');
    }
    fputcsv($out, $head, $this->delimiter, $this->enclosure);
    foreach ($lines as $row) {
      $newRow = array();
      $newRow[] = $row['filePath'];
      if ($copyright) {
        $newRow[] = $row['content'];
      } else {
        if ($row['agentFindings'] !== null) {
          $newRow[] = implode(' ', $row['agentFindings']);
        } else {
          $newRow[] = "";
        }
        if ($row['conclusions'] !== null) {
          $newRow[] = implode(' ', $row['conclusions']);
        } else {
          $newRow[] = "";
        }
      }
      fputcsv($out, $newRow, $this->delimiter, $this->enclosure);
    }
    $content = ob_get_contents();
    ob_end_clean();
 
    $headers = array(
      'Content-type' => 'text/csv, charset=UTF-8',
      'Content-Disposition' => 'attachment; filename='.$fileName.'.csv',
      'Pragma' => 'no-cache',
      'Cache-Control' => 'no-cache, must-revalidate, maxage=1, post-check=0, pre-check=0',
      'Expires' => 'Expires: Thu, 19 Nov 1981 08:52:00 GMT'
    );
 
    return new Response($content, Response::HTTP_OK, $headers);
  }
 
  private function printSpreadsheet($lines, $uploadtreeTablename)
  {
    $request = $this->getRequest();
    $itemId = intval($request->get('item'));
    $path = Dir2Path($itemId, $uploadtreeTablename);
    $fileName = $path[count($path) - 1]['ufile_name']."-".date("Ymd");
 
    $spreadsheet = new Spreadsheet();
    $sheet = $spreadsheet->getActiveSheet();
 
    $headRow = array(
        'A' => array(5, 'id', 'ID'),
        'B' => array(30, 'path', 'Source Name or Path'),
        'C' => array(20, 'name', 'OSS Name'),
        'D' => array(10, 'version', 'OSS Version'),
        'E' => array(20, 'scan results', 'Scan Results'),
        'F' => array(20, 'concluded results', 'Concluded Results'),
        'G' => array(20, 'download', 'Download Location'),
        'H' => array(20, 'homepage', 'Homepage'),
        'I' => array(30, 'copyright', 'Copyright Text'),
        'J' => array(10, 'exclude', 'Exclude'),
        'K' => array(30, 'comment', 'Comment')
    );
    $styleArray = [
        'font' => [
            'bold' => true,
            'color' => ['argb' => \PhpOffice\PhpSpreadsheet\Style\Color::COLOR_WHITE],
        ],
        'alignment' => [
            'vertical' => \PhpOffice\PhpSpreadsheet\Style\Alignment::VERTICAL_CENTER,
        ],
        'borders' => [
            'allBorders' => [
                'borderStyle' => \PhpOffice\PhpSpreadsheet\Style\Border::BORDER_THIN,
                'color' => ['argb' => \PhpOffice\PhpSpreadsheet\Style\Color::COLOR_BLACK],
            ]
        ],
        'fill' => [
            'fillType' => \PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID,
            'startColor' => ['argb' => '002060'],
        ],
    ];
    $sheet->getStyle('A1:J1')->applyFromArray($styleArray);
    foreach ($headRow as $key => $val) {
      $cellName = $key.'1';
 
      $sheet->getColumnDimension($key)->setWidth($val[0]);
 
      $sheet->setCellValue($cellName, $val[2]);
    }
 
    $styleArray = [
        'font' => [
            'color' => ['argb' => '808080'],
        ],
        'borders' => [
            'vertical' => [
                'borderStyle' => \PhpOffice\PhpSpreadsheet\Style\Border::BORDER_THIN,
                'color' => ['argb' => 'B2B2B2'],
            ]
        ],
        'fill' => [
            'fillType' => \PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID,
            'startColor' => ['argb' => 'FFFFCC'],
        ],
    ];
    $sheet->getStyle('A2:J2')->applyFromArray($styleArray);
    $annotationRow = array(
      'A' => array('id', '-'),
      'B' => array('path', '[Name of the Source File or Path]'),
      'C' => array('name', '[Name of the OSS used]'),
      'D' => array('version', '[Version Number of the OSS]'),
      'E' => array('scanResults', '[Scan results. Use SPDX Identifier : https://spdx.org/licenses/]'),
      'F' => array('concludedResults', '[Concluded results. Use SPDX Identifier : https://spdx.org/licenses/]'),
      'G' => array('download', '[Download URL or a specific location within a VCS for the OSS]'),
      'H' => array('homepage', '[Web site that serves as the OSSs home page]'),
      'I' => array('copyright', '[The copyright holders of the OSS. E.g. Copyright (c) 201X Copyright Holder]'),
      'J' => array('exclude', '[If this OSS is not included in the final version, Check exclude]'),
      'K' => array('comment','')
    );
    foreach ($annotationRow as $key => $val) {
      $cellName = $key.'2';
 
      $sheet->setCellValue($cellName, $val[1]);
    }
 
    $styleArray = [
        'borders' => [
            'allBorders' => [
                'borderStyle' => \PhpOffice\PhpSpreadsheet\Style\Border::BORDER_THIN,
                'color' => ['argb' => \PhpOffice\PhpSpreadsheet\Style\Color::COLOR_BLACK],
            ]
        ],
    ];
 
    $id = 1;
    foreach ($lines as $row) {
      $rowNumber = $id + 2;
      $range = 'A'.$rowNumber.':K'.$rowNumber;
      $sheet->getStyle($range)->applyFromArray($styleArray);
      $sheet->setCellValue('A'.$rowNumber, "$id");
      $sheet->setCellValue('B'.$rowNumber, $row['filePath']);
 
      if ($row['agentFindings'] !== null) {
        $scannedLicenses = implode(',', $row['agentFindings']);
        $sheet->setCellValue('E'.$rowNumber, $scannedLicenses);
      }
      if ($row['conclusions'] !== null) {
        $concludedLicenses = implode(',', $row['conclusions']);
        $sheet->setCellValue('F'.$rowNumber, $concludedLicenses);
      }
      $id++;
    }
 
    header('Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
    header('Content-Disposition: attachment; filename="'.$fileName.'.xlsx"');
    header('Cache-Control: max-age=0');
 
    $writer = new Xlsx($spreadsheet);
    ob_end_clean();
    $writer->save('php://output');
    exit();
  }
 
  private function reduceCopyrightLines($lines)
  {
    $reducedLines = array();
    foreach ($lines as $line) {
      foreach ($line as $copyright) {
        $reducedLines[] = $copyright;
      }
    }
    return $reducedLines;
  }
}
 
$NewPlugin = new UIExportList();
$NewPlugin->Initialize();