Added support for comparison of scans

app/controllers/DependencyCheckReportsParser.scala

@@ -114,6 +114,12 @@ private final case class BadFilter(pattern: String) extends Filter{
 
 object DependencyCheckReportsParser{
   def forAdHocScan(analysis: Analysis): Result = Result(Map(ReportInfo("adHocScan", "Ad hoc scan", "AHS", None) -> analysis), Map(), new ProjectsWithReports(new Projects(Map(), Map(), Map()), Set()), Map())
+  def forAdHocScans(analysises: Map[String, Analysis]): Result = Result(
+    bareFlatReports = analysises.map{case (key, analysis) => ReportInfo("adHocScan", "Ad hoc scan", "AHS:"+key, Some(key)) -> analysis},
+    bareFailedAnalysises = Map(),
+    projectsReportInfo = new ProjectsWithReports(new Projects(Map(), Map(), Map()), Set()),
+    failedReportDownloads = Map()
+  )
   final case class ResultWithSelection(result: Result, projectsWithSelection: ProjectsWithSelection)
   final case class Result(bareFlatReports: Map[ReportInfo, Analysis], bareFailedAnalysises: Map[ReportInfo, Throwable], projectsReportInfo: ProjectsWithReports/*TODO: maybe rename to rootProjects*/, failedReportDownloads: Map[ReportInfo, Throwable]){
     //lazy val projectsReportInfo = new ProjectsWithReports(projects, (bareFlatReports.keySet ++ bareFailedAnalysises.keySet ++ failedReportDownloads.keySet).map(_.fullId)) // TODO: consider renaming to projectsWithReports

app/controllers/Statistics.scala

@@ -6,7 +6,7 @@ import com.google.inject.name.Named
 import com.ysoft.odc.Confidence.Confidence
 import com.ysoft.odc.statistics.{LibDepStatistics, TagStatistics}
 import com.ysoft.odc._
-import controllers.DependencyCheckReportsParser.ResultWithSelection
+import controllers.DependencyCheckReportsParser.{Result, ResultWithSelection}
 import controllers.api.{ApiConfig, ApiController}
 import models.LibraryTag
 import modules.TemplateCustomization
@@ -25,6 +25,8 @@ final case class ScannedProject(name: String, repos: Seq[ScannedRepository], tea
 
 final case class GroupedDependencyIdentifier(hashes: Hashes, identifiers: Seq[Identifier])
 
+final case class CompareScanRequest(plan: String, reports: Map[String, String])
+
 object GroupedDependencyIdentifier{
   def fromGroupedDependency(groupedDependency: GroupedDependency): GroupedDependencyIdentifier = GroupedDependencyIdentifier(
     hashes = groupedDependency.hashes,
@@ -386,5 +388,34 @@ class Statistics @Inject()(
     }
   }
 
+  private implicit val compareScanRequestFormats = Json.format[CompareScanRequest]
+
+  def showSet[T: Writes](set: Set[T]) = JsArray(set.toSeq.map(implicitly[Writes[T]].writes))
+  def showDiff[T: Writes](diff: SetDiff[T]) = Json.obj("added" -> showSet(diff.added), "removed" -> showSet(diff.removed), "old"->showSet(diff.oldSet), "new"->showSet(diff.newSet))
+
+  def compareScan() = ApiAction(ScanResults).async(parse.json[CompareScanRequest]){ implicit req =>
+    val unparsedReports = req.body.reports
+    val reportMapFuture = Future {
+      unparsedReports.mapValues(OdcParser.parseXmlReport).view.force
+    }
+    val (lastRefreshTime, resultsFuture) = projectReportsProvider.resultsForVersions(versions)
+    resultsFuture flatMap { allResults =>
+      select(allResults, Some("project:"+req.body.plan)).fold(Future.successful(NotFound(Json.obj("error"->"not found")))) { selection =>
+        reportMapFuture.map {reportMap =>
+          def extractVulnerabilities(r: Result) = {
+            r.vulnerableDependencies.flatMap(_.vulnerabilities.map(_.name)).toSet
+          }
+          val adHocReports = DependencyCheckReportsParser.forAdHocScans(reportMap)
+          def compare[T](f: Result => Set[T]) = new SetDiff(f(selection.result), f(adHocReports))
+          //adHocReports.dep
+          Ok(Json.obj(
+            "vulnerabilities"->showDiff(compare(extractVulnerabilities)),
+            "dependencies"->showDiff(compare(_.groupedDependencies.map(GroupedDependencyIdentifier.fromGroupedDependency).toSet))
+          ))
+        }
+      }
+    }
+  }
+
 
 }

app/controllers/api/ApiResources.scala

@@ -3,10 +3,11 @@ package controllers.api
 trait ApiResources {
   val ProjectTable = ApiResource("project-table")
   val Dependencies = ApiResource("dependencies")
+  val ScanResults = ApiResource("scan-results")
 }
 
 object ApiResources extends ApiResources{
-  val All = Set(ProjectTable, Dependencies)
+  val All = Set(ProjectTable, Dependencies, ScanResults)
   private val AllByName = All.map(res => res.name -> res).toMap
   def byName(name: String): Option[ApiResource] = AllByName.get(name)
 }