Skip to content

Main Navigation Docs Apps Themes APIs Frontends

HTTP APIs

Meteor

Meteor Admin SDK

Meteor Component Library

Meteor Icon Kit

Design

shopware.design

Releases

Learning

Appearance

Sidebar Navigation

Docs

Concepts

Commerce

Catalog

Products

Categories

Sales Channels

Checkout

Cart

Orders

Payments

Content

Shopping Experiences (CMS)

Cookie Consent Management

Framework

Architecture

Storefront

Administration

Rule system

Rule concepts

Rule evaluation

Data Abstraction Layer

Messaging

Migrations

HTTP Cache

Elasticsearch

Flow

System Check

In-App Purchases

Extensions

Apps

Plugins

API

Store API

Admin API

Translations

Built-in Translation Handling

Fallback language selection

Guides

Installation

Setups

Docker

Devenv

Symfony CLI

Additional Docker Options

Additional Devenv Options

Requirements

Project Template

Extensions

Plugins

Plugin fundamentals

Add plugin configuration

Use plugin configuration

Database migrations

Dependency injection

Listening to events

Add custom service

Adjusting a service

Add plugin dependencies

Add custom CLI commands

Add scheduled task

Using custom fields of type media

Adding NPM dependencies

Adding Composer dependencies

Plugin lifecycle methods

Logging

Checkout

Cart

Add cart collector/processor

Add cart items

Add cart discounts

Add cart validator

Change price of items in cart

Customize price calculation

Tax provider

Document

Add custom document

Add custom document type

Order

Using the state machine

Listen to order changes

Payment

Add payment plugin

Customize payment provider

Content

CMS

Add CMS block

Add CMS element

Add data to CMS element

Mail

Add data to mails

Add mail templates

Media

Prevent Deletion of Media Files Referenced in your Plugins

Add custom media extension

Remote Thumbnail Generation

SEO

Add custom SEO URLs

Extend robots.txt configuration

Sitemap

Add custom sitemap entries

Modifying sitemap entries

Remove sitemap entries

Stock

Implementing your own stock storage

Loading Stock Information from a different Source

Reading and Writing Stock

Elasticsearch

Add product entity extension to elasticsearch

Framework

Data Handling / DataAbstractionLayer

Entities via attributes

Reading data

Writing data

Adding custom complex data

Adding complex data to existing entities

Replacing associated data

Removing associated data

Adding data associations

Adding data translations

Using database events

Using flags

Field inheritance

Versioning entities

Adding Data Indexer

Caching

Custom Fields

Add custom field

Fetching data from "entity selection" custom field

Event

Add custom event

Finding events

Extension Points

Finding Extension Points

Creating Custom Extension Points

Extension Points vs Events

Message Queue

Add message to queue

Add message handler

Add middleware

Rule

Add custom rules

Store API

Add store API route

Override existing route

Filesystem

Filesystem - Flysystem

Flow

Add Flow Builder action

Add Flow Builder trigger

Running actions inside transactions

Rate Limiter

Add Rate Limiter to API Route

System Checks

Add custom check

Administration

Advanced configuration

Extending Webpack

Add shortcuts

Add rule assignment configuration

Modify dynamic product groups blacklist

Data handling processing

Using the data handling

Using the data grid component

The Shopware object

Using custom fields

Add custom data to the search

Handling media

Using Vuex Stores

Mixins directives

Adding Mixins

Using Mixins

Using Directives

Module component management

Add custom module

Add custom component

Customize modules

Customizing components

Add custom input field to existing component

Using base components

Permissions error handling

Adding permissions

Adding error handling

Routing navigation

Add custom route

Add menu entry

Override existing routes

Add tab to existing module

Services utilities

Making API requests

Adding Services

Extending Services

Using utility functions

Add filter

Using filter

Injecting services

The Sanitizer helper

System updates

Upgrading to Meteor Components

Changing from Webpack to Vite

Removing Vue Migration Build

Native Vue

Upgrading to Pinia

Templates styling

Writing templates

Adding snippets

Using assets

Add custom styles

Ui ux

Adding responsive behavior

Storefront

Customize templates

Add custom controller

Add caching to custom controller

Add dynamic content via AJAX calls

Add custom Javascript

Override existing Javascript

Add Javascript as script tag

Add custom assets

Add custom captcha

Add custom styling

Add custom icons

Add custom page

Add custom pagelet

Add translations

Add custom listing filters

Fetching data with Javascript

Add data to storefront page

Add cookie to manager

Customize Header/Footer

Reacting to cookie consent changes

Reacting to javascript events

Working with media and thumbnails

Remove Javascript plugin

Add custom field in the storefront

Add custom sorting for product listing

Add SCSS variables

Add SCSS variables via Subscriber

Using a modal window

Using the datepicker plugin

Use nested line items

Add custom twig functions

Testing

Cypress End-to-end testing

Cypress End-to-end testing

Best practices on writing end-to-end tests

Playwright E2E testing

Install & Configure

Deployment

Fixtures

Page Objects

Actor Pattern

Test Suite Types

Test Suite

Local development

Language Agnostic Testing

Test Data Service

Best Practices

Jest unit tests in Shopware's administration

Jest unit tests in Shopware's storefront

PHP unit testing

API

Custom Pricing

Multi Inventory

Plugin Base Guide

Bundle

Plugins for Symfony developers

Redis

In-App Purchases (IAP)

Themes

Theme Base Guide

Create a first theme

Differences Plugins and Apps vs Themes

Theme configuration

Add SCSS Styling and JavaScript to a Theme

Override Bootstrap variables in a Theme

Add assets to a Theme

Add custom icons

Theme inheritance

Theme with Bootstrap styling

Theme inheritance configuration

Apps

App Starter Guides

Starter Guide - Read and write data

Starter Guide - Add an API endpoint

Starter Guide - Create Admin Extensions

App SDKs

Official JavaScript SDK

Getting started

Lifecycle

Context

Signing

HTTP-client

Integrations

External Frontend

Official Symfony bundle

Official PHP SDK

Getting started

Lifecycle

Context

Signing

HTTP-client

Events

App Scripts

Cart manipulation

Data loading

Custom endpoints

Storefront

Apps as themes

Customize templates

Add cookies to the consent manager

Administration

Meteor Admin SDK

Add custom action button

Add custom module

Add CMS element

Add translations for apps

Flow Builder

Add custom flow action from app system

Add custom flow trigger from app system

Custom Data

Custom fields

Custom entities

Content

CMS

Add custom CMS blocks

Rule Builder

Add custom rule conditions

App Base Guide

Configuration

Tax provider

Payment

Webhook

Shipping methods

Client-side communication to the app backend

Signing & Verification in the App System

In-App Purchases (IAP)

Gateways

Checkout

Checkout Gateway

Checkout Gateway Command Reference

Context

Context Gateway Command Reference

Context Gateway

In app purchase

In-App Purchase Gateway

Hosting

Installation & Updates

Deployments

Deployment with Deployer

Deployment Helper

Building without Database

Cluster Setup

Docker Image

Extension Management

Performing Shopware Updates

Configurations

Shopware

HTML sanitizer

Staging

Stock

Static System Configuration

Environment Variables

Framework

Custom routes

SameSite protection

Observability

Logging

Profiling / Tracing

OpenTelemetry

Performance

Cache

Performance Test with K6

Session

Increment Storage

Lock Storage

Number Ranges

Cart Storage

Performance Tweaks

Infrastructure

Elasticsearch

Set up Elasticsearch

Debugging Elasticsearch

Redis

Filesystem

Rate Limiter

Database Cluster

Message Queue

Scheduled Task

Reverse HTTP Cache

Integrations / API

General Concepts

Search Criteria

Request Headers

Generated Reference

API Versioning

Partial Data Loading

Products

Extensions

Migration Assistant

Concept

Profile and Connection

DataSelection and DataSet

Migration Context

Premapping

Gateway and Reader

Convert and Mapping

Logging

Writer

Media Processing

Guides

Extending a Shopware migration profile

Extending the Migration Connector

Decorating a Shopware Migration Assistant converter

Creating a new migration profile

B2B Suite

Concepts

System architecture

Basic conventions

Method structure

Line Item List

Guides

Core

Dependency injection

Store API

REST API

Listing service

CRUD service

Assignment service

Audit Log

Exception

Currency

Entity based ACL

Overloading classes

Storefront Authentication

Installation

Storefront

Ajax Panel

Product Search

Complex views

Modal component

Company

ACL and Routing

Extending the Storefront

Example Plugins

Administration

B2B Components

Employee Management

Concepts

Entities & Schema

Guides

API Route Restriction for Employees

Employee Invitation

B2B Roles

Create permissions via App

Create permissions via plugin

Subscription Integration

Quotes Management

Concepts

Entities & Schema

Guides

Quotes conversion

Shopping lists

Concepts

Entities & Schema

Guides

API & Pricing

Order Approval

Concepts

Entities and workflow

Guides

Order approval permissions

Payment Process

How to add a new approval condition

Organization unit

Concepts

Entities & Schema

Guides

Store API

Extending the Organization entity

How to identify the organization unit from the context

B2B Suite Migration

Concept

Migration Table

Technical Terms and Concepts

Execution

Prerequisites

Running Migration

Troubleshooting

Development

Adding Component

Fields Mapping

Handlers

Extending Migration

Validation and Run

References

References

Role and Permission Mapping

Commercial

Advanced Search

Installation

Define a custom Elasticsearch Definition

Add more fields to product search

Configure Searchable Fields

Language analyzers

Cross search

Extending search template

Modify search logic

Search and suggest routes

Completion

Subscriptions

Guides

Separate checkout

Mixed checkout

Template scoping

B2B Employee Integration

Subscription concept

PaaS

Shopware PaaS Native

Get Started

Prepare Shopware codebase

CLI

Quickstart

Fundamentals

Organizations

Projects

Applications

Environment variables

Secrets

Account

Resources

Databases

Object Storage

Monitoring

Logs

Traces

Monitor events

CDN

Guides

How to set up repository access

Using the Vault

Update Shopware in PaaS Native

How to set up OpenSearch

Frequently Asked Questions

Known issues

Shopware PaaS

PaaS CLI Setup

Repository

Build & Deploy

Setup Template

Elasticsearch

RabbitMQ

Fastly

Blackfire

Composable frontends

Composable-Frontends Performance

Blackfire Continuous Profiling of Nuxt.js

Sales Agent

Customization

Branding Customization

I18n Customization

Component Customization

Best practices

Frontend App Deployment

Ubuntu Server with PM2

AWS

Cloudflare

Local installation

Testing

Digital Sales Rooms

Installation

Admin side installation

Frontend app installation

Setup 3rd parties

Realtime Video Call - Daily.co

Realtime Service - Mercure

Configuration

Domain Configuration

Plugin Configuration

Configuration with CLI

Customization

Branding Customization

I18n Customization

Component Customization

Best practices

Frontend App Deployment

Ubuntu Server with PM2

AWS

Cloudflare

SaaS

Shopware CLI

Other Installation Options

Extension commands

Building extensions and creating archives

Standalone Admin Watcher

Extracting Meta Data

Configuration

Project commands

Generating MySQL dumps

Build a complete Project

Remote Extension Management

Helper Commands

Autofixer

Image Proxy

Shopware account commands

Authentication

Releasing automated extension to Shopware Store

Updating Store Page of Extension

Configure Composer Repository

Validation

Formatter

Automatic refactoring

SaaS

Resources

References

API Reference

Core Reference

DAL Reference

Fields Reference

EnumField reference

Flags Reference

Filters Reference

Aggregations Reference

Composer Commands Reference

Commands Reference

Flow Reference

Rules Reference

Actions Reference

App Reference

Script Reference

Cart Manipulation script services reference

Data Loading script services reference

Custom Endpoint script services reference

Miscellaneous script services reference

Script hooks reference

Product script services reference

Manifest Reference

Webhook Events Reference

Payment Reference

CMS Reference

Entities Reference

Flow Action Reference

Administration Reference

Utils

Mixins

Directives

Upgrades and Migrations

Administration

Vue 3 upgrade

Core

Translation

Language Pack Migration

Migrating Extensions

Storefront Reference

Shopware's twig functions

Storefront plugins

Testing Reference

Custom E2E Commands

E2E Commands

Adr

Implement architecture decision records

Get control of association clone behavior as developer

Implement sales channel context token requirement for store-api and sales-channel-api

Document template refactoring

Implement app system inside platform

Implement individual sorting

Merchant registration

Notification titles are pre-defined and make use of the global namespace

Import ACL privileges from other roles

CustomField label loading in storefront

The best-practice to always re-fetch the data after saving

Creating events in Shopware

DAL join filter

Add the login required annotation

Decoration pattern

API version removal

Processing of nested line items

When to use plain SQL or the DAL

Vue administration app has ESLint support

Introduce jest-fail-on-console

Move storefront script to head with defer

Storefront coding standards

Make shopware/shopware stand-alone for development and testing

Refactor admin build process to webpack-multi-compiler mode

Make Core mail templates independent from Storefront urls

Technical concept custom entities

Refactor theme inheritance

Payment Flow

Refund handling

App scripts

Preparing data for rule evaluation

Adjust ADR approval rules for the new org structure

Introduce increment pattern

Merge E2E projects into a single project

Add possibility for plugins to add a HTML file

Admin extension API standards

Add feature flag support for Storefront SCSS

Allow apps to define custom api endpoints

Feature flags for major versions

Move controller level annotation into Symfony route annotation

Rule Scripting in apps

Domain exceptions

Consistent deprecation notices in Core

Use `ResetInterface` to reset instance state during requests

Extract data handling classes to extension sdk

New templates for line items and nested line items

Available stock improvements

Base sales channel context factory

Cache stampede protection

Initial state id loader

Prevent mail updates

Profiler integrations

Redis cart persister

Specify priority of translations in DAL write payloads

Add default cms pages to products and categories

Integrate an app into flow action

Introducing tax providers

Remove static analysis with psalm

Rule condition field abstraction

Integrate an app into the flow event

Add typescript support for storefront javascript

Providing the admin extension SDK

Concept for blogs using Shopping Experiences

Adding the `StorableFlow` instead of the `FlowEvent` for implementing the flow DelayAction in flow builder

Add bootstrap JS-plugin initialization utility to storefront JS

Vue 2.7 update

Mapping of product area

Hide and show CMS content

Deprecation handling during PHPUnit test execution

Test structure

Composer-based web updater

Deprecate the storefront CSRF implementation

Replace drop-shadow with box-shadow

Run Lighthouse tests in E2E env

Atomic theme compilation

Npm packages pre-release versions

Add native lazy loading for images to the storefront

App script product pricing

Deprecate autoloading associations in DAL entity definitions

Flow storer with scalar values

Follow test pyramid

Unstructured ADRs

Native extension system with vue

Admin text editor evaluation

Mocking repositories

Disable the CSS autoprefixer in the Storefront by default

New language inheritance mechanism for opensearch

Jest test files should be JavaScript only

Optimize cart cleanup

Experimental features

Stock Manipulation API

Use PHP 8.1 Enums

Switch to UUIDv7

Exception Log Level configuration

Client side communication to App Server

Default handling for non specified salutations

Flow Builder Preview

Collecting and dispatching entity data

Media path rewrite

Post updater

Add Feature property to `@experimental` annotation

Introduction of Unique Identifiers for Checkout Methods

Make more use of Bootstrap tooling and remove !important from Bootstrap CSS utils

Make feature flags toggleable on demand

New acceptance test suite

Introduce transactional flow actions

Disable Vue compat mode per component level

Implementation of Meteor Component Library

Checkout gateway

Add jest runner with disabled compat mode

Error-code log Level configuration in platform or cloud

Replace Vuex with Pinia

Transition to an Event-Based Extension System

Deprecating Meteor Admin SDK public SDK

Telemetry abstraction layer

Add more unit tests namespaces to FeatureFlag extension

System Health Checks in Shopware

Native Block System in Shopware

Vue 2 Options API to Vue 3 Composition API Conversion Codemod

[A11y] Offer HTML alternative to our pdf standard documents

Remove the asterisk next to every price and replace it with actual text

Make Rule classes internal

Move flow execution after business process

Deprecate Iterator.helper in Storefront JS

Context Gateway

Implement measurement system

Integrating the language pack into platform

Cache layer for navigation loader

Adding a country-agnostic language layer

Caching Strategy for Store API

Co-locate Administration Technical Documentation with Source Code

Pin All NPM Dependencies to Exact Versions

Replace changelog ADR with "Changelog & Release Info Process"

Improved HTTP Cache Layer

Introduce Product Type And Deprecate Product States

Config Reference

Server

Apache

Caddy

Nginx

Security

Guidelines

Code

Core

2023-05-16 - PHP 8.1 & Symfony 6.1 new features

ADR

Introduction

Decorator pattern

Domain exceptions

Extendability

Introduction

Final and internal annotation

Internal

Unit tests

Writing code for static analysis

Contribution Guidelines

Backward Compatibility

Cart Process

Context Rules & Rule Systems

Dependency Injection & Dependency Handling

Document Code

Events

Page Loader

Platform Domains

Public APIs

Routing

Session and State

Store API

Storefront Controller

Troubleshooting

Performance

PHPStan

Elasticsearch

Test

Testing guidelines for extensions

Quality guidelines for apps and themes in the app system

Quality guidelines for apps in the plugin system

Document

Fonts & Formats

Text

Code

General

Methodize Assets

Conceptual Structure

Doc Process

Language & Grammar

Embedding external repositories

Tooling

CLI

Hot Module Reloading using watchers

IDE

Shopware Toolbox

Fixture Bundle

Accessibility

Storefront Accessibility

Accessibility Checklist

Administration Reference

Resources
References

On this page

docsmainResources

Administration Reference

This section covers concepts on Utils, Mixins and Directives.

Ask a question on StackOverflow

Edit this page on GitHub

Pager

Previous pageFlow Action Reference

Was this page helpful?

UnsatisfiedSatisfied

Be the first to vote!

0.0 / 5 (0 votes)

info@shopware.com
00 800 746 7626 0

Product

APIs
SDKs
B2B Suite
Extensions
Headless Storefront

Resources

User Documentation
Design Documentation
E-commerce knowledge
Jump into development
Training & Certification

Community

Forum
Community Day
Stack Overflow
Feedback & Issues

GitHub Channels

Shopware 5
Shopware 6
Development Template
Contribute to the docs
Contribute to platform

News & Updates

Blog
Shopware TV
Announcements
Product Changelog

Newsletter

Copyright © shopware AG - All rights reserved

Terms & Conditions
Privacy policy
Legal notice
Cookie settings