perf: optimise generic template copying

apps/backend/db_patches/0165_AddViewForGenericTemplates.sql

@@ -0,0 +1,30 @@
+DO
+$$
+BEGIN
+	IF register_patch('AddViewForGenericTemplates.sql', 'ellenwright', 'Add new view for generic templates', '2024-11-13') THEN
+	BEGIN
+
+    CREATE VIEW generic_templates_view  as select 
+    g.generic_template_id as generic_template_id, g.title, g.creator_id, g.proposal_pk, g.questionary_id, g.question_id, g.created_at,
+    fr.user_id as fap_reviewer,
+    fc.user_id as fap_chair,
+    fs.user_id as fap_secretary,
+    i.manager_user_id as instrument_manager,
+    ihs.user_id as scientist_on_proposal, 
+    vu.user_id as visitor
+
+    from generic_templates g
+    left join visits v on v.proposal_pk = g.proposal_pk
+    left join visits_has_users vu on vu.visit_id = v.visit_id 
+    left join fap_reviews fr on fr.proposal_pk = g.proposal_pk
+    left join fap_chairs fc on fc.fap_id = fr.fap_id
+    left join fap_secretaries fs on fs.fap_id = fr.fap_id
+    left join instrument_has_proposals ihp on ihp.proposal_pk = g.proposal_pk
+    left join instrument_has_scientists ihs on ihs.instrument_id = ihp.instrument_id
+    left join instruments i on i.instrument_id = ihp.instrument_id;
+
+    END;
+	END IF;
+END;
+$$
+LANGUAGE plpgsql;

apps/backend/src/auth/questionary/GenericTemplateQuestionaryAuthorizer.ts

@@ -39,9 +39,12 @@ export class GenericTemplateQuestionaryAuthorizer
     }
 
     const queryResult =
-      await this.genericTemplateDataSource.getGenericTemplates({
-        filter: { questionaryIds: [questionaryId] },
-      });
+      await this.genericTemplateDataSource.getGenericTemplates(
+        {
+          filter: { questionaryIds: [questionaryId] },
+        },
+        agent
+      );
 
     if (queryResult.length !== 1) {
       logger.logError(

apps/backend/src/datasources/GenericTemplateDataSource.ts

@@ -1,4 +1,6 @@
 import { GenericTemplate } from '../models/GenericTemplate';
+import { Role } from '../models/Role';
+import { UserWithRole } from '../models/User';
 import { UpdateGenericTemplateArgs } from '../resolvers/mutations/UpdateGenericTemplateMutation';
 import { GenericTemplatesArgs } from '../resolvers/queries/GenericTemplatesQuery';
 
@@ -21,7 +23,14 @@ export interface GenericTemplateDataSource {
   getGenericTemplate(
     genericTemplateId: number
   ): Promise<GenericTemplate | null>;
-  getGenericTemplates(args: GenericTemplatesArgs): Promise<GenericTemplate[]>;
+  getGenericTemplates(
+    args: GenericTemplatesArgs,
+    agent: UserWithRole | null
+  ): Promise<GenericTemplate[]>;
+  getGenericTemplatesForCopy(
+    userId?: number,
+    role?: Role
+  ): Promise<GenericTemplate[]>;
   createGenericTemplateWithCopiedAnswers(
     title: string,
     creatorId: number,

apps/backend/src/datasources/mockups/GenericTemplateDataSource.ts

@@ -1,4 +1,6 @@
 import { GenericTemplate } from '../../models/GenericTemplate';
+import { Role } from '../../models/Role';
+import { UserWithRole } from '../../models/User';
 import { UpdateGenericTemplateArgs } from '../../resolvers/mutations/UpdateGenericTemplateMutation';
 import { GenericTemplatesArgs } from '../../resolvers/queries/GenericTemplatesQuery';
 import { GenericTemplateDataSource } from '../GenericTemplateDataSource';
@@ -35,7 +37,15 @@ export class GenericTemplateDataSourceMock
   }
 
   async getGenericTemplates(
-    _args: GenericTemplatesArgs
+    _args: GenericTemplatesArgs,
+    agent: UserWithRole | null
+  ): Promise<GenericTemplate[]> {
+    return this.genericTemplates;
+  }
+
+  async getGenericTemplatesForCopy(
+    userId?: number,
+    role?: Role
   ): Promise<GenericTemplate[]> {
     return this.genericTemplates;
   }

apps/backend/src/datasources/postgres/GenericTemplateDataSource.ts

@@ -4,6 +4,7 @@ import { inject, injectable } from 'tsyringe';
 
 import { Tokens } from '../../config/Tokens';
 import { GenericTemplate } from '../../models/GenericTemplate';
+import { Role, Roles } from '../../models/Role';
 import { UpdateGenericTemplateArgs } from '../../resolvers/mutations/UpdateGenericTemplateMutation';
 import { GenericTemplatesArgs } from '../../resolvers/queries/GenericTemplatesQuery';
 import { SubTemplateConfig } from '../../resolvers/types/FieldConfig';
@@ -247,4 +248,39 @@ export default class PostgresGenericTemplateDataSource
         records.map((record) => createGenericTemplateObject(record))
       );
   }
+
+  async getGenericTemplatesForCopy(
+    userId?: number | null,
+    role?: Role
+  ): Promise<GenericTemplate[]> {
+    if (
+      !(
+        role?.shortCode == Roles.INSTRUMENT_SCIENTIST ||
+        role?.shortCode == Roles.USER_OFFICER
+      )
+    ) {
+      return database
+        .select('*')
+        .from('generic_templates_view')
+        .modify((query) => {
+          // add filter for user role
+          query.where('fap_reviewer', userId);
+          query.orWhere('creator_id', userId);
+          query.orWhere('scientist_on_proposal', userId);
+          query.orWhere('fap_chair', userId);
+          query.orWhere('fap_secretary', userId);
+          query.orWhere('instrument_manager', userId);
+          query.orWhere('visitor', userId);
+          query.distinctOn('generic_template_id');
+        })
+        .orderBy('generic_template_id', 'asc')
+        .then((records: GenericTemplateRecord[]) =>
+          records.map((record) => createGenericTemplateObject(record))
+        );
+    } else {
+      const args: GenericTemplatesArgs = {};
+
+      return this.getGenericTemplates(args);
+    }
+  }
 }

apps/backend/src/factory/pdf/proposal.ts

@@ -563,9 +563,12 @@ export const collectProposalPDFDataTokenAccess = async (
       Tokens.GenericTemplateDataSource
     );
 
-  const genericTemplates = await genericTemplateDataSource.getGenericTemplates({
-    filter: { proposalPk: proposal.primaryKey },
-  });
+  const genericTemplates = await genericTemplateDataSource.getGenericTemplates(
+    {
+      filter: { proposalPk: proposal.primaryKey },
+    },
+    user
+  );
 
   const genericTemplatePDFData = (
     await Promise.all(

apps/backend/src/factory/zip/attachment.ts

@@ -205,7 +205,7 @@ const init = (user: UserWithRole) => {
             .resolve<GenericTemplateDataSource>(
               Tokens.GenericTemplateDataSource
             )
-            .getGenericTemplates(args);
+            .getGenericTemplates(args, user);
         }
 
         return baseContext.queries.genericTemplate.getGenericTemplates(

apps/backend/src/mutations/ProposalMutations.ts

@@ -875,9 +875,12 @@ export default class ProposalMutations {
       }
 
       const proposalGenericTemplates =
-        await this.genericTemplateDataSource.getGenericTemplates({
-          filter: { proposalPk: sourceProposal.primaryKey },
-        });
+        await this.genericTemplateDataSource.getGenericTemplates(
+          {
+            filter: { proposalPk: sourceProposal.primaryKey },
+          },
+          agent
+        );
 
       for await (const genericTemplate of proposalGenericTemplates) {
         const clonedGenericTemplate =

apps/backend/src/queries/GenericTemplateQueries.ts

@@ -44,7 +44,26 @@ export default class GenericTemplateQueries {
     agent: UserWithRole | null,
     args: GenericTemplatesArgs
   ) {
-    let genericTemplates = await this.dataSource.getGenericTemplates(args);
+    let genericTemplates = await this.dataSource.getGenericTemplates(
+      args,
+      agent
+    );
+
+    genericTemplates = await Promise.all(
+      genericTemplates.map((genericTemplate) =>
+        this.genericTemplateAuth.hasReadRights(agent, genericTemplate.id)
+      )
+    ).then((results) => genericTemplates.filter((_v, index) => results[index]));
+
+    return genericTemplates;
+  }
+
+  @Authorized()
+  async genericTemplatesOnCopy(agent: UserWithRole | null) {
+    let genericTemplates = await this.dataSource.getGenericTemplatesForCopy(
+      agent?.id,
+      agent?.currentRole
+    );
 
     genericTemplates = await Promise.all(
       genericTemplates.map((genericTemplate) =>

apps/backend/src/resolvers/queries/GenericTemplatesQuery.ts

@@ -52,4 +52,14 @@ export class GenericTemplatesQuery {
 
     return response;
   }
+
+  @Query(() => [GenericTemplate], { nullable: true })
+  async genericTemplatesOnCopy(@Ctx() context: ResolverContext) {
+    const response =
+      await context.queries.genericTemplate.genericTemplatesOnCopy(
+        context.user
+      );
+
+    return response;
+  }
 }