Merge branch 'develop' into bugfix/FOUR-27904

Author: gproly

ProcessMaker/Application.php

@@ -114,11 +114,4 @@ public function bootstrapWith(array $bootstrappers)
 
         return parent::bootstrapWith($bootstrappers);
     }
-
-    public function reactivateConsoleApp()
-    {
-        Container::setInstance($this);
-        $this->hasBeenBootstrapped = false;
-        $this->make(Kernel::class)->bootstrap();
-    }
 }

ProcessMaker/Console/Commands/HorizonListen.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace ProcessMaker\Console\Commands;
+
+use Illuminate\Queue\Console\ListenCommand as BaseCommand;
+
+// https://github.com/laravel/horizon/issues/624
+class HorizonListen extends BaseCommand
+{
+    /**
+     * The console command name.
+     *
+     * @var string
+     */
+    protected $signature = 'horizon:listen
+        {connection? : The name of connection}
+        {--name=default : The name of the worker}
+        {--delay=0 : The number of seconds to delay failed jobs (Deprecated)}
+        {--backoff=0 : The number of seconds to wait before retrying a job that encountered an uncaught exception}
+        {--max-time=0 : The maximum number of seconds the worker should run}
+        {--max-jobs=0 : The number of jobs to process before stopping}
+        {--force : Force the worker to run even in maintenance mode}
+        {--memory=128 : The memory limit in megabytes}
+        {--queue= : The queue to listen on}
+        {--sleep=3 : Number of seconds to sleep when no job is available}
+        {--timeout=60 : The number of seconds a child process can run}
+        {--tries=1 : Number of times to attempt a job before logging it failed}
+        {--supervisor= : The name of the supervisor the worker belongs to}
+        {--rest=0 : Number of seconds to rest between jobs}';
+
+    /**
+     * Indicates whether the command should be shown in the Artisan command list.
+     *
+     * @var bool
+     */
+    protected $hidden = true;
+
+    /**
+     * Execute the console command.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        if (config('horizon.fast_termination')) {
+            ignore_user_abort(true);
+        }
+
+        parent::handle();
+    }
+}

ProcessMaker/Contracts/ConditionalRedirectServiceInterface.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace ProcessMaker\Contracts;
+
+use ProcessMaker\Models\ProcessRequestToken;
+
+/**
+ * @see \ProcessMaker\Services\ConditionalRedirectService
+ * @package ProcessMaker\Contracts
+ */
+interface ConditionalRedirectServiceInterface
+{
+    /**
+     * Process a set of conditions and return the first that satisfies for an array of data.
+     *
+     * @param array $conditionalRedirect
+     * @param array $data
+     *
+     * @return array|null
+     */
+    public function resolve(array $conditionalRedirect, array $data): ?array;
+
+    /**
+     * Process a set of conditions and return the first that satisfies for a process request token.
+     *
+     * @param array $conditionalRedirect
+     * @param ProcessRequestToken $token
+     *
+     * @return array|null
+     */
+    public function resolveForToken(array $conditionalRedirect, ProcessRequestToken $token): ?array;
+}

ProcessMaker/Events/ProcessUpdated.php

@@ -26,6 +26,8 @@ class ProcessUpdated implements ShouldBroadcastNow
 
     public $activeTokens;
 
+    public $elementDestination;
+
     /**
      * Create a new event instance.
      *
@@ -41,6 +43,7 @@ public function __construct(ProcessRequest $processRequest, $event, TokenInterfa
         if ($token) {
             $this->tokenId = $token->getId();
             $this->elementType = $token->element_type;
+            $this->elementDestination = $token->elementDestination;
         }
     }
 

ProcessMaker/Models/MessageEventDefinition.php

@@ -48,6 +48,6 @@ public function execute(EventDefinitionInterface $event, FlowNodeInterface $targ
             }
         }
 
-        return $this;
+        return parent::execute($event, $target, $targetRequest, $token);
     }
 }

ProcessMaker/Models/ProcessRequestToken.php

@@ -13,6 +13,7 @@
 use Laravel\Scout\Searchable;
 use Log;
 use ProcessMaker\Casts\MillisecondsToDateCast;
+use ProcessMaker\Contracts\ConditionalRedirectServiceInterface;
 use ProcessMaker\Events\ActivityAssigned;
 use ProcessMaker\Events\ActivityReassignment;
 use ProcessMaker\Facades\WorkflowUserManager;
@@ -753,13 +754,35 @@ public function valueAliasStatus($value, $expression, $callback = null, User $us
 
         $value = mb_strtolower($value);
 
-        return function ($query) use ($value, $statusMap, $expression, $user) {
+        // Capture processManagerIds from the builder if it's available
+        // The $callback parameter is actually the $builder from ExtendedPMQL
+        $builder = $callback;
+        $processManagerIds = null;
+        if ($builder && method_exists($builder, 'getQuery')) {
+            $processManagerIds = $builder->getQuery()->processManagerIds ?? null;
+        }
+
+        return function ($query) use ($value, $statusMap, $expression, $user, $processManagerIds) {
+            // Also check in the current query in case it's available there
+            $currentProcessManagerIds = $query->getQuery()->processManagerIds ?? null;
+            $finalProcessManagerIds = $processManagerIds ?? $currentProcessManagerIds;
+            $isProcessManager = !empty($finalProcessManagerIds);
+
             if ($value === 'self service') {
                 if (!$user) {
                     $user = auth()->user();
                 }
 
-                if ($user) {
+                if ($isProcessManager) {
+                    // When processesIManage is active, include self-service tasks from managed processes
+                    $selfServiceTaskIds = ProcessRequestToken::select(['id'])
+                        ->whereIn('process_id', $finalProcessManagerIds)
+                        ->where('is_self_service', 1)
+                        ->whereNull('user_id')
+                        ->where('status', 'ACTIVE');
+
+                    $query->whereIn('process_request_tokens.id', $selfServiceTaskIds);
+                } elseif ($user) {
                     $taskIds = $user->availableSelfServiceTaskIds();
                     $query->whereIn('process_request_tokens.id', $taskIds);
                 } else {
@@ -1369,10 +1392,28 @@ public function reassign($toUserId, User $requestingUser)
      *
      * @return array|null Returns the destination URL.
      */
-    private function getElementDestination($elementDestinationType, $elementDestinationProp): ?array
+    private function getElementDestination($elementDestinationType, $elementDestinationProp, array $conditionalRedirectProp): ?array
     {
         $elementDestination = null;
 
+        if (!empty($conditionalRedirectProp['isEnabled']) && !empty($conditionalRedirectProp['conditions'])) {
+            $result = $this->evaluateConditionalRedirect(app(ConditionalRedirectServiceInterface::class), $conditionalRedirectProp);
+            if ($result) {
+                $elementDestinationType = $result['taskDestination']['value'];
+
+                $url = match ($elementDestinationType) {
+                    'customDashboard' => $result['customDashboard']['url'] ?? null,
+                    'externalURL' => $result['externalUrl'] ?? null,
+                    default => null,
+                };
+
+                $elementDestinationProp = [
+                    'value' => [
+                        'url' => $url,
+                    ],
+                ];
+            }
+        }
         switch ($elementDestinationType) {
             case 'anotherProcess':
             case 'customDashboard':
@@ -1416,6 +1457,15 @@ private function getElementDestination($elementDestinationType, $elementDestinat
         ];
     }
 
+    private function evaluateConditionalRedirect(ConditionalRedirectServiceInterface $conditionalRedirectService, array $conditionalRedirectProp): ?array
+    {
+        if (!$conditionalRedirectProp['isEnabled']) {
+            return null;
+        }
+
+        return $conditionalRedirectService->resolveForToken($conditionalRedirectProp['conditions'], $this);
+    }
+
     /**
      * Determines the destination URL based on the element destination type specified in the definition.
      *
@@ -1426,6 +1476,8 @@ public function getElementDestinationAttribute(): ?array
         $definition = $this->getDefinition();
         $elementDestinationProp = $definition['elementDestination'] ?? null;
         $elementDestinationType = null;
+        $conditionalRedirectProp = $definition['conditionalRedirect'] ?? '[]';
+        $conditionalRedirectProp = json_decode($conditionalRedirectProp, true);
 
         try {
             $elementDestinationProp = json_decode($elementDestinationProp, true);
@@ -1436,7 +1488,7 @@ public function getElementDestinationAttribute(): ?array
             return null;
         }
 
-        return $this->getElementDestination($elementDestinationType, $elementDestinationProp);
+        return $this->getElementDestination($elementDestinationType, $elementDestinationProp, $conditionalRedirectProp);
     }
 
     /**

ProcessMaker/Providers/ProcessMakerServiceProvider.php

@@ -12,6 +12,7 @@
 use Illuminate\Queue\Events\JobAttempted;
 use Illuminate\Queue\Events\JobProcessing;
 use Illuminate\Queue\Events\JobRetryRequested;
+use Illuminate\Queue\Listener;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Env;
 use Illuminate\Support\Facades;
@@ -22,9 +23,13 @@
 use Illuminate\Support\Facades\URL;
 use Laravel\Dusk\DuskServiceProvider;
 use Laravel\Horizon\Horizon;
+use Laravel\Horizon\SystemProcessCounter;
+use Laravel\Horizon\WorkerCommandString;
 use Lavary\Menu\Menu;
 use ProcessMaker\Cache\Settings\SettingCacheManager;
+use ProcessMaker\Console\Commands\HorizonListen;
 use ProcessMaker\Console\Migration\ExtendedMigrateCommand;
+use ProcessMaker\Contracts\ConditionalRedirectServiceInterface;
 use ProcessMaker\Events\ActivityAssigned;
 use ProcessMaker\Events\ScreenBuilderStarting;
 use ProcessMaker\Events\TenantResolved;
@@ -46,6 +51,7 @@
 use ProcessMaker\PolicyExtension;
 use ProcessMaker\Providers\PermissionServiceProvider;
 use ProcessMaker\Repositories\SettingsConfigRepository;
+use ProcessMaker\Services\ConditionalRedirectService;
 use RuntimeException;
 use Spatie\Multitenancy\Events\MadeTenantCurrentEvent;
 use Spatie\Multitenancy\Events\TenantNotFoundForRequestEvent;
@@ -71,9 +77,6 @@ class ProcessMakerServiceProvider extends ServiceProvider
     // Track the landlord values for multitenancy
     private static $landlordValues = null;
 
-    // Cache tenant app containers to save memory
-    private static $tenantAppContainers = [];
-
     public function boot(): void
     {
         // Track the start time for service providers boot
@@ -241,6 +244,21 @@ public function register(): void
         });
 
         $this->app->instance('tenant-resolved', false);
+
+        /**
+         * Conditional Redirect Service
+         * This service is used to evaluate the conditional redirect property of a process request token.
+         */
+        $this->app->bind(ConditionalRedirectServiceInterface::class, ConditionalRedirectService::class);
+
+        $this->app->when(HorizonListen::class)->needs(Listener::class)->give(function ($app) {
+            return new Listener(base_path());
+        });
+
+        if (config('app.multitenancy')) {
+            WorkerCommandString::$command = 'exec @php artisan horizon:listen';
+            SystemProcessCounter::$command = 'horizon:listen';
+        }
     }
 
     /**
@@ -261,13 +279,10 @@ private static function bootstrapTenantApp(JobProcessing|JobRetryRequested $even
             // Create a new tenant app instance
             $_SERVER['TENANT'] = $tenantId;
 
-            if (!isset(self::$tenantAppContainers[$tenantId])) {
-                self::$tenantAppContainers[$tenantId] = require base_path('bootstrap/app.php');
-            }
-            self::$tenantAppContainers[$tenantId]->reactivateConsoleApp();
-
-            // Change the job's app service container to the tenant app
-            $event->job->getRedisQueue()->setContainer(self::$tenantAppContainers[$tenantId]);
+            $app = require base_path('bootstrap/app.php');
+            $app->make(\ProcessMaker\Console\Kernel::class)->bootstrap();
+            \Illuminate\Container\Container::setInstance($app);
+            $event->job->getRedisQueue()->setContainer($app);
         }
     }