sendou.ink/app/features/tournament/TournamentTeamRepository.server.ts

// TODO: add rest of the functions here that relate more to tournament teams than tournament/bracket

import type { Transaction } from "kysely";
import { sql } from "kysely";
import { nanoid } from "nanoid";
import { INVITE_CODE_LENGTH } from "~/constants";
import { db } from "~/db/sql";
import type { DB, Tables } from "~/db/tables";
import { databaseTimestampNow } from "~/utils/dates";

export function setActiveRoster({
  teamId,
  activeRosterUserIds,
}: {
  teamId: number;
  activeRosterUserIds: number[];
}) {
  return db
    .updateTable("TournamentTeam")
    .set({ activeRosterUserIds: JSON.stringify(activeRosterUserIds) })
    .where("TournamentTeam.id", "=", teamId)
    .execute();
}

const regOpenTournamentTeamIdsByJoinedUserId = (userId: number) =>
  db
    .selectFrom("TournamentTeamMember")
    .innerJoin(
      "TournamentTeam",
      "TournamentTeam.id",
      "TournamentTeamMember.tournamentTeamId",
    )
    .innerJoin("Tournament", "Tournament.id", "TournamentTeam.tournamentId")
    .innerJoin("CalendarEvent", "CalendarEvent.tournamentId", "Tournament.id")
    .innerJoin(
      "CalendarEventDate",
      "CalendarEventDate.eventId",
      "CalendarEvent.id",
    )
    .select("TournamentTeamMember.tournamentTeamId")
    .where("TournamentTeamMember.userId", "=", userId)
    .where(
      sql`coalesce(
      "Tournament"."settings" ->> 'regClosesAt', 
      "CalendarEventDate"."startTime"
    )`,
      ">",
      databaseTimestampNow(),
    )
    .execute()
    .then((rows) => rows.map((row) => row.tournamentTeamId));

export async function updateMemberInGameName({
  userId,
  inGameName,
  tournamentTeamId,
}: {
  userId: number;
  inGameName: string;
  tournamentTeamId: number;
}) {
  return db
    .updateTable("TournamentTeamMember")
    .set({ inGameName })
    .where("TournamentTeamMember.userId", "=", userId)
    .where("TournamentTeamMember.tournamentTeamId", "=", tournamentTeamId)
    .execute();
}

export async function updateMemberInGameNameForNonStarted({
  userId,
  inGameName,
}: {
  userId: number;
  inGameName: string;
}) {
  const tournamentTeamIds =
    await regOpenTournamentTeamIdsByJoinedUserId(userId);

  return (
    db
      .updateTable("TournamentTeamMember")
      .set({ inGameName })
      .where("TournamentTeamMember.userId", "=", userId)
      // after they have checked in no longer can update their IGN from here
      .where("TournamentTeamMember.tournamentTeamId", "in", tournamentTeamIds)
      // if the tournament doesn't have the setting to require IGN, ignore
      .where("TournamentTeamMember.inGameName", "is not", null)
      .execute()
  );
}

export function create({
  team,
  avatarFileName,
  userId,
  tournamentId,
  ownerInGameName,
}: {
  team: Pick<
    Tables["TournamentTeam"],
    "name" | "prefersNotToHost" | "noScreen" | "teamId"
  >;
  avatarFileName?: string;
  userId: number;
  tournamentId: number;
  ownerInGameName: string | null;
}) {
  return db.transaction().execute(async (trx) => {
    const avatarImgId = avatarFileName
      ? await createSubmittedImageInTrx({
          trx,
          avatarFileName,
          userId,
        })
      : null;

    const tournamentTeam = await trx
      .insertInto("TournamentTeam")
      .values({
        tournamentId,
        name: team.name,
        inviteCode: nanoid(INVITE_CODE_LENGTH),
        prefersNotToHost: team.prefersNotToHost,
        noScreen: team.noScreen,
        teamId: team.teamId,
        avatarImgId,
      })
      .returning("id")
      .executeTakeFirstOrThrow();

    await trx
      .insertInto("TournamentTeamMember")
      .values({
        tournamentTeamId: tournamentTeam.id,
        userId,
        isOwner: 1,
        inGameName: ownerInGameName,
      })
      .execute();
  });
}

export function update({
  team,
  avatarFileName,
  userId,
}: {
  team: Pick<
    Tables["TournamentTeam"],
    "id" | "name" | "prefersNotToHost" | "noScreen" | "teamId"
  >;
  avatarFileName?: string;
  userId: number;
}) {
  return db.transaction().execute(async (trx) => {
    const avatarImgId = avatarFileName
      ? await createSubmittedImageInTrx({
          trx,
          avatarFileName,
          userId,
        })
      : // don't overwrite the existing avatarImgId even if no new avatar is provided
        // delete is a separate functionality
        undefined;

    await trx
      .updateTable("TournamentTeam")
      .set({
        name: team.name,
        prefersNotToHost: team.prefersNotToHost,
        noScreen: team.noScreen,
        teamId: team.teamId,
        avatarImgId,
      })
      .where("TournamentTeam.id", "=", team.id)
      .execute();
  });
}

async function createSubmittedImageInTrx({
  trx,
  avatarFileName,
  userId,
}: {
  trx: Transaction<DB>;
  avatarFileName: string;
  userId: number;
}) {
  const result = await trx
    .insertInto("UnvalidatedUserSubmittedImage")
    .values({
      url: avatarFileName,
      // in the context of tournament teams images are treated as globally "validated"
      // instead the TO takes responsibility for removing inappropriate images
      validatedAt: databaseTimestampNow(),
      submitterUserId: userId,
    })
    .returning("id")
    .executeTakeFirstOrThrow();

  return result.id;
}

export function deleteLogo(tournamentTeamId: number) {
  return db
    .updateTable("TournamentTeam")
    .set({ avatarImgId: null })
    .where("TournamentTeam.id", "=", tournamentTeamId)
    .execute();
}