symfony2

Social networking web application part1

2011-12-02T08:29:00.000-08:00

In this tutorial we are going to create a web application having social networking functionality. For this we have user registration, user profile, web forms, friends list, photo album, message service.

Back again....

2011-12-02T08:13:00.000-08:00

After a long time of absence, i going to make a series of tutorial based on some of the common applications with advanced concepts. within these days symfony2 become very robust and powerful framework. i'm considering an audience, which had minimum knowledge about symfony framework..

First step

2011-02-14T09:23:00.000-08:00

In this tutorial we understand about the file structure of our web app.

Before that
    1.obtain a new copy of symfony framework from here.
    2.make a new folder inside your server and named as "webapp".
    3.create a folder structure like below:

www/ <- your web root directory
    webapp/ 
        app/
            cache/
            config/
            logs/
        src/
            webapps/
                HelloBundle/
                    Controller/
                    Resources/
        vendor/
                   
            
        web/       4. place your unarchived symfony inside the vendor folder.  

sugarbox in brief

2010-08-27T00:50:00.000-07:00

This post is the summary of the previous three tutorial posts.

1. download the latest sugarbox from here.. (or you can use git clone command)
2. upload to your server, initially set permission to all
3.check whether you have all the required items(go to your browser http://localhost/sugarbox/web/check.php)
4.In terminal cd to your sugarbox directory
5.in terminal type this
php blog/console -s
6.you'll get a symfony environment. to see all the available commands type this:

list

7.to create database as configured in blog/config/config.yml type this in terminal:

doctrine:database:create

8.we create the Entity model in src/Application/BlogBundle/Entity/Blog.php doctrine take this and convert to database schema. to create this(schema) type

doctrine:schema:create

9.next, create repositories for entity

doctrine:generate:repositories

10.the above will create BlogBundle/Entity/BlogRepositories.php

After finishing the above steps check in your browser.

http://localhost/sugarbox/web/index.php

To create new blog post :

http://localhost/sugarbox/web/index.php/blog/new

sugarbox part 3

2010-08-23T22:26:00.000-07:00

routing.yml

homepage:
pattern: /
defaults: { _controller: FrameworkBundle:Default:index }

blog:
resource: BlogBundle/Resources/config/routing.yml

From the first line(homepage), it's clear that, the URL http://localhost/sugarbox/web/index.php/ goes to the 'Default' controller in 'FrameworkBundle' and point to the 'index' action. It shows this in your browser:

Congratulations!
You have successfully created a new Symfony 2 application.
So check it yourself. You can give any name instead of homepage.

The second(blog), point to another routing file inside src/Application/BlogBundle/Resources/config/routing.yml

it goes like this:

blog:
pattern: /blog
defaults: { _controller: BlogBundle:Blog:index }

blog_new:
pattern: /blog/new
defaults: { _controller: BlogBundle:Blog:new }

so when a request like this http://localhost/sugarbox/web/index.php/blog points to 'Blog' controller in 'BlogBundle' and 'index' action. This outputs this:

Blog Application
Hello Blog index!

Http://localhost/sugarbox/web/index.php/blog/new points to 'Blog' controller in 'BlogBundle' and 'new' action. This outputs this:

Beware: we can't save the post now. So by clicking submit button make no sense!

In your terminal go to sugarbox directory
$ cd sugarbox
symfony2 has inbuilt CLI. We now initiate thie
$ php blog/console -s
this will display this:

to list all commands

Symfony > list
Symfony displays this:

Now we are going to create database as configured in config.yml
initialy, we drop the database(todo), if there any present.
Symfony > doctrine:database:drop
Dropped database for connection named todo
Symfony > doctrine:database:create
Created database for connection named todo

to check, go to your phpmyadmin. You'll see todo database(empty)
To create tables according to schema created in BlogBundle/Entity/Blog.php.

first, we create repositories
Symfony > doctrine:generate:repositories
Generating entity repositories for "BlogBundle"

> generating Bundle\BlogBundle\Entity\BlogRepository

now we create the schema
Symfony > doctrine:schema:create

to check, go to phpmyadmin. There is a table named 'posts'

sugarbox part2

2010-08-23T10:52:00.001-07:00

autoload.php

$vendorDir = __DIR__.'/vendor';

require_once $vendorDir.'/symfony/src/Symfony/Framework/UniversalClassLoader.php';

use Symfony\Framework\UniversalClassLoader;

$loader = new UniversalClassLoader();
$loader->registerNamespaces(array(
    'Symfony'                    => $vendorDir.'/symfony/src',
    'Application'                => __DIR__,
    'Bundle'                     => __DIR__,
    'Doctrine\\Common'           => $vendorDir.'/doctrine-common/lib',
    'Doctrine\\DBAL\\Migrations' => $vendorDir.'/doctrine-migrations/lib',
    'Doctrine\\ODM\\MongoDB'     => $vendorDir.'/doctrine-mongodb/lib',
    'Doctrine\\DBAL'             => $vendorDir.'/doctrine-dbal/lib',
    'Doctrine'                   => $vendorDir.'/doctrine/lib',
    'Zend'                       => $vendorDir.'/zend/library',
));
$loader->registerPrefixes(array(
    'Swift_' => $vendorDir.'/swiftmailer/lib/classes',
    'Twig_' => $vendorDir.'/twig/lib',
));
$loader->register();

Now we good to create class for our own application-blog. All the php files related to application goes to corresponding application bundles. In this case inside BlogBundle.

Inside BlogBundle you'll see these folders:

Controller

Entity

Resources

and this file BlogBundle.php

open BlogBundle.php

BlogBundle.php

namespace Application\BlogBundle;

use Symfony\Framework\Bundle\Bundle;

class BlogBundle extends Bundle
{
}

All your controller classess goes into Controller folder.

Model classess goes into Entity folder

All layouts, views, custom application routes goes into Resources folder.

Ok. let's begin with Model classess. In this tutorial we are using doctrine 2 as ORM. You can read more about doctrine 2 here. S2 also supports propel. So you have download the doctrine 2 from here.

In doctrine2 we can create schema from three files: plain php(annotation), YAML, xml. We go for annotation type, bcoz it has more advantage. In Entity folder create a php file – Blog.php

Blog.php

declare(ENCODING = 'utf-8');
namespace Application\BlogBundle\Entity;

use Symfony\Component\Validator\Mapping\ClassMetadata;
use Symfony\Component\Validator\Constraints;

/**
* @Entity(repositoryClass="Bundle\BlogBundle\Entity\BlogRepository")
* @Table(name="posts")
* @HasLifecycleCallbacks
*/

class Blog
{
    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addPropertyConstraint('title', new Constraints\NotBlank());
        $metadata->addPropertyConstraint('title', new Constraints\MinLength(5));
        $metadata->addGetterConstraint('description', new Constraints\NotNull());
    }

        /**
         * @Id @Column(type="integer")
         * @GeneratedValue(strategy="AUTO")
         */
        private $id;
   /**
   *
   * @Column(type="string", length=250)
   *
   */
   protected $title;

   /**
   *
   *
   * @column(type="string", length=250)
   */
   protected $description;



   public function getId()
        {
            return $this->id;
        }


   public function setTitle($title) {
       $this->title = $title;
   }


   public function getTitle() {
       return $this->title;
   }


   public function setDescription($description) {
       $this->description = $description;
   }


   public function getDescription() {
       return $this->description;
   }



}

Doctrine ORM change the above class into schema and create database. For this we use CLI(command line interface). To setup doctrine and configure our application we've to write blog/config/config.yml .

let's take a look:

kernel.config:
    charset:       UTF-8
    error_handler: null

web.config:
    router:     { resource: "%kernel.root_dir%/config/routing.yml" }
    validation: { enabled: true, annotations: true }

web.templating:
    escaping:       htmlspecialchars

doctrine.dbal:
connections:
    default:
      driverClass: Doctrine\DBAL\Driver\PDOMySql\Driver #
      dbname:   todo
      user:     root
      password: admin
doctrine.orm: ~

in s2, you can create multiple database connection. here use single (default) connection. you can give the database name, mysql username, password .

[continue]

note: these tutorials are updated frequently. i know there are so many typos and errors are there. please comment those here. if you have any doubts disscuss here.

sugarbox

2010-08-23T10:35:00.000-07:00

In this application we are using latest symfony2 code. There are so many different changes are made in this latest version. You can get the original symfony2 code from http://github.com/symfony

So we have to make a custom application. Sugarbox can be downloaded from here.

The steps:

Download sugarbox from above mentioned URL
unzip and upload to server root

This the final structure.

symfony2 basic:

web/index.php is front controller. It's the only php file that access from a browser. So all your php files are well protected. Index.php accepts the HTTP request from the browser and sends it to the application. S2 is kernal based application. Kernal is the heart of all s2 operations. So to create a s2 app we need to create sub class of this kernal (abstract) class. This is placed under blog folder. So create a php file called BlogKernel.php. The naming is very important. Create another folder 'config' inside blog main folder. All configuration files and routing files are placed under config folder. For this tutorial we not go for caching and logging mechanism. We can back here after finishing this tutorial.

In s2, all are in the form of bundles. 'Bundles are first class citizen'. So our application bundle(BlogBundle) will place inside Application folder. Ok. So let's do some coding.

Front Controller

Open web/index.php file using your favourite text editor.

require_once __DIR__.'/../blog/BlogKernel.php';

$kernel = new BlogKernel('dev', true);
$kernel->handle()->send();

These are the only lines that goes into index.php. Here we create a new instance of our Blogkernal class which we will create soon. In $kernel = new BlogKernel('prod', false); line, 'prod' and 'false' are two arguments that pass to the blog application. 'prod' means setup the production environment and false means no debugging. Instead of 'prod' you can give 'dev' for development. In development environment you need debugging on – so instead of 'false' we write 'true'.

Application kernel

Ok lets move to BlogKernel.php.

require_once __DIR__.'/../src/autoload.php';

use Symfony\Framework\Kernel;
use Symfony\Component\DependencyInjection\Loader\LoaderInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;

class BlogKernel extends Kernel
{
    public function registerRootDir()
    {
        return __DIR__;
    }

    public function boot()
    {
        Symfony\Component\OutputEscaper\Escaper::markClassesAsSafe(array(
            'Symfony\Component\Form\Form',
            'Symfony\Component\Form\Field'
        ));

        return parent::boot();
    }

    public function registerBundles()
    {
        $bundles = array(
            new Symfony\Framework\KernelBundle(),
            new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
            new Symfony\Bundle\ZendBundle\ZendBundle(),
            new Symfony\Bundle\SwiftmailerBundle\SwiftmailerBundle(),
            new Symfony\Bundle\DoctrineBundle\DoctrineBundle(),
            //new Symfony\Bundle\DoctrineMigrationsBundle\DoctrineMigrationsBundle(),
            //new Symfony\Bundle\DoctrineMongoDBBundle\DoctrineMongoDBBundle(),
            //new Symfony\Bundle\PropelBundle\PropelBundle(),
            //new Symfony\Bundle\TwigBundle\TwigBundle(),
            new Application\BlogBundle\BlogBundle(),
        );

        if ($this->isDebug()) {
        }

        return $bundles;
    }

    public function registerBundleDirs()
    {
        return array(
            'Application'     => __DIR__.'/../src/Application',
            'Bundle'          => __DIR__.'/../src/Bundle',
            'Symfony\\Bundle' => __DIR__.'/../src/vendor/symfony/src/Symfony/Bundle',
        );
    }
//to load config files
    public function registerContainerConfiguration(LoaderInterface $loader)
    {
        // use YAML for configuration
        // comment to use another configuration format
        $container = new ContainerBuilder();
        $loader->load(__DIR__.'/config/config_'.$this->getEnvironment().'.yml');
        $container->setParameter('validator.message_interpolator.class', 'Application\\BlogBundle\\Validator\\NoValidationXliffMessageInterpolator');
        return $container;

        // uncomment to use XML for configuration
        //$loader->load(__DIR__.'/config/config_'.$this->getEnvironment().'.xml');

        // uncomment to use PHP for configuration
        //$loader->load(__DIR__.'/config/config_'.$this->getEnvironment().'.php');
    }
}

i think the above is self explanatory.

Now we go to the autoload.php.

[continue]

symfony2 PR3 released

2010-08-22T07:50:00.000-07:00

Today symfony2 PR3 sandbox released. Several errors and bugs are fixed. I'm experienced so much errors when i progress through these tutorials. so i stop writing tutorials for a while. Sorry for not updating this blog. Now i'm back with interesting new stuff. please keep in touch .

symfony sugarbox

2010-08-06T00:35:00.000-07:00

please see new symfony 2 tutorial here.

Mongodb : Getting wet

2010-08-05T08:24:00.000-07:00

Mongodb is another database system using the features of RDBMS and key-value stores. It's a non-sql database. All the results display in json format. MongoDB is a scalable document database, which is also open source. In MongoDB there are no tables and rows. You have collections and documents instead. And collections can contain any type of document, it is not limited by the columns or fields like a table. i.e. Mongodb is schemaless. So that you can update with new fields,

without altering the entire structure. In the case of RDBMS you must change the schema.

Mongodb can be download from here: Downloads

Mongodb installation for unix : Installation

In this post i'm writing about symfony2+doctrine2-ODM+mongodb

doctrine2-ODM (Doctrine MongoDB Object Document Mapper). You can read more from here.

There is a blog tutorial in here.

sandbox configuration

2010-08-05T01:13:00.000-07:00

All the configuration files goes into hello/config folder. The file structure is given below.

config folder

the configuration files written in yaml format. doctrine configurations are done in config.yml. you can do seperate configuration for dev, prod, even for testing.

doctrine configuration:(in config.yml)

doctrine.dbal:
   driver: PDOMySql
   dbname: todo
   user: root
   password: admin
doctrine.orm: ~

routing.yml

homepage:
   pattern: /
   defaults: { _controller: FoundationBundle:Default:index }

hello:
   resource: HelloBundle/Resources/config/routing.yml

The Architecture

2010-08-04T02:06:00.000-07:00

Today we going to understand the directory structure, basic routing,controller-view actions etc.

This is the basic directory structure of symfony 2 sandbox.

Introduction

2010-08-03T09:15:00.000-07:00

This blog is dedicated to symfony2 web development. i intend to post a series of tutorials for using symfony2 in real web apps.

There is a support group here
My codes are here