Geekality » Software Development

JavaScript: Uppercase first letter in a string

Torleif — Wed, 30 Jun 2010 13:21:07 +0000

In PHP there is a very handy function called ucfirst which

Returns a string with the first character of str capitalized, if that character is alphabetic.

Needed that in JavaScript, but discovered there was no such thing.

Luckily I quickly found a function over at StackOverflow that I adjusted slightly and added to the string class:

String.prototype.ucfirst = function()
{
return this.charAt(0).toUpperCase() + this.substr(1);
}

Can be used like so:

alert('some text'.ucfirst())
// Alerts: Some text

Alternative method

In some cases it might be good to handle this in CSS instead though. For example to uppercase the first letter in all list items, you can do this:

li:first-letter
{
text-transform: uppercase;
}

Weeee Ok, back to work…

PHP: How to easily provide JSON and JSONP

Torleif — Sun, 27 Jun 2010 18:03:28 +0000

Have some server-side data that you would like to grab through an AJAX call? For example by using the jQuery.ajax method?

A really easy way of doing this is by using the JSON format.

JSON

It is hyper simple. All you need to do is to set the content-type to application/json and encode your data using the json_encode function.

header('content-type: application/json; charset=utf-8');

$data = array(1, 2, 3, 4, 5, 6, 7, 8, 9);

echo json_encode($data);

You can test it out for example in the FireBug console by running this line:

$.ajax({url: 'data.php'})
// Response: [1,2,3,4,5,6,7,8,9]

You should see the request being done in the console and also in the Net tab. If it didn’t work, you might be subject to the following:

Due to browser security restrictions, most “Ajax” requests are subject to the same origin policy; the request can not successfully retrieve data from a different domain, subdomain, or protocol.

A nice and simple solution to that problem is JSONP.

JSONP

As stated on Wikipedia,

JSONP or “JSON with padding” is a complement to the base JSON data format, a usage pattern that allows a page to request and more meaningfully use JSON from a server other than the primary server.

I’m not sure I get everything about JSONP, but I have used it and I know that it works It’s almost just as easy as plain JSON actually, and all that’s needed is to wrap the JSON encoded data in a callback function provided as a GET parameter.

header('content-type: application/json; charset=utf-8');

$data = array(1, 2, 3, 4, 5, 6, 7, 8, 9);

echo $_GET['callback']. '('.json_encode($data).')';

You can test it by running

$.ajax({url: 'data.php', dataType:'jsonp'})
// Response: jsonp1277656587731([1,2,3,4,5,6,7,8,9])

This time you won’t see the call in the FireBug console though, but only in the Net tab. That’s because the data is loaded in a script tag instead of through an actual AJAX call. Thankfully jQuery handles all of that though, so you don’t have to worry about it at all. You’ll get the same JSON data in your response handler, ready to be used however you want to

What if you’d like to have both options?

JSON and JSONP

Providing both is easy as cake. Just check if the callback parameter is set or not:

header('content-type: application/json; charset=utf-8');

$data = array(1, 2, 3, 4, 5, 6, 7, 8, 9);
$json = json_encode($data);

echo isset($_GET['callback'])
? "{$_GET['callback']}($json)"
: $json;

That’s all! Please comment if you have any feedback

PHP: Generating transparent PNG fillers

Torleif — Sun, 13 Jun 2010 13:45:38 +0000

So, I was fooling around the other day with an HTML table and wanted to make the odd rows slightly darker. Figured I could use for example an 80% transparent black PNG to do that (or could have just assigned a darker color, but where’s the fun in that?). Either way, ended up making a little something that I thought I could share just for the fun of it. I learned a few things, so maybe someone else can too

So, here’s how to make a small transparent PNG filler image on-the-fly using PHP

I called the script fill.php, and the first line looks like this:

header('Content-type: image/png');

This starts the php script and sets the content-type to image/png which means the web browser will that we are an image and not an html file which usually is the default.

Next up we get the parameters from the user:

$p = $_GET + array
(
'r' => 0,
'g' => 0,
'b' => 0,
'a' => 0,
);

Here I create an array with default values and merge it with the $_GET array so that values from the user will override the default values. This means we are sure we have all the values we need and that the user only have to specify the ones he want to.

The r, g and b values should be a number between 0 and 255 and the alpha value should be between 0 and 127. So, next up we need to make sure that that is the case so we don’t use some other bogus we might have gotten:

array_walk($p, function (&$item, $key)
{
$item = min(max(0, $item), $key == 'a' ? 127 : 255);
});

This goes through each parameter and makes sure it is a number between 0 and 255 (or 127 for the alpha).

Since we have what we need now, we can start with creating our image:

$img = @imagecreatetruecolor(15, 15)
or die('Cannot Initialize new GD image stream');

We also need to set a flag that we want to use full alpha channel information (as opposed to single-color transparency) in this image:

imagesavealpha($img, true);

We are now ready to fill our image with the color we are asked for:

$color = imagecolorallocatealpha($img,
$p['r'],
$p['g'],
$p['b'],
$p['a']);
imagefill($img, 0, 0, $color);

And finally output the result and destroy the image resource we have been working with:

imagepng($img, null, 9);
imagedestroy($img);

And that’s actually all there is to it!

The complete code looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

header('Content-type: image/png');

// Replace default parameters with user input
$p = $_GET + array
(
'r' => 0,
'g' => 0,
'b' => 0,
'a' => 0,
);

// Make sure they are within limits
// (colors: 0-255, alpha: 0-127)
array_walk($p, function (&$val, $key)
{
$val = min(max(0, $val), $key == 'a' ? 127 : 255);
});

// Create image
$img = @imagecreatetruecolor(15, 15)
or die('Cannot Initialize new GD image stream');

// Use full alpha channel information
imagesavealpha($img, true);

// Fill image
$color = imagecolorallocatealpha($img,
$p['r'],
$p['g'],
$p['b'],
$p['a']);
imagefill($img, 0, 0, $color);

// Output result
imagepng($img, null, 9);
imagedestroy($img);

If you want to check out a working demo version of this, you can test out my little testing tool I created while having fun with this at tools.geekality.net/filling-factory

Let me know what you think! And as usual, please let me know if you see something that is wrong or could be improved or anything like that

C#: How to send emails

Torleif — Sun, 16 May 2010 00:21:02 +0000

Sending a basic email message in a C# application is quite easy thanks to a class called SmptClient.

We simply need an address to send to, an address to send from, the message we want to send and the client:

That was pretty simple, wasn’t it? But what if we need to authenticate with our server? And what if we want to send our message in a more secure manner?

Authentication

You will quite often find that an SMTP server requires you to authenticate yourself before it will let you do anything. This is however very simple to do. All we need, is to provide our credentials to the client:

var client = new SmtpClient("smtp.example.com")
{
Credentials = new NetworkCredential
{
UserName = "me@example.com",
Password = "password",
},
};

Now, when you try to send your message like before, it should be sent without problems But what if you want to send your email securely?

Using SSL to encrypt the connection

To send emails through an encrypted connection, all you have to do is to set the EnableSSL property of the SmtpClient to true:

var client = new SmtpClient("smtp.example.com")
{
EnableSSL = true,
Credentials = new NetworkCredential
{
UserName = "me@example.com",
Password = "password",
},
};

When you now try to send your email, it will use the Secure Socket Layer to encrypt the connection. Like me, you might run into a problem though; an AuthenticationException with the following message: The remote certificate is invalid according to the validation procedure.

Imperfect certificates

After reading about how these certificates work and some more digging around I found out that the certificate of the SMTP server I use is considered invalid for two reasons: Firstly it was not issued by a trusted Certification Authority (like VeriSign or Thawte), but by my host (Dreamhost) themselves. And finally there is a mismatch between the domain I’m connecting to (smtp.example.com) and the domain the certificate was issued to (mail.dreamhost.com).

Manual certificate validation

SSL has two purposes: security and authentication. And the security will actually work fine and all the traffic will be encrypted even if the authentication fails. In other words, as long as we can look at the certificate ourselves and be sure that we thrust it, we can go ahead and continue with our work.

To check the certificate ourselves we can provide a RemoteCertificateValidationCallback delegate to a class called the ServicePointManager.

ServicePointManager.ServerCertificateValidationCallback
= OurCertificateValidation;

But how can we decide if we should trust the certificate or not? Well, I have found three ways that works nicely. Well, actually just two since the first way is to just cover your eyes and let anything pass.

Pretend validation

The following implementation is a way to simply say that I don’t care:

static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return true;
}

This is of course not very good… we should at least make some effort and check if the certificate is the one we should be getting. We can for example…

Check the certificate fingerprint

Certificates have something called a fingerprint and if we know the fingerprint of the certificate we should get, then we can compare it with the fingerprint of the one we actually got.

static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return certificate.GetCertHashString()
== "6B8C79AB966D70277BA86E6F820859A2B5B8CCC0"; // SHA-1 fingerprint
}

If you don’t think this is enough, you can for example…

Check the whole certificate

If you can export the certificate to a file somehow, you can then later compare the certificate you get with the one you have stored and make sure they are equal.

static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
var actualCertificate = X509Certificate.CreateFromCertFile("example.cert");
return certificate.Equals(actualCertificate);
}

I got a hold of the certificate file by sticking the following snippet inside my validation delegate, ran my code once, and then changed it back to normal again:

static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
using (var file = File.Create("example.cert"))
{
var cert = certificate.Export(X509ContentType.Cert);
file.Write(cert, 0, cert.Length);
}
return false;
}

I also successfully exported it from Opera, which I use as an email client, by going to Preferences, Security, Manage Certificates, Approved and then export the one I want. This of course assumes you have have previously approved the certificate for use with Opera.

Wrap-up

That’s all for now! Found it kind of fun to get this working and thought I could share it in case someone else struggles with this. Please comment and let me know if I have misunderstood something or done a big blunder or something like that! I mostly just know that my code is working, so if you know more about how these security issues work and you know something you think i should know as well: Please share! I’d like to learn

Here is my final complete code:

using System;
using System.Net.Mail;
using System.Net;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.IO;
using System.Net.Security;

namespace Geekality.SecureEmail
{
class Program
{
static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
var actualCertificate = X509Certificate.CreateFromCertFile("example.com.cert");

return certificate.Equals(actualCertificate);
}

static void Main(string[] args)
{
// Register our own certificate validation
ServicePointManager.ServerCertificateValidationCallback = OurCertificateValidation;

// Message
var from = new MailAddress("me@example.com", "Me");
var to = new MailAddress("you@example.com", "Myself");

var message = new MailMessage(from, to)
{
Subject = "Greetings!",
Body = "How are you doing today?",
};

// Create client
var client = new SmtpClient("smtp.example.com")
{
EnableSsl = true,
Credentials = new NetworkCredential
{
UserName = "me@example.com",
Password = "password",
},
};

// Try to send
using (client)
{
try
{
client.Send(message);
Console.WriteLine("Message sent!");
}
catch (AuthenticationException e)
{
Console.WriteLine(e.Message);
}
catch (SmtpException e)
{
Console.WriteLine(e.Message);
}
}

Console.ReadKey(true);
}
}
}

Kohana PHP framework

Torleif — Mon, 19 Apr 2010 19:59:46 +0000

As you might know, I am developing some internal software for LifeStyleTV at the moment. Because of various slightly annoying circumstances I am stuck using PHP and MySQL for this. Not the worst of course, but I must say I really do prefer C# over PHP for oh so many reasons. But anyways, that wasn’t the point of this post. The point is that for my life to become hopefully quite a bit easier and hopefully a lot more organized I decided to go looking for a framework I can use as a base for the software I will be developing.

After much looking I finally stumbled over a framework called Kohana.

Kohana is an open source, object oriented H MVC web framework built using PHP5 by a team of volunteers that aims to be swift, secure, and small.

Kohana is licensed under a BSD license, so you can legally use it for any kind of open source, commercial, or personal project.

Getting started with it was a bit of a hassle because the documentation isn’t the greatest, but the small community has been helpful and the framework is pretty clear once you grasp the basics. For me it was particularly difficult since I don’t really have that much experience with MVC frameworks at all. But so far it has been very fun to learn and code with it.

There are currently two versions of Kohana, 2 and 3. These are pretty much different frameworks, and I decided to go for version 3 as it seem to be cleaner and support HMVC which seems very interesting.

Here are some very helpful resources that helped me get started:

Alrighty, will blog more about Kohana some other day. Maybe even some tutorials…?

Are you using any PHP frameworks? What do you use? Please share!

How to check for duplicates

Torleif — Tue, 19 Jan 2010 16:57:09 +0000

Say you have an IEnumerable of some sort and you want to check if it contains any duplicates. How do you do that?

Terrible solution

I needed to do this a while ago and the first solution that hit me wasn’t exactly good. Linq has method called Distinct, which returns the distinct items in a sequence (weeds out duplicates). Using that to check if duplicates exists you can do something like this:

var hasDuplicates =
subjects.Count() != subjects.Distinct().Count();

This is of course a really bad solution. So don’t use it!

Good solution

The much better solution is to use a HashSet.

The HashSet class provides high performance set operations. A set is a collection that contains no duplicate elements, and whose elements are in no particular order.

In addition to the fact that it cannot contain duplicate items, it also has a very nice add-method which returns false if the item is already in the set.

To check for duplicates using a hash set we can start out by assuming there is no duplicates and then add items to the hash set until we either run out of items, or we try to add an item that already exists. In the first case our assumption was right and in the second it turned out to be wrong.

var set = new HashSet<T>();

var hasDuplicates = false;

foreach (var s in subjects)
if (!set.Add(s))
{
hasDuplicates = true;
break;
}

Good and handy solution

Since we don’t want to type in that stuff over and over again we want this snippet in a nice extension method. Code snippet coming up

using System.Collections.Generic;

namespace Geekality.Snippets
{
public static class EnumerableExtensions
{
public static bool HasDuplicates<T>(this IEnumerable<T> subjects)
{
return HasDuplicates(subjects, EqualityComparer<T>.Default);
}

public static bool HasDuplicates<T>(this IEnumerable<T> subjects, IEqualityComparer<T> comparer)
{
if(subjects == null)
throw new ArgumentNullException("subjects");

if(comparer == null)
throw new ArgumentNullException("comparer");

var set = new HashSet<T>(comparer);

foreach (var s in subjects)
if (!set.Add(s))
return true;

return false;
}
}
}

Simple and handy. You use it for example like this:

if(subjects.HasDuplicates())
{
// Do something
}

Hope it can help someone, somewhere, below and/or over the rainbow

Let me know what you think. I’m always open for improvements and feedback

Test-Driven Development: By Example

Torleif — Tue, 01 Dec 2009 17:36:16 +0000

I earlier wrote about the book, The Art of Unit Testing, which I finished a while ago. That book was very good and was focused on how to write good unit tests. It also mentioned Test-Driven Development, TDD, but not too much. The book I read next, which I finished a few days ago, was kind of the other way around. Pretty much only about TDD. And from the title, Test-Driven Development: By Example, that shouldn’t be much of a shocker

The book is written by Kent Beck and explains the basics about TDD. It does this pretty well, step by step, by example, just like the title says. The book also talks some about TDD in a more general sense. What it is, how it works, why it works, et cetera.

From the back-cover:

Readers will learn to:

Solve complicated tasks, beginning with the simple and proceeding to the more complex.

Write automated tests before coding.

Grow a design organically by refactoring to add design decisions one at a time.

Create tests for more complicated logic, including reflection and exceptions.

Use patterns to decide what tests to write.

Create tests using xUnit, the architecture at the heart of many programmer-oriented testing tools.

It pretty much kept the promises The only part I didn’t really like about this book was that I found much of the coding kind of messy. Could be because the languages used in the examples are Java and Python, which I don’t really like that much syntax-wise. An even more important reason though, is that I just finished reading The Art of Unit Testing So, I suppose I have become a bit demanding when it comes to cleanliness when coding and writing unit-tests. I suppose that is a good thing (I do however not claim in any way that the code I currently write is extremely clean in any way! But I do strive for it to be so )

I can really recommend this book to anyone who are curious to get familiar with TDD. I certainly see the value of doing TDD and is in the process of trying to incorporate it into my development habits.

Red — Write a little test that doesn’t work, and perhaps doesn’t even compile at first.

Green — Make the test work quicky, committing whatever sins necessary in the process.

Refactor — Eliminate all of the duplication created in merely getting the test to work.

Red/green/refactor — the TDD mantra.

You can get it at Amazon, and probably a lot of other places too as it is a pretty well-known book.