FOUR-20913: invalidate Screen Cache on Translation changes

ProcessMaker/Cache/Monitoring/CacheMetricsDecorator.php

@@ -139,6 +139,22 @@ public function missing(string $key): bool
         return $this->cache->missing($key);
     }
 
+    /**
+     * Invalidate cache for a specific screen
+     *
+     * @param int $screenId Screen ID
+     * @return bool
+     * @throws \RuntimeException If underlying cache doesn't support invalidate
+     */
+    public function invalidate(int $screenId, string $language): bool
+    {
+        if ($this->cache instanceof ScreenCacheInterface) {
+            return $this->cache->invalidate($screenId, $language);
+        }
+
+        throw new \RuntimeException('Underlying cache implementation does not support invalidate method');
+    }
+
     /**
      * Calculate the approximate size in bytes of a value
      *
@@ -169,4 +185,23 @@ protected function calculateSize(mixed $value): int
 
         return 0; // for null or other types
     }
+
+    /**
+     * Get a value from the cache or store it if it doesn't exist.
+     *
+     * @param string $key
+     * @param callable $callback
+     * @return mixed
+     */
+    public function getOrCache(string $key, callable $callback): mixed
+    {
+        if ($this->cache->has($key)) {
+            return $this->cache->get($key);
+        }
+
+        $value = $callback();
+        $this->cache->set($key, $value);
+
+        return $value;
+    }
 }

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -2,6 +2,7 @@
 
 namespace ProcessMaker\Cache\Screens;
 
+use Illuminate\Support\Facades\Storage;
 use ProcessMaker\Managers\ScreenCompiledManager;
 
 class LegacyScreenCacheAdapter implements ScreenCacheInterface
@@ -54,4 +55,40 @@ public function has(string $key): bool
     {
         return $this->compiledManager->getCompiledContent($key) !== null;
     }
+
+    /**
+     * Delete a screen from cache
+     */
+    public function delete(string $key): bool
+    {
+        return $this->compiledManager->deleteCompiledContent($key);
+    }
+
+    /**
+     * Clear all screen caches
+     */
+    public function clear(): bool
+    {
+        return $this->compiledManager->clearCompiledContent();
+    }
+
+    /**
+     * Check if screen is missing from cache
+     */
+    public function missing(string $key): bool
+    {
+        return !$this->has($key);
+    }
+
+    /**
+     * Invalidate all cache entries for a specific screen
+     *
+     * @param int $screenId Screen ID
+     * @return bool
+     */
+    public function invalidate(int $screenId, string $language): bool
+    {
+        // Get all files from storage that match the pattern for this screen ID
+        return $this->compiledManager->deleteScreenCompiledContent($screenId, $language);
+    }
 }

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -47,4 +47,14 @@ public static function create(): ScreenCacheInterface
         // Wrap with metrics decorator if not already wrapped
         return new CacheMetricsDecorator($cache, app()->make(RedisMetricsManager::class));
     }
+
+    /**
+     * Get the current screen cache instance
+     *
+     * @return ScreenCacheInterface
+     */
+    public static function getScreenCache(): ScreenCacheInterface
+    {
+        return self::create();
+    }
 }

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -21,6 +21,43 @@ public function set(string $key, mixed $value): bool;
 
     /**
      * Check if screen exists in cache
+     *
+     * @param string $key Screen cache key
+     * @return bool
      */
     public function has(string $key): bool;
+
+    /**
+     * Delete a screen from cache
+     *
+     * @param string $key Screen cache key
+     * @return bool
+     */
+    public function delete(string $key): bool;
+
+    /**
+     * Clear all screen caches
+     *
+     * @return bool
+     */
+    public function clear(): bool;
+
+    /**
+     * Check if screen is missing from cache
+     *
+     * @param string $key Screen cache key
+     * @return bool
+     */
+    public function missing(string $key): bool;
+
+    /**
+     * Invalidate cache for a specific screen
+     *
+     * @param int $screenId
+     * @return bool
+     */
+    public function invalidate(
+        int $screenId,
+        string $language,
+    ): bool;
 }

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -5,6 +5,7 @@
 use Illuminate\Cache\CacheManager;
 use ProcessMaker\Cache\CacheInterface;
 use ProcessMaker\Managers\ScreenCompiledManager;
+use ProcessMaker\Models\Screen;
 
 class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
 {
@@ -139,4 +140,25 @@ public function missing(string $key): bool
     {
         return !$this->has($key);
     }
+
+    /**
+     * Invalidate all cache entries for a specific screen
+     * @param int $screenId Screen ID
+     * @param string $language Language code
+     * @return bool
+     */
+    public function invalidate(int $screenId, string $language): bool
+    {
+        // Get all keys from cache that match the pattern for this screen ID
+        // TODO Improve this to avoid scanning the entire cache
+        $pattern = "*_{$language}_sid_{$screenId}_*";
+        $keys = $this->cacheManager->get($pattern);
+
+        // Delete all matching keys
+        foreach ($keys as $key) {
+            $this->cacheManager->forget($key);
+        }
+
+        return true;
+    }
 }

ProcessMaker/Cache/Settings/SettingCacheManager.php

@@ -31,6 +31,7 @@ private function determineCacheDriver(): string
         if (in_array($defaultCache, ['redis', 'cache_settings'])) {
             return self::DEFAULT_CACHE_DRIVER;
         }
+
         return $defaultCache;
     }
 
@@ -150,7 +151,7 @@ public function clearBy(string $pattern): void
             // Get all keys
             $keys = Redis::connection($connection)->keys($this->cacheManager->getPrefix() . '*');
             // Filter keys by pattern
-            $matchedKeys = array_filter($keys, fn($key) => preg_match('/' . $pattern . '/', $key));
+            $matchedKeys = array_filter($keys, fn ($key) => preg_match('/' . $pattern . '/', $key));
 
             if (!empty($matchedKeys)) {
                 Redis::connection($connection)->del($matchedKeys);

ProcessMaker/Events/TranslationChanged.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace ProcessMaker\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class TranslationChanged
+{
+    use Dispatchable;
+
+    public string $locale;
+
+    public array $changes;
+
+    public ?string $screenId;
+
+    /**
+     * Create a new event instance.
+     *
+     * @param string $locale
+     * @param array $changes Key-value pairs of changed translations
+     * @param string|null $screenId Optional screen ID if change is specific to a screen
+     */
+    public function __construct(int $screenId, string $language, array $changes)
+    {
+        $this->language = $language;
+        $this->changes = $changes;
+        $this->screenId = $screenId;
+    }
+}

ProcessMaker/Listeners/InvalidateScreenCacheOnTranslationChange.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace ProcessMaker\Listeners;
+
+use Illuminate\Support\Facades\Log;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
+use ProcessMaker\Events\TranslationChanged;
+use ProcessMaker\Models\Screen;
+
+class InvalidateScreenCacheOnTranslationChange
+{
+    /**
+     * Handle the event.
+     */
+    public function handle(TranslationChanged $event): void
+    {
+        try {
+            if ($event->screenId) {
+                $this->invalidateScreen($event->screenId, $event->language);
+            }
+        } catch (\Exception $e) {
+            Log::error('Failed to invalidate screen cache', [
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
+                'language' => $event->language,
+                'screenId' => $event->screenId,
+            ]);
+            throw $e; // Re-throw to ensure error is properly handled
+        }
+    }
+
+    /**
+     * Invalidate cache for a specific screen
+     */
+    protected function invalidateScreen(string $screenId, string $locale): void
+    {
+        try {
+            $screen = Screen::find($screenId);
+            if ($screen) {
+                $cache = ScreenCacheFactory::getScreenCache();
+                $cache->invalidate($screen->id, $locale);
+            } else {
+                Log::warning('Screen not found', ['screenId' => $screenId]);
+            }
+        } catch (\Exception $e) {
+            Log::error('Error in invalidateScreen', [
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
+                'screenId' => $screenId,
+                'locale' => $locale,
+            ]);
+            throw $e;
+        }
+    }
+}

ProcessMaker/Managers/ScreenCompiledManager.php

@@ -106,4 +106,28 @@ protected function getFilename(string $screenKey)
     {
         return 'screen_' . $screenKey . '.bin';
     }
+
+    /**
+     * Delete all compiled content for a specific screen ID and language
+     *
+     * @param string $screenId Screen ID
+     * @param string $language Language code
+     * @return bool
+     */
+    public function deleteScreenCompiledContent(string $screenId, string $language): bool
+    {
+        $files = Storage::disk($this->storageDisk)->files($this->storagePath);
+        $deleted = false;
+
+        foreach ($files as $file) {
+            // Remove the 'screen_' prefix and '.bin' extension for pattern matching
+            $filename = str_replace(['screen_', '.bin'], '', basename($file));
+            if (strpos($filename, "_{$language}_sid_{$screenId}_") !== false) {
+                Storage::disk($this->storageDisk)->delete($file);
+                $deleted = true;
+            }
+        }
+
+        return $deleted;
+    }
 }

ProcessMaker/Models/Screen.php

@@ -7,6 +7,7 @@
 use Illuminate\Validation\Rule;
 use ProcessMaker\Assets\ScreensInScreen;
 use ProcessMaker\Contracts\ScreenInterface;
+use ProcessMaker\Events\TranslationChanged;
 use ProcessMaker\Traits\Exportable;
 use ProcessMaker\Traits\ExtendedPMQL;
 use ProcessMaker\Traits\HasCategories;

ProcessMaker/Models/ScreenVersion.php

@@ -4,6 +4,7 @@
 
 use Illuminate\Database\Eloquent\Builder;
 use ProcessMaker\Contracts\ScreenInterface;
+use ProcessMaker\Events\TranslationChanged;
 use ProcessMaker\Traits\HasCategories;
 use ProcessMaker\Traits\HasScreenFields;
 
@@ -33,6 +34,14 @@ class ScreenVersion extends ProcessMakerModel implements ScreenInterface
         'translations' => 'array',
     ];
 
+    /**
+     * Boot the model and its events
+     */
+    public static function boot()
+    {
+        parent::boot();
+    }
+
     /**
      * Set multiple|single categories to the screen
      *

ProcessMaker/Models/Setting.php

@@ -143,7 +143,7 @@ public static function messages()
      *
      * @param  string  $key
      *
-     * @return \ProcessMaker\Models\Setting|null
+     * @return Setting|null
      * @throws \Exception
      */
     public static function byKey(string $key)
@@ -393,7 +393,7 @@ public static function getFavicon()
      */
     public static function groupsByMenu($menuId)
     {
-        $query = Setting::query()
+        $query = self::query()
             ->select('group')
             ->groupBy('group')
             ->where('group_id', $menuId)
@@ -420,7 +420,7 @@ public static function groupsByMenu($menuId)
      */
     public static function updateSettingsGroup($settingsGroup, $id)
     {
-        Setting::where('group', $settingsGroup)->whereNull('group_id')->chunk(
+        self::where('group', $settingsGroup)->whereNull('group_id')->chunk(
             50,
             function ($settings) use ($id) {
                 foreach ($settings as $setting) {
@@ -440,7 +440,7 @@ function ($settings) use ($id) {
      */
     public static function updateAllSettingsGroupId()
     {
-        Setting::whereNull('group_id')->chunk(100, function ($settings) {
+        self::whereNull('group_id')->chunk(100, function ($settings) {
             $defaultId = SettingsMenus::EMAIL_MENU_GROUP;
             foreach ($settings as $setting) {
                 // Define the value of 'menu_group' based on 'group'