1. “qualifySkus” is confusing. Is it an array/list/collection of “qualifiedSKUs” or a flag that’s a result of “qualifyingSkus” or….
2. “qualifySKus” should be a constant with a nice comment, not an in-line String.
3. The method getSkusRespository seems like it would return a catalog repository, doesn’t it? Instead it takes in a List of String SkuIds, loads up the corresponding SKU RepositoryItems, removes any that have the property “isLive” set to false, and removes any that have a current inventory stock level of zero. It then returns an ArrayList of those filtered SKU RepositoryItems. Perhaps a better name might be “getLiveInStockSKUs”?
4. What on earth is “d”? Even looking at the full code of this class, it’s very difficult to tell what d is meant to contain. It’s actually a List of Strings of SkuIds that are qualifying skus for a given promo. “qualifiedSkus” would be a better name.
5. cItem is a commerce item. However it’s not actually used by the getSkusRepository method at all. There’s no reason to pass it in.
6. This line is in an ATG droplet and shoves the result of the getSkusRepository method into a request param before servicing an oparam. However, as you can see, it doesn’t inspect the output of the method. As I explained above, the method actually filters a list of SKUs based on isLive and current inventory state. It’s very possible that there will be no live and in-stock SKUs, and the param’s value will be null or an empty list. In that case, we’d actually want to render a different oparam, which is defined and called elsewhere, but not here. Validate your output!

That’s six issues in one line. Please don’t write code like this.

ATG Eclipse Templates

By making commonly used code blocks available with a couple of keystrokes it is much easier to write best practices code, that otherwise you might shortcut around.

You can view, import, and create new templates by going to Eclipse’s Preferences, then opening Java->Editor->Templates. Each Template has a Name, this is what triggers it for auto-complete so making this simple and unique is good, a Description, a Context, a checkbox to Automatically insert, and then the Pattern which is the code that will get inserted for you. Within the Pattern you have access to a substantial number of variables, such as the current class or method name, variables, method arguments, dates, etc… which allow you do some very useful things.

For ATG coding I’ve created nine Templates for common code blocks.

My templates isBlank and isNotBlank create if blocks based on ATG’s StringUtils.isBlank method, which checks for null, empty, or blank Strings. Checking Strings is something that I do all the time (validating user input, query params, etc…) so being able to do it in a few keystrokes is very useful.

ls.isBlank(${cursor})) {

}

I have three templates for ATG Performance Monitor operations. Adding in ATG Performance Monitor hooks when you’re coding can make diagnosing performance problems later much easier. Using templates means you don’t have to remember the syntax or even type in the class and method names:

PerformanceMonitor.startOperation("${enclosing_type}", "${enclosing_method}");

I also have four templates for the primary ATG logging methods with the respective if blocks needed to prevent unnecessary String concatenations.

if(isLoggingDebug()) {
	logDebug("${enclosing_type}.${enclosing_method}:" + "${cursor}");
}

I’ve exported these nine ATG templates so you can easily import and start to use them.
Eclipse ATG Coding Templates.

What templates have you created?

There was an example on how to integrate JForum and Crowd, which works pretty well. When you login to the forum, it checks Crowd and creates a local account if needed and logs you in.

However, we want single sign-on (SSO) so that our users don’t need to login to the forums separately. We also want group membership in Crowd to be reflected in JForum to allow us to manage permissions based on Crowd managed groups.

I’ve written a JForum SSO implementation that ties into Crowd that I’m going to share here. It’s version 1.1 (just added group sync), but it seems to work nicely.

Download the zip file here:
jforum-crowd-sso

unzip it into your jforum/WEB-INF/classes/ directory.

You have to install the crowd client jar, and the crowd.properties file.

You may also need to install the xfire jars if you get errors. I did.

Then you need to setup the sso configuration in the jforum/WEB-INF/config/SystemGlobals.properties

like this:

authentication.type=sso
sso.implementation = com.digitalsanctuary.jforum.CrowdSSO
sso.redirect = your crowd managed app login page
sso.crowd.syncGroups=false

That last flag should be set to true if you would like the user’s groups synced from Crowd to JForum at auth time. This takes a second, so I made it optional. It does not push JForum group membership info to Crowd, it just syncs Crowd data down, as Crowd should be your master directory for that type of data.

The source code is available here for now:

CrowdSSO.java

-EDIT-

Added a full downloadable module and installation instructions here:

http://confluence.atlassian.com/display/CROWDEXT/JForum+Single+Sign-On+Crowd+Connector

How To Resize Uploaded Images Using Java

I have upgraded the image resizing code. The results are noticeably better in quality, even at thumbnail sizes. I wanted to share the completed new code, in case anyone needs it.

Again, thanks to Matt S. for his pointers.

    /**
     * The JAI.create action name for handling a stream.
     */
    private static final String JAI_STREAM_ACTION = "stream";

    /**
     * The JAI.create action name for handling a resizing using a subsample averaging technique.
     */
    private static final String JAI_SUBSAMPLE_AVERAGE_ACTION = "SubsampleAverage";

    /**
     * The JAI.create encoding format name for JPEG.
     */
    private static final String JAI_ENCODE_FORMAT_JPEG = "JPEG";

    /**
     * The JAI.create action name for encoding image data.
     */
    private static final String JAI_ENCODE_ACTION = "encode";

    /**
     * The http content type/mime-type for JPEG images.
     */
    private static final String JPEG_CONTENT_TYPE = "image/jpeg";

    private int mMaxWidth = 800;

    private int mMaxWidthThumbnail = 150;

.....

    /**
     * This method takes in an image as a byte array (currently supports GIF, JPG, PNG and
     * possibly other formats) and
     * resizes it to have a width no greater than the pMaxWidth parameter in pixels.
     * It converts the image to a standard
     * quality JPG and returns the byte array of that JPG image.
     *
     * @param pImageData
     *                the image data.
     * @param pMaxWidth
     *                the max width in pixels, 0 means do not scale.
     * @return the resized JPG image.
     * @throws IOException
     *                 if the image could not be manipulated correctly.
     */
    public byte[] resizeImageAsJPG(byte[] pImageData, int pMaxWidth) throws IOException {
	InputStream imageInputStream = new ByteArrayInputStream(pImageData);
	// read in the original image from an input stream
	SeekableStream seekableImageStream = SeekableStream.wrapInputStream(imageInputStream, true);
	RenderedOp originalImage = JAI.create(JAI_STREAM_ACTION, seekableImageStream);
	((OpImage) originalImage.getRendering()).setTileCache(null);
	int origImageWidth = originalImage.getWidth();
	// now resize the image
	double scale = 1.0;
	if (pMaxWidth > 0 && origImageWidth > pMaxWidth) {
	    scale = (double) pMaxWidth / originalImage.getWidth();
	}
	ParameterBlock paramBlock = new ParameterBlock();
	paramBlock.addSource(originalImage); // The source image
	paramBlock.add(scale); // The xScale
	paramBlock.add(scale); // The yScale
	paramBlock.add(0.0); // The x translation
	paramBlock.add(0.0); // The y translation

	RenderingHints qualityHints = new RenderingHints(RenderingHints.KEY_RENDERING,
		RenderingHints.VALUE_RENDER_QUALITY);

	RenderedOp resizedImage = JAI.create(JAI_SUBSAMPLE_AVERAGE_ACTION, paramBlock, qualityHints);

	// lastly, write the newly-resized image to an output stream, in a specific encoding
	ByteArrayOutputStream encoderOutputStream = new ByteArrayOutputStream();
	JAI.create(JAI_ENCODE_ACTION, resizedImage, encoderOutputStream, JAI_ENCODE_FORMAT_JPEG, null);
	// Export to Byte Array
	byte[] resizedImageByteArray = encoderOutputStream.toByteArray();
	return resizedImageByteArray;
    }

———————–
I am building a Seam application which need to support users uploading images, and then the site displaying them. I wanted to resize big images into something reasonable (say 1024 or 800 px wide) and generate a thumbnail, and I also wanted to standardize on a single image format just to make things easy and consistent.

So I needed method that would take an uploaded image as a byte array (byte[]) and would resize the image (if needed) and convert it to a fixed quality JPG, and give me back a byte array to store in the database. I am using Seam, so I get a handy byte array, but this method should work fine for non-Seam applications as well.

    /**
     * This method takes in an image as a byte array (currently supports GIF, JPG, PNG and possibly other formats) and
     * resizes it to have a width no greater than the pMaxWidth parameter in pixels. It converts the image to a standard
     * quality JPG and returns the byte array of that JPG image.
     *
     * @param pImageData
     *                the image data.
     * @param pMaxWidth
     *                the max width in pixels, 0 means do not scale.
     * @return the resized JPG image.
     * @throws IOException
     *                 if the iamge could not be manipulated correctly.
     */
    public byte[] resizeImageAsJPG(byte[] pImageData, int pMaxWidth) throws IOException {
	// Create an ImageIcon from the image data
	ImageIcon imageIcon = new ImageIcon(pImageData);
	int width = imageIcon.getIconWidth();
	int height = imageIcon.getIconHeight();
	mLog.info("imageIcon width: #0  height: #1", width, height);
	// If the image is larger than the max width, we need to resize it
	if (pMaxWidth > 0 && width > pMaxWidth) {
	    // Determine the shrink ratio
	    double ratio = (double) pMaxWidth / imageIcon.getIconWidth();
	    mLog.info("resize ratio: #0", ratio);
	    height = (int) (imageIcon.getIconHeight() * ratio);
	    width = pMaxWidth;
	    mLog.info("imageIcon post scale width: #0  height: #1", width, height);
	}
	// Create a new empty image buffer to "draw" the resized image into
	BufferedImage bufferedResizedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
	// Create a Graphics object to do the "drawing"
	Graphics2D g2d = bufferedResizedImage.createGraphics();
	g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
	// Draw the resized image
	g2d.drawImage(imageIcon.getImage(), 0, 0, width, height, null);
	g2d.dispose();
	// Now our buffered image is ready
	// Encode it as a JPEG
	ByteArrayOutputStream encoderOutputStream = new ByteArrayOutputStream();
	JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(encoderOutputStream);
	encoder.encode(bufferedResizedImage);
	byte[] resizedImageByteArray = encoderOutputStream.toByteArray();
	return resizedImageByteArray;
    }

In my application I call this method twice, once to convert the uploaded image into a limited size JPG, and then once again to generate a much smaller thumbnail. I store both of these in the database and will use caching at the Apache layer to ensure performance.

public static final int NUM_CARDS_IN_DECK=52;

First, we define the variable as public, this is not necessary for using the constant within the same class, but is needed in order to access the same constant from multiple classes. I will go into this distinction in more detail later.

Secondly we mark it as static. This provides two related features. The variable can be referenced without instantiating a copy of it’s enclosing object. The variable will only exist ONCE in memory. This is very efficient. Also, during compilation the access will be in-lined into the class and therefore much faster.

Thirdly we mark it as final. This prevents the value from being changed or overridden, ensuring that that the value is consistent throughout your entire application, and letting the compiler know it does not have to worry about the value changing.

From there it looks like a normal variable except for the name. The convention is to name constants in all capitals with underscore characters separating logical words.

Where – local or global
Constants can be defined within one of your functional classes as private (or another restrictive modifier), and used only within that class, or they can be defined in a single purpose location holding all of your shared constants as public. For the nature of this container, see the next section.

The defining line governing where a given constant should live is based on it’s usage. Is it something that is specific to the one class, or is it something that multiple classes within your application should be utilizing? You can always refactor it later as well, so don’t get too hung up on this question.

How – interface versus class
For constants that need to accessed from multiple classes, there are two options on exposing the constants. First, by creating an Interface which will hold all of the constants for your application. Then, in any class you need access to a constant, you simply implement the interface. The advantage to this is that you do not need to prefix the constant name with a class or anything else. This has been a popular approach, and many of the initial examples of constants used this method. However, thankfully, it has finally been recognized as an anti-pattern. Using an interface for this purpose is really abusing the concept of an interface. An interface is meant to hold a type definition, not to piggie-back your constants around your application.

The second approach, creating a constants class which houses your constants and referring to them via the Class.CONSTANT notation in your code (or you can import the individual static constants if you like) is the best approach. It is easy to tell where the constants are defined, and you aren’t cluttering up your class definition.

Why – context through constants
People usually think to use a constant when a value may be used across many classes within their application. For instance an application limit such as the maximum number of threads to use, or the number of cards in a deck of playing cards, etc…
These are great places to use constants (assuming they shouldn’t be runtime configurable properties). In this case one of the main reasons constants are used are to provide a single point of definition. Allowing you to have consistency across the application and a single point to make changes.

What is often overlooked is the use of constants to provide context. The above usage does this as well, but is rarely a motivating factor for developers. I advocate using local constants in classes frequently in order to convey context to your code. Consider this code:

int tally = 0;
for(int i = 0; i < 60; i++) {
Random rand = new Random();
if(rand.nextInt(100) > 60) {
tally = tally + 5;
}
}

There are many numbers but no context. This can easily happen with Strings as well, see the section on ATG for an example. If you were new and had been asked to adjust the game logic to make the game this code is part of, easier or harder it would not be easy. Now, let’s add some context to the functionality by using local constants:

private static final int SECONDS_PER_TURN = 60;
private static final int PERCENT_CHANCE_OF_SLIPPING_PER_SECOND = 60;
private static final int FEET_SLIPPED = 5;
.....
int tally = 0;
for(int i = 0; i < SECONDS_PER_TURN; i++) {
Random rand = new Random();
if(rand.nextInt(100) > PERCENT_CHANCE_OF_SLIPPING_PER_SECOND) {
tally = tally + FEET_SLIPPED;
}
}

and it becomes clear that this piece of code calculates the number of feet slipped in a turn. It also makes it easy to adjust the percent chance of slipping, without getting confused by the multiple uses of “60” in the area. If you use constants to give your code more context you will thank yourself later, as will anyone else who deals with your code.

ATG – repositories
Repositories are ATG’s data access and object-relational mapping technology. In many ways the technology is similar to Hibernate with a few key differences. One of those differences is that instead of mapping to typed objects like Hibernate does, ATG Repositories use RepositoryItem to represent every data object. The values are accessed through a value dictionary. In the repository definition file you map out all the objects, their properties (and the tables and columns backing them), and the relationships between objects. Each object is given an item descriptor name which is used to identify that type of object. The properties of an object are also named. These names are used to query objects from the database and access, or update, the properties of the object.

Take a shoe management application (not that you need one): You have a Shoes object, representing a pair of shoes, which happens to have a few properties, including flags for shoes, boots, or sandals (not the best way to model it, but perhaps it is a legacy database). You also have a Wearer object, for the person currently wearing the shoes. This object has a shoe property. You have a Manufacturer who has a shoes Collection property. You also have an Owner who also has a shoes Collection property. You can see where this is going.

RepositoryItem shoes = Repository.getItem(myShoesId, “shoes”);
if((Boolean)shoes.getPropertyValue(“shoes”).booleanValue()) {
List manShoes = (List)manufacturerer.getPropertyValue(“shoes”);
manShoes.add(shoes);
manufacturer.setPropertyValue(“shoes”, shoes);
.........
}
And so on. You can see that it can get ugly very quickly. And of course you may want to change the names of properties as time goes on, and trying to work through all of your code to update it each time is bound to cause problems.
When using ATG Repositories, I highly recommend using a constants file to hold all of the item descriptor and property names.