Help mij met het opzetten van een maatwerk Statamic add-on
description
Met deze prompt kan ik gericht hulp krijgen bij het ontwikkelen van een unieke Statamic add-on die precies aansluit bij mijn projectbehoeften. Het helpt mij om maatwerk functionaliteit toe te voegen zonder te worstelen met algemene oplossingen, wat tijd bespaart en mijn website uitbreidbaar maakt.
prompt
Help mij met het ontwerpen en schrijven van een Statamic add-on die de volgende functionaliteit bevat: <beschrijf de gewenste functionaliteit>. ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hieronder vind je een stapsgewijze gids om een Statamic 3.1.2 add-on te ontwikkelen die automatisch SEO metadata genereert voor nieuwe pagina's en integreert met de Google Analytics API.
Stap 1: Maak een nieuwe add-on aan
------------------------------------
Gebruik Composer om een nieuwe add-on te maken:
```bash
composer create-statamic-addon jouwnaam/seo-metadata-generator
```
Dit creëert een basisstructuur voor je add-on.
Stap 2: Structuur en basisbestanden
-------------------------------------
In de map `src/` van je add-on maak je de benodigde classes, bijvoorbeeld:
- `SeoMetadataGenerator.php` (de hoofdklasse)
- `ServiceProvider.php` (voor registraties en event listening)
Stap 3: Event listener voor nieuwe pagina's
--------------------------------------------
Je wilt dat de metadata automatisch gegenereerd wordt bij het aanmaken van een nieuwe pagina. Gebruik hiervoor de `EntryCreated` event.
In `ServiceProvider.php`:
```php
namespace Jouwnaam\SeoMetadataGenerator;
use Statamic\Events\EntrySaved;
use Illuminate\Support\ServiceProvider;
use Statamic\Facades\Entry;
class ServiceProvider extends ServiceProvider
{
public function boot()
{
// Luister naar de event van het opslaan van een nieuwe pagina
\Statamic\Facades\Event::listen(EntrySaved::class, function ($event) {
$entry = $event->entry;
// Controleer of het een nieuwe pagina betreft
if ($entry->wasRecentlyCreated() && $entry->collectionHandle() === 'pagina') {
$this->generateSeoMetadata($entry);
}
});
}
protected function generateSeoMetadata($entry)
{
// Roep je service aan om metadata te genereren
(new SeoMetadataGenerator())->generate($entry);
}
}
```
Stap 4: Het genereren van SEO metadata
---------------------------------------
In `SeoMetadataGenerator.php`:
```php
namespace Jouwnaam\SeoMetadataGenerator;
use Statamic\Facades\Entry;
class SeoMetadataGenerator
{
public function generate(Entry $entry)
{
// Voorbeeld: genereer een titel en description op basis van content
$title = $entry->get('titel') ?? 'Standaard Titel';
$description = $this->generateDescription($entry);
// Sla de metadata op in velden of via een aparte structuur
$entry->set('seo_title', $title);
$entry->set('seo_description', $description);
$entry->save();
}
protected function generateDescription(Entry $entry)
{
// Bijvoorbeeld: eerste 150 tekens van content
$content = $entry->get('inhoud') ?? '';
return substr($content, 0, 150);
}
}
```
Zorg dat je in je paginacontenttype velden hebt voor `seo_title` en `seo_description`, of maak hiervoor aparte velden aan.
Stap 5: Integratie met Google Analytics API
---------------------------------------------
Voor de Analytics-integratie:
1. Maak een Google Cloud Project en activeer de Analytics API.
2. Download de OAuth 2.0 credentials (`credentials.json`).
3. Installeer de Google API Client Library:
```bash
composer require google/apiclient
```
4. Voeg een service toe om data op te halen:
```php
namespace Jouwnaam\SeoMetadataGenerator;
use Google\Client;
use Google\Service\AnalyticsReporting;
class GoogleAnalyticsService
{
protected $client;
public function __construct()
{
$this->client = new Client();
$this->client->setAuthConfig(storage_path('app/credentials.json'));
$this->client->addScope(AnalyticsReporting::ANALYTICS_READONLY);
}
public function getPageViews($pageUrl)
{
$service = new AnalyticsReporting($this->client);
// Stel rapportage verzoek op (voorbeeld)
// Dit vereist dat je de juiste view ID hebt
$viewId = 'YOUR_VIEW_ID';
$dateRange = new \Google\Service\AnalyticsReporting\DateRange([
'startDate' => '7daysAgo',
'endDate' => 'today',
]);
$metrics = new \Google\Service\AnalyticsReporting\Metric([
'expression' => 'ga:pageviews',
]);
$request = new \Google\Service\AnalyticsReporting\ReportRequest([
'viewId' => $viewId,
'dateRanges' => [$dateRange],
'metrics' => [$metrics],
'dimensionFilterClauses' => [
new \Google\Service\AnalyticsReporting\DimensionFilterClause([
'filters' => [
new \Google\Service\AnalyticsReporting\DimensionFilter([
'dimensionName' => 'ga:pagePath',
'operator' => 'EXACT',
'expressions' => [$pageUrl],
]),
],
]),
],
]);
$body = new \Google\Service\AnalyticsReporting\GetReportsRequest([
'reportRequests' => [$request],
]);
$response = $service->reports->batchGet($body);
// Verwerk response om pageviews op te halen
// ...
return $pageViews ?? 0;
}
}
```
5. Koppel deze data aan je metadata of gebruik het voor analyses.
Stap 6: Automatisering en testen
---------------------------------
- Test je add-on door een nieuwe pagina aan te maken en te controleren of de metadata automatisch gegenereerd wordt.
- Voeg eventueel een CLI-commando toe om handmatig metadata te genereren.
- Zorg dat je API-sleutels en credentials veilig opgeslagen worden.
Samenvatting
-------------
- Maak een Statamic add-on met event listeners voor nieuwe pagina's.
- Genereer SEO metadata op basis van pagina-inhoud.
- Integreer met Google Analytics API om pagina prestaties te analyseren.
- Test en verfijn je add-on.
Mocht je verdere hulp nodig hebben bij specifieke code of implementatie, laat het gerust weten!
provider: deepseek
model: deepseek-chat
Ik help je graag met het ontwerpen van een Statamic add-on voor automatische SEO metadata. Hier is een complete handleiding in het Nederlands:
## Statamic SEO Metadata Add-on voor versie 3.1.2
### Vereisten
- Statamic 3.1.2
- PHP 7.4+
- Google Analytics API toegang
- Composer
### Stap 1: Add-on aanmaken
```bash
php please make:addon SEOGenerator
```
### Stap 2: Package Structure
```
seo-generator/
├── src/
│ ├── SEOGeneratorServiceProvider.php
│ ├── Tags/
│ │ └── SEOTags.php
│ ├── Listeners/
│ │ └── GenerateSEOMetadata.php
│ └── Services/
│ └── GoogleAnalyticsService.php
├── config/
│ └── seo-generator.php
└── resources/
└── views/
└── seo.antlers.html
```
### Stap 3: Service Provider (`SEOGeneratorServiceProvider.php`)
```php
<?php
namespace App\Addons\SEOGenerator;
use Statamic\Providers\AddonServiceProvider;
use App\Addons\SEOGenerator\Listeners\GenerateSEOMetadata;
use App\Addons\SEOGenerator\Tags\SEOTags;
use Statamic\Events\EntrySaved;
class SEOGeneratorServiceProvider extends AddonServiceProvider
{
protected $tags = [
SEOTags::class,
];
protected $listen = [
EntrySaved::class => [
GenerateSEOMetadata::class,
],
];
public function boot()
{
parent::boot();
$this->publishes([
__DIR__.'/../config/seo-generator.php' => config_path('seo-generator.php'),
], 'seo-generator-config');
}
}
```
### Stap 4: Configuratiebestand (`config/seo-generator.php`)
```php
<?php
return [
'google_analytics' => [
'property_id' => env('GOOGLE_ANALYTICS_PROPERTY_ID'),
'credentials_path' => env('GOOGLE_APPLICATION_CREDENTIALS'),
],
'default_metadata' => [
'title_template' => '{title} | {site_name}',
'description_length' => 160,
'keywords_count' => 5,
],
'enabled_collections' => [
'pages',
'blog',
],
];
```
### Stap 5: Google Analytics Service (`Services/GoogleAnalyticsService.php`)
```php
<?php
namespace App\Addons\SEOGenerator\Services;
use Google\Client;
use Google\Service\AnalyticsData;
use Illuminate\Support\Facades\Cache;
class GoogleAnalyticsService
{
protected $client;
protected $service;
public function __construct()
{
$this->client = new Client();
$this->client->setAuthConfig(config('seo-generator.google_analytics.credentials_path'));
$this->client->addScope(AnalyticsData::ANALYTICS_READONLY);
$this->service = new AnalyticsData($this->client);
}
public function getPopularKeywords($days = 30)
{
return Cache::remember('ga_popular_keywords', 3600, function () use ($days) {
$request = new AnalyticsData\RunReportRequest([
'property' => 'properties/' . config('seo-generator.google_analytics.property_id'),
'dateRanges' => [new AnalyticsData\DateRange(['start_date' => $days . 'daysAgo', 'end_date' => 'today'])],
'dimensions' => [new AnalyticsData\Dimension(['name' => 'searchKeyword'])],
'metrics' => [new AnalyticsData\Metric(['name' => 'activeUsers'])],
'limit' => 10
]);
$response = $this->service->properties->runReport(
config('seo-generator.google_analytics.property_id'),
$request
);
return collect($response->getRows())->pluck('dimensionValues.0.value')->toArray();
});
}
public function getContentPerformance($url)
{
// Implementatie voor content performance data
}
}
```
### Stap 6: Event Listener (`Listeners/GenerateSEOMetadata.php`)
```php
<?php
namespace App\Addons\SEOGenerator\Listeners;
use Statamic\Events\EntrySaved;
use App\Addons\SEOGenerator\Services\GoogleAnalyticsService;
use Statamic\Facades\Entry;
class GenerateSEOMetadata
{
protected $gaService;
public function __construct(GoogleAnalyticsService $gaService)
{
$this->gaService = $gaService;
}
public function handle(EntrySaved $event)
{
$entry = $event->entry;
$collection = $entry->collectionHandle();
if (!in_array($collection, config('seo-generator.enabled_collections'))) {
return;
}
if (!$entry->get('seo_title') && !$entry->get('meta_description')) {
$this->generateMetadata($entry);
}
}
protected function generateMetadata($entry)
{
$popularKeywords = $this->gaService->getPopularKeywords();
$title = $this->generateTitle($entry, $popularKeywords);
$description = $this->generateDescription($entry, $popularKeywords);
$entry->set('seo_title', $title)
->set('meta_description', $description)
->saveQuietly();
}
protected function generateTitle($entry, $keywords)
{
$template = config('seo-generator.default_metadata.title_template');
return str_replace(
['{title}', '{site_name}'],
[$entry->get('title'), config('app.name')],
$template
);
}
protected function generateDescription($entry, $keywords)
{
$content = $entry->get('content') ?? '';
$description = strip_tags($content);
$description = substr($description, 0, config('seo-generator.default_metadata.description_length'));
return $description . ' | ' . implode(', ', array_slice($keywords, 0, 3));
}
}
```
### Stap 7: Tags voor templates (`Tags/SEOTags.php`)
```php
<?php
namespace App\Addons\SEOGenerator\Tags;
use Statamic\Tags\Tags;
class SEOTags extends Tags
{
protected static $handle = 'seo';
public function meta()
{
return view('seo-generator::seo', [
'title' => $this->context->get('seo_title'),
'description' => $this->context->get('meta_description'),
'keywords' => $this->context->get('meta_keywords'),
]);
}
}
```
### Stap 8: SEO Template (`resources/views/seo.antlers.html`)
```html
@if(seo_title)
<title>{{ seo_title }}</title>
<meta name="title" content="{{ seo_title }}">
@endif
@if(meta_description)
<meta name="description" content="{{ meta_description }}">
@endif
@if(keywords)
<meta name="keywords" content="{{ keywords }}">
@endif
<meta property="og:title" content="{{ seo_title ?? title }}">
<meta property="og:description" content="{{ meta_description }}">
```
### Stap 9: Installatie en configuratie
1. Plaats de add-on in `app/Addons/SEOGenerator`
2. Voeg service provider toe aan `config/app.php`:
```php
'providers' => [
// ...
App\Addons\SEOGenerator\SEOGeneratorServiceProvider::class,
],
```
3. Publiceer configuratie:
```bash
php please vendor:publish --tag=seo-generator-config
```
4. Omgevingsvariabelen toevoegen aan `.env`:
```
GOOGLE_ANALYTICS_PROPERTY_ID=GA4_PROPERTY_ID
GOOGLE_APPLICATION_CREDENTIALS=/pad/naar/service-account-key.json
```
### Stap 10: Gebruik in templates
```antlers
<head>
{{ seo:meta }}
<!-- overige head content -->
</head>
```
### Belangrijke opmerkingen:
- Zorg voor een geldige Google Service Account
- Configureer GA4 property correct
- Test grondig in development omgeving
- Voeg caching toe voor API requests
- Implementeer error handling voor API failures
Deze add-on genereert automatisch SEO metadata bij het aanmaken van nieuwe pagina's en integreert met Google Analytics voor keyword-optimalisatie.