blueleftistconstructor

Grails, Validation of Map on Domain Class

Grails has a bunch of can’d validators such as maxSize, blank, nullable and so forth. These are hard workers, they’ll check values, report errors which can easily be internationalized, and can even influence auto-schema generation (a feature I advise you ignore).

If you are reading this maybe you googled something like “grails map validation” which means that you want to know how you can properly check a map of something inside of a domain class. Well this post may or may not help you. What I was doing today was working on a way to allow arbitrary key values (only strings) to be set on my domain class. I figured I would allow 255 characters for key and value.

This ends up not being all to difficult but does require that you know how the underlying Spring Framework mechanisms work.

First off is the Errors interface which in Grails uses the concrete implementation BeanPropertyBindingResult.

When using a custom validator you can pass a code block, or closure, that take 3 parameters. In order they are the value being validated, the object that value is part of, and the Errors implementation being used for the object to handle validation and error messaging. When, in your validator code, you find an error you will want to tell the Errors object. There are a number of methods in the Errors interface which allow this. Look at the various flavors of reject and rejectValue which are found. It’s important to really understand how these work because you’ll rely on getting things right here to be able to use property files to externalize and i18n your error messages.

What I ended up doing in this closure was iterating the key/value pairs, and checking if the lengths of the keys and values. If any key or value was more than 255 characters I added an error for that field on that object to the Errors object by calling rejectValue. This worked out perfect and the validator works just like the ones baked into Grails. I can put a version of my message in any language and it will be properly built and reported at the proper layer of my application.

Here is the code for my validator:

attributes(validator: { attributes, obj, errs ->
	attributes.each { k, v ->
		if (k.size() > 255) {
			errs.rejectValue("attributes", "key.toobig", [k] as Object[], "Key size too big, max is 255" as String)
		}
		if (v.size() > 255) {
			errs.rejectValue("attributes", "value.toobig", [k] as Object[], "Value for key ${k} too big, max is 255" as String)
		}
	}
})

Notice that the ‘as Object[]‘ and ‘as String’ are there to make sure the types are cast to the proper ones which the methods of the Errors interface require. Remember Groovy gotcha #1739, if you use interpolation in a literal string you will get a GString (yes really that is what they called it) and not a String type back, and any method that requires String will be unhappy if you pass it a GString (yeah imagine that).