[cce_cfm]
<cfcontent type="text/xml" reset="Yes"><?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
  <atom:link href="http://www.YourSite.com/index.cfm/feed"
    rel="self" type="application/rss+xml" />
  <title>YourSite.com</title>
  <link>http://www.YourSite.com</link>
  <description>Your Description Goes Here</description>
  <cfoutput>
    <pubDate>#HTMLEditFormat(DateFormat(now(), 'ddd, dd mmm yyyy'))#
      #HTMLEditFormat(TimeFormat(now(), 'HH:mm:ss'))# EST</pubDate>
  <language>en-us</language>
  <ttl>40</ttl>
  <s:find slug="blog">
  <s:children-each order="publishedAt desc" where="status='published'">
    <item>
      <cfset thisChild = request.tags.currentChild>
      <title>#HTMLEditFormat(thisChild.title)#</title>
      <description><![CDATA[<s:content part="body" page="#thisChild#"/>]]></description>
      <pubDate>#HTMLEditFormat(DateFormat(thisChild.publishedAt, 'ddd, dd mmm yyyy'))#
         #HTMLEditFormat(TimeFormat(thisChild.publishedAt, 'HH:mm:ss'))# EST</pubDate>
      <guid isPermaLink="true">http://www.yoursite.com/index.cfm/#thisChild.slug#</guid>
      <link>http://www.yoursite.com/index.cfm/#thisChild.slug#</link>
    </item>
  </s:children-each>
  </s:find>
</channel></cfoutput>
</rss></cfcontent><cfabort>
[/cce_cfm]

Most of this code is the required RSS XML. Just drop in your site-specific domain name, description, etc.

The <s:find slug=”blog> tag finds the blog, and then <s:children-each> loops over all the children that are under the blog page. I used thisChild as a convenience variable instead of having to type request.tags.currentChild every time. The <cfabort> at the end keeps Splash from adding extra HTML tags at the end of the file.

You could also create an easy XML site map using a similar approach. Just change out the XML wrapper.

• <s: find>
• <s: children-each>
• <s: children-first >
• <s: children-last >
• <s: ifFirst >
• <s: unlessFirst >
• <s: ifLast >
• <s: unlessLast >

There’s a complete list of tags and documentation over on the GitHub Wiki. But, I’ll give you an overview and show you how to use these tags for a blog.

<s:find> This tag looks up a page and stores the page object so that subsequent tags can use that page object.

<s: children-each> The tag finds all the children of a page and loops over them.

<s: children-first > and <s: children-last > finds the first or last child page.

The rest of the tags are all used inside of a <s: children-each> tag. They check to see if the current child page is the first one, last one, or whatever.

Making a Blog page with Splash Tags

Let’s say you have a page named Blog, that has several posts that are child pages of Blog. Then, in the body for the blog page, put something like this:

[cce_cfm]
<h3>Articles</h3>
<s:find slug="blog">
  <s:children-each
   order="publishedAt desc"
   where="status='published'">
    <cfset thisChild = request.tags.currentChild>
    <cfoutput>
      <dt class="blogList">
         <a href="#thisChild.slug#">#thisChild.title#</a>
            | #DateFormat(thisChild.publishedAt, 'long')#</dt>
      <dd class="blogDesc">#thisChild.description#</dd>
    </cfoutput>
  </s:children-each>
</s:find>
[/cce_cfm]

<s:find slug=”blog”> finds the blog page, and then <s:children-each> loops over all the pages. By the way, <s:children-each> uses the CFWheels findAll model method, so all of the cool CFWheels parameters are available in <s:children-each>!

If you want to see an example of what this looks like, visit the DonorUp blog page.

All in all, that’s a lot of output for very little programming effort. That’s what I call the secret to programmer happiness!

CFWheels is an open source ColdFusion framework that is inspired by Ruby on Rails. Besides being easy to use and learn, using CFWheels lets you adapt great ideas from Ruby on Rails (RoR) applications. RoR has the Radiant CMS, and Splash is the ColdFusion/CFWheels adaptation!

You can easily download Splash from http://wiki.github.com/russjohnson/SplashCMS/. The documentation for Splash is still kind of sparse, but the Radiant documentation is mostly applicable, and you can easily see how most things are supposed to work. Then, if you get stuck, email the Google Group.

Splash Layouts, Snippets, and Pages

Splash uses Layouts, Snippets, and Pages to build a website.

A layout, as you might imagine, is like a skin for an entire website. You can have multiple layouts and use different layouts for different pages.

Pages are specific URLs on a Splash site, and each page has a specific layout specified. A page can have multiple “page parts.” Most pages will have a “Body” part, but some might also have a “Sidebar” or other parts.

Snippets are reusable content chunks. You might have a navigation snippet that displays the main navigation for your site. Headers and Footers are other common snippets.

Splash Tags

There is one other very powerful component to Splash — Splash Tags. These are ColdFusion custom tags that extend ColdFusion and HTML to work with Splash. Here’s a simple example: the [ccei_cfm]<s:title /> [/ccei_cfm] tag. This tag just retrieves the page’s title from the page object and inserts it in place of the tag. So, in your layout, you would typically have something like:

[ccei_cfm]<title><s:title /></title>[/ccei_cfm]

The pages title information from the database is then easily inserted into the HTML title tag!

There are a lot more tags, so see the Wiki.

Splash in Action

I recently completed the DonorUp.com website using Splash. I was really pleased with how easily I was able to get many thing to come together. So, try Splash and leave a comment to let me know how you like it!

On the CFWheels Google Group, Cathy recently asked about the sendEmail() function. This is a pretty good example to show you some debugging tips.

sendEmail() wraps the cfmail tag. Here’s some more information:

CFWheels on sending email.

This all looks pretty straightforward, but what do you do if it’s not working?

First, setup a test view page. Go to the Wheels views folder and add a new folder called test. Then create a new file called index.cfm in the test folder. The path should be /views/test/index.cfm.

In the index.cfm file you just create, put the following:

[cce_cfm]
<cfset
	set(functionName="sendEmail",
	server="yourServer",
	username="yourUsername",
	password="yourPassword")
>
[/cce_cfm]

This will trigger the sendEmail() function. You can access the test page at http://localhost/index.cfm/test. But, if you go to this page, you’ll get an error because we didn’t create myemailtemplate, yet. So, make another CFM page in /views/test/ called myemailtemplate.cfm. The content can be anything you want. Something like “Test email” is fine.

Wheels knows you are in the Test controller, so it looks for templates in the /views/test folder. Wait a minute! You never said anything about creating a controller. That’s one of the cool things about Wheels. Even without a controller, it will still show you the view page, and things still work!

Now, go back to the test page at http://localhost/index.cfm/test. If everything is working, you should get an email message. If it’s not working, you can put other stuff in your test page. Try these out:

• <cfdump var=”#params#”> will show you the params structure with your actions, controller, data you’re passing, etc.
• <cfdump var=”#wheels#”> will show information on your filters.
• <cfdump var=”#application.wheels#”> will show all the wheels settings, functions, routes — All kinds of cool things.

Now sendEmail() is a little trickier. It uses ColdFusion’s <cfmail> tag. Put this in your /views/test/index.cfm file:

[cce_cfm]
<cfmail from="me@mydomain.com"
    to="me@mydomain.com"
    subject="Test Message">
  This is a test
</cfmail>
[/cce_cfm]

If this won’t work, then it’s your server configuration, not Wheels. You may have to specify your server name or login information. That’s pretty easy, too. Just put the following in your config/settings:

[cce_cfm]
<cfset
	set(functionName="sendEmail",
	server="yourServer",
	username="yourUsername",
	password="yourPassword")
>
[/cce_cfm]

I hope this helps!

For the DonorUp website, I used CFWheels and the Splash CMS. Once I knew the tricks, it turned out to be really easy to make this work. So, I decided to write a post to explain what you need to know.

Typically, in ColdFusion, you add an onError() method to your Application.cfc file. Wheels gives you various hooks into Application.cfc, but Wheels already has an onError() method. So, you can’t add another one! Fortunately, Wheels has an easy way to handle most errors.

How to send error messages from CFWheels

All you have to do to get Wheels to send error message emails  is add the following into your /config/settings.cfm file:

<cfset set(sendEmailOnError = true)>
<cfset set(errorEmailAddress = “you@yourServer.com”)>

Now, whenever there’s an error, you’ll get a really nice email with all the troubleshooting info you’ll need. Easy!

How to setup a custom error page in CFWheels or Splash

As part of its built-in error handling, Wheels runs the file at /events/onerror.cfm. Just put a redirect to your error page at the top of onerror.cfm and you’re done:

<cfset redirectTo(route=”viewer”, slug=”error-page”)>

In my case, I went into the Splash CMS admin and added a page called Error Page. This way, the page is automatically styled to match the rest of the site. The error page apologizes to the user for the error, and let’s them know I am going to fix it!

When Wheels does its error handling, it will run /events/onerror.cfm, and the redirectTo() will send them to my error page! If you aren’t running Splash, you could just use the other arguments of redirectTo() to send them to any controller and action.

You can also put your own HTML or CFML code in onerror.cfm, but I like doing it this way better as it uses all the layouts and styling of my site!

Please leave me a comment if you like this approach or have other ideas!

Recently, I have been customizing a Mura site, so I thought I’d document some of the key things you need to know!

1 – Create a New Site to Customize

When initially installed, Mura automatically creates the  “Default” site. But, don’t customize this site. Make a new site and customize it. This way, you can still do Mura updates without overwriting your customizations.

• Login to your admin area
• Go to Site Settings -> Add New Site. (Site Settings is in the upper right of the admin screen.)
• Name the site whatever you want. For example, you might call it MySite.
• Now, when you go to customize things, don’t look in the Default folder. Instead find the MySite folder.
• If you want MySite to come up automatically when you go to www.YourDomain.com, click on Site Settings. Then, use the Order drop downs to set MySite to 1.

2 – Customize /MySite/includes/

Much of what you’ll want to customize is in the /MySite/Includes/ directory. Here are some things you might want to customize:

• If you are using a theme like Merced, customize the style sheet at /MySite/includes/themes/merced/css/site.css. It’s a good idea not to change the other style sheets. Just override the style in site.css. More Info from Mura …
• Again, if you’re using Merced or another theme, customize the templates at /MySite/includes/themes/merced/templates/.  Don’t forget to look in the /inc folder for the header and footer includes. More Info from Mura …

3 – Change the behavior of Display Objects

You can change how the Display Objects work! For many Display Objects, you can just copy the display object, put it in /MySite/includes/display_objects/custom/ and modify your copy. I wanted to add a download link to the images in the image gallery, so it was more complicated. Matt Levine of Mura advised me to:

• Go get /MySite/includes/eventHandler.cfc and add a new onGalleryBodyRender function (See below).
• Create a new directory named gallery at /MySite/includes/display_objects/custom/gallery. Into this new directory, copy index.cfm from /default/includes/display_objects/gallery/index.cfm. Now we have a copy of the gallery file to customize, so customize your heart out!
• Stay in /gallery/index.cfm. Find the references to getSite() and queryPermFilter() method calls. Change these to renderer.getSite() and renderer.queryPermFilter().
• Still in /gallery/index.cfm, change the template path in <cfinclude template=”../dsp_nextN.cfm”>. The new path should be ../../../dsp_nextN.cfm.
• Reload the app either by clicking Reload Application in the admin, or adding ?appreload to the end of the url. A lot of the objects are loaded when the application starts, so I found it’s a good idea to reload after making changes.

Here’s the code for the updated eventHandler.cfc:

[cf]

<cffunction name="onGalleryBodyRender" output="true" returntype="void">
<cfargument name="event">
<cfset var renderer=event.getContentRenderer()>
<cfsilent>
<cfset renderer.loadShadowBoxJS() />
<cfset renderer.addToHTMLHeadQueue("custom/gallery/htmlhead/gallery.cfm")>
<cfif not event.valueExists(‘galleryItemID’)><cfset event.setValue(‘galleryItemID’,”)></cfif>
</cfsilent>

<!— When you override default output you need to run content throught the renderer.setDynamicContent() method to process [mura] tag calls—>
<cfoutput>#renderer.setDynamicContent(event.getValue(‘contentBean’).getBody())#</cfoutput>

<!— Now include the customized display object —>
<cf_CacheOMatic key="portalBody#event.getValue(‘contentBean’).getcontentID()##event.getValue(’startRow’)##event.getValue(‘galleryItemID’)#" nocache="#event.getValue(‘r’).restrict#">
<cfinclude template="display_objects/custom/gallery/index.cfm">
</cf_CacheOMatic>

</cffunction>
[/cf]

I hope this helps someone get started with Mura! If you have suggestions for improving this information or just have a question, please leave a comment.

Just like Rails, CFWheels supports layouts to create a master template and to avoid repeating yourself.

For our simple app, we could just work with the default layout located at /views/layout.cfm. But, to follow the book, let’s create a controller-specific layout at: /views/ads/layout.cfm. So, this layout.cfm in the /view/ads/ subdirectory will only be used for views associated with the ads controller.

[cf]
<!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>
<cfoutput>
<title>Ads: #params.action#</title>
#stylesheetLinkTag("default")#
</cfoutput>
</head>
<body>
<cfoutput>
<div id="wrapper">
<div id="header">
<div>
<h1>MeBay</h1>
<ul id="nav">
<li>#linkTo(text="All Ads", route="adsNoKey")#</li>
</ul>
</div>
</div>

<div id="content">
#contentForLayout()#
</div>
<div id="clearfooter"></div>
</div>
<div id="footer"></div>
</cfoutput>
</body>
</html>
[/cf]

Most of this code is HTML boilerplate. #params.action# inserts the name of the current action in the Title tag. The params structure is always passed from the controller to the view. It includes the name of the action, variables, etc. You can always cfdump it out if you want to see what all is in there.

#stylesheetLinkTag(“default”)# uses another CFWheels helper function. By convention, stylesheets are located in the /stylesheets directory. So this function builds the link to our stylesheet named default.css. Download the code for Chapter 2 from the Head First Rails website, and get default.css from the /public/stylesheets/ folder. In CFWheels, put default.css in your /stylesheets folder. If you have trouble with the stylesheet, make sure all the images references are correct. If your web server configuration is different, you might need to adjust the paths.

On line 16, we’ve setup a link to our index action.

On line 22, you see #contentForLayout()#. This is where CFWheels puts the content from the other view pages — show.cfm and index.cfm. It’s the equivalent of <%= yield %> in Rails.

That’s it! Now we have a pretty, styled meBay application. Visit http://localhost/index.cfm/ads/ and see how pretty things look.

Next, it’s on to Chapter 3. In software development, things always change. And, now meBay wants to let people post ads online!

First, let’s add a new route so that http://localhost/index.cfm/ads/ goes to the new index action we’ll add in a minute.

Open up /config/routes.cfm, and change it to:

[cf]
<cfset addRoute(name="ads", pattern="/ads/[key]", controller="ads", action="show")>
<cfset addRoute(name="adsNoKey", pattern="/ads/", controller="ads", action="index")>
<cfset addRoute(name="catchall", pattern="[path]", controller="redirect", action="index")>
<cfset addRoute(name="home", pattern="", controller="redirect", action="index")>
[/cf]

Notice the new route on line 2: <cfset addRoute(name=”adsNoKey”, pattern=”/ads/”, controller=”ads”, action=”index”)>. CFWheels checks the routes in order. So, if the URL pattern matches /ads/[key], it will go to the show action. But, if the key isn’t there, it matches the /ads/ pattern and goes to the new index action.

Now, we need to add an index action to the controller and then an index.cfm view. Open up /controllers/Ads.cfc and add the new index function. Leave the show function alone.

[cf]
<!— ads/index —>
<cffunction name="index">
<cfset ads = model("Ad").findAll()>
<cfdump var="#ads#"><cfabort>
</cffunction>
[/cf]

Notice the that we set ads = model(“Ad”).findAll().  This tells Wheels, to go get the Ad model, and findAll the data — Pretty Powerful! The data comes back as a ColdFusion query object.

For testing, put the <cfdump>line  in your controller, and send your browser to:  http://localhost/index.cfm/ads/. You’ll see the query dumped out in all its glory! This is a pretty good debugging trick. Add a <cfdump> to your controller to see what variables and data the controller is passing to the view. Remove the <cfdump> line, and let’s go create the view.

Go create /views/ads/index.cfm:

[cf]
<h1>All Ads</h1>
<ul>
<cfoutput query="ads">
<li>#linkTo(text="#ads.name#", route="ads", key="#ads.id#")#</li>
</cfoutput>
</ul>
[/cf]

Pretty simple! Specifying the query attribute in <cfoutput> makes this just like a <cfloop>. You end up with a bunch of List Items (<li>) — One for each record in the query we got from the controller.

linkTo() is another cool Wheels helper function. You could just use an <a> tag. However, using the linkTo() function is a best practice because it makes your application more portable. We specified the “ads” route in the function. If, later on, we changed our subfolders or URL rewriting, everything would still work.

That’s it. Send your browser to: http://localhost/index.cfm/ads/ and you should see a list of ads. Each ad will have a link that takes you to the show action and displays the ad.

First, we need to fix our controller at /controllers/Ads.cfc. Make sure your show function looks like:

[cf]
<cffunction name="show">
<!— Find the record —>
<cfset ad = model("Ad").findByKey(params.key)>
</cffunction>
[/cf]

When Wheels created the model, it automatically adds the findByKey method. All we have to do is tell it which key we want, and params.key has the key value!

We still need to fix /views/ads/show.cfm to display the data. Change this file to:

[cf]
<cfoutput>
<p><b>Name:</b>#ad.name#</p>
<p><b>Description:</b>#ad.description#</p>
<p><b>Price:</b>#ad.price#</p>
<p><b>Seller Id:</b>#ad.seller_id#</p>
<p><b>Email:</b>#ad.email#</p>
<p><img src="#ad.img_url#"/></p>
</cfoutput>
[/cf]

Pretty neat. Just put the values in the view and wrap it up in a <cfoutput> tag! Wheels handles the hard part of getting the data from the database into the model.

Go back to: http://localhost/index.cfm/ads/3, and you’ll see that the data is now being correctly displayed.

There’s a good section in the CFWheels docs on Using Routes.  But, I’m going to continue following along with the examples in Head First Rails, starting on page 56.

If you try a URL like this: http://localhost/index.cfm/ads/3, Wheels will give you an error: Could not find the view page for the ‘3′ action in the ‘ads’ controller. That’s because, Wheels is looking for the Ads controller with the “3″ action. Rails would complain that there is no action (Method in the Ads controller) called ‘3′. But, Wheels is smarter and just goes straight to the view. We don’t have a ‘3′ method in Ads.cfc, but Wheels still tries to load a view from /views/ads/3.cfm. The file isn’t there, so it throws an error.

Setting up a Route will let us fix this! Open up /config/routes.cfm. It defaults to something like:

[cf]
<cfset addRoute(name="home", pattern="", controller="wheels", action="congratulations")>
[/cf]

Did you ever wonder how you got to that nice congratulations page when you just go to: http://localhost/? What happens is that our route, the “home” route, says, that if the URL pattern is “” (Blank String), Wheels should go the the wheels controller, and run the action congratulations.

Take a peek at /controllers/Wheels.cfc. Sure enough, there is a congratulations method that loads up info on the current version of Wheels. And, then of course, it looks for the view in /views/wheels/congratulations.cfm. The file is already there as part of the default Wheels installation. If you open it up, you can see the HTML code including the place where it inserts the version information Wheels got from the controller.

The default routes.cfm file is nice, but lets make some changes!

[cf]
<cfset addRoute(name="ads", pattern="/ads/[key]", controller="ads", action="show")>
<cfset addRoute(name="catchall", pattern="[path]", controller="redirect", action="index")>
<cfset addRoute(name="home", pattern="", controller="redirect", action="index")>
[/cf]

It’s important to understand that Wheels goes through the routes in order from top to bottom. As soon as it finds a match, it goes to the appropriate controller. Here’s how you interpret this route.cfm:

• Ads. If the URL pattern looks like: http//localhost/index.cfm/ads/3, go to the show action in the ads controller. Did you notice the pattern includes [key]? This tells Wheels to set the key parameter to whatever is in the URL — 3 in this case.
• Catchall. If the URL doesn’t match the Ads pattern, Wheels will try the next pattern. This pattern matches [path]. In other words, it matches anything, and puts the value in the path parameter. Actually, it doesn’t put everything in the path paramter — Just the part before the next slash, “/”. http//localhost/index.cfm/xxx/yyy/zzz/3 will only have “xxx” in the path parameter. A route like this is a good one to add to catch any unknown URLs a user might enter — Sort of like a 404 Error page.
• Home. If the URL pattern  is blank, we’ve got one more route to cover that case. Remember, the pattern is just the stuff that comes after http//localhost/index.cfm/.

Ultimately Routes just offer a convenient way to map a URL to a controller. They are useful for having prettier URLs that make more sense to the users.  You can always use query params in your URL and completely bypass routes. This URL, http://localhost/index.cfm?controller=ads&action=show&key=3 directly specifies the controller and action, so there’s no need for Wheels to check the route!

I’m going to keep following the book, but there is a great tutorial that covers the same ideas over on the CFWheels website.

Convention Rules!  CFWheels has conventions for almost everything. As long as you follow the conventions, things just work naturally.

For example, look at a URL like this http://localhost/ads/show/5. CFWheels will automatically interpret this to run the show function in the ads controller. The number 5 is passed as a “key”.

Before I keep going, I have to touch on URL rewriting. The URL I just used as an example will only work if your server supports full URL rewriting. I’m using the ColdFusion development server, and it only offers “partial” URL rewriting. So, I have to use a URL like this: http://localhost/index.cfm/ads/show/5. Notice that index.cfm has to be inserted in the URL!

You can also specify the Controller and Action like this: http://localhost/index.cfm?controller=ads&action=show&key=5. Doing it this way will always work. It bypasses routes and any server URL rewriting problems. You might want to just use this form of URL while you are learning or if you are debugging a problem.

In any case, the idea is to run the show function in the ads controller. CFWheels will look for Ads.cfc in the controller folder, and will look for the show function inside Ads.cfc.

Then, it will run the show function and load the view. It will expect there to be a view file in /views/ads named show.cfm to match the function you called.

But, guess what? If you don’t create the Ads.cfc controller, CFWheels, will still try to run the view. Normally, you’ll want the controller to get some data for you, but if not, you could skip the controller altogether.

Here’s my controller code for /controllers/Ads.cfc:

[cf]
<cfcomponent extends="Controller">

<cffunction name="index">

</cffunction>

<cffunction name="show">

</cffunction>

</cfcomponent>
[/cf]

Later, we’ll add some functionality to the controller, but I’m following the book. And, for now, the only two actions we need are index and show.

At this point, you could try to go to http://localhost/index.cfm?controller=ads&action=show&key=5. But, you’d get a Wheels error because there is no view file.

Here’s my view code for /views/ads/show.cfm:

[cf]
<p><b>Name:</b></p>
<p><b>Description:</b></p>
<p><b>Price:</b></p>
<p><b>Seller Id:</b></p>
<p><b>Email:</b></p>
<p><img src=""/></p>
[/cf]

I know, this doesn’t do much either, but we’ll add on. Be Patient!

Now, if you go to http://localhost/index.cfm?controller=ads&action=show&key=5, you’ll see the lovely static view file you just created.

Next time, we’ll look at routes some more, and eventually, we’ll actually make this app work.

Starting on Page 45 in Head First Rails …

Whether we use scaffolding or not, we still have to create the database. In Rails, you do this with the script/generate model command and then running rake. But, in CFWheels, it’s easiest to just use SQL and create the database directly. Here is some mySQL code to create the needed ads table.

[sql]

CREATE TABLE `ads` (
`id` INTEGER PRIMARY KEY NOT NULL auto_increment,
`name` varchar(255),
`description` text,
`price` decimal,
`seller_id` integer,
`email` varchar(255),
`img_url` varchar(255),
`created_at` datetime,
`updated_at` datetime
);
[/sql]

Later on, we’ll want to populate the table with some sample data, so let me go ahead and show the full SQL that creates the table and adds the test data:

[sql]
DROP TABLE IF EXISTS `ads` ;
CREATE TABLE `ads` (
`id` INTEGER PRIMARY KEY NOT NULL auto_increment,
`name` varchar(255),
`description` text,
`price` decimal,
`seller_id` integer,
`email` varchar(255),
`img_url` varchar(255),
`created_at` datetime,
`updated_at` datetime
);
INSERT INTO `ads` VALUES(1,’Typewriter’,'Old manual typewriter. Many years useful service. Works best with a bottle next to it.’,71.95,54,’dhammett@email.com’,'http://homepage.mac.com/david_griffiths/typewriter.png’,”,”);
INSERT INTO `ads` VALUES(2,’Football’,'Some strings frayed.’,74.02,45,’marty@googlemail.com’,'http://www.freefever.com/freeclipart/clipart/football2.gif’,”,”);
INSERT INTO `ads` VALUES(3,’Moosehead’,'Slightly moth-eaten. One of the antlers is broken and there’’s a strange buzzing sound behind the eyes…’,2978.25,56,’kathy@hotmail.com’,'http://saloon.javaranch.com/ubb/moosefly.gif’,”,”);
INSERT INTO `ads` VALUES(4,’Desk’,'Milk desk – go…’,4800,123,’andy@allmail….’,'http://picasaweb.goog…’,”,”);
INSERT INTO `ads` VALUES(5,’Door curtain’,'Beaded door cu…’,11,773,’dawn@hotmail….’,'http://www.freewebsit…’,”,”);
INSERT INTO `ads` VALUES(6,’Apple Newton’,'Still works! M…’,25,2,’ahertz@differ…’,'http://www.differnet….’,”,”);
INSERT INTO `ads` VALUES(7,’Sinclair C5′,’Battery flat t…’,372.06,346,’clive@sinclai…’,'http://www.ebay.com/w…’,”,”);
INSERT INTO `ads` VALUES(8,’Edsel’,'Never used aut…’,355,755,’bing@badabing…’,'http://pages.google.c…’,”,”);
INSERT INTO `ads` VALUES(37,’Diamond’,'203.4 carats, grade D pear cut diamond. Low price for quick sale. Owner leaving the country.’,1000000,5234,’pink@panther.com’,'http://’,”,”);
[/sql]

It’s easy enough to manually create the Model, but for convenience, let’s use the scaffolding plugin anyway.

Click the Scaffold link at the bottom of any CFWHeels page –  In the debug section, next to Plugins. Then, on the scaffold page, enter ad as the Object name, select Model from the Type drop down, and click Generate. Remember, the table is named ads (plural with an “s”), but the the model is named ad (singular).

Now, open /models/Ad.cfc. You’ll see something that looks like:

[cf]
<cfcomponent extends="Model">

<!— All initialization related tasks are done in the "init" function which is run the first time the model is requested. —>
<cffunction name="init">
</cffunction>

</cfcomponent>
[/cf]

That’s all it takes to create a model! Your model must extend Model.cfc — That’s where all the CFWheels goodness happens. Other than that, all you need is an init function. Later on, you can use the init function to add extra capabilities, but for now, all that’s needed is a blank init function!

We thought we were done, but now the boss wants to record events along with ticket sales. Remember we are following along in Head First Rails, and converting everything to CFWheels!

Fortunately, with scaffolding, all we need to do is create the new database table and run the scaffolding plugin.

Here’s the create table SQL query:

CREATE TABLE `events` (
`id` int(11) NOT NULL auto_increment,
`artist` varchar(255) NOT NULL,
`description` text,
`price_low` decimal NOT NULL,
`price_high` decimal NOT NULL,
`event_date` date NOT NULL,
PRIMARY KEY  (`id`)
)

I got the idea from a Rails app to create a “spec” directory to hold application specification information. And, I created a database sub-directory to hold all my table creation SQL. So the query is stored in /spec/database/events.sql.

Next, click the Scaffold link. Look in the debug information at the bottom of each page, next to Plugins. Then, on the scaffold page, enter event as the Object name, and click Generate. Remember, the table is named events (plural with an “s”), but the the object is named event (singular).

All that’s left is to open /views/events/ and edit the labels in edit.cfm, index.cfm, new.cfm and show.cfm. This last step isn’t really needed to make things work, but the boss is kind of picky.

Great — We’ve finished with Chapter 1 of Head First Rails. You now know how to:

• Create a new CFWheels application
• Install the scaffolding plugin to CFWheels
• Setup a database table and  use scaffolding to automatically generate the Model, View, and Controller code.
• Edit HTML in the View
• Add fields and new tables to the database

Next time, we’ll start Chapter 2, and build an application from scratch — Without using scaffolding.

Now, I’ll continue working through the exercises in Head First Rails and converting things to CFWheels.

Page 27: Edit the HTML in the View

When you use scaffolding, the labels will be the same as the field names in the database. This may be OK, but if you need to change them to make them more readable by humans, it’s easy enough to edit the HTML in the views.

• Look at the directory for webroot/views/tickets. You’ll see four files named edit.cfm, index.cfm, new.cfm, and show.cfm. These are the four files that you need to edit.
• Open up edit.cfm, and you’ll see the code like: <label>Seat_id_seq</label>. Seat_id_seq isn’t a very human-friendly label, so let’s change it to Seat #.
• Change the code to <label>Seat ##</label>. Remember this is inside a <cfoutput> block, so you have to escape the # symbol by typing it twice.
• Open index.cfm and change the appropriate line to <cfcol header=”Seat ##” text=”#seat_id_seq#” />.
• Now make similar changes to new.cfm and show.cfm.
• Save everything, then go to http://localhost/tickets/index.cfm?controller=tickets&action=index to see your beautiful new labels!

I made one other change to the code to make things work correctly! At the bottom of the show.cfm file, there’s a line that starts out with
#linkTo(text=”Return to the listing”, action=”action”)#. This may be a bug in scaffolding, or maybe I did something wrong. This line should really say:
#linkTo(text=”Return to the listing”, action=”index“)#. This way, the link will go back to the index view.

Page 31: Adding a new data field

The Boss forgot that we need a phone number field, so now we have to add it!

In Rails, you have to do > script/generate migration … and then run > rake db:migrate. In CFWheels, we’ll just run an Alter Table query on the database. Here’s the query I ran:

ALTER TABLE tickets
ADD phone varchar(255)

But, just like with Rails, changing the database isn’t enough (Page 36). We still have to update the code in the View files to handle the new field. Here’s the code I added to edit.cfm and new.cfm:

<p><label>Phone</label> <br />
#textField(objectName=’ticket’, property=’phone’)#</p>

Notice the textField() function. This is the CFWheels equivalent of <%= f.text_field :phone %>. Rails also has the f.label function. I’m not sure of the advantages of using a helper function for labels. But, this doesn’t seem to be available in CFWheels — At least not yet!

By the way, you can get details on any helper function like the textField tag at:

http://code.google.com/p/cfwheels/wiki/textFieldTag

The changes to show.cfm and index.cfm are similar. If you have any trouble, leave me a comment!

I heard a rumor that the Boss wants to add event information to our application. We’ll look at this next time!

I’ve been really pleased with CFWheels. It’s the ColdFusion answer to Ruby on Rails, and it just makes sense to me!

The documentation is good. Still, for a new learner, some things are missing. So, I thought maybe I can leverage some Rails resources. I found a great book — Head First Rails. I’m going to do some posts on translating the book to CFML and to CFWheels. I think this will help my learning and may help others.

From here, I’m assuming that you know something about web development, CFML, and already have a ColdFusion server running on your computer. If not, this information may be too advanced for you. CFWheels runs great on the development edition of ColdFusion that’s available from Adobe. Railo is also supported. You can learn more about the requirements at: http://cfwheels.org/docs/chapter/requirements.

Now on to Head First Rails, Chapter 1: Really Rapid CFWheels

Page 7: Creating a New Application

In Rails, you open a command prompt and type > rails tickets.  This sets up the folder structure for your app.

In CFWheels, you do the same thing by downloading the CFWheels files and just unzipping them to a folder named tickets in your webroot. The name of the folder is very important. CFWheels and Rails both rely on convention instead of configuration. Things have to be named consistently!

Page 14: Creating Tables (Migration)

In Rails, you create tables in the database by going to a command prompt and typing > ruby script/generate scaffold tickets … Then, you have to run a migration by typing > rake db.migrate. These two commands also write code for your application! Rails will automatically create Model, View, and Controller files for your new table.

CFWheels handles this a little differently, but you can quickly get to the same place. First, you have to install the Scaffolding plugin.

• Download the scaffolding plugin
• Save the .zip file in your wwwroot/tickets/plugins folder.
• Reload CFWheels by running this URL in your browser: http://localhost/tickets/?reload=true
• CFWheels will automatically unzip and install the file! You’ll see Scaffold listed as a plugin at the bottom of the page along with other debugging information.
• NOTE: Apparently there’s a problem with the Plugin Manager right now. I had to delete the Plugin Manager files from the plugins directory. Then, this process worked for me. I discovered the problem was with my ColdFusion server configuration. I had added a Dump() method to Component.cfc. When Wheels tried to load multiple plug-ins, it saw the duplicated method, and threw an error as a result of the naming conflict.

You’ll only need to do the steps above once. Now, lets use scaffolding to create an app in CFWheels. Instead of using the script/generate syntax, CFWheels expects you to just create your table via a SQL query or whatever database tools you like to use. Most developers know how to do this, and I like this approach better than learning a new syntax in Rails!

Here’s my Create Table SQL script. This is essentially the same command you type into Rails via script/generate.

CREATE TABLE `tickets` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(255) NOT NULL,
`seat_id_seq` varchar(255) NOT NULL,
`address` text NOT NULL,
`price_paid` decimal NOT NULL,
`email_address` varchar(255) DEFAULT NULL,
PRIMARY KEY  (`id`)
)

Now, it get’s really easy. Either click the Scaffold link on the bottom of your browser screen, or point your browser to http://localhost/tickets/index.cfm?controller=wheels&action=plugins&name=scaffold. This will display the scaffolding plugin screen.

Just enter the name of the table and click Generate. That’s it! Instant Application. Go to  http://localhost/tickets/index.cfm?controller=tickets&action=index to see your new application. Rails automatically creates a route, so their URL is simpler, and you can easily do the same thing if you want. For me, when learning, I’d rather see the controller and action clearly shown in the URL. There’s always time to switch to pretty URL’s later on.

Next we’ll edit the HTML in the view. But, that’s another post. Please leave a comment if I got something wrong or you like my approach!

In the early 1990’s, many companies were developing client/server applications. There would be a back end database, along with a server that accessed the database and added logic and processing to the data. And, there would be a custom client written with a tool like Visual Basic.

Then, in the mid-1990’s, the Web changed everything! Developers realized that a web browser could provide the functions of the custom client. The Internet made sure that the network was universally available, and nearly every Internet user had a web browser.

Unfortunately, HTML and other web standards were originally designed to provide layout for static, non-changing documents. By switching from custom client software to web browser clients, the applications became universally accessible. But, the user interface took a big step backwards!

Have you ever tried to go online to buy an airline ticket? As long as you know exactly what you want–Which flights and which days–Everything goes fairly smoothly. And, it still takes several mouse clicks and page reloads to get your ticket purchased. But, what if you just want to find a low cost way to take a vacation, and your flight plans and schedule are flexible. Most online travel sites aren’t designed to support flexible travelers. Users end up having to repeatedly go through all those mouse clicks and page reloads looking for a low cost option.

Wouldn’t it be much easier if a rich user interface was available? A rich user interface is one that minimizes mouse clicks, does not require page reloads, and makes it much easier to do flexible queries. Macromedia’s new Flash MX product provides the missing capabilities needed to build rich user interfaces.

The online reservation system shown below for the Broadmoor Hotel provides a great example of a rich user interface. With no page reloads, the user can choose a date in the left-hand panel, and see available rooms in the middle panel. Or, a user can pick a room type, and have the dates highlighted when that type of room is available! When it’s time to book a room, that happens in the right-hand panel. Everything is available on the single screen–Even validation for credit card or booking information. Try it yourself at http://reservations.broadmoor.com!

Broodmoor Rich Internet Application Example

It’s easy to imaging a wide variety of possible applications for rich user interfaces including:

• Reservation systems for sporting events, conference rooms, special events, etc.
• Form processing for insurance companies, banks, or any other company needing flexible, validated forms.
• Online report generation and data visualization.
• e-Commerce
• Customer or Employee self-service applications for customer service, HR, support, etc.

Clearly, rich user interfaces will be critical for both external, customer-focused web applications and for internal, employee-focused applications.

A web server is a specialized type of file server. Its job is to retrieve files from the server’s hard drive, format the files for the Web browser, and send them out via the network. Web servers are designed to do a great job of sending static content out to a large number of users. The pages delivered by the server are expected to be the same for everyone who visits the server.

The function of a typical Web server is shown below. The user requests a web page. The Web Server finds the web page file in a local directory and sends it back out to the user. When graphic files are requested, the same thing happens. The Web Server finds the requested graphic files and sends them back to the user.
The Web Server standards were originally designed to publish static documents on the Internet. There was a limited capability for accessing dynamic content, but this was never intended to support high volume, highly interactive Web applications.

How a Web server works

Then, as the Internet and Web browsers became popular in the mid-1990’s, organizations saw an opportunity to provide web pages that contained dynamic content like stock prices, weather information, inventory levels, and shipping status for a package. Web browsers became such a pervasive way to access information that users and organizations desired to access a wide variety of information and applications through their Web browser. So, Web servers had to be extended to allow software application development and access to databases.
Then, What is a Web Application Server?

Web application servers are designed specifically to extend web servers to support dynamic content. The application server software “hooks in” to the web server software and automatically intercepts any user requests for dynamic content. The web server still sends out static web pages and graphic files–Just like before. But now, the application server can create dynamic content by mixing data with templates, running programs, or by accessing databases.

How a Web Application server works

There are a variety of Web Application Server product available. Some of the more popular products include:
Macromedia:
Cold Fusion

Cold Fusion is inexpensive and easy to learn resulting in low cost for both development and implementation. Its may be less applicable for complex or high-volume projects.

Microsoft:
Active Server Pages and .Net

For companies that have already committed to Microsoft, the Active Server Pages (ASP) application server included with IIS is a good choice. ASP code is usually written in Visual Basic, and there a large number of qualified developers resulting in moderate development cost. ASP typically only runs with Microsoft operating systems, so it is not a great choice for high-volume projects that will run on Unix hardware..

Microsoft is migrating ASP to its new .Net product. This product offers a lot of potential, but as of May, 2002, all the components are still not released and .Net is still unproven.
Java 2
Enterprise Edition

Java 2 Enterprise Edition (J2EE) is a great choice for enterprise and mission critical applications. It is highly scalable and can run under almost any operating system from Windows to high-end Unix servers. J2EE code is written in Java.

J2EE application servers are available from over 30 vendors including IBM (WebSphere), Sun (iPlanet) BEA (WebLogic), Macromedia (jRun). There are even several open source J2EE servers (Tomcat, Resin, & jBoss).