Filtering by team is now more failsafe

app/controllers/DependencyCheckReportsParser.scala

@@ -45,6 +45,15 @@ private final case class ProjectFilter(project: ReportInfo) extends Filter{
 }
 private final case class TeamFilter(team: Team) extends Filter{
   override def filters: Boolean = true
+
+  private def splitSuccessesAndFailures[T, U](set: Set[Either[T, U]]) = {
+    val (lefts, rights) = set.partition(_.isLeft)
+    (
+      lefts.map(_.asInstanceOf[Left[T, U]].a),
+      rights.map(_.asInstanceOf[Right[T, U]].b)
+    )
+  }
+
   override def subReports(r: Result): Option[Result] = {
     val Wildcard = """^(.*): \*$""".r
     @inline def toMapStrict[K, V](l: Traversable[(K, V)]) = l.toSeq.groupBy(_._1).mapValues{  // without toSeq, the pattern matching might fail
@@ -62,16 +71,22 @@ private final case class TeamFilter(team: Team) extends Filter{
       if(failedProjectsFriendlyNames contains name) Seq()
       else sys.error("Unknown project: "+name)
     )
-    def reportInfoByFriendlyProjectName(fpn: String) = fpn match{
+    def reportInfoByFriendlyProjectName(fpn: String): Either[Iterable[ReportInfo], String] = {
-      case Wildcard(rfpn) => rootProjectReports(rfpn)
+      def toEither[T](v: Option[T]): Either[T, String] = v.fold[Either[T, String]](Right(fpn))(Left(_))
-      case _ => Set(reportInfoByFriendlyProjectNameMap(fpn))
+      fpn match{
+        case Wildcard(rfpn) => toEither(rootProjectReports.get(rfpn))
+        case _ => toEither(reportInfoByFriendlyProjectNameMap.get(fpn).map(Set(_)))
+      }
     }
-    val reportInfos = team.projectNames.flatMap(reportInfoByFriendlyProjectName)
+    val (reportInfosDeep, projectsNotFound) = splitSuccessesAndFailures(team.projectNames.map(reportInfoByFriendlyProjectName))
+    val reportInfos: Set[ReportInfo] = reportInfosDeep.flatten
     def submap[T](m: Map[ReportInfo, T]) = reportInfos.toSeq.flatMap(ri => m.get(ri).map(ri -> _) ).toMap
     def submapBare[T](m: Map[ReportInfo, T]): Map[ReportInfo, T] = reportInfos.toSeq.flatMap(ri => m.get(ri.bare.ensuring{x => println(x.fullId); true}).map(ri -> _) ).toMap
+    // TODO: projectsNotFoundMap is a hack for reporting errors to humans, because there is no suitable category for such errors
+    val projectsNotFoundMap = projectsNotFound.map(name => ReportInfo("name: " + name, name, "name: " + name, None) -> new RuntimeException("Project " + name + " not found")).toMap
     Some(Result(
       bareFlatReports = submap(r.bareFlatReports),
-      bareFailedAnalysises = submapBare(r.bareFailedAnalysises),
+      bareFailedAnalysises = submapBare(r.bareFailedAnalysises) ++ projectsNotFoundMap,
       projectsReportInfo = r.projectsReportInfo,
       failedReportDownloads = submapBare(r.failedReportDownloads)
     ))

app/controllers/Projects.scala

@@ -11,9 +11,9 @@ class Projects @Inject() (configuration: Configuration) {
     projectsConfig.entrySet().map( k => k.getKey -> projectsConfig.getString(k.getKey)).toMap
   }
   val projectSet = projectMap.keySet
-  val teamIdSet = configuration.getStringSeq("yssdc.teams").getOrElse(sys.error("yssdc.teams is not set")).map(TeamId).toSet
+  private val teamIdSet = configuration.getStringSeq("yssdc.teams").getOrElse(sys.error("yssdc.teams is not set")).map(TeamId).toSet
   private val teamsByIds = teamIdSet.map(t => t.id -> t).toMap
-  val teamLeaders = {
+  private val teamLeaders = {
     import scala.collection.JavaConversions._
     configuration.getObject("yssdc.teamLeaders").getOrElse(sys.error("yssdc.teamLeaders is not set")).map{case(k, v) =>
       TeamId(k) -> v.unwrapped().asInstanceOf[String]
@@ -26,17 +26,17 @@ class Projects @Inject() (configuration: Configuration) {
     }
   }
 
-  def existingTeamId(s: String): TeamId = teamsByIds(s)
+  private def existingTeamId(s: String): TeamId = teamsByIds(s)
 
-  val projectToTeams = configuration.getObject("yssdc.projectsToTeams").get.mapValues{_.unwrapped().asInstanceOf[java.util.List[String]].map(c =>
+  private val projectToTeams = configuration.getObject("yssdc.projectsToTeams").get.mapValues{_.unwrapped().asInstanceOf[java.util.List[String]].map(c =>
     existingTeamId(c)
   ).toSet}.map(identity)
 
-  val projectAndTeams = projectToTeams.toSeq.flatMap{case (project, teams) => teams.map(team => (project, team))}
+  private val projectAndTeams = projectToTeams.toSeq.flatMap{case (project, teams) => teams.map(team => (project, team))}
 
-  val teamsToProjects = projectAndTeams.groupBy(_._2).mapValues(_.map(_._1).toSet).map(identity)
+  private val teamsToProjects = projectAndTeams.groupBy(_._2).mapValues(_.map(_._1).toSet).map(identity)
 
-  val teamsById: Map[String, Team] = for{
+  private val teamsById: Map[String, Team] = for{
     (team, projectNames) <- teamsToProjects
   } yield team.id -> Team(
     id = team.id,