Chetan's CakePHP

Remember before making cakephp application

2012-09-15T04:39:00.002-07:00

Hello Cakebakers,

Aim of this post is enhance the quallity, maintainability of cakephp application.

1. Fat Models and Skinny Controllers

2. Create the maximum common function

- Should make helper if you want to make common function in view side
- Should make component or common function in app_controller if you want to make common function in Controller side

3. Reducing Use of
App::import('Controller','yourControllerName');
$variable_name = new yourControllerName();

Because:
It loads a whole controller class.

Solution :
Make a common function in AppController.php

4. Reducing use of Model in View side

       Like :
       App::import('Model','yourModelName')
        $variable_name = new yourModelName();
       $variablename->find('all');

      Because :
       It violate MVC rules

     More details :
      http://chetan4cake.blogspot.in/2012/04/find-in-view-in-cakephp.html

5. Reducing use of requestaction()

   Because :
    It slows down perfomance of webpage.

   Solution :
   Use Concept of Fat Models and Skinny Controllers

   Example :
    Make a function in your Category model
    function getCategories(){
            $categories = $this->find('all',array('recursive' => '-1'));
            return $categories;
       }

      In our controller we can call this function and pass it to element.
    $categories = $this->Category->getCategories();
    $this->set('categories',$categories);

6. CakePHP Components :

     Components are relatively heavy - they use big memory to your application. They definitely have their place, but take care to include only the ones you really need, since they are loaded on every request.

   Reducing use of var $components = array('...');

   Solution :

           Use App::import('Componant','...');

   But sometime we have to use var $componants;

7. Load Cakephp Vendor files lazily
      Cake has great support for vendor code - that is, 3rd party libraries that you call from your application to avoid re-implementing the wheel. Be wary, however, of calling App::import(’Vendor’, …); at the top of any of your controllers or components. What this does is load the vendor libraries for every page on your site, even if that code is not used! Instead, place your App::import() statement immediately before you use the library. That way, it is only loaded if you actually make the call!

8. Reducing Use of $uses Unless You Really, Absolutely Have To.

    Use concept of Model Chains.
    $uses is a controller attribute that allows you to access additional models to the default one. Say you have a blog application and one of the controllers is posts. By default you have access to the Post model. If you wanted to also have access to the Comment model you could do (but shouldn't):

   class PostsController extends AppController {
        var $name = 'Posts';
        var $uses = array('Post', 'Comment');
   }

    Model Chains

      Since Comment is associated to Post through a HasMany relationship you can access the Comment model through Post. Like this:

       $comments = $this->Post->Comment->findAllByPostId($id);

The relation chain extends infinitely, including all models down the line.

9. Url rewriting should be done from routes.php instead of writing or changing in .htaccess

10 . Library extensions should be added in app/Lib folder instead of addding it in cakePHP's base library

11. Maintain bootstrap.php file

- Define all constant variable ,site URL , third-party credential,plugin url in bootstrap.php file

Suggest me if I am somewhere wrong.Any suggestion are welcome.

Mail me on "chetanspeed511987@gmail.com" if any query for same.

CakePHP JOIN

2012-08-09T05:29:00.001-07:00

Hello CakeBakers

Mail me on "chetanspeed511987@gmail.com" if any query for same.

MVC of CakePHP

2012-07-12T09:28:00.002-07:00

Hello CakeBakers, I attach the best image of mvc stucture of cakephp.

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Email in CakePHP 2.0+

2012-07-11T06:03:00.001-07:00

CakeEmail is a new class to send email. With this class you can send email from any place of your application. In addition to using the EmailComponent from your controller, you can also send mail from Shells, and Models.

This class replaces the EmailComponent and gives more flexibility in sending emails. For example, you can create your own transports to send email instead of using the provided smtp and mail.

Most sites need a way to send out emails. CakePHP provides a simple way to send both html and plain text emails using the email component. Here’s how I deployed and used the email component.

At the appropriate point (after the add is complete) I call a custom function:

$this->__sendEmailConfirm($this->User->id,$activationKey )

The sendEmailConfirm function looks like this:

I then have a folder called ‘Emails’ in my View folder.This contains two sub folders, ‘html’ and ‘text’. Within the html folder I have a template called ‘user_confirm.ctp’.
This relates to the template I am calling in my __sendEmailConfirm function.
$email->emailFormat('html'); specifies I am sending an HTML email,
, so Cake looks in the View/Emails/html folder for a template that matches the value set by $email->template('xxx'); – in my case xxx = ‘user_confirm’.

So the output of the email are determined by these two lines:

$email->template('user_confirm');
$email->emailFormat('html');

The user_confirm.ctp file can be as complex or simple as you choose. In my case I have this:

Hey there < ? = $name ? >, we will have you up and running in no time, but first we just need you to confirm your user account by clicking the link below:

< ? = $activate_url ? >

Within each of the subfolders, create a default.ctp file, which is the layout that will receive and wrap the email element.

My default.ctp file in the View/Layouts/Emails/html folder is very simple:

< ! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" >

< ? php echo $content_for_layout; ? >

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Exception handling in cakephp 2.0+

2012-06-26T22:53:00.001-07:00

Now, I discribe step by step how to handle error 400,403,404,405,501 in cakephp2.0+

Step-1 : Update /app/Config/core.php

open /app/Config/core.php, and find the following:

Configure::write('Exception', array(
    'handler' => 'ErrorHandler::handleException',
    'renderer' => 'ExceptionRenderer',
    'log' => true
));

and Replace with following:

Configure::write('Exception', array(
    'handler' => 'ErrorHandler::handleException',
    'renderer' => 'AppExceptionRenderer',
    'log' => true
));

Step-2 : Create following file if not exists

1. /app/View/Errors/error400.ctp
2. /app/View/Errors/error403.ctp
3. /app/View/Errors/error404.ctp
4. /app/View/Errors/error405.ctp
5. /app/View/Errors/error500.ctp
6. /app/View/Errors/error501.ctp

in above file , you can put your custom error design.

Step-3 : Create /app/Lib/Error/AppExceptionRenderer.php

App::uses('ExceptionRenderer', 'Error');

class AppExceptionRenderer extends ExceptionRenderer {

    /*-------------------------------------------------------------------------*/
    /* -- Exceptions
    /*-------------------------------------------------------------------------*/

    public function notFound($error) {
        $this->controller->beforeFilter();
        $this->controller->set('title_for_layout', 'Not Found');
        $this->controller->render('/Errors/error404');
        $this->controller->response->send();
    }
    public function badRequest($error) {
        $this->controller->beforeFilter();
        $this->controller->set('title_for_layout', 'Not Found');
        $this->controller->render('/Errors/error400');
        $this->controller->response->send();
    }
    public function forbidden($error) {
        $this->controller->beforeFilter();
        $this->controller->set('title_for_layout', 'Not Found');
        $this->controller->render('/Errors/error403');
        $this->controller->response->send();
    }
    public function methodNotAllowed($error) {
        $this->controller->beforeFilter();
        $this->controller->set('title_for_layout', 'Not Found');
        $this->controller->render('/Errors/error405');
        $this->controller->response->send();
    }
    public function internalError($error) {
        $this->controller->beforeFilter();
        $this->controller->set('title_for_layout', 'Not Found');
        $this->controller->render('/Errors/error500');
        $this->controller->response->send();
    }
    public function notImplemented($error) {
        $this->controller->beforeFilter();
        $this->controller->set('title_for_layout', 'Not Found');
        $this->controller->render('/Errors/error501');
        $this->controller->response->send();
    }

    /*-------------------------------------------------------------------------*/
    /* -- Other
    /*-------------------------------------------------------------------------*/

    public function missingController($error) {
        $this->notFound($error);
    }
    public function missingAction($error) {
        $this->notFound($error);
    }
    public function missingView($error) {
        $this->notFound($error);
    }
    public function missingLayout($error) {
        $this->internalError($error);
    }
    public function missingHelper($error) {
        $this->internalError($error);
    }
    public function missingBehavior($error) {
        $this->internalError($error);
    }
    public function missingComponent($error) {
        $this->internalError($error);
    }
    public function missingTask($error) {
        $this->internalError($error);
    }
    public function missingShell($error) {
        $this->internalError($error);
    }
    public function missingShellMethod($error) {
        $this->internalError($error);
    }
    public function missingDatabase($error) {
        $this->internalError($error);
    }
    public function missingConnection($error) {
        $this->internalError($error);
    }
    public function missingTable($error) {
        $this->internalError($error);
    }
    public function privateAction($error) {
        $this->internalError($error);
    }

}

-- in above function,
   set method:
     We need to do is set our title_for_layout variable so it’s passed to the view
   render method :
     The first params is the view you want to render and
     The second params is the layout to render it in (second is optional).

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Authentication for browser back button

2012-06-05T21:39:00.000-07:00

How to authentication for browser back button in cakephp 2.x ?

problem :

Once you are logging out of the application
you are still able to see the previous pages using browser back button.
then for resolving it, add below code.

Solution :

Add below code in your AppController.php

public function beforeRender() {

$this->response->disableCache();

}

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Simple DEMO of Search plugin in Cakephp 2.0

2012-06-01T10:25:00.002-07:00

How to configure Search plugin in Cakephp 2.x

1. Download Search plugin from :

https://github.com/CakeDC/search

2. Put it in app/Plugin.

3. Create Database :

Database name : search

CREATE TABLE IF NOT EXISTS `tickets` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`status` varchar(25) NOT NULL,
`category` varchar(50) NOT NULL,
`title` varchar(50) NOT NULL,
`content` varchar(250) NOT NULL,
`created` datetime NOT NULL,
`modified` datetime NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=9 ;

4. Database Configuration :

    public $default = array(
        'datasource' => 'Database/Mysql',
        'persistent' => false,
        'host' => 'yourhost',
        'login' => 'yourusername',
        'password' => 'yourpassword',
        'database' => 'search',
        'prefix' => '',
        //'encoding' => 'utf8',
    );

5. Add below code in app/bootstrap.php

CakePlugin::loadAll(array(
            'Search' => array('routes' => true, 'bootstrap' => true),
        ));

6. Make TicketsController.php

< ? php
App::uses('AppController', 'Controller');
/**
* Tickets Controller
*
* @property Ticket $Ticket
*/
class TicketsController extends AppController {
    public $components = array('Search.Prg');
    public $presetVars = array(
        array('field' => 'title', 'type' => 'value'),
        array('field' => 'status', 'type' => 'value'),
      );
    public function beforeFilter() {
        $this->set('statuses', $this->Ticket->statuses);
        $this->set('categories', $this->Ticket->categories);
        parent::beforeFilter();
        }

/**
* index method
*
* @return void
*/
    public function index() {

        $this->Prg->commonProcess();
        $this->paginate =
            array(
            'limit' => 2,
            'conditions' => $this->Ticket->parseCriteria($this->passedArgs)
            );

        //$this->paginate['conditions'] = $this->Ticket->parseCriteria($this->passedArgs);
        $this->set('tickets', $this->paginate());
    }
/**
* view method
*
* @param string $id
* @return void
*/
    public function view($id = null) {
        $this->Ticket->id = $id;
        if (!$this->Ticket->exists()) {
            throw new NotFoundException(('Invalid ticket'));
        }
        $this->set('ticket', $this->Ticket->read(null, $id));
    }
/**
* add method
*
* @return void
*/
    public function add() {
        if ($this->request->is('post')) {
            $this->Ticket->create();
            if ($this->Ticket->save($this->request->data)) {
                $this->Session->setFlash(('The ticket has been saved'));
                $this->redirect(array('action' => 'index'));
            } else {
                $this->Session->setFlash(('The ticket could not be saved. Please, try again.'));
            }
        }
    }
/**
* edit method
*
* @param string $id
* @return void
*/
    public function edit($id = null) {
        $this->Ticket->id = $id;
        if (!$this->Ticket->exists()) {
            throw new NotFoundException(('Invalid ticket'));
        }
        if ($this->request->is('post') || $this->request->is('put')) {
            if ($this->Ticket->save($this->request->data)) {
                $this->Session->setFlash(('The ticket has been saved'));
                $this->redirect(array('action' => 'index'));
            } else {
                $this->Session->setFlash(('The ticket could not be saved. Please, try again.'));
            }
        } else {
            $this->request->data = $this->Ticket->read(null, $id);
        }
    }
/**
* delete method
*
* @param string $id
* @return void
*/
    public function delete($id = null) {
        if (!$this->request->is('post')) {
            throw new MethodNotAllowedException();
        }
        $this->Ticket->id = $id;
        if (!$this->Ticket->exists()) {
            throw new NotFoundException(('Invalid ticket'));
        }
        if ($this->Ticket->delete()) {
            $this->Session->setFlash(('Ticket deleted'));
            $this->redirect(array('action' => 'index'));
        }
        $this->Session->setFlash(__('Ticket was not deleted'));
        $this->redirect(array('action' => 'index'));
    }
}

7. Make Model "Ticket.php"

< ? php
App::uses('AppModel', 'Model');
/**
* Ticket Model
*
*/
class Ticket extends AppModel {
/**
* Display field
*
* @var string
*/
    public $displayField = 'title';

    public $actsAs = array('Search.Searchable');

    public $filterArgs = array(
        array('name' => 'title', 'type' => 'query','method'=>'filterTitle'),
        array('name' => 'status', 'type' => 'string'),

    );

/**
construct *
* @return void
*/
     public function construct($id = false,$table = null,$ids = null) {
        $this->statuses = array(
            'open' => ('Open',true),
            'closed' => ('Closed',true),
        );
        $this->categories = array(
            'bug' => ('bug',true),
            'support' => ('support',true),
            'technical' => ('technical',true),
            'other' => ('other',true),
        );
        parent::construct($id,$table,$ids);

        }

/**
* filterTitle method
*
* @return void
*/
    public function filterTitle($data = array()) {
        $filter = $data['title'];
        if(empty($filter))
        {
            return array();
        }
        $cond = array(
            'OR' => array(
                $this->alias . '.title LIKE' => '%' . $filter . '%',
            ));
        return $cond;
    }

}

8. Make a View File in app/View/Tickets/

You have to create view file like index.ctp , add.ctp , edit.ctp , view.ctp by using cakebake.

After creating above file,put below code in your index.ctp.

< ? php

        echo $this->Form->create('Ticket', array(
    'url' => array_merge(array('action' => 'index'), $this->params['pass'])
));
        echo $this->Form->input('title', array('div' => false,'empty'=>true));
        echo $this->Form->input('status', array('div' => false,'empty'=>true));
        echo $this->Form->submit(__('Search', true), array('div' => false));
        echo $this->Form->end();

    ? >

9. Put below code in app/Plugin/Search/Config/bootstrap.php

< ? php
define("PLUGIN_DIR", CakePlugin::path('Search'));
?>

10. Try to run your application.

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Thanks to all

Virtual Keyboard Helper in CakePHP

2012-05-05T01:48:00.001-07:00

Virtual Keyboard Helper in CakePHP

1. How to Use it

-- Include below helper in your controller

var $helpers = array('Keyboard');

-- in your ctp file, write below code

echo $this->Keyboard->generate();
?>

2.How to Make Virtual Keyboard Helper

-- Put below helper file in views/helper/keyboard.php

class KeyboardHelper extends Helper {

    var $helpers = array('Html', 'Javascript', 'Form');

    function generate()
    {

        $html = array();

        $html[] = $this->Html->css('keyboard');

        $html[] = $this->Javascript->link('keyboard');

        $html[] = $this->Form->input('keyboardddddd', array('class'=>'keyboardInput','label'=>false,'div'=>false,'type' => 'textarea','value'=>''));

        return "\n" . implode("\n", $html);
    }

}

?>

3. How to get library of Virtual Keyboard Helper

-- javascript code :

http://www.greywyvern.com/code/javascript/keyboard.js

-- css code :

http://www.greywyvern.com/code/javascript/keyboard.css

-- image

http://www.greywyvern.com/code/javascript/keyboard.png

Reference site :
http://www.greywyvern.com/code/javascript/keyboard
Thanks to him.

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Import Model in Controller

2012-04-19T23:57:00.006-07:00

How Many Time Accessing a model in AppController or in any Controllers?

1. var $uses = array('ModelName');

2. $this->loadModel('ModelName');

3. $this->ModelName = ClassRegistry::init('ModelName');

4. App::import('Model', 'ModelName');

How to Use it :

$this->ModelName->find();

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Find in View in Cakephp

2012-04-12T21:44:00.003-07:00

How to Use Find Query in View in CakePHP ?

1.
Inside your Menu model create a method, something like getMenu()

function getMenu()
{
$test = array();
$test = $this->Menu->find('all');
return $test;
}

In this method do your find() and get the results you want. Modify the results as you need and like to within the getMenu() method and return the data.

If you need that menu on every page in AppController::beforeFilter() or beforeRender() simply do

$this->set('menu', ClassRegistry::init('Menu')->getMenu());

If you do not need it everywhere you might go better with using requestAction getting the data using this method from the Menus controller that will call getMenu() from the model and return the data. Setting it where you need it would be still better, if you use requestAction you also want to cache it very likely.

2.
NOTE : This Way VIOLATE The MVC RULE

In AppHelper ,

Make a below function

function getMenu()
{

App::import('Model', 'Menu');
$this->Menu= &new Menu();
$test = array();
$test = $this->Menu->find('all');
return $test;
}

Use above function in view like :


 $menu = $html->getMenu();
 print_r($menu);

 ?>

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Self Association in CakePHP

2012-04-12T03:34:00.002-07:00

How to Create Self Association in CakePHP

< ? php

class Post extends AppModel {

var $name = 'Post';

var $belongsTo = array(

'Parent' => array(

'className' => 'Post',

'foreignKey' => 'parent_id'

)

);

var $hasMany = array(

'Children' => array(

'className' => 'Post',

'foreignKey' => 'parent_id'

)

);

}

Fetching a nested array of associated records:

If your table has parent_id field you can also use find('threaded') to fetch nested array of records using a single query without setting up any associations

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Difference between Component and Plugin in Cakephp

2012-04-10T21:33:00.002-07:00

Difference between a “component” and a “plugin” in cakephp

Components and Plugins are still separate entities in Cake 2.0. According to the manual components are "are packages of logic that are shared between controllers", whereas plugins are "a combination of controllers, models, and views". Compoments extend the base Component class, while Plugins have their own AppModel and AppController.

Think of a plugin as a separate Cake application sharing the same core libraries with your main application.

MobileSite in Cakephp

2012-04-09T03:37:00.000-07:00

Make Mobile site in Cakephp

I could say an endless number of good things about CakePHP, my framework of choice for database-driven sites, but after two years of working with it, I return endlessly to a single bad thing: the official documentation is maddening. The cookbookremains slightly hostile to all but the most advanced coders. Most sections are deliberately obtuse on certain points, like a puzzle box that provides a description of each piece but never shows you a picture of what the top left corner ought to look like.

The result is that we beta coders flail for a while when tackling a new problem in Cake, before finally discovering that the solution was far simpler than we originally thought. Case in point: optimizing a Cake site for mobile devices. As my latest CakePHP project needed both a standard site and a mobile version optimized for the iPhone/iPod Touch and other mobile webkit browsers, I spent a few days browsing through plugins and components, thinking I’d need some additional horsepower to create a robust mobile web app along side the usual browser fare. In the end, however, I found everything I needed inside Cake itself.

I needed to do two things:

Detect webkit-based mobile browsers
Automatically serve those browsers a mobile optimized page if one was available for the requested action.

Here’s how I did it, and how you might, too.

Cake’s RequestHandler component includes a nifty method for detecting mobile browsers — $this->RequestHandler->isMobile() — but the default list of devices detected by Cake 1.2 is a bit dated.

Fortunately, it’s easy to update. The default list of device names is found in the RequestHandler component’s core file,cake/libs/controller/components/request_handler.php:

if (!defined('REQUEST_MOBILE_UA')) {
    define('REQUEST_MOBILE_UA', '(iPhone|MIDP|AvantGo|BlackBerry|J2ME|Opera Mini|DoCoMo|NetFront|Nokia|PalmOS|PalmSource|portalmmm|Plucker|ReqwirelessWeb|SonyEricsson|Symbian|UP\.Browser|Windows CE|Xiino)');
}

Update this by copying it to your core configuration file —/app/config/core.php — and adding the device names of your choice. I simply added Android to snag all those new Google-happy devices using webkit browsers. To wit:

   define('REQUEST_MOBILE_UA', '(Android|iPhone|MIDP|AvantGo|BlackBerry|J2ME|Opera Mini|DoCoMo|NetFront|Nokia|PalmOS|PalmSource|portalmmm|Plucker|ReqwirelessWeb|SonyEricsson|Symbian|UP\.Browser|Windows CE|Xiino)');

There are several places you could put mobile view files —app/views/elements or app/views/themed come to mind — but I decided on something slightly different. Cake automatically looks for an action’s view files inside a view folder named after the action’s controller. For instance, a page request forusers/login expects to find a view file at/app/views/users/login.ctp. Given that, I extended the convention by creating a subfolder named mobile inside each controller’s existing view folder. So, my mobile view forusers/login is located at /app/views/users/mobile/login.ctp.

Mobile-optimized pages will need a different layout than standard pages. Create a file named mobile.ctp and save it inside /app/views/layouts.

Here’s where Cake really shines. All we need to do in order to send all mobile devices to any mobile-optimized pages is create the following logic inside the beforeFilter() of/app/app_controller.php.

        // check for mobile devices
        if ($this->RequestHandler->isMobile()) {
            // if device is mobile, change layout to mobile
            $this->layout = 'mobile';
            // and if a mobile view file has been created for the action, serve it instead of the default view file
            $mobileViewFile = VIEWS . strtolower($this->params['controller']) . '/mobile/' . $this->params['action'] . '.ctp';
            if (file_exists($mobileViewFile)) {
                $mobileView = strtolower($this->params['controller']) . '/mobile/';
                $this->viewPath = $mobileView;
            }
        }

This code does the following:

Detects mobile browsers using our updated device list
Changes the layout to our new mobile layout
Checks to see if a mobile view file exists inside the mobile subfolder described above.
If the file exists, the logic changes to the mobile view before displaying the page.

One thing to keep in mind about this approach is that it doesn’t allow mobile viewers to switch back to the standard browser view, assuming instead that you’ll take care to retain all essential functions in your mobile views. It does, however, preserve your original URLs across all platforms, with none of that ganky mobile redirection that lesser sites use.

What’s new

2012-04-08T03:32:00.000-07:00

CakePHP 2.0 released: What’s new?

“CakePHP is a rapid development framework for PHP that provides an extensible architecture for developing, maintaining, and deploying applications. Using commonly known design patterns like MVC and ORM within the convention over configuration paradigm, CakePHP reduces development costs and helps developers write less code. ”

And now, it even got better. After a year and a half of coding, CakePHP 2.0 is released.

I will first talk about some cool new features and explain some of them later.

New features

Dropped PHP 4 support and we have refactored all the code to be strictly compliant with PHP 5.2+.
Use of native features like exceptions, PDO, SPL, json_encode and much more.
Embraced the PSR-0 recommendation for file naming. Now all your classes map to a file with the same name. Less things to remember!
New Error and Exception handlers provide easier to configure, and ease working with errors such as page not found, unauthorized error and lots more.
Improved I18n functions for easier multilingual development.
Support for injecting your own objects to act as CakePHP libraries, such as component, helpers and behaviors, no more excuses for modifying core files.
Console libraries rebuilt from scratch, automatic help generation, parameter checking, and colors!
New Request and Response objects for easier handling of HTTP requests.
Better session handling for easier custom engines. Put your sessions into storage systems like Memcache with less effort.
Completely refactored Auth system. It is now easier to configure and plug in your own implementations for external login services or your permissions system.
Brand new email library with support for multiple transports. With easy to use global configuration, logging, and charset support.
Dropped SimpleUnit in favor of PHPUnit. PHPUnit is the defacto testing framework for PHP with support for more options, better mock objects, and improved console output [16]
Reworked the SecurityComponent to suck less, now you can more easily protect your apps against CSRF and form tampering attacks while having fun.
Improved support for PostgreSql, SQLite and SqlServer, they are now first class citizens along with Mysql datasource.
HTML 5 form inputs support in form helper.
A Sexier default look taking advantage of new CSS 3 features.
A lot faster, almost everything is now lazy-loaded, and even on debug mode you will feel your applications flying.
CakePHP 2.0 completely dropped the PHP 4 support and is now supporting PHP 5.2.6 and above. This was expected.

Models

The model construction process has been made lighter. Model associations are now lazy loaded, applications with lots of models and associations will see great time reductions in the bootstrap process.
Now models won’t require a database connection in the construction process. The database will be accessed for the first time only when a find operation is issued or information for one of the columns is required.

Views
View will now always have the last rendered content (view or layout) accessible through $this->output. In helpers you can use $this->_View->output. Modifying this property will change the content that comes out of the view rendering.

Helpers
There are some interesting new features inside powerful CakePHP Helpers:
FormHelper now supports all HTML5 input types and custom input types. Just use the input type you want as the method on the helper. For example range() would create an input with type = range.
postLink() and postButton() Creates link/button to access some page using HTTP method POST. With this, in your controller you can avoid some action, like delete, to be accessed by GET method.
select() with multiple = checkbox, now treats the 'id' attribute as a prefix for all the generated options.
getCrumbsList() Creates breadcrumb links wrapped in elements in HTMLHelper

Error handling
The error handling implementation has dramatically changed in 2.0. Exceptions have been introduced throughout the framework, and error handling has been updated to offer more control and flexibility.

PHPUnit
All of the core test cases and supporting infrastructure have been ported to use PHPUnit 3.5. Of course you can continue to use SimpleTest in your application by replacing the related files.
No further support will be given for SimpleTest and it is recommended that you migrate to PHPUnit as well.

Database Objects
Cake 2.0 introduces some changes to Database objects that should not greatly affect backwards compatibility. The biggest one is the adoption of PDO for handling database connections.
If you are using a vanilla installation of PHP 5 you will already have installed the needed extensions, but you may need to activate individual extensions for each driver you wish to use.

Console
CakePHP features not only a web framework but also a console framework for creating console applications. Console applications are ideal for handling a variety of background tasks such as maintenance, and completing work outside of the request-response cycle. CakePHP console applications allow you to reuse your application classes from the command line.
CakePHP comes with a number of console applications out of the box. Some of these applications are used in concert with other CakePHP features (like ACL or i18n), and others are for general use in getting you working faster.
One of the cool things is that the console app is now colorized to easier spot error messages and other critical information.

Internationalization & Localization

2012-04-07T00:17:00.002-07:00

Internationalization & Localization

One of the best ways for your applications to reach a larger audience is to cater for multiple languages. This can often prove to be a daunting task, but the internationalization and localization features in CakePHP make it much easier.

Internationalizing Your Application

There are only a few steps to go from a single-language application to a multi-lingual application, the first of which is to make use of the __() function in your code. Below is an example of some code for a single-language application:



Posts

To internationalize your code, all you need to do is to wrap strings in __() like so:

 echo __('Posts') ?>

If you do nothing further, these two code examples are functionally identical - they will both send the same content to the browser. The __() function will translate the passed string if a translation is available, or return it unmodified. It works similar to other Gettext implementations (as do the other translate functions, such as __d() , __n() etc)

With your code ready to be multilingual, the next step is to create your pot file, which is the template for all translatable strings in your application. To generate your pot file(s), all you need to do is run the i18n console task, which will look for where you’ve used a translate function in your code and generate your pot file(s) for you. You can and should re-run this console task any time you change the translations in your code.

The pot file(s) themselves are not used by CakePHP, they are the templates used to create or update your po files, which contain the translations. Cake will look for your po files in the following location:

/app/Locale//LC_MESSAGES/.po

The default domain is ‘default’, therefore your locale folder would look something like this:

/app/Locale/eng/LC_MESSAGES/default.po (English)
/app/Locale/fre/LC_MESSAGES/default.po (French)
/app/Locale/por/LC_MESSAGES/default.po (Portuguese)

To create or edit your po files it’s recommended that you do not use your favorite editor. To create a po file for the first time it is possible to copy the pot file to the correct location and change the extension however unless you’re familiar with their format, it’s quite easy to create an invalid po file or to save it as the wrong charset (if you’re editing manually, use UTF-8 to avoid problems). There are free tools such as PoEdit which make editing and updating your po files an easy task; especially for updating an existing po file with a newly updated pot file.

The three-character locale codes conform to the ISO 639-2 standard, although if you create regional locales (en_US, en_GB, etc.) cake will use them if appropriate.

Remember that po files are useful for short messages, if you find you want to translate long paragraphs, or even whole pages - you should consider implementing a different solution. e.g.:

// App Controller Code.
public function beforeFilter() {
    $locale = Configure::read('Config.language');
    if ($locale && file_exists(VIEWS . $locale . DS . $this->viewPath)) {
        // e.g. use /app/View/fre/Pages/tos.ctp instead of /app/View/Pages/tos.ctp
        $this->viewPath = $locale . DS . $this->viewPath;
    }
}

or:

// View code
echo $this->element(Configure::read('Config.language') . '/tos')

Localization in CakePHP

To change or set the language for your application, all you need to do is the following:

Configure::write('Config.language', 'fre');

This tells Cake which locale to use (if you use a regional locale, such as fr_FR, it will use the ISO 639-2 locale as a fallback if it doesn’t exist), you can change the language at any time during a request. e.g. in your bootstrap if you’re setting the application default language, in your (app) controller beforeFilter if it’s specific to the request or user, or in fact anytime at all before you want a message in a different language. To set the language for the current user, you can store the setting in the Session object, like this:

$this->Session->write('Config.language', 'fre');

At the beginning of each request in your controller’s beforeFilter you should configure Configure as well:

class AppController extends Controller{
    public function beforeFilter() {
        Configure::write('Config.language', $this->Session->read('Config.language'));
    }
}

Doing this will ensure that both I18n and TranslateBehavior access the same language value.

It’s a good idea to serve up public content available in multiple languages from a unique url - this makes it easy for users (and search engines) to find what they’re looking for in the language they are expecting. There are several ways to do this, it can be by using language specific subdomains (en.example.com, fra.example.com, etc.), or using a prefix to the url such as is done with this application. You may also wish to glean the information from the browser’s user-agent, among other things.

As mentioned in the previous section, displaying localized content is done using the __() convenience function, or one of the other translation functions all of which are globally available, but probably be best utilized in your views. The first parameter of the function is used as the msgid defined in the .po files.

CakePHP will automatically assume that all model validation error messages in your $validate array are intended to be localized. When running the i18n shell these strings will also be extracted.

There’s one other aspect of localizing your application which is not covered by the use of the translate functions, and that is date/money formats. Don’t forget that CakePHP is PHP :), therefore to set the formats for these things you need to use setlocale.

If you pass a locale that doesn’t exist on your computer to setlocale it will have no effect. You can find the list of available locales by running the command locale -a in a terminal.

More Deatils : http://book.cakephp.org

How to speed up Big site in cakephp?

2012-04-05T21:11:00.006-07:00

Equip Apache JMeter to generate the load
Enable profiling your web app by xdebug
In my own experience running heavy apps with CakePHP and MySQL (more than 250 tables) the bottleneck reside in a bad use of the CakePHP ORM.

Sometimes, you will fetch a lot more datas than you need.

find('all') function associated to high recursive value looks cool and speed up the development time.

But in fact, this can be really awful, especially when your app and database is growing. The number of associated models will grow too, fetching recursively more and more datas.

A good practice is to always specify the fields you need. Also, for spectific queries, you should unbind associated models you don't need.

For complex queries, don't hesitate to write optimized queries by hand, using the query() function.

In developpment, you should enable CakePHP debug mode for profiling SQL queries in your Config/core.phpfile :

Configure::write('debug',
2);

This will help you to find the slowest.

Optimizing your queries is the first step. If this doesn't solve your issue, your database is maybe not well designed.

In addition, you should use an opcode cache in production, such as APC or XCache.

You really need to get a tool like jmeter and benchmark to see where your problem points will be. You can spend a lot of time guessing and improving, but you won't see real results until you measure and compare your changes.

For example, for many years, the MySQL query cache was the solution to all of our performance problems. If your site was slow, MySQL experts suggested turning the query cache on. It turns out that if you have a high write load, the cache is actually crippling. If you turned it on without testing, you'd never know.

And don't forget that you are never done scaling. A site that handles 10req/s will need changes to support 1000req/s. And if you're lucking enough to need to support 10,000req/s, your architecture will probably look completely different as well.

Databases

Don't use MySQLi -- PDO is the 'modern' OO database access layer. The most important feature to use is placeholders in your queries. It's smart enough to use server side prepares and other optimizations for you as well.
You probably don't want to break your database up at this point. If you do find that one database isn't cutting, there are several techniques to scale up, depending on your app. Replicating to additional servers typically works well if you have more reads than writes. Sharding is a technique to split your data over many machines.

Caching

You probably don't want to cache in your database. The database is typically your bottleneck, so adding more IO's to it is typically a bad thing. There are several PHP caches out there that accomplish similar things like APC and Zend.
Measure your system with caching on and off. I bet your cache is heavier than serving the pages straight.
If it takes a long time to build your comments and article data from the db, integrate memcache into your system. You can cache the query results and store them in a memcached instance. It's important to remember that retrieving the data from memcache must be faster than assembling it from the database to see any benefit.
If your articles aren't dynamic, or you have simple dynamic changes after it's generated, consider writing out html or php to the disk. You could have an index.php page that looks on disk for the article, if it's there, it streams it to the client. If it isn't, it generates the article, writes it to the disk and sends it to the client. Deleting files from the disk would cause pages to be re-written. If a comment is added to an article, delete the cached copy -- it would be regenerated.

You'll need a working version of CakePHP installed. This is running on 1.2.6.
Download jsmin 1.1.0 or later and put it in vendors/jsmin.
Download CSSTidy 1.3 or later and put the contents in vendors/csstidy.
Download the helper and unzip it to app/views/helpers.
Include the helper in any controller that will need it. Most likely you will put it in AppController so that it's available to all your controllers:
view plain copy to clipboard print ?
1. var $helpers = array('Asset.Asset');
In your layout and views include Javascript files as you normally would when using the $scripts_for_layout approach:
view plain copy to clipboard print ?
1. $javascript->link('jquery', false);
Similarly include your css with the inline option set to false:
view plain copy to clipboard print ?
1. $html->css('style', null, null, false);
Then in your layout file, in the head section, instead of using $scripts_for_layout call the helper:
view plain copy to clipboard print ?
1. echo $asset->scripts_for_layout();

9.For More details : http://sandbox2.pseudocoder.com/demo/asset

Global Constants in CakePHP 2.0

2012-04-04T23:35:00.003-07:00

Core Definition Constants

Most of the following constants refer to paths in your application.

constant APP: Path to the application’s directory.

constant APP_DIR: Equals app or the name of your application directory.

constant APPLIBS: Path to the application’s Lib directory.

constant CACHE: Path to the cache files directory. It can be shared between hosts in a multi-server setup.

constant CAKE: Path to the cake directory.

constant CAKE_CORE_INCLUDE_PATH: Path to the root lib directory.

constant CORE_PATH: Path to the root directory with ending directory slash.

constant CSS: Path to the public CSS directory.

constant CSS_URL: Web path to the CSS files directory.

constant DS: Short for PHP’s DIRECTORY_SEPARATOR, which is / on Linux and \ on windows.

constant FULL_BASE_URL: Full url prefix. Such as https://example.com

constant IMAGES: Path to the public images directory.

constant IMAGES_URL: Web path to the public images directory.

constant JS: Path to the public JavaScript directory.

constant JS_URL: Web path to the js files directory.

constant LOGS: Path to the logs directory.

constant ROOT: Path to the root directory.

constant TESTS: Path to the tests directory.

constant TMP: Path to the temporary files directory.

constant VENDORS: Path to the vendors directory.

constant WEBROOT_DIR: Equals webroot or the name of your webroot directory.

constant WWW_ROOT: Full path to the webroot.

Timing Definition Constants

constant TIME_START: Unix timestamp in microseconds as a float from when the application started.

constant SECOND: Equals 1

constant MINUTE: Equals 60

constant HOUR: Equals 3600

constant DAY: Equals 86400

constant WEEK: Equals 604800

constant MONTH: Equals 2592000

constant YEAR: Equals 31536000

For More Details : http://book.cakephp.org/2.0/en/core-libraries/global-constants-and-functions.html

CakePHP Model Associations Cheat Sheet

2012-04-04T03:29:00.002-07:00

$hasMany – one to many

array(

'UniqueName' => array(

'className' => 'thatClassName',

'foreignKey' => 'this_fk_id',

'conditions' => array(

'That.field' => 'somevalue'

'order' => 'That.field DESC',

'limit' => '5',

'fields' => 'That.fields',

'offset' => 0,

'dependent'=> true,

'exclusive' => false,

'finderQuery' => 'FULL JOIN QUERY'

)

);

$hasOne – one to one

array(

'UniqueName' => array(

'className' => 'thatClassName',

'foreignKey' => 'this_fk_id',

'conditions' => array(

'That.field' => 'somevalue'

'fields' => 'That.fields',

'dependent' => true

)

);

$belongsTo– many to one

array(

'UniqueName' => array(

'className' => 'thatClassName',

'foreignKey' => 'that_fk_id',

'conditions' => array(

'That.field' => 'somevalue'

'fields' => 'That.fields',

'counterCache' => false

)

);

$hasAndBelongsToMany– many to many

array(

'UniqueName' => array(

'className' => 'thatClassName',

'joinTable' => 'join(s)_table(s)',

'with' => 'JoiningClassName',

'foreignKey' => 'this_id',

'associationForeignKey'=> 'that_id',

'unique'=> true,

'conditions' => array(

'That.field' => 'somevalue'

'order' => 'That.field DESC',

'limit' => '5',

'fields' => 'That.fields',

'offset' => 0,

'finderQuery' => 'FULL JOIN QUERY',

'deleteQuery' => 'FULL DELETE QUERY',

'insertQuery' => 'FULL INSERT QUERY'

)

);

Model Relationship Convertions

Foreign
keys in hasMany, belongsTo or hasOne relationships

are
recognized by default as the (singular) name of the related

model
followed by _id

Join
tables, used in hasAndBelongsToMany (HABTM)

relationships
between models should be named after the model

tables
they will join in alphabetical order (apples_zebras rather

than
zebras_apples).

All
tables with models require a PRIMARY KEY named 'id'.

Differences between bind model and contain cakephp

2012-03-30T05:27:00.001-07:00

What is the differences between bind model and contain cakephp?

One of the most powerful features of CakePHP is the ability to link relational mapping provided by the model. In CakePHP, the links between models are handled through associations. If you set up these associations in your model, then when you retrieve your data Cake will automagically retrieve associated data too.

The containable behavior allows you to filter and limit model find operations (assuming you have set up your model associations)

http://book.cakephp.org/view/1323/Containable

bind and unbind are useful for changing model associations on the fly:

http://book.cakephp.org/view/1045/Creating-and-Destroying-Associations-on-the-Fly

htaccess in cakephp

2012-03-28T23:52:00.003-07:00

BASIC KNOWLEDGE OF .htaccess IN CAKEPHP

What is .htaccess?

.htaccess(Hypertext Access file) is a configuration file for use on web servers running the Apache Web Server software. When a .htaccess file is placed in a directory which is in turn 'loaded via the Apache Web Server', then the .htaccess file is detected and executed by the Apache Web Server software. These .htaccess files can be used to alter the configuration of the Apache Web Server software to enable/disable additional functionality and features that the Apache Web Server software has to offer. These facilities include basic redirect functionality, for instance if a 404 file not found error occurs, or for more advanced functions such as content password protection or image hot link prevention.

Use of .htaccess?

Forbidding access:

Forbidding all files
Allow access from a certain IP address
Forbid access from a certain IP address
Forbidding a group of files by mask
Forbidding a particular file

Setting a password:

Password for a directory
Password for one file only
Password for a group of files
Checking access rights to three directories two of which are subdirectories

Redirections:

Redirecting a visitor to another URL
Displaying different pages depending on the visitor's IP address
Redirecting a user when he requests certain pages
How to change the default page
How to make Apache process SSI directives
How to process Apache errors yourself?
How to forbid the contents of a directory to be displayed if it has no index file?
Is it possible to specify the default encoding of files the browser receives them in?
Is it possible to specify the encoding of uploaded files?

Frequent errors:

I created the .htaccess file, but the server returns 500 - Internal Erorr

How to configure .htaccess in cakephp?

/var/www/app/webroot/.htaccess

    RewriteEngine On
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^(.*)$ index.php?url=$1 [QSA,L]
/var/www/app/.htaccess

    RewriteEngine on
    RewriteRule    ^$    webroot/    [L]
    RewriteRule    (.*) webroot/$1    [L]
/var/www/.htaccess

    RewriteEngine on
    RewriteRule ^$ app/webroot/ [L]
    RewriteRule (.*) app/webroot/$1 [L]

New Features cakephp2.0

2012-03-28T04:20:00.001-07:00

New Features in CakePHP 2.0

Models

Now models won’t require a database connection in the construction process. The database will be accessed for the first time only when a find operation is issued or information for one of the columns is required.

View

View will now always have the last rendered content (view or layout) accessible through $this->output. In helpers you can use $this->_View->output. Modifying this property will change the content that comes out of the view rendering.

Helpers

HtmlHelper :

- getCrumbList() Creates breadcrumb links wrapped in
- elements
- loadConfig() has moved from Helper to HtmlHelper class. This method now uses the new reader classes (see 2.0 Configure) to load your config file. As an option you can pass the path as second parameter (app/Config is default). To simplify, you can set the configuration file (and the reader) in Controller::$helpers (example below) to load on helper constructor. In configuration file you can set the below keys:
- - tags Should be an array with key value;
  - minimizedAttributes Should be a list;
  - docTypes Should be an array with key value;
  - attributeFormat Should be a string;
  - minimizedAttributeFormat Should be a string.
  Example of how to set configuration file on controller:
```
public $helpers = array(
    'Html' => array(
        'configFile' => array('config_file', 'php')  
```
```
     // Option one: an array with filename and reader name
        'configFile' => 'config_file' 
```
```
     // Option two: a string with filename. 
```
```
     )
);
```

FormHelper :

FormHelper now supports all HTML5 input types and custom input types. Just use the input type you want as the method on the helper. For example range() would create an input with type = range.
postLink() and postButton() Creates link/button to access some page using HTTP method POST. With this, in your controller you can avoid some action, like delete, to be accessed by GET method.
select() with multiple = checkbox, now treats the 'id' attribute as a prefix for all the generated options.

Router

Route objects can now return full urls, and Router will not further modify them beyond adding the query string and fragment elements. For example this could be used to create routes to handle subdomains, or enabling https/http flags. An example of a route class that supports subdomains would be:

< ? php
class SubdomainRoute extends CakeRoute {

 public function match ($params) {
 $subdomain = isset($params['subdomain'])?$params['subdomain']: null; 
        unset($params['subdomain']);
        $path = parent::match($params);
        if ($subdomain) {
            $path = 'http://' . $subdomain . '.localhost' . $path;
        }
        return $path;
    }
} 
 
 

When creating links you could do the following to make links pointing at other subdomains.

< ? php

echo $this->Html->link( 'Other domain', array('subdomain' => 'test', 'controller' => 'posts', 'action' => 'add') );

The above would create a link with http://test.localhost/posts/add as the url.

Thanks to : http://book.cakephp.org/2.0/en/appendices/new-features-in-cakephp-2-0.html

Chetan's CakePHP

Remember before making cakephp application

Mail me on "chetanspeed511987@gmail.com" if any query for same.

CakePHP JOIN

Mail me on "chetanspeed511987@gmail.com" if any query for same.

MVC of CakePHP

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Email in CakePHP 2.0+

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Exception handling in cakephp 2.0+

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Authentication for browser back button

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Simple DEMO of Search plugin in Cakephp 2.0

How to configure Search plugin in Cakephp 2.x

1. Download Search plugin from :

https://github.com/CakeDC/search

2. Put it in app/Plugin.

3. Create Database :

Database name : search

4. Database Configuration :

public $default = array( 'datasource' => 'Database/Mysql', 'persistent' => false, 'host' => 'yourhost', 'login' => 'yourusername', 'password' => 'yourpassword', 'database' => 'search', 'prefix' => '', //'encoding' => 'utf8', );

5. Add below code in app/bootstrap.php

CakePlugin::loadAll(array( 'Search' => array('routes' => true, 'bootstrap' => true), ));

6. Make TicketsController.php

7. Make Model "Ticket.php"

8. Make a View File in app/View/Tickets/

You have to create view file like index.ctp , add.ctp , edit.ctp , view.ctp by using cakebake.

After creating above file,put below code in your index.ctp.

9. Put below code in app/Plugin/Search/Config/bootstrap.php

< ? php define("PLUGIN_DIR", CakePlugin::path('Search'));?>

10. Try to run your application.

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Thanks to all

Virtual Keyboard Helper in CakePHP

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Import Model in Controller

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Find in View in Cakephp

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Self Association in CakePHP

How to Create Self Association in CakePHP

Fetching a nested array of associated records:

Mail me on "chetanspeed511987@gmail.com" if any query for same.

Difference between Component and Plugin in Cakephp

Difference between a “component” and a “plugin” in cakephp

MobileSite in Cakephp

What’s new

CakePHP 2.0 released: What’s new?

Models

Internationalization & Localization

Internationalizing Your Application

Posts

echo __('Posts') ?>

Localization in CakePHP

How to speed up Big site in cakephp?

Databases

Caching

Global Constants in CakePHP 2.0

Core Definition Constants

Timing Definition Constants

CakePHP Model Associations Cheat Sheet

Differences between bind model and contain cakephp

What is the differences between bind model and contain cakephp?

htaccess in cakephp

BASIC KNOWLEDGE OF .htaccess IN CAKEPHP

What is .htaccess?

Use of .htaccess?

Forbidding access:

Setting a password:

Redirections:

Frequent errors:

How to configure .htaccess in cakephp?

New Features cakephp2.0

New Features in CakePHP 2.0

Models

View

Helpers

HtmlHelper :

FormHelper :

public $default = array(
'datasource' => 'Database/Mysql',
'persistent' => false,
'host' => 'yourhost',
'login' => 'yourusername',
'password' => 'yourpassword',
'database' => 'search',
'prefix' => '',
//'encoding' => 'utf8',
);

CakePlugin::loadAll(array(
'Search' => array('routes' => true, 'bootstrap' => true),
));

< ? php
define("PLUGIN_DIR", CakePlugin::path('Search'));
?>