Merge pull request #75 from TalentLayer-Labs/BP-118_JobPostingConditions

2Bp 118 job posting conditions

Author: 0xRomain

src/app/api/collaborators/[id]/route.ts

@@ -0,0 +1,92 @@
+import { IRemoveBuilderPlaceCollaborator } from '../../../../pages/[domain]/admin/collaborator-card';
+import { User } from '.prisma/client';
+import { checkOwnerSignature, isCollaboratorExists } from '../../../utils/domain';
+import prisma from '../../../../postgre/postgreClient';
+import { ERROR_REMOVING_BUILDERPLACE_OWNER } from '../../../../modules/BuilderPlace/apiResponses';
+import { handleApiError } from '../../../utils/handleApiErrors';
+
+export async function GET(req: Request) {}
+
+export async function PUT(req: Request, { params }: { params: { id: string } }) {
+  console.log('PUT');
+  const body: IRemoveBuilderPlaceCollaborator = await req.json();
+  console.log('params', params);
+  console.log('json', body);
+
+  try {
+    const response = await checkOwnerSignature(
+      body.data.builderPlaceId,
+      body.data.ownerTalentLayerId,
+      body.signature,
+      body.address,
+    );
+
+    console.log('response', response instanceof Response);
+
+    if (response instanceof Response) {
+      return response;
+    }
+
+    /**
+     * @dev: Check whether the collaborator is not the BuilderPlace owner
+     */
+    if (response?.builderPlace?.owner?.address === body.data.collaboratorAddress) {
+      console.log('Cant remove the owner as a collaborator');
+      return Response.json({ error: 'Restricted access' }, { status: 400 });
+    }
+
+    /**
+     * @dev: Check whether the collaborator exists
+     */
+    const existingCollaborators: User[] = response?.builderPlace?.collaborators || [];
+
+    if (!isCollaboratorExists(existingCollaborators, body.data.collaboratorAddress)) {
+      console.log('Collaborator does not exist');
+      return Response.json({ error: 'Not a collaborator' }, { status: 400 });
+    }
+
+    console.log('Removing collaborator', body.data.collaboratorAddress);
+
+    let status = 500;
+    let collaborator: User | null = null;
+
+    try {
+      collaborator = await prisma.user.findUnique({
+        where: {
+          address: body.data.collaboratorAddress,
+        },
+      });
+
+      if (!collaborator) {
+        status = 400;
+        throw new Error('Collaborator not found');
+      }
+
+      await prisma.builderPlace.update({
+        where: {
+          id: Number(body.data.builderPlaceId),
+        },
+        data: {
+          collaborators: {
+            disconnect: [{ id: collaborator.id }],
+          },
+        },
+      });
+
+      console.log('Collaborator removed successfully', body.data.collaboratorAddress);
+    } catch (error: any) {
+      handleApiError(error, ERROR_REMOVING_BUILDERPLACE_OWNER, status);
+    }
+
+    return Response.json(
+      {
+        message: 'Collaborator removed successfully',
+        address: collaborator?.address,
+        id: collaborator?.id,
+      },
+      { status: 200 },
+    );
+  } catch (error: any) {
+    return Response.json({ error: error.message }, { status: 400 });
+  }
+}

src/app/api/collaborators/route.ts

@@ -0,0 +1,94 @@
+import { IRemoveBuilderPlaceCollaborator } from '../../../pages/[domain]/admin/collaborator-card';
+import { checkOwnerSignature, isCollaboratorExists } from '../../utils/domain';
+import { EntityStatus, User } from '.prisma/client';
+import prisma from '../../../postgre/postgreClient';
+import { handleApiError } from '../../utils/handleApiErrors';
+import {
+  COLLABORATOR_NOT_FOUND,
+  ERROR_ADDING_COLLABORATOR,
+  ERROR_REMOVING_BUILDERPLACE_OWNER,
+  USER_NOT_FOUND,
+  USER_PROFILE_NOT_VERIFIED,
+} from '../../../modules/BuilderPlace/apiResponses';
+
+export async function POST(req: Request) {
+  console.log('POST');
+  const body: IRemoveBuilderPlaceCollaborator = await req.json();
+  console.log('json', body);
+
+  try {
+    const response = await checkOwnerSignature(
+      body.data.builderPlaceId,
+      body.data.ownerTalentLayerId,
+      body.signature,
+      body.address,
+    );
+
+    console.log('response', response instanceof Response);
+
+    if (response instanceof Response) {
+      return response;
+    }
+
+    /**
+     * @dev: Check whether the collaborator exists
+     */
+    const existingCollaborators: User[] = response?.builderPlace?.collaborators || [];
+
+    if (isCollaboratorExists(existingCollaborators, body.data.collaboratorAddress)) {
+      console.log('Collaborator already exists');
+      return Response.json({ error: 'Already a collaborator' }, { status: 400 });
+    }
+
+    console.log('Adding collaborator', body.data.collaboratorAddress);
+
+    let errorMessage = ERROR_ADDING_COLLABORATOR;
+    let status = 500;
+    let collaborator: User | null = null;
+
+    try {
+      const newCollaborator = await prisma.user.findUnique({
+        where: {
+          address: body.data.collaboratorAddress,
+        },
+      });
+
+      if (!newCollaborator) {
+        errorMessage = USER_NOT_FOUND;
+        throw new Error(USER_NOT_FOUND);
+      }
+
+      //TODO still useful?
+      if (newCollaborator?.status === EntityStatus.PENDING) {
+        errorMessage = USER_PROFILE_NOT_VERIFIED;
+        throw new Error(USER_PROFILE_NOT_VERIFIED);
+      }
+
+      await prisma.builderPlace.update({
+        where: {
+          id: Number(body.data.builderPlaceId),
+        },
+        data: {
+          collaborators: {
+            connect: [{ id: newCollaborator.id }],
+          },
+        },
+      });
+
+      console.log('Collaborator added successfully', body.data.collaboratorAddress);
+    } catch (error: any) {
+      handleApiError(error, errorMessage, status);
+    }
+
+    return Response.json(
+      {
+        message: 'Collaborator added successfully',
+        // address: newCollaborator?.address,
+        // id: newCollaborator?.id,
+      },
+      { status: 200 },
+    );
+  } catch (error: any) {
+    return Response.json({ error: error.message }, { status: 400 });
+  }
+}

src/app/api/platforms/route.ts

@@ -60,8 +60,9 @@ export async function POST(req: Request) {
 
     return Response.json({ id: builderPlace.id }, { status: 201 });
   } catch (error: any) {
+    console.log('errrrrrrrrrrrrrrrrrror', error);
     // @TODO: move error handle to a middleware ? or factorize it ?
-    let message = 'Failed to create plaform';
+    let message = 'Failed to create platform';
     if (error instanceof PrismaClientKnownRequestError) {
       if (error.code === 'P2002') {
         const target = (error.meta?.target as string)[0] || 'data';

src/app/utils/delegate.ts

@@ -8,7 +8,7 @@ import { NetworkEnum } from '../../types';
 export async function isPlatformAllowedToDelegate(
   chainId: number,
   userAddress: string,
-): Promise<Response | void> {
+): Promise<Response | boolean> {
   const user = await getUserByAddress(chainId, userAddress);
   const delegateAddresses: string[] = user.data?.data?.users[0]?.delegates.map((delegate: any) =>
     delegate.toLowerCase(),
@@ -23,6 +23,9 @@ export async function isPlatformAllowedToDelegate(
       { error: 'Delegation is Not activated for this address' },
       { status: 401 },
     );
+  else {
+    return true;
+  }
 }
 
 export async function getDelegationSigner(): Promise<WalletClient | null> {

src/app/utils/domain.ts

@@ -0,0 +1,100 @@
+import { recoverMessageAddress } from 'viem';
+import { User } from '.prisma/client';
+import {
+  getBuilderPlaceByCollaboratorAddressAndId,
+  getBuilderPlaceByOwnerTlIdAndId,
+} from '../../modules/BuilderPlace/actions/builderPlace';
+
+/**
+ * Checks if the signature is from a BuilderPlace collaborator by getting the BuilderPlace
+ * by the collaborator address & BuilderPlace Database id
+ * @param id: Database BuilderPlace id
+ * @param signature: Signature to verify
+ */
+export const checkSignature = async (id: string, signature: `0x${string}` | Uint8Array) => {
+  try {
+    const address = await recoverMessageAddress({
+      message: id,
+      signature: signature,
+    });
+
+    const builderPlace = await getBuilderPlaceByCollaboratorAddressAndId(
+      address.toLocaleLowerCase(),
+      id,
+    );
+
+    if (!builderPlace) {
+      return Response.json({ error: 'No BuilderPlace found' }, { status: 400 });
+    }
+
+    return { builderPlace, address };
+  } catch (error) {
+    console.error('Error in checkSignature:', error);
+
+    return Response.json(
+      { error: 'An error occurred while verifying the signature' },
+      { status: 500 },
+    );
+  }
+};
+
+/**
+ * Checks if the signature is from the BuilderPlace owner by getting the BuilderPlace
+ * by the owner DataBase id & BuilderPlace Database id
+ * @param builderPlaceId: Database BuilderPlace id
+ * @param ownerId: Database BuilderPlace owner id
+ * @param signature: Signature to verify
+ * @param address: Address to verify
+ * @throws 401 if the signature is not from the BuilderPlace owner
+ */
+export const checkOwnerSignature = async (
+  builderPlaceId: string,
+  ownerId: string,
+  signature: `0x${string}` | Uint8Array,
+  address: `0x${string}`,
+) => {
+  try {
+    const signatureAddress = await recoverMessageAddress({
+      message: `connect with ${address}`,
+      signature: signature,
+    });
+
+    const builderPlace = await getBuilderPlaceByOwnerTlIdAndId(ownerId, builderPlaceId);
+
+    /**
+     * Check whether the signature is from the BuilderPlace owner
+     */
+    if (
+      builderPlace &&
+      signatureAddress.toLocaleLowerCase() !== builderPlace?.owner?.address?.toLocaleLowerCase()
+    ) {
+      return Response.json({ error: 'Not BuilderPlace owner' }, { status: 401 });
+    }
+
+    return { builderPlace, address: signatureAddress };
+  } catch (error) {
+    console.error('Error in checkSignature:', error);
+
+    return Response.json(
+      { error: 'An error occurred while verifying the signature' },
+      { status: 500 },
+    );
+  }
+};
+
+export const isCollaboratorExists = (
+  collaborators: User[] = [],
+  newCollaboratorAddress: string,
+): boolean => {
+  console.log(
+    'collaborators',
+    collaborators.map(collaborator => {
+      console.log(collaborator.address);
+    }),
+  );
+  console.log('newCollaboratorAddress', newCollaboratorAddress);
+  return collaborators.some(
+    collaborator =>
+      collaborator?.address?.toLocaleLowerCase() === newCollaboratorAddress.toLocaleLowerCase(),
+  );
+};

src/components/AsyncButton.tsx

@@ -2,20 +2,28 @@ function AsyncButton({
   isSubmitting,
   label = 'Create',
   onClick,
-  buttonCss,
+  validateButtonCss,
+  loadingButtonCss,
+  disabled = false,
 }: {
   isSubmitting: boolean;
   label?: string;
   onClick: () => Promise<void>;
-  buttonCss?: string;
+  validateButtonCss?: string;
+  loadingButtonCss?: string;
+  disabled?: boolean;
 }) {
   return (
     <div className='flex flex-row justify-between items-center'>
       {isSubmitting ? (
         <button
           type='button'
           disabled
-          className={`py-2 px-5 bg-primary text-primary opacity-50 rounded-xl border inline-flex items-center ${buttonCss}`}>
+          className={`${
+            loadingButtonCss
+              ? loadingButtonCss
+              : `py-2 px-5 bg-primary text-primary opacity-50 rounded-xl border inline-flex items-center`
+          }`}>
           <svg
             role='status'
             className='inline mr-2 w-4 h-4 text-base-content animate-spin '
@@ -37,8 +45,11 @@ function AsyncButton({
         <button
           type='button'
           onClick={onClick}
+          disabled={disabled}
           className={`${
-            buttonCss ? buttonCss : `grow px-5 py-2 rounded-xl bg-primary text-primary`
+            validateButtonCss
+              ? validateButtonCss
+              : `grow px-5 py-2 rounded-xl bg-primary text-primary`
           }`}>
           {label}
         </button>

src/components/ConfigurePlatform/ConfigurePlatformForm.tsx

@@ -39,6 +39,9 @@ const ethAddressRegex = /^0x[a-fA-F0-9]{40}$/;
 
 const validationSchema = Yup.object({
   subdomain: Yup.string().required('Subdomain is required'),
+  //TODO check Yup, try to make the JobConditions work ? Problème, quand on push on ne submit pas,
+  // donc en théorie ça ne passera pas. Faut juste essayer de faire en sorte que
+  // les err messages ne reset pas à chaque change. Un genre de prevent default ?
 
   // tempFormValues: Yup.object({
   //   tempNftAddress: Yup.string().matches(ethAddressRegex, 'Invalid Ethereum address').notRequired(),

src/components/ConfigurePlatform/JobPostingConditionsFieldArray.tsx

@@ -179,7 +179,7 @@ function JobPostingConditionsFieldArray({
                     <AsyncButton
                       label={'Add NFT Condition'}
                       isSubmitting={nftSubmitting}
-                      buttonCss={'w-52'}
+                      validateButtonCss={'w-52 grow px-5 py-2 rounded-xl bg-primary text-primary'}
                       onClick={() =>
                         addJobPostingConditions(push, setFieldValue, setFieldError, {
                           type: 'NFT',
@@ -230,7 +230,7 @@ function JobPostingConditionsFieldArray({
                     <AsyncButton
                       label={'Add Token Condition'}
                       isSubmitting={tokenSubmitting}
-                      buttonCss={'w-52'}
+                      validateButtonCss={'w-52 grow px-5 py-2 rounded-xl bg-primary text-primary'}
                       onClick={() =>
                         addJobPostingConditions(push, setFieldValue, setFieldError, {
                           type: 'Token',