Page History

                                            
  Welcome to the Symfony2 bundle generator  
                                            


Your application code must be written in bundles. This command helps
you generate them easily.

Each bundle is hosted under a namespace (like Acme/Bundle/BlogBundle).
The namespace should begin with a "vendor" name like your company name, your
project name, or your client name, followed by one or more optional category
sub-namespaces, and it should end with the bundle name itself
(which must have Bundle as a suffix).

See http://symfony.com/doc/current/cookbook/bundles/best_practices.html#index-1 for more
details on bundle naming conventions.

Use / instead of \  for the namespace delimiter to avoid any problem.

Bundle namespace: eZ/Publish/Bundles/CookbookBundle

In your code, a bundle is often referenced by its name. It can be the
concatenation of all namespace parts but it's really up to you to come
up with a unique name (a good practice is to start with the vendor name).
Based on the namespace, we suggest eZPublishBundlesCookbookBundle.

Bundle name [eZPublishBundlesCookbookBundle]: 

The bundle can be generated anywhere. The suggested default directory uses
the standard conventions.

Target directory [.../ezpublish5/src]: 

Determine the format to use for the generated configuration.

Configuration format (yml, xml, php, or annotation) [annotation]: yml

To help you get started faster, the command can generate some
code snippets for you.

Do you want to generate the whole directory structure [no]? yes

                             
  Summary before generation  
                             

You are going to generate a "eZ\Publish\Bundles\CookbookBundle\eZPublishBundlesCookBookBundle" bundle
in ".../ezpublish5/src/" using the "yml" format.

Do you confirm generation [yes]? yes

                     
  Bundle generation  
                     

Generating the bundle code: OK
Checking that the bundle is autoloaded: OK
Confirm automatic update of your Kernel [yes]? yes  
Enabling the bundle inside the Kernel: OK
Confirm automatic update of the Routing [yes]? yes
Importing the bundle routing resource: OK

                                               
  You can now start using the generated code!  
                                               

<?php
/**
 * File containing the CookBookCommand class.
 *
 * @copyright Copyright (C) 2012 eZ Systems AS. All rights reserved.
 * @license http://www.gnu.org/licenses/gpl-2.0.txt GNU General Public License v2
 * @version //autogentag//
 */
namespace eZ\Publish\Bundles\CookBookBundle\Command;

use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;

class CookBookCommand extends ContainerAwareCommand
{
    /**
     * This method override configures on input argument for the content id
     */
    protected function configure()
    {
        $this->setName( 'cookbook:run' )->setDefinition(
            array(
                new InputArgument( 'contentId', InputArgument::REQUIRED, 'An existing content id' )
            )
        );
    }

    /**
     * execute the command
     * @param InputInterface $input
     * @param OutputInterface $output
     */
    protected function execute( InputInterface $input, OutputInterface $output )
    {
        // fetch the input argument
        $contentId = $input->getArgument( 'contentId' );

        // get the repository from the di container
        $repository = $this->getContainer()->get( 'ezpublish.api.repository' );

        // get the content service from the repsitory
        $contentService = $repository->getContentService();

        try
        {
            // print out the content info for the given content id
            print_r( $contentService->loadContentInfo( $contentId ) );
        }
        catch( \eZ\Publish\API\Repository\Exceptions\NotFoundException $e )
        {
            // if the id is not found
            $output->writeln( "No content with id $contentId" );
        }
        catch( \eZ\Publish\API\Repository\Exceptions\UnauthorizedException $e )
        {
            // not allowed to read this content
            $output->writeln( "Anonymous users are not allowed to read content with id $contentId" );
        }
    }
}

        $contentTypeService = $repository->getContentTypeService();
        try
        {
            // instanciate a create struct
            $groupCreate = $this->contentTypeService->newContentTypeGroupCreateStruct($groupIdentifier);
            // call service method
            $contentTypeGroup =  $this->contentTypeService->createContentTypeGroup( $groupCreate );
            // print out the group
            print_r($contentTypeGroup);
        }
        catch( \eZ\Publish\API\Repository\Exceptions\UnauthorizedException $e )
        {
            // react on permission denied
            $output->writeln($e->getMessage());
        }
        catch( \eZ\Publish\API\Repository\Exceptions\ForbiddenException $e )
        {
            // react on identifier already exists
            $output->writeln($e->getMessage());
        }

        // get the user service from the repository
		$userService = $repository->getUserService();
        // load user by credentials
        $user = $userService->loadUserByCredentials($user,$password);
        // set user in repository
        $repository->setCurrentUser($user);

        // get content type service from repository
        $contentTypeService = $repository->getContentTypeService();
        // load the content type group
        try
        {
            $contentTypeGroup = $contentTypeService->loadContentTypeGroupByIdentifier($groupIdentifier);
        }
        catch(\eZ\Publish\API\Repository\Exceptions\NotFoundException $e)
        {
            $output->writeln("content type group with identifier $groupIdentifier not found");
            return;
        }
        // instanciate a ContentTypeCreateStruct with the given content type identifier
        $contentTypeCreateStruct = $contentTypeService->newContentTypeCreateStruct($contentTypeIdentifier );
        // the main language code for names and description
        $contentTypeCreateStruct->mainLanguageCode = 'eng-GB';
        // the name schema for generating the content name by using the title attribute
        $contentTypeCreateStruct->nameSchema = '<title>';
        // set names for the content type
        $contentTypeCreateStruct->names = array(
                'eng-GB' => $contentTypeIdentifier . 'eng-GB',
                'ger-DE' => $contentTypeIdentifier . 'ger-DE',
        );
        // set description for the content type
        $contentTypeCreateStruct->descriptions = array(
                'eng-GB' => 'Description for ' . $contentTypeIdentifier . 'eng-GB',
                'ger-DE' => 'Description for ' . $contentTypeIdentifier . 'ger-DE',
        );
        /********************** add fields ***************************************/
        // add a title field
        $titleFieldCreateStruct = $contentTypeService->newFieldDefinitionCreateStruct('title', 'ezstring');
        // set names and description for display
        $titleFieldCreateStruct->names = array('eng-GB' => 'Title','ger-DE' => 'Titel',);
        $titleFieldCreateStruct->descriptions = array('eng-GB' => 'The Title','ger-DE' => 'Der Titel');
        // set an group for the field
        $titleFieldCreateStruct->fieldGroup = 'content';
        // set position inside the content type
        $titleFieldCreateStruct->position = 1;
        // enable translation
        $titleFieldCreateStruct->isTranslatable = true;
        // require this field to set on content creation
        $titleFieldCreateStruct->isRequired = true;
        // enabled to find field via content search
        $titleFieldCreateStruct->isSearchable = true;
        // add field definition to content create struct
        $contentTypeCreateStruct->addFieldDefinition( $titleFieldCreateStruct );
        // add a body field
        $bodyFieldCreate = $contentTypeService->newFieldDefinitionCreateStruct('body', 'ezstring');
        // set names and description for display
        $bodyFieldCreate->names = array('eng-GB' => 'Body','ger-DE' => 'Text');
        $bodyFieldCreate->descriptions = array('eng-GB' => 'Description for Body','ger-DE' => 'Beschreibung Text');
        $bodyFieldCreate->fieldGroup = 'content';
        $bodyFieldCreate->position = 2;
        $bodyFieldCreate->isTranslatable = true;
        $bodyFieldCreate->isRequired = true;
        $bodyFieldCreate->isSearchable = true;
        // add field definition to content create struct
        $contentTypeCreateStruct->addFieldDefinition( $bodyFieldCreate );
        // set the content type group for the content type
        $groups = array($contentTypeGroup);
        // start a transaction
        $repository->beginTransaction();
        try
        {
            // create the content type - the returned content type is in status DRAFT
            $contentTypeDraft = $contentTypeService->createContentType($contentTypeCreateStruct,$groups);
            // publish the content type draft
            $contentTypeService->publishContentTypeDraft($contentTypeDraft);
            // commit the transaction
            $repository->commit();
        }
        catch( \eZ\Publish\API\Repository\Exceptions\UnauthorizedException $e )
        {
            // react on permission denied
            $output->writeln($e->getMessage());
            $repository->rollback();
        }
        catch( \eZ\Publish\API\Repository\Exceptions\ForbiddenException $e )
        {
            // react on identifier already exists
            $output->writeln($e->getMessage());
        }
        catch( \Exception $e )
        {
            $output->writeln($e->getMessage());
            $repository->rollback();
        }
    }

        // get the content service from the repository
        $contentService = $repository->getContentService();
        // get the location service from the repsitory
        $locationService = $repository->getLocationService();
        // get the user service from the repsitory
        $contentTypeService = $repository->getContentTypeService();
        try
        {
            // load the content type with identifier
            $contentType = $contentTypeService->loadContentTypeByIdentifier($contentTypeIdentifier);
            // instanciate a location create struct
            $locationCreateStruct = $locationService->newLocationCreateStruct($parentLocationId);
            // instanciate a content creation struct
            $contentCreateStruct = $contentService->newContentCreateStruct($contentType, 'eng-GB');
            // set title field
            $contentCreateStruct->setField('title',$title);
            // set body field
            $contentCreateStruct->setField('body', $body);
            // create a draft using the content and location create structs
            $draft = $contentService->createContent($contentCreateStruct, array($locationCreateStruct));
            // publish the content draft
            $content = $contentService->publishVersion($draft->versionInfo);
            // print out the content
            print_r($content);
        }
        catch(\eZ\Publish\API\Repository\Exceptions\NotFoundException $e)
        {
            // react on content type or location not found
            $output->writeln($e->getMessage());
        }
        catch(\eZ\Publish\API\Repository\Exceptions\InvalidArgumentException $e)
        {
            // react on remote id exists already
            $output->writeln($e->getMessage());
        }
        catch(\eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException $e)
        {
            // react on a field is not valid
            $output->writeln($e->getMessage());
        }
        catch(\eZ\Publish\API\Repository\Exceptions\ContentValidationException $e)
        {
            // react on a required field is missing or empty
            $output->writeln($e->getMessage());
        }
    }

        try
        {
            // load the content info for the given id
            $contentInfo = $contentService->loadContentInfo($contentId);
            // create a draft from the current published version
            $contentDraft = $contentService->createContentDraft($contentInfo);
            // instanciate a content update struct
            $contentUpdateStruct = $contentService->newContentUpdateStruct();
            // set language for new version
            $contentUpdateStruct->initialLanguageCode = 'eng-GB';
            // set fields
            $contentUpdateStruct->setField( 'title', $newtitle );
            $contentUpdateStruct->setField( 'body', $newbody );
            // update draft
            $contentDraft = $contentService->updateContent($contentDraft->versionInfo, $contentUpdateStruct);
            // publish draft
            $content = $contentService->publishVersion($contentDraft->versionInfo);
            print_r($content);
        }
        catch(\eZ\Publish\API\Repository\Exceptions\NotFoundException $e)
        {
            // react on content type not found
            $output->writeln($e->getMessage());
        }
        catch(\eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException $e)
        {
            // react on a field is not valid
            $output->writeln($e->getMessage());
        }
        catch(\eZ\Publish\API\Repository\Exceptions\ContentValidationException $e)
        {
            // react on a required field is missing or empty
            $output->writeln($e->getMessage());
        }
    }

            // set language for new version
            $contentUpdateStruct->initialLanguageCode = $newLanguage;
            // set fields
            $contentUpdateStruct->setField( 'title', $newtitle );
            $contentUpdateStruct->setField( 'body', $newbody );

            // set one language for new version
            $contentUpdateStruct->initialLanguageCode = 'fra-FR';
			// set fields for german - here the language has to be passed in third argument
            $contentUpdateStruct->setField( 'title', $newgermantitle, 'ger-DE' );
            $contentUpdateStruct->setField( 'body', $newgermanbody, 'ger-DE' );
            // set fields for french
            $contentUpdateStruct->setField( 'title', $newfrenchtitle);
            $contentUpdateStruct->setField( 'body', $newfrenchbody);