HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/utils/db/entities/rowTasks.db.server.ts

import { Prisma, RowTask } from "@toolctrl/db/prisma-browser";
import UserModelHelper from "~/utils/helpers/models/UserModelHelper";
import { db } from "~/utils/db.server";
import { UserSimple } from "../users.db.server";
import { RowWithValues } from "./rows.db.server";

export type RowTaskWithDetails = RowTask & {
  createdByUser: UserSimple;
  assignedToUser: UserSimple | null;
  row: RowWithValues;
};

export async function getRowTasks(rowId: string): Promise<RowTaskWithDetails[]> {
  return await db.rowTask.findMany({
    where: {
      rowId,
    },
    include: {
      ...UserModelHelper.includeSimpleCreatedByUser,
      assignedToUser: true,
      row: {
        include: {
          createdByUser: { select: UserModelHelper.selectSimpleUserProperties },
          createdByApiKey: true,
          values: { include: { media: true, multiple: true, range: true } },
        },
      },
    },
    orderBy: [
      {
        completed: "asc",
      },
      {
        createdAt: "asc",
      },
    ],
  });
}

export async function getRowTask(id: string): Promise<RowTaskWithDetails | null> {
  return await db.rowTask.findUnique({
    where: {
      id,
    },
    include: {
      ...UserModelHelper.includeSimpleCreatedByUser,
      assignedToUser: true,
      row: {
        include: {
          createdByUser: { select: UserModelHelper.selectSimpleUserProperties },
          createdByApiKey: true,
          values: { include: { media: true, multiple: true, range: true } },
        },
      },
    },
  });
}

export async function getRowTaskInRow({ id, rowId }: { id: string; rowId: string }): Promise<RowTaskWithDetails | null> {
  return await db.rowTask.findFirst({
    where: {
      id,
      rowId,
    },
    include: {
      ...UserModelHelper.includeSimpleCreatedByUser,
      assignedToUser: true,
      row: {
        include: {
          createdByUser: { select: UserModelHelper.selectSimpleUserProperties },
          createdByApiKey: true,
          values: { include: { media: true, multiple: true, range: true } },
        },
      },
    },
  });
}

export async function createRowTask(data: {
  createdByUserId: string;
  rowId: string;
  title: string;
  description?: string;
  completed?: boolean;
  completedAt?: Date | null;
  completedByUserId?: string | null;
  assignedToUserId?: string | null;
  deadline?: Date | null;
}) {
  return await db.rowTask.create({
    data: {
      createdByUserId: data.createdByUserId,
      rowId: data.rowId,
      title: data.title,
      description: data.description ?? "",
      completed: data.completed ?? false,
      completedAt: data.completedAt ?? null,
      completedByUserId: data.completedByUserId ?? null,
      assignedToUserId: data.assignedToUserId ?? null,
      deadline: data.deadline ?? null,
    },
  });
}

export async function updateRowTaskInRow(
  scope: { id: string; rowId: string },
  data: {
    createdByUserId?: string;
    rowId?: string;
    title?: string;
    description?: string;
    completed?: boolean;
    completedAt?: Date | null;
    completedByUserId?: string | null;
    assignedToUserId?: string | null;
    deadline?: Date | null;
  }
) {
  const updated = await db.rowTask.updateMany({
    where: {
      id: scope.id,
      rowId: scope.rowId,
    },
    data,
  });
  if (updated.count !== 1) {
    throw new Error("Row task not found");
  }
  return updated;
}

export async function deleteRowTaskInRow(scope: { id: string; rowId: string }) {
  const deleted = await db.rowTask.deleteMany({
    where: {
      id: scope.id,
      rowId: scope.rowId,
    },
  });
  if (deleted.count !== 1) {
    throw new Error("Row task not found");
  }
  return deleted;
}

export async function getAllRowTasks({
  completed,
  assignedOrCreatedUserId,
  tenantId,
}: {
  completed?: boolean;
  assignedOrCreatedUserId?: string;
  tenantId?: string | null;
}): Promise<RowTaskWithDetails[]> {
  const userWhere: Prisma.RowTaskWhereInput = {};
  if (assignedOrCreatedUserId) {
    userWhere.OR = [
      {
        createdByUserId: assignedOrCreatedUserId,
      },
      {
        assignedToUserId: assignedOrCreatedUserId,
      },
    ];
  }
  return await db.rowTask.findMany({
    where: {
      completed,
      ...(tenantId !== undefined ? { row: { tenantId } } : {}),
      ...userWhere,
    },
    include: {
      ...UserModelHelper.includeSimpleCreatedByUser,
      assignedToUser: true,
      row: {
        include: {
          createdByUser: { select: UserModelHelper.selectSimpleUserProperties },
          createdByApiKey: true,
          values: { include: { media: true, multiple: true, range: true } },
        },
      },
    },
    orderBy: [
      {
        createdAt: "desc",
      },
    ],
  });
}