/**
* @param string[][][] &$filesWithLicenses
* @param ItemTreeBounds $itemTreeBounds
*/
protected function addScannerResults(&$filesWithLicenses, ItemTreeBounds $itemTreeBounds)
{
$uploadId = $itemTreeBounds->getUploadId();
$scannerAgents = array_keys($this->agentNames);
$scanJobProxy = new ScanJobProxy($this->container->get('dao.agent'), $uploadId);
$scanJobProxy->createAgentStatus($scannerAgents);
$scannerIds = $scanJobProxy->getLatestSuccessfulAgentIds();
if (empty($scannerIds)) {
return;
}
$selectedScanners = '{' . implode(',', $scannerIds) . '}';
$tableName = $itemTreeBounds->getUploadTreeTableName();
$stmt = __METHOD__ . '.scanner_findings';
$sql = "SELECT DISTINCT uploadtree_pk,rf_fk FROM {$tableName} ut, license_file\n WHERE ut.pfile_fk=license_file.pfile_fk AND rf_fk IS NOT NULL AND agent_fk=any(\$1)";
$param = array($selectedScanners);
if ($tableName == 'uploadtree_a') {
$param[] = $uploadId;
$sql .= " AND upload_fk=\$" . count($param);
$stmt .= $tableName;
}
$sql .= " GROUP BY uploadtree_pk,rf_fk";
$this->dbManager->prepare($stmt, $sql);
$res = $this->dbManager->execute($stmt, $param);
while ($row = $this->dbManager->fetchArray($res)) {
$reportedLicenseId = $this->licenseMap->getProjectedId($row['rf_fk']);
$shortName = $this->licenseMap->getProjectedShortname($reportedLicenseId);
if ($shortName != 'No_license_found' && $shortName != 'Void') {
$filesWithLicenses[$row['uploadtree_pk']]['scanner'][] = $shortName;
$this->includedLicenseIds[$reportedLicenseId] = true;
}
}
$this->dbManager->freeResult($res);
return "licenseInfoInFile determined by Scanners {$selectedScanners}";
}
protected function getStatements($uploadId, $uploadTreeTableName, $groupId = null)
{
$itemTreeBounds = $this->uploadDao->getParentItemBounds($uploadId, $uploadTreeTableName);
$clearingDecisions = $this->clearingDao->getFileClearingsFolder($itemTreeBounds, $groupId);
$dbManager = $GLOBALS['container']->get('db.manager');
$licenseMap = new LicenseMap($dbManager, $groupId, LicenseMap::REPORT);
$mainLicIds = $this->clearingDao->getMainLicenseIds($uploadId, $groupId);
$ungroupedStatements = array();
foreach ($clearingDecisions as $clearingDecision) {
if ($clearingDecision->getType() == DecisionTypes::IRRELEVANT) {
continue;
}
/** @var ClearingDecision $clearingDecision */
foreach ($clearingDecision->getClearingLicenses() as $clearingLicense) {
if ($clearingLicense->isRemoved()) {
continue;
}
if ($this->onlyComments && !($comment = $clearingLicense->getComment())) {
continue;
}
$originLicenseId = $clearingLicense->getLicenseId();
$licenseId = $licenseMap->getProjectedId($originLicenseId);
if (!$this->onlyComments && in_array($licenseId, $mainLicIds)) {
continue;
}
if ($this->onlyComments) {
$text = $comment;
} else {
$reportInfo = $clearingLicense->getReportInfo();
$text = $reportInfo ?: $this->getCachedLicenseText($licenseId, $groupId);
}
$ungroupedStatements[] = array('content' => $licenseMap->getProjectedShortname($originLicenseId, $clearingLicense->getShortName()), 'uploadtree_pk' => $clearingDecision->getUploadTreeId(), 'text' => $text);
}
}
return $ungroupedStatements;
}
/**
* @param $tagId
* @param ItemTreeBounds $itemTreeBounds
* @param $UniqueTagArray
* @param $selectedAgentId
* @param int $groupId
* @param ScanJobProxy $scanJobProxy
* @return array
*/
private function createFileListing($tagId, ItemTreeBounds $itemTreeBounds, &$UniqueTagArray, $selectedAgentId, $groupId, $scanJobProxy)
{
if (!empty($selectedAgentId)) {
$agentName = $this->agentDao->getAgentName($selectedAgentId);
$selectedScanners = array($agentName => $selectedAgentId);
} else {
$selectedScanners = $scanJobProxy->getLatestSuccessfulAgentIds();
}
/** change the license result when selecting one version of nomos */
$uploadId = $itemTreeBounds->getUploadId();
$isFlat = isset($_GET['flatten']);
if ($isFlat) {
$options = array(UploadTreeProxy::OPT_RANGE => $itemTreeBounds);
} else {
$options = array(UploadTreeProxy::OPT_REALPARENT => $itemTreeBounds->getItemId());
}
$descendantView = new UploadTreeProxy($uploadId, $options, $itemTreeBounds->getUploadTreeTableName(), 'uberItems');
$vars['iTotalDisplayRecords'] = $descendantView->count();
$columnNamesInDatabase = array($isFlat ? 'ufile_name' : 'lft');
$defaultOrder = array(array(0, "asc"));
$orderString = $this->getObject('utils.data_tables_utility')->getSortingString($_GET, $columnNamesInDatabase, $defaultOrder);
$offset = GetParm('iDisplayStart', PARM_INTEGER);
$limit = GetParm('iDisplayLength', PARM_INTEGER);
if ($offset) {
$orderString .= " OFFSET {$offset}";
}
if ($limit) {
$orderString .= " LIMIT {$limit}";
}
/* Get ALL the items under this Uploadtree_pk */
$sql = $descendantView->getDbViewQuery() . " {$orderString}";
$dbManager = $this->getObject('db.manager');
$dbManager->prepare($stmt = __METHOD__ . $orderString, $sql);
$res = $dbManager->execute($stmt, $descendantView->getParams());
$descendants = $dbManager->fetchAll($res);
$dbManager->freeResult($res);
/* Filter out Children that don't have tag */
if (!empty($tagId)) {
TagFilter($descendants, $tagId, $itemTreeBounds->getUploadTreeTableName());
}
if (empty($descendants)) {
$vars['fileData'] = array();
return $vars;
}
if ($isFlat) {
$firstChild = reset($descendants);
$lastChild = end($descendants);
$nameRange = array($firstChild['ufile_name'], $lastChild['ufile_name']);
} else {
$nameRange = array();
}
/******* File Listing ************/
$pfileLicenses = array();
foreach ($selectedScanners as $agentName => $agentId) {
$licensePerPfile = $this->licenseDao->getLicenseIdPerPfileForAgentId($itemTreeBounds, $agentId, $isFlat, $nameRange);
foreach ($licensePerPfile as $pfile => $licenseRow) {
foreach ($licenseRow as $licId => $row) {
$lic = $this->licenseProjector->getProjectedShortname($licId);
$pfileLicenses[$pfile][$lic][$agentName] = $row;
}
}
}
$baseUri = Traceback_uri() . '?mod=fileBrowse' . Traceback_parm_keep(array('upload', 'folder', 'show'));
$tableData = array();
global $Plugins;
$latestSuccessfulAgentIds = $scanJobProxy->getLatestSuccessfulAgentIds();
foreach ($descendants as $child) {
if (empty($child)) {
continue;
}
$tableData[] = $this->createFileDataRow($child, $uploadId, $selectedAgentId, $pfileLicenses, $groupId, $baseUri, $UniqueTagArray, $isFlat, $latestSuccessfulAgentIds);
}
$vars['fileData'] = $tableData;
return $vars;
}
/**
* @param array $child
* @param int $uploadId
* @param int $selectedAgentId
* @param array $pfileLicenses
* @param int $groupId
* @param ClearingDecision[][] $editedMappedLicenses
* @param string $uri
* @param null|ClearingView $ModLicView
* @param array $UniqueTagArray
* @param boolean $isFlat
* @param int[] $latestSuccessfulAgentIds
* @return array
*/
private function createFileDataRow($child, $uploadId, $selectedAgentId, $pfileLicenses, $groupId, $editedMappedLicenses, $uri, $ModLicView, &$UniqueTagArray, $isFlat, $latestSuccessfulAgentIds)
{
$fileId = $child['pfile_fk'];
$childUploadTreeId = $child['uploadtree_pk'];
$linkUri = '';
if (!empty($fileId) && !empty($ModLicView)) {
$linkUri = Traceback_uri();
$linkUri .= "?mod=view-license&upload={$uploadId}&item={$childUploadTreeId}";
if ($selectedAgentId) {
$linkUri .= "&agentId={$selectedAgentId}";
}
}
/* Determine link for containers */
$isContainer = Iscontainer($child['ufile_mode']);
if ($isContainer && !$isFlat) {
$fatChild = $this->uploadDao->getFatItemArray($child['uploadtree_pk'], $uploadId, $this->uploadtree_tablename);
$uploadtree_pk = $fatChild['item_id'];
$linkUri = "{$uri}&item=" . $uploadtree_pk;
if ($selectedAgentId) {
$linkUri .= "&agentId={$selectedAgentId}";
}
$child['ufile_name'] = $fatChild['ufile_name'];
if (!Iscontainer($fatChild['ufile_mode'])) {
$isContainer = false;
}
} else {
if ($isContainer) {
$uploadtree_pk = Isartifact($child['ufile_mode']) ? DirGetNonArtifact($childUploadTreeId, $this->uploadtree_tablename) : $childUploadTreeId;
$linkUri = "{$uri}&item=" . $uploadtree_pk;
if ($selectedAgentId) {
$linkUri .= "&agentId={$selectedAgentId}";
}
}
}
/* Populate the output ($VF) - file list */
/* id of each element is its uploadtree_pk */
$fileName = $child['ufile_name'];
if ($isContainer) {
$fileName = "<a href='{$linkUri}'><span style='color: darkblue'> <b>{$fileName}</b> </span></a>";
} else {
if (!empty($linkUri)) {
$fileName = "<a href='{$linkUri}'>{$fileName}</a>";
}
}
/* show licenses under file name */
$childItemTreeBounds = new ItemTreeBounds($childUploadTreeId, $this->uploadtree_tablename, $child['upload_fk'], $child['lft'], $child['rgt']);
if ($isContainer) {
$agentFilter = $selectedAgentId ? array($selectedAgentId) : $latestSuccessfulAgentIds;
$licenseEntries = $this->licenseDao->getLicenseShortnamesContained($childItemTreeBounds, $agentFilter, array());
$editedLicenses = $this->clearingDao->getClearedLicenses($childItemTreeBounds, $groupId);
} else {
$licenseEntries = array();
if (array_key_exists($fileId, $pfileLicenses)) {
foreach ($pfileLicenses[$fileId] as $shortName => $rfInfo) {
$agentEntries = array();
foreach ($rfInfo as $agent => $match) {
$agentName = $this->agentNames[$agent];
$agentEntry = "<a href='?mod=view-license&upload={$child['upload_fk']}&item={$childUploadTreeId}&format=text&agentId={$match['agent_id']}&licenseId={$match['license_id']}#highlight'>" . $agentName . "</a>";
if ($match['match_percentage'] > 0) {
$agentEntry .= ": {$match['match_percentage']}%";
}
$agentEntries[] = $agentEntry;
}
$licenseEntries[] = $shortName . " [" . implode("][", $agentEntries) . "]";
}
}
/* @var $decision ClearingDecision */
if (false !== ($decision = $this->clearingFilter->getDecisionOf($editedMappedLicenses, $childUploadTreeId, $fileId))) {
$editedLicenses = $decision->getPositiveLicenses();
} else {
$editedLicenses = array();
}
}
$concludedLicenses = array();
/** @var LicenseRef $licenseRef */
foreach ($editedLicenses as $licenseRef) {
$projectedId = $this->licenseProjector->getProjectedId($licenseRef->getId());
$projectedName = $this->licenseProjector->getProjectedShortname($licenseRef->getId(), $licenseRef->getShortName());
$concludedLicenses[$projectedId] = $projectedName;
}
$editedLicenseList = implode(', ', $concludedLicenses);
$licenseList = implode(', ', $licenseEntries);
$fileListLinks = FileListLinks($uploadId, $childUploadTreeId, 0, $fileId, true, $UniqueTagArray, $this->uploadtree_tablename, !$isFlat);
$getTextEditUser = _("Edit");
$fileListLinks .= "[<a href='#' onclick='openUserModal({$childUploadTreeId})' >{$getTextEditUser}</a>]";
if ($isContainer) {
$getTextEditBulk = _("Bulk");
$fileListLinks .= "[<a href='#' onclick='openBulkModal({$childUploadTreeId})' >{$getTextEditBulk}</a>]";
}
$filesThatShouldStillBeCleared = array_key_exists($childItemTreeBounds->getItemId(), $this->filesThatShouldStillBeCleared) ? $this->filesThatShouldStillBeCleared[$childItemTreeBounds->getItemId()] : 0;
$filesToBeCleared = array_key_exists($childItemTreeBounds->getItemId(), $this->filesToBeCleared) ? $this->filesToBeCleared[$childItemTreeBounds->getItemId()] : 0;
$filesCleared = $filesToBeCleared - $filesThatShouldStillBeCleared;
$img = $filesCleared == $filesToBeCleared ? 'green' : 'red';
return array($fileName, $licenseList, $editedLicenseList, $img, "{$filesCleared}/{$filesToBeCleared}", $fileListLinks);
}
