How to Find the URL to Some Google Calendar XML

Google does a great job of giving you direct access to the XML of any calendar that may appear on your personal calender. You even have the option of making your private calendars public, thereby getting access to your own calendar XML feed. In Google calendar, if you click Settings (Img.1), then click the first orange XML button (Img. 2), Google gives you a URL to your calendar’s XML. You must make the calendar you want to use in your AS3 project public.

Click Settings to find the Google Calendar XML URL for your AS3 project

Click the Orange XML Button

Once you have the URL to your XML, you may want to append some sorting options to your XML.

Sort Your XML Before You Use It

By default, Google adds events to your XML by the date the event was created on the calendar, not by the event’s start date or end date. This is odd but there is a quick fix. By appending a little more data to your calendar URL, you have have sorted XML. I recommend adding this to the end of your URL:

?orderby=starttime&sortorder=ascending&max-results=5

Now that you have sorted, usable XML, let’s add it to your Actionscript.

The Code

Here is a short example of how to parse your Google Calender XML in Actionscript 3.0.

var xmlLoader:URLLoader = new URLLoader();
var xml_data:XML = new XML(); 
xmlLoader.addEventListener(Event.COMPLETE, load_xml); 
 
xmlLoader.load(new URLRequest("http://www.google.com/calendar/feeds/0p18vi9o7tve7uokobk4irlhb4@group.calendar.google.com/public/full?orderby=starttime&max-results=5&singleevents=true&sortorder=a"));
 
function load_xml(e:Event):void {
 
	xml_data = new XML(e.target.data);
	parse_xml(xml_data);
 
}
 
function parse_xml(xml_data:XML):void {
 
	// Number of XML / Calendar Entries
	var numEntries:int = xml_data.*::entry.length();
 
	// Loop for Event Title and Summary
	for(var i:int=0; i<numEntries; i++) {
 
		var event_text = xml_data.*::entry[i].*::title.text().toXMLString();
		var eventStartDate = xml_data.*::entry[i].*::summary.text().toXMLString();
		trace(event_text);
		trace(eventStartDate);
 
	}
 
}

If you have some basic knowledge of AS3 loaders, then this will not look very complicated. First, we create a new AS3 loader, which will grab our XML and load it up so we can put it to use. Once you actually deploy your flash site, you may need to use a PHP XML proxy file to spoof your sever into thinking the Google Calendar XML is local.

After we create the loader, we add an event listener that sends the data to our parse function after the data loads. Then, we’re off and running. Make sure you replace the Google URL with our own calendar URL (I have a demo in there now). You can also change which XML node data you’d like to get by the word “title” in the event_text variable with the name of another node in the XML. See below:

xml_data.*::entry[i].*::NODE_YOU_WANT.text().toXMLString();

In light of this, I’m restructuring my blog to only focus on these languages and environments. I will also look at content management systems, but only in a limited scope. Most of my content management system talk will probably be connected with Typo3.

And, because I am a higher-ed web professional, I may sneak in a few posts about marketing and web development from the university website perspective.

To kick things off, check out my latest post: Building a Basic Authorize.net Payment Form.

Luckily, Authorize.net does a very good job providing documentation to web developers, making this form creation process very easy.

This form is for Authorize.Net’s Advanced Integrated Method, the recommended connection method that offers the most security and flexibility.

The whole point of secure online transactions is that sensative information, especially credit card information, should never be stored in a database. That information should be used to handle a payment then immediately forgotten. Some online retailers save the last 4 digits of a credit card but only for recipt purposes. The form I will help you build will forget the credit card info, making it ultra safe. I will also show you how to log this form data in a database.

Step 1: Database

First we need a database. Here is a little SQL to get you going:

CREATE TABLE IF NOT EXISTS `transaction_log` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`pid` int(11) NOT NULL,
`response_code` int(11) NOT NULL,
`payment_data` text NOT NULL,
`response_data` text NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ;

The record keeping system I use serializes data, which is very basic. This works to keep you out of tax problems (because you have a complete payment record) but it isn’t the best for a direct download because the data has to be un-serialized.

Step 2: The HTML Form

Now on the the HTML. I am going to append a little bit of Javascript and a touch of PHP into this HTML form.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

<?php   if(isset($_POST['run'])) { include('payment_validation.php'); }   ?>   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>Payment gateway Form</title> </head>   <body> <form name="payment" action="" method="post" onsubmit="document.getElementById('submit_button').disabled = 1;"> <p><input type="hidden" name="page_id" value="4"></p> <p><label>First Name</label><input type="text" name="first_name"></p> <p><label>Last Name</label><input type="text" name="last_name"></p> <p><label>Comments</label><textarea name="comments"></textarea></p> <p><label>Card Num</label><input type="text" name="cc_card_num"></p> <p><label>Expiration Date</label><input type="text" name="cc_exp_date"></p> <p><label>Amount</label><input type="text" name="cc_amount"></p> <p><label>Description</label><input type="text" name="cc_description"></p> <p><input name="submit" id="submit_button" type="submit"></p> <p><input type="hidden" name="run" value="true"></p> </form> </body> </html>

It is good to take special note of the “onsubmit” attribute I’ve added to the form tag. This little snippet of Javascript prevents someone from accidentally clicking the submit button twice, thereby avoiding doubled transactions. The PHP at the top of the example HTML includes our payment validation script once the form is submitted. The “payment_validation.php” script it includes validates whether or not we have filled out all the form’s required fields. Now, some of these fields must be required because Authorize.net has a set of required information that they use for payment processing, including name, card number, etc. The PHP below just makes sure we have all that information.

Step 3: Validation

I am not going to go into to much more detail about form validation with PHP. That’s a topic for another tutorial. I will warn you, though, that the validation I use in this script is very basic. You should spend time making it stronger.

<?php
 
$required_fields = array(
	'page_id' => 'page_id',
	'Amount' => 'cc_amount',
	'Credit Card Number' => 'cc_card_num',
	'Credit Card Expiration Date' => 'cc_exp_date',
	'Description' => 'cc_description'
);
 
function verify_data_present($required_fields) {
 
	$errors = array();
 
	if(empty($_POST)) { // Ensure we have some data
		die("<strong>No Post! Nothing to send to Authorize.net</strong>");
	}
 
	// Make sure that all of the required fields exist as keys in the post array
	foreach($required_fields as $key => $value) {
		if(!in_array($value, array_keys($_POST))) {
			$errors[] = $value . " does not exist in post data and is required!";
		} else {
			if(empty($_POST[$value])) {
				$errors[] = $key . " is a required field.";
			}
		}
	}
 
	if(!is_numeric($_POST['cc_card_num'])) $errors[] = "Card number must be numeric!";
 
	if(!is_numeric($_POST['cc_amount'])) $errors[] = "Amount must be a decimal of form x.xx without the dollar sign!";
 
	if(!empty($errors)) {
 
		echo "<div><ul>";
		foreach($errors as $value) {
			echo "<li>" . $value . "</li>";
		}
		echo "</ul></div>";
		return false;
 
	} else {
		return true;
	}
}
 
// Verifty Required POST data isn't empty
if(!verify_data_present($required_fields)) {
	die();
} else {
	include('gateway.php');
	echo "<div class="approved">Your transaction has been approved.</div>";
}
?>

Step 4: The Gateway

Near the end of this PHP script, you will see this line: include('gateway.php');. That is the magic PHP include that sends along the payment information to Authorize.net and, even if the payment fails, adds the transaction details to your database. Let’s take a look at that script now. I warn you, though, this PHP is intimidating at first glance.

<?php
 
// Settings
$post_url = "https://test.authorize.net/gateway/transact.dll";
$db_host = "localhost";
$db_user = "root";
$db_pass = "";
$db_name = "payments";
$db_table = "transaction_log";
 
// Setup the array with data to post to authorize.net
$post_values = array(
	"x_login" => "********", // Given to you by Authorize.net (make sure you replace!)
	"x_tran_key" => "****************", // Given to you by Authorize.net (make sure you replace!)
 
	"x_version" => "3.1",
	"x_delim_data" => "TRUE",
	"x_delim_char" => "|",
	"x_relay_response" => "FALSE",
 
	"x_type" => "AUTH_CAPTURE",
	"x_method" => "CC",
	"x_card_num" => $_POST['cc_card_num'],
	"x_exp_date" => $_POST['cc_exp_date'],
 
	"x_amount" => $_POST['cc_amount'],
	"x_description" => $_POST['cc_description'],
 
	// The Values Below are Optional
 
	"x_first_name" => "John",
	"x_last_name" => "Doe",
	"x_address" => "1234 Street",
	"x_state" => "CA",
	"x_zip" => "90210"
);
 
// This section takes the input fields and converts them to the proper format
// for an http post. For example: "x_login=username&amp;x_tran_key=a1B2c3D4"
 
$post_string = "";
foreach( $post_values as $key => $value )
	{ $post_string .= "$key=" . urlencode( $value ) . "&amp;"; }
$post_string = rtrim( $post_string, "&amp; " );
 
// This sample code uses the CURL library for php to establish a connection,
// submit the post, and record the response.
// If you receive an error, you may want to ensure that you have the curl
// library enabled in your php configuration
 
$request = curl_init($post_url); // initiate curl object
	curl_setopt($request, CURLOPT_HEADER, 0); // set to 0 to eliminate header info from response
	curl_setopt($request, CURLOPT_RETURNTRANSFER, 1); // Returns response data instead of TRUE(1)
	curl_setopt($request, CURLOPT_POSTFIELDS, $post_string); // use HTTP POST to send form data
	curl_setopt($request, CURLOPT_SSL_VERIFYPEER, FALSE); // uncomment this line if you get no gateway response.
	$post_response = curl_exec($request); // execute curl post and store results in $post_response
	// additional options may be required depending upon your server configuration
	// you can find documentation on curl options at http://www.php.net/curl_setopt
	curl_close ($request); // close curl object
 
// This line takes the response and breaks it into an array using the specified delimiting character
$response_array = explode($post_values["x_delim_char"],$post_response);
 
/*
 * Before we allow the system to do anything with the
 * rest of the form data we need to make sure that the
 * credit card number gets removed to prevent sensitive
 * information from getting out just in case we are
 * compromised.
 */
 
unset($_POST['cc_card_num']); // remove the credit card info
 
print_r($response_array);
 
// **********************************************
//     NOW WE CAN DO STUFF WITH THE RESPONSE
// **********************************************
 
// Connect to the database
$mysqli = new mysqli($db_host,$db_user,$db_pass,$db_name);
 
// Check db connection
if(mysqli_connect_errno()) die(mysqli_connect_error());
 
// Store the form info
$query = "INSERT INTO ".$db_table." SET pid = '".$_POST['page_id']."', response_code = '".$response_array[0]."', payment_data = '".serialize($_POST)."', response_data = '".serialize($response_array)."'";
 
if(!$mysqli->query($query)) {
	echo $mysqli->error;
}
 
unset($_POST);
?>

This script looks scary but it is quite straight forward. It starts with some basic variable declarations, which consist of database connection variables and a very important $post_url. This defines the URL we will use to POST data to Authorize.net. It is currently set to the default Authorize.net test environment. That way we don’t have to worry about actually spending money to experiment with this payment form.

The next part of this “gateway.php” script is an array of data called $post_values. This is the actual array of data that gets sent to Authorize.net. Notice the POST data we are adding from our form. That’s the real bread and butter of the whole process! More importantly, though, are two parts of this array that identify who you are to Authorize.net. They are the x_login and x_tran_key. I think of these as my username and password to Authorize.net. Make sure that when you get your login and key from Authorize.net (after your account setup) to keep them safe. You will have to add your login and key to this form. You can request a test account from Authorize.net.

After the $post_values array you’ll begin to see more complicated PHP. You do not need to edit this data. Whet you see is the initialization of a CURL object which handles the POST of our data to Authorize.net. It also handles the response we get, which tells us whether or not our payment was approved. That response gets added the $post_response array defined on line 55 of the “gateway.php” script.

After this CURL object (in the PHP) you’ll see a few lines of code that add the serialized POST data to our database, sans any credit card information. The credit card is stripped from our data on line 71 of the “gateway.php” script with the unset($_POST['cc_card_num']); command.

Finished

That’s it! Please take note that I echo the response array after the form is submitted. Interpreting this response can be challenging, but you can do it with help from the Authorize.net Developer’s Guide. This form is available for download.

Thanks

Thanks to Ben Lobaugh for his help with this script.

New features include the ability to follow publishers and writers, a re-vamped contest page that’s sort-able, a place for publishers to add submission guidelines, and an activity wall that lets users see the announcements and updates from writers and publishers they follow.

I invite you to see the new LitList for yourself. Visit http://www.litlist.net

The Problem

This is the heart of the problem: channel.position mis-reports the actual position of the audio for mp3 files less than 128kbps.

Files larger than 128kbps seem to work fine. It has also been suggested that in order for channel.position to work correctly, the mp3 audio must also sampled at 44.100kHz. It is also reported that Adobe has been notified of this bug.What surprised me the most about his endeavor is Adobe’s over-sight with their SoundChannel. Not only is it, reportedly, loaded with bugs, but it also lacks basic functions. While we have a play() and stop(), for example, we aren’t given a pause().

I originally found information about this problem at http://www.stevensacks.net/2008/08/07/bug-with-sound-channel-position-and-mp3s-less-than-128kbps/.

The Solution

Until Adobe fixes this problem, re-sample your audio greater than 128kbps.

Wordpress

Wordpress is a system that comes hopped up on easy pills, and because of this, bloggers and developers love it equally. With Wordpress 2.8, you can have a whole system online within a few minutes, including a pre-packaged theme. But this blogging platform also comes with some disadvantages.

The Positives

• Wordpress is easy to install.
• Thousands of extensions make Wordpress flexible.
• Online support in the Wordpress Codex is very good.
• Easy to update.
• Easy back-end navigation.
• You don’t need to know much PHP.

Getting a site out of idea land and into code is very easy with Wordpress. After you run through the short install process, you have thousands of choices on ways to extend your Wordpress install by using any number of extensions, some of which even make Wordpress act more like a CMS. Take, for example, Sitemap Generator, a plugin that builds a site maps for Wordpress sites. Developers would tell you that having a site map ready for Google to consume is essential. Other CMS-like plugins available for Wordpress include user permissions extenders and plugins that give you hierarchical page navigation.

One thing you don’t need to worry about is Wordpress’ lack of support. Their support site is very thorough. Even learning about Wordpress’ specific functions is quite easy. One more note about Wordpress’ positive aspects: since Wordpress 2.8, you’ve been able to update the platform very easily. Literally with the click of a button, Wordpress can get a new back-end.

The Negatives

• Wordpress is too popular, and thus a major target for spammers.
• Limited scope.

The reason I mentioned the ease of being able to update Wordpress is because, if left in a legacy state your Worpress install will eventually get hacked. Because of its popularity and its core blogging focus, spammers actively try to take advantage of Wordpress to post spam comments and posts. But as long as you update your platform, the spammers stay at bay. Using Akismet also helps.

Wordpress, too, when compared to other online content platforms, has a very limited scope. Its purpose is really to blog. So, if you are planning to build a site with multiple blogs, each of which have multiple authors, then look for a different platform. Or if you are planning to build a more dynamic site, one which frequently interacts with a database or collects data online, then Wordpress probably isn’t for you.

Drupal

Do you look at a page of PHP and release a high-pitched squeal of excitement? If so, Drupal might throw you into cardiac arrest. While that might sound bad to Wordpress lovers, Drupal is, in fact, very similar to Wordpress in a number of ways. It too has good and bad properties.

The Positives

• Drupal is easy to install.
• You can theme everything, including the back-end.
• Online support is is very good.
• Thousands of extensions are available.
• You can build large sites.

Since version 5, Drupal (which is in version 6 now) has had a similar step-though installation process to that of Wordpress. But some call it more challenging. The install processes of both platforms seemed equal to me, neither of which were too complicates. As long as you know your database login information, you are fine.

Similarly too, Drupal has plenty of extensions. Installing extensions, too, is just like installing them in Wordpress. Download the files and copy them into a plugin directory.

The major advantage you get from Drupal over Wordpress is that you can build sites that go far beyond the blogging scope, though you can blog with Drupal too. Everyone from large corporations to small businesses use Drupal to give themselves a usable web space. Shopping cart systems, for example, are much more common in Drupal than in Wordpress. If you use Drupal, however, don’t expect the ride to be as easy as it is on the Wordpress train. Getting Drupal to do what you want can sometimes take writing your own PHP or modifying extensions, even though it gives you an excellent framework for adding content and pages to your site. And it comes with more robust architecture for you to exploit in sites, like the ability to add pages in a hierarchy.

The Negatives

• Building extensions requires a thorough knowledge of Drupal’s hook system.
• You must be very well versed in HTML, CSS, and PHP.
• Back-end navigation isn’t as friendly.
• Less clear distinction between front-end and back-end.

Drupal, unlike Wordpress, just isn’t as user friendly. There is less of a distinction between the back-end and the front-end of a Drupal site, which often made me feel confused about my location. I kept looking for a back-end, which is why I recommend skinning the back-end and front-end differently. Also, Drupal’s back-end navigation isn’t as friendly. More clicking is involved to get you into CMS settings and content creation, whereas Wordpress has everything conveniently organized in their back-end menu.

Those are some basic differences between Drupal and Wordpress. Here’s what you should take to the bank: each of these systems can be used to blog, so take that as an excuse to learn both. Once you start blogging in Drupal, you may just turn into a PHP whiz that will never resort to simple blogging again. Or you might find yourself prepared to build more complicated sites for larger clients.

Firefox and Chrome have more support for emerging standards like HTML5 and CSS3, but Internet Explorer 8 invested heavily in having world-class, consistent support for the entire CSS2.1 specification.

Dear Microsoft,

Thank you for putting out a waste of code that will, again, send web programmers into cardiac arrest. You should have had CSS 2.1 compliance years ago, with all other popular browsers. The reason programmer’s don’t use CSS3 is because CSS3 isn’t supported by Internet Explorer, essentially making IE8 the new IE6: a turd.

First, let’s look at the code. Below is a complete weather XML parsing function that allows you to call the current temperature (or other weather information) using a zip code.

<?php
channel->item->children("http://xml.weather.yahoo.com/ns/rss/1.0");
 
foreach($items as $x => $item) {
	foreach($item->attributes() as $k => $attr) {
		if($k == 'day') $day = $attr;
		if($x == 'forecast') {
			$forecast[$x][$day . ''][$k] = $attr;
		} else {
			$forecast[$x][$k] = $attr;
		}
	}
}
 
if(isset($forecast)) {
	return $forecast['condition']['temp'];
} else {
	return "Weather for that zip code is unavailable.";
}
 
echo weather("83642");
?>

What Is All This?

All this code is actually pretty easy to understand. Lines three and four of the function are simplexml commands that load some XML for us to work with. For more information about simplexml, dig around on PHP’s website.

Now, right after we load the XML, we need to break the XML into workable pieces, which is done on line 9. Now, if you look at the raw XML supplied from Yahoo, you’ll notice that the current temperature is actually an attribute of an XML tag. So, in lines 15 through 19, we use PHP to build an array of the XML items (defined by the tag) and their attributes, out of which we return the current temperature on line 21.

So, once the data is parsed, you should be able to call back information you want, like the forecast. Try returning something like this on line 21, making sure you grab the right day:

$forecast['forecast']['Thu']['text'];

That’s It

Now, have fun with this. Add weather info wherever you want!

Try adding this code, with your domain, to your root .htaccess file:

RewriteEngine On
RewriteCond %{SERVER_PORT} !^443$
RewriteRule ^typo3(/(.*))?$ https://www.example.com/typo3/$2 [R=301,L]

Once working, your /typo3 directory should be secure.

How Do I Know if Imagemagick is Installed?

There are two good ways of seeing whether or not Imagemagick is installed on your sever. Usually, if you host your site on a larger host provider, like GoDaddy, Imagemagick will be provided. But if you are not sure, here is how to check your Imagemagick install from the server side and through Typo3.

To check if Imagemagick is installed on your Linux based server, try typing the following command into a terminal window:

convert

If Imagemagick is installed, you should see a screen of help cascade through the terminal window. If not, you’ll get an error. You can also check to see if Imagemagick is installed through Typo3’s Install module. To access the Typo3 Install module you would need to create an empty file named ENABLE_INSTALL_TOOL (there is no file extension) and put it into “typo3conf” folder. Once inside, click on “Image Processing” and scroll down to “Current Configuration”.

This section will tell you if Typo3 was able to locate an Imagemagick installation on the server. The image below is an example of the server configuration with Imagemagick.

Install Imagemagick

Installing Imagemagick on a Linux server is quite easy. It is even easier on the Windows side. I am only going to cover a Linux installation in this guide.

First, download the latest version of Imagemagick.

Second, unzip the download files.

Third, open a terminal window and navigate to the files you just unzipped. I unzipped the files to my root directory, so I navigated with a command like:

cd ImageMagick-6.5.1

Once in the Imagemagick folder, run the following commands to configure the installation, make the install, and install the files.

./configure

make

If ImageMagick configured and compiled without complaint, you are ready to install it on your system. Administrator privileges are required to install. On a recent attempt to install Imagemagick, I was missing some image libraries, so my first attempt to install Imagemagick failed. Make sure you have all the necessary libraries installed. If you don’t, you may see some errors at the end of the ‘make’ command’s output.

If you are ready to install, use the following command to get jpg and png support on the server. Sometimes, the default Imagemagick install commands don’t provide all the necessary features for Typo3. Installing Typo3 with the ‘–with-jpeg’ and ‘–with-png’ tags should fix that problem.

make install --with-jpeg --with-png

OnceTypo3 is successfully installed, you will need to restart your web server. This will ensure that Apache is looking for and using the Imagemagick extensions. You will also need to return to the Install module in Typo3 and make sure that Typo3 is seeing and using Imagemagick.

Once everything is complete, your thumbnails should be working on the backend (no more yellow question marks) and image resizing should be a breeze!