{$description}
+{/block} \ No newline at end of file diff --git a/exampleplugins/5.2/SeoExample/Resources/views/frontend/glossary/index.tpl b/exampleplugins/5.2/SeoExample/Resources/views/frontend/glossary/index.tpl new file mode 100644 index 0000000000..383f993a64 --- /dev/null +++ b/exampleplugins/5.2/SeoExample/Resources/views/frontend/glossary/index.tpl @@ -0,0 +1,12 @@ +{extends file="parent:frontend/index/index.tpl"} + +{block name="frontend_index_content_left"}{/block} + +{block name="frontend_index_content"} + {foreach $words as $wordData} +{$description}
+{/block} \ No newline at end of file diff --git a/exampleplugins/5.2/SeoExample52/Resources/views/frontend/glossary/index.tpl b/exampleplugins/5.2/SeoExample52/Resources/views/frontend/glossary/index.tpl new file mode 100644 index 0000000000..383f993a64 --- /dev/null +++ b/exampleplugins/5.2/SeoExample52/Resources/views/frontend/glossary/index.tpl @@ -0,0 +1,12 @@ +{extends file="parent:frontend/index/index.tpl"} + +{block name="frontend_index_content_left"}{/block} + +{block name="frontend_index_content"} + {foreach $words as $wordData} +
-
-## What is the 99 Papercut Project?
-
-As an open source project, Shopware’s strength is attributed to the feedback and involvement from our vibrant Community. So in honor of this philosophy, we created the project “99 Papercuts” to encourage your direct involvement in making Shopware the best possible eCommerce software for your needs.
-
-In the first phase of the project, we asked for your suggestions on how Shopware could be tweaked and made even better. To make this project a huge success, we need the added manpower from your contributions in this second phase.
-
-## Get involved in making Shopware an even better solution!
-
-
-
-Starting on Monday, 5th September and continuing until Monday, 19th September, we would like to tackle as many papercut bugs as possible, together with developers and coders from our Community.
-
-## How you can contribute:
-
-1. Join our [IRC Channel](/contributing/irc) for direct communication with us and the rest of the community.
-2. Find a papercut that you want to fix from the ) }}){kind=logo}
+ ) }}){kind=logo}
diff --git a/source/blog/_posts/2016-10-06-qa-at-speed.md b/source/blog/_posts/2016-10-06-qa-at-speed.md
index 5bbdc7f2cc..2ea39db3d5 100644
--- a/source/blog/_posts/2016-10-06-qa-at-speed.md
+++ b/source/blog/_posts/2016-10-06-qa-at-speed.md
@@ -9,7 +9,7 @@ little more insight into our quality assurance (QA) process.
As a software company, we try to cover the whole development process in an agile culture, and since the majority of our teams are using Scrum or Kanban, we try to strictly follow the 
+ 
+
+The small controller actions don't respond with the full page dom tree anymore. Each controller is only responsible for a
+specific panel content.
+
+One ouf our targets was also to use most of the already existing dependencies instead of adding new frameworks just for
+the B2B-Suite. We use jQuery because it is a base dependency of Shopware 5.
+
+We decided to develop our own lightweight frontend framework on top of jQuery which allows asynchronous HTTP requests for our frontend.
+The main target of this framework is to execute asynchronous calls and render the response in a given and zoned DOM element by using an event.
+The behaviour is very similar to angular's [zone.js](https://github.com/angular/zone.js).
+
+## Code Example
+The base structure of our ajax panel index action looks like this:
+```html
+
+```
+
+On page load our jQuery ajax panel plugin will search for the class `ajax-panel` and use the data attribute `data-url`.
+If this attribute contains a valid url the jQuery plugin will perform an asynchronous http request on the attribute url.
+If the response is signed with a HTTP Status Code of 200 the response will be rendered back in the original zoned div with the data-id `example`.
+
+## Response Example
+
+The ajax panel controller action responds with the content of the ajax panel element and moves the dom structure inside the given element.
+The response could be like:
+
+```html
+
+
+So how should we test this? Let's discuss some strategies:
+
+## Testing Strategy: Functional testing only
+
+Many projects out there use acceptance tests as their only way of automated testing. So why is it a bad idea? One word: Performance! Functional tests use a real browser to check the application. Even high performance applications have response times of at least 50ms, excluding the JavaScript execution time you are quickly at 500ms or more - for a **single page**. So let's math with an average of 250ms per page:
+
+| Page Loads | Time |
+|-------------|---------|
+| 1 | 250 ms |
+| 5 | 1.25 s |
+| 10 | 2.5 s |
+| 50 | 12.5 s |
+| 100 | 25 s |
+| 400 | 100 s |
+
+Now you have to ask yourself: Do you want to maintain this? Is it useful? Creating an application that has 400 different click paths is quite easy, but waiting 100 seconds to validate every single change is tedious at least and at worst it stops being helpful quickly.
+
+The main advantage is that - at least for settled applications - introducing testing late in a development flow makes this a quick win because usually you have to write the least amount of code for this. And even if the Structure of your source code does not allow to easily introduce testing into every layer, these tests at least tend to solidify the basic functionality. So this is possible by just introducing a single layer on top of your application:
+
+
+
+**Good:**
+
+* Gives you 99% certainty that the application works correctly.
+* Adds minimal code to maintain.
+
+**Bad:**
+
+* Takes a long time even for small applications
+* Does not help developers
+* Does nothing to your application architecture, but add a few css classes
+* Usually very fragile, small changes tend to have an unreasonably big impact (you change a buttons position and the login breaks)
+
+**Verdict:** Run!
+
+## Testing Strategy: The Pyramid
+
+There is a testing pyramid favored by people like Robert C. Martin, it looks like this:
+
+
+
+"A Testing Pyramid that puts the focus on **unit tests** proposes to write a few integration tests and if really necessary few functional test. So for our example application this looks like this:
+
+
+
+So what do we have here? We have a Unit Test for each class of the application. Each dependency is mocked so we can test the code of a single service in absolute isolation. This is the core of your test suite: The unit tests! Now we need to integrate in a few places, I personally would propose that `MyService` and `ContextProvider` should be integrated with their subsidiary services, so we add this:
+
+
+
+These two integration tests that integrate the central services with their storage. Last but not least we have a small functional test for our controller.
+
+
+
+Pyramid successfully implemented!
+
+But this did not work for us. Since we use minimal Integration tests and mock all outputs of the dependencies we quickly found ourselves in a place where the test suite did not produce certain edge cases correctly. Mocks are simply a lie in your system. Let's take a closer look at `MyServiceTest`:
+
+
+
+The Problem is the dependency between the mocks and the actual implementations. Although one can connect them through a *realization* arrow, mocks treat real implementations like interfaces. So if the signature does not change, but the result itself changes over time a mock will not catch this error. And changing the result over time is quite easy:
+
+At first a method might look like this:
+
+```php
+public function isValidResponseCode(int $code): bool
+{
+ return in_array($code, [200, 300]);
+}
+```
+
+And then gets changed to this:
+
+```php
+public function isValidResponseCode(int $code): bool
+{
+ return in_array($code, [200, 300, 202, 303]);
+}
+```
+
+Boom, a mock will never automatically produce this result, but for all means it will keep the test suite green. There are certain other problems with mocks, so... Time for a digression:
+
+----
+
+## Digression: Mocking
+
+All I really can say about mocking is this: it is a pain in the ass! There are currently a few contenders for mocking in PHPUnit tests and they all work internally the same way and are kind of awful. So lets say we have a class called `Something` that has a method called `getResponse` and we want it to return `'foo'` for our test, how would we accomplish this through mocking?
+
+```php
+class Something {
+ public function getResponse(): string {
+ return 'bar';
+ }
+}
+```
+
+#### PHPUnit Mocks
+
+The default for PHPUnit Mocks is to use the built in Mocking Framework. This usually looks like this:
+
+```php
+class SomeTest extends PHPUnit_Framework_TestCase {
+
+ public function test_something()
+ {
+ // create a mock
+ $stub = $this->createMock(Something::class);
+
+ // Configure the mock
+ $stub->method('getResponse')
+ ->willReturn('foo');
+
+ $this->assertEquals('foo', $stub->getResponse());
+ }
+}
+```
+
+Cool? No! Actually there are a few problems with that:
+
+* If you refactor the `getResponse` method no IDE will match this with this string automatically.
+* When you write this you have to remember what the `getResponse` Method was called. The IDE will not help you here.
+* `'foo'` is a totally made up value. As you can see the real implementation is not able to create this value, so why is there a test that checks against impossible values?
+
+#### Prophecy
+
+Prophecy is part of the newer generation of mocking frameworks. It has a two step approach, where you first configure the mock and then create the result. So how would this look like?
+
+```php
+class SomeTest extends PHPUnit_Framework_TestCase {
+
+ public function test_something()
+ {
+ // create a prophet
+ $prophet = $this->prophesize(Something::class);
+
+ // Configure the prophet
+ $prophet->getResponse()
+ ->willReturn('foo');
+
+ // create the mock
+ $stub = $prophet->reveal();
+
+ $this->assertEquals('foo', $stub->getResponse());
+ }
+}
+```
+
+Cool? A little bit cooler at least. It is possible to annotate the real class for prophets, at least. But other then that it has the same issues as `PHPUnit Mocks`.
+
+#### Just use PHP
+
+Of course we can create mocks with the built in features of the language itself. Just like this:
+
+```php
+class SomeTest extends PHPUnit_Framework_TestCase {
+
+ public function test_something()
+ {
+ // create a prophet
+ $stub = new class extends Something {
+ public function getResponse(): string {
+ return 'foo';
+ }
+ };
+
+ $this->assertEquals('foo', $stub->getResponse());
+ }
+}
+```
+
+Although this is by far my favorite approach because the IDE can help you best with this approach, it still is messy.
+
+**It is impossible to get `foo` as a return value from the tested method** This means that tests with Mocks tend to use made up values that can diverge quite heavily from real data.
+
+----
+
+So how did the pyramid fair for us?
+
+**Good:**
+
+* Helps during development, creates entry points for every possible error
+* Always fast to execute
+* Creates extremely well designed classes
+
+**Bad:**
+
+* Almost doubles the amount of code in your project
+* Mocks need to be changed in sync with their loosely coupled subjects
+* Produces false positives
+* Creates sometimes awkward to integrate classes
+
+**Verdict:** Can be better...
+
+## Testing Strategy: The Diamond
+
+There is a third strategy, that puts all the effort into Integration tests. This looks something like that:
+
+
+
+I have color coded the application diagram to show you how we interpreted the diamond:
+
+* **Green:** No dependencies, a test becomes automatically a **unit test**
+* **Yellow:** Has dependencies (either on other classes, or on infrastructure) must be an **integration test**
+* **Blue:** Is front facing so it must be a **functional test**
+
+
+
+By applying this simple ruleset we still have a one to one parity of test classes to production classes. This means that for each bug or feature there is an easy entry point in our test suite. And the test suite is therefore useful for developers and gets actively supported. If bugs are introduced during development there is usually a test that shows it immediately. If a contract between objects is changed this change is immediately available in the suite and in many cases even leads to a failing test. (depending on the test quality: see [Mutation Testing by my colleague Thomas Eiling](https://developers.shopware.com/blog/2017/08/24/mutation-testing/)).
+
+So now let's take a look at our `MyServiceTest` the way it looks like in integration testing:
+
+
+
+This test still covers all n-paths of the class `MyService`! It covers most paths in it's directly dependant classes `MyRepository` and `ValidationService` and covers a few paths in their dependencies, and so on. You can imagine this like different saturations of a color:
+
+
+
+Now we no longer make up the output of any subsidiary service. We even noticed that using the real storage has virtually no impact on the test performance, but creates a huge benefit by testing the friction between these different services in our test suite at all times [(see factor X)](https://12factor.net/dev-prod-parity).
+
+The big picture then looks like this:
+
+
+
+The mocks in this case come from a specially set up database and this is the only real downside to this approach. Your fixtures may diverge from a production setting! We have seen this in the past and usually got real bugs from this. But even in these cases the problem arose from a single point of failure which is far better then mocking in every single place.
+
+**Good:**
+
+* Helps during development, creates entry points for every possible error
+* Almost as fast as unit tests
+* The real data is used
+* Creates an architecture of well integrated parts
+
+**Bad:**
+
+* Almost doubles the amount of code in your project
+* Fixture data will never show 100% production state
+* Will also not give you a 100% certainty that everything works
+
+**Verdict:** We use it!
+
+## A word on TDD
+
+I personally am a huge fan of TDD and practice it almost always when developing or exploring software. This practice is not lost here. Just because you have to implement stuff that you are using does not reduce the amount of freedom you have in the 30 second cycle of test driven development. On the contrary - at least for me - it tends to create more realistic assumptions on the scope of classes. By doing almost only integration testing all my tests look and feel the same. The usual friction that occurs when combining multiple unit tested classes is by far reduced because the integration assumptions all - by definition - hold up against the real implementations.
+
+## Conclusion
+
+The Diamond seems to be the best solution to the testing strategy problem. In fact we have been and still are developing the B2B-Suite with that strategy in mind and have seen quite good results with it. Currently our complete suite takes around 3 minutes to execute which is still passable for a quick overview. None of our tests depend on its predecessor and can all be executed in isolation (which makes Mutation testing possible in the first place), so during development we usually single out a few tests to run repeatedly.
+
+The issue of software architecture comes a little short in this blog post, let me tell you why: It is a problem where tests only are a part of the solution! As you could read in a [previous post I published](https://developers.shopware.com/blog/2016/12/05/large-scale-plugin-architecture/) where I used the actor model to create a plugin architecture there are numerous ways that need to be taken into account when creating a sustainable system architecture. Testing will help you a lot with *friction* and *cohesion* (as introduced by Robert C. Martin) but not help you derive a greater truth from this. This is a place where [DDD](https://en.wikipedia.org/wiki/Domain-driven_design) seems to provide the better tools.
+
+So all in all, at least to us this is the best overall approach to develop stable software, with the least tradeoffs and the most benefits. Thanks for reading and as always feel free to get in touch and discuss with me!
diff --git a/source/blog/_posts/2018-01-09-exclusive-enterprise-dev-training.md b/source/blog/_posts/2018-01-09-exclusive-enterprise-dev-training.md
new file mode 100644
index 0000000000..c53e2f6e09
--- /dev/null
+++ b/source/blog/_posts/2018-01-09-exclusive-enterprise-dev-training.md
@@ -0,0 +1,70 @@
+---
+title: Exclusive Enterprise Developer Training
+tags:
+- b2b-suite
+- enterprise
+- training
+
+categories:
+- dev
+
+authors: [nd]
+github_link: blog/_posts/2018-01-09-exclusive-enterprise-dev-training.md
+
+---
+
+
+
+# Exclusive Enterprise Developer Training - Only five places remaining
+
+In this one-day workshop, you will get insight into the technology behind Shopware Enterprise, namely the Shopware Accelerator “B2B Suite”. Led by the developers who created the software itself, you will learn everything about this key feature, including practical application. This training is designed for experienced developers who already have the “Shopware Certified Developer” certificate.
+
+## Info:
+
+### Date
+February 23, 2018
+
+### Time
+Check-in: From 8:30 am
+
+Start: 9 am
+
+End: 5 pm
+
+### Location:
+shopware AG
+
+Ebbinghoff 10
+
+48624 Schöppingen
+
+Germany
+
+### Fee:
+795 Euro per person
+
+## Registration
+Please send an email to sales@shopware.com
+
+## What you can expect
+- Training held in English
+- Intro to the Enterprise architecture
+- Working with the B2B Suite
+- Intro to the order management
+- Intro to the user management
+- Extending the UI
+
+## Target group
+- Experienced PHP developers
+- max. 5 participants
+
+## Requirements
+- Basic knowledge of Doctrine
+- Basic knowledge of Smarty
+- Basic Knowledge of ExtJS
+
+## Services
+- One-day training
+- Fully equipped computer
+- catering
+
diff --git a/source/blog/_posts/2018-01-11-mutation-testing-with-infection.md b/source/blog/_posts/2018-01-11-mutation-testing-with-infection.md
new file mode 100644
index 0000000000..1d33951ab0
--- /dev/null
+++ b/source/blog/_posts/2018-01-11-mutation-testing-with-infection.md
@@ -0,0 +1,374 @@
+---
+title: Mutation Testing with Infection
+tags:
+- phpunit
+- infection
+- testing
+
+categories:
+- dev
+
+authors: [tn]
+github_link: blog/_posts/2018-01-11-mutation-testing-with-infection.md
+
+---
+
+
+
+###### Association rule generation framework for a B2C website (Suchacka & Chodak, 2017)
+
+
+###### Histogram of session lengths for buying sessions for innovative and traditional customers (Suchacka & Chodak, 2017)
+
-
-This will create a "copy" of the entire Shopware repository into your personal user namespace.
-
-## Clone your fork to your local machine
-
-After the "forking action" has completed, clone your fork locally (this will create a `shopware` directory):
-
-```git clone git@github.com:USERNAME/shopware.git```
-
-Add the shopware repository as `upstream` remote:
-
-```cd shopware```
-
-```git remote add upstream https://github.com/shopware/shopware.git```
-
-Verify the new remote named `upstream`:
-
-```git remote -v```
-
-```origin git@github.com:USERNAME/shopware.git (fetch)```
-
-```origin git@github.com:USERNAME/shopware.git (push)```
-
-```upstream https://github.com/shopware/shopware.git (fetch)```
-
-```upstream https://github.com/shopware/shopware.git (push)```
-
-Now that you have the shopware source code locally on your machine please follow the [Git Installation Instructions](https://github.com/shopware/shopware#installation-via-git).
-
-## Create a new Feature branch
-
-Each time you want to work on a patch, create a feature branch:
-
-```git fetch upstream```
-
-```git checkout -b my-new-feature upstream/5.2```
-
-The first command will fetch the latest updates from the upstream project (shopware).
-The second will create a new branch named `my-new-feature`, that is based off the `5.2`-branch of the `upstream` remote.
-
-## Submit your pull request
-
-Push your branch to your github fork:
-
-```git push origin my-new-feature```
-
-## Create a Pull Request on Github
-Navigate back to the [Shopware Github Repository](https://github.com/shopware/shopware) and click the **"Compare & pull request"-Button**.
-
-
-
-Before creating your pull request make sure that it fits our [contribution guideline](/contributing/contribution-guideline/).
-
-### How to create a Pull Request
-
-- [https://git-scm.com/book](https://git-scm.com/book)
-- [https://try.github.io](https://try.github.io)
\ No newline at end of file
diff --git a/source/contributing/contribution-guideline/index.md b/source/contributing/contribution-guideline/index.md
deleted file mode 100644
index fa50573bc2..0000000000
--- a/source/contributing/contribution-guideline/index.md
+++ /dev/null
@@ -1,111 +0,0 @@
----
-layout: default
-title: Contribution Guideline
-github_link: contributing/contribution-guideline/index.md
-indexed: true
-tags: [pullrequest, github, guideline, contribute, git, pull-request, fork]
-menu_title: Contribution Guideline
-menu_order: 20
-group: Contributing
----
-
-
-
-## Introduction
-First of all, thank you! You have decided to contribute code to our software and become a member of the large shopware community. We appreciate your hard work and want to handle it with the most possible respect.
-
-To ensure the quality of our code and our products we have created a small guideline we all should endorse to. It helps you and us to collaborate with our software. Following these guidelines will help us to integrate your changes in our daily workflow.
-
-## Requirements for a successful pull request
-To avoid that your pull request gets rejected, you should always check that you provided all necessary information, so that we can integrate your changes in our internal workflow very easily. Here is a check-list with some requirements you should always consider when committing new changes.
-
-- Did you fill out the [pull request info template](https://github.com/shopware/shopware/blob/5.2/.github/PULL_REQUEST_TEMPLATE.md) as detailed as possible?
-- Do you made entries in the correct `Upgrade.md` file with a small documentation of your changes?
-- Does your pull request address the correct shopware version? Breaks and features cannot be merged in a patch release.
-- Is your implementation missing some important parts? For example translations, downward compatibility, compatibility to important plugins, etc.
-- Did you provide the necessary tests for your implementation?
-- Is there already an existing pull request tackling the same issue?
-
-Pull requests which do not fulfill these requirements will never be accepted by our team. To avoid that your changes go through unnecessary workflow cycles make sure to check this list with every pull request.
-
-## The developing workflow on GitHub
-When you create a new pull request on GitHub normally it will get a first sight within a week. We do regular meetings to screen all new pull requests on GitHub. In this meeting there is a team of up to five shopware developers of different specialisations which will discuss your changes. Together we decide what will happen next to your pull request. We will set one of the following labels which indicate the status of the pull request. Here is a list of all possible states.
-
-
- 
- 
- 
- 
- 
- 
- 
+
```
-If you don't want to display the default shop logo you can simply replace the path with a path to your desired image. In this example we copied our new logo into the `frontend/_public/src/img/logos/` directory of our `NewsDocExample` theme:
+If you don't want to display the default shop logo you can simply replace the path with a path to your desired image.
+In this example we copied our new logo into the `frontend/_public/src/img/logos/` directory of our `NewsDocExample` theme:
```html
@@ -71,7 +81,9 @@ If you don't want to display the default shop logo you can simply replace the pa
### Change the newsletter headline
-In this example we will change the color of the **newsletter headline (2)** in the right top corner. To change the color you can also edit your copied `header.tpl` file from the logo example. You can find the desired code in line 7:
+In this example we will change the color of the **newsletter headline (2)** in the right top corner.
+To change the color you can also edit your copied `header.tpl` file from the logo example.
+You can find the desired code in line 7:
```html
-
-
+
+In case of a plugin, use the following code:
+```
+/** @var CrudService $crud */
+$crud = $this->container->get('shopware_attribute.crud_service');
+
+$crud->update('s_user_attributes', 'recommendedVariants', 'multi_selection', [
+ 'displayInBackend' => true,
+ 'label' => 'Recommended variants',
+ 'entity' => 'Shopware\Models\Article\Detail',
+]);
+$crud->update('s_user_attributes', 'recommendedStream', 'single_selection', [
+ 'displayInBackend' => true,
+ 'label' => 'Recommended stream',
+ 'entity' => 'Shopware\Models\ProductStream\ProductStream',
+]);
+```
+
+To display the data in the account section, add the following source code to a template which extends the `frontend/account/index.tpl`:
+
+```
+{extends file="parent:frontend/account/index.tpl"}
+{block name="frontend_account_index_welcome"}
+ {$smarty.block.parent}
+
+ {$data = $sUserData.additional.user}
+
+ 
-
### Example #1: Simple extension
+
+
In this example, an extension for Shopware's default customer module is implemented. First of all, an existing free
-text field should be changed to only allow entering numbers.
+text field should be changed ComboBox with preset titles.
In order to do so, we need to know where the original text field is created. This happens in
-`themes/Backend/ExtJs/backend/customer/view/detail/billing.js` in the method `createBillingFormRight`. This method
-will return all fields for the right side of the billing info overview. In order to modify this method, we subscribe to
-the `PostDispatchSecure` event of the customer controller:
-
+`themes/Backend/ExtJs/backend/customer/view/detail/window.js` in the method `createPersonalFieldSet`. This method
+will return all fields for the right side of the billing info overview as a FieldSet. In order to modify this method, we subscribe to
+the `PostDispatchSecure` event of the customer controller in the service.xml:
+
+```xml
+
+### Example #2: Custom components
-### Example #2: Custom components
+
-After registering the element and creating all the configuration fields we already see a full functional shopping world element in the backend module which can be placed on the design canvas. All we have to do now is to provide a frontend template to define the layout in the store. In the `Views` directory of our plugin we create the necessary directory structure to the file. Template files for shopping world elements can automatically be added by creating the hierarchy structure in the special directory called `emotion_components`. The full path to the template file would be `Views/emotion_components/widgets/emotion/components/{name}.tpl`.
+
+After registering the element and creating all the configuration fields we already see a full functional shopping world element in the backend module which can be placed on the design canvas. All we have to do now is to provide a frontend template to define the layout in the store. In the `Resources/views` directory of our plugin we create the necessary directory structure to the file. Template files for shopping world elements can automatically be added by creating the hierarchy structure in the special directory called `emotion_components`. The full path to the template file would be `Resources/views/emotion_components/widgets/emotion/components/{name}.tpl`.
-The name of the file has to match the definition in your `createEmotionComponent()` method. You can access your configuration fields inside the template file as properties of the `$Data` smarty variable. Let's create the embed code for displaying the Vimeo video.
+The name of the file has to match the definition in the `createOrUpdate()` method. You can access your configuration fields inside the template file as properties of the `$Data` smarty variable. Let's create the embed code for displaying the Vimeo video.
```
{block name="widgets_emotion_components_vimeo_element"}
@@ -400,47 +405,272 @@ The name of the file has to match the definition in your `createEmotionComponent
{/block}
```
+To load your template you have to register the emotion component view subscriber in your dependency injection container. This subscriber registers all necessary view paths for your frontend template and custom components.
+
+```xml
+
+Since Shopware 5.3 it is possible to export and import shopping worlds including all settings and
+assets. Shopware delivers component handlers for all standard shopping world elements which use assets.
+
+Due to the fact every element is storing its assets slightly different, it is required
+to have component handlers which "know" their component and know where to extract assets from and where to put back data on import.
+
+The component handlers are using a special service tag to be registered by the `PresetDataSynchronizer` Service which is used to prepare the export and
+process the import for single elements.
+
+```xml
+
If you want to go a little further by creating custom configuration fields for your element you have the possibility to create your own ExtJS component for the element. Here you have full access to the configuration form in ExtJS. You can manipulate existing fields or add new fields which are more complex than the standard form elements.
-The file for the component is also located in the `emotion_components` directory, so it will be detected automatically. The complete path to the file is `Views/emotion_components/backend/{name}.js`.
+The file for the component is also located in the `emotion_components` directory. The complete path to the file is `Resources/views/emotion_components/backend/{name}.js`.
For the Vimeo example we use the custom ExtJS component to make a call to the Vimeo api for receiving information about the preview image of the video and save it in the hidden input we already created via the helper functions.
+First of all you have to define a xtype in the createEmotionComponent() method for your element.
+
+```php
+$vimeoElement = $this->emotionComponentInstaller->createOrUpdate(
+ $this->pluginName,
+ 'SwagVimeoElement',
+ [
+ 'xtype' => 'emotion-components-vimeo',
+ // the config of your component
+ ]
+);
```
+
+Now we can implement the custom javascript.
+
+```js
//{block name="emotion_components/backend/vimeo_video"}
Ext.define('Shopware.apps.Emotion.view.components.VimeoVideo', {
@@ -448,6 +678,13 @@ Ext.define('Shopware.apps.Emotion.view.components.VimeoVideo', {
alias: 'widget.emotion-components-vimeo',
+ snippets: {
+ 'vimeo_interface_color': {
+ 'fieldLabel': '{s name=interfaceColorFieldLabel}{/s}',
+ 'supportText': '{s name=interfaceColorSupportText}{/s}'
+ }
+ },
+
initComponent: function () {
var me = this;
@@ -497,32 +734,64 @@ The component always has to extend the base class `Shopware.apps.Emotion.view.co
In the component you can get access to the fields which you already created by using the `findField()` method on the `form` object which can be received by `this.getForm()`.
+If you want to translate the field label, support and help texts, just add the property `snippets`. Using the name which which was set in the emotion component installer, define every input field which you want to translate.
+
## Advanced: Adding a custom designer component in ExtJS ##
Since Shopware 5.2 you are able to create a custom ExtJS component for the designer elements. Here you have the possibility to add an icon and a preview template for the element, which gets shown in the grid of the designer.
For extending the designer components we have to do a classic template extension of the backend files. So we create a new file in the necessary template hierarchy `Views/backend/emotion/{pluginName}/view/detail/elements`.
-Otherwise than the custom emotion component we have to register the template manually by extending the template inheritance system with our new file. We can subscribe to the `PostDispatch` event of the emotion module in the `install()` method of our plugin to do so.
-
+Otherwise than the custom emotion component we have to register the template manually by extending the template inheritance system with our new file. We can subscribe to the `PostDispatch` event of the emotion module.
+```xml
+
+ 
+
In this article we'll be focusing on the important parts to get started with the development of custom digital publishing elements.
If you want to get more information about developing plugins for Shopware in general, please head over to the [plugin quick start guide](/developers-guide/plugin-quick-start).
@@ -34,107 +34,173 @@ To add a new element to the Digital Publishing module we will need the following
- **Frontend template**
## Registering the subscriber
-First we register a new **subscriber** and the plugin namespace in the `Bootstrap.php` of our plugin.
-
-```php
-public function install()
-{
- $this->subscribeEvent('Enlight_Controller_Front_StartDispatch', 'registerSubscriber');
- $this->subscribeEvent('Shopware_Console_Add_Command', 'registerSubscriber');
-
- return true;
-}
-
-public function registerPluginNamespace()
-{
- $this->Application()->Loader()->registerNamespace(
- 'Shopware\SwagDigitalPublishingSample',
- $this->Path()
- );
-}
-
-public function registerSubscriber()
-{
- $this->registerPluginNamespace();
-
- $subscribers = array(
- new Resources($this)
- );
-
- foreach ($subscribers as $subscriber) {
- $this->Application()->Events()->addSubscriber($subscriber);
- }
-}
+First we register new **subscribers** in the `service.xml` of our plugin.
+
+```xml
+
+- `onPostDispatchWidget`: Adds the *Views* directory, so we can automatically extend the templates of the storefront.
+
+
In the next step, we will look at the first event, which subscribes to the post dispatch of the backend. With it, we can extend the backend with our ExtJS template files in the `onPostDispatchBackend` callback. To add a new element to the Digital Publishing module, we have to extend the original `container.js` of the editor with our own `extension.js` file. All files should go in the `Views` directory of our plugin, in `backend/swag_digital_publishing_sample/view/editor`. We also create the custom handler for our element in the `elements` subdirectory called `youtube_element_handler.js`. These files are added to the backend template by the `extendsTemplate()` method.
## Creating the backend handler
-Now that we extended the backend template and created the necessary ExtJS files, we can write some code. Let's start with the custom handler for our element: `Views/backend/swag_digital_publishing_sample/view/editor/elements/youtube_element_handler.js`
+Now that we extended the backend template and created the necessary ExtJS files, we can write some code. Let's start with the custom handler for our element: `Resources/views/backend/swag_digital_publishing_sample/view/editor/elements/youtube_element_handler.js`
```
//{block name="backend/swag_digital_publishing/view/editor/abstract_element_handler"}
@@ -161,7 +227,7 @@ To extend the backend template, we're editing the Smarty `{block}` of the abstra
- `iconCls`: the CSS class for the element icon
- `createFormItems()`: the method which returns the configuration fields for this element
-Now that we have created the handler, we have to add it to the list of available element handlers. Therefore, we created the `extension.js` to extend the original editor: `Views/backend/swag_digital_publishing_sample/view/editor/extension.js`
+Now that we have created the handler, we have to add it to the list of available element handlers. Therefore, we created the `extension.js` to extend the original editor: `Resources/views/backend/swag_digital_publishing_sample/view/editor/extension.js`
```
//{block name="backend/swag_digital_publishing/view/editor/container"}
@@ -285,7 +351,7 @@ We already implemented the functionality to translate the fields of an element i
## Creating the frontend template ##
-Now that we have a fully functional element, we want to add the frontend template. In the subscriber we already added the `Views/` directory of our plugin via the `onPostDispatchFrontend` callback, so we can directly add a new template file. All element templates are located in the `widgets/swag_digital_publishing/components/` directory. We create the same structure for our custom element and create the corresponding template file `youtube.tpl`. It is important that the file has exactly the same name as we defined it in the ExtJS handler. The template will then be loaded automatically for our element.
+Now that we have a fully functional element, we want to add the frontend template. In the subscriber we already added the `Resources/views/` directory of our plugin via the `onPostDispatchWidget` callback, so we can directly add a new template file. All element templates are located in the `widgets/swag_digital_publishing/components/` directory. We create the same structure for our custom element and create the corresponding template file `youtube.tpl`. It is important that the file has exactly the same name as we defined it in the ExtJS handler. The template will then be loaded automatically for our element.
```
+
+## Introduction
+With __Shopware 5.3__ we introduced shopping world / emotion presets. This tutorial will point out how to create a custom emotion preset plugin to offer your created shopping worlds to other users. These kind of plugins
+can be contributed to the Community Store like any other plugin. You just have to set a special flag in your Account settings for deployment, so that your plugin gets marked as emotion preset.
+
+### Qualification
+Before getting started with this tutorial, it is recommended to become familiar with creating Shopware plugins first, since this guide will only point out the extras for creating a __custom emotion preset plugin__. For further information on developing plugins see [our plugin guides](/plugin-guide).
+
+## Plugin Structure
+The structure of the example plugin is as follows:
+
+
+
+The example plugin is based on the Shopware 5.2 plugin system.
+
+## Creating Preset Data
+Creating preset data is really simple, because you can easily use the backend export function for shopping worlds. This function will
+prepare your shopping worlds data as needed for a plugin. It will extract all assets from the shopping worlds and save all settings and data in the preset `*.json` file.
+
+### Create simple dataclasses for better maintainability
+As you can see in the example plugin, which you can find at the end of this article, we created a simple class for our preset which implements the `Shopware\Components\Emotion\Preset\PresetMetaDataInterface`. This interface is
+required for the preset import during plugin installation.
+
+We have some simple getters here that are required to be implemented. With this getters all information
+of your preset will be collected during installation.
+
+The `getPresetData()` method uses a simple helper class that gets the json data from our export and replaces a path placeholder `__ASSETPATH__` we are using
+with the actual path to the assets inside our plugin.
+
+```php
+/**
+ * @return array
+ */
+public function getPresetData()
+{
+ $json = SwagEmotionPresetExample::getJsonData('MyCustomPreset.json');
+ return json_decode($json, true);
+}
+```
+
+The exported `json` data will have all information about the assets that are exported.
+
+```json
+"syncData": {
+ "assets": {
+ "8b16ebc056e613024c057be590b542eb": "file:\/\/___ASSETPATH___\/media\/MyCustomPreset\/beach_teaser5038874e87338.jpg",
+ "1728efbda81692282ba642aafd57be3a": "file:\/\/___ASSETPATH___\/media\/MyCustomPreset\/deli_teaser503886c2336e3.jpg",
+ "db85e2590b6109813dafa101ceb2faeb": "file:\/\/___ASSETPATH___\/media\/MyCustomPreset\/flip_teaser503886e4dd480.jpg",
+ "99c5e07b4d5de9d18c350cdf64c5aa3d": "file:\/\/___ASSETPATH___\/media\/MyCustomPreset\/bienen_teaser.jpg",
+ "e995f98d56967d946471af29d7bf99f1": "file:\/\/___ASSETPATH___\/media\/MyCustomPreset\/beach1503f8532d4648.jpg",
+ "6cd67d9b6f0150c77bda2eda01ae484c": "file:\/\/___ASSETPATH___\/media\/MyCustomPreset\/beach2503f8535275aa.jpg",
+ "6bc24fc1ab650b25b4114e93a98f1eba": "file:\/\/___ASSETPATH___\/media\/MyCustomPreset\/beach3503f853820fa7.jpg"
+ }
+ }
+```
+Here we changed the paths from `images\imagename.png` to `file://__ASSETPATH__/media/PRESETNAME/IMAGENAME.png`. Be aware that
+the slashes have to be escaped because otherwise we would have illegal json data.
+
+We advise you to use an external source for image data because of the size limitation for plugins in our Community Store.
+
+## Installation
+For the installation of your presets during plugin installation you can use the `PresetInstaller` service which is available via the service container. The following example shows how installation and
+uninstallation are done by the example plugin.
+
+```php
+public function install(InstallContext $context)
+{
+ /** @var PresetInstaller $presetInstallerService */
+ $presetInstallerService = $this->container->get('shopware.emotion.preset_installer');
+
+ $presetInstallerService->installOrUpdate($this->getPresetInstances());
+}
+
+public function uninstall(UninstallContext $context)
+{
+ /** @var PresetInstaller $presetInstallerService */
+ $presetInstallerService = $this->container->get('shopware.emotion.preset_installer');
+
+ $presetInstallerService->uninstall([
+ 'my_custom_preset',
+ ]);
+}
+
+/**
+ * @return PresetMetaDataInterface[]
+ */
+private function getPresetInstances()
+{
+ return [
+ new MyCustomPreset()
+ ];
+}
+```
+
+During installation we pass an array of `PresetMetaDataInterfaces` to the `PresetInstaller`.
+
+For uninstallation we just use the __technical__ name of our emotion preset.
+
+## Download
+The example plugin can be found 
-## Options Parameter
-The options parameter of the `setElement` function allows to set several configurations on the form element.
-
### Label
-The label parameter allows to create a simple descriptional label for the form element.
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('text', 'simpleTextField',
- array('label' => 'Text')
- );
-}
+The label tag allows to create a simple descriptional label for the form element.
+```xml
+
+
```
-### Value
-The value parameter stands for the default value of the field if this hasn´t been edited yet. It will directly be shown in the configuration element.
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('text', 'simpleTextField',
- array(
- 'label' => 'Text',
- 'value' => 'Vorauswahl'
- )
- );
-}
+### Description
+The description tag allows to provide a more detailed description of the configuration element.
+
+```xml
+
+
-### Scope
-With help of the scope parameter it is possible to generate subshop specific configurations. Leaving this option out results in a configuration option
-that applies for all subshops.
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('text', 'simpleTextField',
- array(
- 'label' => 'Text',
- 'value' => 'Vorauswahl',
- 'scope' => Shopware\Models\Config\Element::SCOPE_SHOP
- )
- );
-}
+### Value
+The value tag stands for the default value of the field if this hasn´t been edited yet. It will directly be shown in the configuration element.
+```xml
+
-
-You can read more on subshop specific configuration at the end of this article reading the [Subshop specific configuration](#subshop-specific-plugin-configur) part.
+
+### Scope
+With help of the scope attribute it is possible to generate subshop specific configurations. Leaving this option out results in a configuration option
+that applies for all subshops.
+```xml
+ 
+
+### Colorpicker
+```xml
+
### Datefield
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('date', 'myDatefield',
- array(
- 'label' => 'Date',
- 'value' => NULL
- )
- );
-}
+```xml
+
### Datetime field
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('datetime', 'myDatetimefield',
- array(
- 'label' => 'Date-Time',
- 'value' => NULL
- )
- );
-}
+```xml
+
### HTML editor
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('html', 'myHtmlfield',
- array(
- 'label' => 'HTML',
- 'value' => NULL
- )
- );
-}
+```xml
+
### Time interval
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('interval', 'myIntervalfield',
- array(
- 'label' => 'Interval',
- 'value' => NULL
- )
- );
-}
+```xml
+
### Mediaselection
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('mediaselection','myMediaselectionfield',
- array(
- 'label' => 'Media',
- 'value' => NULL
- )
- );
-}
+```xml
+
### Numberfield
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('number', 'myNumberfield',
- array(
- 'label' => 'Number',
- 'minValue' => 0
- )
- );
-}
+```xml
+
### Selectionfield / remote combobox
+```xml
+
-### Textfield
+### Multi selectionfield / multi combobox / multi remote combobox
+
+To make your selectfield / combobox multiple selectable, you need to create the options node:
+
+```xml
+
### Textarea
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('textarea', 'myTextareafield',
- array(
- 'label' => 'Text-Area',
- 'value' => NULL
- )
- );
-}
+```xml
+
### Timefield
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('time', 'myTimefield',
- array(
- 'label' => 'Time',
- 'value' => NULL
- )
- );
-}
+```xml
+
-## Configure basic settings
-The plugin configurations of the various plugins are automatically
-reachable via the basic settings under the "Additional settings" entry:
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('text', 'simpleTextField',
- array(
- 'label' => 'Text',
- 'value' => 'Vorauswahl',
- 'scope' => Shopware\Models\Config\Element::SCOPE_SHOP,
- 'description' => 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut',
- 'required' => true
- )
- );
-}
-```
-
-
-
-If you think they are better off under another entry, you can move your configuration entry to another submenu in the settings:
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('text', 'simpleTextField',
- array(
- 'label' => 'Text',
- 'value' => 'Vorauswahl',
- 'scope' => Shopware\Models\Config\Element::SCOPE_SHOP,
- 'description' => 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr.',
- 'required' => true
- )
- );
-
- $repository = Shopware()->Models()->getRepository('Shopware\Models\Config\Form');
- $form->setParent(
- $repository->findOneBy(array('name' => 'Interface'))
- );
-}
-```
-
-
-
-## Translation of configurations
-The Shopware backend is fully translatable. To translate the custom plugin configurations you can use following code:
-```
-public function createConfiguration()
-{
- $form = $this->Form();
-
- $form->setElement('text', 'simpleTextField',
- array(
- 'label' => 'Text',
- 'value' => 'Vorauswahl',
- 'scope' => Shopware\Models\Config\Element::SCOPE_SHOP,
- 'description' => 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr.',
- 'required' => true
- )
- );
-
- //contains all translations
- $translations = array(
- 'en_GB' => array(
- 'myTextField' => 'Text input',
- ),
- 'es_ES' => array(
- 'myTextField' => 'introducción de texto',
- ),
- 'fr_FR' => array(
- 'myTextField' => 'La saisie de texte',
- ),
- //...
- );
-
- $this->addFormTranslations($translations);
-}
-```
-It is also possible to create translated options for the selection element like this:
-```
- /**
- * Creates the plugin configuration
- */
- private function createPluginConfig()
- {
- $store = [
- ['normal', ['de_DE' => 'Nicht anders darstellen', 'en_GB' => "Don't change displaying"]],
- ['pseudo', ['de_DE' => 'Alten Preis als neuen Pseudopreis setzen', 'en_GB' => 'Set old price as new pseudo price']],
- ['price', ['de_DE' => 'Nur neuen Preis hervorheben', 'en_GB' => 'Only highlight new price']]
- ];
-
- $form = $this->Form();
- $form->setElement(
- 'select',
- 'promotionPriceDisplaying',
- [
- 'label' => 'Preisdarstellung',
- 'description' => 'Durch bestimmte Promotions kann sich der Preise eines Aritkels ändern. Hier können Sie definieren, wie der Preis auf der Detailseite dargestellt werden soll.',
- 'store' => $store,
- 'value' => 'normal',
- 'scope' => Element::SCOPE_SHOP,
- ]
- );
-
- $translation = [
- 'en_GB' => [
- 'promotionPriceDisplaying' => [
- 'label' => 'Price displaying',
- 'description' => 'The price of a product could be changed by particular promotions. Define here, how the price should be displayed on the detail page.'
- ]
- ]
- ];
-
- $this->addFormTranslations($translation);
- }
+### Button
+```xml
+
-
-
-Let´s have a look what we did here:
-```
-$form = $this->Form();
-$form->setElement('text', 'simpleTextField',
- array(
- 'label' => 'Text',
- 'value' => 'Vorauswahl',
- 'scope' => Shopware\Models\Config\Element::SCOPE_SHOP,
- 'description' => 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr',
- 'required' => true
- )
-);
-```
-We created a new configuration textfield. Now we define our translations. We create an array with all the translations as key values inside:
-```
-//contains all translations
-$translations = array(
- 'en_GB' => array(
- 'myTextField' => 'Text input',
- ),
- 'es_ES' => array(
- 'myTextField' => 'introducción de texto',
- ),
- 'fr_FR' => array(
- 'myTextField' => 'La saisie de texte',
- ),
- //...
-);
+## Configure basic settings
+The plugin configurations of the various plugins are automatically
+reachable via the basic settings under the "Additional settings" entry:
+```xml
+
+
+
+
+
+### Filter for B2B account
+
+After activating a customer as debtor or sales representative these customers can be filtered in the backend of Shopware 5.3.0 and newer.
+
+
+
+### Login
+
+After your account was activated you can login to your account directly from the frontend account page.
+Direct Link: `my-shop.de/account`
+
+
+
+### Remove debitor
+
+Removing a debitor will remove all related data, including contacts, budgets, contingents, roles and the additional order data.
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/addresses.md b/source/shopware-enterprise/b2b-suite/component-guide/addresses.md
new file mode 100644
index 0000000000..79364b0eaa
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/addresses.md
@@ -0,0 +1,36 @@
+---
+layout: default
+title: Addresses
+github_link: shopware-enterprise/b2b-suite/component-guide/addresses.md
+indexed: true
+menu_title: Addresses
+menu_order: 5
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+This component is managed in the company module, direct link to the company module: `my-shop.de/b2bcompany`.
+
+There are two different types of addresses:
+* Billing addresses
+* Shipping addresses
+
+
+
+### Add and edit an address
+New addresses can be created by using the *Create address* button.
+In the form you can decide between billing and shipping address.
+All required fields are marked with a star.
+
+To edit an existing address you can click on the whole row to load the edit form.
+
+
+
+### Address Deletions
+To remove addresses you can use the trash button to delete the address which is no longer required.
+
+### Default Addresses
+The default addresses of the debtor are not showing in the company listing normally.
+They have to be assigned by the debtor in the role details view.
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/alternative-listing-view.md b/source/shopware-enterprise/b2b-suite/component-guide/alternative-listing-view.md
new file mode 100644
index 0000000000..e3c794a321
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/alternative-listing-view.md
@@ -0,0 +1,24 @@
+---
+layout: default
+title: Alternative Listing View
+github_link: shopware-enterprise/b2b-suite/component-guide/alternative-listing-view.md
+indexed: true
+menu_title: Alternative Listing View
+menu_order: 14
+menu_chapter: true
+group: B2B-Suite
+subgroup: Component Guide
+---
+
+The alternative listing view can be activated with the button in the left of the sorting field. This view is reduced on
+the basic product information like ordernumber, name, price and quantity you want to buy. So it is possible
+to add directly one or more products in your cart or to a selected order list.
+
+### Alternative View on Category Page
+
+
+
+### Alternative View on Search Result Page
+
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/budgets.md b/source/shopware-enterprise/b2b-suite/component-guide/budgets.md
new file mode 100644
index 0000000000..65e48fab4f
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/budgets.md
@@ -0,0 +1,31 @@
+---
+layout: default
+title: Budgets
+github_link: shopware-enterprise/b2b-suite/component-guide/budgets.md
+indexed: true
+menu_title: Budgets
+menu_order: 7
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+This component is managed in the company module, direct link to the company module: `my-shop.de/b2bcompany`.
+
+The budget module allows to manage your budgets. Budgets are used to define the amount users and roles can spend in a fiscal year.
+
+#### Feature Overview
+* Create / Edit / Delete budgets
+* Edit master data
+* Get an overview about the remaining budget
+* Send email to a responsible contact if the budget reaches a specific percentage
+* Define a fiscal year
+
+
+
+Budgets define the amount of money, which a contact or role can spend.
+You can set the period and start date of a fiscal year and whether
+the responsible contact want to get a mail if the defined percentage is reached.
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/checkout.md b/source/shopware-enterprise/b2b-suite/component-guide/checkout.md
new file mode 100644
index 0000000000..4f914f9bc0
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/checkout.md
@@ -0,0 +1,52 @@
+---
+layout: default
+title: Checkout
+github_link: shopware-enterprise/b2b-suite/component-guide/checkout.md
+indexed: true
+menu_title: Checkout
+menu_order: 12
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+Direct-Link to the module: `my-shop.de/checkout/confirm`
+
+The B2B-Suite adds two more functions to the checkout of Shopware:
+* An order reference number
+* A requested delivery date
+
+The fields have multiple features:
+* Both fields are not affecting Shopware during the order process.
+* Backend users can access these information in the order detail panel.
+* Users can also add more specific information to these fields like "ES-271" or "only mondays".
+
+
+
+
+
+### Order Lists
+If the cart is filled with an order list, the B2B-Suite will show the name of the list below every products.
+
+`my-shop.de/checkout/cart`
+
+
+`my-shop.de/checkout/confirm`
+
+
+`my-shop.de/checkout/finish`
+
+
+### Budgets
+Every b2b user, except debtors, must have a sufficient budget to place or accept an order.
+
+The confirm page includes a budget selection with a small overview of the selected budget.
+Only sufficient budgets can be chosen.
+
+
+
+### Contingent Rules Messages
+You can see all contingent rules and restrictions on the `my-shop.de/checkout/confirm` page if they are fulfilled or not
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/company.md b/source/shopware-enterprise/b2b-suite/component-guide/company.md
new file mode 100644
index 0000000000..e865dc0800
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/company.md
@@ -0,0 +1,29 @@
+---
+layout: default
+title: Company
+github_link: shopware-enterprise/b2b-suite/component-guide/company.md
+indexed: true
+menu_title: Company
+menu_order: 3
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+Direct-Link to the module: `my-shop.de/b2bcompany`
+
+
+
+## General
+
+The company module allows you to manage your company and set permissions to roles and contacts.
+The following entities will be managed in this module:
+
+
+
+#### Change Contact Password
+To send a change password mail to a contact, you have to confirm the password activation checkbox and save the data.
+
+
+
+After saving, a mail with a password activation link will be send.
+
+You can change the `b2bPasswordActivation` mail template in the Shopware Backend.
+
+Following the link in the mail, the customer could change the password of his account.
+
+
+
+### Contact details
+To configure the contact settings you can press somewhere on the contact row.
+In the detail window you can
+* Edit master data
+* Change billing address
+* Change shipping address
+* Manage contact visibility
+* Manage role visibility
+* Manage roles
+* Manage permissions
+* Manage contingents
+* Manage Order lists
+* Manage Budgets
+
+### Contact Deletions
+To remove contacts you can use the trash button to delete the contact which is no longer required.
+Since **version 3.0.5** and **version 4.2.1** of the B2B-Suite, removing the contact will also remove the shopware user data and transfer all offers and orders from the contact to the debtor.
+
+### Shopware Backend
+The contacts are **not available** in the Backend.
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/contingents.md b/source/shopware-enterprise/b2b-suite/component-guide/contingents.md
new file mode 100644
index 0000000000..1a0dd6ca0c
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/contingents.md
@@ -0,0 +1,63 @@
+---
+layout: default
+title: Contingents
+github_link: shopware-enterprise/b2b-suite/component-guide/contingents.md
+indexed: true
+menu_title: Contingents
+menu_order: 6
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+This component is managed in the company module, direct link to the company module: `my-shop.de/b2bcompany`.
+
+Contingents are used to limit the ability to order without clearance for specific contact accounts or whole roles.
+The B2B-Suite defaults to disallow all direct orders and put them into the clearance process.
+
+A contingent group is a container for a specific rule set.
+
+
+
+### Add contingent groups
+
+In the contingent module you can create new contingent groups by clicking on the "Create contingent group" button.
+After submitting the form you will be forwarded to the contingent detail page.
+
+
+
+### Add contingent rules
+
+After creating the contingent group you can define corresponding rules. You have to set *Contingent rules* in Order to allow contacts to direct order or clear orders themselves.
+
+There are three types of rules that can be configured.
+
+* Order amount
+* Order item quantity
+* Order quantity
+
+The rules supports three types of restrictions:
+
+#### Restriction Types
+
+**Order amount**
+
+Handles the maximum order amount net per time unit.
+
+**Order item quantity**
+
+Handles the maximum quantity of products per time unit.
+
+**Order quantity**
+
+Handles the maximum allowed orders per time unit.
+
+
+
+### Add contingent restrictions
+
+A contingent restriction disallows orders that are otherwise whitelisted through the contingents rule set. Currently you can directly disable products from certain categories or their subcategories. Also are restrictions based on product price and product ordernumber available.
+
+### Contingent group deletions
+To remove contingent groups you can use the trash button to delete the selected group which is no longer required.
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/dashboard.md b/source/shopware-enterprise/b2b-suite/component-guide/dashboard.md
new file mode 100644
index 0000000000..4d0271da5c
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/dashboard.md
@@ -0,0 +1,39 @@
+---
+layout: default
+title: Dashboard
+github_link: shopware-enterprise/b2b-suite/component-guide/dashboard.md
+indexed: true
+menu_title: Dashboard
+menu_order: 2
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+Direct-Link to the module: `my-shop.de/b2bdashboard`
+
+The dashboard offers a quick view over all B2B-Suite features.
+
+
+
+### Landingpage
+
+In the Shopware Backend, you can select a shopping world for every customergroup to display above the dashboard.
+
+
+
+You can select the shopping world in the Shopware Backend at the customergroup attributes.
+
+
+
+A direct declaration for the shopping worlds to debtors and contacts is possible through the tab `Debtor Landingpage` in the shopware backend customer detail view of a debtor.
+
+
+
+If the shopping worlds are not directly assigned the contacts inherit the shopping worlds from their debtor and the debtor inherit the shopping worlds from the customergroup.
+
+### Contingent Rules
+You can see all rules and restrictions for the specific contact on the dashboard.
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/demo-environment.md b/source/shopware-enterprise/b2b-suite/component-guide/demo-environment.md
new file mode 100644
index 0000000000..9f75a6f1cd
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/demo-environment.md
@@ -0,0 +1,111 @@
+---
+layout: default
+title: Demo Environment
+github_link: shopware-enterprise/b2b-suite/component-guide/demo-environment.md
+indexed: true
+menu_title: Demo Environment
+menu_order: 1
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+
+
+## Description
+
+In our demo environment, we have several demo accounts to test the B2B-Suite. In the following tables all described users
+have the password "shopware". The debtor is the only user which have up to ten entries, so there is no pagination in the frontend.
+
+
+#### Feature Overview
+* Import *.csv, *.xls or *.xlsx file
+* configuration of column to use (first column starts with 0), csv delimiter, csv enclosure and used headline
+* overview of imported products
+* fast order grid to add products by ordernumber to the basket
+* autocompletion for product ordernumbers (deactivates autocompletion for given input field)
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/index.md b/source/shopware-enterprise/b2b-suite/component-guide/index.md
new file mode 100644
index 0000000000..7c092d018e
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/index.md
@@ -0,0 +1,36 @@
+---
+layout: default
+title: Component Guide
+github_link: shopware-enterprise/b2b-suite/component-guide/index.md
+indexed: true
+tags: [b2b, guide, start, begin]
+menu_title: Component Guide
+subgroup: B2B-Suite
+menu_order: 2
+group: Shopware Enterprise
+---
+
+
+
+## General
+
+The B2B-Suite has different use cases for various types of users.
+In the following document you can find several links for workflows.
+
+
+
+After having taken these actions, you will be redirected to an overview of your new offer.
+
+
+
+There you can:
+* Go back to cart
+* Add / delete / edit products
+* Add / delete / Edit discount prices
+* Add / delete / edit a discount
+
+After processing your offer request you can send it to an admin user.
+
+## Get an overview of all your offers
+You can access an overview of all offer requests.
+
+
+
+They can be searched and sorted by different criteria.
+
+Clicking on the row or detail button opens the detail view.
+
+## Detail view
+The offer detail view provides three different views.
+ * An overview which shows the most important information. These are the original prices, the discount prices, the state and event dates.
+ * A grid view of all items. There you can edit, delete and add items to the offer
+ * A change view which provides a changelog of all actions done in the context of this offer e.g. adding items or comments.
+
+
+
+## Backend overview
+Also, an additional view is added for the Shopware backend.
+
+It can be accessed through the new menu item in the customers index tab.
+
+
+
+This view shows a list of all offers which have to be processed by the admin.
+
+
+
+## Backend detail view
+With the backend overview the admin can access the detail view of all offer requests.
+
+
+
+The admin can modify the positions or the total discount of an offer to create an counter-offer.
+After the modification from the admin, the status will be automatically set to admin declined.
+This can be done by changing the offer and sending it back.
+
+But there are also actions which can be performed all the time.
+* Setting an expiration date for an offer
+* Comment the offer to communicate with the customer
+
+## Create an Order
+After an order has been accepted by the customer and the admin it can be converted to an order.
+
+view of the accepted offer request. This can be done with a button, which appears in the detail overview of the accepted offer request.
+
+
+
+It redirects you to the checkout page.
+
+You can still change the quantity to a value higher than the offer value and still add items to the cart.
+
+Here you can order it or create an order clearance if necessary.
+
+After creating the order it will be shown in the order overview.
+Also the changelog of the offer will be displayed in the the order comment history.
+
+## See the changes of your offer
+
+This overview mainly serves the purpose to show you the current state and the history of your offer.
+You will see if the offer already got approved, declined, or even sent.
+Furthermore, all other changes will be shown there like changes of the discount, added items, removed items and price changes.
+
+You can access it from the history in the offer detail overview.
+
+There you can also find a button for creating comments.
+
+
+
+
+
+
+
+The same functionality can be accessed from the backend.
+
+The site can be accessed from the history tab of the offer detail view.
+
+
+
+
+
+## Get notified about changes
+
+Every time the status of an offer (associated with you) changes you will get notified by an email.
+
+Beeing a backend user you can choose to receive emails or not by marking the corresponding checkbox in the user administration.
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/order-list.md b/source/shopware-enterprise/b2b-suite/component-guide/order-list.md
new file mode 100644
index 0000000000..7bf65d6895
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/order-list.md
@@ -0,0 +1,79 @@
+---
+layout: default
+title: Order List
+github_link: shopware-enterprise/b2b-suite/component-guide/order-list.md
+indexed: true
+menu_title: Order List
+menu_order: 9
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+Direct-Link to the module: `my-shop.de/b2borderlist`
+
+
+
+### Order List Overview
+A list with all available order lists.
+A user can delete, copy or add the items to the basket for every order list.
+
+
+
+### Create Order List
+With a click on the `create order list` Button a user can create a new order list.
+To create a list, a name is required.
+
+
+
+### Edit Order List
+A click on the row or the edit button opens an Order List.
+
+### Master Data
+After clicking, a modal window opens with the name of the list.
+A User can always change the name of the order list.
+
+
+
+### Positions
+All positions are listed in the modal window.
+
+
+
+With the arrow buttons, you can sort the order list positions.
+Deleting is done by clicking the delete button in the row.
+Through editing, a user can change a position´s quantity and write a comment.
+
+
+
+### Add Products
+A user can add a position by clicking the add item Button.
+After clicking the modal window ask the two **required values** `ordernumber` and `quantity`.
+The `ordernumber` mus be a **valid** item order number from a normal item (`mode = 0`) in the shop.
+The comment is an **optional** value.
+
+
+
+### Add Products from Detail Page
+Optionally a user can add products to a specific order list on the product detail page.
+
+
+
+
+If the product is already on the list, an error message will be shown.
+
+
+
+### Add Products from Cart
+On the confirm `my-shop.de/checkout/confirm` and cart page `my-shop.de/checkout/cart`, a user can add all normal products (`modus = 0`), to a specific order list.
+
+
+
+The user can also create a new order list from the cart, by selecting **create new order list**.
+
+
+
+Every product position from a cart can also be particular added to an order list.
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/order.md b/source/shopware-enterprise/b2b-suite/component-guide/order.md
new file mode 100644
index 0000000000..612c481e2b
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/order.md
@@ -0,0 +1,157 @@
+---
+layout: default
+title: Order
+github_link: shopware-enterprise/b2b-suite/component-guide/order.md
+indexed: true
+menu_title: Order
+menu_order: 8
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+Direct-Link to the module: `my-shop.de/b2border`
+
+
+
+## Order Overview
+
+
+
+The Order overview shows two distinct grids.
+The first one is a list of all orders from your account and other accounts with fitting visibility rights. The second one is a list of all orders you are allowed to clear.
+
+### Order History
+
+If you are logged in as a Contact you will see all your personal orders, if the account is a Debtor you will see all orders triggered by your whole organization.
+This overview mainly serves the purpose to show you th current state of past orders. You will see if the already got approved, declined, or even send.
+From here you can:
+
+* Open the order details and see the whole history of the order.
+* Create an order list for later uses.
+
+### Run into order clearance
+
+First of all you have to place a temporary order which is out of your allowed contingent rules or budgets.
+In the confirm step instead of direct order placement you can only choose "request clearance".
+
+### Accept and Decline orders
+Users with fitting contingent rules can now accept or decline the order which was placed before.
+To accept the requested order you can use the check button. During the
+accept process, the temporary order will be changed to a normal order. The shop administrator
+is now able to deliver the placed order.
+
+If you want to decline the order there is a cross button which change the temporary order to a permanent
+declined order.
+
+
+
+#### Decline
+Triggering the decline button will open a modal box, where you can optionally add a comment.
+This comment will be available to the user who started the order in the first place.
+
+
+
+#### Accept
+Triggering the accept button, you will be redirected to the confirm page and have a cart filled with the items of the temporary order.
+You can place the order, ask for an offer or cancel the clearance process with the `cancel Clearance` button.
+
+
+
+### Create Order List
+With the order list create permission an order list can be created through every order by clicking the create order list button.
+The detail window of the order list will open and the data of the order list can be changed.
+
+
+
+### Edit Order
+A click on the row or the edit button opens an Order.
+
+
+
+
+
+If the user is placing the order with products from an order list, a short info will be shown.
+
+
+
+### Positions
+In temporary orders, users can add, delete or modify the normal products (`mode = 0`) with the buttons.
+
+
+
+The button Add Line Item triggers the process to add an Product with a specific quantity and comment to the order clearance.
+
+Deleting is done by clicking the delete button in the row.
+Through editing, a user can change a position´s quantity and write a comment.
+
+
+
+Positions from permanent orders cannot be changed.
+
+
+
+If the user is placing the order with products from an order list, a short info will be shown.
+
+
+
+### History
+Every change from the order is logged and listed in the history.
+
+
+
+### Order reference number and requested delivery date in order confirmation mail
+The B2B-Suite enriches orders with additional order data.
+For example, it is possible to define a custom order reference number and requesting a delivery date in the checkout.
+These data are also possible to view in the order confirmation mail.
+
+#### B2B-Suite for Shopware 5
+In this version, the mail confirmation template will be extended automatically.
+If you use a custom mail template, you should check your template, because the structure could slip after running the migration, which extends the template.
+
+##### How to check and modify your template
+Hover over the settings tab in the backend and click on "mail templates" at "mail management" to get a new window with all mail templates.
+Then you click on "system mails" and select the "sOrder" template.
+There you can modify the plain and HTML content to change the order or structure of your mail contents.
+The B2B-Suite extension should look like:
+
+ {if $orderReference}
+ Order reference number: {$orderReference}
+ {/if}
+ {if $requestedDeliveryDate}
+ Requested delivery date: {$requestedDeliveryDate}
+ {/if}
+
+##### How to modify your template
+Click on the settings tab in the administration and choose "Email templates" at the "Shop" settings.
+Then edit the mail template with the "Order confirmation" type.
+There you can modify the content of your mail in plain and HTML text.
+
+For the B2B-Suite order template extension you have to add these snippets into your content depending on the type of text:
+
+###### Plain text
+
+ {% verbatim %}{% if order.customFields.b2bOrderReferenceHolder is defined and order.customFields.b2bOrderReferenceHolder != '' %}
+ Order reference number: {{ order.customFields.b2bOrderReferenceHolder }}
+ {% endif %}
+ {% if order.customFields.b2bDeliveryDateHolder is defined and order.customFields.b2bDeliveryDateHolder != '' %}
+ Requested delivery date: {{ order.customFields.b2bDeliveryDateHolder }}
+ {% endif %}{% endverbatim %}
+
+###### HTML text
+
+ {% verbatim %}{% if order.customFields.b2bOrderReferenceHolder is defined and order.customFields.b2bOrderReferenceHolder != '' %}
+ Order reference number: {{ order.customFields.b2bOrderReferenceHolder }}
+The custom ordernumber upload allows to import ordernumbers from *.csv, *.xls or *.xlsx files
+and **replace** them with existing.
+
+##### Upload feature overview
+* Import *.csv, *.xls or *.xlsx file
+* configuration of column to use (first column starts with 0), csv delimiter, csv enclosure and used headline
+
+#### Custom ordernumber grid
+
+The grid shows a list of all custom ordernumbers.
+The empty line can be used, to add new custom ordernumbers.
+
+##### Feature overview
+* Create / Edit / Delete custom ordernumbers
+* autocompletion for product ordernumbers
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/payment.md b/source/shopware-enterprise/b2b-suite/component-guide/payment.md
new file mode 100644
index 0000000000..88423a59d6
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/payment.md
@@ -0,0 +1,37 @@
+---
+layout: default
+title: Payment
+github_link: shopware-enterprise/b2b-suite/component-guide/payment.md
+indexed: true
+menu_title: Payment
+menu_order: 17
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+### Clearance Payment Method
+For order clearance, a payment method with the internal name `b2b_order_clearance_payment` will be created.
+
+
+
+The payment method **has to be active** and will be **automatically selected** before placing an order for the clearance process.
+
+`my-shop.de/checkout/shippingPayment`
+
+
+
+`my-shop.de/checkout/confirm`
+
+
+
+### Risk Management Rule
+A Shopware backend user can block a payment method for b2b or normal users with the risk management rule `B2B Account`.
+
+Value `1` is for blocking the payment for b2b user and the value `0` for normal user.
+
+
+
+### Payment Inheritance
+Every contact inherits the debtor payment after login. You can change it for an order. After another login the contact inherits the debtor payment again.
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/permissions.md b/source/shopware-enterprise/b2b-suite/component-guide/permissions.md
new file mode 100644
index 0000000000..a7e62bf753
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/permissions.md
@@ -0,0 +1,34 @@
+---
+layout: default
+title: Permissions
+github_link: shopware-enterprise/b2b-suite/component-guide/permissions.md
+indexed: true
+menu_title: Permission Management
+menu_order: 10
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+Direct-Link to the module: `my-shop.de/b2bcontact`
+
+The contact module also allows to define permissions for contacts. The permissions can be set by component.
+Notice: The Debtor account does not experience any ACL behaviour. A Debtor is always the Superadmin.
+
+The default behaviour is to block all access. Which means that all access control panels are
+whitelisting additional resources or actions.
+
+To grant privileges you have to assign a role or a permission to a contact. Important to know is, that
+direct granted privileges to a contact ranked higher than role privileges.
+
+
+
+## Assignment Types
+* Grant privilege
+* Inherit privilege
+
+We decide between two types of privilege. To grant access to a specific component there is the checkbox
+which is flagged by a checkmark.
+The second option allows the user to grant his privilege to other users. This option ist flagged by the
+forward icon.
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/price.md b/source/shopware-enterprise/b2b-suite/component-guide/price.md
new file mode 100644
index 0000000000..cd8cee3270
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/price.md
@@ -0,0 +1,35 @@
+---
+layout: default
+title: Price
+github_link: shopware-enterprise/b2b-suite/component-guide/price.md
+indexed: true
+menu_title: Price
+menu_order: 13
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+
+First you get the id of the product from the s_articles_details table.
+The id is 15 in our case.
+
+With the identifier you are able to fire the API call.
+
+
+
+And then you see the price update.
+
+
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/profile.md b/source/shopware-enterprise/b2b-suite/component-guide/profile.md
new file mode 100644
index 0000000000..c126069bd7
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/profile.md
@@ -0,0 +1,26 @@
+---
+layout: default
+title: Profile Page
+github_link: shopware-enterprise/b2b-suite/component-guide/profile.md
+indexed: true
+menu_title: Profile Page
+menu_order: 2
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+Direct-Link to the module: `my-shop.de/b2baccount`
+
+## Profile Page
+
+With an existing b2b account you can access your profile page by pressing on your own name.
+Here you can change your account password. Additionally you have access to the order lists if your account
+have the required permissions.
+
+### Profile Avatar
+
+You are able to upload your own profile picture (Square). If you don't setup a picture we use [Gravatar](http://gravatar.com)
+as a fallback. If you would like to change your fallback avatar you have to define the avatar on [gravatar.com](http://gravatar.com)
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/quick_start.md b/source/shopware-enterprise/b2b-suite/component-guide/quick_start.md
new file mode 100644
index 0000000000..363fef859e
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/quick_start.md
@@ -0,0 +1,44 @@
+---
+layout: default
+title: Quick Start
+github_link: shopware-enterprise/b2b-suite/component-guide/quick_start.md
+indexed: true
+menu_title: Quick start
+menu_order: 17
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+This document describes, how to quick start, if you have a demo package of the B2B-Suite. If you don't have
+such a package yet, please contact us via [this form](https://enterprise.shopware.com/en/b2b-signup).
+
+## Installation
+We will provide the B2B-Suite as typical Shopware plugin. In your project, you can make use of the full framework architecture,
+of course. But for a quick demo, the plugin is much easier to use.
+
+The B2B-Suite requires the following plugins to be installed:
+* [Cron](http://en.community.shopware.com/Plugin-Cron_detail_1606.html)
+
+To [run the cronjob](http://en.community.shopware.com/Cronjobs_detail_1103.html), it has to be configured in your system.
+
+You can install and activate the plugin from the [Plugin Manager in the Shopware backend](http://en.community.shopware.com/Plugin-Manager-from-Shopware-5_detail_1858.html#Installed).
+
+Please clear the caches afterwards and reload the backend.
+
+In Shopware 5.3.x or lower the B2B Suite requires always SSL or no SSL configuration. In Shopware 5.4.x the partial SSL option is no longer available.
+
+In Shopware 5.4.x or newer, the B2B Suite can also be installed by the composer installation of shopware with the store-plugin-installer module. More detailed information can be found [here](https://github.com/shyim/store-plugin-installer).
+
+## Creating a frontend user account
+In order to test the B2B-Suite in the Shopware Frontend, [create a customer account first](http://en.community.shopware.com/Create_detail_1180_681.html). This can be done from the menu
+`Customers->Create`. Now create a customer as usual. In order to upgrade this customer to a debtor account and grant access to the features of the
+B2B-Suite, just tick the "Mark the account as debtor" box:
+
+
+
+#### Feature overview
+* Create / Edit / Delete roles
+* Edit master data
+* Manage permissions
+* Change billing address
+* Change shipping address
+* Manage Budgets
+
+### Add and edit a role
+
+To add a role you can click on the "Create role" button which will open a new form.
+After submitting the creation form you will be forwarded to the role configuration.
+
+
+
+### Role detail
+
+After you created the role you can access multiple settings for the created role:
+* Master data
+* Manage permissions
+* Manage contact visibility
+* Manage role visibility
+* Billing addresses
+* Shipping addresses
+* Manage contingents
+* Manage order lists
+* Manage budgets
+
+
+
+### Role deletions
+To remove roles you can use the trash button to delete the role which is no longer required.
+
+### Inheritance
+
+
+
+The permissions of a role will be implicit inherit from other roles.
+E.g. (compared to the screenshot) The Role "Research & Development" inherits implicit the permissions of the roles
+"IT-Administration", "Technical Engineering" and "Product Development". If the "Technical Engineering" has the
+permission to edit order lists, the "Research & Development" role has no need to get these permission explicit.
+It is possible to drag'n'drop a role before, after or as a child role.
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/sales-representative.md b/source/shopware-enterprise/b2b-suite/component-guide/sales-representative.md
new file mode 100644
index 0000000000..ebf9a2ca63
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/sales-representative.md
@@ -0,0 +1,44 @@
+---
+layout: default
+title: Sales Representative
+github_link: shopware-enterprise/b2b-suite/component-guide/sales-representative.md
+indexed: true
+menu_title: Sales Representative
+menu_order: 15
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+Direct-Link to the module: `my-shop.de/b2bsalesrepresentative`
+
+### Client overview
+
+After login as a sales representative, you can see an overview of all your clients.
+You are not able to visit other sites of the shop, if you are not logged in as a client.
+The list can be sorted or filtered.
+You can log in as a client with the log in button.
+
+
+
+### Logged in as a client
+
+After log in as a client, a top bar will be displayed.
+The name of the client is displayed on the left and the client overview link is on the right of the top bar.
+You have the same rights as the client and are able to place orders or configure other things.
+
+
+
+### Backend sales representative
+
+Every Shopware customer can be declared as a sales representative by checking the sales representative checkbox in the customer detail module.
+
+
+
+An image for the sales representative can be selected at the customer attributes.
+
+
+
+After a reload of the customer module, the clients for the declared "sales representative" can be chosen in a new tab.
+
+
diff --git a/source/shopware-enterprise/b2b-suite/component-guide/statistics.md b/source/shopware-enterprise/b2b-suite/component-guide/statistics.md
new file mode 100644
index 0000000000..5404539343
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/component-guide/statistics.md
@@ -0,0 +1,25 @@
+---
+layout: default
+title: Statistics
+github_link: shopware-enterprise/b2b-suite/component-guide/statistics.md
+indexed: true
+menu_title: Statistics
+menu_order: 3
+menu_chapter: true
+group: Shopware Enterprise
+subgroup: B2B-Suite
+subsubgroup: Component Guide
+---
+
+Direct-Link to the module: `my-shop.de/b2bstatistic`
+
+The statistics offers the following functionality:
+* quick view of relevant order statistics with available filter for a more detailed view
+* viewed statistics can be exported to disk as csv or xls file
+* grid view of filtered orders
+
+
+
+### Grid view of selected orders
+
+
diff --git a/source/shopware-enterprise/b2b-suite/download/index.html b/source/shopware-enterprise/b2b-suite/download/index.html
new file mode 100644
index 0000000000..35efb1ab32
--- /dev/null
+++ b/source/shopware-enterprise/b2b-suite/download/index.html
@@ -0,0 +1,31 @@
+---
+layout: default
+title: Download
+github_link: b2b-suite/download/index.md
+indexed: true
+tags: [b2b, download]
+menu_title: Download
+menu_order: 5
+group: Shopware Enterprise
+subgroup: B2B-Suite
+---
+
+
+
+
+
+
+
+In order to edit the test plans, just run `./scripts/jm-edit.sh`. It will open the JMeter application. The Shopware
+JMeter Scripts generally defines 9 different components (2) you can use in your test plans:
+
+ * `Frontend - Start`: A call to the start page
+ * `Frontend - Category`: A call to a random category page
+ * `Frontend - Search`: Performs a random search
+ * `Frontend - Random`: A request to a random static page
+ * `Frontend - addToBasket`: Add a product to the shopping cart
+ * `Frontend - ArticleDetail`: A call to a random product detail page
+ * `Frontend - Register`: Registers a new customer
+ * `Frontend - Login`: Logs in as an existing customer
+ * `Frontend - Checkout`: Calls the checkout confirm and the checkout finish page (thus performs an order)
+
+Most of these components use certain assets (1): For the `Frontend - Category` component, for example, a random category URL is required -
+and provided by the corresponding asset.
+
+The actual test plans are defined in so called "thread groups": Each thread group copies or links one or more components
+and therefor "tells a user story" such as "a user visits the start page, searches for 5 items and then adds two items to cart" or
+"a user browses 3 categories, adds 1 item to cart, registers and performs an order". This way you can try to model real
+user's behaviour in your test plans. In production, for example, just 3 to 5% of your users will actually perform a checkout.
+So it makes sense to create one thread group only browsing the shop and one thread group which actually performs checkouts.
+
+The Shopware JMeter Scripts define 9 thread groups which you can change to your needs: E.g. one group for users mostly
+searching, one group for users mostly browsing, one group for registered users and one group for users not yet registered.
+Copy / link the pre-defined components into each thread group as needed. After saving you can close the window again and
+configure, how many threads / users are active for each thread group.
+
+### Test plan configuration
+First edit the file `config/testplan_config.properties`. By default it will look like this:
+
+```
+server.hostname = shopware.local
+server.protocol = http
+
+execution.delay = 10000
+
+execution.deviation = 5000
+
+execution.rampup = 30
+
+execution.duration = 120
+
+threads.group_1.users = 100
+threads.group_2.users = 3
+threads.group_3.users = 0
+threads.group_4.users = 0
+threads.group_5.users = 0
+threads.group_6.users = 0
+threads.group_7.users = 0
+threads.group_8.users = 0
+threads.group_9.users = 0
+```
+
+ * ` server.hostname`: Hostname of the server you want to load test, e.g. `my-production-shop.example.com`
+ * `server.protocol`: The protocol you want to use, usually `http` or `https`
+ * `execution.delay`: How many ms should pass between each action of a thread group
+ * `execution.deviation`: The `execution.delay` will randomly be increased / reduced by `execution.deviation`
+ * `execution.rampup`: JMeter will take up to `execution.rampup` seconds until all threads are started
+ * `execution.duration`: Number of seconds the load test should run
+ * `threads.group_NUMER.users`: Number of concurrent users you want to simulate for a thread group
+
+The above configuration, for example, will run for 2 minutes and spawn 100 threads ("users") for the first thread group
+and 3 threads ("users") for the second thread group. Between each request of a thread ("user") a 10 second delay is defined.
+
+### Generating the assets
+In order to run JMeter some assets needs to be generated, so that JMeter knows which URLs to call and which products
+to buy. All assets are generated directly from Shopware's database. For that reason, you need to specify your database
+credentials in `scripts/credentials.sh`. A template for that file can be found in `scripts/credentials.dist.sh`.
+
+Furthermore you need to specify `SHOP_USER_PASSWORD`: JMeter will use this password when logging in as a user. If you are
+load testing an existing database dump, you will usually need to set the passwords in the database:
+
+`UPDATE s_user SET password="$2y$10$PeSQ3o7F0hocHKH.1CvUCexZ/qernZ4wUC4cbGj2a3jLgLCcvwMRm"`
+
+This will set all passwords to "shopware". JMeter will now be able to log in as any of these users. As an alternative
+you can also generate dummy data automatically by using the [Shopware CLI tools](https://github.com/shopwareLabs/sw-cli-tools).
+
+In order to generate all assets, just run `./scripts/all-uris.sh`. If you just want to (re-)generate a part of the assets,
+there are specific scripts such as `scripts/uri-accounts.sh` or `scripts/uri-search.sh`.
+
+### Running the load test and inspecting the results
+In order to execute the load test, just run `scripts/jm-run.sh`. It will execute the test plan for the configured
+`execution.duration`:
+
+
+
+While the test plans run, its usually helpful to watch the load of the application servers and the database: If disc load,
+RAM usage or CPU usage are extremely high, you might have found a bottleneck. But also keep in mind, that the number
+of connections can be a limiting factor for all of these servers.
+
+After the test plan exited, you can run `./scripts/jm-edit.sh` again in order to open JMeter. At the bottom of the navigation
+on the left side you find "Summary Report" (1). Click on it and open the CSV file of your JMeter run (2):
+
+
+
+JMeter will present you all URLs which have been called, the average response time, number of samples, percentage of
+errors and other useful metrics. You can even inspect every single request by selecting "View Result Tree" from the
+navigation. After opening the `result.csv` file, JMeter will show you every request with the corresponding headers and
+body. This is especially useful, if you want to debug errors.
+
diff --git a/source/shopware-enterprise/pricing-engine/index.html b/source/shopware-enterprise/pricing-engine/index.html
new file mode 100644
index 0000000000..0698366c51
--- /dev/null
+++ b/source/shopware-enterprise/pricing-engine/index.html
@@ -0,0 +1,29 @@
+---
+layout: default
+title: Pricing Engine
+github_link: pricing-engine/index.html
+indexed: true
+menu_title: Pricing Engine
+group: Shopware Enterprise
+---
+
+
+
+
+Now you will see an overview of all imported pricelists. All information about each pricelist is present there like name, priority, price and condition count.
+
+
+With clicking on the edit button the Pricelistdetailview will open and you can see the created conditions for this list.
+
+
+
+In this view you are able to add, update and delete conditions for the previous selected price list. Below you can see an example how to add a new condition:
+
+
+
+If you want to check which prices are imported for a product, the Pricing Engine adds a new tab to the product detail view. In this tab you can search for prices and filter by given price lists:
+
+
diff --git a/source/shopware-enterprise/search/configuration.md b/source/shopware-enterprise/search/configuration.md
new file mode 100644
index 0000000000..465b3f0b13
--- /dev/null
+++ b/source/shopware-enterprise/search/configuration.md
@@ -0,0 +1,92 @@
+---
+layout: default
+title: Configuration
+github_link: search/configuration.md
+indexed: true
+menu_title: Configuration
+group: Shopware Enterprise
+subgroup: Enterprise Search
+menu_order: 3
+---
+
+Shopware Enterprise Search has comprehensive configuration options to configure the search as needed.
+
+
+
+## Basic settings
+The basic settings allow some general configuration of the search:
+
+* Highlight search terms: Will highlight the search term in the search result
+* Find products for the first suggestion: In addition to products matching the actual search term, SES will also show
+products matching the first suggestion for the search term. So even if SES cannot find products for the search term
+based on the search configuration, it will still be able to find products for a similar search term. This makes it less
+likely that no products can be found.
+* Content search - Number of results on search result page: Configure the number of search results per content type
+* Content search - Number of results for ajax search: Configure the number of search results for the quick search
+* Min score value for ajax and content search
+
+## Synonyms
+Synonyms allow you to configure search terms which are considered to be synonym or should match the same result set,
+e.g. "shoe" and "sneaker". Synonyms are managed in synonym groups, where all search terms in a synonym group are considered
+synonyms.
+
+Additionally you can limit synonyms to certain shops and add a shopping world to the search result page of search terms
+belonging to that synonym group. That way you can have your "shoe shopping world" appear on searches for "shoe" as well
+as "sneaker" and "boot".
+
+## Relevance
+Relevance defines the fields ElasticSearch will consider during a search as well as the relevance the have. Additionaly
+you can modify how ElasticSearch handles those fields.
+
+* Name: A meaningful name for the relevance definition, e.g. "rank exact matches higher"
+* Relevance: The boost ElasticSearch will apply to products matching the search term in the given field (1-100)
+* Field: The field this definition applies for, e.g. "name" for the product name. Most of a product's fields are available
+here, some might even appear multiple times, e.g. `name`, `name.german_analyzer` and `name.raw`. The suffix indicates,
+how ElasticSearch handles the field: `name` might have some special characters removed, `name.german_analyzer` will
+apply some optimizations for german language, `name.raw` does not have any optimizations. In addition to that
+there are special fields you should consider: `attributes.enterprise.product_suggestion` will split compound words
+such as "skyscraper" into separate words such as "sky" and "scraper". This is especially useful for language like e.g. german.
+Also there is `attributes.enterprise.product_suggestion_compound` which will search the ngram index and also match "skyscraper"
+for searches like "ysc". As this might massively lower the quality of the suggestions, we usually recommend to not use
+this field, if it can be avoided.
+* Fuzzyness: Number of letters that will be ignored / corrected by the search:
+ * `Auto`: Automatically determine the value depending on the length of the search string. Usually: 0 for 1-2 characters, 1
+ for 3-5 characters and 2 for anything longer then that.
+ * `None`: No correction of letters
+ * `One`: One letter will be corrected
+ * `Two`: Two letters are corrected
+ * `Three`: Three letters are corrected
+* Operator: Defined how the search term is compared to the field: `AND` will only match, if all search terms occur in the field,
+`OR` matches, once one search term can be found in the field. `AND` is less likely - and therefor usually will get a higher
+boosting than `OR`. E.g. By defining a higher rating for `AND`, a customer searching for "sky scraper" will first see
+"sky scraper" and then "skyway" or "whisky".
+* Type: Defines what is considered a match. `Default` will apply the default mechanisms of ElasticSearch, `phrase` will
+force a whole word to match. `Phrase prefix` will allow to match a word, even if just the beginning matches, e.g. "skyscraper" for "sky".
+* Maximum expansion: Only available for `phrase prefix`. Defines how many letters may follow after the beginning of the
+word and still are considered a match. Searching "sky" will only match "skyscraper", if maximum expansion is at least 7
+(the number of letters in "scraper").
+
+Generally you will always need multiple relevance definitions for several fields. Think of the relevance definitions as
+usage scenarios:
+
+* If a word matches multiple terms in the name, rank it highest: `field: name, operator: and, relevance: 100`
+* If one word matches exactly, rank it high: `field: name, operator: or, relevance: 90`
+* Match medium, if part of a compound word matches: `field: attributes.enterprise.product_suggestion, relevance: 50`
+* Match medium, if manufacturer matches partially: `field: manufacturer.name, operator: or, relevance: 50, type: phrase_prefix`
+
+Usually this is the most relevant part when setting SES for a shop: Usually customers want both: Very precise and good
+rankings for products matching the term properly as well as fuzzy matches for less relevant searches.
+
+
+## Boost
+Boost behaves similar to the relevance configuration. They allow to define additional boosts for products which meet
+certain criteria. This way you can configure, that a product is especially interesting, if it is e.g. a topsellet product.
+
+* Boosting name: Meaningful name for the boost definition, e.g. "boost topseller products"
+* Relevance value: The value of the boosting (1-100)
+* Table field: The boost will only apply, if the defined field of the product is `true`. E.g. `isTopSeller` or `isNew`.
+
+By default SES will only allow you to choose from boolean product and attributes fields, as these can easily be checked
+for their state. In future versions this might be extended to also support arbitrary fields and apply rules on them, such
+as `product.release_date < 2017/02/03`. Feel free to give us feedback, if this might be relevant for you.
+
diff --git a/source/shopware-enterprise/search/developer/and_or.md b/source/shopware-enterprise/search/developer/and_or.md
new file mode 100644
index 0000000000..9cb45dbaef
--- /dev/null
+++ b/source/shopware-enterprise/search/developer/and_or.md
@@ -0,0 +1,62 @@
+---
+layout: default
+title: AND / OR search
+github_link: search/developer/and_or.md
+indexed: true
+menu_title: AND / OR
+group: Shopware Enterprise
+subgroup: Enterprise Search
+subsubgroup: Developer
+menu_order: 4
+---
+
+AND / OR searches are two typical search configurations: Given a search with multiple words (e.g. "samsung screen") an AND
+search will only find products which matches both teams. An OR search, however, will find all products which match
+at least one of these terms.
+In practice an AND search is useful to find high quality matches: A customer searching for "samsung screen" does not
+want to find all screens and all products from Samsung: He wants to find all screens from the brand Samsung. OR searches
+on the other hand might be useful for searches such as "display monitor" where people want to find all products matching
+one of the terms.
+
+## AND / OR searches in SES
+The default configuration of SES includes both: Given a search like "samsung screen" SES will give products matching both
+terms (AND) a relevance of 100. Products matching only one of the terms (OR) will get a relevance of 80. This way you
+get best of both worlds: High quality matches will always be ranked first, less quality matches can still be found.
+
+## Changing the configuration
+In the following examples two products "chair" and "clock" have been defined.
+### OR
+In the SES backend module only one rule is defined. The `operator` configuration is set to "OR":
+
+
+
+Searching in the frontend for "clock chair" both products can be found.
+
+
+
+### AND
+Now only an AND rule is configured by setting the `operator` configuration to "AND":
+
+
+
+Now the search will not return any results, as there are no products with both words in the name:
+
+
+
+If there was a product such as "clock with chair motive" it would be found.
+
+### Recommendation
+As described above, pure AND / OR searches for products can easily be configured in SES. In most cases, however,
+the combined approach is more useful: It makes sure that AND matches are preferred while OR matches can still be found
+as fallback.
+Also notice that AND rules will only apply per field: So the "samsung screen" example will only apply as long as both terms are part
+of the same field (e.g. the name). An AND search over multiple fields could be implemented, however, by decorating
+`\SwagEnterpriseSearch\Bundle\SearchBundleES\SearchQueryBuilder::buildQuery` where the actual search queries are created.
+Also you could index the both fields in question as one field and then configure it from the backend module.
+
+### Other entities
+Content related search results (e.g. blog, categories, shopping worlds etc) are implemented using the `completion_suggestion`
+functionality of ElasticSearch and cannot be configured from the backend module. The relevant logic for these search types can
+be found in `\SwagEnterpriseSearch\Bundle\SearchBundle\SuggestionFacet` as well as `\SwagEnterpriseSearch\Bundle\SearchBundleES\SuggestionHandler`.
+
+
diff --git a/source/shopware-enterprise/search/developer/boosting.md b/source/shopware-enterprise/search/developer/boosting.md
new file mode 100644
index 0000000000..e206ae0354
--- /dev/null
+++ b/source/shopware-enterprise/search/developer/boosting.md
@@ -0,0 +1,187 @@
+---
+layout: default
+title: Boosting
+github_link: search/developer/boosting.md
+indexed: true
+menu_title: Boosting
+group: Shopware Enterprise
+subgroup: Enterprise Search
+subsubgroup: Developer
+menu_order: 3
+shopware_version: 1.2.0
+---
+
+"Boosting" is the process on prioritizing certain search results over others. For example a shop owner might
+want to boost products in order to free the stock for new products. Or during a promotion products from a certain
+manufacturer should be boosted.
+
+
+
+## Boosting in SES
+
+Rules for boosting can be created from the SES backend module. The screenshot below shows the boosting configuration:
+
+
+
+The follwing fields are available:
+
+ * `Boosting name`: Usually there will be multiple boosting, for each use case a seperate one. In order to tell apart the
+ various boostings, its recommended to choose a speaking name for each rule
+ * `Active`: SES will only apply boostings which are marked as "active"
+ * `Relevance`: The boost each product matching the rules will get. Usually a value between 1 and 100, higher values are also possible
+ * `Boosting rule`: Defines, which products should get the defined boosting. In the image above all products having the
+ "comming soon" flag set will get a boost of 10
+ * `Valid from… till…`: Defines from when to when the boosting applies. This allows preparing future boostings / promotions
+
+## Technical overview
+
+Boostings are applied during query time, the main entry point is `\SwagEnterpriseSearch\Bundle\SearchBundleES\SearchQueryBuilder::applyBoosting`.
+This will read all configured, active and valid boosting definitions from the database and apply them after they have been
+converted to ElasticSearch queries by `\SwagEnterpriseSearch\Bundle\EnterpriseSearchBundle\Boosting\BoostingQueryBuilder::getBoostingQuery`.
+All rule types that are available in the backend module (`AND`, `OR`, `PRODUCT_COMPARE` and `TRUE`) have separate
+handlers, such as `\SwagEnterpriseSearch\Bundle\EnterpriseSearchBundle\Boosting\RuleHandler\AndRuleHandler` or
+`\SwagEnterpriseSearch\Bundle\EnterpriseSearchBundle\Boosting\RuleHandler\ProductRuleHandler`. These will convert a definition
+such as `['ProductCompareRule' => ['name', '=', 'table']` to an ElasticSearch query such as `BoolQuery(TermQuery('name', 'table'), BoolQuery::should)`.
+
+### Own rule types
+
+Own rule types can simply be registered through the DI container:
+
+```
+
+
+## Performance
+SES makes use of ElasticSearch - a well known high performing, scalable search engine. For that
+reason Shopware Enterprise Search will search million of products in short time. This will take load from your database
+and therefore improve the scalability of your overall server setup.
+
+The good performance of Shopware Enterprise Search especially can be seen in our quick search functionality: Every key
+stroke will show the users better suggestions, content pages and products for his search - with almost no impact to
+the database.
+
+## Behavioural boosting
+Behavioural boosting will track the customer journey and boost products depending on the customer's behaviour.
+Viewing a product, browsing a category or filtering for manufacturers or properties will in future boost products,
+which matches these criteria. So if a customer filtered for t-shirts in "XL" and "red", products matching these criteria
+will get an improved ranking.
+
+
+## Synonyms
+Synonyms allow you to define groups of words, which are considered to be synonym: So searching for "car" will also find
+products which are only optimized for "vehicle".
+
+
+
+## Shopping worlds
+With SES you can define shopping worlds for certain searches. Therefore you are able to prepare high quality search
+result pages in order to optimize conversion for certain parts of your catalogue.
+
+
+
+## Understanding your words
+In addition to fuzzy searches (searches being tolerant to typos to a certain degree) SES is also able to split compound
+words into individual words, which is especially relevant for german languages. Imagine a product called "skyscraper":
+SES "understands", that this word is compound from "sky" and "scraper" - and will find it without falling back to fuzzy
+mechanisms. This massively improves the quality of your search results in comparison to mechanisms such as
+[n-gram](https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-ngram-tokenizer.html).
+
+## Helps you optimizing your searches
+The preview functionality will not only allow you to quickly check certain searches - it also helps you to understand,
+why certain results are ranked higher than others.
+
+
+
+## Highly configurable
+With SES the search can be configured for the customer's needs. Highlighting of search terms and number of results
+per content type can be configured, of course. Also the minimum ranking value can be determined.
+
+
+
+A suggestion blacklist and the minimum word length for suggestions can be configured in the indexing settings tab.
+
+
+
+
+### Relevance
+Additionally you can define the relevance of each
+product's field individually and specify fuziness, search operators and type of search to be performed. So a product
+matching a search term perfectly will get a better ranking than a product where the search term needs to substitute a letter.
+Products matching multiple search terms will get a better ranking than products matching just a few words. And a product
+where the search term matches manufacturer as well as product name will get a better ranking than products only matching
+one of both.
+
+
+
+
+### Boosting
+Usually you want to boost certain groups of items. In addition to the relevance system, you can boost items matching
+certain criteria, e.g. topseller items, items from certain manufacturers or categories etc. Of course custom attributes / free
+text fields are also supported.
+
+
+
+### Profiles
+Profiles help you to organize sets of configuration: You can have different profiles for different shops or even prepare
+configurations for certain promotions and activate them with just a single mouse click.
+
+
diff --git a/source/shopware-enterprise/search/index.html b/source/shopware-enterprise/search/index.html
new file mode 100755
index 0000000000..a8079f3ce8
--- /dev/null
+++ b/source/shopware-enterprise/search/index.html
@@ -0,0 +1,43 @@
+---
+layout: default
+title: Enterprise Search
+github_link: search/index.html
+indexed: true
+menu_title: Enterprise Search
+group: Shopware Enterprise
+menu_order: 20
+menu_style: bullet
+menu_chapter: true
+---
+
+
+
+