Undefined index: action in /cake/dispatcher.php line 144

$aInfo = $this->requestAction('/tours/GetAgentInfo/' . $property["Listing"]["agent"] . '/' . $property["Listing"]["listingoffice"]);
?>

The problem turned out to be that one of the values in $property["Listing"] was returning a value which included a space. Something like this: “396 “. Since the requestAction method uses a URL to get it’s parameters, it was bombing when the URL looked like this: ‘/tours/GetAgentInfo/396 /94′. I used the php trim() function to remove spaces, and presto… problem solved!

$aInfo = $this->requestAction('/tours/GetAgentInfo/' . trim($property["Listing"]["agent"]) . '/' . trim($property["Listing"]["listingoffice"]));
?>

100% PHP

• PHP.net
• PHP-Scripts Blog
• PHP Developer
• Marco Tabini
• PHP Freaks

Cake PHP

• CakePHP
• The Bakery
• CakePHP for Beginners
• H3RALD
• WithCake

Occasional PHP

• Shaun Inman
• Snook
• There and Back Again

Let’s assume we have two tables, colors and products. Our model states that products hasAndBelongsToMany colors. Also, colors hasAndBelongsToMany products.

Add the following code to app_controller.php:

function getSelectedItems($data)
{
$return = array();
foreach ($data as $row)
{
$return[$row['id']] = $row['name'];
}
return $return;
}


Our edit function in the products_controller.php will look something like this:

function admin_edit($id = null)
{
if (empty($this->data))
{
$this->set('colors', $this->requestAction('/colors/select'));
// get data for colors DropDownList
$this->Product->id = $id;
$this->data = $this->Product->read();
$this->set('selected_colors', $this->getSelectedItems($this->data['Color']));
}
else
{
if ($this->Product->save($this->data))
{
$this->flash("Your product has been updated.", '/admin/products');
}
else
{
$this->flash("Unable to update your product.", '/admin/products');
}
}
}


And finally, the code for the multi-select:

selectTag("Color/Color", $colors, $selected_colors, array('multiple' => 'multiple'))?>


If the associations are set up correctly, Cake will automagically save the updated colors when $this->Product->save($this->data) is called in the products controller. I hope this is helpful to someone, I spent a lot of time digging it up!

Pre-requisite: CakePHP

First, download Shuro’s component, sd_auth. Copy and paste the code into a file called sd_auth.php and put it inside app/controllers/components.

Now, create app_controller.php in app/ and paste the code below:

class AppController extends Controller
{
var $components = array('SdAuth');
function adminAuth()
{
// Auth Check.
if($this->SdAuth->isloggedin() == FALSE)
{
$this->layout = "admin_login";
} else {
$this->layout = "admin";
}
}
}

Next, uncomment the following line in app/config/core.php:

define('CAKE_ADMIN', 'admin');

Now, if you pre-pend a function in any of your controllers with “admin_” (eg: admin_add) it will now be accessed via the path /admin/add. Insert the authentication call at the beginning of each one of those functions:

function admin_add()
{
$this->adminAuth();
}

…and that method will be authenticated before continuing! Thanks for the tip Shunro.

Almost two years ago I jumped into ASP.NET and C# headfirst. This was my first exposure to OOP. I love it, and I don’t plan on turning back. However, for personal projects and freelancing I prefer to use PHP. PHP was my first “server-side” language (not counting a really small ASP email script I wrote leveraged on my very first freelance development gig). I love it for it’s straight forward nature, low cost, and great support.

Many of the conveniences that ASP.NET offers are not inherently available with PHP. This, and the chest-beating of many RoR developers, has led me on a quest for a useful Framework for PHP.

The Quest Begins

I began by simply googling “php frameworks”. This returned a plethora of comparisons and reviews which I began to peruse. Along the way I learned some new terminology: Model-View-Controller. Four frameworks stood out to me based on feature set, community, support, and cost (free!).

The Frameworks

Prado

I was initially impressed by several things about Prado:

1. Currently on version 3 and has a two year track record
2. It has an active community
3. It’s methodology is very similar to ASP.NET
4. The majority of the Framework is very well documented
5. Native development for PHP 5

Based on these strengths I decided to try Prado first. I found it easy to install and begin building applications. I built a simple login and used their templating system. Overall, I found the entire environment very friendly familiar. However, Prado suffers from some performance hits because of it’s architecture when using complicated dynamic templates. For this reason I decided to continue my quest. However, I would recommend Prado to anyone coming from ASP.NET who is developing small to medium sized applications.

Symfony

Symfony seemed like the next logical progression. It is well documented, highly reviewed, and seems to be very robust and efficient. I spent about an hour tooling around the documentation. I decided to abandon Symfony and move on after reading the installation documentation Please don’t judge me, I just get nervous when I have to do that much jockeying around with the command line.

CakePHP

It looks like I’m probably going to stick with Cake.

1. Easy to install
2. Active, enthusiastic community
3. Good beginner tutorials (unfortunately the remainder of the documentation is still under development and leaves a lot to be desired)

I was up and running and had built my first basic application in under an hour using the easy to follow blog tutorial. However, as I’ve tried to dig deeper I’ve had to dive into google groups, irc, and other sites for help figuring out the subtleties of Cake.

Code Igniter

I haven’t tried it yet, but it looks interesting. If Cake doesn’t work out, it’s next on the list.

One of my favorite languages to code in is PHP. PHP is a “server-side” language. This means it does all of the work on the server and then sends the results to your browser. There are a specific set of rules that must be followed carefully or else the code will not work. It occurred to me that this mirrors some of my life experience. Here are 5 life lessons that can be illustrated by the simple rules of PHP.

Look before you leap.

Sound advice. Don’t take any action before checking out what you’re getting into. PHP provides a basic mechanism for dealing with this life principle.

if (condition) {
// if the condition is true, do this
} else {
// here is your fallback plan!
}

How many tears would we avoid in our lives if we made a habit of running a simple if…then procedure before making a decision?

Persistence can pay off, but don’t get stuck in an infinite loop.

We’ve all heard about the value of working hard, but what about working smart? Just like life, PHP provides an easy tool that allows you to pound away at a single task until it is complete.

while (condition) {
// continue repeating this until the condition is met.
}

There is a catch though! Not every task can be completed by simply pounding away at it. It’s up to you to make sure you don’t get stuck in a cycle with no way to get out of it!

Cookies can help make new friends.

PHP allows you to give cookies to visitors to your website! A cookie is a small file deposited on the visitors computer that helps you remember who they are and what they like. If you’ve given a visitor cookies in the past, it is possible to instantly recall information about them. Your new friend’s favorite color, their name, or anything else they might have told you about the first time they visited, can be used to customize their experience when they return. Remember, not everyone likes cookies, so don’t be forceful (they are your friends after all). They are usually very nice in moderation though!

Remember lessons learned from past trials.

PHP has a built in way to journal any hurdles you overcome and provide notes to yourself if you ever come across the same problem again. Often, like life, writing code is a bit of a puzzle. It requires creatively putting together the simple rules of code (life) into steps that will ultimately yield results and, handling any unexpected circumstances that could rudely interrupt your well thought out plan at the wrong moment. What a great idea, learn from our victories!

Have some constants in your life.

Writing code is a lot like solving a math problem. One of the challenges of manipulating complicating problems is juggling all of the variables. Variables are nice because they allow you to change what they represent. However, this is also the tricky part; the more variable you have, the more complicated it is to keep track of the value of each one. Sometimes, a variable will inadvertently be changed to something it shouldn’t, and will compromise the integrity of the output. Thankfully, PHP (and life) allow us to use constants. Constants represent values that don’t change! While this will sometimes make your puzzles more challenging to solve, the end result is that having constants in your equation will give a firm foundation for reliable output.