Getting Started

Minimal Steps

Installation

composer require cekurte/pagebundle

Add the bundle to config/bundles.php (Symfony) or config/app.php (Laravel via bridge):

// Laravel (if using a Symfony bridge)
Cekurte\PageBundle\CekurtePageBundle::class => ['all' => true],

Publish Assets & Config

php artisan vendor:publish --provider="Cekurte\PageBundle\CekurtePageBundle" --tag="config"
php artisan vendor:publish --provider="Cekurte\PageBundle\CekurtePageBundle" --tag="public"

First Use Case: Create a Page

Run migrations:
```
php artisan migrate
```

use Cekurte\PageBundle\Entity\Page;
$page = new Page();
$page->setTitle('About Us');
$page->setSlug('about');
$page->setContent('<h1>Welcome to our page!</h1>');
$page->setTemplate('default.html.twig'); // or custom template
$page->setPublished(true);
$page->setWidgets([/* widget config */]);
$em->persist($page);
$em->flush();

Display a Page In a controller or Twig template:

{{ render_page('about') }}

Or in Laravel (if using a bridge):

return view('page', ['page' => \Cekurte\PageBundle\PageManager::getPage('about')]);

Implementation Patterns

Core Workflows

Page Management

CRUD via Admin: Use the provided admin interface (if enabled) to manage pages, widgets, and templates.

Programmatic Creation: Create pages dynamically in controllers or services:

$pageManager = $this->get('cekurte_page.manager');
$page = $pageManager->createPage([
    'title' => 'Contact',
    'slug' => 'contact',
    'content' => '<p>Reach out to us!</p>',
    'widgets' => [
        ['type' => 'contact_form', 'config' => [...]]
    ]
]);

Widget Integration
- Built-in Widgets:
  - Google Maps: Configure via google_maps widget type with api_key, lat, lng, and zoom.
  - Contact Form: Use contact_form widget type with recipient_email and fields.
- Custom Widgets: Extend the bundle by creating a new widget class and registering it in the service container:
```
# config/services.yaml (Symfony) or config/app.php (Laravel)
services:
    App\Widget\CustomWidget:
        tags:
            - { name: cekurte_page.widget, type: custom_widget }
```
Template Overrides
- Override default templates by copying files from: vendor/cekurte/pagebundle/Resources/views/ to resources/views/cekurte_page/.
- Customize page rendering logic by extending the PageRenderer service.
Routing
- Pages are automatically routed via slug. Example:
```
/about → Renders the 'about' page.
```
- Override routing by defining custom routes in routes/web.php:
```
Route::get('/custom-page', 'PageController@show')->name('page.custom');
```
Localization
- Translate page titles/content using Symfony’s translation system or Laravel’s localization:
```
{{ page.title|trans }}
```

Integration Tips

Laravel-Specific:
- Use the PageBundle bridge (if available) to integrate with Laravel’s service container and Blade templates.
- Example Blade template:
```
@component('cekurte-page::page', ['page' => $page])
@endcomponent
```
Symfony-Specific:
- Leverage Twig’s render_page function for dynamic page rendering.
- Use dependency injection for the PageManager service:
```
public function __construct(\Cekurte\PageBundle\Manager\PageManager $pageManager) {
    $this->pageManager = $pageManager;
}
```

Frontend Integration:

Load widget-specific assets (e.g., Google Maps API) via Twig:

{% block javascripts %}
    {{ parent() }}
    {{ widget_javascripts(page.widgets) }}
{% endblock %}

Gotchas and Tips

Pitfalls

Widget Configuration:
- Missing Widget Types: Only google_maps and contact_form are built-in. Custom widgets require manual registration.
- Validation Errors: Widget configs must match expected schema. Validate in Tinker before deployment:
```
$widget = ['type' => 'google_maps', 'config' => ['api_key' => 'invalid']];
$pageManager->validateWidget($widget); // Throws exception if invalid.
```
Routing Conflicts:
- Pages with slugs like admin or login may conflict with Laravel/Symfony’s default routes. Exclude them via:
```
$page->setExcludedFromRouting(true);
```
Template Inheritance:
- Overriding templates requires copying the entire template hierarchy. Use extends in custom templates:
```
{% extends 'cekurte_page::base.html.twig' %}
```
Database Migrations:
- Customize the Page entity by extending it and updating migrations:
```
// src/Entity/ExtendedPage.php
use Cekurte\PageBundle\Entity\Page as BasePage;

class ExtendedPage extends BasePage {
    // Add custom fields.
}
```
- Update the bundle’s migration files or create a new migration.
Caching:
- Pages are cached by default. Clear cache after updates:
```
php artisan cache:clear
```
- Disable caching for development:
```
$pageManager->setCacheEnabled(false);
```

Debugging

Widget Rendering Issues:
- Check widget logs in storage/logs/laravel.log (Laravel) or var/log/dev.log (Symfony).
- Enable debug mode for Twig:
```
// config/packages/twig.yaml (Symfony)
twig:
    debug: true
```

Route Debugging:

Dump routes to identify conflicts:
```
php artisan route:list
```

Test page rendering in Tinker:

$page = $pageManager->getPage('about');
var_dump($page->getWidgets());

Database Issues:
- Verify migrations ran:
```
php artisan migrate:status
```
- Check the pages and widgets tables for expected data.

Tips

Development Workflow:
- Use the dev environment to test widgets and templates without caching:
```
// config/app.php (Laravel)
'env' => env('DEV', 'local'),
```
- Enable Twig debugging for real-time template updates.

Performance:

Lazy-load widgets in templates:

{% for widget in page.widgets if widget.type == 'google_maps' %}
    {{ render_widget(widget) }}
{% endfor %}

Use fragment caching for static page content:

{% cache 'page_about_content' %}
    {{ page.content }}
{% endcache %}

Extending Functionality:
- Custom Widget Events: Dispatch events for widget rendering:
```
// In a service
$event = new WidgetRenderEvent($widget);
$this->eventDispatcher->dispatch($event, WidgetEvents::PRE_RENDER);
```
- Page Events: Listen for page.save or page.delete events to trigger actions.

Testing:

Test page rendering with PHPUnit:

public function testPageRendering() {
    $page = $this->createMock(Page::class);
    $page->method('getSlug')->willReturn('test');
    $this->assertEquals('Test Page', $this->pageManager->getPage('test')->getTitle());
}

Use Laravel’s HTTP tests for route testing:

$response = $this->get('/test');
$response->assertSee('Test Content');

Localization:

Translate widget labels and placeholders:

# config/translation_messages.yaml (Symfony)
en:
    cekurte_page:
        widgets:
            google_maps:
                title: 'Map Location'

In Laravel

Pagebundle Laravel Package