fix: wip

packages/lib/utils/organisations.ts

@@ -0,0 +1,119 @@
+import type { OrganisationGlobalSettings, Prisma } from '@prisma/client';
+import {
+  DocumentVisibility,
+  type OrganisationGroup,
+  type OrganisationMemberRole,
+} from '@prisma/client';
+
+import type { ORGANISATION_MEMBER_ROLE_MAP } from '../constants/organisations';
+import {
+  LOWEST_ORGANISATION_ROLE,
+  ORGANISATION_MEMBER_ROLE_HIERARCHY,
+  ORGANISATION_MEMBER_ROLE_PERMISSIONS_MAP,
+} from '../constants/organisations';
+
+/**
+ * Determines whether a team member can execute a given action.
+ *
+ * @param action The action the user is trying to execute.
+ * @param role The current role of the user.
+ * @returns Whether the user can execute the action.
+ */
+export const canExecuteOrganisationAction = (
+  action: keyof typeof ORGANISATION_MEMBER_ROLE_PERMISSIONS_MAP,
+  role: keyof typeof ORGANISATION_MEMBER_ROLE_MAP,
+) => {
+  return ORGANISATION_MEMBER_ROLE_PERMISSIONS_MAP[action].some((i) => i === role);
+};
+
+/**
+ * Compares the provided `currentUserRole` with the provided `roleToCheck` to determine
+ * whether the `currentUserRole` has permission to modify the `roleToCheck`.
+ *
+ * @param currentUserRole Role of the current user
+ * @param roleToCheck Role of another user to see if the current user can modify
+ * @returns True if the current user can modify the other user, false otherwise
+ */
+export const isOrganisationRoleWithinUserHierarchy = (
+  currentUserRole: keyof typeof ORGANISATION_MEMBER_ROLE_MAP,
+  roleToCheck: keyof typeof ORGANISATION_MEMBER_ROLE_MAP,
+) => {
+  return ORGANISATION_MEMBER_ROLE_HIERARCHY[currentUserRole].some((i) => i === roleToCheck);
+};
+
+export const getHighestOrganisationRoleInGroup = (
+  groups: Pick<OrganisationGroup, 'type' | 'organisationRole'>[],
+): OrganisationMemberRole => {
+  let highestOrganisationRole: OrganisationMemberRole = LOWEST_ORGANISATION_ROLE;
+
+  groups.forEach((group) => {
+    const currentRolePriority = ORGANISATION_MEMBER_ROLE_HIERARCHY[group.organisationRole].length;
+    const highestOrganisationRolePriority =
+      ORGANISATION_MEMBER_ROLE_HIERARCHY[highestOrganisationRole].length;
+
+    if (currentRolePriority > highestOrganisationRolePriority) {
+      highestOrganisationRole = group.organisationRole;
+    }
+  });
+
+  return highestOrganisationRole;
+};
+
+// Todo: orgs test
+export const buildOrganisationWhereQuery = (
+  organisationId: string | undefined,
+  userId: number,
+  roles?: OrganisationMemberRole[],
+): Prisma.OrganisationWhereInput => {
+  // Note: Not using inline ternary since typesafety breaks for some reason.
+  if (!roles) {
+    return {
+      id: organisationId,
+      members: {
+        some: {
+          userId,
+        },
+      },
+    };
+  }
+
+  return {
+    id: organisationId,
+    members: {
+      some: {
+        userId,
+        organisationGroupMembers: {
+          some: {
+            group: {
+              organisationRole: {
+                in: roles,
+              },
+            },
+          },
+        },
+      },
+    },
+  };
+};
+
+export const generateDefaultOrganisationSettings = (): Omit<
+  OrganisationGlobalSettings,
+  'id' | 'organisation'
+> => {
+  return {
+    documentVisibility: DocumentVisibility.EVERYONE,
+    documentLanguage: 'en',
+    includeSenderDetails: true,
+    includeSigningCertificate: true,
+
+    typedSignatureEnabled: true,
+    uploadSignatureEnabled: true,
+    drawSignatureEnabled: true,
+
+    brandingEnabled: false,
+    brandingLogo: '',
+    brandingUrl: '',
+    brandingCompanyDetails: '',
+    brandingHidePoweredBy: false,
+  };
+};

packages/lib/utils/team-global-settings-to-branding.ts

@@ -1,13 +1,30 @@
-import type { TeamGlobalSettings } from '@prisma/client';
+import type { OrganisationGlobalSettings } from '@prisma/client';
 
 import { NEXT_PUBLIC_WEBAPP_URL } from '../constants/app';
 
-export const teamGlobalSettingsToBranding = (teamGlobalSettings: TeamGlobalSettings) => {
+export const teamGlobalSettingsToBranding = (
+  settings: Omit<OrganisationGlobalSettings, 'id'>,
+  teamId: number,
+) => {
   return {
-    ...teamGlobalSettings,
+    ...settings,
     brandingLogo:
-      teamGlobalSettings.brandingEnabled && teamGlobalSettings.brandingLogo
-        ? `${NEXT_PUBLIC_WEBAPP_URL()}/api/branding/logo/team/${teamGlobalSettings.teamId}`
+      settings.brandingEnabled && settings.brandingLogo
+        ? `${NEXT_PUBLIC_WEBAPP_URL()}/api/branding/logo/team/${teamId}` // Todo: (orgs) Handle orgs
+        : '',
+  };
+};
+
+// Todo: (orgs) Handle orgs
+export const organisationGlobalSettingsToBranding = (
+  settings: Omit<OrganisationGlobalSettings, 'id'>,
+  organisationId: string,
+) => {
+  return {
+    ...settings,
+    brandingLogo:
+      settings.brandingEnabled && settings.brandingLogo
+        ? `${NEXT_PUBLIC_WEBAPP_URL()}/api/branding/logo/organisation/${organisationId}`
         : '',
   };
 };

packages/lib/utils/teams.ts

@@ -1,7 +1,16 @@
+import type { OrganisationGlobalSettings, Prisma, TeamGlobalSettings } from '@prisma/client';
+
+import type { TeamGroup } from '@documenso/prisma/generated/types';
+import type { TeamMemberRole } from '@documenso/prisma/generated/types';
+
 import { NEXT_PUBLIC_WEBAPP_URL } from '../constants/app';
 import { DocumentSignatureType } from '../constants/document';
 import type { TEAM_MEMBER_ROLE_MAP } from '../constants/teams';
-import { TEAM_MEMBER_ROLE_HIERARCHY, TEAM_MEMBER_ROLE_PERMISSIONS_MAP } from '../constants/teams';
+import {
+  LOWEST_TEAM_ROLE,
+  TEAM_MEMBER_ROLE_HIERARCHY,
+  TEAM_MEMBER_ROLE_PERMISSIONS_MAP,
+} from '../constants/teams';
 
 export const formatTeamUrl = (teamUrl: string, baseUrl?: string) => {
   const formattedBaseUrl = (baseUrl ?? NEXT_PUBLIC_WEBAPP_URL()).replace(/https?:\/\//, '');
@@ -46,11 +55,26 @@ export const isTeamRoleWithinUserHierarchy = (
   return TEAM_MEMBER_ROLE_HIERARCHY[currentUserRole].some((i) => i === roleToCheck);
 };
 
+export const getHighestTeamRoleInGroup = (groups: TeamGroup[]): TeamMemberRole => {
+  let highestTeamRole: TeamMemberRole = LOWEST_TEAM_ROLE;
+
+  groups.forEach((group) => {
+    const currentRolePriority = TEAM_MEMBER_ROLE_HIERARCHY[group.teamRole].length;
+    const highestTeamRolePriority = TEAM_MEMBER_ROLE_HIERARCHY[highestTeamRole].length;
+
+    if (currentRolePriority > highestTeamRolePriority) {
+      highestTeamRole = group.teamRole;
+    }
+  });
+
+  return highestTeamRole;
+};
+
 export const extractTeamSignatureSettings = (
   settings?: {
-    typedSignatureEnabled: boolean;
-    drawSignatureEnabled: boolean;
-    uploadSignatureEnabled: boolean;
+    typedSignatureEnabled: boolean | null;
+    drawSignatureEnabled: boolean | null;
+    uploadSignatureEnabled: boolean | null;
   } | null,
 ) => {
   if (!settings) {
@@ -73,3 +97,99 @@ export const extractTeamSignatureSettings = (
 
   return signatureTypes;
 };
+
+// Todo: orgs test
+export const buildTeamWhereQuery = (
+  teamId: number | undefined, // Todo: test if this is okay
+  userId: number,
+  roles?: TeamMemberRole[],
+): Prisma.TeamWhereUniqueInput => {
+  // Note: Not using inline ternary since typesafety breaks for some reason.
+  if (!roles) {
+    return {
+      id: teamId,
+      teamGroups: {
+        some: {
+          organisationGroup: {
+            organisation: {
+              members: {
+                some: {
+                  userId,
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+  }
+
+  return {
+    id: teamId,
+    teamGroups: {
+      some: {
+        organisationGroup: {
+          organisation: {
+            members: {
+              some: {
+                userId,
+              },
+            },
+          },
+        },
+        teamRole: {
+          in: roles,
+        },
+      },
+    },
+  };
+};
+
+/**
+ * Majority of these are null which lets us inherit from the organisation settings.
+ */
+export const generateDefaultTeamSettings = (): Omit<TeamGlobalSettings, 'id' | 'team'> => {
+  return {
+    documentVisibility: null,
+    documentLanguage: null,
+    includeSenderDetails: null,
+    includeSigningCertificate: null,
+
+    typedSignatureEnabled: null,
+    uploadSignatureEnabled: null,
+    drawSignatureEnabled: null,
+
+    brandingEnabled: null,
+    brandingLogo: null,
+    brandingUrl: null,
+    brandingCompanyDetails: null,
+    brandingHidePoweredBy: null,
+  };
+};
+
+/**
+ * Derive the final settings for a team.
+ *
+ * @param organisationSettings The organisation settings to inherit values from
+ * @param teamSettings The team settings which can override the organisation settings
+ */
+export const extractDerivedTeamSettings = (
+  organisationSettings: Omit<OrganisationGlobalSettings, 'id'>,
+  teamSettings: Omit<TeamGlobalSettings, 'id'>,
+): Omit<OrganisationGlobalSettings, 'id'> => {
+  const derivedSettings: Omit<OrganisationGlobalSettings, 'id'> = {
+    ...organisationSettings,
+  };
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  for (const key of Object.keys(derivedSettings) as (keyof typeof derivedSettings)[]) {
+    const teamValue = teamSettings[key];
+
+    if (teamValue !== null) {
+      // @ts-expect-error Should work
+      derivedSettings[key] = teamValue;
+    }
+  }
+
+  return derivedSettings;
+};