Aviblock.com » Expression Engine

Fixing PATH_INFO on bluehost and other shared hosts

Avi — Fri, 07 Aug 2009 19:54:43 +0000

The first time I setup an Expression Engine site on bluehost, and removed the index.php file via the .htaccess file, I ran into a problem where every template was redirecting back to the main index template. At the time, I traced this down to fact that the “segments” were not getting populated properly.
A brief search led to the EE wiki, which advocated swapping out PATH_INFO for ORIG_PATH_INFO. Although not being a fan of hacking core stuff, I was kind of cornered into this, so I went for it. This has been my running solution for the past two years.
Recently, I ran into an issue where the $_SERVER['PHP_SELF'] was not returning anything after the file name. In other words, for http://mysite/foo.php/bar, PHP_SELF should be equal to foo.php/bar.
I spoke with my host about it (a similar host to bluehost), and they said to put the following in the php.ini file: cgi.fix_pathinfo=Off
After, I did this, PHP_SELF worked fine. Unfortunately, I ran into a similar situation like I described at the outset. Then it hit me…I changed ORIG_PATH_INFO back to PATH_INFO and…it worked!
So now I listed this as another potential solution in the EE wiki.

Templatizer

Avi — Tue, 19 May 2009 14:07:04 +0000

I released an extension the other day for EE. You can find it here.

The basic idea is that creating templates in Expression Engine, especially if you don’t plan to edit them from the CP, can sometimes be a little repetitive and annoying.
Normally with EE, the templates are stored in the database, and you have the option of also storing them on the filesystem. But in order for them to be recognized by EE, they must reside in the database at least.

Using this extension, you can start your template off as a physical file, and the first time you view it in the browser, it will automatically be recognized by EE and inserted into the database!

Flash Messenger for Expression Engine

Avi — Thu, 07 May 2009 16:47:11 +0000

A common idiom in web development is that a form is submitted via POST, and then a redirect is done to a success page. The reason for this is that if we left the result of the submission to return HTML to the browser, we would run into the infamous and confusing message “To display this page, Firefox must send information that will repeat any action (such as a search or order confirmation) that was performed earlier.” (At least the way firefox tells you). This has become none as the POST/REDIRECT/GET pattern.

The problem becomes that, because of the stateless nature of HTTP, this second request has absolutely no connection to the previous request. If we just wanted to display a thank you page, or a success page, this would not be much of a problem. But what if we wanted to display the same form again, and display a success message on top when its submitted?

One way of doing this, which is the way Expression Engine does it, is to pass in a parameter in the query string, like ?success=1. The problem with this is that now if somebody refreshes the page, they’ll see the same message. Not the biggest deal in the world, but can we do better?

The answer to all the statelessness of HTTP is with sessions. There is a pattern that takes advantage of this called a “flash message“. The basic idea is to store a value in a session when the form is submitted, and to echo it back the first time the page is displayed again, after a succesful POST.

I wanted this functionality in some of my Expression Engine SAEF’s and other such forms. I also wanted a way to easily set up flash messages, within the form itself, so that I didn’t have to hack any modules, or look for a hook.

Here is what the API looks like. I will pick on solspaces {exp:user:edit} which I am using to create a edit profile form.

Image the following form:

My Profile
{exp:user:edit}
First Name

Last Name


{/exp:user:edit}

This creates a basic profile form where the user can change his first and last name (assuming these custom member variables were set up). If we submit this form, it will return right to were it came from, with no indication as to that anything happened.

So we will change it like this:

My Profile
{flash_msg}
{exp:user:edit}
{exp:flash_msg msg="Profile edited succesfully!"}
First Name

 
Last Name


{/exp:user:edit}

Now when we submit the form, we are greeted with the message “Profile edited succesfully!”. Refresh the page, and its gone!

And now for the exciting technical part! How is this magic done?

First the general overview: The plugin creates a hidden form element who’s value is a random hash. At the same time this element is created, a session variable is created with this hash and the message, as well as a flag. There is a extension on the session_end hook which looks for the presence of this form element, and the session variable. If the two hashes are the same, the flag in the session variable is set, and the plugin knows it can display the session variable.

Here is the extension:

function sessions_end($SESS) {
    global $IN;
 
    if (REQ == 'ACTION') {
        $hash = $IN->GBL('flash-hash');
        if ($hash) {
            session_start();
            if ($_SESSION['flash_msg']['flash-hash'] == $hash) {
                $_SESSION['flash_msg']['done'] = true;
            }
        }
    }
}

I think that code is pretty self explanatory (or at least I explained it earlier).

Now the plugin:

function Flash_msg() {
	global $TMPL, $FNS;
 
	$hash = $FNS->random('encrypt');
	session_start();
	if (isset($_SESSION['flash_msg']) && $_SESSION['flash_msg']['done']) {
		$TMPL->template = $TMPL->swap_var_single('flash_msg', $_SESSION['flash_msg']['msg'], $TMPL->template);
	}
	else{
		$TMPL->template = $TMPL->swap_var_single('flash_msg', '', $TMPL->template);
	}
 
	$_SESSION['flash_msg']  = array('done' => false, "flash-hash" => $hash, "msg" => $TMPL->fetch_param('msg'));
	$this->return_data = "-hash" type="hidden" value="$hash" />";
}

Pretty straight forward, I think. The only interesting thing here is the line:

$TMPL->template = $TMPL->swap_var_single('flash_msg', '', $TMPL->template);

This takes advantage of some bad OOP design on Expression Engine’s part, so that my plugin can make changes, like variable substitution, anywhere in the template!

There’s one problem with all of this though. What if we set one of the fields in that form to required, and left it out? We would see the output of the Expression Engine’s error page, and when we went back, the flash message would appear! We need a way at to determine if the form was successful or not. Unfortunately, a successful submit is merely a semantic thing. Its up to the programmer to determine if was successful or not. I though about this problem for a long time, and then came up with an ingenious, almost hackish solution. If only there was a hook in the Output::show_user_error() method!

In absence of that I thought, why don’t I just subclass the Output class, and overwrite that method, and then replace the global $OUT variable with new version!

As simple as this:

class MyOutput extends Output {
	 function show_user_error($type = 'submission', $errors, $heading = '') {
		$_SESSION['flash_msg']['done'] = false;
 
		return parent::show_user_error($type, $errors, $heading);
	 }
}

This just simply overwrites the show_user_error method, resets the flag, and shores off back to its parent to do the rest!

I simply include this little class at the bottom of the extension and then we rewrite our extension method as follows:

function sessions_end($SESS) {
	global $IN, $OUT;
 
	if (REQ == 'ACTION') {
		$hash = $IN->GBL('flash-hash');
		if ($hash) {
			$OUT = new MyOutput();
			session_start();
			if ($_SESSION['flash_msg']['flash-hash'] == $hash) {
				$_SESSION['flash_msg']['done'] = true;
			}
		}
	}
}

All I’m doing now is replacing the global $OUT variable with my own subclassed Output class!

Presenting a list of Timezones to the user

Avi — Thu, 12 Mar 2009 20:41:18 +0000

I first got into timezones when I working on an calendar app which displayed various times of day which are pertinent to Jewish daily life. The app would display calculated times which of course would differ based on the timezone of the given location. As I investigated into timezones, I found them to be fairly complicated. Not all timezones are even on the hour…some are at 30 minute offsets, some at 45 minutes, and historically there have been even stranger offsets than that.

To make matters worse, there’s the whole issue of Daylight Saving Time. Apparently some places have it some don’t. Some countries have a set date for DST, some pick a new one each year depending on circumstances. And of course, DST does not mean only adding one hour.

My research led me to what is “colloquially” known as the “Olson” database. The Olson database is a de facto standard in the world of keeping time. The most recognizable part of the way timezones are identified is the {Continent}/{Location} signature. For example, the timezone that I am in is called “America/New_York”. The Olson database tracks all historical information about timezones back at least until 1970. By timezone information, this also means transitions for DST and the GMT offset for both standard time and DST.

The best part of all of this, is that PHP 5 and up has built in support for understanding Olson timezones. This means that you all you need is the timezone id (the tzid), and you can have PHP worry about all the timezone and DST calculations.

Recently, I was working on another app which required members to select a timezone. The app is written on top of Expression Engine which contains a full blown membership system. The membership system includes a timezone setting. Let’s take a quick look at the what this look like:

Selecting a timezone in Expression Engine

Notice the checkbox that says “Daylight Saving Time”? This means that the user has to remember, every year, to select that checkbox when DST happens. Not very fun. Expression Engine is written in PHP 4, and the authors intend to keep that, stubbornly, for as long as possible.

I’m not here to wrant on Expression Engine (that’s for another time), but either way, this would not suit my purposes. I can’t rely on users remembering to “spring forward” when they have to.

The alternative is to provide a list based on the Olson database. The problem is that, as of this post, their are 560 tzid’s in the database, and they are not “friendly” nor recognizable to anybody but geeks.

I started looking around on the Interwebs trying to see what other people came up with. There was a question on Stackoverflow.com which hit the nail on the head, but anybody answering the question missed the point completely.

Eventually I realized that I must present a list similar to Expression Engine’s list, but which has the values as Olson tzid’s. The first step was to clean up the list a little. Much of the information is redundant, and only there for historical purposes. For instance, until 2006, much of Indiana did not observe DST. After 2006, however, the story changed. This explains why there are so many Olson tzid’s with Indiana in them. However, for all practical purposes, they’re the same.

The question is, what defines them as the same? I determined the best way would be to look at the DST transition date (if applicable), and the resulting offsets and compare them. Fortunately, PHP has a function that does this…timezone_transitions_get().

My idea was to pull in all the timezones and their transistions into excel and sort them by offset, and transition dates to identify which tzids are similar. After that, to figure out a friendly name to call them.

Doing more research I found somebody made a spreadsheet which tried to map Windows timezone names to Olson tzid’s. I used this a base reference for the names I chose, although I found not all the data in that spreadsheet was accurate (one day I will submit my changes to the author). Some timezones I had to come up with my own names like “America/Havana” which has different rules for any place in its timezone. I decided to call this (GMT-05:00) Cuba for lack of anything else.

In the end, I came up with a list of about 80 or so timezones, and I’m somewhat proud of my results:

Here is the list:

If anybody can offer any improvements to this or a different suggestion altogether, that would be great.