1. SQL Repository: uses the Generic SQL Adapter(GSA) to perform a mapping between ATG and data stored in a SQL database.

2.Versioned Repository: is an extension of SQL repository used in ATG Content Administration. It has versions for every set of data.For example a price for a product is edited, new entry will be made with a new version number instead of editing the price.

The SQL repository is implemented through the atg.adapter.gsa package. The main ATG component in the SQL repository is an instance of the atg.adapter.gsa.GSARepository class, which implements the interfaces atg.repository.MutableRepository and atg.repository.content.ContentRepository and which extends the class atg.repository.RepositoryImpl.

Lets keep aside the hardcore theory for now and move to more practical aspects of repositories.

A repository is a collection of repository items. In general, a repository item corresponds to the smallest uniquely identifiable entity in the underlying data store. Each repository item is made of properties and these properties store the data and thus makes a repository item. These properties of a repository item are defined inside the repository’s ITEM DESCRIPTORs. Properties of repository items may be single-valued or multi-valued.

Its still confusing…??? be patient,towards the end there is a something informative which will help you enhance your understanding.

What is an Item Descriptor?
Lets keep it simple with the help of an SQL Repository, for example, each database table have its own repository item descriptor. Sometimes a JOIN of multiple tables into a single item descriptor.

Points to Note:
ATG repositories support Java collections and hence we can store a List, Map or  Arrays.
ATG repositories allow one-one, one – many and many- many relationships.

Here is what i have promised: how to setup a repository..??

We have a database table (eg:  tb_tango).
Now create a property file which specifies the repository mapping xml file, class file, data Source etc. Lets name it as “dummyPropFile.properties“. The mapping xml(repositoryMapping.xml) file specifies the repository item desciptors. And the final step is registering the repository with dynamo(I have explained it in another post(question-5)).

Table name and details

create table tb_tango{
id Varchar2(30),
prof varchar2(255),
fname varchar2(50)
}

“dummyPropFile.properties”

$class=atg.adapter.gsa.GSARepository
definitionFiles=Folder Structure/repositoryMapping.xml
XMLToolsFactory=/atg/dynamo/service/xml/XMLToolsFactory
transactionManager=/atg/dynamo/transaction/TransactionManager
idGenerator=/atg/dynamo/service/IdGenerator
dataSource=/atg/dynamo/service/jdbc/dataSourceFile

* The “dataSourceFile”  is yet another property file where the JDBC connections and database driver,server name, user, password etc are specified.

“repositoryMapping.xml”

<!DOCTYPE gsa-template PUBLIC "-//Art Technology Group, Inc.//DTD General SQL Adapter//EN"
        "http://www.atg.com/dtds/gsa/gsa_1.0.dtd">
<gsa-template>
<item-descriptor name="tango">
	<table name="tb_tango" type="primary" id-column-name="id">
		<property name="id" column-names="id" data-type="string"/>
		<property name="profession" column-names="prof" data-type="string"/>
		<property name="firstname" column-names="fname" data-type="string"/>
	</table>
</item-descriptor>

</gsa-template>

1. SampleBean.properties
The component which bridges the java file with the jsp file.This name is used to import the java class into the jsp. In our example we are keeping it simple, nothing abstruse will be written in that.

$class= rootfolder.SampleBeanJ

The “rootfolder” is the location where the java class resides.And its in this SampleBeanJ we will write our actual application logic.

2. SampleBeanJ.java
SBJ is written like any other java class, it starts with the package information, then the imports, then the class declaration with access specifiers and extentions if any.

package rootfolder;
import java.io.IOException;// not actually required in our case, written just to stick to the standard format.
public class SampleBeanJ
{
	private String varFromBean;

	//getter method
	public String getVarFromBean() {
		return varFromBean;
	}
	//setter method.
	public void setVarFromBean(String varFromBean) {
		this.varFromBean = varFromBean;
	}
}

How the variable “varFromBean” is getting/setting a value is a different issue and we will discuss it in some other session. Our prime focus is on how to use a bean variable in a jsp, also the various methods of handling the bean variables.

Lets take a look at our “ttt.jsp”
Dont forget to include the dsp tag libs at the very beginning. Also the tag libs for the jstl(Jsp Standard Tag Library).
3. ttt.jsp

<%@ taglib uri="/dspTaglib" prefix="dsp" %>
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c"%>
<dsp:page>
<dsp:importbean bean="rootfolder/SampleBean"/>
//comment : the attribute bean specifies the property file, which in turn points to the java file.(The ATG component centric architecture)
<%
String jspVar1 = "foo";
//comment : Java code inside the JSP is kept inside <% and %> characters (just like expressions, but without the = sign at the start of the sequence.)This block of code is known as a "SCRIPLET".A scriptlet contains Java code that is executed every time the JSP is invoked.
%>
<dsp:getvalueof bean="SampleBean.varFromBean" idtype="java.lang.String" id="jspid">
<%
jspVar1 = jspid;
//comment: the "jspid" has the value of the private string variable"varFromBean" in the SampleBean class.
%>
</dsp:getvalueof>
<%if("foo".equals(jspVar1)){%>
<c:out value="foo from the jsp itself"></c:out>
<%}else{%>
<dsp:valueof bean="SampleBean.varFromBean"/>
//comment:value of the variable will be printed.
<%}%>
</dsp:page>

Here we see a method of using the variable in a bean inside the jsp.There are different other ways also to do the same. I will try to explain those in other posts. Hope this one helps.

Properties of Category and Products as defined by ATG Commerce Framework

Category Properties
ancestorCategories	Set of categories which are higher in the catelog hierarchy than this category.
childCategories	List of all Categories which comes under this Category.
childProducts	List of all products that are children of the category.
creationDate	The date on which the Category was created.
displayName	Is the name ACC displays for the category.
endDate	Date the category will no longer be available.
parentCategory	Specifies the default parent category for the category .
root	Specifies whether this category is the starting of the hierarchy, its a boolean value.
Product Properties:
ancestorCategories	Generated Set of categories that are higher in the catalog hierarchy than the product.
childSKUs	List of all SKUs that are children of the product.
creationDate	Date on which the product was created.
description	Descriptive text for display with the product.
displayName	Product name displayed by the ACC.
endDate	Date the product will no longer be available.
parentCategory	Specifies the default parent category for the product.

DSP:DROPLET tag: helps you invoke a servlet bean from a JSP page. The programming logic will be encapsulated in a java class(bean) which is used in the jsp.

ForEach Droplet: (“atg.droplet.ForEach” is the class, Component is “atg/dynamo/droplet/ForEach”) help us to iterate through the elements of an array which we specify. The droplet helps us to specify the HTML before and after the array processing also to specify the HTML if the array is empty.

Example:

<dsp:droplet name="/atg/dynamo/droplet/ForEach">
  <dsp:param name="array"  bean="/Employee.technologies"/>
  <dsp:oparam name="outputStart">
    <p>Employee and corresponding technologies</p>
  </dsp:oparam>
  <dsp:oparam name="output">
    <li><dsp:valueof param="element"></dsp:valueof></li>
  </dsp:oparam>
  <dsp:oparam name="outputEnd">
    <p>List finished</p>
  </dsp:oparm>
</dsp:droplet>

Here “Employee” is a bean and “technologies” is returning a set of values(various technlogies the particular employee know).Say atg,java,jsp,javascripts.
The output will be like:
Employee and corresponding technologies
atg
java
jsp
javascripts
List finished

INPUT PARAMETERs in the droplet:
1.   array: parameter can be a collection, enumeration, Iterator, map or array.
2.  sortProperties
This is an optional parameter and holds a string that specifies the order the items in the array are rendered.
A + and – will sort the properties in acsending and descending order respectively. The Syntax varies depending on the type of item in the array,
- If its a JavaBean specify the sortProperties in a comma seperated list of property names.
- If the array constitutes a Strings, numbers or dates; just mention a + or -
- While sorting values of a map and we have to sort according to the key, give “_key” along with +/- to indicate the sort order.
Eg: (in the above order)

<dsp:param name="sortProperties" values="+name, - age"/> (This will sort first by an alphabetical ordering of name and then by descending order of age.)
<dsp:param name="sortProperties" values="+"/>
<dsp:param name="sortProperties" values="+_key"/>

<dsp:param name="color" bean="/myProfile/Color.favoriteColor"/>
<dsp:param name="color" value="Blue"/>
<dsp:param name="color" param="favColor"/>

DSP VALUEOF tag : renders a value in a bean property or page parameter. “BEAN”, “PARAM”,”VALUE” are the attributes used with the tag. Of these three “BEAN” or “PARAM” is mandatory
Sample usage:

<dsp:page>
<dsp:importbean bean="/sample/Employee"/>
<html>
<body>
Name: <dsp:valueof bean="Employee.name"/>
Age: <dsp:valueof bean="Employee.age"/>
</body>
</html>
</dsp:page>

Here valueof will help render the value of employee from the “Employee” imported in the beginning.To include a default value, remove the final back slash, add an end tag (</dsp:valueof>), and insert your default value between that start tag and end tag.
<dsp:valueof bean=”Employee.name”>Default Value</dsp:valueof>

DSP SETVALUE tag: helps the page developer to set a bean property or page parameter with a constant value, value copied from another bean property, param value; “BEAN” or “PARAM” is mandatory attributes with the setvalue tag, these are destination values. The source attributes are BEANVALUE, PARAMVALUE and VALUE. If no source value is specified a NULL is assigned to destination.
Eg:
A fixed value :

<dsp:setvalue bean=“Employee.Designation” value=“analyst” />
A component property value :

<dsp:setvalue bean=“Employee.Designation” beanvalue=“/EmployeeDetails/EmployeeId.Designation” />
A parameter value :

<dsp:setvalue bean=“Employee.Designation” paramvalue=“empDesig” />
“empDesig” : is a page parameter previously set to some value, this will be copied to “Designation” property.

DSP INCLUDE tag: lets you include a page fragment inside a JSP file.It also helps to pass page parameters from the parent page to the included page. SRC or PAGE are the required attributes.One must use one of these attributes to specify which page needs to be included.

Tag Converters:
Allows the formatting of the tags.They let you specify how data in forms is interpreted and displayed, and to control when exceptions are thrown. Various tag converters are date, required,maxdate,mindate,nullable,number etc. The converters can be used in two different ways:
Explicit Converter:
<dsp:valueof bean=”Employee.DOB” converter=”date” date=”M/dd/yyyy”/>
Here the “converter” specifies the type of attribute later date=”M/dd/yyyy” specifies the format in which the bean value to be rendered.Output will look like 5/08/1986. Instead if we give date=”MMM dd,yyyy”, the output will be MAY 08,1986.
Implicit Converter:
Avoids the “converter” attribute and directly gives the format.
<dsp:valueof bean=“Employee.DOB” date=“M dd yyyy”/>

1.  What is atg Nucleus??

Nucleus is a ATG container for components. It creates and initializes component instances on request. It manages the components scope. It locates the properties file for the component and through that it reaches the class file of the component. Nucleus components are Java Objects each with an associated .properties file which store configuration values.

2 . What is MANIFEST file??

Applications often depend on other modules, these dependencies are declared in this file.The file name is MANIFEST.MF and resides in the META_INF directory. It specifies ATG-Class-Path,ATG-Required, ATG-Config-Path etc

3. How a component is Instantiated ??
One can start or stop components manually using an ACC.

OR.

We can instruct nucleus to start a component during server startup, this is done by modifying the “Initial.properties” file.Add the component name to the “initialServices” property inside the Initial.properties file.

4. Differentiate Global,Request & session scopes.

Global: components are accessible from all other components.Not available across ATG servers, each server has its own copy of global scoped component.

Session: means every user of the application gets a separate copy of the component, and component exists for duration of the user’s session.

Request : A component is called in for returning the values of a search, so each time a search is triggered an object instantiation happens and its gone when the result page is closed.Which means the scope of the search component is request.Eg:-formhandlers normally have a request scope.

5. What is a context root?
Is a URL mounting point of the web application. It decides what URL site site visitors will enter to get to the site. Eg: http://www.atg.com/”context-root”
“context-root” is specified in the “application.xml” file in the “j2ee-apps” folder.

” The Apache POI Project’s mission is to create and maintain Java APIs for manipulating various file formats based upon the Office Open XML standards (OOXML) and Microsoft’s OLE 2 Compound Document format (OLE2). In short,you can read and write MS Excel files using Java.”

HSSF is used in here for the excel reading and writing, it is a pure Java implementation of the Excel ’97-2003(The example here is using hssf package). XSSF is java implementation of Excel-’07(.xlsx format). A funny thing about HSSF is that its the acronym of Horrible Spread Sheet Format. The package used is “org.apache.poi.hssf.usermodel “, it contains classes to generate excel documents. HSSFWorkbook, HSSFSheet  & HSSFRow classes will help you in your task. For the above classes to be available you need to add the jar file into the project folder.The JAR we used is poi.jar. The code below reads an excel and prints each cell of the excel. The functionality is written in the main() sothat you can try it out just by copying the class. Picture shows a sample excel file i used and also some methods.

Note:-             

• Make sure you have the excel in the location mentioned in the code and also in the specified format.
• If “row.getCell()” is trying to read a cell with no value it will return a “java.lang.NullPointerException”. So either columns should not be empty or modify code accordingly for this sample program to be run.

SAMPLEeXCELpARSING.java

import java.io.File;
import java.io.FileInputStream;
import java.util.Iterator;

import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

public class SampleExcelParsing
{
	@SuppressWarnings("unchecked")
	public static void main(String[] argS)
	{
		File f = null;
		FileInputStream fis = null;
		// Short variable to get the column number.row.getCell() method takes a
		// short variable as input.
		short column1 = 0;
		short column2 = 1;
		short column3 = 2 ;
		try{

			f = new File("E:\\FilesforTesting\\T3Test.xls");
			fis = new FileInputStream(f);
			HSSFWorkbook wb = new HSSFWorkbook(fis);
			HSSFSheet sheet = wb.getSheetAt(0);
			Iterator rows = sheet.rowIterator();
			StringBuffer s = new StringBuffer();
//			 To skip first row.
			HSSFRow row = rows.next();
			while(rows.hasNext()){
				row = rows.next();
				String columnOwner = row.getCell(column1).toString();
				String columnCategory = row.getCell(column2).toString();
				String columnLink = row.getCell(column3).toString();
				s.append(columnOwner)
				.append("..")
				.append(columnCategory)
				.append("..")
				.append(columnLink)
				.append("\n");
			}
			fis.close();
			System.out.print(s);

		}catch(Exception ex)
		{System.out.println("Exption...."+ex);}

	}
}

This xpath will lead you to grandson node. All other things in the code are self explanatory. An xml specified in the code is also provided., make sure  you copy the xml(test.xml) in the same path mentioned in the java code. Hope the code snippet helps. This code will work fine within an ATG environment. I tried successfully.

Drawback:

This code will definitely help you find the value of known node, but wont help you in finding a dynamic node.Which means you need to specify the node name to get the value.Eg: you can’t read all “category” nodes of  “granddaughter” just by specifying xpath till “granddaughter”.

1 .     “testParsingXML.java”

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import atg.xml.tools.XMLToDOMParser;
import atg.xml.tools.apache.ApacheXMLToolsFactory;

public class testParsingXML{
public static void main(String[] argS){
		XMLToDOMParser xtdParser;
		ApacheXMLToolsFactory axtFactory = new ApacheXMLToolsFactory();
		xtdParser = axtFactory.createXMLToDOMParser();
		File xmlFile = null;
		FileInputStream fis= null;
		xmlFile = new File("E:\\test.xml");

		try {
			fis = new FileInputStream(xmlFile);	 // Should wrap with try catch block
			byte fileContent[] = new byte[(int)xmlFile.length()];
			fis.read(fileContent); 	// Should wrap with try catch block
			ByteArrayInputStream bis = new ByteArrayInputStream(fileContent);
			Document document = xtdParser.parse(bis ,false ,null);
			String xPath ="/root/daughter[@name=\"secondchild\"]/granddaughter[@name=\"three2tango\"]/category[@name=\"c1\"]";
			Enumeration nodes = axtFactory.createXSLQueryEngine().select(xPath, document, null);
			Node node = nodes.nextElement();
			if (node.hasAttributes())
			{
			NamedNodeMap attributes = node.getAttributes();
			System.out.println(attributes.item(1));
			System.out.println(attributes.getNamedItem("name").getTextContent());
			System.out.println(attributes.getNamedItem("value").getTextContent());
			}
		} catch (FileNotFoundException e) {
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

2. “test.xml”

     <root>
	<son name="firstchild">
		<grandson name="gs1" value="dileep"/>
		<grandson name="gs2" value="lloyd"/>
		<grandson name="gs3" value="vivek"/>
	</son>
	<daughter name="secondchild">
		<granddaughter name="three2tango">
			<category name="c1" value="java"/>
			<category name="c2" value="atg"/>
		</granddaughter>
	</daughter>
</root>

6.Set the “Path to Decompiler” as your “jad.exe” location.
7.Set the “Directory for temperary files “ as “D\.jadeclipse”
8. Restart eclipse once more to use JAD.

The decompiler will come handy when you are moving back and forth through ATG Out of the Box components. If JAD is there OOTB components and can be read and understood easily. Click ToDownload JAD Utility.