Oh no! The great Apple is authenticating their higher education purchases through some thoroughly Microsoft based technology. Say it ain’t so!

The Telerik Radgrid is both a blessing and a curse at the same time. How can a grid, that seems designed to have a dropdown column in it and comes with default filtering, not take into account the fact that you are going to have foreign keys in a grid that you want to filter on?

This is an ongoing rant of mine. Getting good foreign key support on large enterprise applications seems like an uphill struggle every single time. I wrote about how I like to see books on programming jump right in and show me how to get my foreign key drop downs hooked up almost right off the bat, since it is almost entirely unavoidable in any application that has any sort of usefulness in my opinion.

My goodness getting the RadGrid to do your bidding can be an infuriating ride. Personally, I think components should just work out of the box. I know the RadGrid is extremely complex and there are layers upon layers of documentation and examples on the Telerik site, but to me, I shouldn’t have to find out about how difficult it is to filter on ListTextField after I’ve knocked up a prototyped to a client. Heck the documentation should have a large caveat at the top telling you the limitation of the software. Really, I shouldn’t need to read that far into the documentation just to use the component in my opinion. I want something quick and easy to take the pain out of grid based data admin, not a whole new bloody thing that I have to learn inside out.

As per Telerik’s website:

he built-in GridDropDownColumn will be filtered by its ListValueField when the default filtering feature of the control is used. Filtering by ListTextField is not attainable in the present version of Telerik RadGrid

Great. Thanks! This is burried in the How To section. Okay, not too obtuse, but still, all the basic examples show filtering on example datasets that are things like Customer listings (with Customer, Contact Name, Company). Heck, it is reasonable to assume that Company was being looked up using the GridDropDownColumn column. Isn’t it?

So, Telerik provide a solution – have a hidden field that is the text description. Capture the ItemCommand on the grid and then if it is a filter command, pop the filter text into the hidden field’s filter text box and run the filter based on that criteria. The problem is, out of the box this breaks user experience because the filter text they typed in disappears.

Now you have to hack around to find a way to keep the filter text there. Come on Telerik, get this one together. Not pleasant. I gave up, because I didn’t have time to delve that deeply into the RadGrid. I needed something quicker. Option 2 given by Telerik – implement a custom drop down in the actual filter area of the grid. The example code was long and I didn’t feel like going through it – again time constraints. I just couldn’t spend time exploring all of this because I have deadlines. Why couldn’t they just build this into the grid? If they have solutions, it shouldn’t be that difficult to put it into the base functionality.

One more thing – putting a drop down in that is based on an id field (and let’s be honest it probably is if it’s a lookup into another table) means you get the default “number” filtering options. This means that the filtering options out of the box are things like “greater than”, “less than” etc etc. These don’t make sense for a user who is filtering based on text. This is another fault with their default solution outlined above of using the hidden field and substituting values in. I know you can overide this and put your own filtering menu in, but say it with me…..deadlines.

By now, I’m not a happy bunny. What did I do in the end? I amended my stored proc to bring back a complete result set with description fields (making things slower for me because now I have table joins). Then I hid the drop down list field until the user wanted to edit the row or add a new row in. Then I hid the description fields and showed the drop down fields.

What a bodge.

SELECT [Name]
         [Surname],
         [Address],
         [Telephone],
         [Email]
FROM ATableAboutPeople

See, the error isn’t obvious, because the SQL compiles and runs, but the result set just doesn’t bring back what you expect…..because [Name] is now aliased as [Surname] – all because of a missing comma.
Bollocks!
Hate it when that happens.

There are days when ASP really lives up to its namesake and just completely kills you, or more accurately, kills your webserver that has previously managed to woo you as if it were Cleopatra herself.

Seriously. Microsoft needs to sort out this inter platform CLR bollocks. How is it that an application working perfectly on a local machine and a test server fails on a production server? Versions? Bollocks – all the asp.net versions are the same. I bet even they wouldn’t be able to answer it. Then to add insult to injury, all they give you is

Void System.Web.UI.WebControls.Parameter..ctor

Yah. Okaaaay……very helpful there Mr M$ ASP.Net. I mean, sure. That makes a lot of sense. I know exactly what to do now.

Thank goodness for the interwebs, otherwise I would be stuck trying to decode this nonesense myself. To the rescue this blog post. Thank you good sir.

If you jump between Linux and Windows XP like I do, sometimes you’ll pull your Rails app into the dreaded M$ platform, fire it up and be greeted with a lovely “Internal Server Error”. Naturally it goes on to say something like “You have a nil object when you didn’t expect it! You might have expected an instance of Array. The error occurred while evaluating nil.each” despite the fact that you’ve changed no code since last night when your app was running rather nicely in a Linux environment thank you very much. Sometimes you just need to hack your way out of a problem without worrying about the whys and wherefores – and that’s exactly what we are going to do here. So……open up config\environments\development.rb and find this line :

config.logger = Logger.new(config.log_path, 2, 10.kilobytes)

comment it out comme ça

#config.logger = Logger.new(config.log_path, 2, 10.kilobytes)

and fire it up again. All good? Yes? Excellent. Fixed. Why? Um. Log rotation in XP apparently. Something funny about it. Don’t really know. Haven’t investigated it much further because there is no way in hell I’m going to run a production Rails app in Windows. Ever.

Yes indeed folks, I bring you the number of passports lost or stolen in Europe as recorded by the British consulates in said countries for the year 01 April 2008 to 31 March 2009.

Red = worse. From which we can falsely infer that we shouldn’t go to the red ones because you are more likely to have your passport stolen

One of the blessings in WordPress is the vast array of plugins available. However, it is also one of the curses….because it makes us lazy. While this doesn’t seem to be problematic in the short term, in the longer term, large numbers of plugins can cause blogs to slow down, and even worse, the various plugins could start interfering with each other. So, whenever I can, I like to write my own code – the two advantages are that
1 – I can control exactly what goes in to the code, making it do what I need and no more
and
2 – I’ve written the code so if things start to clash, it’s going to be easier to debug.

So, let’s learn how to create a WordPress page to display every comment on our blog and just for fun, let’s also code up a quicktag which we can place into any page or post where we want the comments displayed.

Start in your theme’s functions.php

add_filter('the_content', 'all_your_comments_are_belong_to_me');
 
function all_your_comments_are_belong_to_me($content) {
	if (strstr($content, '<!--all_your_comments-->')) { 
 
	  $allcomments = get_comments();
 
    $strout = "<ul>";
 
		foreach ($allcomments as $comment) {
			$postforcomment = get_post($comment->comment_post_ID); 
			$strout .= '<li><strong><a href="'. $comment->comment_author_url . '">' . $comment->comment_author . '</a> had a thought about <a href="'.get_permalink($comment->comment_post_ID).'">'.$postforcomment->post_title.'</a></strong>';
			$strout .= ' on <small>' . $comment->comment_date . '</small><br>';
			$strout .= '<p>' . $comment->comment_content . '</p></li>';
		}
 
		$strout .= '</ul>';
 
		$content = str_replace('<!--all_your_comments-->', $strout, $content);
	}
 
	return $content;
}

What’s all this code doing? Well first, we set up a filter with the add_filter command. Filters allow us to extend much of the core WordPress functionality, allowing us to add our own processing. This is very powerful because it means we can modify the way WordPress saves or displays our data without having to delve into the core WordPress code and hack our WordPress install to pieces. That in turn means that we can safely update the core of our blog without having to worry about re-applying any customised functions that we have written for our blog. Filters are what makes plugins work like magic.

So for this bit of magic, we are adding a filter to a hook called the_content. This tells WordPress that we want to execute some of our own code whenever WordPress is creating the content of a page or post just before it is displayed on the screen. The function we are going to call is all_your_comments_are_belong_to_me which we define right after the add_filter command.

This function takes one argument by default – $content (or whatever you want to call it) which is the actual written content of your post or page (for example you are reading the content of my post right now). We wrap everything in an if statement – which means that we will only process the rest of our code in our function if somewhere in our content we have the following quicktag: all_your_comments.

Okay, into the meat and potatoes – getting every comment to display. Here we use a tasty function called get_comments() which, as the name suggests, gets all the comments for every post in our blog. There are various arguments you can supply to this WordPress function, but we really don’t need any of them for the purposes of our demo. Now we loop through all the comments, creating a string that is the actual html of all the comments we want to output. At the same time, to add a little extra value we grab the post associated with each comment. This is a little bit more costly in terms of actual database round trips, but what the heck, we want a nice output.

We create our string (format it however you want and define your styles in your css. And then, the pièce de résistance – the str_replace which says: “take this lovely html string I have created and substitute it into our $content variable wherever you find the phrase <!––all_your_comments––>”. Remember $content is the actual written content of our page. Finally, we return our $content variable from our function.

One gotcha – when using a hook into the_content, you must return something, so at the very least, if we fail our if condition we just send back the $content that we got in. If you don’t, WordPress will display nothing – no content for your post. Be warned.

Okay now all that’s left is to write a new page to display all these comments – whip up a lovely new page or post and write it up as you wish. At any point, slap in the all_your_comments quicktag and save. And test….All your comments on one page. Lovely.

This code is both good and bad. Good in that it is quick to code up but bad in that every time WordPress displays a post or page, it will go through our function – this will slow down our blog (but hey, I’m taking one for the team on the demo page). So how else could we do this? Well we could create a template page which would do this for us – this would be more efficient, but less flexible because we wouldn’t be able to control where the comments were injected into the contents of the page.

So, I hope you got something out of that. This can easily be extended into a plugin if you are feeling that way inclined; perhaps I’ll do that at some point in the future. For now though, hopefully you enjoyed that little step into WordPress hacking and have a better understanding of how easy it is to code up a custom quicktag in WordPress to pull in all of the comments in your blog.

private Dictionary theThingThatWasNotUnique(){
  blah blah blah;
  Dictionary aSetOfResults= new Dictionary();
  foreach (DataRow dr in ds.Tables[0].Rows){
    DateTime startDate= (DateTime)dr["dtStart"];
    string activityName = (string)dr["sActivityName"];
    aSetOfResults.Add(startDate, activityName);
  }
}

Okay, the Dictionary object in C# is pretty neat. I mean it’s fast and light because it’s essentially a hash table and it really is nice to enumerate through. The gotcha is, it relies on unique values in the key. And herein lies the problem with the code above. In the application I was troubleshooting, the dates that were stored were not guaranteed to be unique. This is really a simple case of not understanding the data structure properly and making false assumptions.

Not a big deal really, because these things usually come out in the wash. The big deal is when it is only caught as the system is going live and we really need to implement a quick patch to get it working without spending a lot of time on it. I’m talking a ten minute patch so it works away for next day or so until we have time to re-factor the code properly.

Here’s what I did.

private Dictionary theThingThatWasNotUnique(){
  blah blah blah;
  Dictionary aSetOfResults= new Dictionary();
  foreach (DataRow dr in ds.Tables[0].Rows) {
    DateTime startDate= (DateTime)dr["dtStart"];
    string activityName = (string)dr["sActivityName"];
    HackUniqueDateTimeIntoDictionary(startDate, activityName , ref aSetOfResults);
    }
}
private void HackUniqueDateTimeIntoDictionary(DateTime possibleNonUniqueDateKey, string aValue, ref Dictionary theDic) {
  if (theDic.ContainsKey(possibleNonUniqueDateKey)) {
    DateTime newkey = possibleNonUniqueDateKey.AddMilliseconds(1);
    HackUniqueDateTimeIntoDictionary(newkey, aValue, ref theDic);
  } else {
    theDic.Add(possibleNonUniqueDateKey, aValue);
  }
}

It’s a bit nasty, but recursively adding a millisecond to the key if it already exists, gets me a workable solution in almost no time at all. Just as quick, you might say, is to re-factor it into an object proper or maybe an arraylist, but the various bits of code that consumed the dictionary object was complex and I didn’t have time to go through all of the various consumers and make them right.

True to tunaslut ideals, this theme is certified dolphin friendly.

Download In Brine WordPress Theme now hosted at wordpress.org