Feature client profile updates api (#10)

* update client profile

* save client profile updates ongoing

* save ongoing

* update profile ongoing

* fetch updates ongoing

* parse updates ongoing

* changed db

* custom field access changes

* save updates

* get updates

* profile update history ongoing

* update history ongoing

* update history order fix

* clean migrations

* settings

* cleanup

* Bug fixes and PR changes

* setting changes

prisma/migrations/20240115152243_create_custom_field_access_table/migration.sql → prisma/migrations/20240127105731_create_custom_field_access_table/migration.sql

@@ -1,13 +1,14 @@
+-- CreateEnum
+CREATE TYPE "Permission" AS ENUM ('VIEW', 'EDIT');
+
 -- CreateTable
 CREATE TABLE "CustomFieldAccess" (
     "id" UUID NOT NULL DEFAULT gen_random_uuid(),
-    "customFieldId" UUID,
-    "permissions" JSONB,
+    "customFieldId" UUID NOT NULL,
+    "portalId" TEXT NOT NULL,
+    "permissions" "Permission"[],
     "createdAt" TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "updatedAt" TIMESTAMPTZ NOT NULL,
 
     CONSTRAINT "CustomFieldAccess_pkey" PRIMARY KEY ("id")
 );
-
--- CreateIndex
-CREATE UNIQUE INDEX "CustomFieldAccess_customFieldId_key" ON "CustomFieldAccess"("customFieldId");

prisma/migrations/20240127105945_create_client_profile_updates_table/migration.sql

@@ -0,0 +1,12 @@
+-- CreateTable
+CREATE TABLE "ClientProfileUpdates" (
+    "id" UUID NOT NULL DEFAULT gen_random_uuid(),
+    "clientId" UUID NOT NULL,
+    "companyId" UUID NOT NULL,
+    "customFields" JSONB NOT NULL,
+    "changedFields" JSONB NOT NULL,
+    "createdAt" TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMPTZ NOT NULL,
+
+    CONSTRAINT "ClientProfileUpdates_pkey" PRIMARY KEY ("id")
+);

prisma/migrations/20240127115634_create_setting_table/migration.sql

@@ -0,0 +1,10 @@
+-- CreateTable
+CREATE TABLE "Setting" (
+    "id" UUID NOT NULL DEFAULT gen_random_uuid(),
+    "portalId" TEXT NOT NULL,
+    "profileLinks" JSONB NOT NULL,
+    "createdAt" TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMPTZ NOT NULL,
+
+    CONSTRAINT "Setting_pkey" PRIMARY KEY ("id")
+);

prisma/migrations/20240129075218_add_portal_id_to_client_profile_updates_table/migration.sql

@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - Added the required column `portalId` to the `ClientProfileUpdates` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- AlterTable
+ALTER TABLE "ClientProfileUpdates" ADD COLUMN     "portalId" TEXT NOT NULL;

prisma/migrations/20240129090605_rename_column_in_setting_table/migration.sql

@@ -0,0 +1,10 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `profileLinks` on the `Setting` table. All the data in the column will be lost.
+  - Added the required column `data` to the `Setting` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- AlterTable
+ALTER TABLE "Setting" DROP COLUMN "profileLinks",
+ADD COLUMN     "data" JSONB NOT NULL;

prisma/schema.prisma

@@ -8,18 +8,38 @@ generator client {
 datasource db {
   provider = "postgresql"
   url      = env("POSTGRES_PRISMA_URL")
+  directUrl = env("POSTGRES_URL_NON_POOLING")
 }
 
 enum Permission {
- VIEW
- EDIT
+  VIEW
+  EDIT
 }
 
 model CustomFieldAccess {
+  id            String       @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  customFieldId String       @db.Uuid
+  portalId      String
+  permissions   Permission[]
+  createdAt     DateTime     @default(now()) @db.Timestamptz()
+  updatedAt     DateTime     @updatedAt @ignore @db.Timestamptz()
+}
+
+model ClientProfileUpdates {
   id            String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
-  customFieldId String  @db.Uuid
-  companyId     String  @db.Uuid
-  permission    Permission
+  clientId      String   @db.Uuid
+  companyId     String   @db.Uuid
+  portalId      String
+  customFields  Json     @db.JsonB
+  changedFields Json     @db.JsonB
   createdAt     DateTime @default(now()) @db.Timestamptz()
   updatedAt     DateTime @updatedAt @ignore @db.Timestamptz()
 }
+
+model Setting {
+  id           String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  portalId     String
+  data Json     @db.JsonB
+  createdAt    DateTime @default(now()) @db.Timestamptz()
+  updatedAt    DateTime @updatedAt @ignore @db.Timestamptz()
+}

src/app/api/client-profile-updates/route.ts

@@ -0,0 +1,116 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { ClientProfileUpdatesRequestSchema, ParsedClientProfileUpdatesResponse } from '@/types/clientProfileUpdates';
+import { CopilotAPI } from '@/utils/copilotApiUtils';
+import { handleError, respondError } from '@/utils/common';
+import { ClientProfileUpdatesService } from '@/app/api/client-profile-updates/services/clientProfileUpdates.service';
+import { ClientResponse, CompanyResponse } from '@/types/common';
+import { z } from 'zod';
+import { createLookup, getObjectDifference, getSelectedOptions } from '@/lib/helper';
+
+export async function POST(request: NextRequest) {
+  const data = await request.json();
+  const clientProfileUpdateRequest = ClientProfileUpdatesRequestSchema.safeParse(data);
+  if (!clientProfileUpdateRequest.success) {
+    return NextResponse.json(clientProfileUpdateRequest.error.issues, { status: 422 });
+  }
+  try {
+    //todo: check access
+    const copilotClient = new CopilotAPI(clientProfileUpdateRequest.data.token);
+    const client: ClientResponse = await copilotClient.getClient(clientProfileUpdateRequest.data.clientId);
+    const clientUpdateResponse = await copilotClient.updateClient(clientProfileUpdateRequest.data.clientId, {
+      customFields: clientProfileUpdateRequest.data.form,
+    });
+    const changedFields = getObjectDifference(clientUpdateResponse.customFields ?? {}, client.customFields ?? {});
+    if (Object.keys(changedFields).length === 0) {
+      return NextResponse.json({});
+    }
+
+    const service = new ClientProfileUpdatesService();
+    await service.save({
+      clientId: clientProfileUpdateRequest.data.clientId,
+      companyId: clientProfileUpdateRequest.data.companyId,
+      portalId: clientProfileUpdateRequest.data.portalId,
+      customFields: clientUpdateResponse.customFields ?? {},
+      changedFields,
+    });
+
+    return NextResponse.json({});
+  } catch (error) {
+    return handleError(error);
+  }
+}
+
+export async function GET(request: NextRequest) {
+  const token = request.nextUrl.searchParams.get('token');
+  const portalId = request.nextUrl.searchParams.get('portalId');
+
+  if (!token) {
+    return respondError('Missing token', 422);
+  }
+  if (!portalId) {
+    return respondError('Missing portalId', 422);
+  }
+
+  try {
+    const copilotClient = new CopilotAPI(z.string().parse(token));
+
+    const [currentUser, clients, companies, portalCustomFields] = await Promise.all([
+      copilotClient.me(),
+      copilotClient.getClients(),
+      copilotClient.getCompanies(),
+      copilotClient.getCustomFields(),
+    ]);
+    //todo:: filter companyIds based on currentUser restrictions
+    const clientProfileUpdates = await new ClientProfileUpdatesService().findMany(portalId, []);
+
+    const clientLookup = createLookup(clients.data, 'id');
+    const companyLookup = createLookup(companies.data, 'id');
+
+    const parsedClientProfileUpdates: ParsedClientProfileUpdatesResponse[] = clientProfileUpdates.map((update) => {
+      const client = clientLookup[update.clientId];
+      const company = companyLookup[update.companyId];
+
+      const customFields = portalCustomFields.data?.map((portalCustomField) => {
+        const value = update.customFields[portalCustomField.key] ?? null;
+        const options = getSelectedOptions(portalCustomField, value);
+
+        return {
+          name: portalCustomField.name,
+          type: portalCustomField.type,
+          key: portalCustomField.key,
+          value: options.length > 0 ? options : value,
+          isChanged: !!update.changedFields[portalCustomField.key],
+        };
+      });
+
+      return {
+        id: update.id,
+        client: getClientDetails(client),
+        company: getCompanyDetails(company),
+        lastUpdated: update.createdAt,
+        customFields,
+      };
+    });
+
+    return NextResponse.json(parsedClientProfileUpdates);
+  } catch (error) {
+    return handleError(error);
+  }
+}
+
+function getClientDetails(client: ClientResponse) {
+  return {
+    id: client.id,
+    name: `${client.givenName} ${client.familyName}`,
+    email: client.email,
+    avatarImageUrl: client.avatarImageUrl,
+  };
+}
+
+function getCompanyDetails(company: CompanyResponse) {
+  return {
+    id: company.id,
+    name: company.name,
+    iconImageUrl: company.iconImageUrl,
+  };
+}

src/app/api/client-profile-updates/services/clientProfileUpdates.service.ts

@@ -0,0 +1,58 @@
+import { PrismaClient } from '@prisma/client';
+import DBClient from '@/lib/db';
+import {
+  ClientProfileUpdates,
+  ClientProfileUpdatesResponse,
+  ClientProfileUpdatesResponseSchema,
+  UpdateHistory,
+} from '@/types/clientProfileUpdates';
+
+export class ClientProfileUpdatesService {
+  private prismaClient: PrismaClient = DBClient.getInstance();
+
+  async save(requestData: ClientProfileUpdates): Promise<void> {
+    await this.prismaClient.clientProfileUpdates.create({
+      data: {
+        clientId: requestData.clientId,
+        companyId: requestData.companyId,
+        portalId: requestData.portalId,
+        customFields: requestData.customFields,
+        changedFields: requestData.changedFields,
+      },
+    });
+  }
+
+  // Company Filter is not applied if companyIds is empty
+  async findMany(portalId: string, companyIds: Array<string>): Promise<ClientProfileUpdatesResponse> {
+    let clientProfileUpdates = [];
+    if (companyIds.length > 0) {
+      clientProfileUpdates = await this.prismaClient.clientProfileUpdates.findMany({
+        where: {
+          portalId: portalId,
+          companyId: {
+            in: companyIds,
+          },
+        },
+      });
+    } else {
+      clientProfileUpdates = await this.prismaClient.clientProfileUpdates.findMany({
+        where: {
+          portalId: portalId,
+        },
+      });
+    }
+
+    return ClientProfileUpdatesResponseSchema.parse(clientProfileUpdates);
+  }
+
+  async getUpdateHistory(customFieldKey: string, clientId: string, lastUpdated: Date): Promise<UpdateHistory[]> {
+    return this.prismaClient.$queryRaw`
+      SELECT "changedFields"
+      FROM "ClientProfileUpdates"
+      WHERE "clientId" = ${clientId}::uuid
+      AND "createdAt" <= ${lastUpdated}
+      AND "changedFields" ->> ${customFieldKey} IS NOT NULL
+      ORDER BY "createdAt" DESC;
+    `;
+  }
+}

src/app/api/custom-field-access/route.ts

@@ -1,31 +1,31 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { CustomFieldAccessRequestSchema } from '@/types/customFieldAccess';
 import { CustomFieldAccessService } from '@/app/api/custom-field-access/services/customFieldAccess.service';
-import { errorHandler } from '@/utils/common';
+import { respondError } from '@/utils/common';
 import { CopilotAPI } from '@/utils/copilotApiUtils';
 import { z } from 'zod';
 
 export async function GET(request: NextRequest) {
   const searchParams = request.nextUrl.searchParams;
   const token = searchParams.get('token');
-  const companyId = searchParams.get('companyId');
+  const portalId = searchParams.get('portalId');
   if (!token) {
-    return errorHandler('Missing token', 422);
+    return respondError('Missing token', 422);
   }
-  if (!companyId) {
-    return errorHandler('Missing companyId', 422);
+  if (!portalId) {
+    return respondError('Missing portalId', 422);
   }
   const copilotClient = new CopilotAPI(z.string().parse(token));
   const customFields = (await copilotClient.getCustomFields()).data;
 
   const customFieldAccessService = new CustomFieldAccessService();
-  const customFieldAccesses = await customFieldAccessService.findAll(z.string().uuid().parse(companyId));
+  const customFieldAccesses = await customFieldAccessService.findAll(z.string().parse(portalId));
 
   const customFieldsWithAccess = customFields?.map((customField) => {
     const customFieldAccess = customFieldAccesses.find((access) => access.customFieldId === customField.id);
     return {
       ...customField,
-      permission: customFieldAccess ? customFieldAccess.permission : null,
+      permission: customFieldAccess ? customFieldAccess.permissions : [],
     };
   });
 
@@ -36,7 +36,7 @@ export async function PUT(request: NextRequest) {
   const data = await request.json();
   const customFieldAccess = CustomFieldAccessRequestSchema.safeParse(data);
   if (!customFieldAccess.success) {
-    return NextResponse.json(customFieldAccess.error.issues);
+    return NextResponse.json(customFieldAccess.error.issues, { status: 422 });
   }
   const customFieldAccessService = new CustomFieldAccessService();
   await customFieldAccessService.save(customFieldAccess.data);

src/app/api/custom-field-access/services/customFieldAccess.service.ts

@@ -17,14 +17,14 @@ export class CustomFieldAccessService {
           customFieldId: {
             in: customFieldIds,
           },
-          companyId: requestData.companyId,
+          portalId: requestData.portalId,
         },
       },
     });
     const accesses = requestData.accesses.map((access) => {
       return {
         ...access,
-        companyId: requestData.companyId,
+        portalId: requestData.portalId,
       };
     });
     const createCustomFields = this.prismaClient.customFieldAccess.createMany({
@@ -34,10 +34,10 @@ export class CustomFieldAccessService {
     await this.prismaClient.$transaction([deleteCustomFields, createCustomFields]);
   }
 
-  async findAll(companyId: string): Promise<CustomFieldAccessResponse> {
+  async findAll(portalId: string): Promise<CustomFieldAccessResponse> {
     const customFieldAccesses = await this.prismaClient.customFieldAccess.findMany({
       where: {
-        companyId: companyId,
+        portalId: portalId,
       },
     });