Seb Duggan

Edwin

2025-05-27T05:30:00Z

My great-uncle Edwin pictured as a young man with the family dogs

Exactly 85 years ago, on 27th May 1940, while the eyes of the nation were turned to the events unfolding on the beaches at Dunkirk, six RAF aircraft set out from Shetland to patrol the Norwegian coast, but only five returned. The three-man crew of the missing aircraft included my great-uncle Edwin; he was just 19 years old.

Edwin Holbrow Alexander was born in 1920, the youngest of the five children (three girls, two boys) of Herbert George Alexander and his wife Annie Georgina. Herbert had enjoyed success for many years as a renowned grower and cultivator of orchids (one of the most famous hybrids is named Cymbidium Alexanderi after him), and managed the collection at Westonbirt, near Tetbury, Gloucestershire. He sat alongside his employer, Sir George Holford, on the Royal Horticultural Society’s orchid committee; and on Sir George’s death in 1926 he bequeathed the entire orchid collection to Herbert.

Edwin (centre) with older brother Stanley and father Herbert

The future looked bright for the family in the 1930s. Edwin’s older brother Stanley (ten years his senior) was already involved in the family horticultural business, which was flourishing, and he was being lined up to take over the reins; but the outbreak of war in 1939 would change everything.

With war on the horizon, Herbert’s sons both joined up. Stanley, who had already served four years from 1933 to 1937 in the Royal Gloucesterchire Hussars, re-enlisted to the Gloucestershire Regiment in May 1939. Edwin, still only 18, was granted a short service commission as Acting Pilot Officer (the lowest ranking commissioned officer) in the Royal Air Force on 29th April 1939.

Edwin in the uniform of a Pilot Officer in the RAF

After the outbreak of war, Edwin was moved on 6th November 1939 to the RAF’s active list as a Pilot Officer, and was assigned to 254 Squadron. 254 had at the start of the war been re-formed as a coastal fighter unit, based at Stradishall in Suffolk, carrying out coastal patrols and convoy escorts along the east coast, later adding reconnaissance and fighter escort.

The squadron was equipped with Bristol Blenheim IVF fighter-bombers which, although dating from the mid-1930s, had already been rendered mostly obsolete by advances in technology in the intervening years. Originally designed as bombers, they had been retro-fitted as three-seater fighters; but they were overly susceptible to enemy fire, both from ground and air, and would later be switched to service as night fighters, where they were less vulnerable to high-performance planes such as the Messerschmitt 109.

Bristol Blenheim IVF fighter-bombers of 254 Squadron

On 16th May 1940, the squadron relocated to RAF Sumburgh in the Shetlands - today the island’s airport, but at the time little more than a grass strip. The following is taken from an account by Wing Commander H.C. Randall DFC, in his memoir Moths to Mosquitos. Based on the date in his account, he would probably have known Edwin (although maybe only briefly).

On the 25th May 1940, I was posted to the most northern airfield at which I was ever to be based – Sumburgh in the Shetland Islands. As well as my most northern posting, it also marked a new low in standards of accommodation. No. 254 was the first Squadron to have been posted here, though there had already been a flight of Gladiators intended for the island’s own defence. The runways had only just been finished, though the same could not have been said about some of the buildings. In fact we were to sleep under canvas.

The mess was a large marquee, and the bar was constructed from empty wooden boxes, each of which had previously been used to transport two 4-gallon petrol canisters. These petrol canisters were the only source of fuel for our Blenheims and worse still, was the fact that the planes had to be completely refueled by hand! Initially the fuel had to be filtered through chamois leather to remove excess water. The boxes soon became the principal, and sometimes only, source of furnishing on the airfield. They were used in the tents as bedside cabinets, chairs and other useful things.

As an airfield Sumburgh was not ideal. At one end of the runway you had Sumburgh Head itself, and at the other you would approach over the village itself down a slope. The short runway had the sea at both ends. Although we were there in the summer and the sea was so close, no one swam as the water was far from warm. I have to admit to attempting a paddle once, but this was rapidly given up as a bad idea! There also seemed to be a perpetual wind at Sumburgh. You were always aware of the sound of empty petrol tins being blown round the airfield. Later when Nissan huts finally arrived, sheets of airborne corrugated iron replaced the petrol containers!

Temporary canvas accommodation at RAF Sumburgh, Shetland

At 05:30 on 27th May 1940, six Bristol Blenheim IVF from 254 Squadron 18 Group were sent from Sumburgh RAF station in two sections of three to sweep the south-western coast of Norway, mainly in search of enemy airfields, but also to locate the auxiliary naval vessel Königsberg (although records seem to show that it had already been sunk the previous month).

Blenheim R3624 (QY-M) was crewed by Edwin and two others: Sergeant Basil A.J. Henrick (also 19) and Sergeant Thomas P.N. Hammond (23). Near Stavanger on the Norwegian coast they were engaged by the enemy, and Edwin’s aircraft was shot down by the Messerschmitt Bf 109 of Lt. Deuschle of II./JG77 (although it was also claimed by Hptm. Lang). It is strange to think that, in a conflict where so many died, aerial combat was still so personal and one-to-one that it is possible to know the name of the pilot who shot Edwin’s plane down.

Coastguards reported that an aircraft had crashed into the sea, and the Thurso lifeboat was launched - but no trace was ever found and the men were reported as missing. Edwin is commemorated, alongside so many others, at the RAF memorial at Runnymede.

Section of the RAF memorial wall at Runnymede displaying Edwin’s name

The loss of Edwin hit the family hard. The following is an excerpt from a letter, written just a couple of weeks later, from my grandmother Vanda (one of Edwin’s sisters) to her brother Stanley:

Didn’t you think the letter to Pa from Bertie’s squadron leader was grand. He was always just Bertie to everyone – none of this terrible side one sees on some officers! I think even the Germans will fall for him – I feel he must be a prisoner Stan don’t you. I mean anyone as grand as Bertie and so straightforward & honest just couldn’t be sent out of this world so quickly. All I hope is that if he is a prisoner they’ll treat him decently – I’ll never never give up hope that he’s not alive, ‘cos it seems quite impossible to me. Doesn’t it seem like that to you?

And she really never did give up that hope: she always believed that somehow one day he would just walk through the door.

It was not, alas, the only wartime loss to be suffered by the family. On 24th September 1944, in the push across Europe after the D-Day landings, Edwin’s brother Stanley (now a Major in the Reconnaissance Corps) was leading a forward recce mission near the town of Mierlo in the Netherlands, when his jeep hit a landmine by the side of the road, and he was killed. He was 34, with two young sons - one aged two, the other only 2 months. He is buried at the war cemetery in Mierlo.

Herbert George Alexander was devastated by the loss of his two sons, and with them the future of the orchid business into which he had invested so much of his life. In their memory he dedicated a pair of stained glass windows at Westonbirt church (now privately owned by Westonbirt School), bearing the insiginia of the Reconnaissance Corps and the Royal Air Force, and with the inscriptions:

Be thou faithful unto death and I will give thee a Crown of Life

and:

To the Glory of God and in loving and grateful memory of Major Stanley George Alexander Reconnaissance Corps killed in action Holland 1944 aged 34 and his brother Pilot Officer Edwin Holbrow Alexander RAF killed in action over Norway 1940 in his twentieth year. Erected by their father and family.

Stained glass windows at Westonbirt church

Another year, another site redesign

2025-03-18T14:38:00Z

Well, this is embarassing. It is exactly two years, to the day, since I posted about the reworking of my site in Eleventy. Specifically, I noted my lack of posting, and vowed to do better.

Jump forward to the present day, and that is still the last thing I posted on my site. And before that it was a gap of 6 years. Not exactly setting the internet alight…

Let's face it, the old site was not pretty...

But now I have finally done the redesign I planned 2 years ago, and I must say I’m rather pleased with how it’s turned out. Here are some of the main features:

built using Eleventy 3.0
social sharing images generated automatically using the OG Image plugin
code examples rendered using Shiki with added language definition for CFML
light/dark mode theme switcher (I prefer the dark)
article reading times
self-hosted fonts for speed and privacy
blazingly fast – 100s across the board in Lighthouse

This time round I’ve reverted to using Nunjucks templates, rather than WebC. I found I was struggling too much to overcome hurdles, and didn’t need any further impediments!

At this stage, I haven’t added a CMS. I’m wavering between Decap CMS which I used before, and Tina CMS, which seems to offer something similar. But htey can be added in later.

What about the old content?

One of the concerns I had was that most of the (admittedly small number of) old posts are now hopelessly outdated, and not relevant to what I now work with. I did consider just deleting them (I still may), but I think for now I’ll just slap a banner on them to make it clear that this is old content.

Having said that, it would be nice not to have that reminder of my failure to blog – 17 posts over a period of 16 years.

What’s next?

I’ve recently got back into analogue audio (vinyl records and reel-to-reel tapes), so there will be some content related to that on here. I’m considering an API connection to pull in data from my Discogs collection to display here on the site (I already have a records page ready and waiting…).

I’ll be posting much more often about code, but also about other things that interest me; for instance, some family history stories turned up in my genealogy research. Most of all, though, I just want to get into the habit of writing stuff!

Relaunching my site in Eleventy

2023-03-18T18:13:00Z

When I last rebuilt my personal site, back in 2017, I was full of good intentions. It was built on Hugo, which was the SSG I chose at the time (a coin flip between Hugo and Jekyll). It had a basic theme, and could be published by simply committing to a Git repo. What could possibly go wrong?

Jump forward 6 years, and the only content I posted was three related articles within the first month. And ever since, it has simply stagnated. It didn’t help that for some reason I found it difficult to get the environment set up on my new laptop…

Now, in 2023, it seems that all the cool kids are using Eleventy - and I can see why. A combination of speed (it blows the other SSGs out of the water) and ease of use (being based on Node, it’s using stuff I‘ve already got set up and installed) makes it the obvious choice. On top of that, there’s an active and friendly community out there too.

The release of Eleventy 2.0 seemed the perfect time to make the switch. This site is currently bare-bones, but if I waited until I had the site perfect I’d never get it launched (or write any new content for it).

So, I’ll be developing the site out in the open, gradually implementing new features and designs. But this is what I have done so far:

migrated my existing content (what little there is of it) into Eleventy
based the site on the eleventy-base-blog starter
converted much of the site to be based on WebC components and layouts. This seems really cool!
added a WebC component to replace images with responsive alternate sizes and formats
implemented Shiki for rendering code examples, in place of the standard Eleventy syntax highlighter. Also added a custom language definition to handle CFML code blocks
added Netlify CMS (which seems to have become Decap CMS since I started on this project) to make it easier to draft and publish new content. I’m hoping this will be the magic bullet that will encourage me to post more regularly!

And, for the future, I plan to overhaul the theme to make it mine; make more use of WebC components (did I mention how cool these are?); and add webmentions to my posts.

So, here’s to a new beginning - I hope I can keep to my good intentions…

Preside selectData(): related objects and joins

2017-02-21T12:00:00Z

In the first two parts of this series, I’ve looked at selecting and filtering data from Preside objects using selectData().

In this third and final instalment, we’ll be accessing the power of related objects. Simple, standalone data objects are all very well, but even a very basic application will define connections between objects. These will be in the form of many-to-many and many-to-one relationships (also one-to-many, which is a many-to-one relationship looked at from the other direction).

If we look at the starwars_character.cfc object, we can see both types of relationship:

component {
	// ... other basic properties defined ...
	property name="homeworld"  relationship="many-to-one"  relatedTo="starwars_planet";
	property name="films"      relationship="many-to-many" relatedTo="starwars_film"     relatedVia="starwars_film_character";
	property name="species"    relationship="many-to-many" relatedTo="starwars_species"  relatedVia="starwars_character_species";
	property name="starships"  relationship="many-to-many" relatedTo="starwars_starship" relatedVia="starwars_starship_pilot";
	property name="vehicles"   relationship="many-to-many" relatedTo="starwars_vehicle"  relatedVia="starwars_vehicle_pilot";
}

We can see from this that a character has a homeworld property, by which it can be related to one single planet; but then can be related to multiple films, vehicles, etc.

Basic joins

The key to selectData() joins is to use a dotted syntax in your column definition, very much like you would in SQL. Bear in mind though that you are using property names rather than table names, e.g. property_name_of_related_object.property_on_related_object:

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [
		  "name"
		, "homeworld.name as homeworld_name"
	  ]
);

Here we are selecting each character along with the name of their homeworld. Note that homeworld.name is actually retrieving data from the starwars_planet object – but the property name is homeworld.

Behind the scenes, Preside is converting this to the following SQL (but you usually won’t need to worry about this):

select    `starwars_character`.`name`, `homeworld`.`name` as homeworld_name
from      `pobj_starwars_character` `starwars_character`
left join `pobj_starwars_planet` `homeworld` on (`homeworld`.`id` = `starwars_character`.`homeworld`)

Extended joins

This gives you data from an object that is directly related to your main object, but Preside allows you to traverse joins as deep as you like. For instance, you might want to get values from an object related to an object related to your main object. To do this, you simple separate the objects in your chain with a $.

In this example, we are getting a list of characters, their homeworld, and the titles of films in which that homeworld has appeared:

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [
		  "name"
		, "homeworld.name as homeworld"
		, "homeworld$films.title as homeworld_film"
	  ]
	, orderBy      = "name, homeworld.name, homeworld$films.episode_id"
);

You will see that the many-to-many relationships are stored in linking tables (whose names are defined here using the relatedVia attribute, but you can leave Preside to set default names for these tables). When selecting data using selectData() you can ignore these linking tables, as Preside does all the heavy lifting for you – it will create SQL joins between starwars_character and starwars_film_character, and then between starwars_film_character and starwars_film.

Or, one step further down the rabbit-hole, we can also add all the species that appeared in films in which that homeworld appeared:

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [
		  "name"
		, "homeworld.name as homeworld"
		, "homeworld$films.title as homeworld_film"
		, "homeworld$films$species.name as homeworld_film_species"
	  ]
	, orderBy      = "name, homeworld.name, homeworld$films.episode_id, homeworld$films$species.name"
);

Note that we use the same syntax for relationships when defining orderBy parameters (and also groupBy, filter, etc.).

Because we are returning a query with joins, there will be many rows of data for each character, containing all the combinations of homeworlds, films and species that match the request. You might want to use the group attribute on your cfloop or cfoutput for the query in order to group the data meaningfully.

Join types

By default, most joins that Preside performs will be left outer join (joins to required properties will, however, use an inner join). So the following query will return all characters and the starships they are associated with, or a blank/null value for the starship if they are not associated with any:

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [ "name", "starships.name as starship" ]
)

However, it may be that you only wish to return those characters who actually have starships assigned to them. In SQL this is done using an inner join; you can instruct Preside to use inner joins for all joins in a query by using the forceJoins argument:

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [ "name", "starships.name as starship" ]
	, forceJoins   = "inner"
)

Valid values for this are left (the default) and inner.

Extra joins and subqueries

Of course, sometimes the data you want to extract from the database will not be accessible via the object’s defined relationships. Maybe you need a subquery that does some calculation for you, or maybe you need to join a table to itself.

This is achieved using the extraJoins argument. This is an array of explicitly defined subqueries, along with all the information needed to join it to your main query:

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [ "name", "homeworld.name as homeworld_name", "homeworld_count.character_count" ]
	, orderBy      = "homeworld_count.character_count desc, name"
	, filter       = "homeworld_count.homeworld = starwars_character.homeworld"
	, extraJoins   = [ {
		  subQuery       = "select count( id ) as character_count, homeworld from pobj_starwars_character group by homeworld"
		, subQueryAlias  = "homeworld_count"
		, subQueryColumn = "homeworld"
		, joinToTable    = "starwars_character"
		, joinToColumn   = "homeworld"
		, type           = "inner"
	  } ]
);

This query will return a list of characters along with the total count of characters from the same homeworld. All 6 of the parameters for the extraJoin are required:

subQuery is the SQL of the subquery. Note that table names in here are the actual database table names, not the name of the Preside object. subQueryAlias gives the subquery a name, and subQueryColumn is the column in this query that will be used to join to a column on the main query (defined by joinToTable (Preside object name) and joinToColumn). Finally, the type parameter defines the type of join (inner or left) that will be used to join to the subquery.

To clarify how all this fits together, here is the generated SQL from this request:

select `starwars_character`.`name`, homeworld.name as homeworld_name, homeworld_count.character_count
from   `pobj_starwars_character` `starwars_character`
left join `pobj_starwars_planet` `homeworld`
	on (`homeworld`.`id` = `starwars_character`.`homeworld`)
inner join (
	select count( id ) as character_count, homeworld
	from pobj_starwars_character
	group by homeworld
) `homeworld_count`
	on (`homeworld_count`.`homeworld` = `starwars_character`.`homeworld`)
where homeworld_count.homeworld = starwars_character.homeworld
order by homeworld_count.character_count desc, `starwars_character`.`name`

Remember from part one how you can use the getSqlAndParamsOnly argument to return a query and its parameters? This can come in very handy when you’re building complex joins with subqueries…

There is one more (optional) parameter that an extraJoin can take, and that is additionalClauses. This is a SQL string which will be added to the on clause which joins the subquery. The following (rather contrived) example will return a list of characters, their homeworld, and the number of characters from that homeworld who share the same hair colour.

result = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [ "name", "homeworld.name as homeworld_name", "count( homeworld_subquery.hair_color ) as same_hair_color_count" ]
	, orderBy      = "name"
	, groupBy      = "starwars_character.id, homeworld_subquery.hair_color"
	, filter       = "homeworld_subquery.homeworld = starwars_character.homeworld"
	, extraJoins   = [ {
		  subQuery          = "select id, homeworld, hair_color from pobj_starwars_character"
		, subQueryAlias     = "homeworld_subquery"
		, subQueryColumn    = "homeworld"
		, joinToTable       = "starwars_character"
		, joinToColumn      = "homeworld"
		, type              = "inner"
		, additionalClauses = "homeworld_subquery.hair_color = starwars_character.hair_color"
	  } ]
);

Both the subQuery and additionalClauses values may include dynamically defined filter parameters, using the same :parameter_name syntax as elsewhere. These dynamic values would be defined in the filterParams argument of the main query, and may be shared by the main query and its subqueries.

Aggregate functions

In the previous example, you’ll notice that we’ve used a count() aggregate function in our selectFields. This shows how easy it is to include aggregate data functions (this combines here with the groupBy clause). Here are a few more examples of simple aggregation of data:

longestVehicle = presideObjectService.selectData(
	  objectName   = "starwars_vehicle"
	, selectFields = [ "max( length ) as max_length" ]
);

vehiclesClasses = presideObjectService.selectData(
	  objectName   = "starwars_vehicle"
	, selectFields = [ "vehicle_class", "count( vehicle_class ) as vehicle_count" ]
	, groupBy      = "vehicle_class"
	, orderBy      = "vehicle_count desc, vehicle_class"
);

There are of course occasions when a subquery using an extraJoin will be the better solution, but most basic aggregation can be achieved just by including here – especially as of Preside 10.8.0, which adds to selectData() the having argument:

vehiclesClasses = presideObjectService.selectData(
	  objectName   = "starwars_vehicle"
	, selectFields = [ "vehicle_class", "count( vehicle_class ) as vehicle_count" ]
	, groupBy      = "vehicle_class"
	, having       = "count( vehicle_class ) >= 4"
	, orderBy      = "vehicle_count desc, vehicle_class"
);

This will return a list of vehicle classes with counts of vehicles, for classes with 4 or more vehicles. having functions exactly as it does in raw SQL, basically acting as a where clause which acts on the aggregate function.

Finally, you can use your DBMS’s proprietary aggregate functions, just like any other function. A particularly useful one is MySQL’s group_concat(), which you can use to generate lists of grouped data directly in the database; it is handy for getting a list of IDs of related records in order to pre-populate object pickers, etc. Note that it is MySQL only: PostgreSQL has the similar string_agg() function; but MS SQL Server doesn’t let you do this without some ugly fiddling about with xml path. So if you’re looking to create a database-agnostic application, you’ll probably be better sticking with standard SQL and grouping the data in your CFML code.

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [ "id", "name", "group_concat( films.title separator ', ' ) as films_appeared_in" ]
	, groupBy      = "id"
	, orderBy      = "name"
);

Conclusion

I hope I’ve demonstrated in these posts the power of getting data from Preside’s object model. I’ve learned a lot from putting this together, especially about complex joins and the trickier filters.

If you have any questions or suggestions, come and join us at the Preside Community forum, which is the best place to get any Preside questions answered…

Preside selectData(): filtering data

2017-02-13T12:00:00Z

If you’ve read part one of this series, you know how to retrieve data from Preside objects using selectData(). But any web application will need you to refine the data down to a subset of the whole dataset, or just a simple record (think of a SQL where clause).

Simple filtering

Every Preside data object has a unique id, and we can use this to retrieve a single record from the database:

film = presideObjectService.selectData(
	  objectName = "starwars_film"
	, id         = "9F049349-18C4-4ED6-848BC0A41F510821"
);

In practice, of course, the ID you pass in is most likely to be dynamic – maybe defined in the URL or form parameters in a request from another page.

Selecting by id (the record’s primary key) is a special case; if you want to filter the records on any other field or fields, you pass a struct of filters to the filter argument:

film = presideObjectService.selectData(
	  objectName   = "starwars_film"
	, filter       = {
		episode_id = 5
	  }
);

You can filter by multiple column values at the same time - if you do this using a filter struct, it will return records that match all the filter values, equivalent to SQL’s where ... and .... In the next example, we’re asking for all characters who are female and have brown hair:

characters = presideObjectService.selectData(
	  objectName = "starwars_character"
	, filter     = {
		  gender     = "female"
		, hair_color = "brown"
	  }
);

This method of filtering also allows you to match a column against one of a set of values (a SQL where ... in (...) clause). This is achieved by passing an array of values in the filter struct. So this next query would retrieve characters whose eyes are either brown, blue or black:

characters = presideObjectService.selectData(
	  objectName = "starwars_character"
	, filter     = {
		eye_color = [ "brown", "blue", "black" ]
	  }
);

More complex filters

All the examples so far have been filtering for an “equals” match. But what if you need to do a greater than or non-equality comparison, or a complex grouping of conditions?

For this, you simply pass any valid SQL string to the filter argument instead of a struct:

theGoodFilms = presideObjectService.selectData(
	  objectName = "starwars_film"
	, filter     = "episode_id >= 4 and episode_id != 6"
);

Of course, usually the values will be dynamic, according to the requiredments of the request. To pass parameterised values into the filter, pass a struct of values in via the filterParams argument:

film = presideObjectService.selectData(
	  objectName   = "starwars_film"
	, filter       = "title != :title"
	, filterParams = {
		title = "A New Hope"
	  }
);

skywalkers = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, filter       = "name like :name"
	, filterParams = {
		name = "%Skywalker"
	  }
);

In these cases, because the parameter name is the same as the field name (title, name), Preside is able to use the object definition to know what the SQL type is of the parameter (in both cases, it’s varchar). However, often you will need to give the parameter a different name (for example, if we were executing the previous example with filterParams). You will now need to define explicitly the type of the parameter by setting its value to be a struct containing type (the SQL type of the field, as defined in your object, e.g. int or varchar) and value (the actual value to be parameterised):

theGoodFilms = presideObjectService.selectData(
	  objectName   = "starwars_film"
	, filter       = "episode_id >= :minEpisode and episode_id != :excludeEpisode"
	, filterParams = {
		  minEpisode     = { type="int", value=4 }
		, excludeEpisode = { type="int", value=6 }
	  }
);

Using the filterParams technique, you can still pass in arrays for SQL in ( ... ) queries:

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, filter       = "eye_color not in ( :eye_color )"
	, filterParams = {
		eye_color = [ "brown", "blue", "black" ]
	  }
);

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, filter       = "eye_color not in ( :colours )"
	, filterParams = {
		colours = { type="varchar", value=[ "brown", "blue", "black" ] }
	  }
);

WARNING! Never include variables directly in the filter string. These will be inserted directly into the generated SQL statement, and will leave you wide open to SQL injection attacks. Always pass dynamic variables in via filterParams.

Extra filters

There are occasions when you will have a basic set of filters for a scenario, but you may also want in addition to apply other filters (some of which might be generated by helper methods). You could achieve this by appending all the filters to the main filter set, but the neater way is by using the extraFilters argument.

extraFilters is an array of filter conditions, each of which can be constructed using any of the variations discussed above. Each item in the array will be a struct with a filter value and an optional filterParams value.

characters = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, filter       = { gender="female" }
	, extraFilters = [
		  {
			filter = { hair_color=[ "black", "brown" ] }
		  }
		, {
			  filter = "eye_color != :excludeColour"
			, filterParams = {
				excludeColour = { type="varchar", value="blue" }
			  }
		  }
		, getMyExtraCustomFilter()
	  ]
);

In the above example we see a regular filter, plus extraFilters containing a simple filter, a filter with explicitly defined parameters, and a filter returned from a separate method. All four of these filters will be combined into one SQL where clause.

Saved filters

Preside allows you to pre-define filters to be used by your application in your Config.cfc file. These are actually of more use in other scenarios, such as filtering the records shown in an objectPicker form control, but they can also be used by selectData().

// application/config/Config.cfc

public void function configure() {
	// other configuration options...

	settings.filters.created_in_last_month = { filter = "datemodified >= date_add( now(), interval -1 month )" };
	settings.filters.modified_in_last_week = { filter = "datemodified >= date_add( now(), interval -3 day   )" };
}

The savedFilters are then passed in as an array, and will be applied in addition to any other filters you have defined.

recentVehicles = presideObjectService.selectData(
	  objectName   = "starwars_vehicle"
	, selectFields = [ "id", "name" ]
	, savedFilters = [ "created_in_last_month", "modified_in_last_week" ]
);

When defining saved filters in Config.cfc, they will generally not be dynamic; however, you can define a saved filter as a closure function which will return the filter configuration based on its internal logic. The closure will take two arguments, the first of which will be an empty struct of arguments, but the second will be the ColdboxController object, which will allow you to access various useful bits of information from the application and request.

Summary

We now know how to select and filter data from single Preside objects, and have seen how flexible and powerful the data filtering is.

In the next part of this series I’ll be looking at joins, and how easy Preside makes it to access data from multiple, related objects.

Preside selectData(): the basics

2017-02-11T12:00:00Z

A little background to start with: Preside is an open-source web development platform, created at Pixl8 Interactive, which runs on the Lucee application server. While at first glance it may look like any other CMS (it was originally called Preside CMS), it does so much more, and can form the hub of some very complex integrations between other applications. The key to this is an incredibly flexible content storage model, and the ability to extend or override almost any aspect of the application to suit your own individual needs.

I’ve only been using Preside for a few months, and started in my role as a Senior Developer at Pixl8 in December 2016. So I’m constantly learning new things about Preside, which puts me in an ideal position to write about it from the perspective of a newcomer. I expect to write plenty about Preside here in the future!

The foundation of Preside’s power is in its data layer implementation, which is based on Preside Data Objects. I may write in the future about aspects of these, but the official guide covers their creation and configuration in a lot of detail. What I’m going to look at here (over the course of several posts) is retrieving data from Preside Objects, which is all done via the selectData() method of the PresideObjectService.

In order to demonstrate selectData(), we’ll first need some data. A great source of sample data is the Star Wars Preside Extension, which imports data from The Star Wars API into Preside, and that’s what I’ll be using throughout these posts.

The simplest query

The following is as simple as it gets. The only required argument for selectData() is objectName:

films = presideObjectService.selectData(
	objectName = "starwars_film"
);

This will return every column of every record from the specified object. One thing to note is that – unlike ORMs and ORM-like approaches – selectData() returns its data as a query resultset. This gives several benefits, not least of which is the ability to construct some very complex data requests to suit any requirement.

For all these examples, I have injected the PresideObjectService as a property:

property name="presideObjectService" inject="presideObjectService";

You can, if you want, use an “Auto Service Object”, which is the given object decorated with the service API CRUD methods. This can be done either within your method:

filmObject = presideObjectService.getObject( "starwars_film" );

Or via injection:

property name="filmObject" inject="presidecms:object:starwars_film";

Your simplest query would then look like this:

films = filmObject.selectData();

Refining your query

That’s all very well, but it’s best usually only to retrieve the columns you require. This is done using the selectFields argument, an array of the columns you want:

films = presideObjectService.selectData(
	  objectName   = "starwars_film"
	, selectFields = [ "title", "episode_id", "director" ]
);

And orderBy will let you sort your results:

films = presideObjectService.selectData(
	  objectName   = "starwars_film"
	, selectFields = [ "title", "episode_id", "director" ]
	, orderBy      = "episode_id"
);

orderBy is a simple SQL order by statement, so can be as complex as you like:

vehicles = presideObjectService.selectData(
	  objectName   = "starwars_vehicle"
	, selectFields = [ "name", "model", "vehicle_class", "crew", "passengers" ]
	, orderBy      = "crew desc, passengers desc, name"
);

Aliases and SQL functions

If you wish, you can rename your columns using simple SQL aliases:

films = presideObjectService.selectData(
	  objectName   = "starwars_film"
	, selectFields = [ "title", "episode_id as episode", "director" ]
);

And you can insert SQL logic into your field definition:

films = presideObjectService.selectData(
	  objectName   = "starwars_film"
	, selectFields = [
		  "episode_id"
		, "concat( 'Episode ', episode_id, ': ', title ) as full_title" ]
	, orderBy      = "episode_id"
);

Note: While Preside’s default database is MySQL/MariaDB, there is also beta support for MSSQL and PostgreSQL. When you’re writing your own applications – where you know what database you will be using – you can use SQL syntax specific to that database. But if you plan on releasing, for example, a Preside extension, you should ensure either that you are using standard SQL syntax, or you provide logic that will provide alternate syntax depending on the DBMS in use.

Paging your results

You will often want to limit the number of rows returned, and if you’re creating a paged interface, you’ll also want to specify which row to start from. This is achieved using maxRows and startRow respectively:

pagedFilms = presideObjectService.selectData(
	  objectName   = "starwars_film"
	, selectFields = [ "title", "episode_id", "director" ]
	, orderBy      = "episode_id"
	, maxRows      = 3
	, startRow     = 4
);

New in Preside 10.8.0

There are a few arguments for selectData() which have been introduced in the forthcoming 10.8.0 release of Preside.

distinct does exactly what you would expect: so the following query would return a distinct list of all the different hair colours of Star Wars characters, if that’s the sort of thing you’re interested in…

hairColours = presideObjectService.selectData(
	  objectName   = "starwars_character"
	, selectFields = [ "hair_color" ]
	, distinct     = true
);

If all you want from your query is to get a count of matching records, use recordCountOnly:

filmCount = presideObjectService.selectData(
	  objectName      = "starwars_film"
	, recordCountOnly = true
);

Finally, there are occasions when you may want simply to return the SQL generated by the method, rather than actually executing it. This might be useful for unit tests, or – as we will discover in a later part of this series – when constructing complex joins.

result = presideObjectService.selectData(
	  objectName          = "starwars_character"
	, getSqlAndParamsOnly = true
);

This will return a struct with two items: sql, which contains the SQL statement, and params, an array of all the SQL parameters for that query (more of this when we get to filters in a later post).

Summary

In this post we’ve looked at the basics of retrieving data in Preside with selectData() with some very trivial examples.

Real-world applications are, of course, more complicated, and in future parts I’ll be talking about filtering records, joins, subqueries and aggregate functions.

Let’s Encrypt SSL with Apache reverse proxy

2017-02-07T12:00:00Z

After years of avoiding SSL like the plague, unless the website absolutely, positively demanded it – due to certificates being both expensive and a nightmare to install/renew – I’ve just discovered Let’s Encrypt, thanks to the one-click simplicity of adding SSL to this site via the Netlify dashboard…

Within 20 minutes of first having the idea, I had all the (more than 20) sites on my CentOS webserver running over HTTPS – at no cost.

I won’t go into the details of setting it all up here, as it’s all covered perfectly well over at Certbot. But I will share the one issue I did have (which added an extra 15 minutes to the setup process).

My sites are powered by Lucee running on Tomcat, served via a reverse proxy (mod_proxy) on an Apache web server. The problem was that the Lucee sites were unaware that they were being served over SSL, and so sites which were set up to redirect to HTTPS – if not already – were going into an endless redirect loop.

The solution is simple. There is an HTTP header, X-Forwarded-Proto, which is a de-facto standard for identifying the originating protocol of an HTTP request when routed through a reverse proxy. If you set it in your vhost definitions on SSL sites, most applications should know that they are being served over HTTPS.

The easiest way (if you’ve used certbot --apache to register and install your certificates) is to edit the file /etc/letsencrypt/options-ssl-apache.conf (location may differ in different flavours of Linux). Simply add the following:

# ...

# Intermediate configuration, tweak to your needs
RequestHeader set X-Forwarded-Proto "https"

# ...

…and restart Apache, and all traffic passing through the proxy will be identified as originating from an HTTPS request.

Working with FoxyCart data feeds in CFML

2016-05-03T12:00:00Z

On a couple of the sites I manage, I have employed FoxyCart to handle the shopping cart and e-commerce. It provides a simple integration into an existing site with very little fuss, and makes it easy to offload the business of running a webshop.

One of the features offered is to post back an XML data feed of each completed transaction, in real time, to your server. You may want this to maintain your own database of orders placed; in my case, it is used to handle MailChimp subscriptions if they ticked the appropriate box during checkout.

However, the encoding/encrypting of the data feed is somewhat arcane, and has taken me a couple of days, on and off, to get up and running in CFML. In fact, due to time constraints, I initially had to spin up a DigitalOcean droplet running PHP in order to handle the process until I could get it working in CFML. (There was a tried and tested PHP solution which I could get running in no time.)

This guide is to help any other poor souls in the future who have to wrestle with this…

The way it works is this: FoxyCart does an RC4 encryption of the XML feed using your own API key (they’ll generate one for you, or you can set it yourself), and it then URL-encodes the rseult and POSTs it to your server (you’ve previously told them what script on your server to fire it at).

Easy, I thought. urlDecode() and then decrypt() using the RC4 algorithm.

Nope.

After much trial and error (mostly error), and hacking the PHP so I could compare exactly what the data was at each stage of the process, I finally solved it. There are two things you need to bear in mind:

When doing the urlDecode(), you need to specify the encoding as ISO-8859-1 (Latin-1). If you use any other encoding, you’ll get a bunch of gibberish with loads of high-ASCII values.
Do not use the CFML decrypt() function - it doesn’t seem to work as expected. I found a number of RC4 libraries in various languages, each doing pretty much the same thing, and there was a CFML version written by Steve Hicks. It needed a slight modification, though, as Steve’s version was expecting the encrypted text to be in Hex format - which it isn’t.

Having done that, you should have a nice XML string which you can parse as normal and then do whatever you will with the data.

These are the two files you’ll need to implement the data feed processing - foxychimp.cfm, which is the file you should point at in the FoxyCart admin, and RC4.cfc, which is my modified version of Steve Hicks’ original library.

Filename foxychimp.cfm

<cfset fcApiKey = "Insert_your_FoxyCart_API_key_here" />


<!---
	Decode the URL-encoded response, using the ISO-8859-1
	(Latin-1) encoding
--->
<cfset encryptedFeed = urlDecode(form["FoxyData"], "ISO-8859-1") />


<!---
	Initialise the RC4 component and call its decrypt method.
	Note the 3rd argument, specifying that the data we are
	passing in is not in Hex format
--->
<cfset RC4 = createObject("component","RC4") />
<cfset feedDataXml = RC4.rc4decrypt(src=encryptedFeed, key=fcApiKey, inputHex=false) />


<!---
	Now you have an XML string which you can parse
--->
<cfset feedData = xmlParse(feedDataXml) />


<!---
	...and do what you like with the feed data
--->
<cfloop array="#feedData.foxyData.transactions.transaction#" index="transaction">

	<!---
		Do whatever you like with each transaction data in here
	--->

</cfloop>


<!---
	FoxyCart expects a simple text response of "foxy"
	to signify that everything has worked.

	You can put error handling in which can return any other string,
	which will then show up in your FoxyCart error logs.
--->
<cfcontent reset="true" />
foxy

Filename RC4.cfc

<!---
ColdFusion RC4 Component

Written by Steve Hicks (steve@aquafusionmedia.com)
http://www.aquafusionmedia.com

Version 1.0 - Released: April 24, 2012

Version 1.1 - Modified by Seb Duggan (seb@sebduggan.com)
			  Added arguments to allow input and output not to be Hex values
			  Released: May 3, 2016
--->

<cfcomponent output="false">
	<!--- Encrypt a String (src) using the Key (key) --->
	<cffunction name="RC4encrypt" access="public" output="false" returntype="string">
		<cfargument name="src" required="yes">
		<cfargument name="key" required="yes">
		<cfargument name="outputHex" type="boolean" default="true">
		<cfset mtxt = strToChars(arguments.src)>
		<cfset mkey = strToChars(arguments.key)>
		<cfset result = RC4calculate(mtxt,mkey)>
		<cfif arguments.outputHex>
			<cfreturn charsToHex(result)>
		<cfelse>
			<cfreturn charsToStr(result)>
		</cfif>
	</cffunction>

	<!--- Decrypt a String (src) using the Key (key) --->
	<cffunction name="RC4decrypt" access="public" output="false" returntype="string">
		<cfargument name="src" required="yes">
		<cfargument name="key" required="yes">
		<cfargument name="inputHex" type="boolean" default="true">
		<cfif arguments.inputHex>
			<cfset mtxt = hexToChars(arguments.src)>
		<cfelse>
			<cfset mtxt = strToChars(arguments.src)>
		</cfif>
		<cfset mkey = strToChars(arguments.key)>
		<cfset result = RC4calculate(mtxt,mkey)>
		<cfreturn charsToStr(result)>
	</cffunction>

	<!--- Set Up the Component Ready for Encryption --->
	<cffunction name="RC4initialize" access="public" output="false" returntype="any">
		<cfargument name="pwd" required="yes">
		<cfset sbox = arraynew(1)>
		<cfset mykey = arraynew(1)>
		<cfset b = 0>
		<cfset intLength = arraylen(arguments.pwd)>
		<cfloop from="0" to="255" index="a">
			<cfset mykey[a + 1] = arguments.pwd[(a mod intLength) + 1]>
			<cfset sbox[a + 1] = a>
		</cfloop>
		<cfloop from="0" to="255" index="a">
			<cfset b = ( b + sbox[a + 1] + mykey[a+1] ) mod 256>
			<cfset tempswap = sbox[a + 1]>
			<cfset sbox[a + 1] = sbox[b + 1]>
			<cfset sbox[b + 1] = tempswap>
		</cfloop>
		<cfreturn sbox>
	</cffunction>

	<!--- Calculate the Cipher --->
	<cffunction name="RC4calculate" access="public" output="false" returntype="any">
		<cfargument name="plaintext" required="yes">
		<cfargument name="psw" required="yes">
		<cfset sbox = RC4initialize(arguments.psw)>
		<cfset i = 0>
		<cfset j = 0>
		<cfset cipher = arraynew(1)>
		<cfloop from="1" to="#arraylen(plaintext)#" index="a">
			<cfset i = (i + 1) mod 256>
			<cfset j = (j + sbox[i + 1]) mod 256>
			<cfset temp = sbox[i + 1]>
			<cfset sbox[i + 1] = sbox[j + 1]>
			<cfset sbox[j + 1] = temp>
			<cfset k = sbox[((sbox[i + 1] + sbox[j + 1]) mod 256) + 1]>
			<cfset cipherby = BitXor(arguments.plaintext[a],k)>
			<cfset arrayappend(cipher,cipherby)>
		</cfloop>
		<cfreturn cipher>
	</cffunction>

	<!--- Convert an Array of Chars into a Hex String --->
	<cffunction name="charsToHex" access="public" output="false" returntype="string">
		<cfargument name="chars" type="array" required="yes">
		<cfset result = ''>
		<cfloop from="1" to="#arraylen(arguments.chars)#" index="i">
			<cfset fbn = formatBaseN(chars[i],16)>
			<cfif len(fbn) eq 1>
				<cfset fbn = '0#fbn#'>
			</cfif>
			<cfset result = result & fbn>
		</cfloop>
		<cfreturn result>
	</cffunction>

	<!--- Convert a Hex String into an Array of Characters --->
	<cffunction name="hexToChars" access="public" output="false" returntype="array">
		<cfargument name="hex" type="string" required="yes">
		<cfset chars = arraynew(1)>
		<cfloop from="1" to="#len(arguments.hex)#" index="i" step="2">
			<cfset arrayappend(chars,inputBaseN(mid(arguments.hex,i,2),16))>
		</cfloop>
		<cfreturn chars>
	</cffunction>

	<!--- Convert an Array of Characters into a String --->
	<cffunction name="charsToStr" access="public" output="false" returntype="string">
		<cfargument name="chars" type="array" required="yes">
		<cfset result = ''>
		<cfloop from="1" to="#arraylen(arguments.chars)#" index="i">
			<cfset result = result & chr(chars[i])>
		</cfloop>
		<cfreturn result>
	</cffunction>

	<!--- Convert a String into an Array of Characters --->
	<cffunction name="strToChars" access="public" output="false" returntype="array">
		<cfargument name="str" type="string" required="yes">
		<cfset codes = arraynew(1)>
		<cfloop from="1" to="#len(arguments.str)#" index="i">
			<cfset codes[i] = asc(mid(arguments.str,i,1))>
		</cfloop>
		<cfreturn codes>
	</cffunction>
</cfcomponent>

SES URLs in Mura FW/1 plugins

2016-03-21T12:00:00Z

The FW/1 plugin architecture for Mura CMS is a very powerful way of embedding complex applications and business logic within your Mura-based website.

However, this comes at the cost of your SES URLs. While Mura itself generates human- and search engine-friendly URLs, your embedded FW/1 app will only have this for the top level of any display object. As you drill down into the app, you will start getting URLs that look like this:

http://example.com/statistics/?MyPluginaction=statistics:main.player&playername=seb-duggan

In this example, the FW/1 app is placed in Mura on the page /statistics/ as a plugin display object. In an ideal world (and how it would probably be if it were a standalone FW/1 site) your URL would be more like:

http://example.com/statistics/player/seb-duggan/

So, how can we achieve this?

One way would be by setting up a bunch of .htaccess rules, and this would be a perfectly workable solution. But what happens when you decide to rename statistics to stats? Wouldn’t it be nice if the URLs were completely controlled by the plugin with no other dependencies, and if the plugin were smart enough to know how to route the URLs wherever it has been placed within the Mura site structure?

After a whole lot of trial-and-error, and whole lot more refactoring, I believe I’ve come up with a pretty robust (and reasonably elegant) solution…

The starting point

All my examples are loosely based on a site I’ve just built for my local cricket club (go and take a look if you like – and see if you can spot where the FW/1 app integrates!).

The normal way to set up an FW/1 plugin would be something like this:

Filename config.xml.cfm

<displayobjects location="global">
	<displayobject
		name="Statistics"
		component="includes.displayObjects"
		displaymethod="dspStatistics"
		persist="false" />
</displayobjects>

Filename displayObjects.cfc

public any function dspStatistics($) {
	return getApplication().doAction("statistics:main.default");
}

This sets up a display object called “Statistics” which can be included into your Mura page. When rendered, it runs the dspStatistics() method, which in turn renders the FW/1 page main.default in the statistics subsystem.

So far, so easy, and if you’ve created an FW/1 plugin before, it should all be very familiar.

Adding the SES

The key to the new system is adding some route definitions to your displayObject configuration file:

Filename config.xml.cfm

<displayobjects location="global">
	<displayobject
		name="Statistics"
		component="includes.displayObjects"
		displaymethod="dspStatistics"
		persist="false">
		<route
			pattern="batting"
			action="statistics:main.batting" />
		<route
			pattern="batting/{'[0-9]{4}'}"
			action="statistics:main.batting" />
		<route
			pattern="player"
			action="statistics:main.playerredirect" />
		<route
			pattern="player/{member.filename}"
			action="statistics:main.player" />
		<route
			pattern="player/{member.filename}/detail"
			action="statistics:main.playerdetail" />
	</displayobject>
</displayobjects>

This doesn’t affect the basic functionality of the definition, but it adds in more data that we can extract and use.

You’ll see several types of route in the example above. The route’s pattern is what gets matched against that part of the URL that comes after the plugin integration point. For example, if you have your plugin object included in the page /statistics/, the first route would match the URL /statistics/batting/.

Parts of the URL that can vary are contained in curly braces. If the content of the curly braces is itself wrapped in single or double quotes, as in the second route, then this is a regular expression. So the second route would match /batting/2016/ (the regex matches a pattern of 4 digits).

If the pattern within the braces is not wrapped in quotes, then this is a value to validate against a bean. So, the fourth route would match against /statistics/player/seb-duggan/ - and would additionally validate that there is a member bean with a filename value of seb-duggan.

Each route has a fully-qualified FW/1 action, the page which should be rendered if the route is matched.

Writing it out like this, it seems quite complicated, but it’s really very simple!

The heavy lifting

There are a bunch of methods which need to be added to your plugin’s eventHandler.cfc to make all this work. I choose to keep them all in a separate file and include them into the eventHandler, but that’s up to you…

private function getSesRoutes() {
	var objectsLen = 0;
	var displayObject = "";
	var result = {};
	var route = {};
	var routes = [];
	var pluginXML = variables.pluginConfig.getPluginManager().getPluginXML(variables.pluginConfig.getModuleId());

	if ( structKeyExists(pluginXML.plugin.displayobjects,"displayobject") ) {
		objectsLen = arrayLen(pluginXML.plugin.displayobjects.displayobject);
		if (objectsLen) {
			for (var i=1; i<=objectsLen; i++) {
				displayObject = pluginXML.plugin.displayobjects.displayobject[i];
				if (structKeyExists(displayObject,"route")) {
					routes = [];
					for (var r=1; r<=arraylen(displayObject.route); r++) {
						route = {};
						route["pattern"] = displayObject.route[r].xmlAttributes.pattern;
						route["action"] = displayObject.route[r].xmlAttributes.action;
						arrayAppend(routes, route);
					}
					result[displayObject.xmlAttributes.displaymethod] = routes;
				}
			}
		}
	}
	return result;
}

private function getSesUrlMatches(required event) {
	var qs = getQueryService();
	var sql = "";
	var dbtype = application.configBean.getDBType();
	var lengthFunction = "";

	if (dbtype == "mssql") {
		lengthFunction = "datalength";
	} else if (listfindnocase("mysql,oracle", dbtype)) {
		lengthFunction = "length";
	} else if (dbtype == "postgresql") {
		lengthFunction = "char_length";
	} else if (dbtype == "nuodb") {
		lengthFunction = "character_length";
	}

	sql = "SELECT
			tcontent.filename,
			tplugindisplayobjects.displaymethod
		FROM
			tplugindisplayobjects
		INNER JOIN
			tcontentobjects
		ON
			tplugindisplayobjects.objectid = tcontentobjects.objectid
		INNER JOIN
			tcontent
		ON
			tcontentobjects.contenthistid = tcontent.contenthistid
		AND
			tcontent.active = 1
		WHERE
			tplugindisplayobjects.moduleid = :moduleid
		AND
			tplugindisplayobjects.displaymethod IN (:displaymethods)
		AND
			tcontent.siteid = :siteid
		AND
			left(:fullurl, #lengthfunction#(tcontent.filename)) = tcontent.filename
		ORDER BY
			#lengthfunction#(tcontent.filename) DESC";
	qs.addParam(name="moduleid", value=variables.pluginConfig.getModuleId(), cfsqltype="cf_sql_varchar");
	qs.addParam(name="siteid", value=arguments.event.getValue("siteid"), cfsqltype="cf_sql_varchar");
	qs.addParam(name="displaymethods", value=structkeylist(variables.pluginConfig.getApplication().getValue("sesRoutes")), list=true, cfsqltype="cf_sql_varchar");
	qs.addParam(name="fullurl", value=arguments.event.getValue("currentfilenameadjusted"), cfsqltype="cf_sql_varchar");

	return qs.execute(sql=sql).getResult();
}

private function validateSesUrlParams(required $, required event, required displayMethod, required sesUrlParts) {
	var routes = variables.pluginConfig.getApplication().getValue("sesRoutes");
	var sesUrlParams = [];

	if (not structkeyexists(routes, arguments.displayMethod)) {
		return false;
	}
	for (var route in routes[arguments.displayMethod]) {
		var routeParts = listToArray(route.pattern, "/");
		if (arrayLen(routeParts) != arrayLen(arguments.sesUrlParts)) {
			continue;
		}

		var match = true;
		for (var i=1; i<=arrayLen(routeParts); i++) {
			if (reFind("^{[""''].+[""'']}$", routeParts[i])) {
				match = validateSesUrlPartRegex($, routeParts[i], arguments.sesUrlParts[i]);
				arrayAppend(sesUrlParams, arguments.sesUrlParts[i]);
			} else if (reFind("^{.+}$", routeParts[i])) {
				match = validateSesUrlPartBean($, routeParts[i], arguments.sesUrlParts[i]);
				arrayAppend(sesUrlParams, arguments.sesUrlParts[i]);
			} else if (routeParts[i] != arguments.sesUrlParts[i]) {
				match = false;
				break;
			}
		}
		if (!match) {
			continue;
		}

		arguments.event.setValue("sesUrlParams", sesUrlParams);
		arguments.event.setValue("sesAction", route.action);
		return true;
	}
	return false;
}

private function validateSesUrlPartRegex(required $, required pattern, required urlPart) {
	arguments.pattern = reReplace(arguments.pattern, "^{[""''](.+)[""'']}$", "\1");

	return refindNoCase("^" & arguments.pattern & "$", arguments.urlPart);
}

private function validateSesUrlPartBean(required $, required pattern, required urlPart) {
	arguments.pattern = reReplace(arguments.pattern, "^{(.+)}$", "\1");
	var entity = listFirst(arguments.pattern, ".");
	var column = listLast(arguments.pattern, ".");

	var checkBean = arguments.$.getBean(entity).loadBy("#column#" = arguments.urlPart);
	return !checkBean.getIsNew();
}

The first method, getSesRoutes(), should be called from the eventHandler’s onApplicationLoad() method:

variables.pluginConfig.getApplication().setValue( "sesRoutes", getSesRoutes() );

This examines the displayObject config file and extracts all the routes for each displayObject, and we cache that in the plugin’s application scope.

We then need to handle the SES URLs by setting up a 404 handler in the eventHandler. By default, Mura will not recognise the URLs we’re trying to catch, and so onSite404() will be invoked:

public any function onSite404(required $, required event) {
	var qMatches = getSesUrlMatches(arguments.event);
	if (qMatches.recordcount) {
		var sesUrlParts = listtoarray(replace(event.getValue("currentfilenameadjusted"), qMatches.filename, ""), "/");
		if (validateSesUrlParams($, event, qMatches.displaymethod, sesUrlParts)) {
			local.contentBean = application.contentManager.getActiveContentByFilename(qMatches.filename, event.getValue('siteid'));
			event.setValue('contentBean', local.contentBean);
		}
	}
}

This is where all the clever stuff happens. First, getSesUrlMatches() looks to see if some part at the beginning of the URL matches any of the Mura pages that include one of the displayObjects with routes defined on them.

If a match is found then we pass the remainder of the URL through and try to match it against the defined routes. We check each section of the URL in turn; if the URL part is a {variable}, then it’s either matched as a regular expression, or the value is checked against the specified bean. Each variable value is appended to an array for use later by the controller methods.

If a route is successfully matched, then the array of variables (sesUrlParams) and the FW/1 action defined on the route (sesAction) are added to the Mura event object for use later by the FW/1 app; and finally, we load in the content for the Mura page we identified earlier and add that to the event object too.

If no match is found, then we simply fall through to the main Mura 404 page, so you don’t need to maintain a separate 404 page in your FW/1 app. And becasue of the way we validate the value of the bean value variable, we already know before going into the FW/1 app if the value passed is a valid one.

The last thing that needs to be modified is the displayObjects method:

public any function dspStatistics($) {
	var action = $.getEvent().getValue("sesAction", "statistics:main.default");
	return getApplication().doAction(action);
}

Here, we are getting the controller action from the event object which will have been set if a route has matched; and if that doesn’t exist, we default to the original action we had at the start.

Finally, you need to configure your FW/1 controller methods to accept the values we’ve extracted from the URLs. Simply add the following to any method that is expecting one or more variables from an SES URL:

var urlParams = rc.$.getEvent().getValue( "sesUrlParams", [] );

…and you have your array of each of the values matched in the URL. So, in my example, if I requested the page:

http://example.com/statistics/player/seb-duggan/detail/

…I would get the content rendered by the controller action statistics:main.playerdetail, and urlParams would contain one value, seb-duggan.

To wrap up

It may seem complicated, but most of it is code that you can add and forget about. The configuration is contained within config.xml.cfm and displayObjects.cfc, just as it was previously, and your FW/1 controller methods will get any variables they need from the event object.

Caveats

I’ve written and tested this on Lucee. The only reason it wouldn’t work on Adobe CF is if I’ve used some Lucee-specific syntax. But I don’t think I have.
I really don’t know what would happen if you had two plugins on the same Mura page, both of which were expecting to match an SES route. If for some reason you have this requirement, please let me know how you get on!
My plugin was written using Mura ORM, and so my validation works against Mura ORM beans. This could be easily modified to check against a table and column, or you could just use regular expressions and do all the data validation within the FW/1 app - but then you would lose the ability to fall through to Mura’s 404 page.

RTFM carefully when applying CF hotfixes!

2012-03-14T12:00:00Z

Here’s a quick tip for anyone who may be seeing some odd behaviour after applying a ColdFusion hotfix (as well as a reminder to myself to be more careful next time…).

I’ve just applied the latest security hotfix to my web server, and everything seemed to have worked fine - except that I suddenly started receiving a bunch of ColdFusion error notifications from a couple of my websites.

The error was being reported as coldfusion.runtime.Cast._double(J)D, and a little Googling directed me to this thread on the MXUnit mailing list, with a solution right at the end. As it’s not exclusively an MXUnit issue (it seemed to come about when getting the difference between two getTickCount() values) I thought I’d share the solution here.

What it boils down to is this. When the installation instructions say:

If hf901-00001.jar, hf901-00002.jar or hf901-00003.jar exist, delete them.

…make sure you look at the filenames very carefully, and do not delete chf9010002.jar - which is the updater for Cumulative HotFix 2.

Once I’d restored the file I’d deleted in error, everything worked again as it should. Roll on ColdFusion 10 with its automated update process…