#725 make teamname selection working with verband-teams

src/main/scala/ch/seidel/kutu/domain/TeamRegel.scala

@@ -49,6 +49,8 @@ sealed trait TeamRegel {
   def parseExtrateams(extraTeamsDef: String) = extraTeamsDef.replace("/", "").split("\\+").map(_.trim).toList
 
   def extractTeams(wertungen: Iterable[WertungView]): List[Team]
+  def extractExtraTeams(wertungen: Iterable[WertungView]): List[String] = wertungen.map(_.wettkampf).toList.distinct.flatMap(_.extraTeams)
+
   def teamsAllowed: Boolean
   def toFormel: String
   def toRuleName: String
@@ -71,13 +73,13 @@ case class TeamRegelVereinGeraet(min: Int, max: Int, extraTeamsDef: String) exte
   override def toRuleName: String = s"""Vereins-Team Rangliste (beste $min Gerätewertungen${if (max > 0) s" aus $max" else ""})"""
 
   override def extractTeams(wertungen: Iterable[WertungView]): List[Team] = {
+    val extraTeams = extractExtraTeams(wertungen)
     wertungen
       .filter(w => w.team != 0)
       .toList
-      .groupBy(w => if (w.team > 0) (w.athlet.verein.map(_.extendedprint).getOrElse(""), w.team) else (extrateams(w.team * -1 -1), w.team))
+      .groupBy(w => w.getTeamName(extraTeams))
       .flatMap { team =>
-        val (teamkey, teamwertungen) = team
-        val (verein, teamNummer) = teamkey
+        val (teamname, teamwertungen) = team
         val athletCount = teamwertungen.map(w => w.athlet.id).toSet.size
         if (athletCount >= min && (max == 0 || athletCount <= max)) {
           val perDisciplinWertungen: Map[Disziplin, List[WertungView]] = teamwertungen
@@ -103,7 +105,6 @@ case class TeamRegelVereinGeraet(min: Int, max: Int, extraTeamsDef: String) exte
               allRelevantWertungen.contains(w.athlet)
             }
           }
-          val teamname = if (teamNummer > 0) s"${verein} ${teamNummer}" else verein
           List(Team(s"${teamname}", toRuleName, limitedTeamwertungen, perDisciplinCountingWertungen, perDisciplinWertungen))
         } else {
           List.empty
@@ -114,21 +115,21 @@ case class TeamRegelVereinGeraet(min: Int, max: Int, extraTeamsDef: String) exte
   override def teamsAllowed: Boolean = true
 }
 case class TeamRegelVereinGesamt(min: Int, max: Int, extraTeamsDef: String) extends TeamRegel {
-  val extrateams = parseExtrateams(extraTeamsDef)
+  private val extrateams = parseExtrateams(extraTeamsDef)
   override def getExtrateams: List[String] = extrateams
 
   override def toFormel: String = s"VereinGesamt($min/${if (max > 0) max else "*"}$extraTeamsDef)"
 
   override def toRuleName: String = s"""Vereins-Team Rangliste (beste $min Gesamtwertungen${if (max > 0) s" aus $max" else ""})"""
 
   override def extractTeams(wertungen: Iterable[WertungView]): List[Team] = {
+    val extraTeams = extractExtraTeams(wertungen)
     wertungen
       .filter(w => w.team != 0)
       .toList
-      .groupBy(w => if (w.team > 0) (w.athlet.verein.map(_.extendedprint).getOrElse(""), w.team) else (extrateams(w.team * -1 -1), w.team))
+      .groupBy(w => w.getTeamName(extraTeams))
       .flatMap { team =>
-        val (teamkey, teamwertungen) = team
-        val (verein, teamNummer) = teamkey
+        val (teamname, teamwertungen) = team
         val athletCount = teamwertungen.map(w => w.athlet.id).toSet.size
         if (athletCount >= min && (max == 0 || athletCount <= max)) {
           val perAthletWertungen = teamwertungen
@@ -147,7 +148,6 @@ case class TeamRegelVereinGesamt(min: Int, max: Int, extraTeamsDef: String) exte
               allRelevantWertungen.contains
             }
           }
-          val teamname = if (teamNummer > 0) s"${verein} ${teamNummer}" else verein
           List(Team(s"${teamname}", toRuleName, limitedTeamwertungen, perAthletWertungen, perAthletWertungen))
         } else {
           List.empty
@@ -159,21 +159,21 @@ case class TeamRegelVereinGesamt(min: Int, max: Int, extraTeamsDef: String) exte
 }
 
 case class TeamRegelVerbandGeraet(min: Int, max: Int, extraTeamsDef: String) extends TeamRegel {
-  val extrateams = parseExtrateams(extraTeamsDef)
+  private val extrateams = parseExtrateams(extraTeamsDef)
   override def getExtrateams: List[String] = extrateams
 
   override def toFormel: String = s"VerbandGerät($min/${if (max > 0) max else "*"}$extraTeamsDef)"
 
   override def toRuleName: String = s"""Verbands-Team Rangliste (beste $min Gerätewertungen${if (max > 0) s" aus $max" else ""})"""
 
   override def extractTeams(wertungen: Iterable[WertungView]): List[Team] = {
+    val extraTeams = extractExtraTeams(wertungen)
     wertungen
       .filter(w => w.team != 0)
       .toList
-      .groupBy(w => if (w.team > 0) (w.athlet.verein.flatMap(_.verband).getOrElse(""), w.team) else (extrateams(w.team * -1 -1), w.team))
+      .groupBy(w => w.getTeamName(extraTeams))
       .flatMap { team =>
-        val (teamkey, teamwertungen) = team
-        val (verband, teamNummer) = teamkey
+        val (teamname, teamwertungen) = team
         val athletCount = teamwertungen.map(w => w.athlet.id).toSet.size
         if (athletCount >= min && (max == 0 || athletCount <= max)) {
           val perDisciplinWertungen: Map[Disziplin, List[WertungView]] = teamwertungen
@@ -200,7 +200,6 @@ case class TeamRegelVerbandGeraet(min: Int, max: Int, extraTeamsDef: String) ext
               allRelevantWertungen.contains(w.athlet)
             }
           }
-          val teamname = if (teamNummer > 0) s"${verband} ${teamNummer}" else verband
           List(Team(s"${teamname}", toRuleName, limitedTeamwertungen, perDisciplinCountingWertungen, perDisciplinWertungen))
         } else {
           List.empty
@@ -211,20 +210,20 @@ case class TeamRegelVerbandGeraet(min: Int, max: Int, extraTeamsDef: String) ext
   override def teamsAllowed: Boolean = true
 }
 case class TeamRegelVerbandGesamt(min: Int, max: Int, extraTeamsDef: String) extends TeamRegel {
-  val extrateams = parseExtrateams(extraTeamsDef)
+  private val extrateams = parseExtrateams(extraTeamsDef)
   override def getExtrateams: List[String] = extrateams
 
   override def toFormel: String = s"VerbandGesamt($min/${if (max > 0) max else "*"}$extraTeamsDef)"
   override def toRuleName: String = s"""Verbands-Team Rangliste (beste $min Gesamtwertungen${if (max > 0) s" aus $max" else ""})"""
 
   override def extractTeams(wertungen: Iterable[WertungView]): List[Team] = {
+    val extraTeams = extractExtraTeams(wertungen)
     wertungen
       .filter(w => w.team != 0)
       .toList
-      .groupBy(w => if (w.team > 0) (w.athlet.verein.flatMap(_.verband).getOrElse(""), w.team) else (extrateams(w.team * -1 -1), w.team))
+      .groupBy(w => w.getTeamName(extraTeams))
       .flatMap { team =>
-        val (teamkey, teamwertungen) = team
-        val (verband, teamNummer) = teamkey
+        val (teamname, teamwertungen) = team
         val athletCount = teamwertungen.map(w => w.athlet.id).toSet.size
         if (athletCount >= min && (max == 0 || athletCount <= max)) {
           val perAthletWertungen = teamwertungen
@@ -243,7 +242,6 @@ case class TeamRegelVerbandGesamt(min: Int, max: Int, extraTeamsDef: String) ext
               allRelevantWertungen.contains
             }
           }
-          val teamname = if (teamNummer > 0) s"${verband} ${teamNummer}" else verband
           List(Team(s"${teamname}", toRuleName, limitedTeamwertungen, perAthletWertungen, perAthletWertungen))
         } else {
           List.empty

src/main/scala/ch/seidel/kutu/domain/package.scala

@@ -919,6 +919,21 @@ package object domain {
 
     def +(r: Resultat) = resultat + r
 
+    def getTeamName(extraTeams: List[String]): String = athlet.verein match {
+      case Some(v) =>
+        if (team == 0) v.easyprint
+        else if (team < 0 && extraTeams.size > team * -1 - 1) {
+          s"${extraTeams(team * -1 - 1)}"
+        }
+        else if (wettkampf.teamrule.exists(r => r.contains("VereinGe")))
+          s"${v.easyprint} $team"
+        else
+          s"${v.verband.getOrElse(v.extendedprint)} $team"
+      case _ => if (team != 0) "$team" else ""
+    }
+
+    lazy val teamName = getTeamName(wettkampf.extraTeams)
+
     def toWertung = Wertung(id, athlet.id, wettkampfdisziplin.id, wettkampf.id, wettkampf.uuid.getOrElse(""), noteD, noteE, endnote, riege, riege2, Some(team))
 
     def toWertung(riege: String, riege2: Option[String]) = Wertung(id, athlet.id, wettkampfdisziplin.id, wettkampf.id, wettkampf.uuid.getOrElse(""), noteD, noteE, endnote, Some(riege), riege2, Some(team))

src/main/scala/ch/seidel/kutu/http/RegistrationRoutes.scala

@@ -374,19 +374,22 @@ trait RegistrationRoutes extends SprayJsonSupport with JwtSupport with JsonSuppo
                     pathEndOrSingleSlash {
                       get {
                         complete {
-                          val wi = WettkampfInfo(wettkampf.toView(readProgramm(wettkampf.programmId)), this)
                           val registration = selectRegistration(registrationId)
-                          val regs = selectAthletRegistrations(registrationId)
-                          val vereinTeams = regs
-                            .flatMap(_.team)
-                            .filter(_ > 0)
-                            .distinct
-                            .sorted
+                          val (teamname, teamNumbers) = if (wettkampf.teamrule.exists(r => r.contains("VereinGe")))
+                                (s"${registration.toVerein.extendedprint}", selectAthletRegistrations(registrationId)
+                                  .flatMap(_.team)
+                                  .filter(_ > 0).distinct.sorted)
+                              else
+                                (s"${registration.verband}", selectRegistrations()
+                                  .filter(_.verband.equalsIgnoreCase(registration.verband))
+                                  .flatMap(vereinsReg => selectAthletRegistrations(vereinsReg.id))
+                                  .flatMap(_.team)
+                                  .filter(_ > 0).distinct.sorted)
 
-                          val nextVereinTeam = if (vereinTeams.isEmpty) 1 else vereinTeams.max + 1
+                          val nextTeamNumber = if (teamNumbers.isEmpty) 1 else teamNumbers.max + 1
 
-                          (1 to nextVereinTeam).toList.map(idx => TeamItem(idx, registration.toVerein.extendedprint)) :::
-                            wi.wettkampf.toWettkampf.extraTeams
+                          (1 to nextTeamNumber).toList.map(idx => TeamItem(idx, teamname)) :::
+                            wettkampf.extraTeams
                               .filter(_.nonEmpty)
                               .zipWithIndex.map(item => TeamItem(item._2 * -1 - 1, item._1))
                         }

src/main/scala/ch/seidel/kutu/squad/JGClubGrouper.scala

@@ -29,14 +29,6 @@ case object JGClubGrouper extends RiegenGrouper {
     x => extractSexGrouper(x),
     x => extractProgrammGrouper(x),
     x => extractJGGrouper(x),
-    x => x.athlet.verein match {
-      case Some(v) =>
-        if (x.team == 0) v.easyprint
-        else if (x.team < 0 && x.wettkampf.extraTeams.size > x.team * -1 -1) {
-          s"${x.wettkampf.extraTeams(x.team * -1 -1)}"
-        }
-        else s"${v.easyprint} ${x.team}"
-      case None => ""
-    },
+    x => x.teamName,
   )
 }

src/main/scala/ch/seidel/kutu/squad/KuTuGeTuGrouper.scala

@@ -15,15 +15,7 @@ case object KuTuGeTuGrouper extends RiegenGrouper {
   val wkGrouper: List[WertungView => String] = List(
     x => x.athlet.geschlecht,
     x => x.wettkampfdisziplin.programm.name,
-    x => x.athlet.verein match {
-      case Some(v) =>
-        if (x.team == 0) v.easyprint
-        else if (x.team < 0 && x.wettkampf.extraTeams.size > x.team * -1 -1) {
-          s"${x.wettkampf.extraTeams(x.team * -1 -1)}"
-        }
-        else s"${v.easyprint} ${x.team}"
-      case None => ""
-    },
+    x => x.teamName,
     // fallback ... should not happen
     x => (x.athlet.gebdat match {case Some(d) => f"$d%tY"; case _ => ""})
   )

src/main/scala/ch/seidel/kutu/view/WettkampfWertungTab.scala

@@ -421,14 +421,29 @@ class WettkampfWertungTab(wettkampfmode: BooleanProperty, programm: Option[Progr
   case object TeamItems {
     def apply(editor: WertungEditor): List[TeamItem] = this.apply(editor.init)
     def apply(editor: WertungView): List[TeamItem] = {
-      val vereinTeams = wkModel
-        .filter(editorRow => editorRow(0).init.athlet == editor.athlet)
-        .map(_.init(0).init.team)
-        .filter(_ > 0).toSet.toList.sorted
+      val (teamname, vereinTeams) = editor.athlet.verein match {
+        case Some(v) if (editor.wettkampf.teamrule.nonEmpty) =>
+          if (editor.wettkampf.teamrule.exists(r => r.contains("VereinGe")))
+            (s"${v.easyprint}", wkModel
+              .filter(editorRow => editorRow(0).init.athlet.verein == editor.athlet.verein)
+              .map(_.init(0).init.team)
+              .filter(_ > 0).toSet.toList.sorted)
+          else {
+            val verband = editor.athlet.verein.flatMap(_.verband).getOrElse(v.easyprint)
+            (s"${v.verband.getOrElse(v.extendedprint)}", wkModel
+              .filter(editorRow => editorRow(0).init.athlet.verein.exists(_.verband.exists(_.equals(verband))))
+              .map(_.init(0).init.team)
+              .filter(_ > 0).toSet.toList.sorted)
+          }
+        case _ => (s"${editor.athlet.verein.getOrElse("")}", wkModel
+          .filter(editorRow => editorRow(0).init.athlet.verein == editor.athlet.verein)
+          .map(_.init(0).init.team)
+          .filter(_ > 0).toSet.toList.sorted)
+      }
 
       val nextVereinTeam = if (vereinTeams.isEmpty) 1 else vereinTeams.max + 1
 
-      (1 to nextVereinTeam).toList.map(idx => TeamItem(idx, editor.athlet.verein.get.easyprint)) :::
+      (1 to nextVereinTeam).toList.map(idx => TeamItem(idx, teamname)) :::
         editor.wettkampf.extraTeams.zipWithIndex.map(item => TeamItem(item._2 * -1 - 1, item._1))
     }
     def map(editor: WertungView): Option[TeamItem] = apply(editor).find(team => team.index == editor.team)
@@ -591,7 +606,7 @@ class WettkampfWertungTab(wettkampfmode: BooleanProperty, programm: Option[Progr
           wettkampfmode
         )) choose true otherwise false
 
-        visible <== when(wettkampfmode) choose wettkampfInfo.teamRegel.teamsAllowed otherwise true
+        visible = wettkampfInfo.teamRegel.teamsAllowed
         prefWidth = 100
 
         onEditCommit = (evt: CellEditEvent[IndexedSeq[WertungEditor], TeamItem]) => {
@@ -747,7 +762,7 @@ class WettkampfWertungTab(wettkampfmode: BooleanProperty, programm: Option[Progr
               wettkampfmode
             )) choose true otherwise false
 
-            visible <== when(wettkampfmode) choose wettkampfInfo.teamRegel.teamsAllowed otherwise true
+            visible = wettkampfInfo.teamRegel.teamsAllowed
             prefWidth = 100
 
             onEditCommit = (evt: CellEditEvent[IndexedSeq[WertungEditor], TeamItem]) => {