FOUR-27904 Web entry Authenticated, is not working, when the start event is with anonymous

 ## Description
When the second task is set to authenticated and the start event to anonymous, we get an error message on the screen.

 ## Related tickets
https://processmaker.atlassian.net/browse/FOUR-27904

Author: gproly

ProcessMaker/AssignmentRules/ProcessManagerAssigned.php

@@ -20,39 +20,78 @@ class ProcessManagerAssigned implements AssignmentRuleInterface
      * The task is assigned to the Manager of the Process.
      *
      * It takes in count the process version of the request.
-     * If the process does not have assigned a Manager, it throws an exception.
+     * If the process does not have assigned a Manager, it returns null instead of throwing an exception.
      *
      * @param ActivityInterface $task
      * @param TokenInterface $token
      * @param Process $process
      * @param ProcessRequest $request
      * @return int|null
-     * @throws ThereIsNoProcessManagerAssignedException
      */
     public function getNextUser(ActivityInterface $task, TokenInterface $token, Process $process, ProcessRequest $request)
     {
         // review for multiple managers
         $managers = $request->processVersion->manager_id;
-        $user_id = $this->getNextManagerAssigned($managers, $task, $request);
-        if (!$user_id) {
-            throw new ThereIsNoProcessManagerAssignedException($task);
+
+        // Normalize: treat empty array as null
+        if (is_array($managers) && empty($managers)) {
+            $managers = null;
         }
 
+        $user_id = $this->getNextManagerAssigned($managers, $task, $request);
+
+        // Return null instead of throwing exception when no manager is found
+        // This allows the process to continue without crashing
         return $user_id;
     }
 
     /**
      * Get the round robin manager using a true round robin algorithm
      *
-     * @param array $managers
+     * @param array|int|null $managers Manager ID(s) - can be array, single int, or null
      * @param ActivityInterface $task
      * @param ProcessRequest $request
      * @return int|null
      */
     private function getNextManagerAssigned($managers, $task, $request)
     {
-        // Validate input
-        if (empty($managers) || !is_array($managers)) {
+        // Handle null case
+        if (is_null($managers)) {
+            return null;
+        }
+
+        // Convert single value to array for backward compatibility
+        if (!is_array($managers)) {
+            // If it's a valid integer, convert to array
+            if (is_numeric($managers) && $managers > 0) {
+                $managers = [(int) $managers];
+            } else {
+                // Invalid single value (0, empty string, 'undefined', etc.)
+                return null;
+            }
+        }
+
+        // Validate array is not empty
+        if (empty($managers)) {
+            return null;
+        }
+
+        // Filter out invalid values (null, 0, empty strings, 'undefined', false, etc.)
+        $managers = array_filter($managers, function ($id) {
+            // Only accept positive integers
+            if (!is_numeric($id)) {
+                return false;
+            }
+            $id = (int) $id;
+
+            return $id > 0;
+        });
+
+        // Re-index array after filtering
+        $managers = array_values($managers);
+
+        // Check if we have any valid managers after filtering
+        if (empty($managers)) {
             return null;
         }
 

ProcessMaker/Models/Process.php

@@ -694,13 +694,25 @@ private function checkAssignment(ProcessRequest $request, ActivityInterface $act
             if ($isSelfService && !$escalateToManager) {
                 return null;
             }
+            // Don't fallback to Process Manager for process_variable assignment when no users found
+            // This preserves the original behavior where invalid users result in no task assignment
+            if ($assignmentType === 'process_variable') {
+                return null;
+            }
             $rule = new ProcessManagerAssigned();
             if ($token === null) {
-                throw new ThereIsNoProcessManagerAssignedException($activity);
+                // Return null instead of throwing exception when no token is available
+                return null;
             }
             $user = $rule->getNextUser($activity, $token, $this, $request);
             if (!$user) {
-                throw new ThereIsNoProcessManagerAssignedException($activity);
+                // Log error when no manager is found, but don't throw exception
+                // This allows the process to continue without crashing
+                // but still records the issue for visibility
+                $exception = new ThereIsNoProcessManagerAssignedException($activity);
+                $request->logError($exception, $activity);
+
+                return null;
             }
             $user = User::find($user);
         }
@@ -808,6 +820,12 @@ private function getNextUserFromProcessVariable($activity, $token)
             $this->getConsolidatedUsers($groupId, $users);
         }
 
+        // If no valid users found, throw exception to prevent token creation
+        // This preserves the original behavior where invalid users result in no task
+        if (empty($users)) {
+            throw new TaskDoesNotHaveUsersException($activity->getId());
+        }
+
         return $this->getNextUserFromGroupAssignment($activity->getId(), $users);
     }