[PKP-LIB][main] #10630 Add support for add existing user to a context

api/v1/invitations/InvitationController.php

@@ -30,33 +30,35 @@
 use PKP\invitation\core\Invitation;
 use PKP\invitation\core\ReceiveInvitationController;
 use PKP\invitation\core\traits\HasMailable;
-use PKP\invitation\invitations\userRoleAssignment\resources\UserRoleAssignmentInviteResource;
-use PKP\invitation\invitations\userRoleAssignment\rules\EmailMustNotExistRule;
 use PKP\invitation\invitations\userRoleAssignment\rules\UserMustExistRule;
 use PKP\invitation\models\InvitationModel;
-use PKP\security\authorization\UserRolesRequiredPolicy;
 use PKP\security\Role;
 use PKP\validation\ValidatorFactory;
-use Validator;
 
 class InvitationController extends PKPBaseController
 {
     public const PARAM_TYPE = 'type';
     public const PARAM_ID = 'invitationId';
     public const PARAM_KEY = 'key';
 
-    public $notNeedAPIHandler = [
-        'getMany',
+    public $actionsInvite = [
+        'get',
+        'populate',
+        'invite',
         'getMailable',
-        'cancel',
     ];
 
-    public $noParamRequired = [
-        'getMany',
+    public $actionsReceive = [
+        'receive',
+        'finalize',
+        'refine',
+        'decline',
+        'cancel',
     ];
 
     public $requiresType = [
         'add',
+        'getMany',
     ];
 
     public $requiresOnlyId = [
@@ -124,7 +126,7 @@ public function getGroupRoutes(): void
             ]),
         ])->group(function () {
 
-            Route::get('', $this->getMany(...))
+            Route::get('{type}', $this->getMany(...))
                 ->name('invitation.getMany');
 
             // Get By Id Methods
@@ -207,45 +209,39 @@ public function authorize(PKPRequest $request, array &$args, array $roleAssignme
             $invitation = Repo::invitation()->getByIdAndKey($invitationId, $invitationKey);
         }
 
-        if ($actionName == 'getMany') {
-            $this->addPolicy(new UserRolesRequiredPolicy($request), true);
-        } else {
-            if (!isset($invitation)) {
-                throw new Exception('Invitation could not be created');
-            }
-
-            $this->invitation = $invitation;
+        if (!isset($invitation)) {
+            throw new Exception('Invitation could not be created');
+        }
 
-            if (!in_array($actionName, $this->notNeedAPIHandler)) {
-                if (!$this->invitation instanceof IApiHandleable) {
-                    throw new Exception('This invitation does not support API handling');
-                }
+        $this->invitation = $invitation;
 
-                if (in_array($actionName, $this->requiresOnlyId) && $this->invitation->getStatus() != InvitationStatus::INITIALIZED) {
-                    throw new Exception('This action is not allowed');
-                }
+        if (!$this->invitation instanceof IApiHandleable) {
+            throw new Exception('This invitation does not support API handling');
+        }
 
-                if (in_array($actionName, $this->requiresIdAndKey) && $this->invitation->getStatus() != InvitationStatus::PENDING) {
-                    throw new Exception('This action is not allowed');
-                }
+        if (in_array($actionName, $this->actionsInvite) && $this->invitation->getStatus() != InvitationStatus::INITIALIZED) {
+            throw new Exception('This action is not allowed');
+        }
 
-                $this->createInvitationHandler = $invitation->getCreateInvitationController($this->invitation);
-                $this->receiveInvitationHandler = $invitation->getReceiveInvitationController($this->invitation);
+        if (in_array($actionName, $this->actionsReceive) && $this->invitation->getStatus() != InvitationStatus::PENDING) {
+            throw new Exception('This action is not allowed');
+        }
 
-                if (!isset($this->createInvitationHandler) || !isset($this->receiveInvitationHandler)) {
-                    throw new Exception('This invitation should have defined its API handling code');
-                }
+        $this->createInvitationHandler = $invitation->getCreateInvitationController($this->invitation);
+        $this->receiveInvitationHandler = $invitation->getReceiveInvitationController($this->invitation);
 
-                $this->selectedHandler = $this->getHandlerForAction($actionName);
+        if (!isset($this->createInvitationHandler) || !isset($this->receiveInvitationHandler)) {
+            throw new Exception('This invitation should have defined its API handling code');
+        }
 
-                if (!method_exists($this->selectedHandler, $actionName)) {
-                    throw new Exception("The handler does not support the method: {$actionName}");
-                }
+        $this->selectedHandler = $this->getHandlerForAction($actionName);
 
-                $this->selectedHandler->authorize($this, $request, $args, $roleAssignments);
-            }
+        if (!method_exists($this->selectedHandler, $actionName)) {
+            throw new Exception("The handler does not support the method: {$actionName}");
         }
 
+        $this->selectedHandler->authorize($this, $request, $args, $roleAssignments);
+
         return parent::authorize($request, $args, $roleAssignments);
     }
 
@@ -269,7 +265,6 @@ public function add(Request $illuminateRequest): JsonResponse
                 'nullable',
                 'required_without:userId',
                 'email',
-                new EmailMustNotExistRule($payload['inviteeEmail']),
             ]
         ];
 
@@ -338,63 +333,53 @@ public function getMany(Request $illuminateRequest): JsonResponse
         $context = $illuminateRequest->attributes->get('context'); /** @var \PKP\context\Context $context */
         $invitationType = $this->getParameter(self::PARAM_TYPE);
 
-        $count = $illuminateRequest->query('count', 10); // default count to 10 if not provided
-        $offset = $illuminateRequest->query('offset', 0); // default offset to 0 if not provided
-
+        // Build the common query
         $query = InvitationModel::query()
-            ->when($invitationType, function ($query, $invitationType) {
-                return $query->byType($invitationType);
-            })
-            ->when($context, function ($query, $context) {
-                return $query->byContextId($context->getId());
-            })
+            ->when($invitationType, fn($query) => $query->byType($invitationType))
+            ->when($context, fn($query) => $query->byContextId($context->getId()))
             ->stillActive();
-
-        $maxCount = $query->count();
-
-        $invitations = $query->skip($offset)
-            ->take($count)
-            ->get();
 
-        $finalCollection = $invitations->map(function ($invitation) {
-            $specificInvitation = Repo::invitation()->getById($invitation->id);
-            return $specificInvitation;
-        });
+        // Delegate to the specific handler for additional logic
+        $specificData = $this->selectedHandler->getMany($illuminateRequest, $query);
 
         return response()->json([
-            'itemsMax' => $maxCount,
-            'items' => (UserRoleAssignmentInviteResource::collection($finalCollection)),
+            'itemsMax' => $query->count(),
+            'items' => $specificData,
         ], Response::HTTP_OK);
     }
 
-    public function getMailable(Request $illuminateRequest): JsonResponse
+    public function cancel(Request $illuminateRequest): JsonResponse
     {
-        if (in_array(HasMailable::class, class_uses($this->invitation))) {
-            $mailable = $this->invitation->getMailable();
-
+        if (!$this->invitation->isPending()) {
             return response()->json([
-                'mailable' => $mailable,
-            ], Response::HTTP_OK);
+                'error' => __('invitation.api.error.invitationCantBeCanceled'),
+            ], Response::HTTP_BAD_REQUEST);
         }
 
-        return response()->json([
-            'error' => __('invitation.api.error.invitationTypeNotHasMailable'),
-        ], Response::HTTP_BAD_REQUEST);
+        try {
+            return $this->selectedHandler->cancel();
+        } catch (\Exception $e) {
+            return response()->json([
+                'error' => $e->getMessage()
+            ], Response::HTTP_INTERNAL_SERVER_ERROR);
+        }
     }
 
-    public function cancel(Request $illuminateRequest): JsonResponse
+    public function getMailable(Request $illuminateRequest): JsonResponse
     {
-        if (!$this->invitation->isPending()) {
+        // Ensure the invitation supports mailables
+        if (!in_array(HasMailable::class, class_uses($this->invitation))) {
             return response()->json([
-                'error' => __('invitation.api.error.invitationCantBeCanceled'),
+                'error' => __('invitation.api.error.invitationTypeNotHasMailable'),
             ], Response::HTTP_BAD_REQUEST);
         }
 
-        $this->invitation->updateStatus(InvitationStatus::CANCELLED);
-
-        return response()->json(
-            (new UserRoleAssignmentInviteResource($this->invitation))->toArray($illuminateRequest), 
-            Response::HTTP_OK
-        );
+        try {
+            return $this->selectedHandler->getMailable();
+        } catch (\Exception $e) {
+            return response()->json([
+                'error' => $e->getMessage(),
+            ], Response::HTTP_INTERNAL_SERVER_ERROR);
+        }
     }
 }

classes/invitation/core/CreateInvitationController.php

@@ -14,12 +14,13 @@
 
 namespace PKP\invitation\core;
 
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Routing\Controller;
+use Illuminate\Support\Collection;
 use PKP\core\PKPBaseController;
 use PKP\core\PKPRequest;
-use PKP\invitation\core\Invitation;
 
 abstract class CreateInvitationController extends Controller
 {
@@ -30,4 +31,8 @@ abstract public function add(Request $illuminateRequest): JsonResponse;
     abstract public function populate(Request $illuminateRequest): JsonResponse;
     abstract public function invite(Request $illuminateRequest): JsonResponse;
     abstract public function get(Request $illuminateRequest): JsonResponse;
+
+    abstract public function cancel(): JsonResponse;
+    abstract public function getMailable(): JsonResponse;
+    abstract public function getMany(Request $illuminateRequest, Builder $query): Collection;
 }

classes/invitation/core/Invitation.php

@@ -236,11 +236,7 @@ public function updatePayload(?ValidationContext $validationContext = null): ?bo
             }
         }
 
-        // Update the payload attribute on the invitation model
-        $this->invitationModel->setAttribute('payload', $currentPayloadArray);
-
-        // Save the updated invitation model to the database
-        return $this->invitationModel->save();
+        return $this->invitationModel->update(['payload' => $currentPayloadArray]);
     }
 
     public function getNotAccessibleBeforeInvite(): array
@@ -351,6 +347,15 @@ public function getExistingUser(): ?User
         return Repo::user()->get($this->invitationModel->userId);
     }
 
+    public function getExistingUserByEmail(): ?User
+    {
+        if (!isset($this->invitationModel->email)) {
+            return null;
+        }
+
+        return Repo::user()->getByEmail($this->invitationModel->email);
+    }
+
     public function getContext(): ?Context
     {
         if (!isset($this->invitationModel->contextId)) {
@@ -480,10 +485,10 @@ protected function array_diff_assoc_recursive($array1, $array2)
         return $difference;
     }
 
-    public function updateStatus(InvitationStatus $status): void
+    public function updateStatus(InvitationStatus $status): bool
     {
         $this->invitationModel->status = $status;
-        $this->invitationModel->save();
+        return $this->invitationModel->save();
     }
 
     public function isPending(): bool

classes/invitation/core/InvitationActionRedirectController.php

@@ -18,16 +18,20 @@
 use Illuminate\Routing\Controller;
 use PKP\invitation\core\enums\InvitationAction;
 
+/**
+ * @template TInvitation of Invitation
+ */
 abstract class InvitationActionRedirectController extends Controller
 {
+    /** @var TInvitation */
     protected Invitation $invitation;
 
     public function __construct(Invitation $invitation)
     {
         $this->invitation = $invitation;
     }
 
-    abstract public function preRedirectActions(InvitationAction $action);
+    abstract public function preRedirectActions(InvitationAction $action): void;
 
     abstract public function acceptHandle(Request $request): void;
     abstract public function declineHandle(Request $request): void;

classes/invitation/invitations/changeProfileEmail/handlers/ChangeProfileEmailInviteRedirectController.php

@@ -79,7 +79,7 @@ public function declineHandle(Request $request): void
         $request->redirectUrl($url);
     }
 
-    public function preRedirectActions(InvitationAction $action)
+    public function preRedirectActions(InvitationAction $action): void
     {
         if ($action == InvitationAction::ACCEPT) {
             $this->getInvitation()->finalize();

classes/invitation/invitations/registrationAccess/handlers/RegistrationAccessInviteRedirectController.php

@@ -107,7 +107,7 @@ public function declineHandle(Request $request): void
         $request->redirectUrl($url);
     }
 
-    public function preRedirectActions(InvitationAction $action)
+    public function preRedirectActions(InvitationAction $action): void
     {
         if ($action == InvitationAction::ACCEPT) {
             $this->getInvitation()->finalize();

classes/invitation/invitations/reviewerAccess/handlers/ReviewerAccessInviteRedirectController.php

@@ -85,7 +85,7 @@ public function declineHandle(Request $request): void
         $request->redirectUrl($url);
     }
 
-    public function preRedirectActions(InvitationAction $action)
+    public function preRedirectActions(InvitationAction $action): void
     {
         return;
     }

classes/invitation/invitations/userRoleAssignment/UserRoleAssignmentInvite.php

@@ -166,6 +166,11 @@ public function getValidationRules(ValidationContext $validationContext = Valida
                 $this->getPayload()->userGroupsToAdd
             );
             $invitationValidationRules[Invitation::VALIDATION_RULE_GENERIC][] = new UserMustExistRule($this->getUserId());
+        }
+
+        if (
+            $validationContext === ValidationContext::VALIDATION_CONTEXT_FINALIZE
+        ) {
             $invitationValidationRules[Invitation::VALIDATION_RULE_GENERIC][] = new EmailMustNotExistRule($this->getEmail());
         }
 
@@ -207,5 +212,25 @@ public function updatePayload(?ValidationContext $validationContext = null): ?bo
         // Call the parent updatePayload method to continue the normal update process
         return parent::updatePayload($validationContext);
     }
-
+
+    public function changeInvitationUserIdUsingUserEmail(): ?bool
+    {
+        $invitationUserByEmail = $this->getExistingUserByEmail();
+
+        if (!isset($this->invitationModel->userId) && isset($invitationUserByEmail)) {
+            $this->invitationModel->userId = $invitationUserByEmail->getId();
+            $this->invitationModel->email = null;
+
+            $result =  $this->invitationModel->save();
+
+            if ($result) {
+                $this->getPayload()->shouldUseInviteData = true;
+
+                return $this->updatePayload();
+            }
+        }
+
+        return null;
+    }
+
 }