TechnoGeeks » CakePHP

Goodbye CakePHP

jesse — Sun, 14 Mar 2010 13:57:21 +0000

It’s been a long journey and it has finally come to an end. Due to professional changes in my life, it is time that I stop using a PHP based MVC framework for web applications. Where will I go, you ask? Its simple – Ruby on Rails! While the aim of this post is to not convert people who use CakePHP to start using something else, I do plan on elaborating some of my reasonings for this switch.

1. My New Job
It cannot make much more sense than this. I recently got a new job (started Feb 1st). The place I work is a pure ruby shop and support several financial based web applications. I had 10 days to learn the syntax/basics of Ruby and loved every minute of it. I was ready for something new and fresh in my life.

2. Maturity
Rails was first! As a result, the project has matured more and seems to have a lot more support.

3. Package / Plugin management
Ruby has RubyGems, which is amazing. CakePHP just released something to handle plugins, but I have a feeling it is not a full package manager (think apt!).

4. Other Little Differences
Several small differences make it a better choice. I found a recent presentation that quickly explains a few of them.

That being said, PHP with CakePHP and Ruby with Rails both have their pros and cons. Each framework will always have its place in my heart. Hopefully I will have time soon to setup a rails environment and start pushing through some personal projects! Until then, I will continue gaining experience at work whilst I triage the problems that I was hired to fix

CakePHP eCommerce Done Right: Mocha Shopping Cart

jesse — Mon, 28 Sep 2009 19:57:12 +0000

Mocha Shopping Cart

A few months back I posted on CakePHP eCommerce and the lack of good solutions. Well that is now no longer the case. I would like to be one of the first people to introduce you to Mocha Shopping Cart. We have been working day and night (literally) to come up with a solution for the small and medium sized business owners to sell their products online easily. We also have geared Mocha to be extend-able and easy for CakePHP designers and developers to add in their own twists for clients.

Mocha is written entirely in CakePHP and jQuery and is certainly the best CakePHP eCommerce app out there. Why do I say that?

Mocha Shopping Cart is…

Fully hosted, secure, pre-installed
Very easy to set up and configure
Themable and Modular (Plug ins docs in the works)
Works with most popular payment and shipping apis (UPS, USPS, Authorize.net, Paypal, etc.)
Charges no transaction fees and no setup fees

If you still don’t believe me, Mocha is offering a limited time only Pre-Launch coupon code that gives you the first month FREE. You can try it for yourself and see how you like it. I think you will agree that it beats CakeCart and BakeSale, HANDS DOWN! And no, Mocha is not free (after the first 30 days). The costs help to speed up development, pay for server and hosting fees, and pay for that cup of coffee that us developers need when its 8 AM and we are having to talk with first thing in the morning.

Official Website: Mocha Shopping Cart
Blog with coupon code: Get a free trial of Mocha Shopping Cart

Easy JSON with CakePHP and jQuery

jesse — Sun, 16 Aug 2009 19:00:52 +0000

I am not sure if this is the fanciest way to get the job done but it works REALLY well. What job am I referring to? I am referring to outputting data as JSON in a CakePHP view and then parsing it in a jQuery AJAX response. Its fairly easy to accomplish with the JSON parser provided by json.org. Scroll to the bottom and download/include json2.js.

Controller example:

				$sizeArray = getimagesize('/path/to/really_cool_image.jpg');

				$outputArray = array(
					'file' => 'really_cool_image.jpg',
					'width' => $sizeArray[0],
					'height' => $sizeArray[1],
				);

				$this->set('result', $outputArray);

				$this->render(null, 'ajax');

AJAX View example:

Configure::write('debug', 0);
echo $javascript->object($result);

jQuery AJAX response handler example:

	  function(response, status) {
	  		imageDetails = JSON.parse(response);
	  		imageName = imageDetails.file;
	  }

CakePHP: Including Models inside your Controller

jesse — Tue, 26 May 2009 16:07:38 +0000

There are currently three methods for including and using models inside your controller. I am referring to the case when your controller does not belong to a model or or the model is not related to the model inside the controller you are working in. Although this case should be extremely rare, it seems to happen to me a lot. This post is basically a re-summary of Gwoo’s response in the CakePHP Google Groups discussion.

1. Controller::loadModel();
This method actually calls ClassRegistry::init() and saves the instance of the model as a parameter in the controller.

Example:

Controller::loadModel('Car');
$cars = $this->Car->find('all');

2. ClassRegistry::init()
This method creates an instance of the Model and returns it for use.

Example:

$car = ClassRegistry::init('Car');
$cars = $car->find('all');

3. App:import() (not recommended)
This method only includes the file. This requires you to create an instance each time.

Example:

App::import('Car');
$car = new Car();
$cars = $car->find('all');

As you can see this is really simple and basic stuff. However, I felt the need to re-post this information. If for nothing else, I will be using this as a reference point for myself

Update 5/27/09: Miles Johnson has a nice write up on this on his blog

CakePHP Character Encoding Checklist

jesse — Fri, 15 May 2009 20:04:01 +0000

I was having some issues today with character encoding and I thought I’d post about it. There are three elements that you need to make sure you have if you want to properly use UTF-8 character encoding in your Cake app. My issue was that I did not have #2, although adding #1 didn’t hurt either.

1. Database Config

Add ‘encoding’ => ‘utf8′ to app/config/database.php

	var $default = array(
		'driver' => 'mysql',
		'persistent' => false,
		'host' => 'localhost',
		'login' => 'user',
		'password' => 'password',
		'database' => 'database',
		'encoding' => 'utf8'
	);

2. Make sure your layout has the charset line in the

	
	 	charset(); ?>
	 	Other elements...

3. This one is set by default, but make sure App.encoding is set in app/config/core.php

/**
 * Application wide charset encoding
 */
	Configure::write('App.encoding', 'UTF-8');

And thats it!

Peep! A friendly GTD compliant productivity tool for you.

jesse — Mon, 11 May 2009 14:33:47 +0000

About a year ago Rick (http://www.rickguyer.com) had me read the book Getting Things Done by David Allen. In his book, Allen teaches you how to use his strategies and procedures on managing your tasks (or actions) in a very organized and well thought out fashion. His strategy is unique and calls for a very unique tool to accompany his GTD system. When I originally read his book, Rick and I spent several days searching for a different program, service, or web app that would allow us to incorporate Allen’s GTD system in an electronic fashion. After a solid week of effort I gave up after finding nothing that I felt was easy to use and completely GTD compliant.

Finally, after over a year, we decided to create this perfect GTD compliant web service that will help people, like us, be able to incorporate Allen’s system and become more productive. Peep! is “a simple and easy-to-use tool to help you focus and start getting things done.” I highly suggest you all try it and let me know what you think.

Head over to http://trypeep.com and get started today!

Coming Soon: Peep!

jesse — Mon, 27 Apr 2009 21:30:20 +0000

We’ve been working hard at the office lately in efforts to launch a new application that will be aimed towards increasing one’s productivity. The app will follow the principles in the book Getting Things Done by David Allen. Check out the sneak peek below!

Authenticating a CakePHP App Against a CakePHP Webservice

jesse — Thu, 26 Mar 2009 15:42:57 +0000

Update 03/27: I fixed the code formatting and added the Cakeservice Behavior

Rick and I figured out a nice solution to having one CakePHP application authenticate a user (and thus acodeessing data) from a different CakePHP application setup as an XML webservice. The authenticating app POSTs an XML string to the web service, which is automatically parsed by CakePHP and put into $this->data. It is then used in a custom xmlLogin() function that uses the Auth Component to log the user in. This solution handles all cookies appropriately so you wont have to worry about much there.

This solution would most likely be better if it were a DataSource instead of a ModelBehavior. We chose a ModelBehavior first because we are not familiar with writing custom data sources yet and wanted a simple, quick, and effective solution. This is a work in progress so I hope to expand on it more later and eventually have it act as a data source instead.

I am assuming:

* You have the latest CakePHP (1.2.1) installed and connected to the database
* You have the Auth Component installed and configured to the defaults
* You have at least one user record with a valid password hash
* You have the XML Helper enabled in your app_controller.php

Step 1: Make CakePHP Act as a Webservice (service side)

1. Add similar code in app/config/routes.php:

Router::mapResources(array('users', 'acodeounts'));
Router::parseExtensions();

2. Add RequestHandler to your components array in app_controller:

var $components = array('RequestHandler');

3. Add an xml folder to each view directory, with .ctp files for each action you would like to have. This is an example of app/views/users/xml/index.ctp:


serialize($users); ?>

See the CakeBook for more information on step 1.

Step 2: Setup CakePHP Errors for Reponse XML (service side)

We decided to use the built in custom errors system inside Cake for displaying Reponse XML for Webservice calls. I know that not all XML responses will be errors (it should actually be the opposite) but I like the way CakePHP handles custom error pages so we leveraged this functionality for this topic.

1. Create app/views/errors/serviceresponse.ctp

2. Create app/app_error.php

controller->set('errorCode', $params['errorCode']);
        $this->controller->set('errorMessage', $params['errorMessage']);
        $this->controller->layout = 'xml/default';
        $this->_outputMessage('serviceresponse');
    }
}
?>

Now this can be called by using this code in the controller as needed

$this->cakeError('serviceResponse', array('errorMessage' => $errorMessage, 'errorCode' => $errorCode));

Step 3: Create Custom Login Function (service side)

1. Add xmlLogin() to app/controllers/users_controller.php

    function xmlLogin() {
        // Verify request is from a webservice
        if ($this->Session->check('webserviceRequest')) {
            $this->Session->delete('webserviceRequest');

            // Default response
            $errorMessage = 'Login is required to acodeess this resource';
            $errorCode = 'login_required';

            // Check to see if data was posted
            if (!empty($this->data)) {
                // Parse the XML object into an array
                $data = Set::reverse($this->data);

                // Hash the passwords
                $this->data = $this->Auth->hashPasswords($data['Users']);

                // Login
                if($this->Auth->login($this->data)) {
                    $errorMessage = 'Logged in';
                    $errorCode    = 'auth_sucodeess';
                } else {
                    $errorMessage = 'Invalide username or password';
                    $errorCode = 'auth_fail';
                }

            }

            // Generate the response
            $this->cakeError('serviceResponse', array('errorMessage' => $errorMessage, 'errorCode' => $errorCode));
        }
    }

2. Modify the default login()

    function login() {
        if ($this->Session->check('webserviceRequest')) {
            $this->Session->delete('webserviceRequest');

            $this->cakeError('serviceResponse', array('errorMessage' => 'Login is required to acodeess this resource', 'errorCode' => 'login_required'));
        }
    }

3. Add in the webserviceRequest check to beforeFilter() in app/app_controller.php

    function beforeFilter() {
        if ($this->params['url']['ext'] == 'xml') {
            $this->Session->write('webserviceRequest', true);
        }
    }

4. Allow xmlLogin() to bypass Auth. Add the following to the top of your users_controller.php:

	var $preAuth = array();
	function beforeFilter() {
		parent::beforeFilter();

		$this->preAuth['password'] = $this->data['User']['password'];
		$this->Auth->allow('loginTest');
	}

Step 4: Install the Cakeservice Behavior (app side)

1. Download cakeservice.php and put it in app/models/behaviors/cakeservice.php

serviceConnect($Model, $params['url']);
		} else {
			return false;
		}

		$postHeaders = array(
			'Host' => 'jadams.bounceme.net',
			'Connection' => 'Close',
		);

		$requestMethod = 'POST';
		if (empty($params['data'])) {
			$requestMethod = 'GET';

		} else {
			$params['data'] = '' . $params['data'];
			$postHeaders = array_merge($postHeaders, array('Content-Length' => strlen($params['data']), 'Content-Type'	=> 'text/xml'));
		}

		$this->_formatHeaders($postHeaders);

		$request = "$requestMethod {$this->_path} HTTP/1.0\r\n";
		$request .= $this->_headers . "\r\n";
		$request .= "\r\n";
		if (!empty($params['data'])) {
			$request .= $params['data'];
		}

		$this->Socket->write($request);

		$response = '';
		while ($data = $this->Socket->read()) {
			$response .= $data;
		}

		$this->_parseResponse($response);

		if (array_key_exists('Location', $this->response['headers'])) {
			//$this->serviceConnect($Model, $this->response['headers']['Location']);
			$params['url'] = $this->response['headers']['Location'];
			$this->request($Model, $params);
		}
		return $this->response['body'];
	}

/**
 * Connect the Behavior to a new URL
 *
 * @param string $url The URL to connect to.
 * @param array $options Options Array for the new connection.
 * @return bool success
 **/
	function serviceConnect(&$Model, $url) {
	    $options = array(
	        'timeout' => 30,
	        'persistent' => false,
	        'defaultUrl' => null,
	        'port' => 80,
	        'protocol' => 'tcp',
	        'followRedirect' => true
	    );		

		$path = $this->_setPath($url);
		$options['host'] = $path['host'];

		if ($this->Socket === null) {
			$this->Socket = new CakeSocket($options);
		} else {
			$this->serviceDisconnect($Model);
			$this->Socket->config = $options;
		}
		return $this->Socket->connect();
	}

/**
 * Disconnect / Reset the Webservice Socket.
 *
 * @return boolean
 **/
	function serviceDisconnect(&$Model) {
		if ($this->Socket !== null) {
			$this->Socket->disconnect();
			$this->Socket->reset();
		}
	}

/**
 * Formats Additional Request Headers
 *
 * @return void
 **/
	function _formatHeaders($headers = array()) {
		$headers['User-Agent'] = 'CakeserviceBehavior';
		$headers['Accept'] = 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5';
		$headers['Accept-Language'] = 'en-us,en;q=0.5';

		// Load cookies
		$headers['Cookie'] = '';
		foreach($this->cookies as $cookieKey => $cookieData) {
			$headers['Cookie'] .= $cookieKey . '=' . $cookieData['value'] . '; ';
		}

		foreach ($headers as $name => $value) {
			$tmp[] = "$name: $value";
		}
		$header = implode("\r\n", $tmp);
		$this->_headers = $header;
	}	

/**
 * Parse the Reponse from the request, separating the headers from the content.
 *
 * @return void
 **/
	function _parseResponse($response) {
		$headers = substr($response, 0, strpos($response, "\r\n\r\n"));
		$body = substr($response, strlen($headers));

		//split up the headers
		$parts = preg_split("/\r?\n/", $headers, -1, PREG_SPLIT_NO_EMPTY);
		$heads = array();
		for ($i = 1, $total = sizeof($parts); $i < $total; $i++ ) {
			list($name, $value) = explode(': ', $parts[$i]);
			$heads[$name] = $value;
		}

		if (array_key_exists('Set-Cookie', $heads)) {
			// Save cookies

			$cookies = array();
			foreach ($heads as $headerKey => $headerValue) {
				if ($headerKey == 'Set-Cookie') {
					$parts = split('; ', $headerValue);

					$cookieKey = '';
					foreach ($parts as $index => $part) {
						list($key, $value) = split('=', $part);

						if ($index == 0) {
							$cookieKey = $key;
							$cookies[$cookieKey]['value'] = $value;
						} else {
							$cookies[$cookieKey][$key] = $value;
						}
					}
				}
			}

			$this->cookies = $cookies;
		}

		$this->response['headers'] = $heads;
		$this->response['body'] = trim($body);
	}	

/**
 * Set the host and path for the webservice.
 * @param string $url The complete url you want to connect to.
 * @return array Host & Path
 **/
    function _setPath($url) {
        $port = 80;
        if (preg_match('/^https?:\/\//', $url)) {
            $url = substr($url, strpos($url, '://') + 3);
        }
        if (strpos($url, '/') === false) {
            $host = $url;
            $path = '/';
        } else {
            $host = substr($url, 0, strpos($url, '/'));
            $path = substr($url, strlen($host));
        }
        if ($path == '') {
            $path = '/';
        }

        $this->_path =$path;
        return array('host' => $host, 'path' => $path, 'port' => $port);
    }

    function setCookies(&$Model, $cookies) {
    	$this->cookies = $cookies;
    }

    function getCookies(&$Model) {
    	return $this->cookies;
    }
}
?>

2. Add cakeservice to your actsAs array in each model you want to utilize it:

var $actsAs = array('cakeservice');

3. Overwrite the default login() function

	function login() {
		if (!empty($this->data)) {
	        $user = array(
	            'Users' => array(
	                'User' => array(
	                    'username'    => $this->data['User']['username'],
	                    'password'    => $this->preAuth['password'],
	                )
	            )
	        );		

	        // Convert the data to XML
	        App::import('Xml');
	        $xml = new Xml($user);

	        // Load existing cookies, if any, for the webservice call
	        if($this->Session->check('apiCookies')) {
	            $this->User->setCookies($this->Session->read('apiCookies'));
	        }

	        // Web service communication
	        $result = $this->User->request(array(
	            'data'    => $xml,
	            'url'    => 'domain.example/path_to_cake/users/xmlLogin.xml',
	        ));

	        // Save the cookies from the web service
	        $cookies = $this->User->getCookies();
	        if(!empty($cookies)) {
	            $this->Session->write('apiCookies', $cookies);
	        }

			$xml = new Xml($result);
			$response = Set::reverse($xml);

			if (isset($response['Responses']['Response']['Data']['User']['id'])) {
				$this->Session->write('Auth.User', $response['Responses']['Response']['Data']['User']);
				$this->Session->setFlash('Successfully logged in.');
				$this->redirect('/');
			} else {
				$authData = $this->Session->read('Message.auth');
				$authData['message'] = $response['Responses']['Response']['message'];
				$this->Session->write('Message.auth', $authData);
			}
		}
	}

Please feel free to post any comments or questions you may have.

Using the Security Component in CakePHP for SSL

jesse — Thu, 05 Mar 2009 22:16:04 +0000

I recently needed to require some of my CakePHP actions to be forced to use a secure connection for security purposes. It took me a long time to finally figure out the solution that I found in CakePHP 1.2 so I figured I would share. There is a handy Security Component provided by CakePHP that does exactly what I was looking for. I attempted to contribute to the Cake Book so hopefully the changes will show up there soon.

The example below shows how to force certain actions (login and checkout) to use a secure connection. You specify as many actions in your $this->Security->requireSecure() function that you want to require to be secure. Each time a request that you put in this method is called in a non-secure manner it will do what is called a black hole. When the request is black holed, it will generate a 404 error by default. In the example below I have overridden the default behavior and created my own custom call back that will redirect to a secure connection automatically.

Security->blackHoleCallback = 'forceSSL';
		$this->Security->requireSecure('login', 'checkout');
	}

	function forceSSL() {
		$this->redirect('https://' . $_SERVER['SERVER_NAME'] . $this->here);
	}
}
?>

Notice: All of the Security Component’s methods will be passed to the same callback function that you specify so be careful if you are using multiple methods.

Update 03/09/09: My doc changes and usage example were accepted on the official Cake book!