Ms2/signin merge users

src/management-system-v2/app/(auth)/signin/page.tsx

@@ -2,6 +2,9 @@ import { getProviders } from '@/app/api/auth/[...nextauth]/auth-options';
 import { getCurrentUser } from '@/components/auth';
 import { redirect } from 'next/navigation';
 import SignIn from './signin';
+import { generateGuestReferenceToken } from '@/lib/reference-guest-user-token';
+
+const dayInMS = 1000 * 60 * 60 * 24;
 
 // take in search query
 const SignInPage = async ({ searchParams }: { searchParams: { callbackUrl: string } }) => {
@@ -13,6 +16,11 @@ const SignInPage = async ({ searchParams }: { searchParams: { callbackUrl: strin
     redirect(callbackUrl);
   }
 
+  // NOTE: expiration should be the same as the expiration for sign in mails
+  const guestReferenceToken = isGuest
+    ? generateGuestReferenceToken({ guestId: session.user.id }, new Date(Date.now() + dayInMS))
+    : undefined;
+
   let providers = getProviders();
 
   providers = providers.filter((provider) => !isGuest || 'development-users' !== provider.id);
@@ -37,7 +45,9 @@ const SignInPage = async ({ searchParams }: { searchParams: { callbackUrl: strin
   if (!session) userType = 'none' as const;
   else userType = isGuest ? ('guest' as const) : ('user' as const);
 
-  return <SignIn providers={providers} userType={userType} />;
+  return (
+    <SignIn providers={providers} userType={userType} guestReferenceToken={guestReferenceToken} />
+  );
 };
 
 export default SignInPage;

src/management-system-v2/app/(auth)/signin/signin.tsx

@@ -58,9 +58,13 @@ const signInTitle = (
 const SignIn: FC<{
   providers: ExtractedProvider[];
   userType: 'guest' | 'user' | 'none';
-}> = ({ providers, userType }) => {
+  guestReferenceToken?: string;
+}> = ({ providers, userType, guestReferenceToken }) => {
   const searchParams = useSearchParams();
   const callbackUrl = searchParams.get('callbackUrl') ?? undefined;
+  const callbackUrlWithGuestRef = guestReferenceToken
+    ? `/transfer-processes?referenceToken=${guestReferenceToken}&callbackUrl=${callbackUrl}`
+    : callbackUrl;
   const authError = searchParams.get('error');
 
   const oauthProviders = providers.filter((provider) => provider.type === 'oauth');
@@ -150,7 +154,9 @@ const SignIn: FC<{
             if (provider.type === 'credentials') {
               return (
                 <Form
-                  onFinish={(values) => signIn(provider.id, { ...values, callbackUrl })}
+                  onFinish={(values) =>
+                    signIn(provider.id, { ...values, callbackUrl: callbackUrlWithGuestRef })
+                  }
                   key={provider.id}
                   layout="vertical"
                 >
@@ -168,7 +174,9 @@ const SignIn: FC<{
               return (
                 <>
                   <Form
-                    onFinish={(values) => signIn(provider.id, { ...values, callbackUrl })}
+                    onFinish={(values) =>
+                      signIn(provider.id, { ...values, callbackUrl: callbackUrlWithGuestRef })
+                    }
                     key={provider.id}
                     layout="vertical"
                   >
@@ -211,7 +219,7 @@ const SignIn: FC<{
                       style={{ width: '1.5rem', height: 'auto' }}
                     />
                   }
-                  onClick={() => signIn(provider.id, { callbackUrl })}
+                  onClick={() => signIn(provider.id, { callbackUrl: callbackUrlWithGuestRef })}
                 />
               </Tooltip>
             );

src/management-system-v2/app/(dashboard)/[environmentId]/processes/[processId]/page.tsx

@@ -1,4 +1,4 @@
-import { getCurrentEnvironment, getCurrentUser } from '@/components/auth';
+import { getCurrentEnvironment } from '@/components/auth';
 import Wrapper from './wrapper';
 import styles from './page.module.scss';
 import Modeler from './modeler';
@@ -18,11 +18,10 @@ const Process = async ({ params: { processId, environmentId }, searchParams }: P
   //console.log('processId', processId);
   //console.log('query', searchParams);
   const selectedVersionId = searchParams.version ? searchParams.version : undefined;
-  const { ability } = await getCurrentEnvironment(environmentId);
-  const { userId } = await getCurrentUser();
+  const { ability, activeEnvironment } = await getCurrentEnvironment(environmentId);
   // Only load bpmn if no version selected.
   const process = await getProcess(processId, !selectedVersionId);
-  const processes = await getProcesses(userId, ability, false);
+  const processes = await getProcesses(activeEnvironment.spaceId, ability, false);
 
   if (!ability.can('view', toCaslResource('Process', process))) {
     throw new Error('Forbidden.');
@@ -35,7 +34,7 @@ const Process = async ({ params: { processId, environmentId }, searchParams }: P
     ? process.versions.find((version) => version.id === selectedVersionId)
     : undefined;
 
-  // Since the user is able to minimize and close the page, everyting is in a
+  // Since the user is able to minimize and close the page, everything is in a
   // client component from here.
   return (
     <>

src/management-system-v2/app/api/auth/[...nextauth]/adapter.ts

@@ -29,7 +29,7 @@ const Adapter = {
     return getUserById(id);
   },
   updateUser: async (user: AuthenticatedUser) => {
-    return updateUser(user.id, user);
+    return updateUser(user.id, { ...user, isGuest: false });
   },
   getUserByEmail: async (email: string) => {
     return getUserByEmail(email) ?? null;

src/management-system-v2/app/api/auth/[...nextauth]/auth-options.ts

@@ -63,16 +63,25 @@ const nextAuthOptions: AuthOptions = {
 
       return session;
     },
-    signIn: async ({ account, user: _user }) => {
+    signIn: async ({ account, user: _user, email }) => {
       const session = await getServerSession(nextAuthOptions);
       const sessionUser = session?.user;
 
-      if (sessionUser?.isGuest && account?.provider !== 'guest-loguin') {
+      // Guest account signs in with proper auth
+      if (
+        sessionUser?.isGuest &&
+        account?.provider !== 'guest-signin' &&
+        !email?.verificationRequest
+      ) {
+        // Check if the user's cookie is correct
+        const sessionUserInDb = await getUserById(sessionUser.id);
+        if (!sessionUserInDb || !sessionUserInDb.isGuest) throw new Error('Something went wrong');
+
         const user = _user as Partial<AuthenticatedUser>;
-        const guestUser = await getUserById(sessionUser.id);
+        const userSigningIn = await getUserById(_user.id);
 
-        if (guestUser?.isGuest) {
-          updateUser(guestUser.id, {
+        if (!userSigningIn) {
+          await updateUser(sessionUser.id, {
             firstName: user.firstName ?? undefined,
             lastName: user.lastName ?? undefined,
             username: user.username ?? undefined,

src/management-system-v2/app/shared-viewer/page.tsx

@@ -54,7 +54,7 @@ const getProcessInfo = async (
     const { ability, activeEnvironment } = await getCurrentEnvironment(session?.user.id);
     ({ spaceId } = activeEnvironment);
     // get all the processes the user has access to
-    const ownedProcesses = await getProcesses(userId, ability);
+    const ownedProcesses = await getProcesses(spaceId, ability);
     // check if the current user is the owner of the process(/has access to the process) => if yes give access regardless of sharing status
     isOwner = ownedProcesses.some((process) => process.id === definitionId);
   }

src/management-system-v2/app/transfer-processes/page.tsx

@@ -0,0 +1,71 @@
+import { getCurrentUser } from '@/components/auth';
+import Content from '@/components/content';
+import { getProcesses, getUserById } from '@/lib/data/DTOs';
+import { Card, Result } from 'antd';
+import { redirect } from 'next/navigation';
+import ProcessTransferButtons from './transfer-processes-confirmation-buttons';
+import { getGuestReference } from '@/lib/reference-guest-user-token';
+
+export default async function TransferProcessesPage({
+  searchParams,
+}: {
+  searchParams: {
+    callbackUrl?: string;
+    referenceToken?: string;
+  };
+}) {
+  const { userId, session } = await getCurrentUser();
+  if (!session) redirect('api/auth/signin');
+  if (session.user.isGuest) redirect('/');
+
+  const callbackUrl = decodeURIComponent(searchParams.callbackUrl || '/');
+
+  const token = decodeURIComponent(searchParams.referenceToken || '');
+  const referenceToken = getGuestReference(token);
+  if ('error' in referenceToken) {
+    let message = 'Invalid link';
+    if (referenceToken.error === 'TokenExpiredError') message = 'Link expired';
+
+    return (
+      <Content title="Transfer Processes">
+        <Result
+          status="error"
+          title={message}
+          subTitle="If you want to transfer the processes from your guest account, you need to sign in with your email from your guest account again."
+        />
+      </Content>
+    );
+  }
+  const guestId = referenceToken.guestId;
+
+  // guestId === userId if the user signed in with a non existing account, and the guest user was
+  // turned into an authenticated user
+  if (!guestId || guestId === userId) redirect(callbackUrl);
+
+  const possibleGuest = await getUserById(guestId);
+  // possibleGuest might be a normal user, this would happen if the user signed in with an existing
+  // accocunt, generating the token above, and before using it, he signed in with a new account.
+  // We only go further then this redirect, if the user signed in with an account that was
+  // already linked to an existing user
+  if (!possibleGuest || !possibleGuest.isGuest) redirect(callbackUrl);
+
+  // NOTE: this ignores folders
+  const guestProcesses = await getProcesses(guestId);
+
+  // If the guest has no processes -> nothing to do
+  if (guestProcesses.length === 0) redirect(callbackUrl);
+
+  return (
+    <Content title="Transfer Processes">
+      <Card
+        title="Would you like to transfer your processes?"
+        style={{ maxWidth: '70ch', margin: 'auto' }}
+      >
+        Your guest account had {guestProcesses.length} process{guestProcesses.length !== 1 && 'es'}.
+        <br />
+        Would you like to transfer them to your account?
+        <ProcessTransferButtons referenceToken={token} callbackUrl={callbackUrl} />
+      </Card>
+    </Content>
+  );
+}

src/management-system-v2/app/transfer-processes/server-actions.ts

@@ -0,0 +1,88 @@
+'use server';
+
+import { getCurrentUser } from '@/components/auth';
+import { Folder } from '@/lib/data/folder-schema';
+import {
+  getProcesses,
+  getFolders,
+  getRootFolder,
+  moveFolder,
+  updateFolderMetaData,
+  updateProcess,
+  getUserById,
+  deleteUser,
+} from '@/lib/data/DTOs';
+import { Process } from '@/lib/data/process-schema';
+import { getGuestReference } from '@/lib/reference-guest-user-token';
+import { UserErrorType, userError } from '@/lib/user-error';
+import { redirect } from 'next/navigation';
+
+export async function transferProcesses(referenceToken: string, callbackUrl: string = '/') {
+  const { session } = await getCurrentUser();
+  if (!session) return userError("You're not signed in", UserErrorType.PermissionError);
+  if (session.user.isGuest)
+    return userError("You can't be a guest to transfer processes", UserErrorType.PermissionError);
+
+  const reference = getGuestReference(referenceToken);
+  if ('error' in reference) return userError(reference.error);
+  const guestId = reference.guestId;
+
+  if (guestId === session.user.id) redirect(callbackUrl);
+
+  const possibleGuest = await getUserById(guestId);
+  if (!possibleGuest || !possibleGuest.isGuest)
+    return userError('Invalid guest id', UserErrorType.PermissionError);
+
+  // Processes and folders under root folder of guest space guet their folderId changed to the
+  // root folder of the new owner space, for the rest we just update the environmentId
+  const userRootFolderId = (await getRootFolder(session.user.id)).id;
+  const guestRootFolderId = (await getRootFolder(guestId)).id;
+
+  // no ability check necessary, owners of personal spaces can do anything
+  const guestProcesses = await getProcesses(guestId);
+  for (const process of guestProcesses) {
+    const processUpdate: Partial<Process> = {
+      environmentId: session.user.id,
+      creatorId: session.user.id,
+    };
+    if (process.folderId === guestRootFolderId) processUpdate.folderId = userRootFolderId;
+    await updateProcess(process.id, processUpdate);
+  }
+
+  const guestFolders = await getFolders(guestId);
+  for (const folder of guestFolders) {
+    if (folder.id === guestRootFolderId) continue;
+
+    const folderData: Partial<Folder> = { createdBy: session.user.id };
+
+    if (folder.parentId === guestRootFolderId) moveFolder(folder.id, userRootFolderId);
+    else folderData.environmentId = session.user.id;
+
+    updateFolderMetaData(folder.id, folderData);
+  }
+
+  deleteUser(guestId);
+
+  redirect(callbackUrl);
+}
+
+export async function discardProcesses(referenceToken: string, redirectUrl: string = '/') {
+  const { session } = await getCurrentUser();
+  if (!session) return userError("You're not signed in", UserErrorType.PermissionError);
+  if (session.user.isGuest)
+    return userError("You can't be a guest to transfer processes", UserErrorType.PermissionError);
+
+  const reference = getGuestReference(referenceToken);
+  if ('error' in reference) return userError(reference.error);
+  const guestId = reference.guestId;
+
+  if (guestId === session.user.id) redirect(redirectUrl);
+
+  const possibleGuest = await getUserById(guestId);
+  if (!possibleGuest || !possibleGuest.isGuest)
+    return userError('Invalid guest id', UserErrorType.PermissionError);
+
+  deleteUser(guestId);
+
+  redirect(redirectUrl);
+}

src/management-system-v2/app/transfer-processes/transfer-processes-confirmation-buttons.tsx

@@ -0,0 +1,47 @@
+'use client';
+
+import { Space, Button } from 'antd';
+import { ReactNode, useTransition } from 'react';
+import {
+  transferProcesses as serverTransferProcesses,
+  discardProcesses as serverDiscardProcesses,
+} from './server-actions';
+
+export default function ProcessTransferButtons({
+  referenceToken,
+  callbackUrl,
+}: {
+  referenceToken: string;
+  callbackUrl?: string;
+  children?: ReactNode;
+}) {
+  const [discardingProcesses, startDiscardingProcesses] = useTransition();
+  function discardProcesses() {
+    startDiscardingProcesses(async () => {
+      await serverDiscardProcesses(referenceToken, callbackUrl);
+    });
+  }
+
+  const [transferring, startTransfer] = useTransition();
+  function transferProcesses() {
+    startTransfer(async () => {
+      await serverTransferProcesses(referenceToken, callbackUrl);
+    });
+  }
+
+  return (
+    <Space style={{ width: '100%', justifyContent: 'right' }}>
+      <Button onClick={discardProcesses} loading={discardingProcesses} disabled={transferring}>
+        No
+      </Button>
+      <Button
+        type="primary"
+        onClick={transferProcesses}
+        loading={transferring}
+        disabled={discardingProcesses}
+      >
+        Yes
+      </Button>
+    </Space>
+  );
+}

src/management-system-v2/lib/change-email/server-actions.ts

@@ -67,7 +67,7 @@ export async function changeEmail(token: string, identifier: string, cancel: boo
   )
     return userError('Invalid token');
 
-  if (!cancel) updateUser(userId, { email: verificationToken.identifier });
+  if (!cancel) updateUser(userId, { email: verificationToken.identifier, isGuest: false });
 
   deleteVerificationToken(tokenParams);
 }