Merge pull request #6 from justbetter/feature/globals-compatibility

Globals compatibility

Author: BobWez98

README.md

@@ -11,22 +11,22 @@
     <a href="https://github.com/justbetter/statamic-entry-translator"><img src="https://img.shields.io/packagist/dt/justbetter/statamic-entry-translator?color=blue&style=flat-square" alt="Total downloads"></a>
 </p>
 
-Automatically translate the content of Statamic entries using translation services.
+Automatically translate the content of Statamic entries and global sets using translation services.
 
 ## Features
 
-This package provides a seamless way to translate Statamic entries to different sites and locales using translation services.
+This package provides a seamless way to translate Statamic entries and global sets to different sites and locales using translation services.
 
 Features:
 
-- Translate entries to multiple sites/locales
+- Translate entries and global sets to multiple sites/locales
 - Support for DeepL translation service
 - Queue-based translation processing
 - Configurable field exclusions
 - Handles nested fields, replicators, and fieldset imports
-- Statamic CP action for easy translation
+- Statamic CP actions for easy entry and global set translation
 - Only translates localizable fields
-- Automatically creates localizations if they don't exist
+- Automatically creates entry localizations if they don't exist
 
 > Also check out our other [Statamic packages](https://github.com/justbetter?q=statamic)!
 
@@ -104,13 +104,24 @@ return [
 
 ### Using the Statamic CP Action
 
+#### Entries
+
 1. Navigate to your entries in the Statamic Control Panel
 2. Select one or more entries you want to translate
 3. Click on the "Actions" dropdown
 4. Select "Translate Content"
 5. Choose the target sites you want to translate to
 6. Click "Run"
 
+#### Global Sets
+
+1. Navigate to your global sets in the Statamic Control Panel
+2. Select a global set you want to translate
+3. Click on the "Actions" dropdown
+4. Select "Translate Content"
+5. Choose the target sites you want to translate to, or select "All sites"
+6. Click "Run"
+
 The translations will be queued and processed asynchronously.
 
 ### Programmatic Usage
@@ -143,23 +154,63 @@ $sites = Site::all()->filter(fn($site) => $site->handle() !== $entry->site()->ha
 TranslateEntries::translateEntries($entry, $sites);
 ```
 
+### Translating Global Sets
+
+To translate a global set to a single site:
+
+```php
+use JustBetter\EntryTranslator\Facades\TranslateGlobalSet;
+use Statamic\Facades\GlobalSet;
+use Statamic\Facades\Site;
+
+$globalSet = GlobalSet::find('settings');
+$sourceSite = Site::get('en');
+$targetSite = Site::get('nl');
+
+TranslateGlobalSet::translate($globalSet, $sourceSite, $targetSite);
+```
+
+To translate a global set to multiple sites:
+
+```php
+use JustBetter\EntryTranslator\Facades\TranslateGlobalSets;
+use Statamic\Facades\GlobalSet;
+use Statamic\Facades\Site;
+
+$globalSet = GlobalSet::find('settings');
+$sourceSite = Site::get('en');
+$targetSites = Site::all()->filter(fn ($site) => $site->handle() !== $sourceSite->handle());
+
+TranslateGlobalSets::translateGlobalSets($globalSet, $sourceSite, $targetSites);
+```
+
 ### Using Jobs Directly
 
 You can dispatch translation jobs directly:
 
 ```php
 use JustBetter\EntryTranslator\Jobs\TranslateEntryJob;
+use JustBetter\EntryTranslator\Jobs\TranslateGlobalSetJob;
 use Statamic\Facades\Entry;
+use Statamic\Facades\GlobalSet;
 use Statamic\Facades\Site;
 
 $entry = Entry::find('entry-id');
 $targetSite = Site::get('en');
 
 TranslateEntryJob::dispatch($entry, $targetSite);
+
+$globalSet = GlobalSet::find('settings');
+$sourceSite = Site::get('en');
+$targetSite = Site::get('nl');
+
+TranslateGlobalSetJob::dispatch($globalSet, $sourceSite, $targetSite);
 ```
 
 ## How It Works
 
+### Entries
+
 1. The package identifies all localizable fields in the entry's blueprint
 2. Fields that are excluded (by handle or type) are filtered out
 3. The source entry's data is extracted for the localizable fields
@@ -168,7 +219,17 @@ TranslateEntryJob::dispatch($entry, $targetSite);
 6. The translated content is merged with the original entry data
 7. The localized entry is saved
 
+### Global Sets
+
+1. The package loads the global set variables for the source and target sites
+2. The package identifies all localizable fields in the global set blueprint
+3. Fields that are excluded (by handle or type) are filtered out
+4. The source global variables are translated by the configured translation service
+5. The translated content is merged with the original source data
+6. The target site's global variables are saved quietly
+
 The package handles:
+
 - Nested fields (fields within fields)
 - Replicator fields
 - Fieldset imports
@@ -186,11 +247,12 @@ namespace App\Translators;
 use JustBetter\EntryTranslator\Translators\BaseTranslator;
 use Illuminate\Support\Collection;
 use Statamic\Entries\Entry;
+use Statamic\Globals\Variables;
 use Statamic\Sites\Site;
 
 class MyCustomTranslator extends BaseTranslator
 {
-    public function translate(Entry $source, Collection $localisableFields, Site $site): array
+    public function translate(Entry|Variables $source, Collection $localisableFields, Site $site): array
     {
         // Your translation logic here
         // Return an array of translated data

src/Actions/TranslateGlobalSet.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace JustBetter\EntryTranslator\Actions;
+
+use Illuminate\Support\Collection;
+use JustBetter\EntryTranslator\Contracts\Fields\CollectsLocalisableFields;
+use JustBetter\EntryTranslator\Contracts\ResolvesTranslator;
+use JustBetter\EntryTranslator\Contracts\TranslatesGlobalSet;
+use Statamic\Globals\GlobalSet;
+use Statamic\Sites\Site;
+
+class TranslateGlobalSet implements TranslatesGlobalSet
+{
+    public function __construct(
+        protected ResolvesTranslator $resolvesTranslator,
+        protected CollectsLocalisableFields $collectFields
+    ) {}
+
+    public function translate(GlobalSet $source, Site $sourceSite, Site $targetSite): void
+    {
+        $sourceVariables = $source->in($sourceSite->handle());
+        $targetVariables = $source->in($targetSite->handle());
+
+        if (! $sourceVariables || ! $targetVariables) {
+            return;
+        }
+
+        $localisableFields = $sourceVariables->blueprint()->fields()->localizable()->items();
+        /** @var Collection<int, non-falsy-string> $localisableFields */
+        $localisableFields = $this->collectFields->collect($localisableFields);
+
+        $data = $this->resolvesTranslator->resolve()->translate($sourceVariables, $localisableFields, $targetSite);
+        $original = $sourceVariables->data()->all();
+
+        $targetVariables->data(array_replace_recursive($original, $data));
+        $targetVariables->saveQuietly();
+    }
+
+    public static function bind(): void
+    {
+        app()->bind(TranslatesGlobalSet::class, static::class);
+    }
+}

src/Actions/TranslateGlobalSetAction.php

@@ -0,0 +1,159 @@
+<?php
+
+namespace JustBetter\EntryTranslator\Actions;
+
+use Illuminate\Support\Arr;
+use Illuminate\Support\Collection;
+use JustBetter\EntryTranslator\Jobs\TranslateGlobalSetsJob;
+use Statamic\Actions\Action;
+use Statamic\Facades\Site;
+use Statamic\Globals\GlobalSet;
+use Statamic\Sites\Site as StatamicSite;
+
+class TranslateGlobalSetAction extends Action
+{
+    // @phpstan-ignore-next-line missingType.parameter
+    public function run($items, $values): array
+    {
+        /** @var Collection<int, GlobalSet> $items */
+        $items = $items;
+        /** @var array<string, array<int, string>> $values */
+        $values = $values;
+
+        $sourceSite = $this->sourceSite();
+        $all = collect($values['to_sites'])->some('all');
+
+        foreach ($items as $source) {
+            $targetSites = $this->targetSites($source, $sourceSite, $all, $values['to_sites']);
+
+            if ($targetSites->isNotEmpty()) {
+                TranslateGlobalSetsJob::dispatch($source, $sourceSite, $targetSites);
+            }
+        }
+
+        $message = __('Globals are added in the queue. It can take a little bit of time to be processed.');
+
+        return ['message' => $message];
+    }
+
+    /**
+     * @return array<string, array<string, array<string>|string>>
+     */
+    public function fieldItems(): array
+    {
+        $sourceSite = $this->sourceSite();
+        $source = $this->items->first();
+
+        /** @var Collection<int, StatamicSite> $sites */
+        $sites = $source instanceof GlobalSet
+            ? $source->sites()->map(fn (string $handle): ?StatamicSite => $this->site($handle))->filter()->values()
+            : Site::all();
+
+        $siteOptions = $sites
+            ->reject(fn (StatamicSite $site): bool => $site->handle() === $sourceSite->handle())
+            ->mapWithKeys(fn (StatamicSite $site) => [
+                $site->handle() => $site->name().' - '.strtoupper($site->lang()),
+            ])
+            ->put('all', 'All sites')
+            ->all();
+
+        return [
+            'to_sites' => [
+                'type' => 'checkboxes',
+                'display' => 'Translate to',
+                'instructions' => 'Select the target sites to translate to',
+                'options' => $siteOptions,
+                'validate' => 'required|array|min:1',
+            ],
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            'from_site' => 'required',
+            'to_sites' => 'required|array|min:1',
+            'to_sites.*' => 'different:from_site',
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function messages(): array
+    {
+        return [
+            'to_sites.*.different' => 'Target sites must be different from the source site',
+            'to_sites.required' => 'Please select at least one target site',
+            'to_sites.min' => 'Please select at least one target site',
+        ];
+    }
+
+    public static function title(): string
+    {
+        return __('Translate Content');
+    }
+
+    public function visibleTo(mixed $item): bool
+    {
+        return $item instanceof GlobalSet;
+    }
+
+    public function authorize(mixed $user, mixed $item): bool
+    {
+        // @phpstan-ignore-next-line
+        return $user->can('edit', $item);
+    }
+
+    protected function sourceSite(): StatamicSite
+    {
+        $contextSite = Arr::get($this->context, 'site');
+
+        $selected = Site::selected();
+        if (! $selected instanceof StatamicSite) {
+            /** @var StatamicSite $selected */
+            $selected = Site::default();
+        }
+
+        $handle = is_string($contextSite) ? $contextSite : $selected->handle();
+
+        $site = $this->site($handle);
+
+        if (! $site) {
+            return $selected;
+        }
+
+        return $site;
+    }
+
+    /**
+     * @param  array<int, string>  $selectedSites
+     * @return Collection<int, StatamicSite>
+     */
+    protected function targetSites(GlobalSet $source, StatamicSite $sourceSite, bool $all, array $selectedSites): Collection
+    {
+        $availableSites = $source->sites()
+            ->map(fn (string $handle): ?StatamicSite => $this->site($handle))
+            ->filter()
+            ->values();
+
+        return $all
+            ? $availableSites->reject(fn (StatamicSite $site): bool => $site->handle() === $sourceSite->handle())->values()
+            : collect($selectedSites)
+                ->map(fn (string $handle): ?StatamicSite => $this->site($handle))
+                ->filter(fn (?StatamicSite $site): bool => $site instanceof StatamicSite
+                    && $site->handle() !== $sourceSite->handle()
+                    && $source->sites()->contains($site->handle()))
+                ->values();
+    }
+
+    protected function site(string $handle): ?StatamicSite
+    {
+        $site = Site::get($handle);
+
+        return $site instanceof StatamicSite ? $site : null;
+    }
+}

src/Actions/TranslateGlobalSets.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace JustBetter\EntryTranslator\Actions;
+
+use Illuminate\Support\Collection;
+use JustBetter\EntryTranslator\Contracts\TranslatesGlobalSets;
+use JustBetter\EntryTranslator\Jobs\TranslateGlobalSetJob;
+use Statamic\Globals\GlobalSet;
+use Statamic\Sites\Site;
+
+class TranslateGlobalSets implements TranslatesGlobalSets
+{
+    /**
+     * @param  Collection<int, Site>  $targetSites
+     */
+    public function translateGlobalSets(GlobalSet $source, Site $sourceSite, Collection $targetSites): void
+    {
+        foreach ($targetSites as $targetSite) {
+            TranslateGlobalSetJob::dispatch($source, $sourceSite, $targetSite);
+        }
+    }
+
+    public static function bind(): void
+    {
+        app()->bind(TranslatesGlobalSets::class, static::class);
+    }
+}

src/Contracts/TranslatesGlobalSet.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace JustBetter\EntryTranslator\Contracts;
+
+use Statamic\Globals\GlobalSet;
+use Statamic\Sites\Site;
+
+interface TranslatesGlobalSet
+{
+    public function translate(GlobalSet $source, Site $sourceSite, Site $targetSite): void;
+}