WIP rewrite quick tour to sandbox

Author: dbu

_images/quick_tour/big-picture-new-page.png

@@ -32,20 +32,23 @@ The bundles provided by the Symfony CMF can work together, but they are also
 able to work standalone. This means that you don't need to add all bundles, you
 can decide to only use one of them (e.g. only the RoutingBundle or the SeoBundle).
 
-Downloading the Symfony CMF Standard Edition
---------------------------------------------
+Downloading the Symfony CMF Sandbox
+-----------------------------------
 
-When you want to start using the CMF for a new project, you can download the
+To explore the CMF, it is best to download the Symfony CMF Sandbox. The sandbox
+contains demonstrations for many of the CMF features and is a good playground
+to familiarize yourself with the CMF.
+
+When you want to start an actual project with the CMF, best download the
 Symfony CMF Standard Edition. The Symfony CMF Standard Edition is similar to
 the `Symfony Standard Edition`_, but contains and configures essential Symfony
-CMF bundles. It also adds a very simple bundle to show some of the basic
-Symfony CMF features.
+CMF bundles.
 
-The best way to download the Symfony CMF Standard Edition is using Composer_:
+The best way to download the Symfony CMF Sandbox is using Composer_:
 
 .. code-block:: bash
 
-    $ composer create-project symfony-cmf/standard-edition cmf
+    $ composer create-project symfony-cmf/sandbox cmf-sandbox
 
 Setting up the Database
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -60,11 +63,12 @@ extension. After that, run these commands:
 
 .. code-block:: bash
 
+    $ cd cmf-sandbox
+    $ cp app/config/phpcr_doctrine_dbal.yml.dist app/config/phpcr.yml
     $ php bin/console doctrine:database:create
     $ php bin/console doctrine:phpcr:init:dbal --force
     $ php bin/console doctrine:phpcr:repository:init
-    # TODO there are no fixtures in the standard edition anymore...
-    $ php bin/console doctrine:phpcr:fixtures:load
+    $ php bin/console doctrine:phpcr:fixtures:load -n
 
 .. tip::
 
@@ -87,9 +91,11 @@ The Request Flow
     inside the Symfony project, if that is not already the root folder of your
     server).
 
-Now, the Standard Edition is ready to use. Navigate to the homepage
+Now, the Sandbox is ready to use. Navigate to the homepage
 (``http://localhost:8000/``) to see the demo:
 
+redo image with current sandbox
+
 .. image:: ../_images/quick_tour/big-picture-home.png
 
 You see that we already have a complete website in our demo. Let's take a
@@ -165,33 +171,24 @@ this template.
 A view also uses a Menu, provided by the KnpMenuBundle_, and it can have
 integration with Create.js, for live editing.
 
-Adding a New Page
------------------
-
-Now you know the request flow, you can start adding a new page. In the Symfony
-CMF Standard Edition, the data is stored in data files, which are loaded when
-executing the ``doctrine:phpcr:fixtures:load`` command. To add a new page, edit
-one of the data files located in the
-``src/AppBundle/Resources/data`` directory:
-
-TODO: replace example, simplecms bundle is not maintained anymore
-
-.. code-block:: yaml
-
-    # src/AppBundle/Resources/data/pages.yml
-    Symfony\Cmf\Bundle\SimpleCmsBundle\Doctrine\Phpcr\Page:
-        # ...
+The Fixtures
+------------
 
-        quick_tour:
-            id: /cms/simple/quick_tour
-            label: "Quick Tour"
-            title: "Reading the Quick Tour"
-            body: "I've added this page while reading the quick tour"
+Now you know the request flow, you can start editing content. While the normal
+usage will be to edit content through a web interface, the CMF sandbox also
+supports  loading content from static files. This is mainly useful for testing
+purposes.
 
-After this, you need to run the ``doctrine:phpcr:fixtures:load`` to reflect
-the changes on the database and after refreshing, you can see your new page!
+The fixtures are loaded with the ``doctrine:phpcr:fixtures:load`` command. To
+edit the home page, edit the first entry in
+``src/AppBundle/Resources/data/page.yml`` to say something different. Then, run
+the ``doctrine:phpcr:fixtures:load`` command to get the changes into the
+content repository. After refreshing the browser, you can see your
+modifications!
 
-.. image:: ../_images/quick_tour/big-picture-new-page.png
+Don't worry, editing fixture files is only done for developing and testing. The
+CMF comes with a Sonata admin integration for convenient online editing, or you
+can build your own editing systems.
 
 Final Thoughts
 --------------

_images/quick_tour/the-model-new-page.png

@@ -23,7 +23,7 @@ data stored with PHPCR has a relationship with at least one other data: its
 parent. The inverse relation also exists, you can also get the children of a
 data element.
 
-Let's take a look at the dump of the tree of the Standard Edition you
+Let's take a look at the dump of the tree of the CMF Sandbox you
 downloaded in the previous chapter. Go to your directory and execute the
 following command:
 
@@ -36,30 +36,43 @@ The result will be the PHPCR tree:
 .. code-block:: text
 
     ROOT:
-      cms:
-        simple:
-          about:
-          contact:
-            map:
-            team:
-          quick_tour:
-          dynamic:
-          docs:
-          demo:
-          demo_redirect:
-          hardcoded_dynamic:
-          hardcoded_static:
-
-Each data is called a *node* in PHPCR. In this tree, there are 13 nodes and
-one ROOT node (created by PHPCR). You may have already seen the document you
-created in the previous section, it's called ``quick_tour`` (and it's path is
-``/cms/simple/quick_tour``). When using the SimpleCmsBundle, all nodes are
-stored in the ``/cms/simple`` path.
+        cms:
+            menu:
+                main:
+                    admin-item:
+                    projects-item:
+                        cmf-item:
+                    company-item:
+                        team-item:
+                ...
+            content:
+                home:
+                    phpcr_locale:en:
+                    phpcr_locale:fr:
+                    phpcr_locale:de:
+                    seoMetadata:
+                    additionalInfoBlock:
+                        child1:
+                ...
+            routes:
+                en:
+                    company:
+                        team:
+                        more:
+                    about:
+                ...
+
+Each data is called a *node* in PHPCR. Everything is attached under the ROOT
+node (created by PHPCR itself).
 
 Each node has properties, which contain the data. The content, title and label
-you set for your page are saved in such properties for the ``quick_tour``
+you set for your page are saved in such properties for the ``home``
 node. You can view these properties by adding the ``--props`` switch to the
-dump command.
+dump command:
+
+.. code-block:: bash
+
+    $ php bin/console doctrine:phpcr:node:dump --props /cms/content/home
 
 .. note::
 
@@ -74,20 +87,21 @@ Doctrine PHPCR-ODM
 The Symfony CMF uses the `Doctrine PHPCR-ODM`_ to interact with PHPCR.
 Doctrine allows a user to create objects (called *documents*) which are
 directly persisted into and retrieved from the PHPCR tree. This is similar to
-the Doctrine ORM used by the Symfony2 Framework, but then for PHPCR.
+the Doctrine ORM provided by default in the Symfony Standard Edition, but for
+PHPCR instead of SQL databases.
 
 Creating a Page with code
 -------------------------
 
 Now you know a little bit more about PHPCR and you know the tool to interact
-with it, you can start using it yourself. In the previous chapter, you created
-a page by using a yaml file which was parsed by the SimpleCmsBundle. This
-time, you'll create a page by doing it yourself.
+with it, you can start using it yourself. In the previous chapter, you edited
+a page by using a yaml file which was parsed by the fixture loader of the
+sandbox. This time, you'll create a page by doing it yourself.
 
 First, you have to create a new DataFixture to add your new page. You do this
 by creating a new class in the AppBundle::
 
-    // src/AppBundle/DataFixtures/PHPCR/LoadPageData.php
+    // src/AppBundle/DataFixtures/PHPCR/LoadQuickTourData.php
     namespace AppBundle\DataFixtures\PHPCR;
 
     use Doctrine\Common\Persistence\ObjectManager;
@@ -100,7 +114,7 @@ by creating a new class in the AppBundle::
         {
             // refers to the order in which the class' load function is called
             // (lower return values are called first)
-            return 10;
+            return 100;
         }
 
         public function load(ObjectManager $documentManager)
@@ -123,7 +137,10 @@ PHPCR. But first, you have to create a new Page document::
         }
 
         $page = new Page(); // create a new Page object (document)
-        $page->setName('new_page'); // the name of the node
+        $page->setName('quick-tour'); // the name of the node
+
+        vno sandbox übernehmen
+
         $page->setLabel('Another new Page');
         $page->setTitle('Another new Page');
         $page->setBody('I have added this page myself!');
@@ -133,16 +150,9 @@ Each document needs a parent. In this case, the parent should just be the root
 node. To do this, we first retrieve the root document from PHPCR and then set
 it as its parent::
 
-    // ...
     public function load(ObjectManager $documentManager)
     {
-        if (!$documentManager instanceof DocumentManager) {
-            $class = get_class($documentManager);
-            throw new \RuntimeException("Fixture requires a PHPCR ODM DocumentManager instance, instance of '$class' given.");
-        }
-
         // ...
-
         // get root document (/cms/simple)
         $simpleCmsRoot = $documentManager->find(null, '/cms/simple');
 
@@ -152,21 +162,46 @@ it as its parent::
 And at last, we have to tell the Document Manager to persist our Page
 document using the Doctrine API::
 
-    // ...
     public function load(ObjectManager $documentManager)
     {
-        if (!$documentManager instanceof DocumentManager) {
-            $class = get_class($documentManager);
-            throw new \RuntimeException("Fixture requires a PHPCR ODM DocumentManager instance, instance of '$class' given.");
-        }
-
         // ...
         $documentManager->persist($page); // add the Page in the queue
         $documentManager->flush(); // add the Page to PHPCR
     }
 
-Now you need to execute the ``doctrine:phpcr:fixtures:load`` command again and
-then you can visit your website again. You'll see your new page you added!
+Now you need to execute the ``doctrine:phpcr:fixtures:load`` command again.
+When dumping the nodes again, your new page should turn up under /cms/content.
+
+To actually see this page in the browser, we need a route::
+
+    public function load(ObjectManager $documentManager)
+    {
+        // ...
+        $route = new Route();
+        $routeRoot = $documentManager->find(null, '/cms/routes/en');
+        $route->setPosition($routeRoot, 'quick-tour');
+        $route->setContent($page);
+        $documentManager->persist($route);
+    }
+
+And we add a menu entry to link to this page, and flush the document manager
+at the end::
+
+    public function load(ObjectManager $documentManager)
+    {
+        $menu = new MenuNode();
+        $menu->setName('new_page');
+        $menu->setLabel('Quick Tour');
+        $menu->setContent($page);
+        $menuMain = $documentManager->find(null, '/cms/menu/main');
+        $menu->setParentDocument($menuMain);
+        $documentManager->persist($menu);
+
+        $documentManager->flush();
+    }
+
+Re-run the fixtures loading command and then refresh the web site. Your new
+page will be added, with a menu entry at the bottom of the menu!
 
 .. image:: ../_images/quick_tour/the-model-new-page.png