fix: introduce onBeforeSave

apps/user-office-backend/src/datasources/QuestionaryDataSource.ts

@@ -3,7 +3,7 @@ import {
   Questionary,
   QuestionaryStep,
 } from '../models/Questionary';
-import { DataType, Question, Template } from '../models/Template';
+import { Template } from '../models/Template';
 
 export interface QuestionaryDataSource {
   getCount(templateId: number): Promise<number>;
@@ -18,10 +18,6 @@ export interface QuestionaryDataSource {
   getBlankQuestionarySteps(templateId: number): Promise<QuestionaryStep[]>;
   getBlankQuestionaryStepsByCallId(callId: number): Promise<QuestionaryStep[]>;
   getAnswers(questionId: string): Promise<AnswerBasic[]>;
-  getLatestAnswerByQuestionaryIdAndDataType(
-    questionaryId: number,
-    dataType: DataType
-  ): Promise<{ answer: AnswerBasic; question: Question } | null>;
   getTemplates(questionId: string): Promise<Template[]>;
   getIsCompleted(questionaryId: number): Promise<boolean>;
   updateAnswer(

apps/user-office-backend/src/datasources/mockups/QuestionaryDataSource.ts

@@ -387,13 +387,6 @@ export class QuestionaryDataSourceMock implements QuestionaryDataSource {
     return [];
   }
 
-  async getLatestAnswerByQuestionaryIdAndDataType(
-    questionaryId: number,
-    dataType: DataType
-  ): Promise<{ answer: AnswerBasic; question: Question } | null> {
-    return null;
-  }
-
   async getTemplates(questionId: string): Promise<Template[]> {
     return [];
   }

apps/user-office-backend/src/datasources/postgres/QuestionaryDataSource.ts

@@ -15,7 +15,6 @@ import {
 import {
   DataType,
   FieldDependency,
-  Question,
   Template,
   Topic,
 } from '../../models/Template';
@@ -36,7 +35,6 @@ import {
   TopicRecord,
   ProposalRecord,
   createProposalObject,
-  createQuestionObject,
 } from './records';
 
 type AnswerRecord<T extends DataType> = QuestionRecord &
@@ -130,33 +128,6 @@ export default class PostgresQuestionaryDataSource
       });
   }
 
-  async getLatestAnswerByQuestionaryIdAndDataType(
-    questionaryId: number,
-    dataType: DataType
-  ): Promise<{ answer: AnswerBasic; question: Question } | null> {
-    return database('answers')
-      .leftJoin(
-        'questions',
-        'questions.question_id',
-        '=',
-        'answers.question_id'
-      )
-      .where('answers.questionary_id', questionaryId)
-      .where('questions.data_type', dataType)
-      .orderBy('answers.created_at', 'desc')
-      .limit(1)
-      .then((rows) => {
-        if (rows.length == 0) {
-          return null;
-        }
-
-        return {
-          answer: createAnswerBasic(rows[0]),
-          question: createQuestionObject(rows[0]),
-        };
-      });
-  }
-
   async getTemplates(questionId: string): Promise<Template[]> {
     return database('templates_has_questions')
       .leftJoin(

apps/user-office-backend/src/eventHandlers/index.ts

@@ -6,7 +6,6 @@ import createCustomHandler from './customHandler';
 import createLoggingHandler from './logging';
 import { createPostToQueueHandler } from './messageBroker';
 import createProposalWorkflowHandler from './proposalWorkflow';
-import createInstrumentPickerHandler from './questionary/instrumentPicker';
 
 export default function createEventHandlers() {
   const emailHandler = container.resolve<
@@ -19,6 +18,5 @@ export default function createEventHandlers() {
     createPostToQueueHandler(),
     createProposalWorkflowHandler(),
     createCustomHandler(),
-    createInstrumentPickerHandler(),
   ];
 }

apps/user-office-backend/src/models/questionTypes/InstrumentPicker.ts

@@ -5,6 +5,7 @@ import { container } from 'tsyringe';
 
 import { Tokens } from '../../config/Tokens';
 import { InstrumentDataSource } from '../../datasources/InstrumentDataSource';
+import { ProposalDataSource } from '../../datasources/ProposalDataSource';
 import { InstrumentPickerConfig } from '../../resolvers/types/FieldConfig';
 import { QuestionFilterCompareOperator } from '../Questionary';
 import { DataType, QuestionTemplateRelation } from '../Template';
@@ -73,4 +74,26 @@ export const instrumentPickerDefinition: Question<DataType.INSTRUMENT_PICKER> =
 
       return fallBackConfig;
     },
+    async onBeforeSave(questionaryId, questionTemplateRelation, answer) {
+      const instrumentDataSource = container.resolve<InstrumentDataSource>(
+        Tokens.InstrumentDataSource
+      );
+
+      const proposalDataSource = container.resolve<ProposalDataSource>(
+        Tokens.ProposalDataSource
+      );
+
+      const proposal = await proposalDataSource.getByQuestionaryId(
+        questionaryId
+      );
+      if (!proposal) {
+        throw new GraphQLError('Proposal not found');
+      }
+
+      const { value } = JSON.parse(answer.value);
+      await instrumentDataSource.assignProposalsToInstrument(
+        [proposal?.primaryKey],
+        value
+      );
+    },
   };

apps/user-office-backend/src/models/questionTypes/QuestionRegistry.ts

@@ -2,6 +2,7 @@ import { logger } from '@user-office-software/duo-logger';
 import { GraphQLError } from 'graphql';
 import { Knex } from 'knex';
 
+import { AnswerInput } from '../../resolvers/mutations/AnswerTopicMutation';
 import { QuestionFilterInput } from '../../resolvers/queries/ProposalsQuery';
 import {
   BooleanConfig,
@@ -142,6 +143,12 @@ export interface Question<T extends DataType> {
     config: QuestionDataTypeConfigMapping<T>,
     callId?: number
   ) => Promise<QuestionDataTypeConfigMapping<T>>;
+
+  onBeforeSave?: (
+    questionaryId: number,
+    questionTemplateRelation: QuestionTemplateRelation,
+    answer: AnswerInput
+  ) => Promise<void>;
 }
 
 // Add new component definitions here

apps/user-office-backend/src/mutations/InstrumentMutations.ts

@@ -126,36 +126,38 @@ export default class InstrumentMutations {
   }
 
   @EventBus(Event.PROPOSAL_INSTRUMENT_SELECTED)
-  async assignProposalsToInstrumentHelper(
+  @ValidateArgs(assignProposalsToInstrumentValidationSchema)
+  @Authorized([Roles.USER_OFFICER])
+  async assignProposalsToInstrument(
     agent: UserWithRole | null,
     args: AssignProposalsToInstrumentArgs
-  ) {
+  ): Promise<ProposalPks | Rejection> {
+    const allProposalsAreOnSameCallAsInstrument =
+      await this.checkIfProposalsAreOnSameCallAsInstrument(args);
+
+    if (!allProposalsAreOnSameCallAsInstrument) {
+      return rejection(
+        'One or more proposals can not be assigned to instrument, because instrument is not in the call',
+        { args }
+      );
+    }
+
     const instrument = await this.dataSource.getInstrument(args.instrumentId);
 
     if (!instrument) {
       return rejection(
-        'Could not assign proposal/s to instrument, instrument not found',
+        'Cannot assign the proposal to the instrument because the proposals call has no such instrument',
         { agent, args }
       );
     }
 
     const proposalPks = args.proposals.map((proposal) => proposal.primaryKey);
 
-    const result = await this.dataSource.assignProposalsToInstrument(
-      proposalPks,
-      args.instrumentId
-    );
-
-    if (result.proposalPks.length !== proposalPks.length) {
-      return rejection('Could not assign proposal/s to instrument', {
-        agent,
-        args,
-      });
-    }
     for await (const proposalPk of proposalPks) {
       const technicalReview = await this.reviewDataSource.getTechnicalReview(
         proposalPk
       );
+
       if (technicalReview) {
         await this.proposalDataSource.updateProposalTechnicalReviewer({
           userId: instrument.managerUserId,
@@ -182,26 +184,19 @@ export default class InstrumentMutations {
       }
     }
 
-    return result;
-  }
-
-  @ValidateArgs(assignProposalsToInstrumentValidationSchema)
-  @Authorized([Roles.USER_OFFICER])
-  async assignProposalsToInstrument(
-    agent: UserWithRole | null,
-    args: AssignProposalsToInstrumentArgs
-  ): Promise<ProposalPks | Rejection> {
-    const allProposalsAreOnSameCallAsInstrument =
-      await this.checkIfProposalsAreOnSameCallAsInstrument(args);
+    const result = await this.dataSource.assignProposalsToInstrument(
+      proposalPks,
+      args.instrumentId
+    );
 
-    if (!allProposalsAreOnSameCallAsInstrument) {
-      return rejection(
-        'One or more proposals can not be assigned to instrument, because instrument is not in the call',
-        { args }
-      );
+    if (result.proposalPks.length !== proposalPks.length) {
+      return rejection('Could not assign proposal/s to instrument', {
+        agent,
+        args,
+      });
     }
 
-    return this.assignProposalsToInstrumentHelper(agent, args);
+    return result;
   }
 
   @Authorized([Roles.USER_OFFICER])

apps/user-office-backend/src/mutations/QuestionaryMutations.ts

@@ -12,6 +12,7 @@ import {
   isMatchingConstraints,
   transformAnswerValueIfNeeded,
 } from '../models/ProposalModelFunctions';
+import { getQuestionDefinition } from '../models/questionTypes/QuestionRegistry';
 import { rejection } from '../models/Rejection';
 import { UserJWT, UserWithRole } from '../models/User';
 import { AnswerTopicArgs } from '../resolvers/mutations/AnswerTopicMutation';
@@ -130,6 +131,18 @@ export default class QuestionaryMutations {
           });
         }
 
+        const definition = getQuestionDefinition(
+          questionTemplateRelation.question.dataType
+        );
+
+        if (definition.onBeforeSave) {
+          definition.onBeforeSave(
+            questionaryId,
+            questionTemplateRelation,
+            answer
+          );
+        }
+
         await this.dataSource.updateAnswer(
           questionaryId,
           answer.questionId,