## Getting Started

### Minimal Setup
1. **Installation**
   ```bash
   composer require binsoul/symfony-bundle-website

return [
    // ...
    Binsoul\WebsiteBundle\WebsiteBundle::class => ['all' => true],
];

First Use Case: Basic Page Rendering The bundle likely provides a WebsiteController or similar. Check the src/Resources/config/routes.yaml (if included) for default routes. For a Laravel equivalent, assume it offers a templating system (e.g., Twig-like) for static pages. Example (hypothetical):
```
// routes/web.php
use Binsoul\WebsiteBundle\Controller\WebsiteController;

Route::get('/about', [WebsiteController::class, 'show'])->name('website.about');
```
- Key Files to Inspect:
  - src/Controller/ for controllers.
  - src/Resources/views/ for templates (if bundled).
  - src/DependencyInjection/ for configuration.
Configuration Override default settings via config/packages/binsoul_website.yaml (Symfony-style). For Laravel, adapt to .env or config/website.php:
```
# Example (adapt to Laravel)
website:
    default_template: 'base.html.twig'
    cache_enabled: true
```

Implementation Patterns

1. Templating Workflow

Assumed Pattern: The bundle likely integrates with Twig (Symfony) or provides a Blade-like wrapper. For Laravel:
- Use the bundle’s render() helper (if available) to output pages:
```
return $this->render('pages/about', ['title' => 'About Us']);
```
- Extend base templates by overriding resources/views/layouts/base.blade.php.

Dynamic Content:

Fetch data via services (e.g., WebsiteService) or repositories:

$pages = app(\Binsoul\WebsiteBundle\Service\PageService::class)->getPublishedPages();

Pass data to views:

return view('website.page', compact('pages'));

2. Routing and URL Generation

Symfony-to-Laravel Adaptation:

Replace Symfony’s path() with Laravel’s route():

// Symfony: $this->generateUrl('website.about')
// Laravel: route('website.about')

Define routes in routes/web.php with namespaced controllers:

Route::prefix('website')->group(function () {
    Route::get('/{page}', [WebsiteController::class, 'show'])->name('website.page');
});

3. Asset Management

Static Assets: Place CSS/JS in public/bundles/website/ (Symfony convention). In Laravel:
- Use mix or vite to compile assets to public/build/.
- Reference assets in Blade:
```
<link href="{{ asset('build/css/website.css') }}" rel="stylesheet">
```

4. Localization (i18n)

Translation Files: Check for translations/ in the bundle. In Laravel:
- Publish translations:
```
php artisan vendor:publish --tag=website-translations
```
- Use Laravel’s __() helper:
```
__('website.welcome_message')
```

5. Caching

Enable Caching: Configure in config/website.php:

'cache' => [
    'enabled' => env('WEBSITE_CACHE_ENABLED', true),
    'driver' => 'file', // or 'redis'
],

Cache Invalidation: Clear cache manually or via events:
```
php artisan cache:clear
```

Gotchas and Tips

Pitfalls

Symfony vs. Laravel Abstraction Layer:
- The bundle assumes Symfony’s Container, Twig, and DependencyInjection. For Laravel:
  - Workaround: Use a facade or service container adapter (e.g., symfony/dependency-injection bridge).
  - Example: Wrap Symfony services in Laravel services:
```
class WebsiteService extends Service
{
    public function __construct(private PageRepository $repository) {}
}
```

Missing Laravel-Specific Features:

Authentication: The bundle may not integrate with Laravel’s Auth. Manually guard routes:
```
Route::get('/dashboard', [WebsiteController::class, 'dashboard'])->middleware('auth');
```

Middleware: Register custom middleware in app/Http/Kernel.php:

protected $routeMiddleware = [
    'website.cache' => \Binsoul\WebsiteBundle\Middleware\CacheMiddleware::class,
];

Template Inheritance:
- If the bundle uses Twig, extend templates with Blade’s @extends:
```
@extends('website::layouts.base')
@section('content')
    {{ $slot }}
@endsection
```
Database Migrations:
- The bundle may include migrations (e.g., pages table). Publish and adapt:
```
php artisan vendor:publish --tag=website-migrations
```
- Modify migrations in database/migrations/ to fit Laravel’s schema builder.

Debugging Tips

Service Not Found:

Ensure the bundle is registered in config/bundles.php (Symfony) or AppServiceProvider (Laravel):

public function register()
{
    $this->app->bind(\Binsoul\WebsiteBundle\Service\PageService::class, function ($app) {
        return new \Binsoul\WebsiteBundle\Service\PageService($app['db']);
    });
}

Route Conflicts:

Use route model binding to avoid clashes:

Route::get('/pages/{page:slug}', [WebsiteController::class, 'show']);

Asset Loading Issues:
- Clear Laravel’s cache and config:
```
php artisan cache:clear
php artisan config:clear
```

Extension Points

Custom Controllers:

Extend the bundle’s base controller:

namespace App\Http\Controllers;

use Binsoul\WebsiteBundle\Controller\AbstractWebsiteController;

class CustomWebsiteController extends AbstractWebsiteController
{
    public function customAction() { /* ... */ }
}

Event Listeners:

Listen to bundle events (e.g., WebsitePagePublished):

use Binsoul\WebsiteBundle\Event\PagePublishedEvent;

public function handle(PagePublishedEvent $event)
{
    Log::info("Page published: {$event->getPage()->getSlug()}");
}

protected $listen = [
    PagePublishedEvent::class => [
        \App\Listeners\LogPagePublish::class,
    ],
];

Custom Templates:
- Override bundle views by publishing assets:
```
php artisan vendor:publish --tag=website-views
```
- Modify published views in resources/views/vendor/website/.

API Integration:

Expose bundle data via Laravel’s API resources:

namespace App\Http\Resources;

use Binsoul\WebsiteBundle\Entity\Page;
use Illuminate\Http\Resources\Json\JsonResource;

class PageResource extends JsonResource
{
    public function toArray($request)
    {
        return ['slug' => $this->slug, 'title' => $this->title];
    }
}

---

Symfony Bundle Website Laravel Package