commands

git init
git status
git add .
git commit -m "Initial Rest api commit"
git remote add origin https://github.com/jojivijay/restapi.git
git remote -v
git push origin master
git log
git reflog
want to remove added url
git remote set-url origin https://github.com/jojivijay/fridayad-api.git
git remote rm origin
git remote add origin https://github.com/jojivijay/fridayad-api.git
git remote -v
git push origin master


grep -Rinw src/ -e 'consensu'
grep -Rinw ~/bin/ -e 'check_root'


sudo rm -rf var/cache/* var/logs/*
sudo chmod -R 777 var/cache var/logs
sudo php -d memory_limit=1000M bin/console cache:clear
sudo chmod -R 777 var/cache var/logs
sudo rm -rf var/cache/* var/logs/*
sudo chmod -R 777 var/cache var/logs
sudo chmod -R 777 var/cache var/logs
sudo -u nginx php -d memory_limit=1000M bin/console assets:install web --symlink
sudo -u nginx php -d memory_limit=1000M bin/console assetic:dump
sudo -u nginx php -d memory_limit=1000M bin/console cache:clear
sudo chmod -R 777 var/cache var/logs
sudo rm -rf var/cache/* var/logs/*
sudo chmod -R 777 var/cache var/logs
sudo chmod -R 777 var/cache var/logs


sudo rm -rf var/logs/*
sudo chmod -R 777 var/cache var/logs
sudo chmod -R 777 var/cache var/logs

sudo git config core.filemode false
sudo chmod -R 777 ../newfriday-ad/
sudo chown -R nginx:nginx ../newfriday-ad/
sudo git config core.filemode false
sudo chcon -R -t httpd_sys_content_rw_t ../newfriday-ad/
sudo chmod -R 777 ../newfriday-ad


sudo php -d memory_limit=1000M bin/console doctrine:schema:validate
sudo php -d memory_limit=1000M bin/console doctrine:schema:update --force
sudo chmod -R 777 var/cache var/logs
sudo rm -rf var/cache/* var/logs/*
sudo chmod -R 777 var/cache var/logs
sudo chmod -R 777 var/cache var/logs

git reflog --date=local

php bin/console debug:container



git init
 git remote add origin https://jojivijaykumar@bitbucket.org/fridaymediagroup/newfriday-ad.git
 git status
 git add README.md
 git commit -m "added readme file"
 git config --global user.name "Joji vijayakumar Namburi"
 git config --global user.email vijay.namburi@fridaymediagroup.com
 git commit --amend
 git push origin master
 git status
 vi .gitignore
 git status
 1git add .gitignore app/ bin/ cat_sql/ composer.json composer.lock data/ doc/ generate_cache.sh generate_sitemap.sh load.sh phpunit.xml.dist sitemap.sh sql_temp/ src/ test_load.sh tests/ var/ web/
git commit -m "first commit of symfony 3.4 upgrade"
 git push origin master
 git config core.filemode false
 git status
 

Signature

security:
    # https://symfony.com/doc/current/security.html#where-do-users-come-from-user-providers
    providers:
        in_memory: { memory: ~ }
        api_key_user_provider:
            id: App\Security\ApiUserProvider
    firewalls:
        dev:
            pattern: ^/(_(profiler|wdt)|css|images|js)/
            security: false
           
        api_firewall:
            pattern: ^/(.*)
            stateless: true
            simple_preauth:
                authenticator: App\Security\ApiAuthenticator
            provider: api_key_user_provider
        # main:
            # anonymous: true
           

            # activate different ways to authenticate

            # http_basic: true
            # https://symfony.com/doc/current/security.html#a-configuring-how-your-users-will-authenticate

            # form_login: true
            # https://symfony.com/doc/current/security/form_login_setup.html

    # Easy way to control access for large sections of your site
    # Note: Only the *first* access control that matches will be used
    access_control:
        # - { path: ^/admin, roles: ROLE_ADMIN }
        # - { path: ^/profile, roles: ROLE_USER }




<?php
namespace App\Security;

use Symfony\Component\Security\Http\Authentication\SimplePreAuthenticatorInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authentication\Token\PreAuthenticatedToken;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use App\Security\ApiUserProvider;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Doctrine\ORM\EntityManager;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\HttpException;

class ApiAuthenticator implements SimplePreAuthenticatorInterface
{
    /* protected $userProvider;
    protected $em;
    protected $container; */

    /* public function __construct(ApiUserProvider $userProvider, EntityManager $em, ContainerInterface $container)
    {
        $this->userProvider = $userProvider;
        $this->em = $em;
        $this->container = $container;
    } */

    public function createToken(Request $request, $providerKey)
    {
        $route = $request->get("_route");
        if((strpos($route, 'nelmio_api_doc_index') !== false) || $route == "app.swagger" || $route == "app.swagger_ui") {
            $token = "anonymous";
        }else{
            $signature = $request->headers->get('Signature');
            $timeStamp = $request->headers->get('Timestamp');
           
            $token = $request->headers->get('Token');
           
            if (!isset($token)) {
                $token = "anonymous";
            }
           
            if (!$signature || !$timeStamp) {
                throw new HttpException(Response::HTTP_BAD_REQUEST, "Missing Mandatory  Parameters in header");
            }
           
            $privateKey = '765022d2f23b3ae5b24abcc6a165449dff002ee16080b232cb4119a449e4aa70';// $this->container->getParameter('app_private_key');
            if(!$privateKey) {
                throw new HttpException(Response::HTTP_BAD_REQUEST, "Missing PrivateKey Parameters");
            }
           
            $generatedSignature = $this->generateSignature($privateKey, $timeStamp);
            if($signature != $generatedSignature) {
                throw new HttpException(Response::HTTP_BAD_REQUEST, "Invalid Signature");
            }
        }
       
        return new PreAuthenticatedToken(
                'anon.',
                $token,
                $providerKey
        );
    }

    public function authenticateToken(TokenInterface $token, UserProviderInterface $userProvider, $providerKey)
    {
        $apiKey = $token->getCredentials();
       
        if (!$userProvider instanceof ApiUserProvider) {
            throw new \InvalidArgumentException(
                sprintf(
                    'The user provider must be an instance of ApiKeyUserProvider (%s was given).',
                    get_class($userProvider)
                    )
                );
        }
        $user = $userProvider->loadUserByUsername($apiKey);

        return new PreAuthenticatedToken(
                $user,
                $apiKey,
                $providerKey,
                $user->getRoles()
        );
    }

    public function supportsToken(TokenInterface $token, $providerKey)
    {
        return $token instanceof PreAuthenticatedToken && $token->getProviderKey() === $providerKey;
    }
   
    public function generateSignature($privateKey, $timeStamp)
    {
        return urlencode(base64_encode(hash_hmac('sha256', $timeStamp.$privateKey, $privateKey, true)));
    }
}




<?php
namespace App\Security;

use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Core\User\User;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\HttpFoundation\Request;

class ApiUserProvider implements UserProviderInterface
{
    private $em;
   
    public function __construct(EntityManagerInterface $em)
    {
        $this->em = $em;
    }

    public function loadUserByUsername($username)
    {
        if($username == 'anonymous') {
            return new User(
                    $username,
                    null,
                    array('IS_AUTHENTICATED_ANONYMOUSLY')
            );
        }
       
        $request = Request::createFromGlobals();
        $api = explode("/", $request->getPathInfo());
        if (isset($api) && $api['1'] == "customerapi") {
            return $this->em->getRepository('AppBundle:CustomerReg')->loadUserByAuthToken($username);
        }
       
    }

    public function refreshUser(UserInterface $user)
    {
        throw new UnsupportedUserException();
    }

    public function supportsClass($class)
    {
        return ('Symfony\Component\Security\Core\User\User' === $class || 'AppBundle\Entity\CustomerReg' === $class);
    }
}

symfony 4.2 necessary lib for REST API's

composer -v

composer clearcache

composer install

composer create-project symfony/skeleton myapi

/usr/local/bin/composer require server --dev
/usr/local/bin/composer require security-check --dev
/usr/local/bin/composer require profiler --dev
/usr/local/bin/composer require maker-bundle --dev
/usr/local/bin/composer require symfony/test-pack --dev

/usr/local/bin/composer guzzlehttp/guzzle
/usr/local/bin/composer require annotations
/usr/local/bin/composer require orm-pack
/usr/local/bin/composer require jms/serializer-bundle
/usr/local/bin/composer require symfony/serializer
/usr/local/bin/composer require friendsofsymfony/rest-bundle
/usr/local/bin/composer require security-bundle
/usr/local/bin/composer require form
/usr/local/bin/composer require validator
/usr/local/bin/composer require doctrine/annotations
/usr/local/bin/composer require translation
/usr/local/bin/composer require mailer
/usr/local/bin/composer require monolog
/usr/local/bin/composer require asset
/usr/local/bin/composer require twig

fos_rest:
    disable_csrf_role: ROLE_API
    param_fetcher_listener: true
    view:
        mime_types:
            json: ['application/json', 'application/json;version=1.0', 'application/json;version=1.1']
        view_response_listener: 'force'
        formats:
            xml: false
            json: true
        templating_formats:
            html: true
    format_listener:
        rules:
            - { path: ^/, priorities: [ json, html ], fallback_format: json, prefer_extension: true }
    exception:
        codes:
            'Symfony\Component\Routing\Exception\ResourceNotFoundException': 404
            'Doctrine\ORM\OptimisticLockException': HTTP_CONFLICT
        messages:
            'Symfony\Component\Routing\Exception\ResourceNotFoundException': true
        exception_controller: 'fos_rest.exception.controller:showAction'
    allowed_methods_listener: true
    access_denied_listener:
        json: true
    body_listener: true

 

nelmio_api_doc:
documentation:
info:
title: My App
description: This is an awesome app!
version: 1.0.0
areas: # to filter documented areas
path_patterns:
- ^/api(?!/doc$) # Accepts routes under /api except /api/doc

Serializer

ApiFormErrorHandler.php

<?php
namespace App\Serializer;

use JMS\Serializer\JsonSerializationVisitor;
use Symfony\Component\Form\Form;
use Symfony\Component\Form\FormError;
use Symfony\Component\Translation\TranslatorInterface;
use JMS\Serializer\Handler\FormErrorHandler as JMSFormErrorsHandler;
use JMS\Serializer\VisitorInterface;


class ApiFormErrorHandler extends JMSFormErrorsHandler
{
private $translator;

public function __construct(TranslatorInterface $translator)
{
$this->translator = $translator;
}

public function serializeFormToJson(JsonSerializationVisitor $visitor, Form $form, array $type)
{
return $this->convertFormToArray($visitor, $form);
}

public function serializeFormErrorToJson(JsonSerializationVisitor $visitor, FormError $formError, array $type)
{
return $this->getErrorMessage($formError);
}

private function getErrorMessage(FormError $error)
{
if (null !== $error->getMessagePluralization()) {
return $this->translator->transChoice($error->getMessageTemplate(), $error->getMessagePluralization(), $error->getMessageParameters());
}
return $this->translator->trans($error->getMessageTemplate(), $error->getMessageParameters());
}

private function convertFormToArray(VisitorInterface $visitor, Form $data)
{
$isRoot = null === $visitor->getRoot();
$form = new \ArrayObject();
$errors = array();
foreach ($data->getErrors() as $error) {
$errors[] = $this->getErrorMessage($error);
}
if ($errors) {
$form['form_errors'] = $errors;
}
$children = array();
foreach ($data->all() as $child) {
if ($child instanceof Form) {
$errorList = $this->convertFieldToArray($visitor, $child);
if($errorList) {
$children[$child->getName()] = $errorList;
}
}
}
if ($children) {
$form['field_errors'] = $children;
}
if ($isRoot) {
$visitor->setRoot($form);
}
return $form;
}

private function convertFieldToArray(VisitorInterface $visitor, Form $data)
{
$isRoot = null === $visitor->getRoot();
$form = new \ArrayObject();
$errors = array();
foreach ($data->getErrors() as $error) {
$errors[] = $this->getErrorMessage($error);
}
if ($errors) {
$form = $errors;
}
$children = array();
foreach ($data->all() as $child) {
if ($child instanceof Form) {
$errorList = $this->convertFieldToArray($visitor, $child);
if(sizeof($errorList) > 0) {
$children[$child->getName()] = $errorList;
}
}
}
if ($children) {
$form = $children;
}
if ($isRoot) {
$visitor->setRoot($form);
}
return $form;
}
}



/**
*
* Action to be taken before persist
* @ORM\PrePersist
*
*/
public function prePersist()
{
$this->createdAt = new \DateTime();
$this->updatedAt = new \DateTime();
}

/**
*
* Action to be taken before update
* @ORM\PreUpdate
*/
public function preUpdate()
{
$this->updatedAt = new \DateTime();
}


@ORM\HasLifecycleCallbacks

* @ORM\Table(name="player",
* indexes={
* @ORM\Index(name="first_name_index", columns={"firstName"}),
* @ORM\Index(name="last_name_index", columns={"lastName"}),
* }
* ) 


use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;
use App\Entity\myenity
use App\Form\myenityType;
use App\Service\myenityService;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Contracts\Translation\TranslatorInterface; 

 throw new HttpException(Response::HTTP_BAD_REQUEST, $e);

test_service:
class: App\Tests\Service
public: true
tags: ['%host%']

myenity_service:
class: App\Service\myenityService
public: true
autowire: true 

$requestContent = $request->getContent();
$requestData = json_decode($requestContent, true);
if (empty($requestData)) {
$requestData = $request->request->all();
}

$form = $this->createForm()
$form->submit($requestData);
$res = $this->myentityservice->createmyenity($player);
$this->translator->trans('playerid')
array("method"=>"PUT")
->add('firstName', TextType::class, array('required' => true, 'constraints' => array(new NotNull())))
 
/**
* @Route("/myentity/{id}", name="getentity", methods={"GET"})
*/

use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Validator\Constraints\NotNull;

use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Contracts\Translation\TranslatorInterface;
use Symfony\Component\HttpKernel\Exception\HttpException; 

use Symfony\Component\HttpFoundation\Response;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use App\Tests\Service\Test;
use GuzzleHttp\Client;
 $data = json_encode(array())
$response = Test::sendRequest('player', 'POST', $data);
$this->assertEquals(Response::HTTP_OK, $response->getStatusCode());
$data = json_decode($response->getBody(), true);
$this->assertArrayHasKey('id', $data);


<?php

namespace App\Tests\Service;

use GuzzleHttp\Client;


class Test{

public static $host = "http://myunit.local/";

public static function sendRequest($endPoint, $method, $data, $id = null){
$client = new Client([
'base_uri' => self::$host
]);

switch ($method){
case 'POST':
$response = $client->post($endPoint, [
'body' => $data,
'headers' => [
'Content-Type' => 'application/json',
]
]);
break;
case 'GET':
$response = $client->get($endPoint.'/'.$data);
break;
case 'DELETE':
$response = $client->delete($endPoint.'/'.$data);
break;
case 'PUT':
$response = $client->put($endPoint, [
'body' => $data,
'headers' => [
'Content-Type' => 'application/json',
]
]);
break;
}

return $response;
}
}


<?xml version="1.0"?>
<xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
<file source-language="en" datatype="plaintext" original="file.ext">
<body>
<trans-unit id="success">
<source>success</source>
<target>Successful</target>
</trans-unit>
<trans-unit id="failed">
<source>failed</source>
<target>Something went worng. Please try again !!!</target>
</trans-unit>
<trans-unit id="dasda">
<source>asdada</source>
<target>sda Id required</target>
</trans-unit>
</body>
</file>
</xliff> 

$form->handleRequest($request);
$request->query->get('id');
'allow_extra_fields' => true,
'csrf_protection' => false 


$builder->add('bookedServices',CollectionType::class, array(
'entry_type' => BookedServicesType::class,
'allow_add' => true,
));

$builder->addEventListener(FormEvents::PRE_SUBMIT, function (FormEvent $event) {
$data = $event->getData();

if(!isset($data['bookedServices']) || $data['bookedServices'] == '' || empty($data['bookedServices']) || empty($data['bookedServices'][0])) {
throw new HttpException(Response::HTTP_BAD_REQUEST, "Booked Services details not added");
}

$event->setData($data);
});

$builder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) {
$data = $event->getData();

$bookedServices = $data->getBookedServices();
foreach ($bookedServices as $bookedService) {
$bookedService->setCustomerAppointment($data);
}

$event->setData($data);
});

use Symfony\Component\Form\Extension\Core\Type\CollectionType;

/**
* @ORM\ManyToOne(targetEntity="CustomerAppointment", inversedBy="bookedServices")
* @ORM\JoinColumn(name="customer_appointment_id", referencedColumnName="id")
*/
private $customerAppointment;

/**
* @Assert\Valid
* @ORM\OneToMany(targetEntity="BookedServices", mappedBy="customerAppointment", cascade={"persist"})
*/
private $bookedServices;

* @Assert\NotBlank(
* message = "Start Time index is required"
* )

use Symfony\Component\Validator\Constraints as Assert;
use AppBundle\Validator\Constraints as BookingAssert;
* @BookingAssert\BookingOffset

namespace AppBundle\Validator\Constraints;

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;

/**
* @Annotation
*/
class BookingOffset extends Constraint
{
public $message = 'Invalid offset';

public function getTargets()
{
return self::CLASS_CONSTRAINT;
}

public function validatedBy()
{
return get_class($this).'Validator';
}
}

namespace AppBundle\Validator\Constraints;

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use AppBundle\Entity\CustomerAppointment;

/**
* @Annotation
*/
class BookingOffsetValidator extends ConstraintValidator
{

public function __construct()
{

}
public function validate($object, Constraint $constraint)
{
$offset = $object->getOffset();
if ($offset < CustomerAppointment::MIN_OFFSET){ // || intval(fmod($offset, CustomerAppointment::MIN_OFFSET)) != 0
$this->context->buildViolation($constraint->message)
->atPath('offset')
->addViolation();
}
}
} 


validator.unique.holiday:
class: AppBundle\Validator\Constraints\UniqueHolidayValidator
arguments: ["@service_container"]
tags:
- { name: validator.constraint_validator, alias: UniqueHolidayValidator }

Mysqldump command:

Mysqldump command:

mysqldump -hlocalhost -uroot -ppassword DBname > /var/www/path.sql

JQuery  plug-in for Pi Charts:

data[] =

[{"name":"Koramangala","y":4,"sliced":true,"selected":true},

{"name":"Old Madras Road","y":16,"sliced":true,"selected":true}]

----------------------------------------------------------------- 

(function( $ ){
  $.fn.pieChartWidget = function(o) {
      var cfg={
        data : [],
        renderTo:'body',          
        sliceColors: ['#E69D01', '#BE0101', '#36AE01', '#FFCC49', '#FFF390', '#64676A']
      };
     
      jQuery.extend(cfg, o);   
     
      jQuery.extend({
            pieChart : function(params){
                Highcharts.setOptions({
                    colors: cfg.sliceColors
                  });
               
                var options = {
                        chart: {                           
                            renderTo: cfg.renderTo,
                            type: 'pie',
                            plotBackgroundColor: null,
                            plotBorderWidth: null,
                            plotShadow: false,
                            backgroundColor:'',
                            cursor:'normal'
                        },
                        title: {
                            text: ''
                        },
                     tooltip: {
                         formatter: function() {
                             var s = '';
                             if(this.point.projectName != undefined){
                              s += '<b>' + this.point.projectName  + '</b><br>';
                             }
                             if(this.point.startDate != undefined){
                                 s += 'Start Date :<b> ' + this.point.startDate + '</b><br>';
                                 s += 'End Date :<b> ' + this.point.endDate + '</b><br>';
                                 s += 'Total Assign hours :<b> ' + this.point.assignHours + '</b><br>';
                                 s += 'Total Spend hours :<b> '+ this.point.spendHours +'/' + this.point.actualHours + '</b><br>';
                             }                            
                             return s;
                         }
                     },
                        legend: {
                            enabled: true
                        },
                        credits : {
                            enabled:false
                        },
                        plotOptions: {
                            pie: {
                                allowPointSelect: true,
                                cursor: 'pointer',
                                shadow: false,
                                size:'100%',
                                borderWidth: 1,
                                dataLabels: {
                                enabled: true,
                                color:'#FFFFFF',
                                padding:1,
                                style: {
                                    fontWeight:'bold'
                                }, 
                                formatter: function () {
                                  return '<b>'+this.y+'%</b>';
                                },
                                distance: -40
                              },
                              showInLegend: false,
                              states: {
                                    hover: {
                                        enabled: false
                                    }
                                },
                                animation: true,
                            }
                          },
                        exporting: {
                            enabled: false
                        },
                        series: [{
                            data: [],
                           
                        }]
                    };
                    jQuery.extend(options, o);
                    options.series[0].data = cfg.data;                   
                    chart = new Highcharts.Chart(options);
            }
        });
       
        return this.each(function(){
            jQuery.pieChart(cfg.data);
        }).extend({
            cfg : cfg,
            jQuery : jQuery
        });
  };
})( jQuery );

------------------------------------------------------------------------------------------------------------------------------------

Plug-in calling: 

     $.post(path,{
         selectedtab:selected_tab
     },function(pieData){
         if(jQuery.isEmptyObject(pieData) != true){
                 $('#widget_content').pieChartWidget({                
                     renderTo: 'widget_content',
                     data: pieData,          
                 });
         }else{
             $('#widget_content').pieChartWidget({                
                  renderTo: 'widget_content',
                  sliceColors: ['#ccc'],
                  data:[{name: 'No data',y: 100,sliced: true,selected: true}],          
              });
         }
    },'json');


 

Permanently setting auto_increment_offset and auto_increment_increment in MySQL.

ALTER TABLE tablename AUTO_INCREMENT = 1;

mysql> SHOW VARIABLES LIKE 'auto_inc%';
+-----------------------------------+-------+
| Variable_name                     | Value |
+-----------------------------------+-------+
| auto_increment_increment   |   1     |
| auto_increment_offset          |   1     |
+------------------------------------+-------+
2 rows in set (0.00 sec)


auto_increment_increment controls the interval between successive column values. Default value 1.

SET GLOBAL auto_increment_increment  = 2;
SET SESSION auto_increment_increment = 2;

(or)

SET @@global.auto_increment_increment = 2;

SET @@session.auto_increment_increment = 2;

auto_increment_offset determines the starting point for the AUTO_INCREMENT column value.

SET GLOBAL auto_increment_offset  = 2;
SET SESSION auto_increment_offset  = 2;

(or)

SET @@global.auto_increment_offset = 2;

SET @@session.global.auto_increment_offset = 2;

restart mysql server (if Required)

sudo service mysql restart  

If the global value of either variable is set, its effects persist until
the global value is changed or overridden by setting the session value,
or until mysqld is restarted. If the local value is set, the new value 
affects AUTO_INCREMENT columns for all tables into which new rows are 
inserted by the current user for the duration of the session, unless the
values are changed during that session.

Virtual host configuration for Symfony2 project on ubuntu.
 (In Development Environment )
Open Terminal and execute below steps

1. Go to : sudo gedit /etc/apache2/sites-enabled/000-default
2. Edit: 

<VirtualHost *:80>

    DocumentRoot /var/www/sample/web

    ServerName sample.com

   

    <Directory /var/www/sample/web/>

        Options Indexes FollowSymLinks MultiViews

        AllowOverride None

        Order allow,deny

        allow from all

        <IfModule mod_rewrite.c>

            RewriteEngine On

            RewriteCond %{REQUEST_FILENAME} !-f

            RewriteRule ^(.*)$ /app_dev.php [QSA,L]

        </IfModule>

    </Directory>

</VirtualHost>

    3.  Go to: sudo gedit /etc/hosts

    4.  Edit :

         127.0.0.1 sample.com 

    5. Restart apache server: sudo service apache2 restart

    6. Open browser and type http://sample.com/app_dev.php

     

 Enjoy...