Ontwikkel een geavanceerde contentvalidatie en foutafhandeling in Craft CMS
description
Met deze prompt kan de gebruiker een robuust validatiesysteem opzetten dat fouten vermindert en de contentkwaliteit waarborgt. Het helpt bij het voorkomen van onjuiste of incomplete gegevensinvoer en verbetert de gebruikerservaring met duidelijke feedback. Dit is effectiever dan standaardvalidatie omdat het maatwerk en gebruikersgerichte foutafhandeling biedt.
prompt
Help me bij het opzetten van een geavanceerd systeem voor contentvalidatie en foutafhandeling in mijn Craft CMS website. Ik wil aangepaste validatieregels toepassen op de volgende inho ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een stapsgewijze handleiding voor het opzetten van een geavanceerd systeem voor contentvalidatie en foutafhandeling in Craft CMS, inclusief aangepaste validatieregels en gebruikersvriendelijke foutmeldingen.
---
### Stap 1: Maak aangepaste validatieregels
**a. Creëer een Custom Validator Class**
Maak een nieuwe PHP-klasse aan in je `craft` map, bijvoorbeeld `CustomValidators.php` (bijvoorbeeld in `craft/web/validators/`).
```php
<?php
namespace craft\validators;
use yii\validators\Validator;
class CustomValidators extends Validator
{
public function validateAttribute($model, $attribute)
{
// Voeg hier je aangepaste validatielogica toe
$value = $model->$attribute;
if ($attribute === 'title') {
// Voorbeeld: titel moet minimaal 10 tekens hebben
if (strlen($value) < 10) {
$this->addError($model, $attribute, 'De titel moet minimaal 10 tekens bevatten.');
}
}
if ($attribute === 'price') {
// Voorbeeld: prijs moet positief zijn
if ($value <= 0) {
$this->addError($model, $attribute, 'De prijs moet een positief getal zijn.');
}
}
// Voeg meer regels toe afhankelijk van inhoudstype
}
}
?>
```
---
### Stap 2: Gebruik de validatie in je inhoudstypes
**b. Pas de `beforeSave()` methode aan in je Entry-Model**
Stel dat je de validatie wilt doen bij het opslaan van een entry, bijvoorbeeld in `Entry.php` of via een event.
```php
use craft\elements\Entry;
use craft\services\Elements;
use craft\validators\CustomValidators;
Event::on(Elements::class, Elements::EVENT_BEFORE_SAVE, function($event) {
$entry = $event->element;
if ($entry instanceof Entry) {
// Check of het een Blogpost of Productpagina is
if (in_array($entry->section->handle, ['blogposts', 'productpagina'])) {
$validator = new CustomValidators();
foreach ($entry->getFieldLayout()->fields() as $field) {
$attribute = $field->handle;
$validator->validateAttribute($entry, $attribute);
}
if ($entry->hasErrors()) {
// Voorkom dat het wordt opgeslagen
$event->isValid = false;
}
}
}
});
```
---
### Stap 3: Duidelijke foutmeldingen tonen aan gebruikers
**c. Foutmeldingen weergeven in je template**
In je Twig-sjablonen, controleer of er validatiefouten zijn en toon deze op een gebruikersvriendelijke manier:
```twig
{% if entry.hasErrors() %}
<div class="error-messages">
<h3>Fouten bij het opslaan van de inhoud:</h3>
<ul>
{% for error in entry.getErrors() %}
<li>{{ error }}</li>
{% endfor %}
</ul>
</div>
{% endif %}
```
**d. Optioneel: AJAX-validatie voor realtime feedback**
Voor een meer geavanceerde aanpak kun je JavaScript gebruiken om validaties te doen en foutmeldingen dynamisch te tonen, bijvoorbeeld met een AJAX-call naar een custom endpoint.
---
### Stap 4: Test je validatie systeem
- Voeg testinhoud toe via de CMS-interface.
- Probeer inhoud met ongeldige data op te slaan.
- Controleer of de juiste foutmeldingen worden getoond en dat de inhoud niet wordt opgeslagen bij fouten.
---
### Samenvatting:
1. Maak een aangepaste validator class.
2. Implementeer validatie in een event zoals `beforeSave`.
3. Toon foutmeldingen in de templates.
4. Test je systeem uitgebreid.
---
Indien je verdere hulp nodig hebt bij specifieke validatieregels of integraties, laat het gerust weten!
provider: deepseek
model: deepseek-chat
Zeker, ik help je graag met het opzetten van een geavanceerd validatiesysteem in Craft CMS. Hier is een complete handleiding:
## Stap 1: Aanmaken van validatie service
Maak eerst een custom module aan voor je validaties:
```php
// modules/ValidationModule/src/ValidationService.php
<?php
namespace modules\ValidationModule\src;
use Craft;
use yii\base\Component;
use craft\elements\Entry;
class ValidationService extends Component
{
public function validateBlogPost(Entry $entry): array
{
$errors = [];
// Titel validatie
if (empty($entry->title)) {
$errors['title'] = 'Titel is verplicht';
} elseif (strlen($entry->title) < 10) {
$errors['title'] = 'Titel moet minimaal 10 karakters bevatten';
}
// Inhoud validatie
if (empty($entry->bodyContent)) {
$errors['bodyContent'] = 'Inhoud mag niet leeg zijn';
} elseif (str_word_count(strip_tags($entry->bodyContent)) < 150) {
$errors['bodyContent'] = 'Blogpost moet minimaal 150 woorden bevatten';
}
// Featured image validatie
if (empty($entry->featuredImage)) {
$errors['featuredImage'] = 'Featured afbeelding is verplicht';
}
return $errors;
}
public function validateProductPage(Entry $entry): array
{
$errors = [];
// Prijs validatie
if (empty($entry->productPrice)) {
$errors['productPrice'] = 'Prijs is verplicht';
} elseif (!is_numeric($entry->productPrice) || $entry->productPrice <= 0) {
$errors['productPrice'] = 'Prijs moet een positief getal zijn';
}
// SKU validatie
if (empty($entry->productSku)) {
$errors['productSku'] = 'SKU is verplicht';
} elseif (!preg_match('/^[A-Z0-9\-]{8,}$/', $entry->productSku)) {
$errors['productSku'] = 'SKU moet minimaal 8 karakters bevatten (hoofdletters, cijfers en streepjes)';
}
// Voorraad validatie
if ($entry->productStock < 0) {
$errors['productStock'] = 'Voorraad kan niet negatief zijn';
}
// Categorie validatie
if (empty($entry->productCategories)) {
$errors['productCategories'] = 'Selecteer minimaal één categorie';
}
return $errors;
}
}
```
## Stap 2: Event handler voor validatie
```php
// modules/ValidationModule/src/EventHandlers/EntryValidationHandler.php
<?php
namespace modules\ValidationModule\src\EventHandlers;
use Craft;
use yii\base\Event;
use craft\events\ModelEvent;
use craft\elements\Entry;
use modules\ValidationModule\src\ValidationService;
class EntryValidationHandler
{
public static function handleBeforeSave(ModelEvent $event)
{
$entry = $event->sender;
if (!$entry instanceof Entry) {
return;
}
$validationService = Craft::$app->getModule('validation-module')->validationService;
$errors = [];
switch ($entry->section->handle) {
case 'blogPosts':
$errors = $validationService->validateBlogPost($entry);
break;
case 'products':
$errors = $validationService->validateProductPage($entry);
break;
}
if (!empty($errors)) {
foreach ($errors as $attribute => $errorMessage) {
$entry->addError($attribute, $errorMessage);
}
$event->isValid = false;
}
}
}
```
## Stap 3: Module configuratie
```php
// modules/ValidationModule/ValidationModule.php
<?php
namespace modules\ValidationModule;
use Craft;
use yii\base\Module;
use modules\ValidationModule\src\ValidationService;
use modules\ValidationModule\src\EventHandlers\EntryValidationHandler;
use craft\events\RegisterComponentTypesEvent;
use craft\services\Fields;
class ValidationModule extends Module
{
public function init()
{
parent::init();
$this->setComponents([
'validationService' => ValidationService::class,
]);
// Registreer event handlers
Craft::$app->onInit(function() {
Craft::$app->getElements()->on(
Entry::EVENT_BEFORE_SAVE,
[EntryValidationHandler::class, 'handleBeforeSave']
);
});
}
}
```
## Stap 4: Configuratie in config/app.php
```php
// config/app.php
return [
'modules' => [
'validation-module' => [
'class' => \modules\ValidationModule\ValidationModule::class,
'components' => [
'validationService' => [
'class' => \modules\ValidationModule\src\ValidationService::class,
],
],
],
],
'bootstrap' => ['validation-module'],
];
```
## Stap 5: Custom foutmeldingen template
```twig
{# templates/_includes/validation-errors.twig #}
{% if entry is defined and entry.hasErrors() %}
<div class="validation-errors alert alert-danger">
<h4>Validatiefouten:</h4>
<ul>
{% for attribute, errors in entry.errors %}
{% for error in errors %}
<li><strong>{{ attribute|capitalize }}:</strong> {{ error }}</li>
{% endfor %}
{% endfor %}
</ul>
</div>
{% endif %}
```
## Stap 6: Frontend validatie (optioneel)
```javascript
// assets/js/validation.js
class CraftValidation {
static init() {
// Client-side validatie voor blogposts
this.setupBlogValidation();
this.setupProductValidation();
}
static setupBlogValidation() {
const form = document.querySelector('form[data-section="blogPosts"]');
if (!form) return;
form.addEventListener('submit', (e) => {
const title = form.querySelector('[name="fields[title]"]');
const content = form.querySelector('[name="fields[bodyContent]"]');
if (title.value.length < 10) {
e.preventDefault();
this.showError(title, 'Titel moet minimaal 10 karakters bevatten');
}
if (this.wordCount(content.value) < 150) {
e.preventDefault();
this.showError(content, 'Minimaal 150 woorden vereist');
}
});
}
static wordCount(text) {
return text.split(/\s+/).filter(word => word.length > 0).length;
}
static showError(field, message) {
// Error weergave logica
}
}
document.addEventListener('DOMContentLoaded', () => CraftValidation.init());
```
## Stap 7: Custom validatie rules toevoegen
```php
// modules/ValidationModule/src/validators/CustomValidators.php
<?php
namespace modules\ValidationModule\src\validators;
use yii\validators\Validator;
class MinWordsValidator extends Validator
{
public $minWords;
public function validateAttribute($model, $attribute)
{
$value = $model->$attribute;
$wordCount = str_word_count(strip_tags($value));
if ($wordCount < $this->minWords) {
$this->addError($model, $attribute,
"Moet minimaal {$this->minWords} woorden bevatten (huidig: {$wordCount})");
}
}
}
```
## Installatie stappen:
1. Maak de mapstructuur aan: `modules/ValidationModule/`
2. Plaats alle bestanden in de juiste mappen
3. Voeg de configuratie toe aan `config/app.php`
4. Clear cache: `php craft clear-cache/all`
5. Test de validatie met verschillende scenario's
Dit systeem biedt:
- Sectie-specifieke validatie
- Duidelijke foutmeldingen voor gebruikers
- Uitbreidbare architectuur
- Zowel server- als client-side validatie
- Custom validatie rules
De foutmeldingen worden automatisch getoond in het Craft CMS control panel en kunnen ook in frontend forms worden weergegeven.