fix: allow collab claim creation when at max primary claims (RetroAchievements#4772)

https://discord.com/channels/310192285306454017/310195377993416714/1492957030934122791

Developers are currently prevented from creating new collab claims when
they have all 4 primary claims used.

Author: wescopeland

app/Policies/AchievementSetClaimPolicy.php

@@ -62,6 +62,17 @@ public function create(User $user, ?Game $game = null): bool
             return true;
         }
 
+        // If another user has a primary claim, collaboration claims don't count against the cap.
+        $activePrimaryClaimByOtherUser = $game->achievementSetClaims()
+            ->active()
+            ->primaryClaim()
+            ->where('user_id', '!=', $user->id)
+            ->exists();
+
+        if ($activePrimaryClaimByOtherUser) {
+            return true;
+        }
+
         // Determine max claims based on role.
         $maxClaims = AchievementSetClaim::getMaxClaimsForUser($user);
 

resources/js/features/games/components/AchievementSetEmptyState/ClaimActionButton/ClaimActionButton.test.tsx

@@ -121,6 +121,25 @@ describe('Component: ClaimActionButton', () => {
     expect(screen.getByRole('button', { name: /collaborate/i })).toBeVisible();
   });
 
+  it('given the user has no claims remaining but can collaborate, shows the collaboration claim button', () => {
+    // ARRANGE
+    render(<ClaimActionButton />, {
+      pageProps: {
+        auth: { user: createAuthenticatedUser({ roles: ['developer'] }) },
+        backingGame: createGame({ forumTopicId: 12345 }),
+        claimData: createGamePageClaimData({
+          numClaimsRemaining: 0,
+          numUnresolvedTickets: 0,
+          wouldBeCollaboration: true,
+        }),
+      },
+    });
+
+    // ASSERT
+    expect(screen.getByRole('button', { name: /collaborate/i })).toBeVisible();
+    expect(screen.queryByText(/used all your achievement set claims/i)).not.toBeInTheDocument();
+  });
+
   it('given the user can make a new claim and all conditions are met, shows the real claim button', () => {
     // ARRANGE
     render(<ClaimActionButton />, {

resources/js/features/games/components/AchievementSetEmptyState/ClaimActionButton/ClaimActionButton.tsx

@@ -11,6 +11,7 @@ import {
 import { usePageProps } from '@/common/hooks/usePageProps';
 import { cn } from '@/common/utils/cn';
 import { ClaimConfirmationDialog } from '@/features/games/components/ClaimConfirmationDialog';
+import { getCanCreateClaim } from '@/features/games/utils/getCanCreateClaim';
 
 export const ClaimActionButton: FC = () => {
   const { auth, backingGame, claimData } = usePageProps<App.Platform.Data.GameShowPageProps>();
@@ -42,7 +43,7 @@ export const ClaimActionButton: FC = () => {
     return null;
   }
 
-  if (!claimData?.numClaimsRemaining && !claimData?.isSoleAuthor) {
+  if (!getCanCreateClaim(claimData)) {
     return (
       <BaseTooltip>
         <BaseTooltipTrigger>
@@ -68,7 +69,7 @@ export const ClaimActionButton: FC = () => {
     );
   }
 
-  if (claimData.wouldBeCollaboration) {
+  if (claimData?.wouldBeCollaboration) {
     return (
       <ClaimConfirmationDialog
         data-testid="claim-button"

resources/js/features/games/components/GameSidebarFullWidthButtons/SidebarContributeLinks/SidebarDevelopmentSection/SidebarClaimButtons/SidebarClaimButtons.test.tsx

@@ -29,6 +29,23 @@ describe('Component: SidebarClaimButtons', () => {
     expect(container).toBeTruthy();
   });
 
+  it('given the user does not have a claim role, does not show the create claim button', () => {
+    // ARRANGE
+    render(<SidebarClaimButtons />, {
+      pageProps: {
+        achievementSetClaims: [],
+        auth: { user: createAuthenticatedUser({ roles: [] }) },
+        backingGame: createGame(),
+        claimData: createGamePageClaimData({ numClaimsRemaining: 1, userClaim: null }),
+        game: createGame({ gameAchievementSets: [] }),
+        targetAchievementSetId: null,
+      },
+    });
+
+    // ASSERT
+    expect(screen.queryByRole('button', { name: /create new claim/i })).not.toBeInTheDocument();
+  });
+
   it('given there are claims in review, does not render anything', () => {
     // ARRANGE
     render(<SidebarClaimButtons />, {
@@ -137,6 +154,27 @@ describe('Component: SidebarClaimButtons', () => {
     expect(screen.getByRole('button', { name: /create new claim/i })).toBeVisible();
   });
 
+  it('given the user has no claims remaining but can collaborate, shows the collaboration claim button', () => {
+    // ARRANGE
+    render(<SidebarClaimButtons />, {
+      pageProps: {
+        achievementSetClaims: [],
+        auth: { user: createAuthenticatedUser({ roles: ['developer'] }) },
+        backingGame: createGame(),
+        claimData: createGamePageClaimData({
+          numClaimsRemaining: 0,
+          userClaim: null,
+          wouldBeCollaboration: true,
+        }),
+        game: createGame({ gameAchievementSets: [] }),
+        targetAchievementSetId: null,
+      },
+    });
+
+    // ASSERT
+    expect(screen.getByRole('button', { name: /create new collaboration claim/i })).toBeVisible();
+  });
+
   it('given the user has a completable claim, shows the complete claim button', () => {
     // ARRANGE
     render(<SidebarClaimButtons />, {

resources/js/features/games/components/GameSidebarFullWidthButtons/SidebarContributeLinks/SidebarDevelopmentSection/SidebarClaimButtons/SidebarClaimButtons.tsx

@@ -5,13 +5,16 @@ import { LuFlagTriangleRight } from 'react-icons/lu';
 import { PlayableSidebarButton } from '@/common/components/PlayableSidebarButton';
 import { usePageProps } from '@/common/hooks/usePageProps';
 import { ClaimConfirmationDialog } from '@/features/games/components/ClaimConfirmationDialog';
+import { useCanShowCreateClaimButton } from '@/features/games/hooks/useCanShowCreateClaimButton';
 import { getAllPageAchievements } from '@/features/games/utils/getAllPageAchievements';
 
 export const SidebarClaimButtons: FC = () => {
-  const { achievementSetClaims, auth, backingGame, claimData, game, targetAchievementSetId } =
+  const { achievementSetClaims, backingGame, claimData, game, targetAchievementSetId } =
     usePageProps<App.Platform.Data.GameShowPageProps>();
   const { t } = useTranslation();
 
+  const canShowCreateClaimButton = useCanShowCreateClaimButton();
+
   const areAnyClaimsInReview = achievementSetClaims.some((c) => c.status === 'in_review');
   if (areAnyClaimsInReview) {
     return null;
@@ -23,20 +26,6 @@ export const SidebarClaimButtons: FC = () => {
   );
   const wouldBeRevisionClaim = allPageAchievements.length > 0;
 
-  const hasClaimRole =
-    auth?.user.roles.includes('developer-junior') || auth?.user.roles.includes('developer');
-
-  const isJuniorDev = auth?.user.roles.includes('developer-junior');
-
-  // Junior developers can only create claims on games with forum topics.
-  const isBlockedByMissingForumTopic = isJuniorDev && !backingGame.forumTopicId;
-
-  // `claimData?.isSoleAuthor` means devs can reclaim their own sets to fix something.
-  const hasClaimsRemaining = claimData?.numClaimsRemaining || claimData?.isSoleAuthor;
-
-  const canShowCreateClaimButton =
-    hasClaimRole && hasClaimsRemaining && !claimData.userClaim && !isBlockedByMissingForumTopic;
-
   return (
     <>
       {canShowCreateClaimButton ? (

resources/js/features/games/hooks/useCanShowCreateClaimButton.ts

@@ -0,0 +1,26 @@
+import { usePageProps } from '@/common/hooks/usePageProps';
+import { UserRole } from '@/common/utils/generatedAppConstants';
+
+import { getCanCreateClaim } from '../utils/getCanCreateClaim';
+
+export function useCanShowCreateClaimButton(): boolean {
+  const { auth, backingGame, claimData } = usePageProps<App.Platform.Data.GameShowPageProps>();
+
+  const user = auth?.user;
+  if (!user || claimData?.userClaim) {
+    return false;
+  }
+
+  const isJuniorDev = user.roles.includes(UserRole.DEVELOPER_JUNIOR);
+  const hasClaimRole = isJuniorDev || user.roles.includes(UserRole.DEVELOPER);
+  if (!hasClaimRole) {
+    return false;
+  }
+
+  // Junior devs can only create claims on games with official forum topics.
+  if (isJuniorDev && !backingGame.forumTopicId) {
+    return false;
+  }
+
+  return getCanCreateClaim(claimData);
+}

resources/js/features/games/utils/getCanCreateClaim.ts

@@ -0,0 +1,6 @@
+export function getCanCreateClaim(claimData: App.Platform.Data.GamePageClaimData | null): boolean {
+  const hasPrimarySlotAvailable = (claimData?.numClaimsRemaining ?? 0) > 0;
+  const canCreateWithoutPrimarySlot = claimData?.isSoleAuthor || claimData?.wouldBeCollaboration;
+
+  return hasPrimarySlotAvailable || !!canCreateWithoutPrimarySlot;
+}

tests/Feature/Community/Controllers/AchievementSetClaimControllerTest.php

@@ -490,6 +490,72 @@ public function testCollaborationClaimAndPrimaryDrop(): void
         $this->assertEquals(0, $collabClaim->extensions_count);
     }
 
+    public function testCollaborationClaimCanBeCreatedWhenDeveloperHasMaxPrimaryClaims(): void
+    {
+        $this->seed(RolesTableSeeder::class);
+
+        /** @var User $primaryDeveloper */
+        $primaryDeveloper = User::factory()->create();
+        $primaryDeveloper->assignRole(Role::DEVELOPER);
+
+        /** @var User $collaborator */
+        $collaborator = User::factory()->create();
+        $collaborator->assignRole(Role::DEVELOPER);
+
+        Forum::factory()->create(['id' => 10, 'title' => 'Default']);
+
+        /** @var Game $targetGame */
+        $targetGame = $this->seedGame(withHash: false);
+
+        // another developer already owns the active primary claim on the target game
+        $primaryClaimDate = Carbon::now()->startOfSecond();
+        Carbon::setTestNow($primaryClaimDate);
+
+        $this->actingAs($primaryDeveloper)->postJson(route('achievement-set-claim.create', $targetGame->id));
+        $targetGame->refresh();
+
+        // fill the collaborator's four primary claim slots
+        for ($i = 0; $i < 4; $i++) {
+            /** @var Game $claimedGame */
+            $claimedGame = $this->seedGame(withHash: false);
+            $claimedGame->forum_topic_id = $targetGame->forum_topic_id;
+            $claimedGame->save();
+
+            Carbon::setTestNow($primaryClaimDate->clone()->addHours($i + 1));
+            Session::flush();
+
+            $this->actingAs($collaborator)->postJson(route('achievement-set-claim.create', $claimedGame->id));
+        }
+
+        // with no primary slots remaining, the collaborator can still join this claimed game
+        $collaborationDate = $primaryClaimDate->clone()->addHours(5);
+        Carbon::setTestNow($collaborationDate);
+        Session::flush();
+
+        $response = $this->actingAs($collaborator)->postJson(route('achievement-set-claim.create', $targetGame->id));
+
+        $response->assertStatus(302);
+        $response->assertRedirect('/');
+        $response->assertSessionHas('success', 'Claim created successfully');
+
+        $collabClaim = $targetGame->achievementSetClaims()->where('user_id', $collaborator->id)->first();
+        $this->assertNotNull($collabClaim);
+        $this->assertEquals($collaborator->id, $collabClaim->user_id);
+        $this->assertEquals($targetGame->id, $collabClaim->game_id);
+        $this->assertEquals(ClaimType::Collaboration, $collabClaim->claim_type);
+        $this->assertEquals(ClaimSetType::NewSet, $collabClaim->set_type);
+        $this->assertEquals(ClaimStatus::Active, $collabClaim->status);
+        $this->assertEquals(ClaimSpecial::None, $collabClaim->special_type);
+        $this->assertEquals($collaborationDate->clone()->addMonths(3), $collabClaim->finished_at);
+
+        $activePrimaryClaims = $collaborator->achievementSetClaims()
+            ->active()
+            ->primaryClaim()
+            ->count();
+
+        $this->assertEquals(4, $activePrimaryClaims);
+    }
+
     public function testCollaborationClaimAndPrimaryComplete(): void
     {
         $this->seed(RolesTableSeeder::class);