diff --git a/src/Turnierplan.App/Client/src/app/i18n/de.ts b/src/Turnierplan.App/Client/src/app/i18n/de.ts
index 590b53c0..05c8ca19 100644
--- a/src/Turnierplan.App/Client/src/app/i18n/de.ts
+++ b/src/Turnierplan.App/Client/src/app/i18n/de.ts
@@ -519,6 +519,11 @@ export const de = {
             MatchWonPoints: 'Punkte für Sieg:',
             MatchDrawnPoints: 'Punkte für Unentschieden:',
             MatchLostPoints: 'Punkte für Niederlage:',
+            HigherScoreLoses: {
+              Label: 'Ergebnis invertieren:',
+              Tooltip: 'Wenn aktiviert, ist diejenige Mannschaft, welche weniger Tore geschossen hat, der Gewinner vom Spiel.',
+              Activated: 'Die Ergebnisse werden invertiert. Das heißt, die Mannschaft mit weniger Toren gewinnt.'
+            },
             ComparisonModes: {
               Label: 'Platzierungsregel in Gruppen:',
               Values: {
diff --git a/src/Turnierplan.App/Client/src/app/portal/components/computation-configuration/computation-configuration.component.html b/src/Turnierplan.App/Client/src/app/portal/components/computation-configuration/computation-configuration.component.html
index 744b03a1..a05ec2f9 100644
--- a/src/Turnierplan.App/Client/src/app/portal/components/computation-configuration/computation-configuration.component.html
+++ b/src/Turnierplan.App/Client/src/app/portal/components/computation-configuration/computation-configuration.component.html
@@ -63,6 +63,23 @@ <h4 class="modal-title" translate="Portal.ViewTournament.Settings.EditComputatio
     </div>
   </div>
 
+  <div class="mb-4 row align-items-center">
+    <div class="col-4">
+      <label
+        class="form-label mb-0"
+        for="higherScoreLoses"
+        translate="Portal.ViewTournament.Settings.EditComputationConfig.Properties.HigherScoreLoses.Label"></label>
+    </div>
+    <div class="col-8 d-flex flex-row align-items-center gap-1">
+      <div class="form-check form-switch">
+        <input class="form-check-input" id="higherScoreLoses" type="checkbox" [(ngModel)]="higherScoreLoses" />
+      </div>
+      <i
+        class="bi bi-info-circle"
+        [ngbTooltip]="'Portal.ViewTournament.Settings.EditComputationConfig.Properties.HigherScoreLoses.Tooltip' | translate"></i>
+    </div>
+  </div>
+
   <label
     class="form-label"
     for="comparisonModes"
diff --git a/src/Turnierplan.App/Client/src/app/portal/components/computation-configuration/computation-configuration.component.ts b/src/Turnierplan.App/Client/src/app/portal/components/computation-configuration/computation-configuration.component.ts
index 7c5e44d5..50b0d297 100644
--- a/src/Turnierplan.App/Client/src/app/portal/components/computation-configuration/computation-configuration.component.ts
+++ b/src/Turnierplan.App/Client/src/app/portal/components/computation-configuration/computation-configuration.component.ts
@@ -18,6 +18,7 @@ export class ComputationConfigurationComponent {
   protected matchWonPoints: number = 0;
   protected matchDrawnPoints: number = 0;
   protected matchLostPoints: number = 0;
+  protected higherScoreLoses: boolean = false;
 
   protected standardComparisonModeOptions: ComparisonModeOption[] = [];
   protected nonStandardComparisonModeOptions: ComparisonModeOption[] = [];
@@ -37,6 +38,7 @@ export class ComputationConfigurationComponent {
     this.matchWonPoints = computationConfiguration.matchWonPoints;
     this.matchDrawnPoints = computationConfiguration.matchDrawnPoints;
     this.matchLostPoints = computationConfiguration.matchLostPoints;
+    this.higherScoreLoses = computationConfiguration.higherScoreLoses;
 
     this.comparisonModeOptionId = '';
     for (const option of availableComparisonModeOptions) {
@@ -67,6 +69,7 @@ export class ComputationConfigurationComponent {
       matchWonPoints: this.matchWonPoints,
       matchDrawnPoints: this.matchDrawnPoints,
       matchLostPoints: this.matchLostPoints,
+      higherScoreLoses: this.higherScoreLoses,
       comparisonModes: [...(comparisonModes ?? [])]
     });
     this.save$.complete();
diff --git a/src/Turnierplan.App/Client/src/app/portal/pages/view-tournament/view-tournament.component.html b/src/Turnierplan.App/Client/src/app/portal/pages/view-tournament/view-tournament.component.html
index 8444669a..48a639eb 100644
--- a/src/Turnierplan.App/Client/src/app/portal/pages/view-tournament/view-tournament.component.html
+++ b/src/Turnierplan.App/Client/src/app/portal/pages/view-tournament/view-tournament.component.html
@@ -258,6 +258,11 @@
                 <span translate="Portal.ViewTournament.Settings.EditComputationConfig.Properties.MatchLostPoints"></span>
                 <span class="fw-bold">{{ tournament.computationConfiguration.matchLostPoints }}</span>
               </div>
+              @if (tournament.computationConfiguration.higherScoreLoses) {
+                <div
+                  class="mb-2"
+                  translate="Portal.ViewTournament.Settings.EditComputationConfig.Properties.HigherScoreLoses.Activated"></div>
+              }
               <div class="mb-3 d-flex flex-row">
                 <span class="me-2" translate="Portal.ViewTournament.Settings.EditComputationConfig.Properties.ComparisonModes.Label"></span>
                 @for (entry of tournament.computationConfiguration.comparisonModes; track entry; let isLast = $last) {
diff --git a/src/Turnierplan.App/Endpoints/Tournaments/SetTournamentComputationConfigurationEndpoint.cs b/src/Turnierplan.App/Endpoints/Tournaments/SetTournamentComputationConfigurationEndpoint.cs
index a1c0699e..3c489f22 100644
--- a/src/Turnierplan.App/Endpoints/Tournaments/SetTournamentComputationConfigurationEndpoint.cs
+++ b/src/Turnierplan.App/Endpoints/Tournaments/SetTournamentComputationConfigurationEndpoint.cs
@@ -45,6 +45,7 @@ private static async Task<IResult> Handle(
             MatchWonPoints = request.Configuration.MatchWonPoints,
             MatchDrawnPoints = request.Configuration.MatchDrawnPoints,
             MatchLostPoints = request.Configuration.MatchLostPoints,
+            HigherScoreLoses = request.Configuration.HigherScoreLoses,
             ComparisonModes = request.Configuration.ComparisonModes.ToList()
         };
 
diff --git a/src/Turnierplan.App/Mapping/Rules/TournamentMappingRule.cs b/src/Turnierplan.App/Mapping/Rules/TournamentMappingRule.cs
index 5fc599d6..184a9c4d 100644
--- a/src/Turnierplan.App/Mapping/Rules/TournamentMappingRule.cs
+++ b/src/Turnierplan.App/Mapping/Rules/TournamentMappingRule.cs
@@ -128,6 +128,7 @@ protected override TournamentDto Map(IMapper mapper, MappingContext context, Tou
                 MatchWonPoints = source.ComputationConfiguration.MatchWonPoints,
                 MatchDrawnPoints = source.ComputationConfiguration.MatchDrawnPoints,
                 MatchLostPoints = source.ComputationConfiguration.MatchLostPoints,
+                HigherScoreLoses = source.ComputationConfiguration.HigherScoreLoses,
                 ComparisonModes = source.ComputationConfiguration.ComparisonModes.ToArray()
             },
             PresentationConfiguration = mapper.Map<PresentationConfigurationDto>(source.PresentationConfiguration)
diff --git a/src/Turnierplan.App/Models/ComputationConfigurationDto.cs b/src/Turnierplan.App/Models/ComputationConfigurationDto.cs
index 83c568a6..dfb583b8 100644
--- a/src/Turnierplan.App/Models/ComputationConfigurationDto.cs
+++ b/src/Turnierplan.App/Models/ComputationConfigurationDto.cs
@@ -10,5 +10,7 @@ public sealed record ComputationConfigurationDto
 
     public required int MatchLostPoints { get; init; }
 
+    public required bool HigherScoreLoses { get; init; }
+
     public required TeamComparisonMode[] ComparisonModes { get; init; }
 }
diff --git a/src/Turnierplan.Core.Test.Unit/Tournament/TeamGroupResultsTest.cs b/src/Turnierplan.Core.Test.Unit/Tournament/TeamGroupResultsTest.cs
index 5c0c8ab3..c21771e9 100644
--- a/src/Turnierplan.Core.Test.Unit/Tournament/TeamGroupResultsTest.cs
+++ b/src/Turnierplan.Core.Test.Unit/Tournament/TeamGroupResultsTest.cs
@@ -56,6 +56,58 @@ public sealed class TeamGroupStatisticsTest
         }
     };
 
+    public static readonly TheoryData<(int GoalsFor, int GoalsAgainst)[], TeamGroupStatistics> AddMatchOutcomeWhenHigherScoreLosesTestData = new()
+    {
+        {
+            [
+                (GoalsFor: 2, GoalsAgainst: 3),
+                (GoalsFor: 1, GoalsAgainst: 1),
+                (GoalsFor: 4, GoalsAgainst: 0)
+            ],
+            new TeamGroupStatistics
+            {
+                ScoreFor = 2 + 1 + 4,
+                ScoreAgainst = 3 + 1 + 0,
+                MatchesWon = 1,
+                MatchesDrawn = 1,
+                MatchesLost = 1,
+                Points = 4
+            }
+        },
+        {
+            [
+                (GoalsFor: 1, GoalsAgainst: 0),
+                (GoalsFor: 2, GoalsAgainst: 2)
+            ],
+            new TeamGroupStatistics
+            {
+                ScoreFor = 1 + 2,
+                ScoreAgainst = 0 + 2,
+                MatchesWon = 0,
+                MatchesDrawn = 1,
+                MatchesLost = 1,
+                Points = 1
+            }
+        },
+        {
+            [
+                (GoalsFor: 1, GoalsAgainst: 1),
+                (GoalsFor: 2, GoalsAgainst: 0),
+                (GoalsFor: 1, GoalsAgainst: 3),
+                (GoalsFor: 2, GoalsAgainst: 2)
+            ],
+            new TeamGroupStatistics
+            {
+                ScoreFor = 1 + 2 + 1 + 2,
+                ScoreAgainst = 1 + 0 + 3 + 2,
+                MatchesWon = 1,
+                MatchesDrawn = 2,
+                MatchesLost = 1,
+                Points = 5
+            }
+        }
+    };
+
     [Theory]
     [InlineData(7, 3, 4)]
     [InlineData(3, 7, -4)]
@@ -101,7 +153,7 @@ public void TeamGroupResults___Add_Match_Outcome___Works_As_Expected((int GoalsF
 
     [Theory]
     [MemberData(nameof(AddMatchOutcomeTestData))]
-    public void TeamGroupResults___Add_Match_Outcome_With_Custom_Computation_Configuration___Works_As_Expected((int GoalsFor, int GoalsAgainst)[] matchOutcomes, TeamGroupStatistics expectedResults)
+    public void TeamGroupResults___Add_Match_Outcome_With_Custom_Point_Counts___Works_As_Expected((int GoalsFor, int GoalsAgainst)[] matchOutcomes, TeamGroupStatistics expectedResults)
     {
         // Arrange
         var results = new TeamGroupStatistics();
@@ -119,4 +171,22 @@ public void TeamGroupResults___Add_Match_Outcome_With_Custom_Computation_Configu
             Points = expectedResults.MatchesDrawn * 2 + expectedResults.MatchesWon * 5
         });
     }
+
+    [Theory]
+    [MemberData(nameof(AddMatchOutcomeWhenHigherScoreLosesTestData))]
+    public void TeamGroupResults___Add_Match_Outcome_With_HigherScoreLoses_Enabled___Works_As_Expected((int GoalsFor, int GoalsAgainst)[] matchOutcomes, TeamGroupStatistics expectedResults)
+    {
+        // Arrange
+        var results = new TeamGroupStatistics();
+        var configuration = new ComputationConfiguration { HigherScoreLoses = true };
+
+        // Act
+        foreach (var matchOutcome in matchOutcomes)
+        {
+            results.AddMatchOutcome(matchOutcome.GoalsFor, matchOutcome.GoalsAgainst, configuration);
+        }
+
+        // Assert
+        results.Should().BeEquivalentTo(expectedResults);
+    }
 }
diff --git a/src/Turnierplan.Core/Tournament/ComputationConfiguration.cs b/src/Turnierplan.Core/Tournament/ComputationConfiguration.cs
index 8a803a25..71776170 100644
--- a/src/Turnierplan.Core/Tournament/ComputationConfiguration.cs
+++ b/src/Turnierplan.Core/Tournament/ComputationConfiguration.cs
@@ -21,6 +21,9 @@ public sealed record ComputationConfiguration
     [JsonPropertyName("l")]
     public int MatchLostPoints { get; set; } = 0;
 
+    [JsonPropertyName("r")]
+    public bool HigherScoreLoses { get; set; } = false;
+
     [JsonPropertyName("cmp")]
     public List<TeamComparisonMode> ComparisonModes { get; set; } = [..__defaultTeamComparisonModes];
 }
diff --git a/src/Turnierplan.Core/Tournament/TeamGroupStatistics.cs b/src/Turnierplan.Core/Tournament/TeamGroupStatistics.cs
index 0c7d12de..63690d4f 100644
--- a/src/Turnierplan.Core/Tournament/TeamGroupStatistics.cs
+++ b/src/Turnierplan.Core/Tournament/TeamGroupStatistics.cs
@@ -36,20 +36,39 @@ internal void AddMatchOutcome(int scoreFor, int scoreAgainst, ComputationConfigu
         ScoreFor += scoreFor;
         ScoreAgainst += scoreAgainst;
 
-        if (scoreFor > scoreAgainst)
-        {
-            MatchesWon++;
-            Points += computationConfiguration.MatchWonPoints;
-        }
-        else if (scoreFor == scoreAgainst)
+        if (scoreFor == scoreAgainst)
         {
             MatchesDrawn++;
             Points += computationConfiguration.MatchDrawnPoints;
+
+            return;
+        }
+
+        if (computationConfiguration.HigherScoreLoses)
+        {
+            if (scoreFor > scoreAgainst)
+            {
+                MatchesLost++;
+                Points += computationConfiguration.MatchLostPoints;
+            }
+            else
+            {
+                MatchesWon++;
+                Points += computationConfiguration.MatchWonPoints;
+            }
         }
         else
         {
-            MatchesLost++;
-            Points += computationConfiguration.MatchLostPoints;
+            if (scoreFor > scoreAgainst)
+            {
+                MatchesWon++;
+                Points += computationConfiguration.MatchWonPoints;
+            }
+            else
+            {
+                MatchesLost++;
+                Points += computationConfiguration.MatchLostPoints;
+            }
         }
     }
 }
diff --git a/src/Turnierplan.Dal/Migrations/20250706170447_Add_HigherScoreLoses.Designer.cs b/src/Turnierplan.Dal/Migrations/20250706170447_Add_HigherScoreLoses.Designer.cs
new file mode 100644
index 00000000..aff8a0ec
--- /dev/null
+++ b/src/Turnierplan.Dal/Migrations/20250706170447_Add_HigherScoreLoses.Designer.cs
@@ -0,0 +1,1285 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Turnierplan.Dal;
+
+#nullable disable
+
+namespace Turnierplan.Dal.Migrations
+{
+    [DbContext(typeof(TurnierplanContext))]
+    [Migration("20250706170447_Add_HigherScoreLoses")]
+    partial class Add_HigherScoreLoses
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.6")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Turnierplan.Core.ApiKey.ApiKey", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(250)
+                        .HasColumnType("character varying(250)");
+
+                    b.Property<DateTime>("ExpiryDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(25)
+                        .HasColumnType("character varying(25)");
+
+                    b.Property<long>("OrganizationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("PrincipalId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("PublicId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("SecretHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrganizationId");
+
+                    b.HasIndex("PrincipalId")
+                        .IsUnique();
+
+                    b.HasIndex("PublicId")
+                        .IsUnique();
+
+                    b.ToTable("ApiKeys", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.ApiKey.ApiKeyRequest", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ApiKeyId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("character varying(150)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApiKeyId");
+
+                    b.HasIndex("Timestamp");
+
+                    b.ToTable("ApiKeyRequests", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Document.Document", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Configuration")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("GenerationCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("LastGeneration")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("LastModifiedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<long>("PublicId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("TournamentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PublicId")
+                        .IsUnique();
+
+                    b.HasIndex("TournamentId");
+
+                    b.ToTable("Documents", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Folder.Folder", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<long>("OrganizationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PublicId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrganizationId");
+
+                    b.HasIndex("PublicId")
+                        .IsUnique();
+
+                    b.ToTable("Folders", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Image.Image", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("FileType")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("character varying(5)");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<long>("OrganizationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PublicId")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("ResourceIdentifier")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrganizationId");
+
+                    b.HasIndex("PublicId")
+                        .IsUnique();
+
+                    b.HasIndex("ResourceIdentifier")
+                        .IsUnique();
+
+                    b.ToTable("Images", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Organization.Organization", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)");
+
+                    b.Property<long>("PublicId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PublicId")
+                        .IsUnique();
+
+                    b.ToTable("Organizations", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.ApiKey.ApiKey>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("ApiKeyId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Principal")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApiKeyId");
+
+                    b.ToTable("IAM_ApiKey", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Folder.Folder>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("FolderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Principal")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FolderId");
+
+                    b.ToTable("IAM_Folder", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Image.Image>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("ImageId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Principal")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ImageId");
+
+                    b.ToTable("IAM_Image", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Organization.Organization>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("OrganizationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Principal")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrganizationId");
+
+                    b.ToTable("IAM_Organization", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Tournament.Tournament>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Principal")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("TournamentId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TournamentId");
+
+                    b.ToTable("IAM_Tournament", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Venue.Venue>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Principal")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("VenueId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VenueId");
+
+                    b.ToTable("IAM_Venue", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Group", b =>
+                {
+                    b.Property<long>("TournamentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<char>("AlphabeticalId")
+                        .HasColumnType("character(1)");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(25)
+                        .HasColumnType("character varying(25)");
+
+                    b.HasKey("TournamentId", "Id");
+
+                    b.ToTable("Groups", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.GroupParticipant", b =>
+                {
+                    b.Property<long>("TournamentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("GroupId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TeamId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer");
+
+                    b.HasKey("TournamentId", "GroupId", "TeamId");
+
+                    b.HasIndex("TournamentId", "TeamId");
+
+                    b.ToTable("GroupParticipants", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Match", b =>
+                {
+                    b.Property<long>("TournamentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<short>("Court")
+                        .HasColumnType("smallint");
+
+                    b.Property<int?>("FinalsRound")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("integer");
+
+                    b.Property<bool?>("IsCurrentlyPlaying")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("Kickoff")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("OutcomeType")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("PlayoffPosition")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ScoreA")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ScoreB")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TeamSelectorA")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("TeamSelectorB")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.HasKey("TournamentId", "Id");
+
+                    b.HasIndex("TournamentId", "GroupId");
+
+                    b.ToTable("Matches", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Team", b =>
+                {
+                    b.Property<long>("TournamentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("EntryFeePaidAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("character varying(60)");
+
+                    b.Property<bool>("OutOfCompetition")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("TournamentId", "Id");
+
+                    b.ToTable("Teams", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Tournament", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("FolderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsMigrated")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("character varying(60)");
+
+                    b.Property<long>("OrganizationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("OrganizerLogoId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PublicId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("PublicPageViews")
+                        .HasColumnType("integer");
+
+                    b.Property<long?>("SponsorBannerId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("SponsorLogoId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("VenueId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Visibility")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FolderId");
+
+                    b.HasIndex("OrganizationId");
+
+                    b.HasIndex("OrganizerLogoId");
+
+                    b.HasIndex("PublicId")
+                        .IsUnique();
+
+                    b.HasIndex("SponsorBannerId");
+
+                    b.HasIndex("SponsorLogoId");
+
+                    b.HasIndex("VenueId");
+
+                    b.ToTable("Tournaments", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.User.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EMail")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<bool>("IsAdministrator")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastLogin")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("LastPasswordChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NormalizedEMail")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("PrincipalId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("SecurityStamp")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEMail")
+                        .IsUnique();
+
+                    b.HasIndex("PrincipalId")
+                        .IsUnique();
+
+                    b.ToTable("Users", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Venue.Venue", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.PrimitiveCollection<List<string>>("AddressDetails")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.PrimitiveCollection<List<string>>("ExternalLinks")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("character varying(60)");
+
+                    b.Property<long>("OrganizationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PublicId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrganizationId");
+
+                    b.HasIndex("PublicId")
+                        .IsUnique();
+
+                    b.ToTable("Venues", "turnierplan");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.ApiKey.ApiKey", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Organization.Organization", "Organization")
+                        .WithMany("ApiKeys")
+                        .HasForeignKey("OrganizationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Organization");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.ApiKey.ApiKeyRequest", b =>
+                {
+                    b.HasOne("Turnierplan.Core.ApiKey.ApiKey", "ApiKey")
+                        .WithMany("Requests")
+                        .HasForeignKey("ApiKeyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ApiKey");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Document.Document", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Tournament.Tournament", "Tournament")
+                        .WithMany("Documents")
+                        .HasForeignKey("TournamentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Tournament");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Folder.Folder", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Organization.Organization", "Organization")
+                        .WithMany("Folders")
+                        .HasForeignKey("OrganizationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Organization");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Image.Image", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Organization.Organization", "Organization")
+                        .WithMany("Images")
+                        .HasForeignKey("OrganizationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Organization");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.ApiKey.ApiKey>", b =>
+                {
+                    b.HasOne("Turnierplan.Core.ApiKey.ApiKey", "Scope")
+                        .WithMany("RoleAssignments")
+                        .HasForeignKey("ApiKeyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scope");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Folder.Folder>", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Folder.Folder", "Scope")
+                        .WithMany("RoleAssignments")
+                        .HasForeignKey("FolderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scope");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Image.Image>", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Image.Image", "Scope")
+                        .WithMany("RoleAssignments")
+                        .HasForeignKey("ImageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scope");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Organization.Organization>", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Organization.Organization", "Scope")
+                        .WithMany("RoleAssignments")
+                        .HasForeignKey("OrganizationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scope");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Tournament.Tournament>", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Tournament.Tournament", "Scope")
+                        .WithMany("RoleAssignments")
+                        .HasForeignKey("TournamentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scope");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.RoleAssignment.RoleAssignment<Turnierplan.Core.Venue.Venue>", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Venue.Venue", "Scope")
+                        .WithMany("RoleAssignments")
+                        .HasForeignKey("VenueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scope");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Group", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Tournament.Tournament", null)
+                        .WithMany("Groups")
+                        .HasForeignKey("TournamentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.GroupParticipant", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Tournament.Group", "Group")
+                        .WithMany("Participants")
+                        .HasForeignKey("TournamentId", "GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Turnierplan.Core.Tournament.Team", "Team")
+                        .WithMany()
+                        .HasForeignKey("TournamentId", "TeamId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+
+                    b.Navigation("Team");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Match", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Tournament.Tournament", null)
+                        .WithMany("Matches")
+                        .HasForeignKey("TournamentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Turnierplan.Core.Tournament.Group", "Group")
+                        .WithMany()
+                        .HasForeignKey("TournamentId", "GroupId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Team", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Tournament.Tournament", null)
+                        .WithMany("Teams")
+                        .HasForeignKey("TournamentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Tournament", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Folder.Folder", "Folder")
+                        .WithMany("Tournaments")
+                        .HasForeignKey("FolderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Turnierplan.Core.Organization.Organization", "Organization")
+                        .WithMany("Tournaments")
+                        .HasForeignKey("OrganizationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Turnierplan.Core.Image.Image", "OrganizerLogo")
+                        .WithMany()
+                        .HasForeignKey("OrganizerLogoId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Turnierplan.Core.Image.Image", "SponsorBanner")
+                        .WithMany()
+                        .HasForeignKey("SponsorBannerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Turnierplan.Core.Image.Image", "SponsorLogo")
+                        .WithMany()
+                        .HasForeignKey("SponsorLogoId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Turnierplan.Core.Venue.Venue", "Venue")
+                        .WithMany("Tournaments")
+                        .HasForeignKey("VenueId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.OwnsOne("Turnierplan.Core.Tournament.ComputationConfiguration", "ComputationConfiguration", b1 =>
+                        {
+                            b1.Property<long>("TournamentId")
+                                .HasColumnType("bigint");
+
+                            b1.PrimitiveCollection<int[]>("ComparisonModes")
+                                .IsRequired()
+                                .HasColumnType("integer[]")
+                                .HasAnnotation("Relational:JsonPropertyName", "cmp");
+
+                            b1.Property<bool>("HigherScoreLoses")
+                                .HasColumnType("boolean")
+                                .HasAnnotation("Relational:JsonPropertyName", "r");
+
+                            b1.Property<int>("MatchDrawnPoints")
+                                .HasColumnType("integer")
+                                .HasAnnotation("Relational:JsonPropertyName", "d");
+
+                            b1.Property<int>("MatchLostPoints")
+                                .HasColumnType("integer")
+                                .HasAnnotation("Relational:JsonPropertyName", "l");
+
+                            b1.Property<int>("MatchWonPoints")
+                                .HasColumnType("integer")
+                                .HasAnnotation("Relational:JsonPropertyName", "w");
+
+                            b1.HasKey("TournamentId");
+
+                            b1.ToTable("Tournaments", "turnierplan");
+
+                            b1.ToJson("ComputationConfiguration");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TournamentId");
+                        });
+
+                    b.OwnsOne("Turnierplan.Core.Tournament.MatchPlanConfiguration", "MatchPlanConfiguration", b1 =>
+                        {
+                            b1.Property<long>("TournamentId")
+                                .HasColumnType("bigint");
+
+                            b1.HasKey("TournamentId");
+
+                            b1.ToTable("Tournaments", "turnierplan");
+
+                            b1.ToJson("MatchPlanConfiguration");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TournamentId");
+
+                            b1.OwnsOne("Turnierplan.Core.Tournament.FinalsRoundConfig", "FinalsRoundConfig", b2 =>
+                                {
+                                    b2.Property<long>("MatchPlanConfigurationTournamentId")
+                                        .HasColumnType("bigint");
+
+                                    b2.Property<bool>("EnableThirdPlacePlayoff")
+                                        .HasColumnType("boolean")
+                                        .HasAnnotation("Relational:JsonPropertyName", "3rd");
+
+                                    b2.Property<int>("FirstFinalsRoundOrder")
+                                        .HasColumnType("integer")
+                                        .HasAnnotation("Relational:JsonPropertyName", "fo");
+
+                                    b2.PrimitiveCollection<List<string>>("TeamSelectors")
+                                        .HasColumnType("text[]")
+                                        .HasAnnotation("Relational:JsonPropertyName", "ts");
+
+                                    b2.HasKey("MatchPlanConfigurationTournamentId");
+
+                                    b2.ToTable("Tournaments", "turnierplan");
+
+                                    b2.HasAnnotation("Relational:JsonPropertyName", "fr");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("MatchPlanConfigurationTournamentId");
+
+                                    b2.OwnsMany("Turnierplan.Core.Tournament.AdditionalPlayoffConfig", "AdditionalPlayoffs", b3 =>
+                                        {
+                                            b3.Property<long>("FinalsRoundConfigMatchPlanConfigurationTournamentId")
+                                                .HasColumnType("bigint");
+
+                                            b3.Property<int>("__synthesizedOrdinal")
+                                                .ValueGeneratedOnAdd()
+                                                .HasColumnType("integer");
+
+                                            b3.Property<int>("PlayoffPosition")
+                                                .HasColumnType("integer")
+                                                .HasAnnotation("Relational:JsonPropertyName", "p");
+
+                                            b3.Property<string>("TeamSelectorA")
+                                                .IsRequired()
+                                                .HasColumnType("text")
+                                                .HasAnnotation("Relational:JsonPropertyName", "a");
+
+                                            b3.Property<string>("TeamSelectorB")
+                                                .IsRequired()
+                                                .HasColumnType("text")
+                                                .HasAnnotation("Relational:JsonPropertyName", "b");
+
+                                            b3.HasKey("FinalsRoundConfigMatchPlanConfigurationTournamentId", "__synthesizedOrdinal");
+
+                                            b3.ToTable("Tournaments", "turnierplan");
+
+                                            b3.HasAnnotation("Relational:JsonPropertyName", "ap");
+
+                                            b3.WithOwner()
+                                                .HasForeignKey("FinalsRoundConfigMatchPlanConfigurationTournamentId");
+                                        });
+
+                                    b2.Navigation("AdditionalPlayoffs");
+                                });
+
+                            b1.OwnsOne("Turnierplan.Core.Tournament.GroupRoundConfig", "GroupRoundConfig", b2 =>
+                                {
+                                    b2.Property<long>("MatchPlanConfigurationTournamentId")
+                                        .HasColumnType("bigint");
+
+                                    b2.Property<int>("GroupMatchOrder")
+                                        .HasColumnType("integer")
+                                        .HasAnnotation("Relational:JsonPropertyName", "o");
+
+                                    b2.Property<int>("GroupPhaseRounds")
+                                        .HasColumnType("integer")
+                                        .HasAnnotation("Relational:JsonPropertyName", "r");
+
+                                    b2.HasKey("MatchPlanConfigurationTournamentId");
+
+                                    b2.ToTable("Tournaments", "turnierplan");
+
+                                    b2.HasAnnotation("Relational:JsonPropertyName", "gr");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("MatchPlanConfigurationTournamentId");
+                                });
+
+                            b1.OwnsOne("Turnierplan.Core.Tournament.ScheduleConfig", "ScheduleConfig", b2 =>
+                                {
+                                    b2.Property<long>("MatchPlanConfigurationTournamentId")
+                                        .HasColumnType("bigint");
+
+                                    b2.Property<short>("FinalsPhaseNumberOfCourts")
+                                        .HasColumnType("smallint")
+                                        .HasAnnotation("Relational:JsonPropertyName", "fc");
+
+                                    b2.Property<TimeSpan>("FinalsPhasePauseTime")
+                                        .HasColumnType("interval")
+                                        .HasAnnotation("Relational:JsonPropertyName", "fp");
+
+                                    b2.Property<TimeSpan>("FinalsPhasePlayTime")
+                                        .HasColumnType("interval")
+                                        .HasAnnotation("Relational:JsonPropertyName", "fd");
+
+                                    b2.Property<DateTime>("FirstMatchKickoff")
+                                        .HasColumnType("timestamp with time zone")
+                                        .HasAnnotation("Relational:JsonPropertyName", "f");
+
+                                    b2.Property<short>("GroupPhaseNumberOfCourts")
+                                        .HasColumnType("smallint")
+                                        .HasAnnotation("Relational:JsonPropertyName", "gc");
+
+                                    b2.Property<TimeSpan>("GroupPhasePauseTime")
+                                        .HasColumnType("interval")
+                                        .HasAnnotation("Relational:JsonPropertyName", "gp");
+
+                                    b2.Property<TimeSpan>("GroupPhasePlayTime")
+                                        .HasColumnType("interval")
+                                        .HasAnnotation("Relational:JsonPropertyName", "gd");
+
+                                    b2.Property<TimeSpan>("PauseBetweenGroupAndFinalsPhase")
+                                        .HasColumnType("interval")
+                                        .HasAnnotation("Relational:JsonPropertyName", "p");
+
+                                    b2.HasKey("MatchPlanConfigurationTournamentId");
+
+                                    b2.ToTable("Tournaments", "turnierplan");
+
+                                    b2.HasAnnotation("Relational:JsonPropertyName", "sc");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("MatchPlanConfigurationTournamentId");
+                                });
+
+                            b1.Navigation("FinalsRoundConfig");
+
+                            b1.Navigation("GroupRoundConfig");
+
+                            b1.Navigation("ScheduleConfig");
+                        });
+
+                    b.OwnsOne("Turnierplan.Core.Tournament.PresentationConfiguration", "PresentationConfiguration", b1 =>
+                        {
+                            b1.Property<long>("TournamentId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<bool>("ShowOrganizerLogo")
+                                .HasColumnType("boolean")
+                                .HasAnnotation("Relational:JsonPropertyName", "ol");
+
+                            b1.Property<int>("ShowResults")
+                                .HasColumnType("integer")
+                                .HasAnnotation("Relational:JsonPropertyName", "o");
+
+                            b1.Property<bool>("ShowSponsorLogo")
+                                .HasColumnType("boolean")
+                                .HasAnnotation("Relational:JsonPropertyName", "sl");
+
+                            b1.HasKey("TournamentId");
+
+                            b1.ToTable("Tournaments", "turnierplan");
+
+                            b1.ToJson("PresentationConfiguration");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TournamentId");
+
+                            b1.OwnsOne("Turnierplan.Core.Tournament.PresentationConfiguration+HeaderLine", "Header1", b2 =>
+                                {
+                                    b2.Property<long>("PresentationConfigurationTournamentId")
+                                        .HasColumnType("bigint");
+
+                                    b2.Property<int>("Content")
+                                        .HasColumnType("integer")
+                                        .HasAnnotation("Relational:JsonPropertyName", "c");
+
+                                    b2.Property<string>("CustomContent")
+                                        .HasColumnType("text")
+                                        .HasAnnotation("Relational:JsonPropertyName", "cc");
+
+                                    b2.HasKey("PresentationConfigurationTournamentId");
+
+                                    b2.ToTable("Tournaments", "turnierplan");
+
+                                    b2.HasAnnotation("Relational:JsonPropertyName", "h1");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("PresentationConfigurationTournamentId");
+                                });
+
+                            b1.OwnsOne("Turnierplan.Core.Tournament.PresentationConfiguration+HeaderLine", "Header2", b2 =>
+                                {
+                                    b2.Property<long>("PresentationConfigurationTournamentId")
+                                        .HasColumnType("bigint");
+
+                                    b2.Property<int>("Content")
+                                        .HasColumnType("integer")
+                                        .HasAnnotation("Relational:JsonPropertyName", "c");
+
+                                    b2.Property<string>("CustomContent")
+                                        .HasColumnType("text")
+                                        .HasAnnotation("Relational:JsonPropertyName", "cc");
+
+                                    b2.HasKey("PresentationConfigurationTournamentId");
+
+                                    b2.ToTable("Tournaments", "turnierplan");
+
+                                    b2.HasAnnotation("Relational:JsonPropertyName", "h2");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("PresentationConfigurationTournamentId");
+                                });
+
+                            b1.Navigation("Header1")
+                                .IsRequired();
+
+                            b1.Navigation("Header2")
+                                .IsRequired();
+                        });
+
+                    b.Navigation("ComputationConfiguration")
+                        .IsRequired();
+
+                    b.Navigation("Folder");
+
+                    b.Navigation("MatchPlanConfiguration");
+
+                    b.Navigation("Organization");
+
+                    b.Navigation("OrganizerLogo");
+
+                    b.Navigation("PresentationConfiguration")
+                        .IsRequired();
+
+                    b.Navigation("SponsorBanner");
+
+                    b.Navigation("SponsorLogo");
+
+                    b.Navigation("Venue");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Venue.Venue", b =>
+                {
+                    b.HasOne("Turnierplan.Core.Organization.Organization", "Organization")
+                        .WithMany("Venues")
+                        .HasForeignKey("OrganizationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Organization");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.ApiKey.ApiKey", b =>
+                {
+                    b.Navigation("Requests");
+
+                    b.Navigation("RoleAssignments");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Folder.Folder", b =>
+                {
+                    b.Navigation("RoleAssignments");
+
+                    b.Navigation("Tournaments");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Image.Image", b =>
+                {
+                    b.Navigation("RoleAssignments");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Organization.Organization", b =>
+                {
+                    b.Navigation("ApiKeys");
+
+                    b.Navigation("Folders");
+
+                    b.Navigation("Images");
+
+                    b.Navigation("RoleAssignments");
+
+                    b.Navigation("Tournaments");
+
+                    b.Navigation("Venues");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Group", b =>
+                {
+                    b.Navigation("Participants");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Tournament.Tournament", b =>
+                {
+                    b.Navigation("Documents");
+
+                    b.Navigation("Groups");
+
+                    b.Navigation("Matches");
+
+                    b.Navigation("RoleAssignments");
+
+                    b.Navigation("Teams");
+                });
+
+            modelBuilder.Entity("Turnierplan.Core.Venue.Venue", b =>
+                {
+                    b.Navigation("RoleAssignments");
+
+                    b.Navigation("Tournaments");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Turnierplan.Dal/Migrations/20250706170447_Add_HigherScoreLoses.cs b/src/Turnierplan.Dal/Migrations/20250706170447_Add_HigherScoreLoses.cs
new file mode 100644
index 00000000..f88ce5d0
--- /dev/null
+++ b/src/Turnierplan.Dal/Migrations/20250706170447_Add_HigherScoreLoses.cs
@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Turnierplan.Dal.Migrations
+{
+    /// <inheritdoc />
+    public partial class Add_HigherScoreLoses : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}
diff --git a/src/Turnierplan.Dal/Migrations/TurnierplanContextModelSnapshot.cs b/src/Turnierplan.Dal/Migrations/TurnierplanContextModelSnapshot.cs
index 7d3b755a..544116c3 100644
--- a/src/Turnierplan.Dal/Migrations/TurnierplanContextModelSnapshot.cs
+++ b/src/Turnierplan.Dal/Migrations/TurnierplanContextModelSnapshot.cs
@@ -928,6 +928,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                                 .HasColumnType("integer[]")
                                 .HasAnnotation("Relational:JsonPropertyName", "cmp");
 
+                            b1.Property<bool>("HigherScoreLoses")
+                                .HasColumnType("boolean")
+                                .HasAnnotation("Relational:JsonPropertyName", "r");
+
                             b1.Property<int>("MatchDrawnPoints")
                                 .HasColumnType("integer")
                                 .HasAnnotation("Relational:JsonPropertyName", "d");