Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.metamodel.util;

import in.shop2020.metamodel.definitions.BulletDefinition;

import in.shop2020.metamodel.definitions.Catalog;

import in.shop2020.metamodel.definitions.Category;

import in.shop2020.metamodel.definitions.CategoryFacetDefinition;

import in.shop2020.metamodel.definitions.CategorySlideDefinition;

import in.shop2020.metamodel.definitions.CompositeDefinition;

import in.shop2020.metamodel.definitions.CompositePartDefinition;

import in.shop2020.metamodel.definitions.DatatypeDefinition;

import in.shop2020.metamodel.definitions.DefinitionsContainer;

import in.shop2020.metamodel.definitions.EditorialImportance;

import in.shop2020.metamodel.definitions.EnumDefinition;

import in.shop2020.metamodel.definitions.EnumValue;

import in.shop2020.metamodel.definitions.FacetDefinition;

import in.shop2020.metamodel.definitions.FeatureDefinition;

import in.shop2020.metamodel.definitions.RuleDefinition;

import in.shop2020.metamodel.definitions.SlideDefinition;

import in.shop2020.metamodel.definitions.SlideFeatureDefinition;

import in.shop2020.metamodel.definitions.Unit;

import in.shop2020.metamodel.jaxb.core.BulletDefinitionType;

import in.shop2020.metamodel.jaxb.core.CategorySlideDefinitionType;

import in.shop2020.metamodel.jaxb.core.CategoryType;

import in.shop2020.metamodel.jaxb.core.CompositeDefinitionType;

import in.shop2020.metamodel.jaxb.core.CompositePartDefinitionType;

import in.shop2020.metamodel.jaxb.core.DatatypeDefinitionType;

import in.shop2020.metamodel.jaxb.core.DefinitionType;

import in.shop2020.metamodel.jaxb.core.EditorialImportanceType;

import in.shop2020.metamodel.jaxb.core.EnumDefinitionType;

import in.shop2020.metamodel.jaxb.core.EnumValueType;

import in.shop2020.metamodel.jaxb.core.FeatureDefinitionType;

import in.shop2020.metamodel.jaxb.core.SlideDefinitionType;

import in.shop2020.metamodel.jaxb.core.SlideFeatureDefinitionType;

import in.shop2020.metamodel.jaxb.core.UnitType;

import in.shop2020.metamodel.jaxb.facets.CategoryFacetDefinitionType;

import in.shop2020.metamodel.jaxb.facets.FacetDefinitionType;

import in.shop2020.metamodel.jaxb.facets.IRDefinitionType;

import in.shop2020.metamodel.jaxb.facets.RuleDefinitionType;

import in.shop2020.util.Utils;

import java.io.FileInputStream;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.TreeMap;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBElement;

import javax.xml.bind.Unmarshaller;

import org.apache.commons.lang.ArrayUtils;

import org.apache.commons.lang.StringUtils;

/**

 * Command line utility that imports model properties defined in XML

 * 

 * MM - Meta-Model Tool

 * 

 * It can be used to do following things

 * 

 * - Import

 * 	 - Datatype definitions

 * 	 - Feature definitions

 * 	 - Slide definitions

 * 	 - Categories

 * 

 * - Show

 * 	 - Datatype definitions

 * 	 - Feature definitions

 * 	 - Slide definitions

 * 	 - Categories

 * 

 * - Show all definition objects that define a category 

 * 

 * 

 * @author naveen

 *

 */

public class MM {

	/**

	 * 

	 */

	public static final String DEFINITIONS_SRC_PATH = 

		"/home/naveen/workspace/eclipse/webapp/src/xml/model/";

	// LOCAL

	/**

	 * 

	 */

	public static final String DEFINITIONS_DB_PATH = 

		"/home/naveen/workspace/eclipse/db/definitions/";

	/**

	 * 

	 */

	public static final String ENTITIES_DB_PATH = 

		"/home/naveen/workspace/eclipse/db/entities/";

	/** WEB

	public static final String DEFINITIONS_DB_PATH = 

		"/var/lib/tomcat6/webapps/shop2020/db/definitions/";

	public static final String ENTITIES_DB_PATH = 

		"/var/lib/tomcat6/webapps/shop2020/db/entities/";

	*/

	/** Validation tool

	public static final String DEFINITIONS_DB_PATH = 

		"./db/definitions/";

	public static final String ENTITIES_DB_PATH = 

		"./db/entities/";

	*/

	/**

	 * 

	 */

	private String definitionSetName;

	/**

	 * 

	 */

	private String srcFile;

	/**

	 * 

	 */

	private String dbFile;

	/**

	 * Usage: MM [show|import|showcategory] [units|datatypedefinitions|featuredefinitions|slidedefinitions|categories|facetdefinitions|categoryfacetdefinitions|irdatarules|irmetadatarules] {Category ID}

	 * 

	 * @param args

	 */

	public static void main(String[] args) throws Exception {

		String[] definitionSetNames = new String[] {"units", 

				"datatypedefinitions", "featuredefinitions", "slidedefinitions", 

				"categories", "facetdefinitions", "categoryfacetdefinitions", 

				"irdatarules", "irmetadatarules"};

		String[] commands = new String[] {"show", "import", "showcategory"};

		String usage = "Usage: MM ["+ StringUtils.join(commands, "|") +"] ["+ 

			StringUtils.join(definitionSetNames, "|") + "] {Category ID}";

		if(args.length < 2) {

			System.out.println(usage);

			System.exit(-1);

		}

		Utils.info("MM "+ args[0] + " " + args[1]);

		String inputCommand = args[0];

		if(!ArrayUtils.contains(commands, inputCommand)) {

			System.out.println(usage);

			System.exit(-1);

		}

		if(inputCommand.equals("show") || inputCommand.endsWith("import")) {

			String inputDefinitionSet = args[1];

			if(!ArrayUtils.contains(definitionSetNames, inputDefinitionSet)) {

				System.out.println(usage);

				System.exit(-1);

			}

			MM mm = new MM(inputDefinitionSet);

			if(inputCommand.equals("import")) {

				mm.importDefinitionSet();

			}

			else if(inputCommand.equals("show")) {

				mm.showDefinitionSet();

			}

		}

		if(inputCommand.equals("showcategory")) {

			String categoryID = args[1];

			long catID = 0;

			try {

				catID = Long.parseLong(categoryID);

			} 

			catch (NumberFormatException nfe) {

				System.out.println("Invalid category ID");

				System.exit(-1);

			}

			MM mm = new MM();

			mm.showCategory(catID);

		}

	}

	/**

	 * 

	 */

	public MM() {

	}

	/**

	 * 

	 * @param definitionSet

	 */

	public MM(String definitionSetName) {

		this.definitionSetName = definitionSetName;

		this.srcFile = DEFINITIONS_SRC_PATH + this.definitionSetName + ".xml";

		this.dbFile = DEFINITIONS_DB_PATH + this.definitionSetName + ".ser";

	}

	/**

	 * 

	 * @param categoryID

	 * @throws Exception 

	 */

	public void showCategory(long categoryID) throws Exception {

		DefinitionsContainer defs = 

			Catalog.getInstance().getDefinitionsContainer();

		ExpandedCategory expCategory = defs.getExpandedCategory(categoryID);

		Utils.info(expCategory);

	}

	/**

	 * 

	 */

	@SuppressWarnings("unchecked")

	public void importDefinitionSet() throws Exception {

		String type = "core";

		if(this.definitionSetName.equals("facetdefinitions") || 

				this.definitionSetName.equals("categoryfacetdefinitions") ||

				this.definitionSetName.equals("irdatarules") || 

						this.definitionSetName.equals("irmetadatarules")) {

			type = "facets";

		}

		Object oDefType = this.unmarshallSrcFile(this.srcFile, type);

		DefinitionType defType = null;

		IRDefinitionType irDefType = null;

		if(type.equals("core")) {

			defType = (DefinitionType)oDefType;

		} 

		else if (type.equals("facets")) {

			irDefType = (IRDefinitionType)oDefType;

		}

		Object objectToStore = null;

		// CORE

		// Units

		if(this.definitionSetName.equals("units")) {

			Map unitsMap = this.convertUnits(defType);

			objectToStore = unitsMap;

		}

		// Categories

		else if(this.definitionSetName.equals("categories")) {

			Map<Long, Category> categoriesMap = new HashMap<Long, Category>();

			Category root = this.convertCategories(defType, categoriesMap);

			//Utils.info(categoriesMap);

			//Utils.info(root);

			//System.exit(0);

			// Tree

			String categoryTreeDBFile = DEFINITIONS_DB_PATH + "categorytree" + 

				".ser";

			if(root != null) {

				DBUtils.store(root, categoryTreeDBFile);

			}

			// Map

			objectToStore = categoriesMap;

		}

		// Datatype Definitions

		else if(this.definitionSetName.equals("datatypedefinitions")) {

			Map<Long, DatatypeDefinition> datatypeDefsMap = 

				this.convertDatatypeDefinition(defType);

			// Store enum value id to value map separately

			String enumValueDBFile = DEFINITIONS_DB_PATH + "enumvalues" + 

				".ser";

			// RE-VISIT - May not be optimal

			Map<Long, EnumValue> enumValuesMap = new TreeMap<Long, EnumValue>();

			for(Long datatypeDefID : datatypeDefsMap.keySet()) {

				DatatypeDefinition datatypeDef = 

					datatypeDefsMap.get(datatypeDefID);

				if(datatypeDef instanceof EnumDefinition) {

					List<EnumValue> enumValues = 

						((EnumDefinition) datatypeDef).getEnumValues();

					for(EnumValue enumValue : enumValues) {

						enumValuesMap.put(new Long(enumValue.getID()), 

								enumValue);

					}

				}

			}

			Utils.info("enumValuesMap=" + enumValuesMap);

			DBUtils.store(enumValuesMap, enumValueDBFile);

			objectToStore = datatypeDefsMap;

		}

		// Feature Definitions

		else if(this.definitionSetName.equals("featuredefinitions")) {

			Map featureDefsMap = this.convertFeatureDefinitions(defType);

			objectToStore = featureDefsMap;

		}

		// Slide Definitions

		else if(this.definitionSetName.equals("slidedefinitions")) {

			Map slideDefsMap = this.convertSlideDefinitions(defType);

			objectToStore = slideDefsMap;

		}

		// FACETS

		// Facet Definitions

		else if(this.definitionSetName.equals("facetdefinitions")) {

			Map facetDefsMap = this.convertFacetDefinitions(irDefType);

			objectToStore = facetDefsMap;

		}

		// Category Facet Definitions

		else if(this.definitionSetName.equals("categoryfacetdefinitions")) {

			Map categoryFacetDefsMap = 

				this.convertCategoryFacetDefinitions(irDefType);

			objectToStore = categoryFacetDefsMap;

		}

		// IR Data Rules

		else if(this.definitionSetName.equals("irdatarules")) {

			Map irdataRuleDefsMap = 

				this.convertRuleDefinitions(irDefType);

			objectToStore = irdataRuleDefsMap;

		}

		// IR Meta-Data Rules

		else if(this.definitionSetName.equals("irmetadatarules")) {

			Map irmetadataRuleDefsMap = 

				this.convertRuleDefinitions(irDefType);

			objectToStore = irmetadataRuleDefsMap;

		}

		if(objectToStore != null) {

			DBUtils.store(objectToStore, this.dbFile);

		}

	}

	/**

	 * 

	 */

	public void showDefinitionSet() throws Exception {

		Object obj = DBUtils.read(this.dbFile);

		Utils.info(obj.toString());

		if(this.definitionSetName.equals("categories")) {

			String categoryTreeDBFile = DEFINITIONS_DB_PATH + "categorytree" + 

				".ser";

			Category root = (Category)DBUtils.read(categoryTreeDBFile);

			Utils.info(root.toString());

			//Utils.info("root.getChildrenCategory().size: " + 

			//		root.getChildrenCategory().size());

		}

	}

	/**

	 * 

	 * @param defType

	 * @return

	 */

	private Map<Long, RuleDefinition> convertRuleDefinitions(

			IRDefinitionType defType) {

		Map<Long, RuleDefinition> idRuleDef = 

			new TreeMap<Long, RuleDefinition>();

		List<RuleDefinitionType> jaxbRuleDefs = defType.getRuleDefinition();

		for(RuleDefinitionType jaxbRuleDef : jaxbRuleDefs) {

			long id = jaxbRuleDef.getID();

			String script = jaxbRuleDef.getScript();

			RuleDefinition ruleDef = new RuleDefinition(id, script);

			ruleDef.setDescription(jaxbRuleDef.getDescription());

			idRuleDef.put(new Long(id), ruleDef);

		}

		Utils.info("idRuleDef=" + idRuleDef);

		return idRuleDef;

	}

	/**

	 * 

	 * @param defType

	 * @return

	 */

	private Map<Long, FacetDefinition> convertFacetDefinitions(

			IRDefinitionType defType) {

		List<FacetDefinitionType> jaxbFacetDefs = defType.getFacetDefinition();

		Map<Long, FacetDefinition> idFacetDefs = 

			new TreeMap<Long, FacetDefinition>();

		for(FacetDefinitionType jaxbFacetDef : jaxbFacetDefs) {

			long id = jaxbFacetDef.getID();

			String target = jaxbFacetDef.getTarget();

			FacetDefinition facetDef = new FacetDefinition(id, target);

			if(jaxbFacetDef.getFeatureDefinitionID() != null) {

				long featureDefID = jaxbFacetDef.getFeatureDefinitionID();

				facetDef.setFeatureDefinitionID(featureDefID);

			}

			if(jaxbFacetDef.getSlideDefinitionID() != null) {

				long slideDefID = jaxbFacetDef.getSlideDefinitionID();

				facetDef.setSlideDefinitionID(slideDefID);

			}

			long irDataRuleID = jaxbFacetDef.getIRDataRuleID();

			facetDef.setIrDataRuleID(irDataRuleID);

			long irMetaDataRuleID = jaxbFacetDef.getIRMetaDataRuleID();

			facetDef.setIrMetaDataRuleID(irMetaDataRuleID);

			facetDef.setDescription(jaxbFacetDef.getDescription());

			idFacetDefs.put(new Long(id), facetDef);

		}

		Utils.info("idFacetDefs=" + idFacetDefs);

		return idFacetDefs;

	}

	/**

	 * 

	 * @param defType

	 * @return

	 * @throws Exception 

	 */

	private Map<Long, CategoryFacetDefinition> convertCategoryFacetDefinitions(

			IRDefinitionType defType) throws Exception {

		List<CategoryFacetDefinitionType> jaxbCategoryFacetDefs = 

			defType.getCategoryFacetDefinition();

		Map<Long, CategoryFacetDefinition> idCategoryFacetDefs = 

			new TreeMap<Long, CategoryFacetDefinition>();

		for(CategoryFacetDefinitionType jaxbCategoryFacetDef : 

			jaxbCategoryFacetDefs) {

			long categoryID = jaxbCategoryFacetDef.getCategoryID();

			List<Long> jaxbFacetDefIDs = 

				jaxbCategoryFacetDef.getFacetDefinitionID();

			CategoryFacetDefinition categoryFacetDef = 

				new CategoryFacetDefinition(categoryID);

			categoryFacetDef.setFacetDefinitionIDs(jaxbFacetDefIDs);

			idCategoryFacetDefs.put(new Long(categoryID), categoryFacetDef);

		}

		// Append parent's facets 

		// Go only one level for now

		// Categories need to be imported first

		DefinitionsContainer defs = 

			Catalog.getInstance().getDefinitionsContainer();

		for(Long categoryID : idCategoryFacetDefs.keySet()) {

			Category category = defs.getCategory(categoryID.longValue());

			Category parentCategory = category.getParentCategory();

			if(parentCategory != null) {

				long parentCategoryID = parentCategory.getID();

				CategoryFacetDefinition parentCategoryFacetDef = 

					idCategoryFacetDefs.get(new Long(parentCategoryID));

				if(parentCategoryFacetDef != null) {

					List<Long> parentsFacetIDs = 

						parentCategoryFacetDef.getFacetDefinitionIDs();

					if(parentsFacetIDs != null) {

						CategoryFacetDefinition categoryFacetDef = 

							idCategoryFacetDefs.get(categoryID);

						categoryFacetDef.appendFacetDefinitionIDs(

								parentsFacetIDs);

					}

				}

			}

		}

		Utils.info("idCategoryFacetDefs=" + idCategoryFacetDefs);

		return idCategoryFacetDefs;

	}

	/**

	 * 

	 * @return Map

	 */

	private Map<Long, SlideDefinition> convertSlideDefinitions(

			DefinitionType defType) {

		Map<Long, SlideDefinition> defs = 

			new HashMap<Long, SlideDefinition>();

		List<SlideDefinitionType> jaxbDefs = defType.getSlideDefinition();

		Iterator<SlideDefinitionType> itjaxbDefs = jaxbDefs.iterator();

		// Slide definitions

		while(itjaxbDefs.hasNext()) {

			SlideDefinitionType jaxbDef = itjaxbDefs.next();

			Utils.info("Slide label=" + jaxbDef.getLabel());

			SlideDefinition def = new SlideDefinition(jaxbDef.getID(),

					jaxbDef.getLabel());

			def.setDescription(jaxbDef.getDescription());

			// Children Slides

			Utils.info("jaxbDef.getChildSlideID=" + jaxbDef.getChildSlideID());

			def.setChildrenSlideDefinitionIDs(jaxbDef.getChildSlideID());

			// Slide Feature Definition

			List<SlideFeatureDefinitionType> jaxbSlideFeatureDefs = 

				jaxbDef.getSlideFeatureDefinition();

			if(jaxbSlideFeatureDefs != null) {

				def.setSlideFeatureDefinitions((

						this.convertSlideFeatureDefinitions(

								jaxbSlideFeatureDefs)));

			}

			Utils.info("def=" + def);

			defs.put(new Long(jaxbDef.getID()), def);

		}

		return defs;

	}

	/**

	 * 

	 * @param jaxbDefs

	 * @return List<SlideFeatureDefinition>

	 */

	private List<SlideFeatureDefinition> convertSlideFeatureDefinitions(

			List<SlideFeatureDefinitionType> jaxbDefs) {

		List<SlideFeatureDefinition> defs = 

			new ArrayList<SlideFeatureDefinition>();

		Iterator<SlideFeatureDefinitionType> itjaxbDefs = jaxbDefs.iterator();

		// Slide-feature definitions

		while(itjaxbDefs.hasNext()) {

			SlideFeatureDefinitionType jaxbDef = itjaxbDefs.next();

			SlideFeatureDefinition def = new SlideFeatureDefinition(

					jaxbDef.getFeatureDefinitionID());

			def.setEditorialImportance(this.convertEditorialImportance(

					jaxbDef.getEditorialImportance()));

			def.setDescription(jaxbDef.getDescription());

			defs.add(def);

		}

		return defs;

	}

	/**

	 * 

	 * @param defType

	 * @return

	 */

	private Map<Long, FeatureDefinition> convertFeatureDefinitions(

			DefinitionType defType) {

		Map<Long, FeatureDefinition> defs = 

			new HashMap<Long, FeatureDefinition>();

		List<FeatureDefinitionType> jaxbDefs = defType.getFeatureDefinition();

		Iterator<FeatureDefinitionType> itjaxbDefs = jaxbDefs.iterator();

		// Feature definitions

		while(itjaxbDefs.hasNext()) {

			FeatureDefinitionType jaxbDef = itjaxbDefs.next();

			//Utils.info("Feature label=" + jaxbDef.getLabel());

			FeatureDefinition def = new FeatureDefinition(jaxbDef.getID(),

					jaxbDef.getLabel());

			def.setAllowsBlank(jaxbDef.isCanbeBlank());

			def.setDescription(jaxbDef.getDescription());

			// Bullet Definition

			BulletDefinitionType jaxbBulletDef = jaxbDef.getBulletDefinition();

			if(jaxbBulletDef != null) {

				def.setBulletDefinition(this.convertBulletDefinition(

						jaxbBulletDef));

			}

			Utils.info("def=" + def);

			defs.put(new Long(jaxbDef.getID()), def);

		}

		return defs;

	}

	/**

	 * 

	 * @param jaxbDef BulletDefinitionType

	 * @return BulletDefinition

	 */

	private BulletDefinition convertBulletDefinition(

			BulletDefinitionType jaxbDef) {

		BulletDefinition def = new BulletDefinition(

				jaxbDef.getDatatypeDefinitionID());

		Long unitID = jaxbDef.getUnitID();

		if(unitID != null) {

			def.setUnitID(unitID.longValue());

		}

		Utils.info("jaxbDef.isIsMultivalue=" + jaxbDef.isIsMultivalue());

		def.setMultivalue(jaxbDef.isIsMultivalue());

		def.setLearned(jaxbDef.isIsLearned());

		def.setDescription(jaxbDef.getDescription());

		return def;

	}

	/**

	 * 

	 * @param defType

	 * @return

	 */

	private Map<Long, DatatypeDefinition> convertDatatypeDefinition(

			DefinitionType defType) {

		Map<Long, DatatypeDefinition> defs = 

			new HashMap<Long, DatatypeDefinition>();

		List<DatatypeDefinitionType> jaxbDefs = defType.getDatatypeDefinition();

		Iterator<DatatypeDefinitionType> it = jaxbDefs.iterator();

		while(it.hasNext()) {

			DatatypeDefinitionType jaxbDef = it.next();

			DatatypeDefinition def = null;

			CompositeDefinitionType compositeDefType = 

				jaxbDef.getCompositeDefinition();

			EnumDefinitionType enumDefType = 

				jaxbDef.getEnumDefinition();

			// Composite data type

			if(compositeDefType != null) {

				CompositeDefinition compDef = new CompositeDefinition(

						jaxbDef.getID(), jaxbDef.getName(), 

						compositeDefType.getSeparator());

				List<CompositePartDefinitionType> jaxbPartDefs = 

					compositeDefType.getCompositePartDefinition();

				Iterator<CompositePartDefinitionType> itPartDefs = 

					jaxbPartDefs.iterator();

				// Collect parts

				while(itPartDefs.hasNext()) {

					CompositePartDefinitionType jaxbPartDef = itPartDefs.next();

					CompositePartDefinition partDef = 

						this.convertCompositePartDefinition(jaxbPartDef);

					compDef.addCompositePartDefinition(partDef);

				}

				def = compDef;

			}

			// Enumerated values

			else if(enumDefType != null) {

				EnumDefinition enumDef = new EnumDefinition(jaxbDef.getID(), 

						jaxbDef.getName());

				List<EnumValueType> jaxbEnumValues = 

					enumDefType.getEnumValue();

				Iterator<EnumValueType> itEnumValues = 

					jaxbEnumValues.iterator();

				// Collect individual value

				while(itEnumValues.hasNext()) {

					EnumValueType jaxbEnumValue = itEnumValues.next();

					EnumValue enumValue = 

						this.convertEnumValueDefinition(jaxbEnumValue);

					enumDef.addEnumValue(enumValue);

				}

				def = enumDef;

			}

			// Primitive

			else {

				def = new DatatypeDefinition(jaxbDef.getID(), 

						jaxbDef.getName());

			}

			def.setDescription(jaxbDef.getDescription());

			Utils.info("def=" + def);

			defs.put(new Long(jaxbDef.getID()), def);

		}

		return defs;

	}

	/**

	 * 

	 * @param jaxbEnumValue

	 * @return EnumValue

	 */

	private EnumValue convertEnumValueDefinition(EnumValueType jaxbEnumValue) {

		EnumValue enumValue = new EnumValue(jaxbEnumValue.getID(), 

				jaxbEnumValue.getValue());

		return enumValue;

	}

	/**

	 * 

	 * @param jaxbPartDef

	 * @return CompositePartDefinition

	 */

	private CompositePartDefinition convertCompositePartDefinition(

			CompositePartDefinitionType jaxbPartDef) {

		CompositePartDefinition partDef = new CompositePartDefinition(

				jaxbPartDef.getLabel(), jaxbPartDef.getDatatypeDefinitionID(), 

				jaxbPartDef.getUnitID());

		partDef.setDescription(jaxbPartDef.getDescription());

		return partDef;

	}

	/**

	 * 

	 * @param defType

	 * @param catMap

	 * @return

	 */

	private Category convertCategories(DefinitionType defType, 

			Map<Long, Category> catMap) {

		List<CategoryType> jaxbCats = defType.getCategory();

		Iterator<CategoryType> it = jaxbCats.iterator();

		// Get root category

		CategoryType jaxbCat = it.next();

		if(jaxbCat == null) {

			Utils.info("Invalid file: " + this.srcFile);

			return null;

		}

		Category root = this.convertCategoryType(jaxbCat, null, catMap);

		Utils.info("catMap.get(10002)=" + catMap.get(new Long(10002)));

		return root;

	}

	/**

	 * 

	 * @param jaxbCat

	 * @param parentCat

	 * @param catMap

	 * @return

	 */

	@SuppressWarnings("unchecked")

	private Category convertCategoryType(CategoryType jaxbCat, 

			Category parentCat, Map<Long, Category> catMap) {

		Category cat = new Category(jaxbCat.getID());

		cat.setLabel(jaxbCat.getName());

		cat.setDescription(jaxbCat.getDescription());

		if(parentCat != null) {

			cat.setParentCategory(parentCat);

			// Copy parent's category-slide definitions

			ArrayList<CategorySlideDefinition> parentCSDef = 

				(ArrayList<CategorySlideDefinition>) 

				parentCat.getCategorySlideDefintions();

			if(parentCSDef != null) {

				cat.setCategorySlideDefintions(

					(List<CategorySlideDefinition>) parentCSDef.clone());

			}

		}

		// Category Slide Definition

		List<CategorySlideDefinitionType> jaxbDefs = 

			jaxbCat.getCategorySlideDefinition();

		Iterator<CategorySlideDefinitionType> it = jaxbDefs.iterator();

		while(it.hasNext()) {

			CategorySlideDefinitionType jaxbDef = it.next();

			CategorySlideDefinition catSlideDef 

			= this.convertCategorySlideDefinitionType(jaxbCat.getID(), jaxbDef);

			cat.addCategorySlideDefintion(catSlideDef);

		}

		// Children

		List<CategoryType> jaxbChildren = jaxbCat.getChildCategory();

		//Utils.info("jaxbChildren.size: " + jaxbChildren.size());

		Iterator<CategoryType> itChildren = jaxbChildren.iterator();

		while(itChildren.hasNext()) {

			CategoryType jaxbChildCat = itChildren.next();

			Category childCat = this.convertCategoryType(jaxbChildCat, cat, 

					catMap);

			cat.addChild(childCat);

		}

		//Utils.info("Parent cat: " + cat);

		// DEBUG ONLY

		Utils.info("####### Cat ID: " + cat.getID());

		if(cat.getCategorySlideDefintions() != null) {

			for(CategorySlideDefinition csd : cat.getCategorySlideDefintions()){

				Utils.info("####### SlideDefintionID=" + 

						csd.getSlideDefintionID());

			}

		}

		catMap.put(new Long(jaxbCat.getID()), cat);

		return cat;

	}

	/**

	 * 

	 * @param categoryID

	 * @param jaxbDef

	 * @return

	 */

	private CategorySlideDefinition convertCategorySlideDefinitionType(

			long categoryID, CategorySlideDefinitionType jaxbDef) {

		CategorySlideDefinition catSlideDef = new CategorySlideDefinition(

				jaxbDef.getSlideDefinitionID());

		catSlideDef.setDescription(jaxbDef.getDescription());

		EditorialImportanceType jaxbEdImp = jaxbDef.getEditorialImportance();

		EditorialImportance edImp = this.convertEditorialImportance(jaxbEdImp);

		catSlideDef.setEditorialImportance(edImp);

		return catSlideDef;

	}

	/**

	 * 

	 * @return Map

	 */

	private Map<Long, Unit> convertUnits(DefinitionType defType) {

		Map<Long, Unit> allUnits = new HashMap<Long, Unit>();

		List<UnitType> jaxbUnits = defType.getUnit();

		Iterator<UnitType> it = jaxbUnits.iterator();

		while(it.hasNext()) {

			UnitType jaxbUnit = it.next();

			Unit unit = new Unit(jaxbUnit.getID());

			unit.setDescription(jaxbUnit.getDescription());

			unit.setFullForm(jaxbUnit.getFullform());

			unit.setShortForm(jaxbUnit.getShortform());

			Utils.info("unit=" + unit);

			allUnits.put(new Long(jaxbUnit.getID()), unit);

		}

		return allUnits;

	}

	/**

	 * 

	 * @param srcFile

	 * @return

	 * @throws Exception

	 */

	private Object unmarshallSrcFile(String srcFile, String type) 

		throws Exception {

        JAXBContext jc = JAXBContext.newInstance("in.shop2020.metamodel.jaxb." +

        		type);

        // create an Unmarshaller

        Unmarshaller u = jc.createUnmarshaller();

        JAXBElement<?> element = (JAXBElement<?>)u.unmarshal(

        		new FileInputStream(srcFile));

        return element.getValue();

	}

	/**

	 * 

	 * @param jaxbEdImp

	 * @return EditorialImportance

	 */

	private EditorialImportance convertEditorialImportance(

			EditorialImportanceType jaxbEdImp) {

		String strEdImp = jaxbEdImp.value();

		EditorialImportance edImp = null;

		if(strEdImp.equals("Mandatory"))

			edImp = EditorialImportance.MANDATORY;

		else if(strEdImp.equals("Optional"))

			edImp = EditorialImportance.OPTIONAL;

		else 

			edImp = EditorialImportance.RECOMMENDED;

		return edImp;

	}

}