I was recently debugging an issue with the Magento compiler that only seemed to occur when our Full Page Cache was enabled.  Drove me nuts for a good part of the day!  Basically when ever accessing the cart or one page checkout you would get a blank screen, just a white blank screen.

So when starting to look into this I did what I normally do and checked out the errors logs.  But what did I find … absolutely nothing!  Nothing in Magento’s, PHP-FPM‘s, or Nginx‘s log files. I even checked the syslog just in case.  I went back and checked all my log settings.   Everything was fine but the blank screen persisted without generating any errors in the logs.  So I decided to turn on PHP’s display_errors setting as there obviously had to be an error of some sort causing this.  And it doesn’t get any easier than just displaying errors in the browser, right?  Nope still nothing, just a white blank screen…

So where to go from here?  I decided to checkout xdebug’s documentation in case there was something there to force a stack trace or something. I first found this and decided to give it a try:

xdebug.show_exception_trace

Type: integer, Default value: 0

When this setting is set to 1, Xdebug will show a stack trace whenever an exception is raised – even if this exception is actually caught.

I figured that should show something so I enabled it… but still nothing!  So went back searching through the documentation tried a few other things and then finally found this:

xdebug.scream

Type: boolean, Default value: 0, Introduced in Xdebug 2.1

If this setting is 1, then Xdebug will disable the @ (shut-up) operator so that notices, warnings and errors are no longer hidden.

And then finally something!

So as it turns out Xdebug’s scream setting can be really useful when you are at your wits end trying to find some error message that is hidden for what ever reason.  I found this to be an odd error at first but at least it’s something to work with.

What ended up causing the error in the first place and why was that exception displayed?  Well long story short Varien_Autoloader::registerScope was hiding all error messages on an include_once AWESOME!

    static public function registerScope($code)
    {
        self::$_scope = $code;
        if (defined('COMPILER_INCLUDE_PATH')) {
            @include_once self::SCOPE_FILE_PREFIX.$code.'.php';
        }
    }

But why the redeclare?  It’s kind of an odd exception to get.  Well, we were hooking into Magento’s controller_action_predispatch event, loading some classes, and doing a few checks.  However controller_action_predispatch occurs before Magento registers the current scope which in this case was “checkout”.  The Magento compiler uses this scope concept to combine known required classes into a single file to cut down on the number of include_once that are needed.  Less file access is needed so it should make IO on the disk a little lighter.

Since Mage_Directory_Model_Currency is defined in Mage_Directory_Model_Currency.php and __checkout.php and we needed the class before the auto loader registered the scope we ended up with a redeclared class.   So that was my fun with debugging the Magento compiler.

After adding a custom Comparator to sort one of my domain models, I started getting the following exception sporadically:

groovy.lang.MissingPropertyException: No such property: name for class:
java.lang.Object

The odd thing is that the model I was attempting to sort was one of my domain models of type Transaction; however, grails was interpreting it as a generic Object. The really weird thing is that it was also interpreting my Transaction objects as generic Objects in other locations as well. After a while of debugging, I went back to the code where I started seeing the issue. I had created a private inner class for the Comparator and defined it as follows:


private class TransactionComparator<Transaction> extends Comparator<Transaction>

...


My mistake was including the generic declaration at the class level. This would be invalid in normal Java syntax; however, groovy was compiling another class named Transaction, but it was casting it to a generic Object. Once I fixed my class to the following, the issue went away:


private class TransactionComparator extends Comparator<Transaction>

...


I hope this helps others that run into similar issues.

I’m writing this mostly for my own reference, but I thought it would be helpful to others as well. I’ve been working a lot lately with integrating CXF into grails via the CXF-grails plugin; however, while enabling MTOM to allow SOAP attachments, I ran into a few issues that I had to work around. The following are the steps I took to successfully allow uploading files via my web service:

1. Enable MTOM on the service


@MTOM(enabled = true)
@javax.jws.WebService(
serviceName = "MyWebService",
portName = "MyWebService",
targetNamespace = "http://test.brimllc.com",
endpointInterface = "com.brimllc.ws.MyWebServiceInterface")
class MyWebService ...


2. Add the MIME type to the DataHandler request object.

This step allows the binding of the incoming attachment to the bean field.


// ... some request bean
@XmlMimeType("application/octet-stream")
private DataHandler fileData;


3. Exclude the ‘/services’ path from UrlMappings.groovy.

Without this step, the default grails URL interceptor will process the request as a file upload, which in turn will read the InputStream, causing the CXF interceptor to have an empty stream.


static excludes = ['/services*']


4. Remove mail.jar & activation.jar from the classpath in BuildConfig.groovy

My project is using the mail plugin, which manually copies over these jars from it’s /lib folder. One of the CXF interceptors will throw an error since the classes contained within these jars has already been loaded by the servlet containers classpath.


grails.war.resources = { stagingDir, args ->
println "Removing mail.jar and activation.jar from WEB-INF/lib/"
delete(file: "${stagingDir}/WEB-INF/lib/mail.jar")
delete(file: "${stagingDir}/WEB-INF/lib/activation.jar")
}


Now, your grails-cxf web service should be able to properly process an incoming MTOM SOAP message. One thing to note is that you may need to extend and modify the LoggingInInterceptor since it doesn’t know how to properly log the incoming messages with multiple boundaries. I can provide examples of this as well if anyone is interested. I’ve tested my service using SoapUI as a SOAP client. SoapUI allows you to specify MTOM settings on your test requests as well as adding attachments.

I’ve done a lot more work with Grails-CXF integration, so if there are other topics that anyone is interested in, email me and let me know. (devs@brimllc.com)

While setting up Test Driven Development environment with Apache CXF, I came across a small issue with creating a JUnit client, which will add the Basic Authentication info in the Http Request Header before sending the request. I found couple of ways to do this using JAXWS, but wanted to stick with Apache CXF.
On the Server side, I was using Spring Security which was not so tricky to configure. To add the header info, I needed to create an “Interceptor”, which will intercept the message before it is “marshalled”. Here is the code -

 
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.codec.binary.Base64;
import org.apache.cxf.interceptor.AbstractOutDatabindingInterceptor;
import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.message.Message;
import org.apache.cxf.phase.Phase;
import org.springframework.beans.factory.annotation.Required;
 public class BasicAuthenticationHeaderGeneratorInterceptor extends
		AbstractOutDatabindingInterceptor {
	public static final String COLON = ":";
	public static final String SPACE = " ";
	public static final String BASIC = "Basic";
	/** Map of allowed users to this system with their corresponding passwords. */
	private Map users;

	@Required
	public void setUsers(Map users) {
		this.users = users;
	}

	public BasicAuthenticationHeaderGeneratorInterceptor() {
		super(Phase.MARSHAL);
	}

	public BasicAuthenticationHeaderGeneratorInterceptor(String phase) {
		super(phase);
	}

	public void handleMessage(Message outMessage) throws Fault {
		Map<String, List> headers = (Map<String, List>) outMessage
				.get(Message.PROTOCOL_HEADERS);
		try {
			headers.put("Authorization", Collections.singletonList(BASIC
					+ SPACE + getBase64EncodedCredentials().trim()));
		} catch (Exception ce) {
			throw new Fault(ce);
		}
	}

	private String getBase64EncodedCredentials(){
		String userName = null;
		String password = null;
		Iterator iterator = null != users ? users.keySet().iterator()
				: null;
		if (null != iterator && iterator.hasNext()) {
			userName = iterator.next();
			password = users.get(userName);
		}
		String clearCredentials = userName + COLON + password;
		return new String(Base64.encodeBase64(clearCredentials.getBytes()));
	}
}

Here is the interceptor configuration in application-context.xml -

 
  <cxf:bus>
		<cxf:outInterceptors>
			<ref bean="basicAuthenticationHeaderGenerator" />
		</cxf:outInterceptors>
  </cxf:bus>

  <bean id="basicAuthenticationHeaderGenerator"
	class="com.blah.interceptor.BasicAuthenticationHeaderGeneratorInterceptor">
		<property name="users">
			<map>
				<entry key="abc" value="dev" />
			</map>
		</property>
	</bean>

I preferred this implementation over JAXWS, since it works great with Spring Test and Apache CXF, without having to use JAXWS API.

I wrote this article in JBoss Community. Here is another version of the same article. It is useful, when porting existing application from Ajax4JSF to use RichFaces.

In RichFaces3.2.2SR1, a4j:jsFunction generates an HTML script, which breaks in IE6/7, but works in FireFox. The issue is the way the jsFunction is rendered.

Here is a sample of how the script is rendered in Ajax4JSF and in RichFaces when html:form’s prependId attribute is false.

Notice that the name and id fields are kept same.

In Ajax4JSF, this will render as -

script id="func1" type="text/javascript"
function func1(){.........};
/script

In RichFaces, this renders as -

script id="func1" type="text/javascript">
func1 = function(){.........};
/script

Having the “id” of script tag and the func1 prototype “name” as same creates the problem. IE6/7 while parsing the script tag gives an error – “Object does not supports this property”.

In RichFaces the renderer for jsFunction is AjaxFunctionRendererBase. This renderer’s getFunction() method has changed from Ajax4JSF and generates this inappropriate javascript code.

A simple fix would be to set html:form’s prependId=”true”, which will append the form’s name to the “id” attribute, and the name and id will be different. There is a catch, in an existing application, then u will have to change all the javascript which uses the “id” to find the element.

The real fix would be to change the AjaxFunctionRenderer of RichFaces. Actually, its more like a workaround. If you are creating a new application from scratch, and using RichFaces, i will still use the RichFaces version.
Here is how to do it -
Create a new class extending the FunctionRenderer in RichFaces, and over-ride the getFunction method -

public class NewAjaxFunctionRenderer extends FunctionRenderer{
 /*
 * (non-Javadoc)
 *
 * @see org.ajax4jsf.framework.renderer.RendererBase#getComponentClass()
 */

 public static final String RENDERER_TYPE = "org.abc.AjaxFunctionRenderer";
 protected Class getComponentClass() {
 return HtmlAjaxFunction.class;
 }

 public String getFunction(FacesContext context, UIAjaxFunction component) {
 StringBuffer script = new StringBuffer();
 JSFunctionDefinition func = new JSFunctionDefinition();
 func.setName(component.getName());
 // Create AJAX Submit function.
 JSFunction ajaxFunction = AjaxRendererUtils.buildAjaxFunction(
 component, context,AjaxRendererUtils.AJAX_FUNCTION_NAME);
 Map options = AjaxRendererUtils.buildEventOptions(context, component);
 Map parameters = (Map) options.get("parameters");
 if (null == parameters) {
 parameters = new HashMap();
 options.put("parameters", parameters);
 }
 ajaxFunction.addParameter(JSReference.NULL);
 ajaxFunction.addParameter(options);
 // Fill parameters.
 for (Iterator it = component.getChildren().iterator(); it.hasNext();) {
 UIComponent child = (UIComponent) it.next();
 if (child instanceof UIParameter) {
 UIParameter parameter = ((UIParameter) child);
 String name = parameter.getName();
 func.addParameter(name);
 // Put parameter name to AJAX.Submit parameter, with default value.
 JSReference reference = new JSReference(name);
 if (null != parameter.getValue()) {
 reference = new JSReference(name + "||"
 + ScriptUtils.toScript(parameters.get(name)));

 }
 // Replace parameter value to reference.
 parameters.put(name, reference);
 }
 }
 func.addToBody(ajaxFunction.toScript());
 func.appendScript(script);
 return script.toString();
 }
}

In faces-config.xml add the new renderer for a4j:jsFunction –

 <renderer>
 <component-family>org.ajax4jsf.components.AjaxFunction</component-family>
 <renderer-type>
 org.ajax4jsf.components.AjaxFunctionRenderer
 </renderer-type>
 <renderer-class>
 org.test.NewAjaxFunctionRenderer
 </renderer-class>
 </renderer>

The tricky part is to find the component-family and renderer-type for AjaxFunctionRenderer. You can explode the richfaces jar and search the faces-config.xml to look for component-family and renderer-type for AjaxFunctionRenderer. Once you have it, this can be easily over-ridden in your application’s faces-config.xml as listed above.

For some reason, I always tend to run into this problem and I forgot the solution I previously implemented. Sometimes, you Magento site will have custom product attributes that you’d like to be viewable from the cart/checkout areas. For performance reasons, the product available to the order/quote doesn’t contain all of the attributes.

Instead of querying the product new to retrieve the attributes, you can instead define what attributes you’d like to be loaded during the cart/checkout process within the a config.xml file. The structure will be as follows:

<sales>
<quote>
<item>
<product_attributes>

<your_attribute_1/>
<your_attribute_2/>

</product_attributes>
</item>
<quote>
<sales>

Maybe this will save some others time as well…

If you search the net for how to add new custom attributes to categories, you’ll find many sites that define the steps in manual SQL inserts. The issue I found was that most of these sites are specific to Magento versions previous to 1.4/Enterprise 1.9 and leave out a crucial step. Also, I find it to be bad practice to manually insert rows into your Magento database because it makes it hard to deploy across environments.

The general approach to create custom category attributes is the following 3 SQL inserts:

INSERT INTO `eav_attribute` (
				`attribute_id` ,
				`entity_type_id` ,
				`attribute_code` ,
				`attribute_model` ,
				`backend_model` ,
				`backend_type` ,
				`backend_table` ,
				`frontend_model` ,
				`frontend_input` ,
				`frontend_label` ,
				`frontend_class` ,
				`source_model` ,
				`is_required` ,
				`is_user_defined` ,
				`default_value` ,
				`is_unique` ,
				`note`
	)
	VALUES (
			NULL ,  '3',  'header_image', NULL ,  'catalog/category_attribute_backend_image',  'varchar', NULL , NULL ,  'image',  'Header Image', NULL , NULL ,  '0',  '0', NULL ,  '0',  ''
	);

	SET @attribute_id = LAST_INSERT_ID();

	INSERT INTO `eav_entity_attribute` (
				`entity_attribute_id` ,
				`entity_type_id` ,
				`attribute_set_id` ,
				`attribute_group_id` ,
				`attribute_id` ,
				`sort_order`
	)
	VALUES (
		NULL ,  '3',  '3',  '3',  @attribute_id,  '30'
	);

	INSERT INTO `catalog_eav_attribute` (
				`attribute_id` ,
				`frontend_input_renderer` ,
				`is_global` ,
				`is_visible` ,
				`is_searchable` ,
				`is_filterable` ,
				`is_comparable` ,
				`is_visible_on_front` ,
				`is_html_allowed_on_front` ,
				`is_used_for_price_rules` ,
				`is_filterable_in_search` ,
				`used_in_product_listing` ,
				`used_for_sort_by` ,
				`is_configurable` ,
				`apply_to` ,
				`is_visible_in_advanced_search` ,
				`position` ,
				`is_wysiwyg_enabled`
	)
	VALUES (
		@attribute_id, NULL ,  '1',  '1',  '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0',  '1',  '',  '0',  '',  '0'
	);

The above code is specific to one of my Magento installs, which in this case I’m creating a custom image attribute. You can create any sort of attribute by identifying a similar attribute and copying most of the columns.

Now, this alone will give you your custom attribute, and if you only have one environment, this may be sufficient. Most projects, however, have development, test, and production environments, and if you manually insert SQL, it can be hard to ensure data consistency.

For this reason, its good practice to create a custom module where you can create a sql setup script that will automatically run and insert your desired columns. For my project, I created a module called Brim_Catalog with the following folder hierarchy:

-app
– code
– local
– Brim
– Catalog
– etc (create a config.xml file here)
– sql
– brim_catalog_setup (create a mysql-install-0.1.0.php here)

Now, in your config.xml, create the following resource declaration:

<resources>
            <brim_catalog_setup>
                <setup>
                    <module>Brim_Catalog</module>
                </setup>
                <connection>
                    <use>core_setup</use>
                </connection>
            </brim_catalog_setup>
        </resources>

Finally, you can define your SQL in the mysql-install-0.1.0.php file as such:

startSetup();

// create a new category attribute 'header_image' to display as the header on category landing pages
$installer->run("
	INSERT INTO `eav_attribute` (
				`attribute_id` ,
				`entity_type_id` ,
				`attribute_code` ,
				`attribute_model` ,
				`backend_model` ,
				`backend_type` ,
				`backend_table` ,
				`frontend_model` ,
				`frontend_input` ,
				`frontend_label` ,
				`frontend_class` ,
				`source_model` ,
				`is_required` ,
				`is_user_defined` ,
				`default_value` ,
				`is_unique` ,
				`note`
	)
	VALUES (
			NULL ,  '3',  'header_image', NULL ,  'catalog/category_attribute_backend_image',  'varchar', NULL , NULL ,  'image',  'Header Image', NULL , NULL ,  '0',  '0', NULL ,  '0',  ''
	);

	SET @attribute_id = LAST_INSERT_ID();

	INSERT INTO `eav_entity_attribute` (
				`entity_attribute_id` ,
				`entity_type_id` ,
				`attribute_set_id` ,
				`attribute_group_id` ,
				`attribute_id` ,
				`sort_order`
	)
	VALUES (
		NULL ,  '3',  '3',  '3',  @attribute_id,  '30'
	);

	INSERT INTO `catalog_eav_attribute` (
				`attribute_id` ,
				`frontend_input_renderer` ,
				`is_global` ,
				`is_visible` ,
				`is_searchable` ,
				`is_filterable` ,
				`is_comparable` ,
				`is_visible_on_front` ,
				`is_html_allowed_on_front` ,
				`is_used_for_price_rules` ,
				`is_filterable_in_search` ,
				`used_in_product_listing` ,
				`used_for_sort_by` ,
				`is_configurable` ,
				`apply_to` ,
				`is_visible_in_advanced_search` ,
				`position` ,
				`is_wysiwyg_enabled`
	)
	VALUES (
		@attribute_id, NULL ,  '1',  '1',  '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0',  '1',  '',  '0',  '',  '0'
	);
");

$installer->endSetup();

That’s all there is to it. Now, every environment that you deploy your code to will be guaranteed to have the same custom category attributes.

If you have every done this:


$_product = Mage::getModel('catalog/product')->load(__PRODUCT_ID__);
$manufacturer = $_product->getManufacturer();


You’ll know that you get the manufacturer’s id instead of it’s name. Which may or may not be what you would have expected. But the product model provides a nice helper method for getting an attributes value, in case it was not what you were expecting. Below is the code to get a product’s manufacturer name instead of it’s ID.


$_product = Mage::getModel('catalog/product')->load(__PRODUCT_ID__);
$manufacturer = $_product->getAttributeText('manufacturer');


This may be common knowledge for many, but since I go back and forth between jQuery and Prototype, I find myself always researching how each Javascript frameworks handle context switching. A frequent problem I run into is having a custom Javascript object who has a function that contains a function closure that tries to call the object itself (that’s a lot to take in). Lets look at an example …

Suppose we have the following jQuery Javascript class:

var SomeObj= function() {
	this.init();
}
$.extend(SomeObj.prototype, {
        init: function(){
             $('button').click(function(index){
                  // I'd like to call this.someMethod();
             });
        },
        someMethod: function(){
            alert('Hello World!');
        }
});

In the code above, I can’t just call ‘this.someMethod()’ within the function closure due to the context at which it will be executed. At the time the code is run, ‘this’ will be set to the button who fires the event. If we want to call a method or field on the custom javascript object, we have to cache its instance within a local variable. If we modify the code as below, it will now work:

var SomeObj= function() {
	this.init();
}
$.extend(SomeObj.prototype, {
        init: function(){
             var self = this;
             $('button').click(function(index){
                  self.someMethod();
             });
        },
        someMethod: function(){
            alert('Hello World!');
        }
});

Now, lets not get all bothered over semantics. I know that the above example is not a real-world example of anything useful; however, the approach I’ve taken may prove helpful for someone in a different scenario.

I’ve been playing around with Google Chart integration into a new Grails application, and while teaching myself the chart data formats, I converted the javascript data encoding script to Groovy. This hasn’t been tested thoroughly, but its been working nicely for me in my project.


/**
* See http://code.google.com/apis/chart/docs/data_formats.html#extended
*/
class GoogleChartUtil {

return chartData;
}
}