Skip to content

Papermark is the open-source DocSend alternative and secure data rooms with built-in analytics and custom domains.

Added link default permission

Ashish Viradiya5bcf212e3cb4
diff --git a/components/datarooms/dataroom-items-list.tsx b/components/datarooms/dataroom-items-list.tsx
index 5144a12c..70a0eddc 100644
--- a/components/datarooms/dataroom-items-list.tsx
+++ b/components/datarooms/dataroom-items-list.tsx
@@ -34,6 +34,7 @@ import {
useDataroom,
} from "@/lib/swr/use-dataroom";
import useDataroomGroups from "@/lib/swr/use-dataroom-groups";
+import useDataroomPermissionGroups from "@/lib/swr/use-dataroom-permission-groups";
import { useMediaQuery } from "@/lib/utils/use-media-query";
import { useRemoveDataroomItemsModal } from "@/components/datarooms/actions/remove-document-modal";
@@ -77,10 +78,15 @@ export function DataroomItemsList({
documentCount: number;
}) {
const { viewerGroups } = useDataroomGroups();
+ const { permissionGroups } = useDataroomPermissionGroups();
const { dataroom } = useDataroom();
const { isMobile } = useMediaQuery();
- const { applyDefaultPermissions, inheritParentPermissions } =
- useDataroomPermissions();
+ const {
+ applyDefaultPermissions,
+ inheritParentPermissions,
+ applyDefaultPermissionGroupPermissions,
+ inheritParentPermissionGroupPermissions,
+ } = useDataroomPermissions();
const [uploads, setUploads] = useState<UploadState[]>([]);
const [rejectedFiles, setRejectedFiles] = useState<RejectedFile[]>([]);
@@ -552,47 +558,93 @@ export function DataroomItemsList({
dataroomDocumentId: string;
}[],
) => {
- if (viewerGroups && viewerGroups.length === 0) return;
-
- const defaultPermission =
- dataroom?.defaultGroupPermission || "ask_every_time";
- if (defaultPermission === "ask_every_time" && files.length > 0) {
- setUploadedFiles(files);
- setShowGroupPermissions(true);
- return;
+ // Check if there are any groups to apply permissions to
+ const hasViewerGroups = viewerGroups && viewerGroups.length > 0;
+ const hasPermissionGroups = permissionGroups && permissionGroups.length > 0;
+
+ if (!hasViewerGroups && !hasPermissionGroups) return;
+
+ const documentIds = files.map((file) => file.documentId);
+ const promises = [];
+
+ // Handle ViewerGroup permissions
+ if (hasViewerGroups) {
+ const defaultPermission =
+ dataroom?.defaultGroupPermission || "ask_every_time";
+
+ if (defaultPermission === "use_default_permissions") {
+ promises.push(applyDefaultPermissions(dataroomId, documentIds));
+ } else if (defaultPermission === "inherit_from_parent") {
+ const isRootLevel = !folderPathName || folderPathName.length === 0;
+ if (isRootLevel) {
+ // For root level, show modal or apply defaults
+ setShowGroupPermissions(true);
+ setUploadedFiles(files);
+ } else {
+ // For subfolder uploads, inherit permissions from parent folder
+ promises.push(
+ inheritParentPermissions(
+ dataroomId,
+ documentIds,
+ folderPathName?.join("/"),
+ ),
+ );
+ }
+ }
}
- if (defaultPermission === "inherit_from_parent") {
- const isRootLevel = !folderPathName || folderPathName.length === 0;
- if (isRootLevel) {
- setUploadedFiles(files);
- setShowGroupPermissions(true);
- } else {
- const documentIds = files.map((file) => file.documentId);
- inheritParentPermissions(
- dataroomId,
- documentIds,
- folderPathName.join("/"),
- ).catch((error) => {
- console.error("Failed to inherit parent permissions:", error);
- toast.error("Failed to inherit parent permissions");
- });
+ // Handle PermissionGroup permissions
+ if (hasPermissionGroups) {
+ const linkPermissionStrategy =
+ dataroom?.defaultLinkPermission || "inherit_from_parent";
+
+ if (linkPermissionStrategy === "inherit_from_parent") {
+ promises.push(
+ inheritParentPermissionGroupPermissions(
+ dataroomId,
+ documentIds,
+ folderPathName?.join("/"),
+ ),
+ );
+ } else if (
+ linkPermissionStrategy === "use_default_permissions" ||
+ linkPermissionStrategy === "use_simple_permissions"
+ ) {
+ const isRootLevel = !folderPathName || folderPathName.length === 0;
+
+ if (isRootLevel) {
+ promises.push(
+ applyDefaultPermissionGroupPermissions(dataroomId, documentIds),
+ );
+ } else {
+ promises.push(
+ inheritParentPermissionGroupPermissions(
+ dataroomId,
+ documentIds,
+ folderPathName?.join("/"),
+ ),
+ );
+ }
}
- return;
}
- if (defaultPermission === "use_default_permissions") {
- const documentIds = files.map((file) => file.documentId);
- applyDefaultPermissions(dataroomId, documentIds).catch((error) => {
+ Promise.allSettled(promises)
+ .then((results) => {
+ const failures = results.filter(
+ (result) =>
+ result.status === "rejected" ||
+ (result.status === "fulfilled" && !result.value.success),
+ );
+
+ if (failures.length > 0) {
+ console.error("Failed to apply default permissions:", failures);
+ toast.error("Failed to apply default permissions");
+ }
+ })
+ .catch((error) => {
console.error("Failed to apply default permissions:", error);
toast.error("Failed to apply default permissions");
});
- return;
- }
-
- if (defaultPermission === "no_permissions") {
- return;
- }
};
return (
diff --git a/components/datarooms/settings/link-permission-settings.tsx b/components/datarooms/settings/link-permission-settings.tsx
new file mode 100644
index 00000000..b8b64a92
--- /dev/null
+++ b/components/datarooms/settings/link-permission-settings.tsx
@@ -0,0 +1,480 @@
+import { useState } from "react";
+
+import { useTeam } from "@/context/team-context";
+import { AnimatePresence, motion } from "motion/react";
+import { toast } from "sonner";
+import useSWR from "swr";
+
+import useDataroomPermissionGroups from "@/lib/swr/use-dataroom-permission-groups";
+import { fetcher } from "@/lib/utils";
+
+import {
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+} from "@/components/ui/card";
+import { Label } from "@/components/ui/label";
+import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group";
+import { Switch } from "@/components/ui/switch";
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from "@/components/ui/table";
+
+type DefaultLinkPermissionStrategy =
+ | "inherit_from_parent"
+ | "use_default_permissions"
+ | "use_simple_permissions";
+
+interface LinkPermissionSettingsProps {
+ dataroomId: string;
+}
+
+export default function LinkPermissionSettings({
+ dataroomId,
+}: LinkPermissionSettingsProps) {
+ const teamInfo = useTeam();
+ const teamId = teamInfo?.currentTeam?.id;
+ const { permissionGroups, mutate: mutateGroups } =
+ useDataroomPermissionGroups();
+
+ const { data: dataroomData, mutate: mutateDataroom } = useSWR<{
+ id: string;
+ name: string;
+ pId: string;
+ defaultLinkPermission: DefaultLinkPermissionStrategy;
+ defaultLinkCanView: boolean;
+ defaultLinkCanDownload: boolean;
+ }>(
+ teamId && dataroomId
+ ? `/api/teams/${teamId}/datarooms/${dataroomId}`
+ : null,
+ fetcher,
+ );
+
+ const [isUpdating, setIsUpdating] = useState(false);
+
+ const handlePermissionChange = async (
+ value: DefaultLinkPermissionStrategy,
+ ) => {
+ if (!dataroomId || !teamId || isUpdating || !dataroomData) return;
+ setIsUpdating(true);
+
+ const optimisticData = { ...dataroomData, defaultLinkPermission: value };
+
+ const mutation = async () => {
+ const res = await fetch(`/api/teams/${teamId}/datarooms/${dataroomId}`, {
+ method: "PATCH",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ defaultLinkPermission: value,
+ }),
+ });
+
+ if (!res.ok) {
+ throw new Error("Failed to update link permission settings");
+ }
+
+ return res.json();
+ };
+
+ try {
+ await toast.promise(
+ mutateDataroom(mutation(), {
+ optimisticData,
+ rollbackOnError: true,
+ populateCache: true,
+ revalidate: false,
+ }),
+ {
+ loading: "Updating link permission settings...",
+ success: "Link permission settings updated successfully",
+ error: (err) => err.message,
+ },
+ );
+ } catch (error) {
+ console.error(error);
+ } finally {
+ setIsUpdating(false);
+ }
+ };
+
+ const handleSimplePermissionChange = async (
+ field: "defaultLinkCanView" | "defaultLinkCanDownload",
+ checked: boolean,
+ ) => {
+ if (!dataroomId || !teamId || isUpdating || !dataroomData) return;
+ setIsUpdating(true);
+
+ let updateData: Record<string, boolean> = { [field]: checked };
+
+ if (
+ field === "defaultLinkCanDownload" &&
+ checked &&
+ !dataroomData.defaultLinkCanView
+ ) {
+ // Enabling download but view is disabled - auto enable view
+ updateData.defaultLinkCanView = true;
+ } else if (
+ field === "defaultLinkCanView" &&
+ !checked &&
+ dataroomData.defaultLinkCanDownload
+ ) {
+ // Disabling view but download is enabled - auto disable download
+ updateData.defaultLinkCanDownload = false;
+ }
+
+ const optimisticData = { ...dataroomData, ...updateData };
+
+ const mutation = async () => {
+ const res = await fetch(`/api/teams/${teamId}/datarooms/${dataroomId}`, {
+ method: "PATCH",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(updateData),
+ });
+
+ if (!res.ok) {
+ throw new Error("Failed to update simple permission settings");
+ }
+
+ return res.json();
+ };
+
+ try {
+ await toast.promise(
+ mutateDataroom(mutation(), {
+ optimisticData,
+ rollbackOnError: true,
+ populateCache: true,
+ revalidate: false,
+ }),
+ {
+ loading: "Updating simple permission settings...",
+ success: "Simple permission settings updated successfully",
+ error: (err) => err.message,
+ },
+ );
+ } catch (error) {
+ console.error(error);
+ } finally {
+ setIsUpdating(false);
+ }
+ };
+
+ const updateGroupPermissions = async (
+ groupId: string,
+ permissions: {
+ defaultCanView?: boolean;
+ defaultCanDownload?: boolean;
+ },
+ ) => {
+ if (!teamId) return;
+
+ toast.promise(
+ fetch(
+ `/api/teams/${teamId}/datarooms/${dataroomId}/permission-groups/${groupId}`,
+ {
+ method: "PATCH",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(permissions),
+ },
+ ).then(async (res) => {
+ if (!res.ok) {
+ throw new Error("Failed to update permission group permissions");
+ }
+ await mutateGroups();
+ }),
+ {
+ loading: "Updating permission group permissions...",
+ success: "Permission group permissions updated successfully",
+ error: "Failed to update permission group permissions",
+ },
+ );
+ };
+
+ const handleViewPermissionChange = async (
+ groupId: string,
+ checked: boolean,
+ ) => {
+ const group = permissionGroups?.find((g) => g.id === groupId);
+ if (!group) return;
+
+ // If disabling view, also disable download in single API call
+ if (!checked && (group.defaultCanDownload ?? false)) {
+ await updateGroupPermissions(groupId, {
+ defaultCanView: checked,
+ defaultCanDownload: false,
+ });
+ } else {
+ await updateGroupPermissions(groupId, {
+ defaultCanView: checked,
+ });
+ }
+ };
+
+ const handleDownloadPermissionChange = async (
+ groupId: string,
+ checked: boolean,
+ ) => {
+ const group = permissionGroups?.find((g) => g.id === groupId);
+ if (!group) return;
+
+ // If enabling download, also enable view in single API call
+ if (checked && !(group.defaultCanView ?? false)) {
+ await updateGroupPermissions(groupId, {
+ defaultCanView: true,
+ defaultCanDownload: checked,
+ });
+ } else {
+ await updateGroupPermissions(groupId, {
+ defaultCanDownload: checked,
+ });
+ }
+ };
+
+ const currentStrategy =
+ dataroomData?.defaultLinkPermission ?? "inherit_from_parent";
+ const showGroupSettings = currentStrategy === "use_default_permissions";
+ const showSimpleSettings = currentStrategy === "use_simple_permissions";
+
+ return (
+ <Card>
+ <CardHeader>
+ <CardTitle>Manage Link Default Permissions</CardTitle>
+ <CardDescription>
+ Configure how permissions are applied when adding new documents and
+ folders to this dataroom.
+ </CardDescription>
+ </CardHeader>
+ <CardContent className="space-y-6">
+ <RadioGroup
+ value={currentStrategy}
+ onValueChange={handlePermissionChange}
+ disabled={isUpdating || !dataroomData}
+ className="space-y-3"
+ >
+ <div className="flex items-center space-x-3">
+ <RadioGroupItem
+ value="inherit_from_parent"
+ id="inherit_from_parent"
+ />
+ <div>
+ <Label
+ htmlFor="inherit_from_parent"
+ className="text-sm font-medium"
+ >
+ Inherit from parent folder
+ </Label>
+ <p className="text-xs text-muted-foreground">
+ New documents and folders will automatically inherit the same
+ permissions as their parent folder. If added to the root level,
+ they will be view-only by default.
+ </p>
+ </div>
+ </div>
+
+ <div className="space-y-4">
+ <div className="flex items-center space-x-3">
+ <RadioGroupItem
+ value="use_default_permissions"
+ id="use_default_permissions"
+ />
+ <div>
+ <Label
+ htmlFor="use_default_permissions"
+ className="text-sm font-medium"
+ >
+ Use default link permissions
+ </Label>
+ <p className="text-xs text-muted-foreground">
+ When you add new documents or folders, all existing links will
+ automatically get the permissions you configure below. This
+ ensures consistent access across your dataroom.
+ </p>
+ </div>
+ </div>
+
+ <AnimatePresence>
+ {showGroupSettings && (
+ <motion.div
+ initial={{ opacity: 0, height: 0 }}
+ animate={{ opacity: 1, height: "auto" }}
+ exit={{ opacity: 0, height: 0 }}
+ transition={{ duration: 0.3, ease: "easeInOut" }}
+ className="ml-6 overflow-hidden"
+ >
+ <div className="space-y-2">
+ {permissionGroups === undefined ? (
+ <div className="rounded-lg border bg-muted/20 p-6 text-center">
+ <p className="text-xs text-muted-foreground">
+ Loading permission groups...
+ </p>
+ </div>
+ ) : permissionGroups.length > 0 ? (
+ <div className="rounded-lg border bg-muted/30">
+ <Table>
+ <TableHeader>
+ <TableRow className="border-b">
+ <TableHead className="h-9 w-[60%] text-xs font-medium">
+ Link Name
+ </TableHead>
+ <TableHead className="h-9 w-[20%] text-center text-xs font-medium">
+ Can View
+ </TableHead>
+ <TableHead className="h-9 w-[20%] text-center text-xs font-medium">
+ Can Download
+ </TableHead>
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {permissionGroups.map((group) => {
+ // Get the link name - usually there's one link per permission group
+ const linkName =
+ group.links?.[0]?.name ||
+ (group.links?.[0]?.id
+ ? `Link #${group.links[0].id.slice(-5)}`
+ : null);
+
+ return (
+ <TableRow
+ key={group.id}
+ className="border-b last:border-b-0"
+ >
+ <TableCell className="py-2 text-sm">
+ {linkName || group.name}
+ {group.links && group.links.length > 1 && (
+ <span className="ml-2 text-xs text-muted-foreground">
+ (+{group.links.length - 1} more)
+ </span>
+ )}
+ </TableCell>
+ <TableCell className="py-2 text-center">
+ <Switch
+ checked={group.defaultCanView ?? false}
+ onCheckedChange={(checked) =>
+ handleViewPermissionChange(
+ group.id,
+ checked,
+ )
+ }
+ />
+ </TableCell>
+ <TableCell className="py-2 text-center">
+ <Switch
+ checked={
+ group.defaultCanDownload ?? false
+ }
+ onCheckedChange={(checked) =>
+ handleDownloadPermissionChange(
+ group.id,
+ checked,
+ )
+ }
+ />
+ </TableCell>
+ </TableRow>
+ );
+ })}
+ </TableBody>
+ </Table>
+ </div>
+ ) : (
+ <div className="rounded-lg border border-dashed bg-muted/20 p-6 text-center">
+ <p className="text-xs text-muted-foreground">
+ No links found. Create links to configure permissions
+ for your dataroom.
+ </p>
+ </div>
+ )}
+ </div>
+ </motion.div>
+ )}
+ </AnimatePresence>
+ </div>
+
+ <div className="space-y-4">
+ <div className="flex items-center space-x-3">
+ <RadioGroupItem
+ value="use_simple_permissions"
+ id="use_simple_permissions"
+ />
+ <div>
+ <Label
+ htmlFor="use_simple_permissions"
+ className="text-sm font-medium"
+ >
+ Use simple default permissions
+ </Label>
+ <p className="text-xs text-muted-foreground">
+ Apply the same view and download permissions to all new
+ documents and folders in this dataroom, regardless of where
+ they're added. This gives you full control over access levels
+ within this dataroom.
+ </p>
+ </div>
+ </div>
+
+ <AnimatePresence>
+ {showSimpleSettings && (
+ <motion.div
+ initial={{ opacity: 0, height: 0 }}
+ animate={{ opacity: 1, height: "auto" }}
+ exit={{ opacity: 0, height: 0 }}
+ transition={{ duration: 0.3, ease: "easeInOut" }}
+ className="ml-6 overflow-hidden"
+ >
+ <div className="space-y-4 rounded-lg border bg-muted/30 p-4">
+ <div className="flex items-center justify-between">
+ <div className="space-y-1">
+ <Label className="text-sm font-medium">Can View</Label>
+ </div>
+ <Switch
+ checked={dataroomData?.defaultLinkCanView ?? false}
+ onCheckedChange={(checked) =>
+ handleSimplePermissionChange(
+ "defaultLinkCanView",
+ checked,
+ )
+ }
+ disabled={isUpdating}
+ />
+ </div>
+ <div className="flex items-center justify-between">
+ <div className="space-y-1">
+ <Label className="text-sm font-medium">
+ Can Download
+ </Label>
+ </div>
+ <Switch
+ checked={dataroomData?.defaultLinkCanDownload ?? false}
+ onCheckedChange={(checked) =>
+ handleSimplePermissionChange(
+ "defaultLinkCanDownload",
+ checked,
+ )
+ }
+ disabled={isUpdating}
+ />
+ </div>
+ </div>
+ </motion.div>
+ )}
+ </AnimatePresence>
+ </div>
+ </RadioGroup>
+ </CardContent>
+ </Card>
+ );
+}
diff --git a/components/datarooms/settings/permission-settings.tsx b/components/datarooms/settings/permission-settings.tsx
index 99f59de6..870867e1 100644
--- a/components/datarooms/settings/permission-settings.tsx
+++ b/components/datarooms/settings/permission-settings.tsx
@@ -139,40 +139,18 @@ export default function PermissionSettings({
groupId: string,
checked: boolean,
) => {
- const group = viewerGroups?.find((g) => g.id === groupId);
- if (!group) return;
-
- // If disabling view, also disable download in single API call
- if (!checked && (group.defaultCanDownload ?? false)) {
- await updateGroupPermissions(groupId, {
- defaultCanView: checked,
- defaultCanDownload: false,
- });
- } else {
- await updateGroupPermissions(groupId, {
- defaultCanView: checked,
- });
- }
+ await updateGroupPermissions(groupId, {
+ defaultCanView: checked,
+ });
};
const handleDownloadPermissionChange = async (
groupId: string,
checked: boolean,
) => {
- const group = viewerGroups?.find((g) => g.id === groupId);
- if (!group) return;
-
- // If enabling download, also enable view in single API call
- if (checked && !(group.defaultCanView ?? false)) {
- await updateGroupPermissions(groupId, {
- defaultCanView: true,
- defaultCanDownload: checked,
- });
- } else {
- await updateGroupPermissions(groupId, {
- defaultCanDownload: checked,
- });
- }
+ await updateGroupPermissions(groupId, {
+ defaultCanDownload: checked,
+ });
};
const currentStrategy =
@@ -182,7 +160,7 @@ export default function PermissionSettings({
return (
<Card>
<CardHeader>
- <CardTitle>Permission Settings</CardTitle>
+ <CardTitle>Group Default Permissions</CardTitle>
<CardDescription>
Configure how group permissions are handled for new documents.
</CardDescription>
diff --git a/components/datarooms/settings/settings-tabs.tsx b/components/datarooms/settings/settings-tabs.tsx
index 3a6cc954..dd43531c 100644
--- a/components/datarooms/settings/settings-tabs.tsx
+++ b/components/datarooms/settings/settings-tabs.tsx
@@ -1,7 +1,7 @@
import Link from "next/link";
import { useRouter } from "next/router";
-import { BellIcon, CogIcon, ShieldIcon } from "lucide-react";
+import { BellIcon, CogIcon, LinkIcon, ShieldIcon } from "lucide-react";
import { cn } from "@/lib/utils";
interface SettingsTabsProps {
@@ -38,6 +38,18 @@ export default function SettingsTabs({ dataroomId }: SettingsTabsProps) {
<BellIcon className="h-4 w-4" />
Notifications
</Link>
+ <Link
+ href={`/datarooms/${dataroomId}/settings/link-permission`}
+ className={cn(
+ "flex items-center gap-x-2 rounded-md p-2 text-primary hover:bg-muted",
+ {
+ "bg-muted font-medium": router.pathname.includes("link-permission"),
+ },
+ )}
+ >
+ <LinkIcon className="h-4 w-4" />
+ Link Permission
+ </Link>
<Link
href={`/datarooms/${dataroomId}/settings/permissions`}
className={cn(
@@ -48,8 +60,8 @@ export default function SettingsTabs({ dataroomId }: SettingsTabsProps) {
)}
>
<ShieldIcon className="h-4 w-4" />
- Permissions
+ Group Permissions
</Link>
</nav>
);
-}
+}
\ No newline at end of file
diff --git a/components/documents/add-document-modal.tsx b/components/documents/add-document-modal.tsx
index bf0ce2a8..eea7f2ce 100644
--- a/components/documents/add-document-modal.tsx
+++ b/components/documents/add-document-modal.tsx
@@ -1,20 +1,14 @@
import Link from "next/link";
import { useRouter } from "next/router";
-
-
import { FormEvent, useEffect, useState } from "react";
-
-
import { useTeam } from "@/context/team-context";
import { PlanEnum } from "@/ee/stripe/constants";
import { parsePageId } from "notion-utils";
import { toast } from "sonner";
import { mutate } from "swr";
-
-
import { useAnalytics } from "@/lib/analytics";
import {
DocumentData,
@@ -91,8 +85,12 @@ export function AddDocumentModal({
const { dataroom } = useDataroom();
const teamId = teamInfo?.currentTeam?.id as string;
- const { applyDefaultPermissions, inheritParentPermissions } =
- useDataroomPermissions();
+ const {
+ applyDefaultPermissions,
+ inheritParentPermissions,
+ applyDefaultPermissionGroupPermissions,
+ inheritParentPermissionGroupPermissions,
+ } = useDataroomPermissions();
useEffect(() => {
if (openModal) setIsOpen(openModal);
@@ -242,10 +240,16 @@ export function AddDocumentModal({
if (dataroomResponse?.ok) {
const dataroomDocument =
(await dataroomResponse.json()) as DataroomDocument & {
- dataroom: { _count: { viewerGroups: number } };
+ dataroom: {
+ _count: { viewerGroups: number; permissionGroups: number };
+ };
};
- if (dataroomDocument.dataroom._count.viewerGroups > 0) {
+ const hasViewerGroups =
+ dataroomDocument.dataroom._count.viewerGroups > 0;
+ const hasPermissionGroups =
+ dataroomDocument.dataroom._count.permissionGroups > 0;
+ if (hasViewerGroups) {
const defaultPermission =
dataroom?.defaultGroupPermission || "ask_every_time";
@@ -272,17 +276,20 @@ export function AddDocumentModal({
]);
} else {
try {
- const result = await inheritParentPermissions(
- dataroomId,
- [document.id],
- currentFolderPath?.join("/"),
- );
- if (!result.success) {
- console.error(
- "Failed to inherit parent permissions:",
- result.error,
+ if (hasViewerGroups) {
+ const result = await inheritParentPermissions(
+ dataroomId,
+ [document.id],
+ currentFolderPath?.join("/"),
);
- toastErrorMessage();
+
+ if (!result.success) {
+ console.error(
+ "Failed to inherit parent permissions:",
+ result.error,
+ );
+ toastErrorMessage();
+ }
}
} catch (error) {
console.error(
@@ -294,20 +301,100 @@ export function AddDocumentModal({
}
} else if (defaultPermission === "use_default_permissions") {
try {
- const result = await applyDefaultPermissions(dataroomId, [
- document.id,
- ]);
+ if (hasViewerGroups) {
+ const result = await applyDefaultPermissions(dataroomId, [
+ document.id,
+ ]);
+ if (!result.success) {
+ console.error(
+ "Failed to apply default permissions:",
+ result.error,
+ );
+ toastErrorMessage();
+ }
+ }
+ } catch (error) {
+ console.error("Failed to apply default permissions:", error);
+ toastErrorMessage();
+ }
+ }
+ }
+
+ if (hasPermissionGroups) {
+ const linkPermissionStrategy =
+ dataroom?.defaultLinkPermission || "inherit_from_parent";
+
+ if (linkPermissionStrategy === "inherit_from_parent") {
+ try {
+ const result = await inheritParentPermissionGroupPermissions(
+ dataroomId,
+ [document.id],
+ currentFolderPath?.join("/"),
+ );
if (!result.success) {
- toastErrorMessage();
console.error(
- "Failed to apply default permissions:",
+ "Failed to inherit parent PermissionGroup permissions:",
result.error,
);
+ toastErrorMessage();
}
} catch (error) {
- console.error("Failed to apply default permissions:", error);
+ console.error(
+ "Failed to inherit parent PermissionGroup permissions:",
+ error,
+ );
toastErrorMessage();
}
+ } else if (
+ linkPermissionStrategy === "use_default_permissions" ||
+ linkPermissionStrategy === "use_simple_permissions"
+ ) {
+ const isRootLevel =
+ !currentFolderPath || currentFolderPath.length === 0;
+
+ if (isRootLevel) {
+ try {
+ const result = await applyDefaultPermissionGroupPermissions(
+ dataroomId,
+ [document.id],
+ );
+ if (!result.success) {
+ console.error(
+ "Failed to apply default PermissionGroup permissions:",
+ result.error,
+ );
+ toastErrorMessage();
+ }
+ } catch (error) {
+ console.error(
+ "Failed to apply default PermissionGroup permissions:",
+ error,
+ );
+ toastErrorMessage();
+ }
+ } else {
+ try {
+ const result =
+ await inheritParentPermissionGroupPermissions(
+ dataroomId,
+ [document.id],
+ currentFolderPath?.join("/"),
+ );
+ if (!result.success) {
+ console.error(
+ "Failed to inherit parent PermissionGroup permissions:",
+ result.error,
+ );
+ toastErrorMessage();
+ }
+ } catch (error) {
+ console.error(
+ "Failed to inherit parent PermissionGroup permissions:",
+ error,
+ );
+ toastErrorMessage();
+ }
+ }
}
}
}
@@ -452,10 +539,18 @@ export function AddDocumentModal({
if (dataroomResponse?.ok) {
const dataroomDocument =
(await dataroomResponse.json()) as DataroomDocument & {
- dataroom: { _count: { viewerGroups: number } };
+ dataroom: {
+ _count: { viewerGroups: number; permissionGroups: number };
+ };
};
- if (dataroomDocument.dataroom._count.viewerGroups > 0) {
+ const hasViewerGroups =
+ dataroomDocument.dataroom._count.viewerGroups > 0;
+ const hasPermissionGroups =
+ dataroomDocument.dataroom._count.permissionGroups > 0;
+
+ // Handle ViewerGroup permissions
+ if (hasViewerGroups) {
const defaultPermission =
dataroom?.defaultGroupPermission || "ask_every_time";
@@ -483,38 +578,122 @@ export function AddDocumentModal({
} else {
// For subfolder uploads, inherit permissions from parent folder automatically
try {
- const result = await inheritParentPermissions(
+ if (hasViewerGroups) {
+ const result = await inheritParentPermissions(
+ dataroomId,
+ [document.id],
+ currentFolderPath?.join("/"),
+ );
+
+ if (!result.success) {
+ console.error(
+ "Failed to inherit parent permissions:",
+ result.error,
+ );
+ toastErrorMessage();
+ }
+ }
+ } catch (error) {
+ console.error("Failed to inherit parent permissions:", error);
+ toastErrorMessage();
+ }
+ }
+ } else if (defaultPermission === "use_default_permissions") {
+ try {
+ if (hasViewerGroups) {
+ const result = await applyDefaultPermissions(dataroomId, [
+ document.id,
+ ]);
+ if (!result.success) {
+ console.error(
+ "Failed to apply default permissions:",
+ result.error,
+ );
+ toastErrorMessage();
+ }
+ }
+ } catch (error) {
+ console.error("Failed to apply default permissions:", error);
+ toastErrorMessage();
+ }
+ }
+
+ // Handle PermissionGroup permissions based on defaultLinkPermission
+ if (hasPermissionGroups) {
+ const linkPermissionStrategy =
+ dataroom?.defaultLinkPermission || "inherit_from_parent";
+
+ if (linkPermissionStrategy === "inherit_from_parent") {
+ try {
+ const result = await inheritParentPermissionGroupPermissions(
dataroomId,
[document.id],
currentFolderPath?.join("/"),
);
if (!result.success) {
- toastErrorMessage();
console.error(
- "Failed to inherit parent permissions:",
+ "Failed to inherit parent PermissionGroup permissions:",
result.error,
);
+ toastErrorMessage();
}
} catch (error) {
- console.error("Failed to inherit parent permissions:", error);
- toastErrorMessage();
- }
- }
- } else if (defaultPermission === "use_default_permissions") {
- try {
- const result = await applyDefaultPermissions(dataroomId, [
- document.id,
- ]);
- if (!result.success) {
console.error(
- "Failed to apply default permissions:",
- result.error,
+ "Failed to inherit parent PermissionGroup permissions:",
+ error,
);
toastErrorMessage();
}
- } catch (error) {
- console.error("Failed to apply default permissions:", error);
- toastErrorMessage();
+ } else if (
+ linkPermissionStrategy === "use_default_permissions" ||
+ linkPermissionStrategy === "use_simple_permissions"
+ ) {
+ const isRootLevel =
+ !currentFolderPath || currentFolderPath.length === 0;
+
+ if (isRootLevel) {
+ try {
+ const result = await applyDefaultPermissionGroupPermissions(
+ dataroomId,
+ [document.id],
+ );
+ if (!result.success) {
+ console.error(
+ "Failed to apply default PermissionGroup permissions:",
+ result.error,
+ );
+ toastErrorMessage();
+ }
+ } catch (error) {
+ console.error(
+ "Failed to apply default PermissionGroup permissions:",
+ error,
+ );
+ toastErrorMessage();
+ }
+ } else {
+ try {
+ const result =
+ await inheritParentPermissionGroupPermissions(
+ dataroomId,
+ [document.id],
+ currentFolderPath?.join("/"),
+ );
+ if (!result.success) {
+ console.error(
+ "Failed to inherit parent PermissionGroup permissions:",
+ result.error,
+ );
+ toastErrorMessage();
+ }
+ } catch (error) {
+ console.error(
+ "Failed to inherit parent PermissionGroup permissions:",
+ error,
+ );
+ toastErrorMessage();
+ }
+ }
}
}
}
@@ -767,4 +946,4 @@ export function AddDocumentModal({
)}
</>
);
-}
\ No newline at end of file
+}
diff --git a/lib/hooks/use-dataroom-permissions.ts b/lib/hooks/use-dataroom-permissions.ts
index 105e63c8..bdf5d424 100644
--- a/lib/hooks/use-dataroom-permissions.ts
+++ b/lib/hooks/use-dataroom-permissions.ts
@@ -94,8 +94,100 @@ export const useDataroomPermissions = () => {
}
};
+ const applyDefaultPermissionGroupPermissions = async (
+ dataroomId: string,
+ documentIds: string[],
+ ): Promise<{ success: boolean; error?: string }> => {
+ if (!teamId) {
+ return { success: false, error: "Team ID not available" };
+ }
+
+ if (!documentIds || documentIds.length === 0) {
+ return { success: false, error: "No document IDs provided" };
+ }
+
+ try {
+ const response = await fetch(
+ `/api/teams/${encodeURIComponent(teamId)}/datarooms/${encodeURIComponent(dataroomId)}/permission-groups/apply-default-permissions`,
+ {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ documentIds,
+ }),
+ },
+ );
+
+ if (!response.ok) {
+ const errorData = await response.json().catch(() => ({}));
+ return {
+ success: false,
+ error: errorData.message || `HTTP ${response.status}`
+ };
+ }
+
+ return { success: true };
+ } catch (error) {
+ console.error("Failed to apply default permission group permissions:", error);
+ return {
+ success: false,
+ error: error instanceof Error ? error.message : "Unknown error"
+ };
+ }
+ };
+
+ const inheritParentPermissionGroupPermissions = async (
+ dataroomId: string,
+ documentIds: string[],
+ folderPath?: string,
+ ): Promise<{ success: boolean; error?: string }> => {
+ if (!teamId) {
+ return { success: false, error: "Team ID not available" };
+ }
+
+ if (!documentIds || documentIds.length === 0) {
+ return { success: false, error: "No document IDs provided" };
+ }
+
+ try {
+ const response = await fetch(
+ `/api/teams/${encodeURIComponent(teamId)}/datarooms/${encodeURIComponent(dataroomId)}/permission-groups/inherit-parent-permissions`,
+ {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ documentIds,
+ folderPath,
+ }),
+ },
+ );
+
+ if (!response.ok) {
+ const errorData = await response.json().catch(() => ({}));
+ return {
+ success: false,
+ error: errorData.message || `HTTP ${response.status}`
+ };
+ }
+
+ return { success: true };
+ } catch (error) {
+ console.error("Failed to inherit parent permission group permissions:", error);
+ return {
+ success: false,
+ error: error instanceof Error ? error.message : "Unknown error"
+ };
+ }
+ };
+
return {
applyDefaultPermissions,
- inheritParentPermissions
+ inheritParentPermissions,
+ applyDefaultPermissionGroupPermissions,
+ inheritParentPermissionGroupPermissions
};
};
\ No newline at end of file
diff --git a/lib/swr/use-dataroom-permission-groups.ts b/lib/swr/use-dataroom-permission-groups.ts
new file mode 100644
index 00000000..7ea7a1db
--- /dev/null
+++ b/lib/swr/use-dataroom-permission-groups.ts
@@ -0,0 +1,49 @@
+import { useRouter } from "next/router";
+
+import { useTeam } from "@/context/team-context";
+import { PermissionGroup, PermissionGroupAccessControls } from "@prisma/client";
+import useSWR from "swr";
+
+import { fetcher } from "@/lib/utils";
+
+export default function useDataroomPermissionGroups() {
+ const teamInfo = useTeam();
+ const router = useRouter();
+
+ const isDataroom = router.pathname.includes("datarooms");
+ const { id } = router.query as {
+ id: string;
+ };
+
+ type PermissionGroupWithCount = PermissionGroup & {
+ accessControls: PermissionGroupAccessControls[];
+ links: {
+ id: string;
+ name: string | null;
+ }[];
+ _count: {
+ links: number;
+ accessControls: number;
+ };
+ };
+
+ const {
+ data: permissionGroups,
+ error,
+ mutate,
+ } = useSWR<PermissionGroupWithCount[]>(
+ teamInfo?.currentTeam?.id &&
+ id &&
+ isDataroom &&
+ `/api/teams/${teamInfo?.currentTeam?.id}/datarooms/${id}/permission-groups`,
+ fetcher,
+ { dedupingInterval: 30000 },
+ );
+
+ return {
+ permissionGroups,
+ loading: !permissionGroups && !error,
+ error,
+ mutate,
+ };
+}
\ No newline at end of file
diff --git a/lib/swr/use-dataroom.ts b/lib/swr/use-dataroom.ts
index 79eddf18..4772e6da 100644
--- a/lib/swr/use-dataroom.ts
+++ b/lib/swr/use-dataroom.ts
@@ -27,7 +27,7 @@ export function useDataroom() {
const teamInfo = useTeam();
const teamId = teamInfo?.currentTeam?.id;
- const { data: dataroom, error } = useSWR<Dataroom>(
+ const { data: dataroom, error } = useSWR<Dataroom & { _count?: { viewerGroups: number; permissionGroups: number } }>(
teamId && id && `/api/teams/${teamId}/datarooms/${id}`,
fetcher,
{
diff --git a/pages/api/teams/[teamId]/datarooms/[id]/documents/index.ts b/pages/api/teams/[teamId]/datarooms/[id]/documents/index.ts
index a35199f1..9d57c698 100644
--- a/pages/api/teams/[teamId]/datarooms/[id]/documents/index.ts
+++ b/pages/api/teams/[teamId]/datarooms/[id]/documents/index.ts
@@ -160,7 +160,7 @@ export default async function handle(
orderBy: { createdAt: "desc" },
take: 1,
},
- _count: { select: { viewerGroups: true } },
+ _count: { select: { viewerGroups: true, permissionGroups: true } },
},
},
},
diff --git a/pages/api/teams/[teamId]/datarooms/[id]/folders/index.ts b/pages/api/teams/[teamId]/datarooms/[id]/folders/index.ts
index 79d29e5b..eebb2048 100644
--- a/pages/api/teams/[teamId]/datarooms/[id]/folders/index.ts
+++ b/pages/api/teams/[teamId]/datarooms/[id]/folders/index.ts
@@ -1,12 +1,138 @@
import { NextApiRequest, NextApiResponse } from "next";
import { authOptions } from "@/pages/api/auth/[...nextauth]";
+import { ItemType } from "@prisma/client";
import slugify from "@sindresorhus/slugify";
import { getServerSession } from "next-auth/next";
import prisma from "@/lib/prisma";
import { CustomUser } from "@/lib/types";
+async function applyFolderPermissions(
+ dataroomId: string,
+ folderId: string,
+ folderPath: string,
+) {
+ try {
+ await applyDefaultFolderPermissions(dataroomId, folderId);
+ } catch (error) {
+ console.error("Error applying folder permissions:", error);
+ }
+}
+
+
+
+async function applyDefaultFolderPermissions(
+ dataroomId: string,
+ folderId: string,
+) {
+ const [dataroom, viewerGroups, permissionGroups] = await Promise.all([
+ prisma.dataroom.findUnique({
+ where: { id: dataroomId },
+ select: {
+ defaultLinkPermission: true,
+ defaultLinkCanView: true,
+ defaultLinkCanDownload: true,
+ teamId: true,
+ },
+ }),
+ prisma.viewerGroup.findMany({
+ where: { dataroomId },
+ select: {
+ id: true,
+ defaultCanView: true,
+ defaultCanDownload: true,
+ },
+ }),
+ prisma.permissionGroup.findMany({
+ where: { dataroomId },
+ select: {
+ id: true,
+ name: true,
+ defaultCanView: true,
+ defaultCanDownload: true,
+ },
+ }),
+ ]);
+
+ if (!dataroom) return;
+
+
+ const allPermissionGroupData: {
+ groupId: string;
+ itemId: string;
+ itemType: ItemType;
+ canView: boolean;
+ canDownload: boolean;
+ canDownloadOriginal: boolean;
+ }[] = [];
+
+ if (permissionGroups.length > 0) {
+ if (dataroom.defaultLinkPermission === "inherit_from_parent") {
+ permissionGroups.forEach(group => {
+ allPermissionGroupData.push({
+ groupId: group.id,
+ itemId: folderId,
+ itemType: ItemType.DATAROOM_FOLDER,
+ canView: true,
+ canDownload: false,
+ canDownloadOriginal: false,
+ });
+ });
+ } else if (dataroom.defaultLinkPermission === "use_simple_permissions") {
+ const globalCanView = dataroom.defaultLinkCanView ?? false;
+ const globalCanDownload = dataroom.defaultLinkCanDownload ?? false;
+
+ if (globalCanView || globalCanDownload) {
+ permissionGroups.forEach(group => {
+ allPermissionGroupData.push({
+ groupId: group.id,
+ itemId: folderId,
+ itemType: ItemType.DATAROOM_FOLDER,
+ canView: globalCanView || globalCanDownload,
+ canDownload: globalCanDownload,
+ canDownloadOriginal: false,
+ });
+ });
+ }
+ } else {
+ permissionGroups
+ .filter(group => group.defaultCanView || group.defaultCanDownload)
+ .forEach(group => {
+ const canDownload = group.defaultCanDownload ?? false;
+ const canView = group.defaultCanView ?? false;
+
+ allPermissionGroupData.push({
+ groupId: group.id,
+ itemId: folderId,
+ itemType: ItemType.DATAROOM_FOLDER,
+ canView: canView || canDownload,
+ canDownload: canDownload,
+ canDownloadOriginal: false,
+ });
+ });
+ }
+ }
+ await Promise.all([
+ viewerGroups.length > 0 && prisma.viewerGroupAccessControls.createMany({
+ data: viewerGroups
+ .filter(group => group.defaultCanView || group.defaultCanDownload)
+ .map(group => ({
+ groupId: group.id,
+ itemId: folderId,
+ itemType: ItemType.DATAROOM_FOLDER,
+ canView: group.defaultCanView ?? false,
+ canDownload: group.defaultCanDownload ?? false,
+ })),
+ skipDuplicates: true,
+ }),
+ allPermissionGroupData.length > 0 && prisma.permissionGroupAccessControls.createMany({
+ data: allPermissionGroupData,
+ skipDuplicates: true,
+ }),
+ ]);
+}
+
export default async function handle(
req: NextApiRequest,
res: NextApiResponse,
@@ -285,6 +411,8 @@ export default async function handle(
},
});
+ await applyFolderPermissions(dataroomId, folder.id, childFolderPath);
+
const folderWithDocs = {
...folder,
documents: [],
diff --git a/pages/api/teams/[teamId]/datarooms/[id]/index.ts b/pages/api/teams/[teamId]/datarooms/[id]/index.ts
index bc2b7174..26526428 100644
--- a/pages/api/teams/[teamId]/datarooms/[id]/index.ts
+++ b/pages/api/teams/[teamId]/datarooms/[id]/index.ts
@@ -7,7 +7,7 @@ import { errorhandler } from "@/lib/errorHandler";
import { getFeatureFlags } from "@/lib/featureFlags";
import prisma from "@/lib/prisma";
import { CustomUser } from "@/lib/types";
-import { DefaultGroupPermissionStrategy } from "@prisma/client";
+import { DefaultGroupPermissionStrategy, DefaultLinkPermissionStrategy } from "@prisma/client";
export default async function handle(
req: NextApiRequest,
@@ -49,6 +49,9 @@ export default async function handle(
id: dataroomId,
teamId,
},
+ include: {
+ _count: { select: { viewerGroups: true, permissionGroups: true } },
+ },
});
if (!dataroom) {
@@ -97,10 +100,13 @@ export default async function handle(
return res.status(401).end("Unauthorized");
}
- const { name, enableChangeNotifications, defaultGroupPermission } = req.body as {
+ const { name, enableChangeNotifications, defaultGroupPermission, defaultLinkPermission, defaultLinkCanView, defaultLinkCanDownload } = req.body as {
name?: string;
enableChangeNotifications?: boolean;
defaultGroupPermission?: DefaultGroupPermissionStrategy;
+ defaultLinkPermission?: DefaultLinkPermissionStrategy;
+ defaultLinkCanView?: boolean;
+ defaultLinkCanDownload?: boolean;
};
const featureFlags = await getFeatureFlags({ teamId: team.id });
@@ -126,6 +132,9 @@ export default async function handle(
enableChangeNotifications,
}),
...(defaultGroupPermission && { defaultGroupPermission }),
+ ...(defaultLinkPermission && { defaultLinkPermission }),
+ ...(typeof defaultLinkCanView === "boolean" && { defaultLinkCanView }),
+ ...(typeof defaultLinkCanDownload === "boolean" && { defaultLinkCanDownload }),
},
});
diff --git a/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/[permissionGroupId].ts b/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/[permissionGroupId].ts
index 1e0fb387..cc479633 100644
--- a/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/[permissionGroupId].ts
+++ b/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/[permissionGroupId].ts
@@ -18,6 +18,13 @@ const itemPermissionSchema = z.object({
const permissionsSchema = z.record(z.string(), itemPermissionSchema);
+const patchPermissionGroupSchema = z.object({
+ name: z.string().optional(),
+ description: z.string().nullable().optional(),
+ defaultCanView: z.boolean().optional(),
+ defaultCanDownload: z.boolean().optional(),
+});
+
export default async function handle(
req: NextApiRequest,
res: NextApiResponse,
@@ -303,6 +310,88 @@ export default async function handle(
});
});
+ return res.status(200).json({ permissionGroup: updatedPermissionGroup });
+ } catch (error) {
+ errorhandler(error, res);
+ }
+ } else if (req.method === "PATCH") {
+ // PATCH /api/teams/:teamId/datarooms/:id/permission-groups/:permissionGroupId
+ const session = await getServerSession(req, res, authOptions);
+ if (!session) {
+ return res.status(401).end("Unauthorized");
+ }
+
+ const {
+ teamId,
+ id: dataroomId,
+ permissionGroupId,
+ } = req.query as {
+ teamId: string;
+ id: string;
+ permissionGroupId: string;
+ };
+
+ const userId = (session.user as CustomUser).id;
+
+ try {
+ const team = await prisma.team.findUnique({
+ where: {
+ id: teamId,
+ users: {
+ some: { userId },
+ },
+ },
+ });
+
+ if (!team) {
+ return res.status(401).end("Unauthorized");
+ }
+
+ const dataroom = await prisma.dataroom.findUnique({
+ where: {
+ id: dataroomId,
+ teamId: teamId,
+ },
+ });
+
+ if (!dataroom) {
+ return res.status(404).json({ error: "Dataroom not found" });
+ }
+
+ const permissionGroup = await prisma.permissionGroup.findUnique({
+ where: {
+ id: permissionGroupId,
+ dataroomId: dataroomId,
+ teamId: teamId,
+ },
+ });
+
+ if (!permissionGroup) {
+ return res.status(404).json({ error: "Permission group not found" });
+ }
+
+ const validationResult = patchPermissionGroupSchema.safeParse(req.body);
+
+ if (!validationResult.success) {
+ return res.status(400).json({
+ error: "Invalid request body",
+ details: validationResult.error.issues,
+ });
+ }
+
+ const dataToUpdate = validationResult.data;
+
+ if (Object.keys(dataToUpdate).length === 0) {
+ return res.status(400).json({ error: "No fields to update" });
+ }
+
+ const updatedPermissionGroup = await prisma.permissionGroup.update({
+ where: {
+ id: permissionGroupId,
+ },
+ data: dataToUpdate,
+ });
+
return res.status(200).json({ permissionGroup: updatedPermissionGroup });
} catch (error) {
errorhandler(error, res);
@@ -310,6 +399,6 @@ export default async function handle(
}
// We only allow GET requests
- res.setHeader("Allow", ["GET", "PUT"]);
+ res.setHeader("Allow", ["GET", "PUT", "PATCH"]);
return res.status(405).end(`Method ${req.method} Not Allowed`);
}
diff --git a/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/apply-default-permissions.ts b/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/apply-default-permissions.ts
new file mode 100644
index 00000000..e731ddc0
--- /dev/null
+++ b/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/apply-default-permissions.ts
@@ -0,0 +1,211 @@
+import { NextApiRequest, NextApiResponse } from "next";
+
+import { authOptions } from "@/pages/api/auth/[...nextauth]";
+import { DefaultGroupPermissionStrategy, ItemType } from "@prisma/client";
+import { getServerSession } from "next-auth/next";
+
+import { errorhandler } from "@/lib/errorHandler";
+import prisma from "@/lib/prisma";
+import { CustomUser } from "@/lib/types";
+
+export default async function handler(
+ req: NextApiRequest,
+ res: NextApiResponse,
+) {
+ if (req.method !== "POST") {
+ res.setHeader("Allow", ["POST"]);
+ return res.status(405).end(`Method ${req.method} Not Allowed`);
+ }
+
+ const session = await getServerSession(req, res, authOptions);
+ if (!session) {
+ return res.status(401).end("Unauthorized");
+ }
+
+ const { teamId, id: dataroomId } = req.query as {
+ teamId: string;
+ id: string;
+ };
+ const userId = (session.user as CustomUser).id;
+
+ try {
+ const { documentIds } = req.body as {
+ documentIds: string[];
+ };
+
+ if (!documentIds || !Array.isArray(documentIds) || documentIds.length === 0) {
+ return res.status(400).json({ message: "Document IDs are required" });
+ }
+
+ // Check if the user is part of the team
+ const team = await prisma.team.findFirst({
+ where: {
+ id: teamId,
+ users: {
+ some: {
+ userId,
+ },
+ },
+ },
+ });
+
+ if (!team) {
+ return res.status(403).json({ message: "Unauthorized" });
+ }
+
+ // Get dataroom and verify it exists and belongs to the team
+ const dataroom = await prisma.dataroom.findUnique({
+ where: {
+ id: dataroomId,
+ },
+ select: {
+ id: true,
+ teamId: true,
+ defaultGroupPermission: true,
+ defaultLinkPermission: true,
+ defaultLinkCanView: true,
+ defaultLinkCanDownload: true,
+ },
+ });
+
+ if (!dataroom || dataroom.teamId !== teamId) {
+ return res.status(404).json({ message: "Dataroom not found" });
+ }
+
+ // Check if dataroom is set to use default permissions for PermissionGroups
+ if (dataroom.defaultLinkPermission !== "use_default_permissions" && dataroom.defaultLinkPermission !== "use_simple_permissions") {
+ return res.status(400).json({
+ message: "Dataroom is not configured to use default permissions for PermissionGroups"
+ });
+ }
+
+ // Get all permission groups with their default permissions
+ const permissionGroups = await prisma.permissionGroup.findMany({
+ where: {
+ dataroomId,
+ },
+ select: {
+ id: true,
+ defaultCanView: true,
+ defaultCanDownload: true,
+ },
+ });
+
+ if (permissionGroups.length === 0) {
+ return res.status(200).json({
+ message: "No permission groups found, no permissions applied"
+ });
+ }
+
+ // Get dataroom document IDs for the provided document IDs
+ const dataroomDocuments = await prisma.dataroomDocument.findMany({
+ where: {
+ documentId: {
+ in: documentIds,
+ },
+ dataroomId,
+ },
+ select: {
+ id: true,
+ documentId: true,
+ },
+ });
+
+ if (dataroomDocuments.length === 0) {
+ return res.status(404).json({
+ message: "No documents found in this dataroom"
+ });
+ }
+
+ // Build permissions to create
+ const permissionsToCreate: {
+ groupId: string;
+ itemId: string;
+ itemType: ItemType;
+ canView: boolean;
+ canDownload: boolean;
+ canDownloadOriginal: boolean;
+ }[] = [];
+
+ if (dataroom.defaultLinkPermission === "use_simple_permissions") {
+ // For simple permissions, use global dataroom settings for all groups
+ const globalCanView = dataroom.defaultLinkCanView ?? false;
+ const globalCanDownload = dataroom.defaultLinkCanDownload ?? false;
+
+ if (globalCanView || globalCanDownload) {
+ permissionGroups.forEach((group) => {
+ dataroomDocuments.forEach((doc) => {
+ permissionsToCreate.push({
+ groupId: group.id,
+ itemId: doc.id,
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ // If download is enabled, automatically enable view
+ canView: globalCanView || globalCanDownload,
+ canDownload: globalCanDownload,
+ canDownloadOriginal: false,
+ });
+ });
+ });
+ }
+ } else {
+ // For other strategies, use individual group defaults
+ permissionGroups.forEach((group) => {
+ // Only create permissions if the group has view or download enabled
+ if (group.defaultCanView || group.defaultCanDownload) {
+ dataroomDocuments.forEach((doc) => {
+ const canDownload = group.defaultCanDownload ?? false;
+ const canView = group.defaultCanView ?? false;
+
+ permissionsToCreate.push({
+ groupId: group.id,
+ itemId: doc.id,
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ // If download is enabled, automatically enable view
+ canView: canView || canDownload,
+ canDownload: canDownload,
+ canDownloadOriginal: false,
+ });
+ });
+ }
+ });
+ }
+
+ if (permissionsToCreate.length === 0) {
+ return res.status(200).json({
+ message: "No default permissions configured, no permissions applied"
+ });
+ }
+
+ // Apply permissions in a transaction
+ await prisma.$transaction(async (tx) => {
+ // First, remove any existing permissions for these documents and groups
+ await tx.permissionGroupAccessControls.deleteMany({
+ where: {
+ itemId: {
+ in: dataroomDocuments.map(doc => doc.id),
+ },
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ groupId: {
+ in: permissionGroups.map(group => group.id),
+ },
+ },
+ });
+
+ await tx.permissionGroupAccessControls.createMany({
+ data: permissionsToCreate,
+ skipDuplicates: true,
+ });
+ });
+
+ res.status(200).json({
+ message: "Default permissions applied successfully",
+ appliedPermissions: permissionsToCreate.length,
+ documentsProcessed: dataroomDocuments.length,
+ groupsProcessed: permissionGroups.length,
+ });
+
+ } catch (error) {
+ console.error("Error applying default permissions:", error);
+ errorhandler(error, res);
+ }
+}
\ No newline at end of file
diff --git a/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/index.ts b/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/index.ts
index 8491630c..7cacb06d 100644
--- a/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/index.ts
+++ b/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/index.ts
@@ -13,7 +13,74 @@ export default async function handle(
req: NextApiRequest,
res: NextApiResponse,
) {
- if (req.method === "POST") {
+ if (req.method === "GET") {
+ // GET /api/teams/:teamId/datarooms/:id/permission-groups
+ const session = await getServerSession(req, res, authOptions);
+ if (!session) {
+ return res.status(401).end("Unauthorized");
+ }
+
+ const { teamId, id: dataroomId } = req.query as {
+ teamId: string;
+ id: string;
+ };
+
+ const userId = (session.user as CustomUser).id;
+
+ try {
+ const team = await prisma.team.findUnique({
+ where: {
+ id: teamId,
+ users: {
+ some: { userId },
+ },
+ },
+ });
+
+ if (!team) {
+ return res.status(401).end("Unauthorized");
+ }
+
+ const dataroom = await prisma.dataroom.findUnique({
+ where: {
+ id: dataroomId,
+ teamId: teamId,
+ },
+ });
+
+ if (!dataroom) {
+ return res.status(404).json({ error: "Dataroom not found" });
+ }
+
+ const permissionGroups = await prisma.permissionGroup.findMany({
+ where: {
+ dataroomId: dataroomId,
+ teamId: teamId,
+ },
+ orderBy: {
+ createdAt: "desc",
+ },
+ include: {
+ links: {
+ select: {
+ id: true,
+ name: true,
+ },
+ },
+ _count: {
+ select: {
+ links: true,
+ accessControls: true,
+ },
+ },
+ },
+ });
+
+ return res.status(200).json(permissionGroups);
+ } catch (error) {
+ errorhandler(error, res);
+ }
+ } else if (req.method === "POST") {
// POST /api/teams/:teamId/datarooms/:id/permission-groups
const session = await getServerSession(req, res, authOptions);
if (!session) {
@@ -120,7 +187,7 @@ export default async function handle(
}
}
- // We only allow POST requests
- res.setHeader("Allow", ["POST"]);
+ // We only allow GET and POST requests
+ res.setHeader("Allow", ["GET", "POST"]);
return res.status(405).end(`Method ${req.method} Not Allowed`);
}
diff --git a/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/inherit-parent-permissions.ts b/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/inherit-parent-permissions.ts
new file mode 100644
index 00000000..e30d0b9b
--- /dev/null
+++ b/pages/api/teams/[teamId]/datarooms/[id]/permission-groups/inherit-parent-permissions.ts
@@ -0,0 +1,418 @@
+import { NextApiRequest, NextApiResponse } from "next";
+
+import { authOptions } from "@/pages/api/auth/[...nextauth]";
+import { ItemType } from "@prisma/client";
+import { getServerSession } from "next-auth/next";
+
+import { errorhandler } from "@/lib/errorHandler";
+import prisma from "@/lib/prisma";
+import { CustomUser } from "@/lib/types";
+
+export default async function handler(
+ req: NextApiRequest,
+ res: NextApiResponse,
+) {
+ if (req.method !== "POST") {
+ res.setHeader("Allow", ["POST"]);
+ return res.status(405).end(`Method ${req.method} Not Allowed`);
+ }
+
+ const session = await getServerSession(req, res, authOptions);
+ if (!session) {
+ return res.status(401).end("Unauthorized");
+ }
+
+ const { teamId, id: dataroomId } = req.query as {
+ teamId: string;
+ id: string;
+ };
+ const userId = (session.user as CustomUser).id;
+
+ try {
+ const { documentIds, folderPath } = req.body as {
+ documentIds: string[];
+ folderPath: string;
+ };
+
+ if (!documentIds || !Array.isArray(documentIds) || documentIds.length === 0) {
+ return res.status(400).json({ message: "Document IDs are required" });
+ }
+
+ if (!folderPath) {
+ return res.status(400).json({ message: "Folder path is required" });
+ }
+
+ const team = await prisma.team.findFirst({
+ where: {
+ id: teamId,
+ users: {
+ some: {
+ userId,
+ },
+ },
+ },
+ });
+
+ if (!team) {
+ return res.status(403).json({ message: "Unauthorized" });
+ }
+
+ const dataroom = await prisma.dataroom.findUnique({
+ where: {
+ id: dataroomId,
+ },
+ select: {
+ id: true,
+ teamId: true,
+ defaultGroupPermission: true,
+ defaultLinkPermission: true,
+ defaultLinkCanView: true,
+ defaultLinkCanDownload: true,
+ },
+ });
+
+ if (!dataroom || dataroom.teamId !== teamId) {
+ return res.status(404).json({ message: "Dataroom not found" });
+ }
+
+ const permissionGroups = await prisma.permissionGroup.findMany({
+ where: {
+ dataroomId,
+ },
+ select: {
+ id: true,
+ },
+ });
+
+ if (permissionGroups.length === 0) {
+ return res.status(200).json({
+ message: "No permission groups found, no permissions applied"
+ });
+ }
+
+ const pathSegments = folderPath.split("/").filter(Boolean);
+ let parentFolder: { id: string } | null = null;
+ let parentPath: string;
+
+ if (pathSegments.length <= 1) {
+ // since there's no parent to inherit from
+ if (dataroom.defaultLinkPermission === "inherit_from_parent") {
+ const permissionsToCreate: {
+ groupId: string;
+ itemId: string;
+ itemType: ItemType;
+ canView: boolean;
+ canDownload: boolean;
+ canDownloadOriginal: boolean;
+ }[] = [];
+
+ // Get dataroom documents for the provided document IDs
+ const newDataroomDocuments = await prisma.dataroomDocument.findMany({
+ where: {
+ documentId: {
+ in: documentIds,
+ },
+ dataroomId,
+ },
+ select: {
+ id: true,
+ documentId: true,
+ },
+ });
+
+ if (newDataroomDocuments.length === 0) {
+ return res.status(404).json({
+ message: "No documents found in this dataroom"
+ });
+ }
+
+ // For root level with inherit_from_parent, use canView: true, canDownload: false
+ permissionGroups.forEach((group) => {
+ newDataroomDocuments.forEach((doc) => {
+ permissionsToCreate.push({
+ groupId: group.id,
+ itemId: doc.id,
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ canView: true,
+ canDownload: false,
+ canDownloadOriginal: false,
+ });
+ });
+ });
+
+ // Apply false permissions in a transaction
+ await prisma.$transaction(async (tx) => {
+ // First, remove any existing permissions for these documents and groups
+ await tx.permissionGroupAccessControls.deleteMany({
+ where: {
+ itemId: {
+ in: newDataroomDocuments.map(doc => doc.id),
+ },
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ groupId: {
+ in: permissionGroups.map(group => group.id),
+ },
+ },
+ });
+
+ // Then create the false permissions
+ await tx.permissionGroupAccessControls.createMany({
+ data: permissionsToCreate,
+ skipDuplicates: true,
+ });
+ });
+
+ return res.status(200).json({
+ message: "View-only permissions applied for root-level folder (inherit_from_parent strategy)",
+ appliedPermissions: permissionsToCreate.length,
+ documentsProcessed: newDataroomDocuments.length,
+ groupsProcessed: permissionGroups.length,
+ });
+ } else {
+ // For other strategies (use_default_permissions, use_simple_permissions), use default permissions
+ const permissionsToCreate: {
+ groupId: string;
+ itemId: string;
+ itemType: ItemType;
+ canView: boolean;
+ canDownload: boolean;
+ canDownloadOriginal: boolean;
+ }[] = [];
+
+ // Get dataroom documents for the provided document IDs
+ const newDataroomDocuments = await prisma.dataroomDocument.findMany({
+ where: {
+ documentId: {
+ in: documentIds,
+ },
+ dataroomId,
+ },
+ select: {
+ id: true,
+ documentId: true,
+ },
+ });
+
+ if (newDataroomDocuments.length === 0) {
+ return res.status(404).json({
+ message: "No documents found in this dataroom"
+ });
+ }
+
+ // Get permission groups with their default permissions
+ const permissionGroupsWithDefaults = await prisma.permissionGroup.findMany({
+ where: {
+ dataroomId,
+ },
+ select: {
+ id: true,
+ defaultCanView: true,
+ defaultCanDownload: true,
+ },
+ });
+
+ // Build permissions using appropriate strategy for root-level folder
+ if (dataroom.defaultLinkPermission === "use_simple_permissions") {
+ // For simple permissions, use global dataroom settings for all groups
+ const globalCanView = dataroom.defaultLinkCanView ?? false;
+ const globalCanDownload = dataroom.defaultLinkCanDownload ?? false;
+
+ if (globalCanView || globalCanDownload) {
+ permissionGroupsWithDefaults.forEach((group) => {
+ newDataroomDocuments.forEach((doc) => {
+ permissionsToCreate.push({
+ groupId: group.id,
+ itemId: doc.id,
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ // If download is enabled, automatically enable view
+ canView: globalCanView || globalCanDownload,
+ canDownload: globalCanDownload,
+ canDownloadOriginal: false,
+ });
+ });
+ });
+ }
+ } else {
+ // For other strategies, use individual group defaults
+ permissionGroupsWithDefaults.forEach((group) => {
+ newDataroomDocuments.forEach((doc) => {
+ const canDownload = group.defaultCanDownload ?? false;
+ const canView = group.defaultCanView ?? false;
+
+ permissionsToCreate.push({
+ groupId: group.id,
+ itemId: doc.id,
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ // If download is enabled, automatically enable view
+ canView: canView || canDownload,
+ canDownload: canDownload,
+ canDownloadOriginal: false,
+ });
+ });
+ });
+ }
+
+ if (permissionsToCreate.length === 0) {
+ return res.status(200).json({
+ message: "No default permissions configured for permission groups"
+ });
+ }
+
+ // Apply default permissions in a transaction
+ await prisma.$transaction(async (tx) => {
+ // First, remove any existing permissions for these documents and groups
+ await tx.permissionGroupAccessControls.deleteMany({
+ where: {
+ itemId: {
+ in: newDataroomDocuments.map(doc => doc.id),
+ },
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ groupId: {
+ in: permissionGroupsWithDefaults.map(group => group.id),
+ },
+ },
+ });
+
+ // Then create the default permissions
+ await tx.permissionGroupAccessControls.createMany({
+ data: permissionsToCreate,
+ skipDuplicates: true,
+ });
+ });
+
+ return res.status(200).json({
+ message: "Default permissions applied for root-level folder",
+ appliedPermissions: permissionsToCreate.length,
+ documentsProcessed: newDataroomDocuments.length,
+ groupsProcessed: permissionGroupsWithDefaults.length,
+ });
+ }
+ }
+
+ // Get parent folder path for non-root folders
+ parentPath = "/" + pathSegments.slice(0, -1).join("/");
+
+ parentFolder = await prisma.dataroomFolder.findUnique({
+ where: {
+ dataroomId_path: {
+ dataroomId,
+ path: parentPath,
+ },
+ },
+ select: {
+ id: true,
+ },
+ });
+
+ if (!parentFolder) {
+ return res.status(404).json({
+ message: "Parent folder not found"
+ });
+ }
+
+ // Get dataroom documents for the provided document IDs
+ const newDataroomDocuments = await prisma.dataroomDocument.findMany({
+ where: {
+ documentId: {
+ in: documentIds,
+ },
+ dataroomId,
+ },
+ select: {
+ id: true,
+ documentId: true,
+ },
+ });
+
+ if (newDataroomDocuments.length === 0) {
+ return res.status(404).json({
+ message: "No documents found in this dataroom"
+ });
+ }
+
+ // Get all permissions for the parent folder
+ const parentFolderPermissions = await prisma.permissionGroupAccessControls.findMany({
+ where: {
+ itemId: parentFolder.id,
+ itemType: ItemType.DATAROOM_FOLDER,
+ groupId: {
+ in: permissionGroups.map(group => group.id),
+ },
+ },
+ select: {
+ groupId: true,
+ canView: true,
+ canDownload: true,
+ canDownloadOriginal: true,
+ },
+ });
+
+ if (parentFolderPermissions.length === 0) {
+ return res.status(200).json({
+ message: "Parent folder has no permissions to inherit."
+ });
+ }
+
+ // Build permissions to create for new documents
+ const permissionsToCreate: {
+ groupId: string;
+ itemId: string;
+ itemType: ItemType;
+ canView: boolean;
+ canDownload: boolean;
+ canDownloadOriginal: boolean;
+ }[] = [];
+
+ parentFolderPermissions.forEach((permission) => {
+ newDataroomDocuments.forEach((doc) => {
+ permissionsToCreate.push({
+ groupId: permission.groupId,
+ itemId: doc.id,
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ canView: permission.canView,
+ canDownload: permission.canDownload,
+ canDownloadOriginal: permission.canDownloadOriginal,
+ });
+ });
+ });
+
+ if (permissionsToCreate.length === 0) {
+ return res.status(200).json({
+ message: "No consistent permissions found to inherit"
+ });
+ }
+
+ // Apply inherited permissions in a transaction
+ await prisma.$transaction(async (tx) => {
+ // First, remove any existing permissions for these documents and groups
+ await tx.permissionGroupAccessControls.deleteMany({
+ where: {
+ itemId: {
+ in: newDataroomDocuments.map(doc => doc.id),
+ },
+ itemType: ItemType.DATAROOM_DOCUMENT,
+ groupId: {
+ in: permissionGroups.map(group => group.id),
+ },
+ },
+ });
+
+ // Then create the inherited permissions
+ await tx.permissionGroupAccessControls.createMany({
+ data: permissionsToCreate,
+ skipDuplicates: true,
+ });
+ });
+
+ res.status(200).json({
+ message: "Parent permissions inherited successfully",
+ appliedPermissions: permissionsToCreate.length,
+ documentsProcessed: newDataroomDocuments.length,
+ groupsProcessed: permissionGroups.length,
+ });
+
+ } catch (error) {
+ console.error("Error inheriting parent permissions:", error);
+ errorhandler(error, res);
+ }
+}
\ No newline at end of file
diff --git a/pages/datarooms/[id]/settings/link-permission.tsx b/pages/datarooms/[id]/settings/link-permission.tsx
new file mode 100644
index 00000000..9d2b4e2c
--- /dev/null
+++ b/pages/datarooms/[id]/settings/link-permission.tsx
@@ -0,0 +1,40 @@
+import { useDataroom } from "@/lib/swr/use-dataroom";
+
+import { DataroomHeader } from "@/components/datarooms/dataroom-header";
+import { DataroomNavigation } from "@/components/datarooms/dataroom-navigation";
+import LinkPermissionSettings from "@/components/datarooms/settings/link-permission-settings";
+import SettingsTabs from "@/components/datarooms/settings/settings-tabs";
+import AppLayout from "@/components/layouts/app";
+
+export default function LinkPermissionSettingsPage() {
+ const { dataroom } = useDataroom();
+
+ if (!dataroom) {
+ return <div>Loading...</div>;
+ }
+
+ return (
+ <AppLayout>
+ <main className="relative mx-2 mb-10 mt-4 space-y-8 overflow-hidden px-1 sm:mx-3 md:mx-5 md:mt-5 lg:mx-7 lg:mt-8 xl:mx-10">
+ <header>
+ <DataroomHeader
+ title={dataroom.name}
+ description={dataroom.pId}
+ actions={[]}
+ />
+
+ <DataroomNavigation dataroomId={dataroom.id} />
+ </header>
+ <div className="mx-auto grid w-full gap-2">
+ <h1 className="text-2xl font-semibold">Settings</h1>
+ </div>
+ <div className="mx-auto grid w-full items-start gap-6 md:grid-cols-[180px_1fr] lg:grid-cols-[250px_1fr]">
+ <SettingsTabs dataroomId={dataroom.id} />
+ <div className="grid gap-6">
+ <LinkPermissionSettings dataroomId={dataroom.id} />
+ </div>
+ </div>
+ </main>
+ </AppLayout>
+ );
+}
diff --git a/prisma/migrations/20250714235157_add_permissiongroup_defaults/migration.sql b/prisma/migrations/20250714235157_add_permissiongroup_defaults/migration.sql
new file mode 100644
index 00000000..1e75f184
--- /dev/null
+++ b/prisma/migrations/20250714235157_add_permissiongroup_defaults/migration.sql
@@ -0,0 +1,12 @@
+-- CreateEnum
+CREATE TYPE "DefaultLinkPermissionStrategy" AS ENUM ('inherit_from_parent', 'use_default_permissions', 'use_simple_permissions');
+
+-- AlterTable
+ALTER TABLE "Dataroom" ADD COLUMN "defaultLinkCanDownload" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN "defaultLinkCanView" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN "defaultLinkPermission" "DefaultLinkPermissionStrategy" NOT NULL DEFAULT 'inherit_from_parent',
+ALTER COLUMN "defaultGroupPermission" SET DEFAULT 'inherit_from_parent';
+
+-- AlterTable
+ALTER TABLE "PermissionGroup" ADD COLUMN "defaultCanDownload" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN "defaultCanView" BOOLEAN NOT NULL DEFAULT false;
diff --git a/prisma/schema/dataroom.prisma b/prisma/schema/dataroom.prisma
index 6f36f263..09cc3e3b 100644
--- a/prisma/schema/dataroom.prisma
+++ b/prisma/schema/dataroom.prisma
@@ -27,9 +27,13 @@ model Dataroom {
// notification settings
enableChangeNotifications Boolean @default(false)
-
+
// default group permission setting
- defaultGroupPermission DefaultGroupPermissionStrategy @default(ask_every_time)
+ defaultGroupPermission DefaultGroupPermissionStrategy @default(inherit_from_parent)
+ defaultLinkPermission DefaultLinkPermissionStrategy @default(inherit_from_parent)
+
+ defaultLinkCanView Boolean @default(false)
+ defaultLinkCanDownload Boolean @default(false)
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
@@ -167,18 +171,27 @@ enum DefaultGroupPermissionStrategy {
no_permissions
}
+enum DefaultLinkPermissionStrategy {
+ inherit_from_parent
+ use_default_permissions
+ use_simple_permissions
+}
+
model PermissionGroup {
- id String @id @default(cuid())
- name String
+ id String @id @default(cuid())
+ name String
description String?
- links Link[]
+ links Link[]
accessControls PermissionGroupAccessControls[]
+ defaultCanView Boolean @default(false)
+ defaultCanDownload Boolean @default(false)
+
dataroomId String
- dataroom Dataroom @relation(fields: [dataroomId], references: [id], onDelete: Cascade)
- teamId String
- team Team @relation(fields: [teamId], references: [id], onDelete: Cascade)
+ dataroom Dataroom @relation(fields: [dataroomId], references: [id], onDelete: Cascade)
+ teamId String
+ team Team @relation(fields: [teamId], references: [id], onDelete: Cascade)
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
@@ -188,17 +201,17 @@ model PermissionGroup {
}
model PermissionGroupAccessControls {
- id String @id @default(cuid())
+ id String @id @default(cuid())
groupId String
- group PermissionGroup @relation(fields: [groupId], references: [id], onDelete: Cascade)
+ group PermissionGroup @relation(fields: [groupId], references: [id], onDelete: Cascade)
// Access control for items (documents or dataroom items)
- itemId String // This can be a document ID or a dataroom item ID
+ itemId String // This can be a document ID or a dataroom item ID
itemType ItemType // Enum: DATAROOM_DOCUMENT, DATAROOM_FOLDER
// Granular permissions
- canView Boolean @default(true)
- canDownload Boolean @default(false)
+ canView Boolean @default(true)
+ canDownload Boolean @default(false)
canDownloadOriginal Boolean @default(false)
createdAt DateTime @default(now())
@@ -206,4 +219,4 @@ model PermissionGroupAccessControls {
@@unique([groupId, itemId])
@@index([groupId])
-}
\ No newline at end of file
+}