Fix: Move carrier live-pricing choice onto ShippingMethod.charge_by

Reverts the earlier per-rate pricing_mode column in favor of extending Lunar's existing charge_by field (cart_total/weight) with a third "live" option, gated by a SupportsLivePricing capability check on the driver. Adds a shared ResolvesFixedPricing trait so any carrier driver can fall back to Lunar's normal price-break resolution, matching the vendor ShipBy driver's own charge_by handling instead of introducing a separate mechanism. Also fixes an incorrect Get() path in the admin form that silently hid the new "live" option.
Feature: Wire up carrier-agnostic shipping admin UI
2026-07-19 02:24:10 +03:00 · 2026-07-19 00:52:01 +03:00 · 2026-07-19 00:51:23 +03:00 · 2026-07-19 00:50:51 +03:00 · 2026-07-19 00:50:15 +03:00 · 2026-07-19 00:42:13 +03:00
64 changed files with 1621 additions and 1782 deletions
@@ -4,56 +4,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ## [0.5.4] - 2026-08-26
 ### Added
 - `Modules\Core\Catalog\ProductService::list()` accepts a `sort` parameter (new `ProductSort` enum: `PriceAsc`, `PriceDesc`, `Newest`), translated into a Meilisearch `sort` clause — `list()` previously had no way to order results, since it always searches with an empty query string and so has no relevance score to fall back on. `Modules\Core\Search\ProductIndexer::getSortableFields()` now also marks `price` sortable (Lunar's base indexer only marks `created_at`/`updated_at`/`skus`/`status`). Requires re-syncing index settings (`php artisan lunar:meilisearch:setup`) on existing stores. Documented in `docs/product-listing.md` ("Sorting").
 ## [0.5.3] - 2026-08-26
 ### Fixed
 - `Modules\Core\Search\ProductIndexer::toSearchableArray()` threw `column reference "id" is ambiguous` on Postgres when computing `channel_ids` — `$model->channels()->wherePivot('enabled', true)->pluck('id')` joins `lunar_channels` and `lunar_channelables`, both of which have an `id` column, and the unqualified `pluck('id')` left Postgres unable to resolve which table's column to select (SQLite/MySQL tolerated the ambiguity). Qualified as `pluck('lunar_channels.id')`.
 ## [0.5.2] - 2026-08-26
 ### Fixed
 - `Modules\Core\Localization\LocaleMiddleware`'s shared view data only ever surfaced a single alternate locale (`altLocale`/`altLocaleUrl`, found via `firstWhere('code', '!=', $current)`) — correct by coincidence for a 2-language store, but silently dropped every locale past the first "other" one found for a 3+ language store, with no error. Replaced with `altLocales`, a collection of every other configured language (`code`, `name`, `url` for the current route each), so a language switcher or `hreflang` tags scale to any number of locales. Documented in `docs/localization.md` ("Shared view data — language switcher and `hreflang` tags").
 ## [0.5.1] - 2026-08-25
 ### Added
 - `Modules\Core\Search\ProductIndexer` now indexes `channel_ids` (filterable) — Lunar's base indexer only marks `status` as filterable, not channel assignment, so storefront search couldn't otherwise scope results to products actually assigned and enabled on the current sales channel. Computed from `$product->channels()->wherePivot('enabled', true)`. Ported from an older `Products` branch whose remote had been deleted; the branch's other, now-superseded `ProductIndexer` changes were dropped in favor of the richer indexer already on `master` (collections, price, variants, reviews — see `0.5.0`).
 ## [0.5.0] - 2026-08-24
 ### Added
 - **`Modules\Core\Catalog\ProductService`**: storefront product listing/filtering (`list()`) and single-product lookup (`getById()`, `getBySlug()`), reading directly from the Meilisearch index rather than the database — one data source, no `->get()` model hydration. Returns plain arrays (not Eloquent models), meant to be called directly from a consuming app's controllers.
  - `ProductFilters` DTO: optional `collectionId`, `brand`, `minPrice`, `maxPrice`, translated into a Meilisearch `filter` expression.
  - Listing results are locale-aware: `withLocalizedFields()` resolves `name`/`description` from the indexer's per-locale fields, falling back to the store's default language (via `LocaleMiddleware::defaultLocale()`) when the current locale has no translation yet, instead of rendering blank.
  - `Modules\Core\Search\ProductIndexer` expanded well beyond its original collection/price additions to carry everything a detail page needs: `id`/`slugs` (filterable — `getById()`/`getBySlug()` resolve purely from the index, no database read), `collection_names`, `tags`, the full media gallery, per-variant data (`sku`, `stock`, `purchasable`, translated option/value names + `meta` for swatches, per-currency prices, variant media), and reviews (`reviews`, `review_count`, `average_rating` — public-safe fields only, `reviewer_email` deliberately excluded).
  - `Modules\Core\Providers\ReviewServiceProvider` (newly registered): re-indexes a product whenever one of its reviews is created/updated/deleted, since a review write doesn't touch the `Product` row and so never fires the product's own model events.
 - **`Modules\Core\Search\ProductSearchService`**: locale-aware full-text product search on top of the same Meilisearch index, for use by a storefront's search bar — separate from `ProductService`, which is for browsing/filtering without a query term.
 - `docs/product-listing.md` and `docs/product-search.md` — usage, full field reference, and design notes for the two services above.
 - `docs/lunar.md` "Gotchas": three new entries hit while building this — `ProductOption`/`ProductOptionValue::name` isn't `attribute_data` (so `translateAttribute()` silently returns `null` for it), a running `queue:work` process not picking up an edited Scout indexer class, and Scout's `paginateRaw()->items()` on the Meilisearch driver returning the whole raw response rather than a hit list.
 ### Fixed
 - The admin login form (`Modules\Core\Auth\Filament\Pages\Login`) had no way back from the OTP-entry step to the email step short of reloading the page. A `back()` method resets to the email step; a "← Back" link/button is shown on the OTP step only.
 ## [0.4.0] - 2026-08-06
 ### Added
 - **Locale-prefixed routing** (`Modules\Core\Localization\LocaleMiddleware`): a `locale` route-middleware alias, opt-in per shop (not pushed onto the `web` group globally, since admin/Livewire/webhook routes must not be locale-redirected). Reads the first URL segment against Lunar's own `languages` table, sets `App::setLocale()`, and redirects unprefixed/unknown-locale requests to a resolved locale (`Accept-Language` match → default language → first language). Every locale is prefixed, including the default (`/el/...`, `/en/...`), never a bare root — avoids the hreflang/duplicate-content ambiguity of a bare-root default locale.
  - Language list cached with `Cache::rememberForever()`, invalidated via `Modules\Core\Localization\LanguageCacheObserver` dispatching `LanguageCreated`/`LanguageUpdated`/`LanguageDeleted` events (see below) rather than doing the work itself.
  - **Language rename safety**: renaming a `Language::code` (e.g. `el` → `gr`) no longer strands existing translations. `MigrateTranslationsForRenamedLanguage` (listening on `LanguageUpdated`) migrates every affected `LanguageLine.text` key from the old code to the new one and flushes both codes' translation caches — closing a real data-loss gap where a rename would otherwise make existing `LanguageLine` translations permanently unreachable.
 - **Storefront UI label translations**: pulled in `spatie/laravel-translation-loader` (self-registers via Composer package auto-discovery; its loader *extends* Laravel's file-based `FileLoader` and merges DB translations on top — existing Filament/Lunar vendor `lang/` strings are unaffected). Labels are looked up via Laravel's native `__('storefront.nav.cart')`, kept in its own `storefront` group so nothing collides with Lunar/Filament's own translation groups.
  - `Modules\Core\Command\InstallLunarCommand` (overriding `lunar:install`) seeds a starter set of ~15 common e-shop labels (`nav.*`, `cart.*`, `product.*`, `auth.*`, `search.*`, English + Greek), idempotently guarded so it's safe on every boot.
  - `Modules\Core\Localization\TranslationReader::group('storefront')` returns the whole reduced/cached label array for a locale (backed by `LanguageLine`'s own forever-cache) — for sharing to a view as `$labels` or `@json()`-ing to JS, on top of `__()` for single-key Blade lookups.
  - **Admin UI**: `Modules\Core\Localization\Filament\Resources\LanguageLineResource` (registered in `CorePlugin`) lists/searches/filters `language_lines` and edits each row's `group`, `key`, and one text input per locale currently in `lunar_languages` — locale columns/inputs are generated dynamically from the language list, so a new language needs no resource changes.
  - **Event-driven writes**: `Modules\Core\Localization\TranslationService` (`create`/`update`/`delete`) is the single write path for `LanguageLine` — the Filament resource's Create/Edit/Delete pages route through it rather than Filament's default direct-model writes. Dispatches `TranslationCreated`/`TranslationUpdated` (carries the full pre-update `{group, key, text}` snapshot, so a bare rename is tracked the same as a text edit)/`TranslationDeleted`, each handled by two listeners:
    - `FlushTranslationCache` — closes a real gap in `LanguageLine`'s own self-invalidation, which only flushes locales/groups present *after* a save. Flushes the union of old and new group+locale combinations, so a locale removed from `text`, or a `group`/`key` rename, can't leave a stale cached array behind.
    - `LogTranslationActivity` — audits every write via the existing `Modules\Core\Logging\ActivityLogService` (`lunar` activity log channel), same `created`/`updated`/`deleted` shape as every other domain write in this project. Properties are flattened with `Arr::dot()` before logging (`text.en`, `text.el` instead of a nested `text` object) since Filament's Activity resource renders `properties` with a flat `KeyValue` field that can't display nested arrays.
 - `Modules\Core\Providers\LocalizationServiceProvider` — split out of the growing `CoreServiceProvider` (per this project's own "split when a provider does too much" convention) to own all locale/translation middleware, observer, and event-listener registration.
 ## [0.3.0] - 2026-07-12
 ### Added
@@ -2,7 +2,7 @@
  "name": "boboko/core",
  "description": "Core module — authentication and shared panel behaviour",
  "type": "library",
-  "version": "0.5.4",
+  "version": "0.3.0",
  "autoload": {
    "psr-4": {
      "Modules\\Core\\": "src/"
@@ -16,8 +16,7 @@
    "symfony/yaml": "^7.0",
    "lunarphp/table-rate-shipping": "^1.3",
    "lunarphp/search": "*",
-    "lunarphp/meilisearch": "*",
+    "lunarphp/meilisearch": "*"
    "spatie/laravel-translation-loader": "^2.8"
  },
  "require-dev": {
    "fakerphp/faker": "^1.23",
@@ -35,15 +34,13 @@
        "Modules\\Core\\Providers\\CoreServiceProvider",
        "Modules\\Core\\Providers\\AuthServiceProvider",
        "Modules\\Core\\Providers\\CustomerServiceProvider",
-        "Modules\\Core\\Providers\\LocalizationServiceProvider",
+        "Modules\\Core\\Providers\\ShippingServiceProvider"
        "Modules\\Core\\Providers\\ReviewServiceProvider"
      ]
    }
  },
  "config": {
    "allow-plugins": {
-      "pestphp/pest-plugin": true,
+      "pestphp/pest-plugin": true
      "php-http/discovery": true
    }
  }
 }
@@ -0,0 +1,50 @@
 <?php
 /*
 |--------------------------------------------------------------------------
 | ACS Courier credentials
 |--------------------------------------------------------------------------
 |
 | ACS requires two credential mechanisms simultaneously: an AcsApiKey
 | HTTP header (gates the REST gateway itself) and four account fields
 | (Company_ID/Company_Password/User_ID/User_Password) sent in every
 | request body. Both are supplied by ACS when your account is set up.
 |
 | Set these via environment variables — never commit real values.
 |
 | ACS_BASE_URL           Root REST endpoint (unversioned, single URL for
 |                        every ACSAlias call).
 | ACS_API_KEY            The AcsApiKey header value.
 | ACS_COMPANY_ID         Company_ID body field.
 | ACS_COMPANY_PASSWORD   Company_Password body field.
 | ACS_USER_ID            User_ID body field.
 | ACS_USER_PASSWORD      User_Password body field.
 | ACS_BILLING_CODE       Your ACS credit/billing code, used for price
 |                        calculation and voucher creation.
 | ACS_SENDER_*           Static sender details reused on every voucher.
 |
 */
 return [
    'base_url' => env('ACS_BASE_URL', 'https://webservices.acscourier.net/ACSRestServices/api/ACSAutoRest'),
    'api_key' => env('ACS_API_KEY'),
    'company_id' => env('ACS_COMPANY_ID'),
    'company_password' => env('ACS_COMPANY_PASSWORD'),
    'user_id' => env('ACS_USER_ID'),
    'user_password' => env('ACS_USER_PASSWORD'),
    'billing_code' => env('ACS_BILLING_CODE'),
    'sender' => [
        'name' => env('ACS_SENDER_NAME'),
        'address' => env('ACS_SENDER_ADDRESS'),
        'zip_code' => env('ACS_SENDER_ZIP'),
        'phone' => env('ACS_SENDER_PHONE'),
    ],
    'timeout' => env('ACS_HTTP_TIMEOUT', 10),
 ];
@@ -0,0 +1,47 @@
 <?php
 /*
 |--------------------------------------------------------------------------
 | Box Now credentials
 |--------------------------------------------------------------------------
 |
 | Box Now uses OAuth2 client-credentials: exchange BOXNOW_CLIENT_ID /
 | BOXNOW_CLIENT_SECRET for a Bearer access token (POST /auth-sessions,
 | ~1hr expiry), then attach it as an Authorization header on every call.
 | Unlike ACS, there is no separate per-request credential body — the
 | token alone authorizes all calls once obtained.
 |
 | Set these via environment variables — never commit real values.
 |
 | BOXNOW_BASE_URL         Root REST endpoint for delivery-requests/parcels.
 | BOXNOW_LOCATION_API_URL Separate, faster endpoint for origins/destinations
 |                         lookups (Box Now recommends this over the main
 |                         base URL for those two calls specifically).
 | BOXNOW_CLIENT_ID        OAuth2 client id.
 | BOXNOW_CLIENT_SECRET    OAuth2 client secret.
 | BOXNOW_ORIGIN_LOCATION_ID  Your warehouse's Box Now locationId, used as
 |                            the pickup origin on every delivery request.
 | BOXNOW_SENDER_*         Static sender contact details reused on every
 |                         delivery request.
 |
 */
 return [
    'base_url' => env('BOXNOW_BASE_URL', 'https://api-production.boxnow.gr/api/v1'),
    'location_api_url' => env('BOXNOW_LOCATION_API_URL', 'https://locationapi-production.boxnow.gr/api/v1'),
    'client_id' => env('BOXNOW_CLIENT_ID'),
    'client_secret' => env('BOXNOW_CLIENT_SECRET'),
    'origin_location_id' => env('BOXNOW_ORIGIN_LOCATION_ID'),
    'sender' => [
        'name' => env('BOXNOW_SENDER_NAME'),
        'email' => env('BOXNOW_SENDER_EMAIL'),
        'phone' => env('BOXNOW_SENDER_PHONE'),
    ],
    'timeout' => env('BOXNOW_HTTP_TIMEOUT', 10),
 ];
@@ -0,0 +1,29 @@
 <?php
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
 return new class extends Migration
 {
    public function up(): void
    {
        Schema::create('shipments', function (Blueprint $table) {
            $table->id();
            $table->foreignId('order_id')->constrained(config('lunar.database.table_prefix').'orders');
            $table->string('carrier');
            $table->string('tracking_reference')->unique();
            $table->string('parent_reference')->nullable();
            $table->timestamp('label_printed_at')->nullable();
            $table->string('manifest_reference')->nullable();
            $table->timestamp('cancelled_at')->nullable();
            $table->json('meta')->nullable();
            $table->timestamps();
        });
    }
    public function down(): void
    {
        Schema::dropIfExists('shipments');
    }
 };
@@ -1,34 +0,0 @@
 <?php
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
 return new class extends Migration
 {
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up(): void
    {
        Schema::create('language_lines', function (Blueprint $table) {
            $table->id();
            $table->string('group')->index();
            $table->string('key');
            $table->json('text');
            $table->timestamps();
        });
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down(): void
    {
        Schema::dropIfExists('language_lines');
    }
 };
@@ -1,242 +0,0 @@
 # Localization
 Storefront routes can be locale-prefixed (`/el/proionta`, `/en/products`) using a middleware
 that reads directly from Lunar's `languages` table — the same table the Filament **Languages**
 resource manages, so there's no separate locale config to keep in sync.
 ---
 ## Why prefix every locale, including the default
 Leaving the default locale bare at the root (`/proionta` for Greek, `/en/products` for English)
 creates ambiguity: is `/` the language-neutral homepage or specifically the Greek version? It
 also complicates `hreflang` (needs a self-referencing tag on the root plus a possibly-duplicate
 `x-default`) and risks duplicate content if a bot or campaign link reaches the root without a
 language signal.
 Prefixing every locale avoids this: every URL unambiguously declares its language, `hreflang`
 tags are symmetrical, and adding a locale later requires no URL restructuring.
 ---
 ## Opt-in, not global
 The middleware is registered as a **named alias** (`locale`), not pushed onto the `web`
 middleware group. Apply it explicitly to the route group(s) that make up your storefront:
 ```php
 // routes/web.php
 use Illuminate\Support\Facades\Route;
 Route::middleware('locale')->group(function () {
    Route::get('/{locale}', HomeController::class);
    Route::get('/{locale}/proionta', ProductIndexController::class);
    Route::get('/{locale}/proionta/{slug}', ProductShowController::class);
 });
 ```
 It is **not** applied automatically because storefront routes aren't the only routes living
 under `web` in a shop:
 - The Filament admin panel (`/boboko*`, see `PanelServiceProvider`) has its own routing/auth
  concerns and must never be locale-redirected.
 - Livewire's internal update endpoint (`/livewire/update`) must resolve without a locale prefix.
 - Webhooks, health checks, and other non-storefront routes shouldn't be touched.
 If a shop's entire `web.php` *is* the storefront, wrapping the whole file in the group above is
 fine — just keep admin/Livewire/webhook routes registered outside of it (as they already are).
 ---
 ## Behavior
 `Modules\Core\Localization\LocaleMiddleware`:
 1. Reads the first path segment (`request()->segment(1)`).
 2. Matches it against `Lunar\Models\Language::code`.
   - **Match** — `App::setLocale($code)` is set, and `locale` / `language` request attributes
     are populated for controllers/views to use.
   - **No match** (missing, wrong, or unknown segment) — redirects to the same path prefixed
     with a resolved locale:
     - the best match from the `Accept-Language` header against available language codes, or
     - the language flagged `default` in the `languages` table, or
     - the first language row, as a last resort.
 The language list is cached with `Cache::rememberForever()` under `core.localization.languages`
 and invalidated automatically. Adding, editing, or removing a language via the Filament
 **Languages** resource clears the cache immediately — no TTL, no stale reads.
 ### How invalidation is wired (event-driven, not the observer itself)
 `Modules\Core\Localization\LanguageCacheObserver` observes `Lunar\Models\Language`'s
 `created`/`updated`/`deleted` Eloquent events, but it's a thin trigger only — it doesn't do any
 invalidation work itself. It dispatches one of three events from
 `Modules\Core\Localization\Events` (`LanguageCreated`, `LanguageUpdated` — carrying the old
 `code` — or `LanguageDeleted`), and two listeners, wired in
 `Modules\Core\Providers\LocalizationServiceProvider`, react:
 - **`FlushLanguageCache`** — flushes `core.localization.languages` on all three events.
 - **`MigrateTranslationsForRenamedLanguage`** — `LanguageUpdated` only, and only when `code`
  actually changed. A renamed `Language::code` (e.g. `el` → `gr`) would otherwise strand every
  `LanguageLine`'s translated text under the old, now-unroutable key —
  `getTranslationsForGroup('gr', ...)` would silently return nothing for that locale even though
  the translated content still exists. This listener moves the `text.{oldCode}` key to
  `text.{newCode}` on every affected `LanguageLine` row and flushes both the old and new code's
  translation cache for every group touched.
 Deleting a `Language` only flushes the language-list cache — `LanguageLine.text` keys for the
 deleted code are left in place rather than destructively erased, in case the language is ever
 re-added under the same code.
 Splitting cache-flush and text-migration into separate listeners (rather than one
 `LanguageCacheObserver` method doing both) mirrors the same event → listener pattern used for
 `TranslationService`'s writes below — the observer only detects *what happened*, listeners own
 *what to do about it*.
 ---
 ## Reading the resolved locale/language downstream
 ```php
 // In a controller or view composer
 $locale = $request->attributes->get('locale');      // e.g. "el"
 $language = $request->attributes->get('language');   // Lunar\Models\Language instance
 ```
 Use `$language->id` when querying Lunar's translatable content (e.g. `Url::where('language_id', ...)`).
 ### Shared view data — language switcher and `hreflang` tags
 The middleware also shares two variables with every view, via `View::share()`, so a layout's
 language switcher or `hreflang` tags don't have to recompute the language list themselves:
 ```blade
 {{-- current locale --}}
 {{ $currentLocale }}   {{-- e.g. "el" --}}
 {{-- every OTHER configured language, each with its own URL for the current page --}}
@foreach ($altLocales as $altLocale)
    <a href="{{ $altLocale['url'] }}" hreflang="{{ $altLocale['code'] }}">{{ $altLocale['name'] }}</a>
@endforeach
 ```
 `$altLocales` is a **collection**, not a single value — deliberately, so it scales to any number
 of configured languages rather than assuming exactly two. Each entry is a plain array:
 | Key | Description |
 |---|---|
 | `code` | The language's `Lunar\Models\Language::code` (e.g. `en`) |
 | `name` | The language's display name |
 | `url` | The **current route**, re-generated with that language's code — via `route($routeName, [...])` when the current request matched a named route, or a bare `/{code}` fallback otherwise |
 A 3+ language store gets one `$altLocales` entry per additional language automatically — nothing
 about this shape assumes or special-cases a two-language store.
 ---
 ## Single-language shops
 If a shop has only one row in `languages`, the middleware still enforces the prefix (e.g. every
 URL under `/en/...`) rather than special-casing it away — this keeps behavior identical across
 shops and avoids a silent restructuring if a second language is added later. If a shop genuinely
 never wants locale prefixes, don't apply the `locale` middleware to its routes at all.
 ---
 ## Storefront UI labels (`__('storefront.*')`)
 The `locale` middleware resolves *which* language a request is in — routing/redirects,
 `Lunar\Models\Language`, and Lunar's own translatable product/collection content. It has nothing
 to do with static UI chrome like "Cart", "Back", "Add to Cart". Those are handled separately by
 [`spatie/laravel-translation-loader`](https://github.com/spatie/laravel-translation-loader),
 stored in the `language_lines` table.
 ### Why a separate system, not another `languages`-table lookup
 Lunar's translatable fields (`TranslatedText`, `Url`, etc.) are all tied to specific *model
 records* — a product's name, a collection's description. UI labels aren't attached to any model;
 they're static strings the app itself owns. `laravel-translation-loader` is Laravel's own
 `__()`/`trans()` mechanism with a DB-backed source layered on top of the normal file-based one —
 no new helper to learn, no bespoke table shape.
 **Nothing existing breaks.** The package's `TranslationLoaderManager` *extends* Laravel's
 `FileLoader` and merges DB translations on top of file-based ones
 (`array_replace_recursive()`) — Filament's own vendor `lang/en/product.php`-style strings
 keep working exactly as before. The package registers itself via Laravel's standard Composer
 package auto-discovery (`extra.laravel.providers` in its own `composer.json`) — nothing needed
 in `CoreServiceProvider` to wire it up.
 ### Usage
 ```blade
 {{ __('storefront.nav.cart') }}
 {{ __('storefront.product.add_to_cart') }}
 ```
 `group` is `storefront` for e-shop UI labels — kept separate from Lunar/Filament's own `lunar::`
 namespaced groups so nothing collides. `__()` resolves the translation for whatever
 `App::getLocale()` currently is, which `LocaleMiddleware` already sets per-request (see
 "Behavior" above) — no extra wiring needed between the two systems.
 ### Seeding
 A starter set of common e-shop labels (`nav.*`, `cart.*`, `product.*`, `auth.*`, `search.*`,
 English + Greek) is seeded by `Modules\Core\Command\InstallLunarCommand` (overrides Lunar's own
 `lunar:install`), guarded by `LanguageLine::where('group', 'storefront')->exists()` — same
 idempotent pattern as the rest of that command, safe to run unattended on every boot.
 ### Admin UI
 `Modules\Core\Localization\Filament\Resources\LanguageLineResource` (registered in
 `CorePlugin`, under the panel's Settings group) lists/searches/filters `language_lines` and
 edits each row's `group`, `key`, and one text input per row currently in `lunar_languages` —
 the locale columns are generated dynamically from `Language::query()->pluck('code')`, so adding
 a third language automatically adds a third input, no resource changes needed.
 ### `TranslationService` — writes go through here, not the model directly
 `Modules\Core\Localization\TranslationService` wraps create/update/delete on `LanguageLine` and
 dispatches a domain event after each write, following this project's standard event-driven
 pattern (see `modules.md`'s "Splitting Service Providers" / event-listener convention —
 the same shape as `Modules\Core\Auth\Events\UserCreated`):
 ```php
 use Modules\Core\Localization\TranslationService;
 app(TranslationService::class)->create('storefront', 'nav.wishlist', [
    'en' => 'Wishlist',
    'el' => 'Λίστα Επιθυμιών',
 ]);
 app(TranslationService::class)->update(
    $languageLine,
    'storefront',
    'nav.wishlist',
    ['en' => 'Wishlist ♥', 'el' => 'Λίστα Επιθυμιών ♥'],
 );
 app(TranslationService::class)->delete($languageLine);
 ```
 `update()` takes the full `group`/`key`/`text` state, not just `text` — a rename is a normal
 update, not a special case. `TranslationCreated`, `TranslationUpdated` (carries the full
 `{group, key, text}` snapshot from *before* the update, so a listener can tell a rename from a
 text edit), and `TranslationDeleted` are dispatched from `Modules\Core\Localization\Events`. Two
 listeners are wired in `Modules\Core\Providers\LocalizationServiceProvider` for all three events:
 - **`FlushTranslationCache`** — `LanguageLine::boot()` already flushes the cache for the
  *current* group's locales present after a save, but misses two cases on update: locales a save
  *removed* from `text` (e.g. dropping the `el` key leaves `storefront.el` stale), and a changed
  `group`/`key` (the *old* group's cached array is never told a row left it). This listener
  flushes every group+locale combination touched by either the old or new state, so nothing —
  including the group a row was renamed away from — can remain stale.
 - **`LogTranslationActivity`** — records the change via `Modules\Core\Logging\ActivityLogService`
  on the `lunar` activity log channel, same `created`/`updated`/`deleted` shape as every other
  domain write in this project. A rename shows up in the log as an `old`/`attributes` diff across
  `group`, `key`, and `text` together, not just a text diff.
 The Filament resource's Create/Edit/Delete pages route through `TranslationService` (via
 `handleRecordCreation`/`handleRecordUpdate`/the delete action's `->action()` override) rather
 than Filament's default direct-model calls, so **every** edit made in the admin UI — including a
 bare `group`/`key` rename with no `text` change — dispatches `TranslationUpdated` and is both
 cache-invalidated and audit-logged.
@@ -1206,6 +1206,3 @@ Real bugs/traps hit while building against Lunar in this package — not obvious
 - **`ProductOption.handle` must be unique and non-null if a product has more than one option.** Lunar's Filament variant-switcher widget does `SelectFilter::make($option->handle)` per option — two options with a `null`/matching handle throws "Filter must have a unique name" as a 500 when opening that product's variant pricing page. Always derive a slug and check uniqueness.
 - **`Attribute.position` is per-group, and the panel sorts by it.** Hardcoding `position => 1` for multiple new attributes in the same group makes their order undefined/collide with existing attributes at position 1. Compute `max('position') + 1` per group instead.
 - **Currency `decimal_places` isn't always 2.** A seeded/demo currency can have the wrong value (seen: EUR seeded with `decimal_places = 1`), which silently corrupts every price display (`€16.50` renders as `165`). If prices look wrong by a factor of 10, check the currency row before assuming the price-writing code is broken.
 - **`Builder::paginateRaw()`'s `items()` is not a hit list on the Meilisearch driver.** It contains the *entire* raw response (`hits`, `query`, `processingTimeMs`, `hitsPerPage`, `page`, `totalPages`, `totalHits`) as one associative array. Treating `$paginator->items()` as a plain list (e.g. `collect($paginator->items())->values()`) silently produces 7 elements — the real hits array happens to land first, the rest are stray scalars from the other response keys — no error, just corrupted data. Pull `$paginator->items()['hits']` explicitly. `total()`/`perPage()`/`currentPage()`/`lastPage()` on the paginator are unaffected. See `Modules\Core\Catalog\ProductService` / `docs/product-listing.md`.
 - **`ProductOption`/`ProductOptionValue::$name` is not `attribute_data` — `translateAttribute('name')` silently returns null for them.** Unlike `Product`/`Collection`/`Brand`, their translated `name` is a plain locale-keyed array cast (`AsArrayObject`) directly on the column, not stored in `attribute_data`. `HasTranslations::translateAttribute()` only reads `attribute_data`, so calling it on these two models compiles fine and returns `null` with no error — read the array directly instead (`$value->name[$locale] ?? ...`). See `Modules\Core\Search\ProductIndexer::translatedName()`.
 - **A running `queue:work` process does not pick up an edited/newly-added Scout indexer class.** It loads PHP classes once at boot and keeps them for the process's lifetime. Symptoms: reindexing commands succeed with no errors, calling `toSearchableArray()` directly (e.g. via `artisan tinker`, which always boots fresh) returns the new fields correctly, but documents written via `$model->searchable()` through the live queue are still missing them. Restart the queue worker after deploying an indexer change — no code fix needed.
@@ -1,177 +0,0 @@
 # Product Listing
 `Modules\Core\Catalog\ProductService` provides catalog browsing/filtering AND single-product
 lookup for a storefront — `list()`, `getById()`, `getBySlug()` — all reading directly from the
 Meilisearch index rather than the database. One data source for everything this service does.
 This is separate from `Modules\Core\Search\ProductSearchService` (see `product-search.md`), which
 handles free-text query search. `ProductService` is for browsing/lookup without a search term.
 ---
 ## Why it reads from the index, not the database
 Every method here reads Meilisearch documents directly and returns plain arrays — never Scout's
 `->get()`, which would re-hydrate Eloquent models from the database. This means the index has to
 carry everything a detail page needs (variants, prices, options, media, reviews — see below), not
 just the trimmed fields a listing page needs. `Modules\Core\Search\ProductIndexer` is built to
 carry that full shape.
 ---
 ## Usage
 ```php
 use Modules\Core\Catalog\ProductFilters;
 use Modules\Core\Catalog\ProductService;
 use Modules\Core\Catalog\ProductSort;
 $service = app(ProductService::class);
 // List everything, paginated
 $result = $service->list(perPage: 24, page: 1);
 // Filter by collection, brand, and/or price range
 $result = $service->list(
    filters: new ProductFilters(collectionId: 17, minPrice: 10.0, maxPrice: 50.0),
    perPage: 24,
    page: 1,
 );
 // Sort — cheapest/priciest first, or newest first. Omit for Meilisearch's default
 // relevance ordering (irrelevant here since the query is always empty).
 $result = $service->list(perPage: 24, page: 1, sort: ProductSort::PriceAsc);
 $result['data'];               // array of Meilisearch documents (plain arrays, not models)
 $result['meta']['total'];
 $result['meta']['per_page'];
 $result['meta']['current_page'];
 $result['meta']['last_page'];
 // Single product, by primary key
 $product = $service->getById(367);   // array, or null if not found
 // Single product, by URL slug (any locale — slugs are indexed across all languages)
 $product = $service->getBySlug('erotika-mprelok');   // array, or null if not found
 ```
 All `ProductFilters` fields are optional; only the ones set are added to the Meilisearch query.
 ---
 ## Fields this depends on: `Modules\Core\Search\ProductIndexer`
 Lunar's own `Lunar\Search\ProductIndexer` only carries listing-grade fields (name, description,
 status, brand, a single thumbnail, skus) and marks just `__soft_deleted`, `skus`, `status` as
 filterable. `Modules\Core\Search\ProductIndexer` extends it to add everything `ProductService`
 needs, listing and detail alike:
 | Field | Source | Notes |
 |---|---|---|
 | `id` | — | Newly marked **filterable** — needed for `getById()`'s `id = "..."` filter; Meilisearch doesn't filter on the primary key by default. |
 | `collections` | `$product->collections->pluck('id')` | Filterable. Array of collection IDs (as strings) — filtering matches by ID, not slug. |
 | `collection_names` | `$product->collections` | Display only, not filterable — translated collection names. |
 | `slugs` | `$product->urls->pluck('slug')` | Filterable. Every locale's `Url::slug` for the product, so `getBySlug()` resolves purely from the index — no database read. |
 | `price` | Cheapest variant's base price | Filterable. Float in major units (e.g. `19.99`, not `1999`). Base price only — no customer group, default currency (`Currency::getDefault()`) only. `null` if the product has no priced variant yet, so it's excluded from range filters rather than treated as free. |
 | `brand` | Already indexed by Lunar's base indexer | Newly marked **filterable** — it existed in the document already, just wasn't usable in a `filter` clause. |
 | `tags` | `$product->tags->pluck('value')` | Display only. |
 | `media` | `$product->media` | Full gallery (id/url/thumb per image), not just the single thumbnail Lunar's base indexer sends. |
 | `variants` | `$product->variants` | Per variant: `id`, `sku`, `stock`, `purchasable`, `options` (option/value names, in the current locale), `prices` (per currency/customer group), `media` (variant-specific images). |
 | `reviews`, `review_count`, `average_rating` | `Modules\Core\Review\Models\ProductReview` | See "Reviews" below. |
 `description` and other translated attributes are indexed as-is, including any HTML markup
 (e.g. from a Shopify `Body (HTML)` import) — **not stripped**. Any view rendering a description
 sourced from `ProductService`'s results must treat it as trusted HTML.
 **`ProductOption`/`ProductOptionValue` names need a different translation accessor.** Unlike
 `Product`/`Collection`/`Brand`, their `name` is a plain locale-keyed array cast, not
 `attribute_data` — Lunar's `translateAttribute('name')` silently returns `null` for them. The
 indexer's `translatedName()` reads the array directly instead. See `docs/lunar.md` "Gotchas".
 ---
 ## Reviews
 `Modules\Core\Review\Models\ProductReview` (`product_reviews` table) is indexed per-product as
 `reviews` (array), plus `review_count` and `average_rating` (rounded to 1 decimal, `null` if the
 product has no reviews). Only public-safe fields are included — **`reviewer_email` is deliberately
 excluded**, it's PII with no storefront use. `reply`/`replied_at` (the staff response) are
 included, since they're meant to be shown alongside the review.
 A review is created/edited independently of its product (a customer submission, a staff reply)
 — its own save doesn't touch the `Product` row, so the product's own model events never fire.
 `Modules\Core\Providers\ReviewServiceProvider` listens on `ProductReview`'s `created`/`updated`/
 `deleted` events and calls `$review->product->searchable()`, so the parent product's document
 stays current without waiting for the next full reindex. This provider must be registered in
 `composer.json`'s `extra.laravel.providers` (already done in this repo) — see `docs/modules.md`
 "Provider Registration Pitfalls" for what happens if a provider like this is ever added but not
 registered.
 ---
 ## Multi-variant products and price
 A product's `price` is its *cheapest* variant's price ("from €19.99" style), not every variant's
 price. A price-range filter matches based on that single minimum — a product with one cheap
 variant and several expensive ones will match a low-price-range filter even though most of its
 variants don't.
 ---
 ## Sorting
 `ProductSort` (`Modules\Core\Catalog\ProductSort`) is a fixed enum of supported sort orders —
 `PriceAsc`, `PriceDesc`, `Newest` — each mapping to a Meilisearch `sort` clause against a field
 `Modules\Core\Search\ProductIndexer::getSortableFields()` marks sortable (`price`, plus
 `created_at`/`updated_at`/`skus`/`status` inherited from Lunar's base indexer). Adding a new
 `ProductSort` case requires adding the matching field to `getSortableFields()` and re-syncing (see
 below) — sortable attributes are index settings, not computed per-query, same as filterable ones.
 Omitting `sort` leaves Meilisearch's default ordering, which is meaningless here since `list()`
 always searches with an empty query string (`Product::search('')`) — there's no relevance score to
 rank by, so results come back in whatever order the index returns them absent an explicit sort.
 ---
 ## Registering the indexer
 Not automatic — an app opts in via its own `config/lunar/search.php`:
 ```php
 'indexers' => [
    Lunar\Models\Product::class => Modules\Core\Search\ProductIndexer::class,
    // ...other model indexers unchanged
 ],
 ```
 ## Re-syncing after this change
 Filterable attributes are Meilisearch index settings, not computed per-query — changing them
 requires re-syncing settings and reindexing existing documents:
 ```bash
 php artisan lunar:meilisearch:setup
 php artisan lunar:search:index "Lunar\Models\Product" --refresh
 ```
 **If `SCOUT_QUEUE=true`, restart the queue worker after deploying an indexer change.** A running
 `queue:work` process loads PHP classes once at boot and keeps that code in memory for its entire
 lifetime — it does not pick up an edited/newly-deployed indexer class. Symptoms: reindexing
 commands succeed with no errors, `Product::toSearchableArray()` returns the new fields correctly
 when called directly (e.g. via `artisan tinker`, which always boots fresh), but documents written
 via `$model->searchable()` through the live queue are still missing the new fields. Restarting the
 queue worker (`docker compose restart queue`, or equivalent) resolves it — no code change needed.
 ---
 ## Meilisearch driver quirk: `paginateRaw()`'s `items()` is not a list of hits
 For the Meilisearch engine specifically, Scout's `Builder::paginateRaw()` puts the **entire raw
 response** (`hits`, `query`, `processingTimeMs`, `hitsPerPage`, `page`, `totalPages`, `totalHits`)
 into the paginator's `items()`, not a plain array of documents. Calling `$paginator->items()`
 and treating it as a list (e.g. `collect($paginator->items())->values()`) silently produces a
 7-element array whose first element happens to be the real hits and the rest are stray scalars
 from the other response keys — no error, just wrong data leaking into what looks like a normal
 list. `ProductService::list()` pulls `$paginator->items()['hits']` explicitly to avoid this;
 `$paginator->total()`/`perPage()`/`currentPage()`/`lastPage()` are unaffected and safe to use
 as-is.
@@ -1,81 +0,0 @@
 # Product Search
 `Modules\Core\Search\ProductSearchService` provides locale-aware full-text product search on
 top of Laravel Scout + Meilisearch.
 ---
 ## Why locale-aware search isn't a filter
 Lunar's Meilisearch indexer (`Lunar\Search\ScoutIndexer::mapSearchableAttributes()`) flattens
 every translated attribute into **locale-suffixed fields on a single document** — a product with
 a translated `name` produces `name_en`, `name_el`, etc. as separate top-level fields, not
 separate documents per locale and not a filterable `locale` field.
 That means "search in Greek" isn't a `->filter('locale = el')` — Meilisearch has no such field to
 filter on. It's a choice of **which fields the query targets**: `name_el`/`description_el`
 instead of `name_en`/`description_en`. This is what Meilisearch's `attributesToSearchOn` search
 parameter controls, exposed through Scout via `Builder::options()`, which passes straight through
 to the underlying Meilisearch client call (`Laravel\Scout\Engines\MeilisearchEngine::performSearch()`
 merges `$builder->options` directly into the search request).
 ---
 ## Usage
 ```php
 use Modules\Core\Search\ProductSearchService;
 $results = app(ProductSearchService::class)->search('running shoes');
 // or an explicit locale, bypassing App::getLocale():
 $results = app(ProductSearchService::class)->search('running shoes', 'el');
 ```
 Returns an `Illuminate\Database\Eloquent\Collection` of `Lunar\Models\Product` — Scout's
 `->get()` hydrates real models from the database after the Meilisearch query, so relations
 (`variants`, `brand`, `media`, etc.) are available on the results as normal.
 `$locale` defaults to `App::getLocale()` — already set correctly on every storefront request by
 `Modules\Core\Localization\LocaleMiddleware` (see `localization.md`), so callers in controllers
 don't need to pass it explicitly.
 ---
 ## Missing-translation fallback
 If a product was only ever given an English name, `name_el` doesn't exist on that document at
 all (Lunar's indexer only writes a `{handle}_{locale}` field for locales actually present in the
 attribute's stored data — see `ScoutIndexer::mapSearchableAttributes()`). Searching strictly
 against `name_el` would make that product invisible to Greek-locale search, even though it's a
 real catalog item.
 To avoid silently hiding incompletely-translated products, `ProductSearchService` targets **both**
 the resolved locale's fields **and** the default language's fields
 (`Lunar\Models\Language::getDefault()->code`) — e.g. searching in `el` targets `name_el`,
 `name_en`, `description_el`, `description_en` together (assuming `en` is the default language).
 A product missing an `el` translation still matches via its `en` fields.
 ---
 ## Field list is dynamic, not hardcoded
 The set of attribute handles searched (`name`, `description`, or whatever else) comes from
 `Lunar\Facades\AttributeManifest::getSearchableAttributes(Product::morphName())` — the same
 source `ScoutIndexer` itself uses to decide what gets indexed. If an admin marks a new attribute
 searchable in the panel, `ProductSearchService` picks it up automatically; nothing in this class
 needs to change.
 ---
 ## Re-syncing after indexer changes
 Changing which attributes are searchable, or `ProductIndexer`'s filterable/sortable fields,
 requires re-syncing Meilisearch's index settings and re-indexing existing documents:
 ```bash
 php artisan lunar:meilisearch:setup
 php artisan lunar:search:index "Lunar\Models\Product" --refresh
 ```
 `ProductSearchService` itself needs no re-sync when locales change — `attributesToSearchOn` is
 computed per-query from the live language list, not baked into index settings.
@@ -46,10 +46,6 @@
                <x-filament::button type="submit" class="w-full">
                    Sign in
                </x-filament::button>
                <x-filament::link wire:click="back" tag="button" type="button" class="mx-auto">
                    &larr; Back
                </x-filament::link>
            </div>
        </form>
    @endif
@@ -0,0 +1,3 @@
 <x-filament-panels::page>
    {{ $this->table }}
 </x-filament-panels::page>
@@ -35,12 +35,6 @@ class Login extends SimplePage
        }
    }
    public function back(): void
    {
        $this->otpSent = false;
        $this->otp = '';
    }
    public function requestOtp(): void
    {
        $this->validate(['email' => 'required|email']);
@@ -1,20 +0,0 @@
 <?php
 namespace Modules\Core\Catalog;
 /**
 * Filter input for ProductService::list(). All fields are optional — omitted
 * filters are simply not added to the Meilisearch query. Values are matched
 * against Modules\Core\Search\ProductIndexer's document fields, so filtering
 * only works on stores where that indexer is registered and the index has
 * been re-synced (see docs/product-listing.md).
 */
 class ProductFilters
 {
    public function __construct(
        public readonly ?int $collectionId = null,
        public readonly ?string $brand = null,
        public readonly ?float $minPrice = null,
        public readonly ?float $maxPrice = null,
    ) {}
 }
@@ -1,130 +0,0 @@
 <?php
 namespace Modules\Core\Catalog;
 use Illuminate\Contracts\Pagination\LengthAwarePaginator;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\App;
 use Lunar\Models\Product;
 use Modules\Core\Localization\LocaleMiddleware;
 /**
 * Storefront product listing/filtering AND single-product lookup, all reading directly
 * from the Meilisearch index (Modules\Core\Search\ProductIndexer) - one data source, no
 * ->get() model hydration anywhere in this service. Callers get plain arrays of the
 * indexed document, not Eloquent models.
 *
 * Full-text query search lives separately in Modules\Core\Search\ProductSearchService;
 * this service is for browsing/filtering without a search term.
 */
 class ProductService
 {
    /**
     * @return array{data: array<int, array>, meta: array}
     */
    public function list(?ProductFilters $filters = null, int $perPage = 24, int $page = 1, ?ProductSort $sort = null): array
    {
        $options = ['filter' => $this->buildFilter($filters)];
        if ($sort !== null) {
            $options['sort'] = [$sort->toMeilisearchSort()];
        }
        $paginator = Product::search('')
            ->options($options)
            ->paginateRaw(perPage: $perPage, page: $page);
        return [
            'data' => collect($this->hitsFrom($paginator))
                ->map(fn (array $product) => $this->withLocalizedFields($product))
                ->all(),
            'meta' => [
                'total' => $paginator->total(),
                'per_page' => $paginator->perPage(),
                'current_page' => $paginator->currentPage(),
                'last_page' => $paginator->lastPage(),
            ],
        ];
    }
    /**
     * Look up a single product by its URL slug (any locale - slugs are indexed across
     * all languages, see Modules\Core\Search\ProductIndexer). Returns the full indexed
     * product document, or null if no product has that slug.
     */
    public function getBySlug(string $slug): ?array
    {
        return $this->findOneWhere('slugs = "'.addcslashes($slug, '"\\').'"');
    }
    /**
     * Look up a single product by its primary key. Returns the full indexed product
     * document, or null if no product has that id.
     */
    public function getById(int $id): ?array
    {
        return $this->findOneWhere("id = \"{$id}\"");
    }
    private function findOneWhere(string $filter): ?array
    {
        $paginator = Product::search('')
            ->options(['filter' => $filter])
            ->paginateRaw(perPage: 1, page: 1);
        $product = $this->hitsFrom($paginator)[0] ?? null;
        return $product !== null ? $this->withLocalizedFields($product) : null;
    }
    /**
     * Resolves the current-locale `name`/`description` from the indexer's
     * per-locale `name_{locale}`/`description_{locale}` fields, falling back to
     * the store's default language (Language::default, see
     * LocaleMiddleware::defaultLocale()) when the current locale has no
     * translation - e.g. a product with no English copy yet still shows its
     * Greek name/description on /en/ rather than rendering blank.
     *
     * Deliberately not config('app.locale') - App::setLocale() overwrites that
     * config value on every request, so by request time it's just whatever the
     * current locale already is, not a stable fallback.
     */
    private function withLocalizedFields(array $product): array
    {
        $locale = App::getLocale();
        $fallbackLocale = LocaleMiddleware::defaultLocale();
        $product['name'] = $product['name_'.$locale] ?? $product['name_'.$fallbackLocale] ?? null;
        $product['description'] = $product['description_'.$locale] ?? $product['description_'.$fallbackLocale] ?? null;
        return $product;
    }
    /**
     * For the Meilisearch driver, Scout's paginateRaw() puts the whole raw response
     * (hits, query, processingTimeMs, ...) in items(), not a plain list of hits - the
     * actual documents are under the 'hits' key.
     */
    private function hitsFrom(LengthAwarePaginator $paginator): array
    {
        $rawResponse = $paginator->items();
        return collect($rawResponse['hits'] ?? [])->values()->all();
    }
    private function buildFilter(?ProductFilters $filters): ?string
    {
        if ($filters === null) {
            return null;
        }
        $clauses = Collection::make([
            $filters->collectionId !== null ? "collections = \"{$filters->collectionId}\"" : null,
            $filters->brand !== null ? 'brand = "'.addcslashes($filters->brand, '"\\').'"' : null,
            $filters->minPrice !== null ? "price >= {$filters->minPrice}" : null,
            $filters->maxPrice !== null ? "price <= {$filters->maxPrice}" : null,
        ])->filter();
        return $clauses->isEmpty() ? null : $clauses->join(' AND ');
    }
 }
@@ -1,25 +0,0 @@
 <?php
 namespace Modules\Core\Catalog;
 /**
 * Sort options for ProductService::list(), each mapped to a Meilisearch `sort`
 * clause against a field indexed as sortable by Modules\Core\Search\ProductIndexer
 * (see its getSortableFields()). Adding a case here requires the matching field
 * to also be sortable in the index, re-synced via `php artisan lunar:meilisearch:setup`.
 */
 enum ProductSort: string
 {
    case PriceAsc = 'price_asc';
    case PriceDesc = 'price_desc';
    case Newest = 'newest';
    public function toMeilisearchSort(): string
    {
        return match ($this) {
            self::PriceAsc => 'price:asc',
            self::PriceDesc => 'price:desc',
            self::Newest => 'created_at:desc',
        };
    }
 }
@@ -18,7 +18,6 @@ use Lunar\Models\Product;
 use Lunar\Models\ProductType;
 use Lunar\Models\TaxClass;
 use Lunar\Models\TaxZone;
 use Spatie\TranslationLoader\LanguageLine;
 /**
 * Overrides Lunar's own lunar:install to skip the interactive prompts (migrate
@@ -242,43 +241,9 @@ class InstallLunarCommand extends Command
            }
        });
        if (! LanguageLine::where('group', 'storefront')->exists()) {
            $this->components->info('Seeding storefront label translations');
            $this->seedStorefrontLabels();
        }
        $this->components->info('Publishing Filament assets');
        $this->call('filament:assets');
        $this->components->info('Lunar default data seeded.');
    }
    private function seedStorefrontLabels(): void
    {
        $labels = [
            'nav.home' => ['en' => 'Home', 'el' => 'Αρχική'],
            'nav.products' => ['en' => 'Products', 'el' => 'Προϊόντα'],
            'nav.cart' => ['en' => 'Cart', 'el' => 'Καλάθι'],
            'nav.account' => ['en' => 'Account', 'el' => 'Λογαριασμός'],
            'nav.back' => ['en' => 'Back', 'el' => 'Πίσω'],
            'cart.empty' => ['en' => 'Your cart is empty', 'el' => 'Το καλάθι σας είναι άδειο'],
            'cart.checkout' => ['en' => 'Checkout', 'el' => 'Ολοκλήρωση Παραγγελίας'],
            'cart.total' => ['en' => 'Total', 'el' => 'Σύνολο'],
            'cart.remove' => ['en' => 'Remove', 'el' => 'Αφαίρεση'],
            'product.add_to_cart' => ['en' => 'Add to Cart', 'el' => 'Προσθήκη στο Καλάθι'],
            'product.out_of_stock' => ['en' => 'Out of Stock', 'el' => 'Εξαντλήθηκε'],
            'product.price' => ['en' => 'Price', 'el' => 'Τιμή'],
            'auth.login' => ['en' => 'Log In', 'el' => 'Σύνδεση'],
            'auth.logout' => ['en' => 'Log Out', 'el' => 'Αποσύνδεση'],
            'search.placeholder' => ['en' => 'Search products…', 'el' => 'Αναζήτηση προϊόντων…'],
        ];
        foreach ($labels as $key => $text) {
            LanguageLine::create([
                'group' => 'storefront',
                'key' => $key,
                'text' => $text,
            ]);
        }
    }
 }
@@ -6,18 +6,24 @@ use Filament\Contracts\Plugin;
 use Filament\Panel;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Support\Facades\Mail;
 use Lunar\Admin\Filament\Resources\OrderResource;
 use Lunar\Admin\Filament\Resources\ProductResource;
 use Lunar\Admin\Filament\Resources\StaffResource;
 use Lunar\Admin\Models\Staff as LunarStaff;
 use Lunar\Admin\Support\Facades\LunarPanel;
 use Lunar\Models\Product;
 use Lunar\Shipping\Filament\Resources\ShippingMethodResource;
 use Lunar\Shipping\Filament\Resources\ShippingMethodResource\Pages\ListShippingMethod;
 use Lunar\Shipping\ShippingPlugin;
 use Modules\Core\Auth\Extensions\StaffResourceExtension;
 use Modules\Core\Auth\Filament\Pages\Login;
 use Modules\Core\Auth\Mail\InviteMail;
 use Modules\Core\Localization\Filament\Resources\LanguageLineResource;
 use Modules\Core\Review\Extensions\ProductResourceExtension;
 use Modules\Core\Review\Models\ProductReview;
 use Modules\Core\Shipping\Extensions\OrderViewExtension;
 use Modules\Core\Shipping\Extensions\ShippingMethodListExtension;
 use Modules\Core\Shipping\Extensions\ShippingMethodResourceExtension;
 use Modules\Core\Shipping\Filament\Pages\ManagePickupManifests;
 class CorePlugin implements Plugin
 {
@@ -33,14 +39,15 @@ class CorePlugin implements Plugin
            ->brandLogo(asset('static/logos/core/boboko-logo.svg'))
            ->darkModeBrandLogo(asset('static/logos/core/boboko-logo-white.svg'))
            ->login(Login::class)
-            ->resources([
+            ->plugin(ShippingPlugin::make())
-                LanguageLineResource::class,
+            ->pages([ManagePickupManifests::class]);
            ])
            ->plugin(ShippingPlugin::make());
        LunarPanel::extensions([
            StaffResource::class => StaffResourceExtension::class,
            ProductResource::class => ProductResourceExtension::class,
            ShippingMethodResource::class => ShippingMethodResourceExtension::class,
            ListShippingMethod::class => ShippingMethodListExtension::class,
            OrderResource\Pages\ManageOrder::class => OrderViewExtension::class,
        ]);
        Product::macro('reviews', function (): HasMany {
@@ -1,12 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Events;
 use Lunar\Models\Language;
 class LanguageCreated
 {
    public function __construct(
        public readonly Language $language,
    ) {}
 }
@@ -1,12 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Events;
 use Lunar\Models\Language;
 class LanguageDeleted
 {
    public function __construct(
        public readonly Language $language,
    ) {}
 }
@@ -1,16 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Events;
 use Lunar\Models\Language;
 class LanguageUpdated
 {
    /**
     * @param  array{code: string}  $old  Snapshot of watched attributes before the update.
     */
    public function __construct(
        public readonly Language $language,
        public readonly array $old,
    ) {}
 }
@@ -1,12 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Events;
 use Spatie\TranslationLoader\LanguageLine;
 class TranslationCreated
 {
    public function __construct(
        public readonly LanguageLine $languageLine,
    ) {}
 }
@@ -1,12 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Events;
 use Spatie\TranslationLoader\LanguageLine;
 class TranslationDeleted
 {
    public function __construct(
        public readonly LanguageLine $languageLine,
    ) {}
 }
@@ -1,16 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Events;
 use Spatie\TranslationLoader\LanguageLine;
 class TranslationUpdated
 {
    /**
     * @param  array{group: string, key: string, text: array}  $old  Snapshot before the update.
     */
    public function __construct(
        public readonly LanguageLine $languageLine,
        public readonly array $old,
    ) {}
 }
@@ -1,107 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Filament\Resources;
 use Filament\Forms;
 use Filament\Forms\Form;
 use Filament\Resources\Resource;
 use Filament\Tables;
 use Filament\Tables\Table;
 use Lunar\Models\Language;
 use Modules\Core\Localization\Filament\Resources\LanguageLineResource\Pages;
 use Spatie\TranslationLoader\LanguageLine;
 class LanguageLineResource extends Resource
 {
    protected static ?string $model = LanguageLine::class;
    protected static ?string $navigationIcon = 'heroicon-o-language';
    protected static ?string $navigationGroup = 'Settings';
    protected static ?string $modelLabel = 'Translation';
    protected static ?string $pluralModelLabel = 'Translations';
    public static function form(Form $form): Form
    {
        return $form->schema([
            Forms\Components\TextInput::make('group')
                ->required()
                ->maxLength(255)
                ->default('storefront')
                ->helperText('Namespace for this label, e.g. "storefront" for e-shop UI text.'),
            Forms\Components\TextInput::make('key')
                ->required()
                ->maxLength(255)
                ->helperText('Dot-notation key, e.g. "nav.cart".'),
            Forms\Components\Fieldset::make('Translations')
                ->schema(static::localeInputs()),
        ]);
    }
    public static function table(Table $table): Table
    {
        return $table
            ->columns([
                Tables\Columns\TextColumn::make('group')
                    ->badge()
                    ->sortable(),
                Tables\Columns\TextColumn::make('key')
                    ->searchable()
                    ->sortable(),
                ...static::localeColumns(),
            ])
            ->filters([
                Tables\Filters\SelectFilter::make('group')
                    ->options(fn () => LanguageLine::query()->distinct()->pluck('group', 'group')),
            ])
            ->defaultSort('key');
    }
    public static function getRelations(): array
    {
        return [];
    }
    public static function getPages(): array
    {
        return [
            'index' => Pages\ListLanguageLines::route('/'),
            'create' => Pages\CreateLanguageLine::route('/create'),
            'edit' => Pages\EditLanguageLine::route('/{record}/edit'),
        ];
    }
    /**
     * @return array<Forms\Components\Textarea>
     */
    private static function localeInputs(): array
    {
        return static::localeCodes()
            ->map(fn (string $code) => Forms\Components\Textarea::make("text.{$code}")
                ->label(strtoupper($code))
                ->rows(2))
            ->all();
    }
    /**
     * @return array<Tables\Columns\TextColumn>
     */
    private static function localeColumns(): array
    {
        return static::localeCodes()
            ->map(fn (string $code) => Tables\Columns\TextColumn::make("text.{$code}")
                ->label(strtoupper($code))
                ->limit(40)
                ->toggleable())
            ->all();
    }
    private static function localeCodes(): \Illuminate\Support\Collection
    {
        return Language::query()->pluck('code');
    }
 }
@@ -1,22 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Filament\Resources\LanguageLineResource\Pages;
 use Filament\Resources\Pages\CreateRecord;
 use Illuminate\Database\Eloquent\Model;
 use Modules\Core\Localization\Filament\Resources\LanguageLineResource;
 use Modules\Core\Localization\TranslationService;
 class CreateLanguageLine extends CreateRecord
 {
    protected static string $resource = LanguageLineResource::class;
    protected function handleRecordCreation(array $data): Model
    {
        return app(TranslationService::class)->create(
            $data['group'],
            $data['key'],
            $data['text'] ?? [],
        );
    }
 }
@@ -1,53 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Filament\Resources\LanguageLineResource\Pages;
 use Filament\Actions;
 use Filament\Actions\Action;
 use Filament\Resources\Pages\EditRecord;
 use Illuminate\Database\Eloquent\Model;
 use Modules\Core\Localization\Filament\Resources\LanguageLineResource;
 use Modules\Core\Localization\TranslationService;
 use Spatie\TranslationLoader\LanguageLine;
 class EditLanguageLine extends EditRecord
 {
    protected static string $resource = LanguageLineResource::class;
    protected function getHeaderActions(): array
    {
        return [
            Actions\DeleteAction::make()
                ->action(function (LanguageLine $record) {
                    app(TranslationService::class)->delete($record);
                    $this->redirect($this->getResource()::getUrl('index'));
                }),
        ];
    }
    /**
     * Filament's default Cancel button uses window.history.back(), which
     * restores the browser's cached previous page instead of re-fetching —
     * so an edit made just before clicking Cancel doesn't show up in the
     * list until a manual refresh. Redirect through Livewire instead, which
     * always re-queries.
     */
    protected function getCancelFormAction(): Action
    {
        return Action::make('cancel')
            ->label(__('filament-panels::resources/pages/edit-record.form.actions.cancel.label'))
            ->url(static::getResource()::getUrl('index'))
            ->color('gray');
    }
    protected function handleRecordUpdate(Model $record, array $data): Model
    {
        return app(TranslationService::class)->update(
            $record,
            $data['group'],
            $data['key'],
            $data['text'] ?? [],
        );
    }
 }
@@ -1,19 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Filament\Resources\LanguageLineResource\Pages;
 use Filament\Actions;
 use Filament\Resources\Pages\ListRecords;
 use Modules\Core\Localization\Filament\Resources\LanguageLineResource;
 class ListLanguageLines extends ListRecords
 {
    protected static string $resource = LanguageLineResource::class;
    protected function getHeaderActions(): array
    {
        return [
            Actions\CreateAction::make(),
        ];
    }
 }
@@ -1,29 +0,0 @@
 <?php
 namespace Modules\Core\Localization;
 use Illuminate\Support\Facades\Event;
 use Lunar\Models\Language;
 use Modules\Core\Localization\Events\LanguageCreated;
 use Modules\Core\Localization\Events\LanguageDeleted;
 use Modules\Core\Localization\Events\LanguageUpdated;
 class LanguageCacheObserver
 {
    public function created(Language $language): void
    {
        Event::dispatch(new LanguageCreated($language));
    }
    public function updated(Language $language): void
    {
        Event::dispatch(new LanguageUpdated($language, [
            'code' => $language->getOriginal('code'),
        ]));
    }
    public function deleted(Language $language): void
    {
        Event::dispatch(new LanguageDeleted($language));
    }
 }
@@ -1,16 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Listeners;
 use Modules\Core\Localization\Events\LanguageCreated;
 use Modules\Core\Localization\Events\LanguageDeleted;
 use Modules\Core\Localization\Events\LanguageUpdated;
 use Modules\Core\Localization\LocaleMiddleware;
 class FlushLanguageCache
 {
    public function handle(LanguageCreated|LanguageUpdated|LanguageDeleted $event): void
    {
        LocaleMiddleware::forgetLanguagesCache();
    }
 }
@@ -1,36 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Listeners;
 use Illuminate\Support\Facades\Cache;
 use Modules\Core\Localization\Events\TranslationCreated;
 use Modules\Core\Localization\Events\TranslationDeleted;
 use Modules\Core\Localization\Events\TranslationUpdated;
 use Spatie\TranslationLoader\LanguageLine;
 /**
 * LanguageLine::boot() already flushes the cache for the current group's locales
 * present after a save, but misses two cases on update: locales removed from
 * `text` (e.g. dropping the "el" key leaves `{group}.el` stale), and a changed
 * `group`/`key` (the old group's cached array never gets told a row left it).
 * This listener flushes every group+locale combination touched by either the
 * old or new state so nothing can remain stale.
 */
 class FlushTranslationCache
 {
    public function handle(TranslationCreated|TranslationUpdated|TranslationDeleted $event): void
    {
        $this->flush($event->languageLine->group, array_keys($event->languageLine->text ?? []));
        if ($event instanceof TranslationUpdated) {
            $this->flush($event->old['group'], array_keys($event->old['text'] ?? []));
        }
    }
    private function flush(string $group, array $locales): void
    {
        foreach ($locales as $locale) {
            Cache::forget(LanguageLine::getCacheKey($group, $locale));
        }
    }
 }
@@ -1,53 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Listeners;
 use Illuminate\Support\Arr;
 use Modules\Core\Localization\Events\TranslationCreated;
 use Modules\Core\Localization\Events\TranslationDeleted;
 use Modules\Core\Localization\Events\TranslationUpdated;
 use Modules\Core\Logging\ActivityLogService;
 use Spatie\TranslationLoader\LanguageLine;
 class LogTranslationActivity
 {
    public function __construct(
        private readonly ActivityLogService $activityLog,
    ) {}
    public function handle(TranslationCreated|TranslationUpdated|TranslationDeleted $event): void
    {
        $languageLine = $event->languageLine;
        match (true) {
            $event instanceof TranslationCreated => $this->activityLog->created(
                $languageLine,
                $this->flatten($languageLine),
            ),
            $event instanceof TranslationUpdated => $this->activityLog->updated(
                $languageLine,
                Arr::dot($event->old),
                $this->flatten($languageLine),
            ),
            $event instanceof TranslationDeleted => $this->activityLog->deleted(
                $languageLine,
                $this->flatten($languageLine),
            ),
        };
    }
    /**
     * Filament's Activity resource renders `properties` with a flat KeyValue
     * field, which can't display a nested value like `text: {en, el}` — it
     * shows as "[object Object]". Flatten to dot-notation ("text.en",
     * "text.el") so every property is a plain string, viewable as-is.
     */
    private function flatten(LanguageLine $languageLine): array
    {
        return Arr::dot([
            'group' => $languageLine->group,
            'key' => $languageLine->key,
            'text' => $languageLine->text,
        ]);
    }
 }
@@ -1,46 +0,0 @@
 <?php
 namespace Modules\Core\Localization\Listeners;
 use Illuminate\Support\Facades\Cache;
 use Modules\Core\Localization\Events\LanguageUpdated;
 use Spatie\TranslationLoader\LanguageLine;
 /**
 * A renamed Language::code (e.g. "el" -> "gr") would otherwise strand every
 * LanguageLine's translated text under the old, now-unroutable key —
 * getTranslationsForGroup($newCode, ...) would silently return nothing for
 * that locale even though the translated content still exists. Move the
 * text.{oldCode} key to text.{newCode} on every affected row instead.
 */
 class MigrateTranslationsForRenamedLanguage
 {
    public function handle(LanguageUpdated $event): void
    {
        $oldCode = $event->old['code'];
        $newCode = $event->language->code;
        if ($oldCode === $newCode) {
            return;
        }
        $affectedGroups = [];
        LanguageLine::query()
            ->whereJsonContainsKey('text->'.$oldCode)
            ->each(function (LanguageLine $languageLine) use ($oldCode, $newCode, &$affectedGroups) {
                $text = $languageLine->text;
                $text[$newCode] = $text[$oldCode];
                unset($text[$oldCode]);
                $languageLine->update(['text' => $text]);
                $affectedGroups[$languageLine->group] = true;
            });
        foreach (array_keys($affectedGroups) as $group) {
            Cache::forget(LanguageLine::getCacheKey($group, $oldCode));
            Cache::forget(LanguageLine::getCacheKey($group, $newCode));
        }
    }
 }
@@ -1,131 +0,0 @@
 <?php
 namespace Modules\Core\Localization;
 use Closure;
 use Illuminate\Http\Request;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\App;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\URL;
 use Illuminate\Support\Facades\View;
 use Lunar\Models\Language;
 use Symfony\Component\HttpFoundation\Response;
 class LocaleMiddleware
 {
    private const CACHE_KEY = 'core.localization.languages';
    public function handle(Request $request, Closure $next): Response
    {
        $languages = $this->availableLanguages();
        if ($languages->isEmpty()) {
            return $next($request);
        }
        $segment = (string) $request->segment(1);
        $language = $languages->firstWhere('code', $segment);
        if (! $language) {
            return $this->redirectToLocalizedUrl($request, $languages);
        }
        App::setLocale($language->code);
        $request->attributes->set('locale', $language->code);
        $request->attributes->set('language', $language);
        // Lets route() calls omit {locale} anywhere in the request lifecycle
        // (controllers, views) — without this, every route() call would need
        // locale passed explicitly every time.
        URL::defaults(['locale' => $language->code]);
        $this->shareLocaleViewData($request, $language, $languages);
        return $next($request);
    }
    public static function forgetLanguagesCache(): void
    {
        Cache::forget(self::CACHE_KEY);
    }
    /**
     * The store's default language code (e.g. 'el') - the fixed fallback other
     * locale-aware code (Modules\Core\Catalog\ProductService) should use, as
     * opposed to config('app.locale') which App::setLocale() mutates per
     * request and so can't serve as a stable fallback.
     */
    public static function defaultLocale(): ?string
    {
        return (new self)->availableLanguages()->firstWhere('default', true)?->code;
    }
    /**
     * Shares the current locale and every OTHER available locale (each with its
     * own URL for the current page) with all views, so the header language
     * switcher and layout hreflang tags don't have to recompute it.
     *
     * `altLocales` is a collection, not a single value — firstWhere('code', '!=',
     * ...) would only ever surface one alternate, which happens to look correct
     * with exactly 2 configured languages (there's only one "other" to find) but
     * silently drops every locale past the first for a 3+ language store, with no
     * error, just fewer switcher options than actually configured. A view iterates
     * `$altLocales` to render as many links/dropdown entries as there are
     * alternates, whether that's 1 or 10.
     */
    private function shareLocaleViewData(Request $request, Language $language, Collection $languages): void
    {
        $route = $request->route();
        $routeName = $route?->getName();
        $altLocales = $languages
            ->reject(fn (Language $other) => $other->code === $language->code)
            ->map(fn (Language $other) => [
                'code' => $other->code,
                'name' => $other->name,
                'url' => $routeName
                    ? route($routeName, array_merge($route->parameters(), ['locale' => $other->code]))
                    : url('/'.$other->code),
            ])
            ->values();
        View::share('currentLocale', $language->code);
        View::share('altLocales', $altLocales);
    }
    private function redirectToLocalizedUrl(Request $request, Collection $languages): Response
    {
        $locale = $this->negotiateLocale($request, $languages);
        $path = trim($request->getPathInfo(), '/');
        $target = '/'.$locale.($path !== '' ? '/'.$path : '');
        $query = $request->getQueryString();
        if ($query) {
            $target .= '?'.$query;
        }
        return redirect($target);
    }
    private function negotiateLocale(Request $request, Collection $languages): string
    {
        $preferred = $request->getPreferredLanguage($languages->pluck('code')->all());
        if ($preferred) {
            return $preferred;
        }
        return $languages->firstWhere('default', true)?->code
            ?? $languages->first()->code;
    }
    private function availableLanguages(): Collection
    {
        return Cache::rememberForever(
            self::CACHE_KEY,
            fn () => Language::query()->get(['id', 'code', 'name', 'default']),
        );
    }
 }
@@ -1,22 +0,0 @@
 <?php
 namespace Modules\Core\Localization;
 use Illuminate\Support\Facades\App;
 use Spatie\TranslationLoader\LanguageLine;
 class TranslationReader
 {
    private const DEFAULT_GROUP = 'storefront';
    /**
     * All labels in a group for the given (or current) locale, keyed by their
     * dot-notation key — e.g. ['nav.cart' => 'Cart', 'nav.home' => 'Home'].
     * Backed by LanguageLine's own forever-cache, so this is a cache hit after
     * the first call for a given group+locale.
     */
    public function group(string $group = self::DEFAULT_GROUP, ?string $locale = null): array
    {
        return LanguageLine::getTranslationsForGroup($locale ?? App::getLocale(), $group);
    }
 }
@@ -1,57 +0,0 @@
 <?php
 namespace Modules\Core\Localization;
 use Illuminate\Support\Facades\Event;
 use Modules\Core\Localization\Events\TranslationCreated;
 use Modules\Core\Localization\Events\TranslationDeleted;
 use Modules\Core\Localization\Events\TranslationUpdated;
 use Spatie\TranslationLoader\LanguageLine;
 class TranslationService
 {
    public function create(string $group, string $key, array $text): LanguageLine
    {
        $languageLine = LanguageLine::create([
            'group' => $group,
            'key' => $key,
            'text' => $text,
        ]);
        Event::dispatch(new TranslationCreated($languageLine));
        return $languageLine;
    }
    public function update(LanguageLine $languageLine, string $group, string $key, array $text): LanguageLine
    {
        // Callers (e.g. Filament's EditRecord) may hand us a model instance
        // already filled with the new form values in memory — refresh from the
        // database first so $old reflects what's actually persisted, not what's
        // about to be written.
        $persisted = $languageLine->fresh();
        $old = [
            'group' => $persisted->group,
            'key' => $persisted->key,
            'text' => $persisted->text,
        ];
        $languageLine->update([
            'group' => $group,
            'key' => $key,
            'text' => $text,
        ]);
        Event::dispatch(new TranslationUpdated($languageLine, $old));
        return $languageLine;
    }
    public function delete(LanguageLine $languageLine): void
    {
        $languageLine->delete();
        Event::dispatch(new TranslationDeleted($languageLine));
    }
 }
@@ -1,39 +0,0 @@
 <?php
 namespace Modules\Core\Providers;
 use Illuminate\Support\Facades\Event;
 use Illuminate\Support\ServiceProvider;
 use Lunar\Models\Language;
 use Modules\Core\Localization\Events\LanguageCreated;
 use Modules\Core\Localization\Events\LanguageDeleted;
 use Modules\Core\Localization\Events\LanguageUpdated;
 use Modules\Core\Localization\Events\TranslationCreated;
 use Modules\Core\Localization\Events\TranslationDeleted;
 use Modules\Core\Localization\Events\TranslationUpdated;
 use Modules\Core\Localization\LanguageCacheObserver;
 use Modules\Core\Localization\Listeners\FlushLanguageCache;
 use Modules\Core\Localization\Listeners\FlushTranslationCache;
 use Modules\Core\Localization\Listeners\LogTranslationActivity;
 use Modules\Core\Localization\Listeners\MigrateTranslationsForRenamedLanguage;
 use Modules\Core\Localization\LocaleMiddleware;
 class LocalizationServiceProvider extends ServiceProvider
 {
    public function boot(): void
    {
        $this->app['router']->aliasMiddleware('locale', LocaleMiddleware::class);
        Language::observe(LanguageCacheObserver::class);
        foreach ([TranslationCreated::class, TranslationUpdated::class, TranslationDeleted::class] as $event) {
            Event::listen($event, FlushTranslationCache::class);
            Event::listen($event, LogTranslationActivity::class);
        }
        foreach ([LanguageCreated::class, LanguageUpdated::class, LanguageDeleted::class] as $event) {
            Event::listen($event, FlushLanguageCache::class);
        }
        Event::listen(LanguageUpdated::class, MigrateTranslationsForRenamedLanguage::class);
    }
 }
@@ -1,23 +0,0 @@
 <?php
 namespace Modules\Core\Providers;
 use Illuminate\Support\ServiceProvider;
 use Modules\Core\Review\Models\ProductReview;
 /**
 * Keeps a product's Meilisearch document in sync with its reviews. A review is
 * created/edited independently of its product (customer submission, staff reply),
 * so the product's own save/update events never fire for it — without this listener,
 * Modules\Core\Search\ProductIndexer's review data would only refresh on the next
 * full product reindex.
 */
 class ReviewServiceProvider extends ServiceProvider
 {
    public function boot(): void
    {
        ProductReview::created(fn (ProductReview $review) => $review->product?->searchable());
        ProductReview::updated(fn (ProductReview $review) => $review->product?->searchable());
        ProductReview::deleted(fn (ProductReview $review) => $review->product?->searchable());
    }
 }
@@ -0,0 +1,97 @@
 <?php
 namespace Modules\Core\Providers;
 use Illuminate\Console\Scheduling\Schedule as ConsoleSchedule;
 use Illuminate\Support\ServiceProvider;
 use Livewire\Livewire;
 use Livewire\Mechanisms\ComponentRegistry;
 use Lunar\Models\Order;
 use Lunar\Shipping\Facades\Shipping;
 use Lunar\Shipping\Filament\Resources\ShippingZoneResource\Pages\ManageShippingRates as VendorManageShippingRates;
 use Lunar\Shipping\Models\ShippingMethod;
 use Modules\Core\Shipping\Carriers\Acs\AcsClient;
 use Modules\Core\Shipping\Carriers\Acs\AcsFulfillmentService;
 use Modules\Core\Shipping\Carriers\Acs\AcsRateDriver;
 use Modules\Core\Shipping\Carriers\Acs\Jobs\WarmAcsAreaCacheJob;
 use Modules\Core\Shipping\Carriers\BoxNow\BoxNowClient;
 use Modules\Core\Shipping\Carriers\BoxNow\BoxNowFulfillmentService;
 use Modules\Core\Shipping\Carriers\BoxNow\BoxNowRateDriver;
 use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
 use Modules\Core\Shipping\Filament\Pages\ManageShippingRates;
 use Modules\Core\Shipping\Models\Shipment;
 class ShippingServiceProvider extends ServiceProvider
 {
    public function register(): void
    {
        $this->mergeConfigFrom(__DIR__ . '/../../config/shippingCarriers/acs.php', 'acs');
        $this->mergeConfigFrom(__DIR__ . '/../../config/shippingCarriers/boxnow.php', 'boxnow');
        $this->app->singleton(AcsClient::class, fn () => new AcsClient(config('acs')));
        $this->app->singleton(BoxNowClient::class, fn () => new BoxNowClient(config('boxnow')));
        $this->app->bind(CarrierFulfillmentInterface::class, function ($app, array $params) {
            return match ($params['carrier'] ?? null) {
                'acs' => $app->make(AcsFulfillmentService::class),
                'box-now' => $app->make(BoxNowFulfillmentService::class),
                default => null,
            };
        });
        // The vendor Rates page has no extension hook, so we swap it for
        // our subclass everywhere. Route::get($path, VendorClass::class)
        // instantiates the vendor class directly via the container for the
        // initial full-page load (bypassing Livewire's component registry
        // entirely), so this container bind is required in addition to the
        // Livewire::component() re-registration below — the bind covers
        // first load, the Livewire registration covers every AJAX
        // round-trip (form submits, table interactions) afterwards.
        $this->app->bind(VendorManageShippingRates::class, ManageShippingRates::class);
    }
    public function boot(): void
    {
        $this->publishes([
            __DIR__ . '/../../config/shippingCarriers/acs.php' => config_path('shippingCarriers/acs.php'),
            __DIR__ . '/../../config/shippingCarriers/boxnow.php' => config_path('shippingCarriers/boxnow.php'),
        ], 'core-config');
        Order::resolveRelationUsing('shipments', function ($order) {
            return $order->hasMany(Shipment::class);
        });
        // Deferred: the Shipping facade resolves a binding registered in
        // lunarphp/table-rate-shipping's own ShippingServiceProvider::boot(),
        // and provider boot order between packages isn't guaranteed.
        $this->app->booted(function () {
            Shipping::extend('acs', fn ($app) => $app->make(AcsRateDriver::class));
            Shipping::extend('box-now', fn ($app) => $app->make(BoxNowRateDriver::class));
            $this->app->make(ConsoleSchedule::class)
                ->job(new WarmAcsAreaCacheJob)
                ->dailyAt('06:00')
                ->when(fn () => ShippingMethod::where('driver', 'acs')->exists());
            $this->overrideRatesPageLivewireComponent();
        });
    }
    /**
     * The vendor Rates page has no extension hook, so we swap it for our
     * subclass (see Shipping/Filament/Pages/ManageShippingRates). Filament
     * already registered the vendor class as a Livewire component under a
     * name derived from its class string (see
     * Panel::registerLivewireComponents()); Livewire's own registry is a
     * simple last-write-wins name => class map, so re-registering the same
     * derived name against our subclass here overrides it — keeping the
     * route, sub-navigation, and every Livewire round-trip (including form
     * submissions) pointed at one consistent component identity.
     */
    private function overrideRatesPageLivewireComponent(): void
    {
        $name = $this->app->make(ComponentRegistry::class)->getName(VendorManageShippingRates::class);
        Livewire::component($name, ManageShippingRates::class);
    }
 }
@@ -2,192 +2,26 @@
 namespace Modules\Core\Search;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
 use Lunar\Models\Currency;
 use Lunar\Models\Price;
 use Lunar\Models\Product;
 use Lunar\Models\ProductVariant;
 use Lunar\Search\ProductIndexer as BaseProductIndexer;
 use Modules\Core\Review\Models\ProductReview;
 use Spatie\MediaLibrary\MediaCollections\Models\Media;
 /**
- * Extends Lunar's own indexer so Modules\Core\Catalog\ProductService can serve both
+ * Lunar's own indexer puts raw attribute HTML (e.g. name_en, description_en) into
- * listing/filtering AND single-product lookups from Meilisearch alone — one data
+ * the search index, which pollutes relevance ranking and highlighting with markup.
- * source, no separate database read path for a product detail page. Adds:
+ * Strip tags from string fields before they reach Meilisearch.
 *   - collections (ids, filterable) and collection_names (display)
 *   - slugs (every locale's Url::slug for the product, filterable) — lets
 *     ProductService::getBySlug() resolve a product from the index directly, with
 *     no database read at all
 *   - price (cheapest variant, filterable) and full per-variant pricing
 *   - variants: sku, stock, purchasable, option values, prices, media
 *   - the full media gallery (not just the single thumbnail Lunar's base indexer sends)
 *   - tags
 *   - reviews: public-safe fields only (see mapReview() — reviewer_email is deliberately
 *     excluded, it's PII with no storefront use), including staff replies, plus an
 *     average rating
 *   - channel_ids (filterable) — Lunar's base indexer only indexes "status" as
 *     filterable, not channel assignment, so search results can't otherwise be
 *     scoped to products actually assigned+enabled on the current sales channel
 *
 * A review is created/edited independently of its product (Modules\Core\Providers\
 * ReviewServiceProvider re-indexes the product on review create/update/delete), so
 * this data doesn't go stale between full reindexes.
 *
 * New fields aren't filterable in Meilisearch until `php artisan lunar:meilisearch:setup`
 * re-syncs index settings, and existing documents need `lunar:search:index --refresh` to
 * pick up the new shape — see docs/product-listing.md. If SCOUT_QUEUE is enabled, the
 * queue worker also needs restarting after deploying changes to this class (see
 * docs/lunar.md "Gotchas" — a running worker keeps stale indexer code in memory).
 */
 class ProductIndexer extends BaseProductIndexer
 {
    public function getFilterableFields(): array
    {
        return [
            ...parent::getFilterableFields(),
            'id',
            'brand',
            'collections',
            'price',
            'slugs',
            'channel_ids',
        ];
    }
    public function getSortableFields(): array
    {
        return [
            ...parent::getSortableFields(),
            'price',
        ];
    }
    public function makeAllSearchableUsing(Builder $query): Builder
    {
        return parent::makeAllSearchableUsing($query)->with([
            'collections',
            'media',
            'tags',
            'urls',
            'variants.images',
            'variants.prices',
            'variants.values.option',
        ]);
    }
    public function toSearchableArray(Model $model): array
    {
        /** @var Product $model */
        $data = parent::toSearchableArray($model);
-        $currency = Currency::getDefault();
+        foreach ($data as $key => $value) {
-        $reviews = ProductReview::where('product_id', $model->id)->with('media')->get();
+            if (is_string($value)) {
-
+                $data[$key] = trim(strip_tags($value));
-        $data['collections'] = $model->collections->pluck('id')->map(fn ($id) => (string) $id)->all();
+            }
-        $data['collection_names'] = $model->collections->map(fn ($collection) => $collection->translateAttribute('name'))->all();
+        }
        $data['slugs'] = $model->urls->pluck('slug')->unique()->values()->all();
        $data['tags'] = $model->tags->pluck('value')->all();
        $data['media'] = $model->media->map(fn (Media $media) => $this->mapMedia($media))->all();
        $data['variants'] = $model->variants->map(fn (ProductVariant $variant) => $this->mapVariant($variant, $currency))->all();
        $data['price'] = $this->cheapestPrice($model, $currency);
        $data['reviews'] = $reviews->map(fn (ProductReview $review) => $this->mapReview($review))->all();
        $data['review_count'] = $reviews->count();
        $data['average_rating'] = $reviews->isEmpty() ? null : round($reviews->avg('rating'), 1);
        $data['channel_ids'] = $model->channels()
            ->wherePivot('enabled', true)
            ->pluck('lunar_channels.id')
            ->toArray();
        return $data;
    }
    private function mapVariant(ProductVariant $variant, Currency $currency): array
    {
        return [
            'id' => $variant->id,
            'sku' => $variant->sku,
            'stock' => $variant->stock,
            'purchasable' => $variant->purchasable,
            'options' => $variant->values->map(fn ($value) => [
                'option' => $this->translatedName($value->option->name),
                'value' => $this->translatedName($value->name),
                'meta' => $value->meta,
            ])->all(),
            'prices' => $variant->prices->map(fn (Price $price) => [
                'currency_id' => $price->currency_id,
                'customer_group_id' => $price->customer_group_id,
                'price' => $price->price->decimal(),
                'compare_price' => $price->compare_price?->decimal(),
                'min_quantity' => $price->min_quantity,
            ])->all(),
            'media' => $variant->images->map(fn (Media $media) => $this->mapMedia($media))->all(),
        ];
    }
    /**
     * Public-safe fields only — reviewer_email is PII with no storefront use and is
     * deliberately excluded, unlike every other column on the review. reply/replied_at
     * (the staff response) are included since they're meant to be shown alongside the
     * review on the storefront.
     */
    private function mapReview(ProductReview $review): array
    {
        return [
            'id' => $review->id,
            'title' => $review->title,
            'body' => $review->body,
            'rating' => $review->rating,
            'reviewed_at' => $review->reviewed_at?->timestamp,
            'reviewer_name' => $review->reviewer_name,
            'reply' => $review->reply,
            'replied_at' => $review->replied_at?->timestamp,
            'location' => $review->location,
            'media' => $review->media->map(fn (Media $media) => $this->mapMedia($media))->all(),
        ];
    }
    /**
     * ProductOption/ProductOptionValue's `name` is a plain locale-keyed array cast
     * (AsArrayObject) directly on the column — unlike Product/Collection/Brand, it is
     * not stored in attribute_data. Lunar's translateAttribute() only reads
     * attribute_data, so it silently returns null for these two models; this reads
     * the array directly instead. Falls back to the first available locale if the
     * current one is missing. Not a general replacement for translateAttribute() —
     * every other translated field in this indexer (product/collection name and
     * description) genuinely is attribute_data-backed and translateAttribute() is
     * correct for those.
     */
    private function translatedName(mixed $name): ?string
    {
        $names = is_array($name) ? $name : (array) $name;
        return $names[app()->getLocale()] ?? reset($names) ?: null;
    }
    private function mapMedia(Media $media): array
    {
        return [
            'id' => $media->id,
            'url' => $media->getUrl(),
            'thumb' => $media->getUrl('small'),
        ];
    }
    /**
     * The cheapest variant's base price (no customer group) in the default currency,
     * as a float in major units — e.g. 19.99, not 1999. Null if the product has no
     * variant with a price in that currency yet, so it's excluded from price filters
     * rather than sorting to the bottom as if it were free.
     */
    private function cheapestPrice(Product $model, Currency $currency): ?float
    {
        $price = $model->variants
            ->flatMap(fn ($variant) => $variant->prices)
            ->filter(fn ($price) => $price->currency_id === $currency->id && $price->customer_group_id === null)
            ->min(fn ($price) => $price->price->value);
        return $price !== null ? $price / (10 ** $currency->decimal_places) : null;
    }
 }
@@ -1,56 +0,0 @@
 <?php
 namespace Modules\Core\Search;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Support\Facades\App;
 use Lunar\Facades\AttributeManifest;
 use Lunar\Models\Language;
 use Lunar\Models\Product;
 /**
 * Lunar's Meilisearch indexer flattens translated attributes into locale-suffixed
 * fields on a single document (name_en, name_el, description_en, description_el —
 * see Lunar\Search\ScoutIndexer::mapSearchableAttributes()), not separate indexes
 * or a filterable locale field. Locale-aware search means choosing which fields
 * to search on, not filtering results by locale.
 */
 class ProductSearchService
 {
    /**
     * @return Collection<int, Product>
     */
    public function search(string $query, ?string $locale = null): Collection
    {
        $locale ??= App::getLocale();
        $defaultLocale = Language::getDefault()->code;
        return Product::search($query)
            ->options([
                'attributesToSearchOn' => $this->searchableFields($locale, $defaultLocale),
            ])
            ->get();
    }
    /**
     * Target the resolved locale's fields plus the default locale's fields, so a
     * product that's only ever been translated into the default language still
     * surfaces when searched in another locale, instead of becoming invisible
     * until every product is fully translated.
     *
     * @return array<int, string>
     */
    private function searchableFields(string $locale, string $defaultLocale): array
    {
        $handles = AttributeManifest::getSearchableAttributes(Product::morphName())
            ->pluck('handle');
        $locales = array_unique([$locale, $defaultLocale]);
        return $handles
            ->crossJoin($locales)
            ->map(fn (array $pair) => "{$pair[0]}_{$pair[1]}")
            ->values()
            ->all();
    }
 }
@@ -0,0 +1,11 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\Acs;
 class AcsArea
 {
    public function __construct(
        public readonly string $stationId,
        public readonly int $branchId,
    ) {}
 }
@@ -0,0 +1,34 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\Acs;
 use Illuminate\Support\Facades\Http;
 class AcsClient
 {
    public function __construct(private readonly array $config) {}
    public function call(string $alias, array $parameters = []): AcsResponse
    {
        $response = Http::withHeaders([
            'AcsApiKey' => $this->config['api_key'],
        ])
            ->timeout($this->config['timeout'])
            ->post($this->config['base_url'], [
                'ACSAlias' => $alias,
                'ACSInputParameters' => array_merge($this->credentialParams(), $parameters),
            ]);
        return AcsResponse::fromHttpResponse($response);
    }
    private function credentialParams(): array
    {
        return [
            'Company_ID' => $this->config['company_id'],
            'Company_Password' => $this->config['company_password'],
            'User_ID' => $this->config['user_id'],
            'User_Password' => $this->config['user_password'],
        ];
    }
 }
@@ -0,0 +1,133 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\Acs;
 use Illuminate\Support\Collection;
 use Lunar\Models\Order;
 use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
 use Modules\Core\Shipping\Contracts\SupportsManifestBatching;
 use Modules\Core\Shipping\DataTransferObjects\ManifestResult;
 use Modules\Core\Shipping\Models\Shipment;
 class AcsFulfillmentService implements CarrierFulfillmentInterface, SupportsManifestBatching
 {
    public function __construct(
        private readonly AcsClient $client,
        private readonly AreaResolver $areaResolver,
    ) {}
    public function createShipment(Order $order, array $overrides = []): Shipment
    {
        $address = $order->shippingAddress;
        $destination = $this->areaResolver->resolve($address->postcode);
        $response = $this->client->call('ACS_Create_Voucher', array_merge([
            'Pickup_Date' => now()->toDateString(),
            'Sender' => config('acs.sender.name'),
            'Recipient_Name' => trim("{$address->first_name} {$address->last_name}"),
            'Recipient_Address' => $address->line_one,
            'Recipient_Zipcode' => $address->postcode,
            'Recipient_Region' => $address->city,
            'Recipient_Phone' => $address->contact_phone,
            'Recipient_Country' => 'GR',
            'Acs_Station_Branch_Destination' => $destination->branchId,
            'Billing_Code' => config('acs.billing_code'),
            'Charge_Type' => 2,
            'Item_Quantity' => 1,
            'Weight' => 0.5,
        ], $overrides))->throwIfError();
        $voucherNo = (string) $response->valueOutput['Voucher_No'];
        $shipment = Shipment::create([
            'order_id' => $order->id,
            'carrier' => 'acs',
            'tracking_reference' => $voucherNo,
            'meta' => [
                'station_destination' => $destination->stationId,
                'weight' => $overrides['Weight'] ?? 0.5,
                'pickup_date' => now()->toDateString(),
            ],
        ]);
        if (($overrides['Item_Quantity'] ?? 1) > 1) {
            $this->persistMultipartVouchers($shipment);
        }
        return $shipment;
    }
    public function printLabel(Shipment $shipment): string
    {
        $response = $this->client->call('ACS_Print_Voucher', [
            'Voucher_No' => $shipment->tracking_reference,
            'Print_Type' => 2,
            'Start_Position' => 1,
        ])->throwIfError();
        $shipment->update(['label_printed_at' => now()]);
        return $response->valueOutput[$shipment->tracking_reference] ?? '';
    }
    public function cancelShipment(Shipment $shipment): void
    {
        if ($shipment->manifest_reference) {
            throw new \RuntimeException('Cannot cancel a shipment already included in an issued manifest.');
        }
        $this->client->call('ACS_Delete_Voucher', [
            'Voucher_No' => $shipment->tracking_reference,
        ])->throwIfError();
        $shipment->update(['cancelled_at' => now()]);
    }
    public function pendingForManifest(): Collection
    {
        return Shipment::query()
            ->where('carrier', 'acs')
            ->whereNull('manifest_reference')
            ->whereNull('cancelled_at')
            ->get();
    }
    public function issueManifest(Collection $shipments): ManifestResult
    {
        $unprinted = $shipments->whereNull('label_printed_at');
        if ($unprinted->isNotEmpty()) {
            return ManifestResult::blocked($unprinted, 'unprinted');
        }
        $response = $this->client->call('ACS_Issue_Pickup_List', [
            'Pickup_Date' => now()->toDateString(),
            'MyData' => null,
        ])->throwIfError();
        $pickupListNo = (string) $response->valueOutput['PickupList_No'];
        $shipments->each(fn (Shipment $shipment) => $shipment->update([
            'manifest_reference' => $pickupListNo,
        ]));
        return ManifestResult::success($pickupListNo, $shipments);
    }
    private function persistMultipartVouchers(Shipment $mainShipment): void
    {
        $response = $this->client->call('ACS_Get_Multipart_Vouchers', [
            'Main_Voucher_No' => $mainShipment->tracking_reference,
        ])->throwIfError();
        foreach ($response->tableOutput['Table_Data'] ?? [] as $row) {
            Shipment::create([
                'order_id' => $mainShipment->order_id,
                'carrier' => 'acs',
                'tracking_reference' => $row['MultiPart_Voucher_No'],
                'parent_reference' => $mainShipment->tracking_reference,
                'meta' => $mainShipment->meta?->toArray() ?? [],
            ]);
        }
    }
 }
@@ -0,0 +1,116 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\Acs;
 use Lunar\DataTypes\Price;
 use Lunar\DataTypes\ShippingOption;
 use Lunar\Shipping\DataTransferObjects\ShippingOptionRequest;
 use Lunar\Shipping\Interfaces\ShippingRateInterface;
 use Lunar\Shipping\Models\ShippingRate;
 use Modules\Core\Shipping\Carriers\Acs\Exceptions\AcsApiException;
 use Modules\Core\Shipping\Concerns\ResolvesFixedPricing;
 use Modules\Core\Shipping\Contracts\SupportsLivePricing;
 class AcsRateDriver implements ShippingRateInterface, SupportsLivePricing
 {
    use ResolvesFixedPricing;
    public ShippingRate $shippingRate;
    public function __construct(
        private readonly AcsClient $client,
        private readonly AreaResolver $areaResolver,
    ) {}
    public function name(): string
    {
        return 'ACS Courier';
    }
    public function description(): string
    {
        return 'Live rate quote from ACS Courier.';
    }
    public function resolve(ShippingOptionRequest $shippingOptionRequest): ?ShippingOption
    {
        $shippingRate = $shippingOptionRequest->shippingRate;
        $shippingMethod = $shippingRate->shippingMethod;
        $cart = $shippingOptionRequest->cart;
        if (($shippingMethod->data['charge_by'] ?? 'cart_total') !== 'live') {
            return $this->resolveFixedPrice($shippingRate, $shippingMethod, $cart);
        }
        $postcode = $cart->shippingAddress?->postcode;
        if (! $postcode) {
            return null;
        }
        return $this->resolveLivePrice($shippingRate, $shippingMethod, $cart, $postcode);
    }
    private function resolveLivePrice(ShippingRate $shippingRate, $shippingMethod, $cart, string $postcode): ?ShippingOption
    {
        try {
            $destination = $this->areaResolver->resolve($postcode);
            $response = $this->client->call('ACS_Price_Calculation', [
                'Billing_Code' => config('acs.billing_code'),
                'Acs_Station_Destination' => $destination->stationId,
                'Weight' => $this->totalWeightInKg($cart),
                'Pickup_Date' => now()->toDateString(),
                'Charge_Type' => 2,
            ])->throwIfError();
        } catch (AcsApiException $e) {
            report($e);
            return null;
        }
        $amount = (int) round(($response->valueOutput['Total_Ammount'] ?? 0) * 100);
        return new ShippingOption(
            name: $shippingMethod->name ?: $this->name(),
            description: $shippingMethod->description ?: $this->description(),
            identifier: $shippingRate->getIdentifier(),
            price: new Price($amount, $cart->currency, 1),
            taxClass: $shippingRate->getTaxClass(),
            taxReference: $shippingRate->getTaxReference(),
            meta: ['acs_station_destination' => $destination->stationId],
        );
    }
    public function on(ShippingRate $shippingRate): self
    {
        $this->shippingRate = $shippingRate;
        return $this;
    }
    private function totalWeightInKg($cart): float
    {
        $weight = 0.0;
        foreach ($cart->lines->load('purchasable') as $line) {
            $variant = $line->purchasable;
            if (! $variant || ! $variant->weight_value) {
                continue;
            }
            $unit = $variant->weight_unit ?? 'kg';
            $value = (float) $variant->weight_value;
            $weight += match ($unit) {
                'g' => $value / 1000,
                'lb' => $value * 0.45359237,
                'oz' => $value * 0.0283495231,
                default => $value, // kg
            } * $line->quantity;
        }
        return max($weight, 0.5); // ACS minimum billable weight
    }
 }
@@ -0,0 +1,43 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\Acs;
 use Illuminate\Http\Client\Response;
 use Modules\Core\Shipping\Carriers\Acs\Exceptions\AcsApiException;
 class AcsResponse
 {
    private function __construct(
        public readonly bool $hasError,
        public readonly ?string $errorMessage,
        public readonly array $valueOutput,
        public readonly array $tableOutput,
    ) {}
    public static function fromHttpResponse(Response $response): self
    {
        $body = $response->json() ?? [];
        // ACS's own JSON key is misspelled ("Responce") — preserved here verbatim.
        $output = $body['ACSOutputResponce'] ?? [];
        return new self(
            hasError: (bool) ($body['ACSExecution_HasError'] ?? ! $response->successful()),
            errorMessage: $body['ACSExecutionErrorMessage'] ?? null,
            valueOutput: $output['ACSValueOutput'][0] ?? [],
            tableOutput: $output['ACSTableOutput'] ?? [],
        );
    }
    public function throwIfError(): self
    {
        if ($this->hasError) {
            throw new AcsApiException(
                $this->errorMessage ?? ($this->valueOutput['Error_Message'] ?? 'Unknown ACS API error'),
                $this->tableOutput,
            );
        }
        return $this;
    }
 }
@@ -0,0 +1,81 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\Acs;
 use Illuminate\Support\Facades\Cache;
 use Modules\Core\Shipping\Carriers\Acs\Exceptions\AcsApiException;
 class AreaResolver
 {
    public const CACHE_KEY = 'acs.areas';
    public function __construct(private readonly AcsClient $client) {}
    /**
     * Resolve a Greek postcode to its ACS station/branch codes.
     *
     * Reads from the table warmed daily by WarmAcsAreaCacheJob. Falls
     * back to a live lookup for that single postcode if the warmed cache is
     * missing (e.g. the daily job never ran or failed) or doesn't contain it.
     */
    public function resolve(string $postcode): AcsArea
    {
        $areas = Cache::get(self::CACHE_KEY);
        if ($areas !== null && isset($areas[$postcode])) {
            return $this->toArea($areas[$postcode]);
        }
        return $this->toArea($this->fetch($postcode));
    }
    /**
     * Fetch and cache the full country's postcode-to-station map in one call.
     */
    public function warmAll(): void
    {
        $areas = [];
        foreach ($this->fetchAll() as $row) {
            $areas[$row['Zip_Code']] = $row;
        }
        Cache::forever(self::CACHE_KEY, $areas);
    }
    private function fetch(string $postcode): array
    {
        $response = $this->client->call('ACS_Area_Find_By_Zip_Code', [
            'Zip_Code' => $postcode,
            'Show_Only_Inaccessible_Areas' => 0,
            'Country' => 'GR',
        ])->throwIfError();
        $area = $response->tableOutput['Table_Data'][0] ?? null;
        if (! $area) {
            throw new AcsApiException("No ACS area found for postcode {$postcode}");
        }
        return $area;
    }
    private function fetchAll(): array
    {
        $response = $this->client->call('ACS_Area_Find_By_Zip_Code', [
            'Zip_Code' => null,
            'Show_Only_Inaccessible_Areas' => 0,
            'Country' => 'GR',
        ])->throwIfError();
        return $response->tableOutput['Table_Data'] ?? [];
    }
    private function toArea(array $row): AcsArea
    {
        return new AcsArea(
            stationId: $row['Station_ID'],
            branchId: (int) $row['Branch_ID'],
        );
    }
 }
@@ -0,0 +1,13 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\Acs\Exceptions;
 use RuntimeException;
 class AcsApiException extends RuntimeException
 {
    public function __construct(string $message, public readonly array $tableOutput = [])
    {
        parent::__construct($message);
    }
 }
@@ -0,0 +1,27 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\Acs\Jobs;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Bus\Dispatchable;
 use Illuminate\Queue\InteractsWithQueue;
 use Illuminate\Queue\SerializesModels;
 use Modules\Core\Shipping\Carriers\Acs\AreaResolver;
 class WarmAcsAreaCacheJob implements ShouldQueue
 {
    use Dispatchable;
    use InteractsWithQueue;
    use Queueable;
    use SerializesModels;
    public int $tries = 3;
    public int $backoff = 60;
    public function handle(AreaResolver $areaResolver): void
    {
        $areaResolver->warmAll();
    }
 }
@@ -0,0 +1,97 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\BoxNow;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\Http;
 use Modules\Core\Shipping\Carriers\BoxNow\Exceptions\BoxNowApiException;
 class BoxNowClient
 {
    private const TOKEN_CACHE_KEY = 'boxnow.access_token';
    public function __construct(private readonly array $config) {}
    /**
     * GET/POST against the main delivery/parcel API, authenticated with a
     * cached Bearer token.
     */
    public function request(string $method, string $path, array $payload = []): array
    {
        $response = Http::withToken($this->token())
            ->timeout($this->config['timeout'])
            ->{$method}("{$this->config['base_url']}{$path}", $payload);
        if ($response->status() === 401) {
            // Token expired early / was revoked — refresh once and retry.
            Cache::forget(self::TOKEN_CACHE_KEY);
            $response = Http::withToken($this->token())
                ->timeout($this->config['timeout'])
                ->{$method}("{$this->config['base_url']}{$path}", $payload);
        }
        if ($response->failed()) {
            throw new BoxNowApiException(
                "Box Now API error ({$response->status()}) on {$method} {$path}",
                $response->json() ?? [],
            );
        }
        return $response->json() ?? [];
    }
    /**
     * The origins/destinations lookups are served faster from a separate
     * location API host, per Box Now's own documentation.
     */
    public function locationRequest(string $path, array $query = []): array
    {
        $response = Http::withToken($this->token())
            ->timeout($this->config['timeout'])
            ->get("{$this->config['location_api_url']}{$path}", $query);
        if ($response->failed()) {
            throw new BoxNowApiException(
                "Box Now location API error ({$response->status()}) on GET {$path}",
                $response->json() ?? [],
            );
        }
        return $response->json() ?? [];
    }
    /**
     * Fetch raw bytes (e.g. a PDF label) rather than JSON.
     */
    public function requestRaw(string $path): string
    {
        $response = Http::withToken($this->token())
            ->timeout($this->config['timeout'])
            ->get("{$this->config['base_url']}{$path}");
        if ($response->failed()) {
            throw new BoxNowApiException("Box Now API error ({$response->status()}) on GET {$path}");
        }
        return $response->body();
    }
    private function token(): string
    {
        return Cache::remember(self::TOKEN_CACHE_KEY, now()->addMinutes(55), function () {
            $response = Http::timeout($this->config['timeout'])
                ->post("{$this->config['base_url']}/auth-sessions", [
                    'grant_type' => 'client_credentials',
                    'client_id' => $this->config['client_id'],
                    'client_secret' => $this->config['client_secret'],
                ]);
            if ($response->failed()) {
                throw new BoxNowApiException('Box Now authentication failed', $response->json() ?? []);
            }
            return $response->json('access_token');
        });
    }
 }
@@ -0,0 +1,92 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\BoxNow;
 use Lunar\Models\Order;
 use Modules\Core\Shipping\Carriers\BoxNow\Exceptions\BoxNowApiException;
 use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
 use Modules\Core\Shipping\Models\Shipment;
 /**
 * Unlike ACS, Box Now has no manifest/pickup-list step — creating a
 * delivery request also books the courier pickup, so this only implements
 * CarrierFulfillmentInterface (not SupportsManifestBatching).
 *
 * Box Now delivers to lockers, not addresses. The storefront locker-picker
 * is out of scope for this pass — createShipment() expects the chosen
 * locker's Box Now locationId via $overrides['locationId'] (e.g. set
 * manually by admin staff until checkout UI exists).
 */
 class BoxNowFulfillmentService implements CarrierFulfillmentInterface
 {
    public function __construct(private readonly BoxNowClient $client) {}
    public function createShipment(Order $order, array $overrides = []): Shipment
    {
        $address = $order->shippingAddress;
        $destinationLocationId = $overrides['locationId'] ?? null;
        if (! $destinationLocationId) {
            throw new BoxNowApiException('No Box Now locker (locationId) was provided for this shipment.');
        }
        $response = $this->client->request('post', '/delivery-requests', [
            'orderNumber' => $order->reference.'-'.$order->id,
            'invoiceValue' => number_format($order->total->decimal, 2, '.', ''),
            'paymentMode' => 'prepaid',
            'amountToBeCollected' => '0.00',
            'origin' => [
                'contactNumber' => config('boxnow.sender.phone'),
                'contactEmail' => config('boxnow.sender.email'),
                'contactName' => config('boxnow.sender.name'),
                'locationId' => config('boxnow.origin_location_id'),
            ],
            'destination' => [
                'contactNumber' => $address->contact_phone,
                'contactEmail' => $address->contact_email,
                'contactName' => trim("{$address->first_name} {$address->last_name}"),
                'locationId' => $destinationLocationId,
            ],
            'items' => [
                [
                    'id' => (string) $order->id,
                    'name' => 'Order '.$order->reference,
                    'value' => '0.00',
                    'compartmentSize' => $overrides['compartmentSize'] ?? 1,
                    'weight' => $overrides['weight'] ?? 0,
                ],
            ],
        ]);
        $parcelId = (string) ($response['parcels'][0]['id'] ?? throw new BoxNowApiException(
            'Box Now delivery request succeeded but returned no parcel id.',
            $response,
        ));
        return Shipment::create([
            'order_id' => $order->id,
            'carrier' => 'box-now',
            'tracking_reference' => $parcelId,
            'meta' => [
                'delivery_request_id' => $response['id'] ?? null,
                'locker_id' => $destinationLocationId,
            ],
        ]);
    }
    public function printLabel(Shipment $shipment): string
    {
        $bytes = $this->client->requestRaw("/parcels/{$shipment->tracking_reference}/label.pdf");
        $shipment->update(['label_printed_at' => now()]);
        return $bytes;
    }
    public function cancelShipment(Shipment $shipment): void
    {
        $this->client->request('post', "/parcels/{$shipment->tracking_reference}:cancel");
        $shipment->update(['cancelled_at' => now()]);
    }
 }
@@ -0,0 +1,48 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\BoxNow;
 use Lunar\DataTypes\ShippingOption;
 use Lunar\Shipping\DataTransferObjects\ShippingOptionRequest;
 use Lunar\Shipping\Interfaces\ShippingRateInterface;
 use Lunar\Shipping\Models\ShippingRate;
 use Modules\Core\Shipping\Concerns\ResolvesFixedPricing;
 /**
 * Box Now has no pricing API, so this always resolves the method's normal
 * charge_by + price-break configuration — the same mechanism the built-in
 * flat-rate/ship-by drivers use. Does not implement SupportsLivePricing:
 * there is no live option to offer.
 */
 class BoxNowRateDriver implements ShippingRateInterface
 {
    use ResolvesFixedPricing;
    public ShippingRate $shippingRate;
    public function name(): string
    {
        return 'Box Now Locker Delivery';
    }
    public function description(): string
    {
        return 'Deliver to a Box Now parcel locker.';
    }
    public function resolve(ShippingOptionRequest $shippingOptionRequest): ?ShippingOption
    {
        return $this->resolveFixedPrice(
            $shippingOptionRequest->shippingRate,
            $shippingOptionRequest->shippingRate->shippingMethod,
            $shippingOptionRequest->cart,
        );
    }
    public function on(ShippingRate $shippingRate): self
    {
        $this->shippingRate = $shippingRate;
        return $this;
    }
 }
@@ -0,0 +1,13 @@
 <?php
 namespace Modules\Core\Shipping\Carriers\BoxNow\Exceptions;
 use RuntimeException;
 class BoxNowApiException extends RuntimeException
 {
    public function __construct(string $message, public readonly array $body = [])
    {
        parent::__construct($message);
    }
 }
@@ -0,0 +1,42 @@
 <?php
 namespace Modules\Core\Shipping\Concerns;
 use Lunar\DataTypes\ShippingOption;
 use Lunar\Facades\Pricing;
 use Lunar\Shipping\Models\ShippingMethod;
 use Lunar\Shipping\Models\ShippingRate;
 /**
 * Shared by any carrier driver that also supports Lunar's own price-break
 * pricing (charge_by = cart_total | weight) as a fallback to, or standalone
 * alternative for, live API pricing. Mirrors the vendor ShipBy driver's
 * charge_by handling exactly, so behavior is consistent with the rest of
 * Lunar's shipping system rather than inventing a separate mechanism.
 */
 trait ResolvesFixedPricing
 {
    private function resolveFixedPrice(ShippingRate $shippingRate, ShippingMethod $shippingMethod, $cart): ?ShippingOption
    {
        $chargeBy = $shippingMethod->data['charge_by'] ?? 'cart_total';
        $tier = $chargeBy === 'weight'
            ? $cart->lines->load('purchasable')->sum(fn ($line) => ($line->purchasable->weight_value ?? 0) * $line->quantity)
            : $cart->lines->sum('subTotal.value');
        $pricing = Pricing::for($shippingRate)->qty($tier)->get();
        if (! $pricing->matched) {
            return null;
        }
        return new ShippingOption(
            name: $shippingMethod->name ?: $this->name(),
            description: $shippingMethod->description ?: $this->description(),
            identifier: $shippingRate->getIdentifier(),
            price: $pricing->matched->price,
            taxClass: $shippingRate->getTaxClass(),
            taxReference: $shippingRate->getTaxReference(),
        );
    }
 }
@@ -0,0 +1,24 @@
 <?php
 namespace Modules\Core\Shipping\Contracts;
 use Lunar\Models\Order;
 use Modules\Core\Shipping\Models\Shipment;
 interface CarrierFulfillmentInterface
 {
    /**
     * Create a shipment with the carrier for the given order.
     */
    public function createShipment(Order $order, array $overrides = []): Shipment;
    /**
     * Fetch the printable label for a shipment (raw file bytes).
     */
    public function printLabel(Shipment $shipment): string;
    /**
     * Cancel a shipment with the carrier.
     */
    public function cancelShipment(Shipment $shipment): void;
 }
@@ -0,0 +1,12 @@
 <?php
 namespace Modules\Core\Shipping\Contracts;
 /**
 * Marker for a Lunar\Shipping\Interfaces\ShippingRateInterface driver that
 * calculates its price from a live carrier API rather than the manually
 * configured ShippingRate price/price-breaks. Admin UI uses this to hide
 * the manual pricing fields for such drivers — carriers without a pricing
 * API simply don't implement it, and manual pricing remains required.
 */
 interface SupportsLivePricing {}
@@ -0,0 +1,24 @@
 <?php
 namespace Modules\Core\Shipping\Contracts;
 use Illuminate\Support\Collection;
 use Modules\Core\Shipping\DataTransferObjects\ManifestResult;
 /**
 * Optional capability for carriers that batch shipments into a manifest
 * before courier pickup (e.g. ACS's end-of-day pickup list). Carriers
 * without this concept simply don't implement it.
 */
 interface SupportsManifestBatching
 {
    /**
     * Shipments created but not yet included in an issued manifest.
     */
    public function pendingForManifest(): Collection;
    /**
     * Finalize the given shipments into a manifest with the carrier.
     */
    public function issueManifest(Collection $shipments): ManifestResult;
 }
@@ -0,0 +1,26 @@
 <?php
 namespace Modules\Core\Shipping\DataTransferObjects;
 use Illuminate\Support\Collection;
 class ManifestResult
 {
    private function __construct(
        public readonly bool $success,
        public readonly ?string $reference,
        public readonly Collection $includedShipments,
        public readonly Collection $blockedShipments,
        public readonly ?string $reason,
    ) {}
    public static function success(string $reference, Collection $includedShipments): self
    {
        return new self(true, $reference, $includedShipments, collect(), null);
    }
    public static function blocked(Collection $blockedShipments, string $reason): self
    {
        return new self(false, null, collect(), $blockedShipments, $reason);
    }
 }
@@ -0,0 +1,101 @@
 <?php
 namespace Modules\Core\Shipping\Extensions;
 use Filament\Actions;
 use Filament\Forms;
 use Filament\Notifications\Notification;
 use Lunar\Admin\Support\Extending\ViewPageExtension;
 use Lunar\Models\Order;
 use Lunar\Shipping\Models\ShippingMethod;
 use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
 class OrderViewExtension extends ViewPageExtension
 {
    public function headerActions(array $actions): array
    {
        $actions[] = $this->createShipmentAction();
        return $actions;
    }
    private function createShipmentAction(): Actions\Action
    {
        return Actions\Action::make('create_shipment')
            ->label('Create Shipment')
            ->icon('heroicon-o-truck')
            ->modalSubmitActionLabel('Create Shipment')
            ->form([
                Forms\Components\Toggle::make('confirm')
                    ->label('Confirm')
                    ->helperText('This will create a real shipment with the carrier.')
                    ->rules([
                        function () {
                            return function (string $attribute, $value, \Closure $fail) {
                                if ($value !== true) {
                                    $fail('Please confirm before creating the shipment.');
                                }
                            };
                        },
                    ]),
            ])
            ->action(function (Order $record, Actions\Action $action) {
                $service = $this->resolveFulfillmentService($record);
                if (! $service) {
                    Notification::make()
                        ->title('No carrier fulfillment integration is configured for this order.')
                        ->danger()
                        ->send();
                    $action->halt();
                    return;
                }
                try {
                    $service->createShipment($record);
                } catch (\Throwable $e) {
                    report($e);
                    Notification::make()
                        ->title('Failed to create shipment: '.$e->getMessage())
                        ->danger()
                        ->send();
                    $action->halt();
                    return;
                }
                Notification::make()
                    ->title('Shipment created.')
                    ->success()
                    ->send();
            })
            ->visible(fn (Order $record) => $record->shipments()->exists() === false
                && $this->resolveFulfillmentService($record) !== null);
    }
    private function resolveCarrier(Order $record): ?string
    {
        $code = $record->shippingAddress?->shipping_option;
        if (! $code) {
            return null;
        }
        return ShippingMethod::where('code', $code)->value('driver');
    }
    private function resolveFulfillmentService(Order $record): ?CarrierFulfillmentInterface
    {
        $carrier = $this->resolveCarrier($record);
        if (! $carrier) {
            return null;
        }
        return app(CarrierFulfillmentInterface::class, ['carrier' => $carrier]);
    }
 }
@@ -0,0 +1,48 @@
 <?php
 namespace Modules\Core\Shipping\Extensions;
 use Filament\Actions;
 use Filament\Forms\Components\Group;
 use Filament\Forms\Components\Select;
 use Lunar\Admin\Support\Extending\BaseExtension;
 use Lunar\Shipping\Facades\Shipping;
 use Lunar\Shipping\Filament\Resources\ShippingMethodResource;
 /**
 * ListShippingMethod::getDefaultHeaderActions() builds its CreateAction's
 * form inline (calling ShippingMethodResource::getDriverFormComponent()
 * directly, a hardcoded 2-option Select) rather than through the resource's
 * own extendForm() pipeline, so ShippingMethodResourceExtension's driver
 * fix never reaches it. Re-declares the same create-action form with a
 * dynamic driver Select instead.
 */
 class ShippingMethodListExtension extends BaseExtension
 {
    public function headerActions(array $actions): array
    {
        foreach ($actions as $action) {
            if ($action instanceof Actions\CreateAction) {
                $action->form([
                    ShippingMethodResource::getNameFormComponent(),
                    Group::make([
                        ShippingMethodResource::getCodeFormComponent(),
                        $this->driverSelect(),
                    ])->columns(2),
                    ShippingMethodResource::getDescriptionFormComponent(),
                ]);
            }
        }
        return $actions;
    }
    private function driverSelect(): Select
    {
        return Select::make('driver')
            ->label('Type')
            ->options(fn () => collect(Shipping::getSupportedDrivers())
                ->mapWithKeys(fn ($driver, $key) => [$key => $driver->name()]))
            ->default('flat-rate');
    }
 }
@@ -0,0 +1,152 @@
 <?php
 namespace Modules\Core\Shipping\Extensions;
 use Filament\Forms\Components\Component;
 use Filament\Forms\Components\Concerns\HasChildComponents;
 use Filament\Forms\Components\Select;
 use Filament\Forms\Form;
 use Filament\Forms\Get;
 use Filament\Tables\Columns\TextColumn;
 use Filament\Tables\Table;
 use Lunar\Admin\Support\Extending\ResourceExtension;
 use Lunar\Shipping\Facades\Shipping;
 use Modules\Core\Shipping\Contracts\SupportsLivePricing;
 class ShippingMethodResourceExtension extends ResourceExtension
 {
    public function extendForm(Form $form): Form
    {
        return $form->schema(
            $this->replaceChargeByField(
                $this->replaceDriverField($form->getComponents())
            )
        );
    }
    /**
     * Extend the vendor's cart_total/weight charge_by Select with a third
     * "live" option — only offered when the currently selected driver
     * supports live pricing (see SupportsLivePricing). Picking it is what
     * tells the driver to call its carrier API instead of resolving a
     * price break.
     */
    private function replaceChargeByField(array $components): array
    {
        return array_map(function (Component $component) {
            if (method_exists($component, 'getName') && $component->getName() === 'charge_by') {
                return $this->chargeBySelect();
            }
            if (in_array(HasChildComponents::class, class_uses_recursive($component), true)) {
                $component->schema(
                    $this->replaceChargeByField($component->getChildComponents())
                );
            }
            return $component;
        }, $components);
    }
    private function chargeBySelect(): Select
    {
        return Select::make('charge_by')
            ->label('Charge by')
            ->options(function (Get $get) {
                $options = [
                    'cart_total' => 'Cart Total',
                    'weight' => 'Weight',
                ];
                // "charge_by" is nested inside a Group with
                // ->statePath('data'), while "driver" sits one level up, at
                // the form root. Note: an *absolute* path here would need to
                // additionally account for the page's own form wrapper
                // (EditRecord::getFormStatePath() === 'data'), which relative
                // paths never cross — so "../driver" (relative) is the
                // correct, page-independent way to reach it, not an
                // absolute 'driver' string.
                if ($this->driverSupportsLivePricing($get('../driver'))) {
                    $options['live'] = 'Live API pricing';
                }
                return $options;
            })
            ->live();
    }
    private function driverSupportsLivePricing(?string $driver): bool
    {
        if (! $driver) {
            return false;
        }
        try {
            return Shipping::driver($driver) instanceof SupportsLivePricing;
        } catch (\InvalidArgumentException) {
            return false;
        }
    }
    public function extendTable(Table $table): Table
    {
        return $table->columns(
            array_map(function ($column) {
                if (method_exists($column, 'getName') && $column->getName() === 'driver') {
                    return $this->driverColumn();
                }
                return $column;
            }, $table->getColumns())
        );
    }
    private function driverColumn(): TextColumn
    {
        return TextColumn::make('driver')
            ->label('Type')
            ->formatStateUsing(fn ($state) => $this->driverLabel($state));
    }
    private function driverLabel(string $key): string
    {
        $driver = collect(Shipping::getSupportedDrivers())->get($key);
        return $driver?->name() ?? $key;
    }
    /**
     * Recursively walk the form tree and replace the hardcoded driver
     * Select (nested inside Section > Group) with one listing every
     * registered driver, built-in or custom.
     *
     * @param  array<Component>  $components
     * @return array<Component>
     */
    private function replaceDriverField(array $components): array
    {
        return array_map(function (Component $component) {
            if (method_exists($component, 'getName') && $component->getName() === 'driver') {
                return $this->driverSelect();
            }
            if (in_array(HasChildComponents::class, class_uses_recursive($component), true)) {
                $component->schema(
                    $this->replaceDriverField($component->getChildComponents())
                );
            }
            return $component;
        }, $components);
    }
    private function driverSelect(): Select
    {
        return Select::make('driver')
            ->label('Type')
            ->options(fn () => collect(Shipping::getSupportedDrivers())
                ->mapWithKeys(fn ($driver, $key) => [$key => $driver->name()]))
            ->default('flat-rate')
            ->live();
    }
 }
@@ -0,0 +1,106 @@
 <?php
 namespace Modules\Core\Shipping\Filament\Pages;
 use Filament\Notifications\Notification;
 use Filament\Pages\Page;
 use Filament\Tables\Actions\Action;
 use Filament\Tables\Actions\BulkAction;
 use Filament\Tables\Columns\TextColumn;
 use Filament\Tables\Concerns\InteractsWithTable;
 use Filament\Tables\Contracts\HasTable;
 use Filament\Tables\Table;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Support\Collection;
 use Lunar\Shipping\Facades\Shipping;
 use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
 use Modules\Core\Shipping\Contracts\SupportsManifestBatching;
 use Modules\Core\Shipping\Models\Shipment;
 class ManagePickupManifests extends Page implements HasTable
 {
    use InteractsWithTable;
    protected static ?string $navigationIcon = 'heroicon-o-truck';
    protected static ?string $navigationLabel = 'Pickup Manifests';
    protected static string $view = 'core::shipping.filament.pages.manage-pickup-manifests';
    public function table(Table $table): Table
    {
        return $table
            ->query($this->pendingQuery())
            ->columns([
                TextColumn::make('carrier')->badge(),
                TextColumn::make('tracking_reference')->label('Tracking #'),
                TextColumn::make('order.reference')->label('Order'),
                TextColumn::make('label_printed_at')->label('Printed')->dateTime()->placeholder('Not printed'),
            ])
            ->actions([
                Action::make('print')
                    ->label('Print')
                    ->icon('heroicon-o-printer')
                    ->action(fn (Shipment $record) => $this->printShipment($record)),
            ])
            ->bulkActions([
                BulkAction::make('print_selected')
                    ->label('Print selected')
                    ->icon('heroicon-o-printer')
                    ->action(fn (Collection $records) => $records->each(fn (Shipment $shipment) => $this->printShipment($shipment))),
                BulkAction::make('issue_manifest')
                    ->label('Issue Manifest')
                    ->icon('heroicon-o-check-circle')
                    ->action(fn (Collection $records) => $this->issueManifest($records)),
            ]);
    }
    private function pendingQuery(): Builder
    {
        $carriers = collect(Shipping::getSupportedDrivers())->keys()->filter(
            fn (string $carrier) => $this->fulfillmentService($carrier) instanceof SupportsManifestBatching
        );
        return Shipment::query()
            ->whereIn('carrier', $carriers)
            ->whereNull('manifest_reference')
            ->whereNull('cancelled_at');
    }
    private function printShipment(Shipment $shipment): void
    {
        $this->fulfillmentService($shipment->carrier)?->printLabel($shipment);
    }
    private function issueManifest(Collection $shipments): void
    {
        $shipments->groupBy('carrier')->each(function (Collection $group, string $carrier) {
            $service = $this->fulfillmentService($carrier);
            if (! $service instanceof SupportsManifestBatching) {
                return;
            }
            $result = $service->issueManifest($group);
            if (! $result->success) {
                Notification::make()
                    ->title("Manifest blocked for {$carrier}: {$result->reason}")
                    ->danger()
                    ->send();
                return;
            }
            Notification::make()
                ->title("Manifest issued for {$carrier}: {$result->reference}")
                ->success()
                ->send();
        });
    }
    private function fulfillmentService(string $carrier): ?CarrierFulfillmentInterface
    {
        return app(CarrierFulfillmentInterface::class, ['carrier' => $carrier]);
    }
 }
@@ -0,0 +1,104 @@
 <?php
 namespace Modules\Core\Shipping\Filament\Pages;
 use Filament\Forms\Form;
 use Filament\Forms\Get;
 use Filament\Tables\Columns\TextColumn;
 use Filament\Tables\Table;
 use Lunar\Shipping\Filament\Resources\ShippingZoneResource\Pages\ManageShippingRates as BaseManageShippingRates;
 use Lunar\Shipping\Models\ShippingMethod;
 use Lunar\Shipping\Models\ShippingRate;
 /**
 * Bound in place of the vendor ManageShippingRates page via the container
 * (see ShippingServiceProvider), since that page has no extension hook of
 * its own. Every reference to the vendor class name — routes, sub-nav,
 * ShippingZoneResource::getPages() — is untouched; the container simply
 * hands back this subclass whenever the vendor class is resolved.
 *
 * Hides the price / price-break fields for a rate whose method has
 * charge_by = "live" (see ShippingMethodResourceExtension, which adds that
 * option to methods whose driver supports live pricing) — those fields
 * would otherwise be dead configuration the driver never reads. Pricing
 * strategy (cart_total / weight / live) stays entirely on the Shipping
 * Method, matching Lunar's own existing charge_by convention; nothing new
 * is stored on the rate itself.
 */
 class ManageShippingRates extends BaseManageShippingRates
 {
    public function form(Form $form): Form
    {
        $form = parent::form($form);
        return $form->schema(
            $this->hidePriceFieldsWhenLive($form->getComponents())
        );
    }
    private function hidePriceFieldsWhenLive(array $components): array
    {
        $isNotLive = fn (Get $get) => static::methodChargeBy($get('shipping_method_id')) !== 'live';
        foreach ($components as $component) {
            if (! method_exists($component, 'getName')) {
                continue;
            }
            if ($component->getName() === 'price') {
                $component->visible($isNotLive)->required($isNotLive)->dehydrated(true);
            }
            if ($component->getName() === 'prices') {
                $component->visible($isNotLive)->dehydrated(true);
            }
        }
        return $components;
    }
    public function table(Table $table): Table
    {
        $table = parent::table($table);
        return $table->columns(
            array_map(function ($column) {
                if (method_exists($column, 'getName') && $column->getName() === 'basePrices.0') {
                    return TextColumn::make('basePrices.0')
                        ->label(__('lunarpanel.shipping::relationmanagers.shipping_rates.table.price.label'))
                        ->formatStateUsing(function ($state, ShippingRate $record) {
                            if (static::methodChargeBy($record->shipping_method_id) === 'live') {
                                return 'Live API pricing';
                            }
                            return $state?->price->formatted;
                        });
                }
                return $column;
            }, $table->getColumns())
        );
    }
    protected static function saveShippingRate(?ShippingRate $shippingRate = null, array $data = []): void
    {
        if (static::methodChargeBy($data['shipping_method_id'] ?? $shippingRate?->shipping_method_id) === 'live') {
            return;
        }
        parent::saveShippingRate($shippingRate, $data);
    }
    protected static function methodChargeBy(ShippingMethod|int|string|null $method): ?string
    {
        if (blank($method)) {
            return null;
        }
        if (! $method instanceof ShippingMethod) {
            $method = ShippingMethod::find($method);
        }
        return $method?->data['charge_by'] ?? null;
    }
 }
@@ -0,0 +1,24 @@
 <?php
 namespace Modules\Core\Shipping\Models;
 use Illuminate\Database\Eloquent\Casts\AsArrayObject;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Lunar\Models\Order;
 class Shipment extends Model
 {
    protected $guarded = [];
    protected $casts = [
        'meta' => AsArrayObject::class,
        'label_printed_at' => 'datetime',
        'cancelled_at' => 'datetime',
    ];
    public function order(): BelongsTo
    {
        return $this->belongsTo(Order::class);
    }
 }
Author	SHA1	Message	Date
arvanitakis	d34e450526	Fix: Move carrier live-pricing choice onto ShippingMethod.charge_by Reverts the earlier per-rate pricing_mode column in favor of extending Lunar's existing charge_by field (cart_total/weight) with a third "live" option, gated by a SupportsLivePricing capability check on the driver. Adds a shared ResolvesFixedPricing trait so any carrier driver can fall back to Lunar's normal price-break resolution, matching the vendor ShipBy driver's own charge_by handling instead of introducing a separate mechanism. Also fixes an incorrect Get() path in the admin form that silently hid the new "live" option.	2026-07-19 02:24:10 +03:00
arvanitakis	4acabe4185	Feature: Wire up carrier-agnostic shipping admin UI Registers ShippingServiceProvider (carrier config, driver/fulfillment bindings, Rates page override) and wires the shipping admin surface into CorePlugin: dynamic carrier dropdown on Shipping Method create/edit, a "Create Shipment" order action resolved generically by carrier, and a Pickup Manifests page for carriers that support manifest batching.	2026-07-19 00:52:01 +03:00
arvanitakis	37c2e1194c	Feature: Add Box Now locker delivery integration Box Now rate driver (fixed pricing only — no live pricing API) and fulfillment service (delivery request creation, label printing, cancellation). Unlike ACS, Box Now books courier pickup automatically on delivery request creation, so no manifest/pickup-list step is implemented. Storefront locker selection is not yet built; createShipment() expects the chosen locker's locationId to be supplied by the caller.	2026-07-19 00:51:23 +03:00
arvanitakis	89255687a1	Feature: Add ACS courier integration ACS rate driver (live price quotes via ACS_Price_Calculation, cached postcode-to-station lookups) and fulfillment service (voucher creation, label printing, end-of-day pickup manifest). Adds a per-rate pricing_mode column so admins can choose live API pricing vs. a fixed price on ACS-driven shipping rates, surfaced via a custom Rates page.	2026-07-19 00:50:51 +03:00
arvanitakis	3599329b57	Feature: Add ManifestResult DTO for carrier manifest batching Completes the carrier-agnostic shipping abstraction (CarrierFulfillmentInterface, SupportsManifestBatching, Shipment model) with the result type SupportsManifestBatching::issueManifest() returns.	2026-07-19 00:50:15 +03:00
arvanitakis	9618d19cfa	Feature: Creating Migration For Adding Pricing Mode to Shipping Rates	2026-07-19 00:42:13 +03:00
arvanitakis	08135c4c8f	Feature: Creating Shipping Carrier Contracts	2026-07-16 17:14:41 +03:00
arvanitakis	e18b2fa44c	Feature: Creating Shipment migration and model	2026-07-16 17:14:23 +03:00