The following shows the sample template for the RSS Feed cartridge:

{ 
   "ecr:type": "template",
   "@group": "SecondaryContent",
   "@description":"A cartridge that displays entries from an RSS feed.",
   "@thumbnailUrl":"/ifcr/tools/xmgr/img/template_thumbnails/sidebar_content.jpg",
   "defaultContentItem":{ 
      "@name":"RSS cartridge",
      "feedUrl": "",
      "numEntries": "5"
   },
   "editorPanel":{ 
      "editor":"editors/DefaultEditorPanel",
      "children":[ 
         {
            "editor": "GroupLabel",
            "label": "${group.contents.label}"
            },
         { 
            "editor":"editors/StringEditor",
            "label":"Feed URL",
            "propertyName":"feedUrl",
            "bootomLabel":"The address of the RSS feed, such as http://www.oracle.com/us/corporate/press/rss/rss-pr.xml"
         },
         { 
            "editor":"editors/NumericStepperEditor",
            "label":"Number of entries to display",
            "minValue":1,
            "maxValue":15,
            "propertyName":"numEntries"
         }
      ]
   },
    "typeInfo": {
        "feedUrl": {"@propertyType": "String"},
        "numEntries": {"@propertyType": "String"}
    }
}

The following shows the code for the sample RSS Feed cartridge handler:

package com.endeca.sample.cartridges;

import com.endeca.infront.assembler.AbstractCartridgeHandler;
import com.endeca.infront.assembler.CartridgeHandlerException;
import com.endeca.infront.assembler.ContentItem;
import com.endeca.infront.assembler.BasicContentItem;
import java.net.URL;
import java.util.ArrayList;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.CharacterData;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;

public class RssFeedHandler extends AbstractCartridgeHandler {

	public ContentItem process(ContentItem pContentItem)
			throws CartridgeHandlerException {
		
		final String urlString = (String) pContentItem.get("feedUrl");
		final int numEntries = 
    Integer.parseInt((String)pContentItem.get("numEntries"));
		
		try {
			URL url = new URL(urlString);
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			DocumentBuilder docBuilder = factory.newDocumentBuilder();
			Document RssContents = docBuilder.parse(url.openStream());
			
			// get the channel info
			Element channel = 
    (Element)RssContents.getElementsByTagName("channel").item(0);
			pContentItem.put("chanTitle", getElementValue(channel, "title"));
			pContentItem.put("chanUrl", getElementValue(channel, "link"));
			
			// get the entries and add them to a list
			ArrayList<ContentItem> entries = new ArrayList<ContentItem>(numEntries);
			NodeList nodes = RssContents.getElementsByTagName("item");
			for(int i=0; i<numEntries; i++) {
				Element element = (Element)nodes.item(i);
				if (element!=null) {
					ContentItem entry = new BasicContentItem("rssEntry");
					entry.put("itemTitle", getElementValue(element, "title"));
					entry.put("itemUrl", getElementValue(element, "link"));
					entry.put("itemDesc", getElementValue(element, "description"));
					entries.add(entry);
				}
			}
			pContentItem.put("entries", entries);
		}
		catch (Exception e) {
			throw new CartridgeHandlerException(e);
		}
		
		return pContentItem;
	}
	
	private static String getCharacterDataFromElement(Element e) {
		try {
			Node child = e.getFirstChild();
			if(child instanceof CharacterData) {
				CharacterData cd = (CharacterData) child;
				return cd.getData();
			}
		}
		catch(Exception ex) {
		}
		return "";
	}
	
	private static String getElementValue(Element parent, String label) {
		return getCharacterDataFromElement(
    (Element)parent.getElementsByTagName(label).item(0));
	}

}

The following shows the code for the sample RSS Feed renderer in JSP:

<%@page language="java" pageEncoding="UTF-8"
contentType="text/html;charset=UTF-8"%>

<%@include file="/WEB-INF/views/include.jsp"%>

<div style="padding:2ex 0">
<b><a href="${component.chanUrl}">${component.chanTitle}</a></b>
<c:forEach var="rssEntry" items="${component.entries}">
    <p><a href="${rssEntry.itemUrl}">${rssEntry.itemTitle}</a><br/>
    ${rssEntry.itemDesc}</p>
</c:forEach>
</div>

The following shows the code for the availability service and its supporting classes:

package com.endeca.sample.cartridges;

public enum Availability {
    IMMEDIATE,
    WEEK,
    DROP_SHIP,
    BACKORDER;

}

package com.endeca.sample.cartridges;

public interface AvailabilityService {

    Availability getAvailabilityFor(String identifier);
}

package com.endeca.sample.cartridges;

public class FixedAvailabilityService implements AvailabilityService {

    public Availability getAvailabilityFor(String identifier) {
        try {
            return Availability.valueOf(identifier);
        } catch (IllegalArgumentException e) {
            return Availability.BACKORDER;
        }
    }
}

The following shows the code for the custom cartridge handler:

package com.endeca.sample.cartridges;

import com.endeca.infront.assembler.CartridgeHandlerException;
import com.endeca.infront.cartridge.RecordDetails;
import com.endeca.infront.cartridge.RecordDetailsConfig;
import com.endeca.infront.cartridge.RecordDetailsHandler;
import com.endeca.infront.cartridge.model.Attribute;
import org.springframework.beans.factory.annotation.Required;

public class AvailabilityRecordDetailsHandler extends RecordDetailsHandler {

    private AvailabilityService availabilityService;
    private String recordSpec;
    private String availabilityPropertyName;

    @Required
    public void setAvailabilityService(
      AvailabilityService availabilityService_) {
        availabilityService = availabilityService_;
    }

    @Required
    public void setRecordSpec(String recordSpec_) {
        recordSpec = recordSpec_;
    }

    @Required
    public void setAvailabilityPropertyName(
      String availabilityPropertyName_) {
        availabilityPropertyName = availabilityPropertyName_;
    }

    @Override
    public RecordDetails process(RecordDetailsConfig detailsConfig) 
      throws CartridgeHandlerException {
        RecordDetails details = super.process(detailsConfig);
        if (null == details) return null;
        Attribute attr = 
          details.getRecord().getAttributes().get(recordSpec);
        if (null == attr || 1 != attr.size()) {
            throw new CartridgeHandlerException("No record spec 
              available on record, or spec is multiassign");
        }
        Attribute<Availability> availability = 
          new Attribute<Availability>();
        availability.add(
          availabilityService.getAvailabilityFor(attr.toString()));
        details.getRecord().getAttributes().put(availabilityPropertyName,
          availability);
        return details;
    }

}

The following shows the code for the recommendations service interface and concrete implementation:

package com.endeca.sample.cartridges;

import java.util.List;

public interface RecommendationService {
    public List<String> getRecommendedProductIds();
}

package com.endeca.sample.cartridges;

import java.util.Arrays;
import java.util.List;

public class TestRecommendationService 
  implements RecommendationService {
    public static final List<String> IDS = 
      Arrays.asList("5891932", "6001963", "1438066", "1581692", 
        "2708142", "1235424", "3422480");

    public List<String> getRecommendedProductIds() {
        return IDS;
    }

}

The following shows the code for the custom cartridge handler:

package com.endeca.sample.cartridges;

import java.util.ArrayList;
import java.util.List;

import com.endeca.infront.assembler.CartridgeHandlerException;
import com.endeca.infront.cartridge.ResultsListConfig;
import com.endeca.infront.cartridge.ResultsListHandler;
import com.endeca.infront.navigation.model.CollectionFilter;
import com.endeca.infront.navigation.model.PropertyFilter;

public class RecommendationsResultsListHandler extends ResultsListHandler {
    private RecommendationService recommendationService;
    private String recordSpec;
    
    public String getRecordSpec() {
        return recordSpec;
    }

    public void setRecordSpec(String recordSpec_) {
        this.recordSpec = recordSpec_;
    }

    public void setRecommendationService(
      RecommendationService recommendationService_) {
        recommendationService = recommendationService_;
    }

    /**
     * This cartridge will get the list of recommended products
     * (by record spec) and explicitly boost each one of them using 
     * a PropertyFilter.
     */
    @Override
    public void preprocess(ResultsListConfig pContentItem)
      throws CartridgeHandlerException {
        List<String> ids =
          recommendationService.getRecommendedProductIds();
        List<CollectionFilter> boostFilters =
          new ArrayList<CollectionFilter>(
                ids.size());
        for (String s : ids) {
            boostFilters.add(new CollectionFilter(new PropertyFilter(
                    recordSpec, s)));
        }

        pContentItem.setBoostStrata(boostFilters);
        super.preprocess(pContentItem);
    }

}

The following shows the code for the sample "Hello, World" cartridge handler with color configuration:

package com.endeca.sample.cartridges;

import com.endeca.infront.assembler.AbstractCartridgeHandler;
import com.endeca.infront.assembler.CartridgeHandlerException;
import com.endeca.infront.assembler.ContentItem;
import com.endeca.infront.assembler.BasicContentItem;
import com.endeca.infront.assembler.ContentItemInitializer;
import com.endeca.sample.cartridges.ColorConfig;
import java.util.ArrayList;
import java.util.Map;

public class ColorConfigHandler extends AbstractCartridgeHandler {
    
	private ContentItemInitializer mInitializer;
	private Map<String, String> mColorOptions;

  public void setContentItemInitializer(ContentItemInitializer initializer) {
    mInitializer = initializer;
  }
  
  public void setColorOptions(Map<String, String> colorOptions) {
  	 mColorOptions = colorOptions;
  }

  /**
   * Returns the merged configuration based on Spring defaults,
   * Experience Manager configuration, and request parameters
   */
  @Override 
  public ContentItem initialize(ContentItem pContentItem) {
    // If any configuration from Experience Manager is empty, remove 
    // that property so we can use the default value
    for (String key: pContentItem.keySet()) {
      if (((String)pContentItem.get(key)).isEmpty())
        pContentItem.remove(key);
    }
      return mInitializer == null ? new ColorConfig(pContentItem) :
        mInitializer.initialize(pContentItem);
    }

  /**
   * Returns the merged configuration and information about the color options
   * available to the site visitor.
   */
  @Override
  public ContentItem process(ContentItem pContentItem)
    throws CartridgeHandlerException {
    int numColors = mColorOptions.size();
    ArrayList<ContentItem> colors = 
      new ArrayList<ContentItem>(numColors);		
    if (mColorOptions != null && !mColorOptions.isEmpty()) {
      for (String key: mColorOptions.keySet()) {
        ContentItem color = new BasicContentItem("colorOption");
        color.put("label", key);
        color.put("hexCode", mColorOptions.get(key));
        colors.add(color);
      }
      pContentItem.put("colorOptions", colors);
    }
    return pContentItem;
  }
}

The following code implements a basic bean that enables us to specify a default value for the message color in the Spring configuration:

package com.endeca.sample.cartridges;

import com.endeca.infront.assembler.BasicContentItem;
import com.endeca.infront.assembler.ContentItem;

public class ColorConfig extends BasicContentItem {
    
	 public ColorConfig() {
		  super();
	 }
	
	 public ColorConfig(final String pType) {
		  super(pType);
	 }
	
 	public ColorConfig(ContentItem pContentItem) {
    super(pContentItem);
  }
    
  public String getMessageColor() {
    return getTypedProperty("messageColor");
  }
  
  public void setMessageColor(String color) {
    this.put("messageColor", color);
  }
}

The following shows the code for the sample "Hello, World" renderer with color choice drop-down in JSP:

<%@page language="java" pageEncoding="UTF-8"
contentType="text/html;charset=UTF-8"%>

<%@include file="/WEB-INF/views/include.jsp"%>
<div style="border-style: dotted; border-width: 1px;
border-color: #999999; padding: 10px 10px">
  <div style="font-size: 150%; 
    color: ${component.messageColor}">${component.message}
  </div>
  <div style="font-size: 80%; padding: 5px 0px">
    <select onchange="location = this.options[this.selectedIndex].value">
      <option value="">Select a color</option>
      <c:forEach var="colorOption" items="${component.colorOptions}">
        <c:url value="<%= request.getPathInfo() %>" var="colorAction">
          <c:param name="color" value="${colorOption.hexCode}" />
        </c:url>
        <option value="${colorAction}">${colorOption.label}</option>
      </c:forEach>
    </select>
  </div>
</div>