431 lines
13 KiB
TypeScript
431 lines
13 KiB
TypeScript
import { usePrisma } from "../utils/prisma";
|
|
import { createNotification } from "./notifications";
|
|
|
|
// ─── Custom Domains ───────────────────────────────────────────────────────────
|
|
|
|
export async function getUserCustomDomains(userId: string) {
|
|
const db = usePrisma();
|
|
const rows = await db.userCustomDomain.findMany({
|
|
where: { userId },
|
|
orderBy: { addedAt: "desc" },
|
|
select: {
|
|
id: true,
|
|
domain: true,
|
|
status: true,
|
|
postId: true,
|
|
addedAt: true,
|
|
submission: {
|
|
select: { id: true, yesVotes: true, noVotes: true, status: true },
|
|
},
|
|
},
|
|
});
|
|
return rows;
|
|
}
|
|
|
|
/**
|
|
* Counts domains that occupy a slot (active + submitted).
|
|
* approved → slot freed (domain joined global list)
|
|
* rejected → slot freed (user can re-submit or delete)
|
|
*/
|
|
export async function countActiveCustomDomains(userId: string) {
|
|
const db = usePrisma();
|
|
return db.userCustomDomain.count({
|
|
where: { userId, status: { notIn: ["approved", "rejected"] } },
|
|
});
|
|
}
|
|
|
|
export async function addUserCustomDomain(
|
|
userId: string,
|
|
domain: string,
|
|
source = "manual",
|
|
) {
|
|
const db = usePrisma();
|
|
return db.userCustomDomain.create({
|
|
data: { userId, domain, source },
|
|
select: { id: true, domain: true },
|
|
});
|
|
}
|
|
|
|
export async function deleteUserCustomDomain(id: string, userId: string) {
|
|
const db = usePrisma();
|
|
// Cannot delete submitted/approved domains (protect integrity)
|
|
const existing = await db.userCustomDomain.findFirst({
|
|
where: { id, userId },
|
|
select: { status: true },
|
|
});
|
|
if (!existing) throw Object.assign(new Error("Not found"), { code: "P2025" });
|
|
if (existing.status === "submitted" || existing.status === "approved") {
|
|
throw Object.assign(
|
|
new Error(
|
|
"Eingereichte oder genehmigte Domains können nicht gelöscht werden",
|
|
),
|
|
{ code: "DOMAIN_LOCKED" },
|
|
);
|
|
}
|
|
return db.userCustomDomain.delete({ where: { id, userId } });
|
|
}
|
|
|
|
export async function deleteAllUserCustomDomains(userId: string) {
|
|
const db = usePrisma();
|
|
return db.userCustomDomain.deleteMany({ where: { userId } });
|
|
}
|
|
|
|
// ─── Domain Submissions ───────────────────────────────────────────────────────
|
|
|
|
// Net-Vote-Schwelle (yesVotes - noVotes) damit eine Submission von der
|
|
// Community-Vote-Phase in die Admin-Review-Phase wandert.
|
|
export const NET_VOTE_THRESHOLD = 10;
|
|
|
|
// Submission-Status:
|
|
// "pending" → Community-Voting-Phase (nur Pro)
|
|
// "in_review" → wartet auf Admin (Legend direkt, Pro nach 10 Netto-Yes-Votes)
|
|
// "approved" → in globaler Blocklist
|
|
// "rejected" → vom Admin abgelehnt
|
|
export type SubmissionPlan = "free" | "pro" | "legend";
|
|
|
|
export async function submitDomainForReview(
|
|
userId: string,
|
|
customDomainId: string,
|
|
plan: SubmissionPlan,
|
|
postId?: string,
|
|
) {
|
|
if (plan === "free") {
|
|
throw Object.assign(new Error("Free-Plan kann keine Domains einreichen"), {
|
|
code: "PLAN_NO_SUBMIT",
|
|
});
|
|
}
|
|
const submissionStatus = plan === "legend" ? "in_review" : "pending";
|
|
const db = usePrisma();
|
|
return db.$transaction(async (tx) => {
|
|
// Mark custom domain as submitted
|
|
const domain = await tx.userCustomDomain.update({
|
|
where: { id: customDomainId, userId },
|
|
data: { status: "submitted", postId: postId ?? null },
|
|
select: { id: true, domain: true },
|
|
});
|
|
// Create submission record
|
|
const submission = await tx.domainSubmission.create({
|
|
data: {
|
|
userId,
|
|
domain: domain.domain,
|
|
customDomainId,
|
|
postId: postId ?? null,
|
|
status: submissionStatus,
|
|
},
|
|
});
|
|
return { domain, submission };
|
|
});
|
|
}
|
|
|
|
export async function castDomainVote(
|
|
userId: string,
|
|
submissionId: string,
|
|
vote: "yes" | "no",
|
|
) {
|
|
const db = usePrisma();
|
|
return db.$transaction(async (tx) => {
|
|
// Upsert vote (change allowed)
|
|
const existing = await tx.domainVote.findUnique({
|
|
where: { userId_submissionId: { userId, submissionId } },
|
|
});
|
|
if (existing) {
|
|
if (existing.vote === vote) return { changed: false };
|
|
await tx.domainVote.update({
|
|
where: { userId_submissionId: { userId, submissionId } },
|
|
data: { vote },
|
|
});
|
|
} else {
|
|
await tx.domainVote.create({ data: { userId, submissionId, vote } });
|
|
}
|
|
|
|
// Recount
|
|
const [yes, no] = await Promise.all([
|
|
tx.domainVote.count({ where: { submissionId, vote: "yes" } }),
|
|
tx.domainVote.count({ where: { submissionId, vote: "no" } }),
|
|
]);
|
|
const updated = await tx.domainSubmission.update({
|
|
where: { id: submissionId },
|
|
data: { yesVotes: yes, noVotes: no },
|
|
});
|
|
|
|
// Netto-Yes (yes - no) muss die Schwelle erreichen, dann wandert die
|
|
// Submission in die Admin-Review-Phase. Approval erfolgt erst durch Admin.
|
|
let movedToReview = false;
|
|
if (updated.status === "pending" && yes - no >= NET_VOTE_THRESHOLD) {
|
|
await tx.domainSubmission.update({
|
|
where: { id: submissionId },
|
|
data: { status: "in_review" },
|
|
});
|
|
movedToReview = true;
|
|
}
|
|
|
|
return { yesVotes: yes, noVotes: no, movedToReview };
|
|
});
|
|
}
|
|
|
|
async function approveDomainSubmissionTx(
|
|
tx: any,
|
|
submissionId: string,
|
|
customDomainId: string,
|
|
domain: string,
|
|
) {
|
|
await tx.domainSubmission.update({
|
|
where: { id: submissionId },
|
|
data: { status: "approved", reviewedAt: new Date() },
|
|
});
|
|
await tx.userCustomDomain.update({
|
|
where: { id: customDomainId },
|
|
data: { status: "approved" },
|
|
});
|
|
// Add to global blocklist
|
|
await tx.blocklistDomain.upsert({
|
|
where: { domain },
|
|
create: { domain, source: "community", isActive: true },
|
|
update: { isActive: true },
|
|
});
|
|
}
|
|
|
|
export async function adminApproveSubmission(
|
|
submissionId: string,
|
|
reviewNote?: string,
|
|
) {
|
|
const db = usePrisma();
|
|
const sub = await db.domainSubmission.findUniqueOrThrow({
|
|
where: { id: submissionId },
|
|
select: {
|
|
customDomainId: true,
|
|
domain: true,
|
|
status: true,
|
|
userId: true,
|
|
postId: true,
|
|
},
|
|
});
|
|
// Admin darf in beiden offenen Phasen approven (Vote oder Review)
|
|
if (sub.status !== "pending" && sub.status !== "in_review") {
|
|
throw new Error("Submission already resolved");
|
|
}
|
|
|
|
await db.$transaction((tx) =>
|
|
approveDomainSubmissionTx(tx, submissionId, sub.customDomainId, sub.domain),
|
|
);
|
|
|
|
// Alle anderen User die diese Domain als Custom Domain haben → Slot freigeben + benachrichtigen
|
|
const affectedDomains = await db.userCustomDomain.findMany({
|
|
where: {
|
|
domain: sub.domain,
|
|
// Submitter's domain already handled in approveDomainSubmissionTx
|
|
id: { not: sub.customDomainId },
|
|
status: { notIn: ["approved", "rejected"] },
|
|
},
|
|
select: { id: true, userId: true },
|
|
});
|
|
|
|
if (affectedDomains.length > 0) {
|
|
// Batch-Update: alle auf "approved" setzen (Slot freigeben)
|
|
await db.userCustomDomain.updateMany({
|
|
where: { id: { in: affectedDomains.map((d) => d.id) } },
|
|
data: { status: "approved" },
|
|
});
|
|
|
|
// Notification an jeden betroffenen User
|
|
await Promise.allSettled(
|
|
affectedDomains.map((d) =>
|
|
createNotification({
|
|
recipientId: d.userId,
|
|
type: "domain_accepted",
|
|
actorName: "ReBreak",
|
|
postId: sub.postId ?? undefined,
|
|
preview: sub.domain,
|
|
}),
|
|
),
|
|
);
|
|
}
|
|
|
|
// Auch Submitter benachrichtigen (Admin hat seine Domain genehmigt)
|
|
await createNotification({
|
|
recipientId: sub.userId,
|
|
type: "domain_accepted",
|
|
actorName: "ReBreak Admin",
|
|
postId: sub.postId ?? undefined,
|
|
preview: sub.domain,
|
|
}).catch(() => {});
|
|
|
|
return db.domainSubmission.findUnique({ where: { id: submissionId } });
|
|
}
|
|
|
|
export async function adminRejectSubmission(
|
|
submissionId: string,
|
|
reviewNote?: string,
|
|
) {
|
|
const db = usePrisma();
|
|
// Submission + zugehörige Custom-Domain laden (für Notification + Cleanup)
|
|
const sub = await db.domainSubmission.findUniqueOrThrow({
|
|
where: { id: submissionId },
|
|
select: {
|
|
userId: true,
|
|
domain: true,
|
|
postId: true,
|
|
customDomainId: true,
|
|
},
|
|
});
|
|
|
|
await db.$transaction(async (tx) => {
|
|
await tx.domainSubmission.update({
|
|
where: { id: submissionId },
|
|
data: {
|
|
status: "rejected",
|
|
reviewedAt: new Date(),
|
|
reviewNote: reviewNote ?? null,
|
|
},
|
|
});
|
|
// Custom-Domain des Submitters komplett aus seiner Liste entfernen
|
|
// (DomainSubmission via onDelete: Cascade automatisch mitgelöscht? NEIN —
|
|
// Submission referenziert customDomain. Wir haben Submission gerade upgedatet,
|
|
// also sicher löschen via Cascade von customDomain → submission.)
|
|
await tx.userCustomDomain.delete({
|
|
where: { id: sub.customDomainId },
|
|
});
|
|
});
|
|
|
|
// Submitter benachrichtigen — Notification von ReBreak (System)
|
|
await createNotification({
|
|
recipientId: sub.userId,
|
|
type: "domain_rejected",
|
|
actorName: "ReBreak",
|
|
postId: sub.postId ?? undefined,
|
|
preview: sub.domain,
|
|
}).catch(() => {});
|
|
|
|
return { customDomainId: sub.customDomainId };
|
|
}
|
|
|
|
export async function getPendingSubmissions() {
|
|
const db = usePrisma();
|
|
return db.domainSubmission.findMany({
|
|
where: { status: { in: ["pending", "in_review"] } },
|
|
orderBy: [{ status: "asc" }, { yesVotes: "desc" }],
|
|
select: {
|
|
id: true,
|
|
domain: true,
|
|
yesVotes: true,
|
|
noVotes: true,
|
|
status: true,
|
|
createdAt: true,
|
|
userId: true,
|
|
postId: true,
|
|
customDomain: { select: { id: true } },
|
|
},
|
|
});
|
|
}
|
|
|
|
// ─── Global Blocklist ─────────────────────────────────────────────────────────
|
|
|
|
export async function getActiveBlocklistCount() {
|
|
const db = usePrisma();
|
|
return db.blocklistDomain.count({ where: { isActive: true } });
|
|
}
|
|
|
|
export async function getActiveBlocklistDomains() {
|
|
const db = usePrisma();
|
|
return db.blocklistDomain.findMany({
|
|
where: { isActive: true },
|
|
select: { domain: true },
|
|
});
|
|
}
|
|
|
|
export async function isBlocklistedDomain(
|
|
domain: string,
|
|
userId: string,
|
|
): Promise<boolean> {
|
|
const db = usePrisma();
|
|
const [global, custom] = await Promise.all([
|
|
db.blocklistDomain.findFirst({
|
|
where: { domain, isActive: true },
|
|
select: { domain: true },
|
|
}),
|
|
db.userCustomDomain.findFirst({
|
|
where: { domain, userId },
|
|
select: { domain: true },
|
|
}),
|
|
]);
|
|
return !!(global || custom);
|
|
}
|
|
|
|
export async function getBlocklistedDomainsSet(
|
|
domains: string[],
|
|
userId: string,
|
|
includeGlobal = true,
|
|
): Promise<Set<string>> {
|
|
if (domains.length === 0) return new Set();
|
|
const db = usePrisma();
|
|
const unique = [...new Set(domains)];
|
|
|
|
// Alle möglichen Parent-Domains erzeugen: "mail.casino.de" → ["mail.casino.de", "casino.de"]
|
|
const allVariants = [
|
|
...new Set(
|
|
unique.flatMap((d) => {
|
|
const parts = d.split(".");
|
|
return parts
|
|
.map((_, i) => parts.slice(i).join("."))
|
|
.filter((v) => v.includes("."));
|
|
}),
|
|
),
|
|
];
|
|
|
|
const queries: Promise<{ domain: string }[]>[] = [];
|
|
|
|
if (includeGlobal) {
|
|
queries.push(
|
|
db.blocklistDomain.findMany({
|
|
where: { domain: { in: allVariants }, isActive: true },
|
|
select: { domain: true },
|
|
}),
|
|
);
|
|
}
|
|
|
|
queries.push(
|
|
db.userCustomDomain.findMany({
|
|
where: { domain: { in: allVariants }, userId },
|
|
select: { domain: true },
|
|
}),
|
|
);
|
|
|
|
const results = await Promise.all(queries);
|
|
const blockedSet = new Set(results.flatMap((r) => r.map((d) => d.domain)));
|
|
|
|
// Zurück auf Original-Domains mappen: wenn irgendein Variant geblockt ist → Original blocken
|
|
const result = new Set<string>();
|
|
for (const orig of unique) {
|
|
const parts = orig.split(".");
|
|
const variants = parts
|
|
.map((_, i) => parts.slice(i).join("."))
|
|
.filter((v) => v.includes("."));
|
|
if (variants.some((v) => blockedSet.has(v))) result.add(orig);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
export async function upsertBlocklistDomains(
|
|
domains: { domain: string; source: string }[],
|
|
) {
|
|
const db = usePrisma();
|
|
// Batch upsert in chunks
|
|
const CHUNK = 5000;
|
|
let total = 0;
|
|
for (let i = 0; i < domains.length; i += CHUNK) {
|
|
const chunk = domains.slice(i, i + CHUNK).map((d) => ({
|
|
...d,
|
|
isActive: true,
|
|
}));
|
|
for (const d of chunk) {
|
|
await db.blocklistDomain.upsert({
|
|
where: { domain: d.domain },
|
|
create: d,
|
|
update: { isActive: true },
|
|
});
|
|
total++;
|
|
}
|
|
}
|
|
return total;
|
|
}
|