Merge branch 'develop' of github.com:UserOfficeProject/user-office-core into SWAP-5022-uo-co-proposer-email-lookup-fails-when-input-cont

Author: yoganandaness

.github/workflows/rebase-prs-with-develop.yml

@@ -0,0 +1,40 @@
+name: Rebase PRs with develop
+
+on:
+  push:
+    branches:
+      - develop
+
+jobs:
+  sync-prs:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Rebase all open non-Dependabots PRs with develop branch as base
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Get all open PRs targeting develop, excluding Dependabot
+          prs=$(gh pr list --state open --base develop --limit 100 --json number,author --jq '.[] | select(.author.is_bot != true) | .number')
+
+          for pr in $prs; do
+            echo "Processing PR #$pr"
+            gh pr checkout $pr
+            git fetch origin develop
+
+            # Attempt rebase
+            if git rebase origin/develop; then
+              echo "PR #$pr rebased successfully. Pushing changes..."
+              git push --force-with-lease
+            else
+              echo "Conflict in PR #$pr. Rebase aborted."
+              git rebase --abort
+              # Optional: Notify author
+              gh pr comment $pr --body "⚠️ Automatic rebase failed due to conflicts. Please rebase manually."
+            fi
+          done

apps/backend/src/eventHandlers/email/essEmailHandler.spec.ts

@@ -277,6 +277,42 @@ describe('essEmailHandler co-proposer invites', () => {
     );
   });
 
+  it('should send mail when co-proposer invite is accepted', async () => {
+    const mockInvite = new Invite(
+      1,
+      faker.string.alphanumeric(8),
+      dummyUser.email,
+      new Date(),
+      dummyUser.id,
+      new Date(),
+      dummyUser.id,
+      false,
+      null,
+      EmailTemplateId.CO_PROPOSER_INVITE_ACCEPTED
+    );
+
+    // Mock userDataSource.getUser to return dummyUser for principal investigator but null for claimer
+    const getUserMock = jest.spyOn(userDataSourceMock, 'getUser');
+    getUserMock
+      .mockResolvedValueOnce(dummyUser) // First call for principal investigator
+      .mockResolvedValueOnce(dummyUser); // Second call for claimer
+
+    const event: ApplicationEvent = {
+      type: Event.PROPOSAL_CO_PROPOSER_INVITE_ACCEPTED,
+      invite: mockInvite,
+      key: 'invite',
+      loggedInUserId: 3,
+      isRejection: false,
+      proposalPKey: 1,
+    };
+
+    const sendMailsSpy = jest.spyOn(mockMailService, 'sendMail');
+
+    await essEmailHandler(event);
+
+    expect(sendMailsSpy).toHaveBeenCalled();
+  });
+
   describe('handling PROPOSAL_SUBMITTED event', () => {
     it('Should have PI and CoProposals in the payload', async () => {
       const event: ApplicationEvent = {

apps/backend/src/eventHandlers/email/essEmailHandler.ts

@@ -47,10 +47,6 @@ export async function essEmailHandler(event: ApplicationEvent) {
     Tokens.CoProposerClaimDataSource
   );
 
-  const inviteDataSource = container.resolve<InviteDataSource>(
-    Tokens.InviteDataSource
-  );
-
   const callDataSource = container.resolve<CallDataSource>(
     Tokens.CallDataSource
   );

apps/backend/src/mutations/InviteMutations.ts

@@ -69,16 +69,16 @@ export default class InviteMutations {
       return rejection('Invite code has expired', { invite: code });
     }
 
-    await this.processAcceptedRoleClaims(agent!.id, invite);
-    await this.processAcceptedCoProposerClaims(agent!.id, invite);
-    await this.processAcceptedVisitRegistrationClaims(agent!.id, invite);
-
     const updatedInvite = await this.inviteDataSource.update({
       id: invite.id,
       claimedAt: new Date(),
       claimedByUserId: agent!.id,
     });
 
+    await this.processAcceptedRoleClaims(agent!.id, updatedInvite);
+    await this.processAcceptedCoProposerClaims(agent!.id, updatedInvite);
+    await this.processAcceptedVisitRegistrationClaims(agent!.id, updatedInvite);
+
     return updatedInvite;
   }
 
@@ -282,7 +282,6 @@ export default class InviteMutations {
       if (proposalHasUser) {
         return;
       }
-
       await this.proposalDataSource.addProposalUser(
         claim.proposalPk,
         claimerUserId

apps/backend/src/workflowEngine/experiment.ts

@@ -22,7 +22,7 @@ const getExperimentWorkflowByCallId = (callId: number) => {
 
 export const getWorkflowConnectionByStatusId = (
   workflowId: number,
-  statusId: number,
+  statusId?: number,
   prevStatusId?: number
 ) => {
   const workflowDataSource = container.resolve<WorkflowDataSource>(
@@ -45,7 +45,6 @@ const shouldMoveToNextStatus = (
         experimentSafetyEventsKey as keyof ExperimentSafetyEventsRecord
       ]
   );
-
   const allNextStatusRulesFulfilled = !statusChangingEvents.some(
     (statusChangingEvent) =>
       allExperimentIncompleteEvents.indexOf(
@@ -203,78 +202,78 @@ export const workflowEngine = async (
          * We store one record of FEASIBILITY_REVIEW with nextStatusId = FAP_SELECTION and another one with nextStatusId = NOT_FEASIBLE.
          * We go through each record and based on the currentEvent we move the proposal into the right direction
          */
-        return Promise.all(
+        const response = await Promise.all(
           currentWorkflowConnections.map(async (currentWorkflowConnection) => {
-            if (!currentWorkflowConnection.nextStatusId) {
-              return;
-            }
-
-            if (!experimentSafetyWithEvents.experimentSafetyEvents) {
-              return;
-            }
-
             const nextWorkflowConnections =
               await getWorkflowConnectionByStatusId(
                 experimentWorkflow.id,
-                currentWorkflowConnection.nextStatusId,
+                undefined,
                 currentWorkflowConnection.statusId
               );
-            if (!nextWorkflowConnections?.length) {
-              return;
-            }
 
-            const workflowDataSource = container.resolve<WorkflowDataSource>(
-              Tokens.WorkflowDataSource
+            return Promise.all(
+              nextWorkflowConnections.map(async (nextWorkflowConnection) => {
+                if (!experimentSafetyWithEvents.experimentSafetyEvents) {
+                  return;
+                }
+                const workflowDataSource =
+                  container.resolve<WorkflowDataSource>(
+                    Tokens.WorkflowDataSource
+                  );
+
+                const statusChangingEvents =
+                  await workflowDataSource.getStatusChangingEventsByConnectionIds(
+                    [nextWorkflowConnection.id]
+                  );
+                if (!statusChangingEvents) {
+                  return;
+                }
+
+                const eventThatTriggeredStatusChangeIsStatusChangingEvent =
+                  statusChangingEvents.find(
+                    (statusChangingEvent) =>
+                      experimentSafetyWithEvents.currentEvent ===
+                      statusChangingEvent.statusChangingEvent
+                  );
+
+                if (!eventThatTriggeredStatusChangeIsStatusChangingEvent) {
+                  return;
+                }
+
+                if (
+                  shouldMoveToNextStatus(
+                    statusChangingEvents,
+                    experimentSafetyWithEvents.experimentSafetyEvents
+                  )
+                ) {
+                  const updatedExperimentSafety =
+                    await experimentDataSource.updateExperimentSafetyStatus(
+                      experimentSafety.experimentSafetyPk,
+                      nextWorkflowConnection.statusId
+                    );
+
+                  if (updatedExperimentSafety) {
+                    await checkIfConditionsForNextStatusAreMet({
+                      nextWorkflowConnections,
+                      experimentWorkflow,
+                      workflowDataSource,
+                      experimentSafetyWithEvents,
+                    });
+
+                    return {
+                      ...updatedExperimentSafety,
+                      workflowId: experimentWorkflow.id,
+                      prevStatusId: currentWorkflowConnection.statusId,
+                      callShortCode: call.shortCode,
+                    };
+                  }
+                }
+              })
             );
-
-            const statusChangingEvents =
-              await workflowDataSource.getStatusChangingEventsByConnectionIds(
-                nextWorkflowConnections.map((connection) => connection.id)
-              );
-            if (!statusChangingEvents) {
-              return;
-            }
-
-            const eventThatTriggeredStatusChangeIsStatusChangingEvent =
-              statusChangingEvents.find(
-                (statusChangingEvent) =>
-                  experimentSafetyWithEvents.currentEvent ===
-                  statusChangingEvent.statusChangingEvent
-              );
-            if (!eventThatTriggeredStatusChangeIsStatusChangingEvent) {
-              return;
-            }
-
-            if (
-              shouldMoveToNextStatus(
-                statusChangingEvents,
-                experimentSafetyWithEvents.experimentSafetyEvents
-              )
-            ) {
-              const updatedExperimentSafety =
-                await experimentDataSource.updateExperimentSafetyStatus(
-                  experimentSafety.experimentSafetyPk,
-                  currentWorkflowConnection.nextStatusId
-                );
-
-              if (updatedExperimentSafety) {
-                await checkIfConditionsForNextStatusAreMet({
-                  nextWorkflowConnections,
-                  experimentWorkflow,
-                  workflowDataSource,
-                  experimentSafetyWithEvents,
-                });
-
-                return {
-                  ...updatedExperimentSafety,
-                  workflowId: experimentWorkflow.id,
-                  prevStatusId: currentWorkflowConnection.statusId,
-                  callShortCode: call.shortCode,
-                };
-              }
-            }
           })
-        );
+        ).then((results) => results.flat());
+
+        return response;
       })
     )
   ).flat();