feat: coproposer invite accept without code

Author: yoganandaness

apps/backend/src/auth/ProposalAuthorization.ts

@@ -242,10 +242,6 @@ export class ProposalAuthorization {
     return isInternalReviewerOnSomeTechnicalReview;
   }
 
-  // async isInvitee(agent: UserWithRole, proposalPk: number) {
-  //   return this.inviteDataSource.isInvitee(agent.id, proposalPk);
-  // }
-
   async hasReadRights(
     agent: UserWithRole | null,
     proposalOrProposalId: Proposal | number

apps/backend/src/datasources/InviteDataSource.ts

@@ -8,6 +8,10 @@ export interface GetInvitesFilter {
   email?: string;
 }
 
+export interface GetCoProposerInvitesFilter extends GetInvitesFilter {
+  proposalPk?: number;
+}
+
 export interface InviteDataSource {
   create(args: {
     createdByUserId: number;
@@ -28,7 +32,7 @@ export interface InviteDataSource {
     isClaimed?: boolean
   ): Promise<Invite[]>;
   getInvites(filter: GetInvitesFilter): Promise<Invite[]>;
-  getProposalInvites(filter: GetInvitesFilter): Promise<Invite[]>;
+  getCoProposerInvites(filter: GetCoProposerInvitesFilter): Promise<Invite[]>;
 
   update(args: {
     id: number;

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

@@ -2,13 +2,19 @@ import { inject, injectable } from 'tsyringe';
 
 import { Tokens } from '../../config/Tokens';
 import { EmailTemplateId } from '../../eventHandlers/email/essEmailHandler';
+import { CoProposerClaim } from '../../models/CoProposerClaim';
 import { Invite } from '../../models/Invite';
 import { CoProposerClaimDataSource } from '../CoProposerClaimDataSource';
-import { GetInvitesFilter, InviteDataSource } from '../InviteDataSource';
+import {
+  GetCoProposerInvitesFilter,
+  GetInvitesFilter,
+  InviteDataSource,
+} from '../InviteDataSource';
 
 @injectable()
 export class InviteDataSourceMock implements InviteDataSource {
   private invites: Invite[];
+  private coProposerClaims: CoProposerClaim[];
 
   constructor(
     @inject(Tokens.CoProposerClaimDataSource)
@@ -86,6 +92,8 @@ export class InviteDataSourceMock implements InviteDataSource {
         EmailTemplateId.USER_OFFICE_REGISTRATION_INVITATION_REVIEWER
       ),
     ];
+
+    this.coProposerClaims = [new CoProposerClaim(2, 1)];
   }
 
   async findByCode(code: string): Promise<Invite | null> {
@@ -177,7 +185,56 @@ export class InviteDataSourceMock implements InviteDataSource {
 
     return invite;
   }
-  getProposalInvites(filter: GetInvitesFilter): Promise<Invite[]> {
-    throw new Error('Method not implemented.');
+  getCoProposerInvites(filter: GetCoProposerInvitesFilter): Promise<Invite[]> {
+    return new Promise((resolve) => {
+      const filteredInvites = this.invites.filter((invite) => {
+        if (filter.createdBefore) {
+          if (invite.createdAt >= filter.createdBefore) {
+            return false;
+          }
+        }
+
+        if (filter.createdAfter) {
+          if (invite.createdAt <= filter.createdAfter) {
+            return false;
+          }
+        }
+
+        if (filter.isClaimed !== undefined) {
+          if (invite.claimedAt === null && filter.isClaimed) {
+            return false;
+          }
+          if (invite.claimedAt !== null && !filter.isClaimed) {
+            return false;
+          }
+        }
+
+        if (filter.isExpired) {
+          if (invite.expiresAt && invite.expiresAt < new Date()) {
+            return false;
+          }
+        }
+
+        if (filter.email) {
+          if (invite.email !== filter.email) {
+            return false;
+          }
+        }
+
+        if (filter.proposalPk) {
+          const inviteIds = this.coProposerClaims
+            .filter((claim) => claim.proposalPk === filter.proposalPk)
+            .map((claim) => claim.inviteId);
+
+          if (!inviteIds.includes(invite.id)) {
+            return false;
+          }
+        }
+
+        return true;
+      });
+
+      resolve(filteredInvites);
+    });
   }
 }

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

@@ -24,6 +24,7 @@ export let dummyProposal: Proposal;
 export let dummyProposalView: ProposalView;
 export let dummyProposalSubmitted: Proposal;
 export let dummyProposalWithNotActiveCall: Proposal;
+export let dummyProposalWithoutInvitation: Proposal;
 
 let allProposals: Proposal[];
 
@@ -165,6 +166,12 @@ export class ProposalDataSourceMock implements ProposalDataSource {
       callId: 2,
     });
 
+    dummyProposalWithoutInvitation = dummyProposalFactory({
+      primaryKey: 4,
+      title: 'Proposal without invitation',
+      proposalId: 'no-invite',
+    });
+
     dummyProposalView = new ProposalView(
       1,
       '',
@@ -212,6 +219,7 @@ export class ProposalDataSourceMock implements ProposalDataSource {
       dummyProposal,
       dummyProposalSubmitted,
       dummyProposalWithNotActiveCall,
+      dummyProposalWithoutInvitation,
     ];
 
     this.proposalsUpdated = [];
@@ -409,7 +417,7 @@ export class ProposalDataSourceMock implements ProposalDataSource {
   }
 
   async getProposalById(proposalId: string): Promise<Proposal | null> {
-    return dummyProposal.proposalId === proposalId ? dummyProposal : null;
+    return allProposals.find((p) => p.proposalId === proposalId) || null;
   }
 
   async doesProposalNeedTechReview(proposalPk: number): Promise<boolean> {

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

@@ -1,7 +1,11 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 
 import { Invite } from '../../models/Invite';
-import { GetInvitesFilter, InviteDataSource } from '../InviteDataSource';
+import {
+  GetCoProposerInvitesFilter,
+  GetInvitesFilter,
+  InviteDataSource,
+} from '../InviteDataSource';
 import database from './database';
 import { createInviteObject, InviteRecord } from './records';
 export default class PostgresInviteDataSource implements InviteDataSource {
@@ -101,13 +105,13 @@ export default class PostgresInviteDataSource implements InviteDataSource {
         }
 
         if (filter.email) {
-          query.where('email', filter.email);
+          query.whereRaw('lower(email) = ?', filter.email.toLowerCase());
         }
       })
       .then((invites: InviteRecord[]) => invites.map(createInviteObject));
   }
 
-  getProposalInvites(filter: GetInvitesFilter): Promise<Invite[]> {
+  getCoProposerInvites(filter: GetCoProposerInvitesFilter): Promise<Invite[]> {
     return database
       .select('*')
       .from('invites')
@@ -138,7 +142,11 @@ export default class PostgresInviteDataSource implements InviteDataSource {
         }
 
         if (filter.email) {
-          query.where('email', filter.email);
+          query.whereRaw('lower(email) = ?', filter.email.toLowerCase());
+        }
+
+        if (filter.proposalPk) {
+          query.where('co_proposer_claims.proposal_pk', filter.proposalPk);
         }
       })
       .then((invites: InviteRecord[]) => invites.map(createInviteObject));

apps/backend/src/mutations/InviteMutations.spec.ts

@@ -47,27 +47,27 @@ describe('Test Invite Mutations', () => {
 
   test('A user can accept valid invite code', () => {
     return expect(
-      inviteMutations.accept(dummyUserWithRole, 'invite-code')
+      inviteMutations.acceptWithCode(dummyUserWithRole, 'invite-code')
     ).resolves.toBeInstanceOf(Invite);
   });
 
   test('A user can not accept invalid code', () => {
     return expect(
-      inviteMutations.accept(dummyUserWithRole, 'invalid-invite-code')
+      inviteMutations.acceptWithCode(dummyUserWithRole, 'invalid-invite-code')
     ).resolves.toHaveProperty('reason', 'Invite code not found');
   });
 
   test('A user can not accept code twice', async () => {
-    await inviteMutations.accept(dummyUserWithRole, 'invite-code');
+    await inviteMutations.acceptWithCode(dummyUserWithRole, 'invite-code');
 
     return expect(
-      inviteMutations.accept(dummyUserWithRole, 'invite-code')
+      inviteMutations.acceptWithCode(dummyUserWithRole, 'invite-code')
     ).resolves.toHaveProperty('reason', 'Invite code already claimed');
   });
 
   test('A user can not accept expired code', async () => {
     return expect(
-      inviteMutations.accept(dummyUserWithRole, 'expired-invite-code')
+      inviteMutations.acceptWithCode(dummyUserWithRole, 'expired-invite-code')
     ).resolves.toHaveProperty('reason', 'Invite code has expired');
   });
 
@@ -375,4 +375,43 @@ describe('Test Invite Mutations', () => {
       'user-office-registration-invitation-co-proposer'
     );
   });
+
+  test('A user can accept valid co proposer invite without code', async () => {
+    const invite = await inviteMutations.acceptCoProposerInvite(
+      { ...dummyUserWithRole, email: 'test2@example.com' },
+      'shortCode'
+    );
+
+    expect(invite).toBeInstanceOf(Invite);
+  });
+
+  test('A user can not accept co proposer invite without code if email does not match', async () => {
+    const invite = await inviteMutations.acceptCoProposerInvite(
+      { ...dummyUserWithRole, email: 'mismatch@example.com' },
+      'shortCode'
+    );
+
+    expect(invite).toBeInstanceOf(Rejection);
+    expect((invite as Rejection).reason).toBe('Invite not found');
+  });
+
+  test('A user can not accept co proposer invite without code if proposal is invalid', async () => {
+    const invite = await inviteMutations.acceptCoProposerInvite(
+      dummyUserWithRole,
+      'invalid-short-code'
+    );
+
+    expect(invite).toBeInstanceOf(Rejection);
+    expect((invite as Rejection).reason).toBe('Proposal not found');
+  });
+
+  test('A user cannot accept a non existing co proposer invite for an existing proposal without code', async () => {
+    const invite = await inviteMutations.acceptCoProposerInvite(
+      dummyUserWithRole,
+      'no-invite'
+    );
+
+    expect(invite).toBeInstanceOf(Rejection);
+    expect((invite as Rejection).reason).toBe('Invite not found');
+  });
 });

apps/backend/src/mutations/InviteMutations.ts

@@ -20,7 +20,7 @@ import { ApplicationEvent } from '../events/applicationEvents';
 import { Event } from '../events/event.enum';
 import { Invite } from '../models/Invite';
 import { rejection, Rejection } from '../models/Rejection';
-import { Role } from '../models/Role';
+import { Role, Roles } from '../models/Role';
 import { SettingsId } from '../models/Settings';
 import { UserRole, UserWithRole } from '../models/User';
 import { SetCoProposerInvitesInput } from '../resolvers/mutations/SetCoProposerInvitesMutation';
@@ -53,7 +53,7 @@ export default class InviteMutations {
   ) {}
 
   @Authorized()
-  async accept(
+  async acceptWithCode(
     agent: UserWithRole | null,
     code: string
   ): Promise<Invite | Rejection> {
@@ -82,6 +82,37 @@ export default class InviteMutations {
     return updatedInvite;
   }
 
+  @Authorized([Roles.USER])
+  async acceptCoProposerInvite(agent: UserWithRole | null, proposalId: string) {
+    const proposal = await this.proposalDataSource.getProposalById(proposalId);
+    if (!proposal) {
+      return rejection('Proposal not found', { proposalId });
+    }
+    if (!agent) {
+      return rejection('User not found', { proposalId });
+    }
+    const [invite] = await this.inviteDataSource.getCoProposerInvites({
+      proposalPk: proposal.primaryKey,
+      email: agent.email,
+      isClaimed: false,
+      isExpired: false,
+    });
+    if (!invite) {
+      return rejection('Invite not found', { proposalId });
+    }
+
+    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);
+
+    return updatedInvite;
+  }
+
   private async getCoProposerInvites(proposalPk: number): Promise<Invite[]> {
     const existingClaims =
       await this.coProposerClaimDataSource.findByProposalPk(proposalPk);

apps/backend/src/queries/InviteQueries.ts

@@ -59,12 +59,12 @@ export default class InviteQueries {
   }
 
   @Authorized()
-  async getProposalInvites(agent: UserWithRole | null) {
+  async getPendingCoProposerInvites(agent: UserWithRole | null) {
     if (!agent) {
       return [];
     }
 
-    const invites = await this.dataSource.getProposalInvites({
+    const invites = await this.dataSource.getCoProposerInvites({
       email: agent.email,
       isClaimed: false,
       isExpired: false,

apps/backend/src/resolvers/mutations/AcceptCoProposerInviteMutation.ts

@@ -0,0 +1,17 @@
+import { Arg, Ctx, Mutation } from 'type-graphql';
+
+import { ResolverContext } from '../../context';
+import { Invite } from '../types/Invite';
+
+export class AcceptCoProposerInviteMutation {
+  @Mutation(() => Invite)
+  acceptCoProposerInvite(
+    @Arg('proposalId') proposalId: string,
+    @Ctx() context: ResolverContext
+  ) {
+    return context.mutations.invite.acceptCoProposerInvite(
+      context.user,
+      proposalId
+    );
+  }
+}