Einladen, statt sich für jemanden ein Passwort auszudenken
Ein Konto von Hand anzulegen heisst: sich für einen anderen ein Passwort ausdenken und es ihm durchsagen — über denselben Kanal, über den auch ein Link gegangen wäre. Jetzt gibt es den Link. Wer ihn öffnet, wählt Namen und Passwort selbst und ist danach angemeldet. Gültigkeit und Anzahl wählst du beim Erstellen: einen Tag bis einen Monat, einmal bis unbegrenzt. **Eine Rolle wählst du nicht** — wer eingeladen wird, ist gewöhnlicher Benutzer. Ein Feld, über das ein Link Adminrechte verschenken könnte, gibt es gar nicht, und damit auch keinen Weg, es versehentlich zu setzen. **Der Link steht genau einmal da.** Gespeichert ist nur sein Fingerabdruck, wie beim Gerätetoken; aus der Liste lässt sich keiner mehr bauen. Eine verlorene Einladung wird deshalb nicht wiedergefunden, sondern neu gemacht. Und gebaut wird die Adresse im Browser: der Server weiss nicht, unter welchem Namen er von aussen erreichbar ist, und hinter einem Reverse Proxy rät er falsch. **Das Rennen beim Einlösen.** Zwei Leute, die gleichzeitig denselben einmaligen Link öffnen, läsen beide „null benutzt" und schrieben beide „eins" — und hätten beide ein Konto. Der Zähler geht deshalb mit einer Bedingung hoch, die die Gültigkeit noch einmal prüft; wer dabei keine Zeile trifft, war der Zweite. Das Ganze in einer Transaktion, damit ein Tippfehler im Namen den Link nicht verbrennt. Beides steht als Test da — zwei gleichzeitige Einlösungen ergeben genau ein Konto. **Angelegt wird, angemeldet wird danach gewöhnlich.** Derselbe Zweischritt wie beim Einrichten, und der Grund ist nicht Bequemlichkeit: die Anmeldung setzt den Sitzungskeks, und ohne den lädt kein Plakat — Bilder weisen sich über ihn aus, nicht über das Token. Gemessen beim Durchspielen: nach dem Einlösen kommt ein Bild mit 200 zurück. **Die Weiche liegt im Hochfahren, nicht im Router.** Der Router läuft nie, wenn niemand angemeldet ist — ein Ausgeloggter mit Einladungslink sähe sonst die Anmeldekarte und landete nach dem Anmelden auf der Startseite, ohne je erfahren zu haben, wozu er eingeladen war. Nach dem Einrichten, damit ein nagelneuer Server zuerst seinen Administrator bekommt. Wer schon angemeldet ist, bekommt kein Formular, sondern den Hinweis und zwei Wege. Und die Gründe einer Ablehnung sind verschieden benannt: abgelaufen, zurückgezogen, schon benutzt. Verschwiegener wäre ein einheitliches „gilt nicht" — und dann fragt der Eingeladene nach, und der Gastgeber rät mit. Nebenbei korrigiert: die Erkundung meinte, dem Benutzernamen fehle ein eindeutiger Index. Er hat einen, seit der ersten Migration, sogar mit `NOCASE`. Das Namensrennen war also nie offen. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
c65356c16f
commit
d5e21d663f
@@ -803,3 +803,39 @@ public sealed record Meldungseintrag(
|
||||
string ReportedBy,
|
||||
/// <summary><c>null</c> heisst: offen.</summary>
|
||||
DateTimeOffset? ResolvedAt);
|
||||
|
||||
/* ---------- Einladungen ---------- */
|
||||
|
||||
/// <summary>Was beim Erstellen eines Einladungslinks gewählt wird.</summary>
|
||||
public sealed record EinladungRequest(
|
||||
/// <summary>Wie viele Tage er gilt.</summary>
|
||||
int Days = 7,
|
||||
/// <summary>Wie oft er sich einlösen lässt. <c>null</c> heisst: unbegrenzt.</summary>
|
||||
int? MaxUses = 1);
|
||||
|
||||
/// <summary>Der frisch erstellte Link — der Token steht hier zum einzigen Mal.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Die Adresse baut der Client.</b> Der Server weiss nicht, unter welchem
|
||||
/// Namen er von aussen erreichbar ist; hinter einem Reverse Proxy rät er
|
||||
/// falsch, und ein falscher Einladungslink ist schlimmer als keiner.
|
||||
/// </remarks>
|
||||
public sealed record EinladungErstellt(Guid Id, string Token, DateTimeOffset ExpiresAt, int? MaxUses);
|
||||
|
||||
/// <summary>Eine Einladung in der Verwaltungsliste — ohne Token.</summary>
|
||||
public sealed record Einladungseintrag(
|
||||
Guid Id,
|
||||
string CreatedBy,
|
||||
DateTimeOffset CreatedAt,
|
||||
DateTimeOffset ExpiresAt,
|
||||
int? MaxUses,
|
||||
int UsedCount,
|
||||
DateTimeOffset? RevokedAt,
|
||||
/// <summary>Ob sich damit jetzt noch ein Konto anlegen lässt.</summary>
|
||||
bool Valid);
|
||||
|
||||
/// <summary>Was die Einladungsseite zeigt, bevor jemand etwas eintippt.</summary>
|
||||
public sealed record Einladungsschau(string ServerName, string InvitedBy, DateTimeOffset ExpiresAt);
|
||||
|
||||
/// <summary>Namen und Passwort, die sich der Eingeladene selbst gibt.</summary>
|
||||
public sealed record EinloesenRequest(string UserName, string Password);
|
||||
|
||||
@@ -0,0 +1,195 @@
|
||||
using System.Security.Claims;
|
||||
using Flaro.Core.Auth;
|
||||
using Flaro.Core.Users;
|
||||
using Flaro.Data;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace Flaro.Api.Endpoints;
|
||||
|
||||
/// <summary>Jemanden über einen Link einladen, statt ein Konto für ihn zu erfinden.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Warum.</b> Ein Konto von Hand anzulegen heisst, sich ein Passwort für
|
||||
/// einen anderen auszudenken und es ihm durchzusagen — über denselben Kanal,
|
||||
/// über den er den Link bekommen hätte. Wer eingeladen wird, soll sich Namen
|
||||
/// und Passwort selbst geben.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Zwei Welten in einer Datei.</b> Erstellen, auflisten und zurückziehen
|
||||
/// ist Verwaltung. Ansehen und Einlösen muss jemand können, der noch gar kein
|
||||
/// Konto hat — also anonym, und damit gedrosselt: es gibt keine globale
|
||||
/// Drossel in diesem Server, ein anonymer Endpunkt ohne eigene wäre
|
||||
/// ungebremst.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class EinladungEndpoints
|
||||
{
|
||||
private const int HoechstensTage = 365;
|
||||
|
||||
public static void MapEinladungen(this IEndpointRouteBuilder app)
|
||||
{
|
||||
var verwalten = app.MapGroup("/api/v1/invites")
|
||||
.RequireAuthorization(FlaroPolicies.Administrator);
|
||||
|
||||
verwalten.MapPost("", async (
|
||||
EinladungRequest anfrage, ClaimsPrincipal wer,
|
||||
FlaroContext db, TimeProvider uhr, CancellationToken ct) =>
|
||||
{
|
||||
if (Kennung(wer) is not { } ich) return Results.Unauthorized();
|
||||
|
||||
var tage = Math.Clamp(anfrage.Days, 1, HoechstensTage);
|
||||
if (anfrage.MaxUses is { } anzahl && anzahl < 1)
|
||||
return Einwand.Bitte("Ein Link, der nullmal gilt, ist keiner.");
|
||||
|
||||
// **Das Geheimnis verlässt den Server genau hier.** Gespeichert
|
||||
// wird nur sein Fingerabdruck; aus der Datenbank lässt sich kein
|
||||
// Link mehr bauen, und eine verlorene Einladung wird deshalb nicht
|
||||
// wiedergefunden, sondern neu gemacht.
|
||||
var token = Secrets.Create();
|
||||
var jetzt = uhr.GetUtcNow();
|
||||
var einladung = new Einladung
|
||||
{
|
||||
TokenFingerprint = Secrets.Fingerprint(token),
|
||||
CreatedByUserId = ich,
|
||||
CreatedAt = jetzt,
|
||||
ExpiresAt = jetzt.AddDays(tage),
|
||||
MaxUses = anfrage.MaxUses,
|
||||
};
|
||||
|
||||
db.Einladungen.Add(einladung);
|
||||
await db.SaveChangesAsync(ct);
|
||||
|
||||
return Results.Ok(new EinladungErstellt(
|
||||
einladung.Id, token, einladung.ExpiresAt, einladung.MaxUses));
|
||||
});
|
||||
|
||||
verwalten.MapGet("", async (FlaroContext db, TimeProvider uhr, CancellationToken ct) =>
|
||||
{
|
||||
var jetzt = uhr.GetUtcNow();
|
||||
var roh = await db.Einladungen.AsNoTracking()
|
||||
.OrderByDescending(e => e.CreatedAt)
|
||||
.Join(db.Users.AsNoTracking(), e => e.CreatedByUserId, u => u.Id,
|
||||
(e, u) => new { E = e, u.UserName })
|
||||
.ToListAsync(ct);
|
||||
|
||||
return Results.Ok(roh.Select(z => new Einladungseintrag(
|
||||
z.E.Id, z.UserName, z.E.CreatedAt, z.E.ExpiresAt,
|
||||
z.E.MaxUses, z.E.UsedCount, z.E.RevokedAt, z.E.Gilt(jetzt))).ToList());
|
||||
});
|
||||
|
||||
// **Zurückziehen, nicht löschen.** Eine Zeile wegzuwerfen hiesse,
|
||||
// hinterher nicht mehr zu wissen, dass es den Link je gab — und genau
|
||||
// das will man wissen, wenn jemand Unerwartetes im Haushalt auftaucht.
|
||||
verwalten.MapDelete("/{id:guid}", async (
|
||||
Guid id, FlaroContext db, TimeProvider uhr, CancellationToken ct) =>
|
||||
{
|
||||
var einladung = await db.Einladungen.FirstOrDefaultAsync(e => e.Id == id, ct);
|
||||
if (einladung is null) return Einwand.Fehlt("Diese Einladung gibt es nicht mehr.");
|
||||
|
||||
einladung.RevokedAt ??= uhr.GetUtcNow();
|
||||
await db.SaveChangesAsync(ct);
|
||||
return Results.NoContent();
|
||||
});
|
||||
|
||||
/* ---------- Was ohne Konto erreichbar sein muss ---------- */
|
||||
|
||||
app.MapGet("/api/v1/invites/{token}", async (
|
||||
string token, FlaroContext db, TimeProvider uhr, CancellationToken ct) =>
|
||||
{
|
||||
var gefunden = await Suchen(db, token, ct);
|
||||
if (Pruefen(gefunden, uhr.GetUtcNow()) is { } einwand) return einwand;
|
||||
|
||||
var name = await db.Users.AsNoTracking()
|
||||
.Where(u => u.Id == gefunden!.CreatedByUserId)
|
||||
.Select(u => u.UserName).FirstOrDefaultAsync(ct) ?? "";
|
||||
|
||||
var servername = await db.Settings.AsNoTracking()
|
||||
.Where(s => s.Key == SystemEndpoints.NameSchlüssel)
|
||||
.Select(s => s.Value).FirstOrDefaultAsync(ct);
|
||||
|
||||
return Results.Ok(new Einladungsschau(
|
||||
string.IsNullOrWhiteSpace(servername) ? "Flaro" : servername,
|
||||
name, gefunden!.ExpiresAt));
|
||||
}).AllowAnonymous().RequireRateLimiting(FlaroRateLimits.SignIn);
|
||||
|
||||
app.MapPost("/api/v1/invites/{token}/redeem", async (
|
||||
string token, EinloesenRequest anfrage,
|
||||
FlaroContext db, TimeProvider uhr, CancellationToken ct) =>
|
||||
{
|
||||
var name = anfrage.UserName?.Trim() ?? "";
|
||||
if (name.Length == 0 || (anfrage.Password?.Length ?? 0) < 8)
|
||||
{
|
||||
return Einwand.Bitte(
|
||||
"Benutzername darf nicht leer sein, das Passwort braucht mindestens 8 Zeichen.");
|
||||
}
|
||||
|
||||
var jetzt = uhr.GetUtcNow();
|
||||
var gefunden = await Suchen(db, token, ct);
|
||||
if (Pruefen(gefunden, jetzt) is { } einwand) return einwand;
|
||||
|
||||
// **Verbrauchen und anlegen gehören zusammen.**
|
||||
//
|
||||
// Zwei Leute, die gleichzeitig denselben einmaligen Link öffnen,
|
||||
// läsen beide `UsedCount = 0` und schrieben beide `1` — und hätten
|
||||
// beide ein Konto. Der Zähler wird deshalb mit einer Bedingung
|
||||
// hochgesetzt, die die Gültigkeit noch einmal prüft; wer dabei
|
||||
// keine Zeile trifft, war der Zweite.
|
||||
//
|
||||
// Und das Ganze in einer Transaktion: scheitert das Anlegen am
|
||||
// Namen, rollt der Verbrauch mit zurück. Sonst wäre ein einmaliger
|
||||
// Link an einem Tippfehler verbrannt.
|
||||
await using var geschaeft = await db.Database.BeginTransactionAsync(ct);
|
||||
|
||||
var verbraucht = await db.Einladungen
|
||||
.Where(e => e.Id == gefunden!.Id
|
||||
&& e.RevokedAt == null
|
||||
&& e.ExpiresAt > jetzt
|
||||
&& (e.MaxUses == null || e.UsedCount < e.MaxUses))
|
||||
.ExecuteUpdateAsync(s => s.SetProperty(e => e.UsedCount, e => e.UsedCount + 1), ct);
|
||||
|
||||
if (verbraucht != 1)
|
||||
return Einwand.Bitte("Dieser Einladungslink wurde schon benutzt.");
|
||||
|
||||
if (await db.Users.AnyAsync(u => u.UserName == name, ct))
|
||||
return Einwand.Belegt($"„{name}“ gibt es schon. Nimm einen anderen.");
|
||||
|
||||
db.Users.Add(new User
|
||||
{
|
||||
UserName = name,
|
||||
PasswordHash = PasswordHasher.Hash(anfrage.Password!),
|
||||
IsAdministrator = false,
|
||||
});
|
||||
|
||||
await db.SaveChangesAsync(ct);
|
||||
await geschaeft.CommitAsync(ct);
|
||||
return Results.NoContent();
|
||||
}).AllowAnonymous().RequireRateLimiting(FlaroRateLimits.SignIn);
|
||||
}
|
||||
|
||||
private static Task<Einladung?> Suchen(FlaroContext db, string token, CancellationToken ct) =>
|
||||
db.Einladungen.FirstOrDefaultAsync(
|
||||
e => e.TokenFingerprint == Secrets.Fingerprint(token ?? ""), ct);
|
||||
|
||||
/// <summary>Der Grund, warum ein Link nicht gilt — oder <c>null</c>.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Unterschiedliche Sätze, mit Absicht.</b> Alles in ein „gilt nicht"
|
||||
/// zusammenzufassen wäre verschwiegener, aber hier ist Verschwiegenheit
|
||||
/// am falschen Platz: wer einen Link bekommen hat und abgewiesen wird,
|
||||
/// muss wissen, ob er zu spät ist oder ob jemand ihn zurückgezogen hat —
|
||||
/// sonst fragt er nach, und der Gastgeber rät mit.
|
||||
/// </remarks>
|
||||
private static IResult? Pruefen(Einladung? einladung, DateTimeOffset jetzt) => einladung switch
|
||||
{
|
||||
null => Einwand.Fehlt("Diesen Einladungslink gibt es nicht."),
|
||||
{ RevokedAt: not null } => Einwand.Bitte("Dieser Einladungslink wurde zurückgezogen."),
|
||||
var e when jetzt >= e.ExpiresAt => Einwand.Bitte("Dieser Einladungslink ist abgelaufen."),
|
||||
var e when e.MaxUses is { } h && e.UsedCount >= h =>
|
||||
Einwand.Bitte("Dieser Einladungslink wurde schon benutzt."),
|
||||
_ => null,
|
||||
};
|
||||
|
||||
private static Guid? Kennung(ClaimsPrincipal wer) =>
|
||||
Guid.TryParse(wer.FindFirstValue(ClaimTypes.NameIdentifier), out var id) ? id : null;
|
||||
}
|
||||
@@ -272,6 +272,7 @@ app.MapArtwork();
|
||||
app.MapProfil();
|
||||
app.MapFreigabe();
|
||||
app.MapMeldungen();
|
||||
app.MapEinladungen();
|
||||
|
||||
// **Was unter /api nicht beantwortet wurde, ist nicht da.** Ohne diese Zeile
|
||||
// fängt der Rückfall darunter jeden unbekannten Pfad ab und liefert die
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
namespace Flaro.Core.Auth;
|
||||
|
||||
/// <summary>Ein Link, mit dem sich jemand selbst ein Konto anlegt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Warum nicht der vorhandene <see cref="AuthCode"/>.</b> Der ist ein
|
||||
/// Gerätecode: fünf Minuten Leben, ein Gerätename daneben, und sein
|
||||
/// <c>ApprovedByUserId</c> zeigt auf ein Konto, das es schon gibt — jemand,
|
||||
/// der angemeldet ist, winkt ein zweites Gerät durch. Eine Einladung ist das
|
||||
/// Gegenteil: erlaubt wird vorab, und wer sie einlöst, hat noch gar kein
|
||||
/// Konto. Dieselbe Tabelle für beides hiesse, die Hälfte ihrer Spalten
|
||||
/// wechselweise leer zu lassen.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Übernommen ist die Geheimnisdisziplin.</b> Wie bei
|
||||
/// <see cref="DeviceToken"/> liegt hier nur der Fingerabdruck; den Link
|
||||
/// selbst bekommt man genau einmal zu sehen, beim Erstellen. Wer die
|
||||
/// Datenbank liest, kann daraus keine Einladung bauen.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Keine Rolle.</b> Wer eingeladen wird, ist gewöhnlicher Benutzer. Ein
|
||||
/// Feld, über das ein Link Adminrechte verschenken könnte, gibt es nicht —
|
||||
/// und damit auch keinen Weg, es versehentlich zu setzen. Administratoren
|
||||
/// legt man von Hand an, und das ist selten genug.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class Einladung
|
||||
{
|
||||
public Guid Id { get; init; } = Guid.CreateVersion7();
|
||||
|
||||
/// <summary>Siehe <see cref="Secrets.Fingerprint"/> — nie der Link selbst.</summary>
|
||||
public required string TokenFingerprint { get; init; }
|
||||
|
||||
public required Guid CreatedByUserId { get; init; }
|
||||
|
||||
public required DateTimeOffset CreatedAt { get; init; }
|
||||
|
||||
public required DateTimeOffset ExpiresAt { get; init; }
|
||||
|
||||
/// <summary>Wie oft er gilt. <c>null</c> heisst: unbegrenzt.</summary>
|
||||
public int? MaxUses { get; init; }
|
||||
|
||||
public int UsedCount { get; set; }
|
||||
|
||||
/// <summary>Von Hand zurückgezogen — <c>null</c> heisst: gilt noch.</summary>
|
||||
public DateTimeOffset? RevokedAt { get; set; }
|
||||
|
||||
/// <summary>Ob sich damit jetzt noch ein Konto anlegen lässt.</summary>
|
||||
public bool Gilt(DateTimeOffset jetzt) =>
|
||||
RevokedAt is null
|
||||
&& jetzt < ExpiresAt
|
||||
&& (MaxUses is not { } hoechstens || UsedCount < hoechstens);
|
||||
}
|
||||
@@ -55,6 +55,9 @@ public sealed class FlaroContext(DbContextOptions<FlaroContext> options) : DbCon
|
||||
public DbSet<User> Users => Set<User>();
|
||||
public DbSet<DeviceToken> DeviceTokens => Set<DeviceToken>();
|
||||
public DbSet<AuthCode> AuthCodes => Set<AuthCode>();
|
||||
|
||||
/// <summary>Links, mit denen sich jemand selbst ein Konto anlegt.</summary>
|
||||
public DbSet<Einladung> Einladungen => Set<Einladung>();
|
||||
public DbSet<Library> Libraries => Set<Library>();
|
||||
public DbSet<ServerSetting> Settings => Set<ServerSetting>();
|
||||
|
||||
@@ -129,6 +132,24 @@ public sealed class FlaroContext(DbContextOptions<FlaroContext> options) : DbCon
|
||||
e.Property(x => x.DeviceId).HasMaxLength(128);
|
||||
});
|
||||
|
||||
b.Entity<Einladung>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
|
||||
// Gesucht wird nur über den Fingerabdruck — und eindeutig, damit
|
||||
// zwei Links niemals dasselbe Konto füttern können.
|
||||
e.HasIndex(x => x.TokenFingerprint).IsUnique();
|
||||
e.Property(x => x.TokenFingerprint).HasMaxLength(64);
|
||||
|
||||
// Die Liste in der Verwaltung: die neuesten zuerst.
|
||||
e.HasIndex(x => x.CreatedAt);
|
||||
|
||||
// Wer einlädt und später gelöscht wird, nimmt seine offenen
|
||||
// Einladungen mit. Ein Link ohne Absender ist keiner.
|
||||
e.HasOne<User>().WithMany().HasForeignKey(x => x.CreatedByUserId)
|
||||
.OnDelete(DeleteBehavior.Cascade);
|
||||
});
|
||||
|
||||
b.Entity<Library>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,62 @@
|
||||
using System;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Flaro.Data.Migrations
|
||||
{
|
||||
/// <inheritdoc />
|
||||
public partial class Einladungen : Migration
|
||||
{
|
||||
/// <inheritdoc />
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.CreateTable(
|
||||
name: "Einladungen",
|
||||
columns: table => new
|
||||
{
|
||||
Id = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
TokenFingerprint = table.Column<string>(type: "TEXT", maxLength: 64, nullable: false),
|
||||
CreatedByUserId = table.Column<Guid>(type: "TEXT", nullable: false),
|
||||
CreatedAt = table.Column<long>(type: "INTEGER", nullable: false),
|
||||
ExpiresAt = table.Column<long>(type: "INTEGER", nullable: false),
|
||||
MaxUses = table.Column<int>(type: "INTEGER", nullable: true),
|
||||
UsedCount = table.Column<int>(type: "INTEGER", nullable: false),
|
||||
RevokedAt = table.Column<long>(type: "INTEGER", nullable: true)
|
||||
},
|
||||
constraints: table =>
|
||||
{
|
||||
table.PrimaryKey("PK_Einladungen", x => x.Id);
|
||||
table.ForeignKey(
|
||||
name: "FK_Einladungen_Users_CreatedByUserId",
|
||||
column: x => x.CreatedByUserId,
|
||||
principalTable: "Users",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
});
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Einladungen_CreatedAt",
|
||||
table: "Einladungen",
|
||||
column: "CreatedAt");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Einladungen_CreatedByUserId",
|
||||
table: "Einladungen",
|
||||
column: "CreatedByUserId");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Einladungen_TokenFingerprint",
|
||||
table: "Einladungen",
|
||||
column: "TokenFingerprint",
|
||||
unique: true);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropTable(
|
||||
name: "Einladungen");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -108,6 +108,47 @@ namespace Flaro.Data.Migrations
|
||||
b.ToTable("DeviceTokens");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Auth.Einladung", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("CreatedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<Guid>("CreatedByUserId")
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<long>("ExpiresAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<int?>("MaxUses")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<long?>("RevokedAt")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.Property<string>("TokenFingerprint")
|
||||
.IsRequired()
|
||||
.HasMaxLength(64)
|
||||
.HasColumnType("TEXT");
|
||||
|
||||
b.Property<int>("UsedCount")
|
||||
.HasColumnType("INTEGER");
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("CreatedAt");
|
||||
|
||||
b.HasIndex("CreatedByUserId");
|
||||
|
||||
b.HasIndex("TokenFingerprint")
|
||||
.IsUnique();
|
||||
|
||||
b.ToTable("Einladungen");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Libraries.Library", b =>
|
||||
{
|
||||
b.Property<Guid>("Id")
|
||||
@@ -920,6 +961,15 @@ namespace Flaro.Data.Migrations
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Auth.Einladung", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Users.User", null)
|
||||
.WithMany()
|
||||
.HasForeignKey("CreatedByUserId")
|
||||
.OnDelete(DeleteBehavior.Cascade)
|
||||
.IsRequired();
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Flaro.Core.Library.Credit", b =>
|
||||
{
|
||||
b.HasOne("Flaro.Core.Library.Movie", null)
|
||||
|
||||
Reference in New Issue
Block a user