Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.metamodel.util;

import in.shop2020.metamodel.definitions.BulletDefinition;

import in.shop2020.metamodel.definitions.Category;

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.EditorialImportance;

import in.shop2020.metamodel.definitions.EnumDefinition;

import in.shop2020.metamodel.definitions.EnumValue;

import in.shop2020.metamodel.definitions.FeatureDefinition;

import in.shop2020.metamodel.definitions.SlideDefinition;

import in.shop2020.metamodel.definitions.SlideFeatureDefinition;

import in.shop2020.metamodel.definitions.Unit;

import in.shop2020.metamodel.jaxb.BulletDefinitionType;

import in.shop2020.metamodel.jaxb.CategorySlideDefinitionType;

import in.shop2020.metamodel.jaxb.CategoryType;

import in.shop2020.metamodel.jaxb.CompositeDefinitionType;

import in.shop2020.metamodel.jaxb.CompositePartDefinitionType;

import in.shop2020.metamodel.jaxb.DatatypeDefinitionType;

import in.shop2020.metamodel.jaxb.DefinitionType;

import in.shop2020.metamodel.jaxb.EditorialImportanceType;

import in.shop2020.metamodel.jaxb.EnumDefinitionType;

import in.shop2020.metamodel.jaxb.EnumValueType;

import in.shop2020.metamodel.jaxb.FeatureDefinitionType;

import in.shop2020.metamodel.jaxb.SlideDefinitionType;

import in.shop2020.metamodel.jaxb.SlideFeatureDefinitionType;

import in.shop2020.metamodel.jaxb.UnitType;

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;

/**

 * MM - Meta-Model Tool

 * Imports and exports model definitions. Validates against meta model

 * 

 * @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/";

	*/

	private String definitionSetName;

	private String srcFile;

	private String dbFile;

	/**

	 * @param args

	 */

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

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

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

				"categories"};

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

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

			StringUtils.join(definitionSetNames, "|") +"]";

		if(args.length < 2) {

			System.out.println(usage);

			System.exit(-1);

		}

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

		String inputCommand = args[0];

		String inputDefinitionSet = args[1];

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

			System.out.println(usage);

			System.exit(-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();

		}

	}

	/**

	 * 

	 * @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";

	}

	/**

	 * 

	 */

	@SuppressWarnings("unchecked")

	public void importDefinitionSet() throws Exception {

		DefinitionType defType = this.unmarshallSrcFile(this.srcFile);

		Object objectToStore = null;

		// 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.logger.info(categoriesMap);

			//Utils.logger.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.logger.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;

		}

		if(objectToStore != null) {

			DBUtils.store(objectToStore, this.dbFile);

		}

	}

	/**

	 * 

	 */

	public void showDefinitionSet() throws Exception {

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

		Utils.logger.info(obj.toString());

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

			String categoryTreeDBFile = DEFINITIONS_DB_PATH + "categorytree" + 

				".ser";

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

			Utils.logger.info(root.toString());

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

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

		}

	}

	/**

	 * 

	 * @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.logger.info("Slide label=" + jaxbDef.getLabel());

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

					jaxbDef.getLabel());

			def.setDescription(jaxbDef.getDescription());

			// Slide Feature Definition

			List<SlideFeatureDefinitionType> jaxbSlideFeatureDefs = 

				jaxbDef.getSlideFeatureDefinition();

			if(jaxbSlideFeatureDefs != null) {

				def.setSlideFeatureDefinitions((

						this.convertSlideFeatureDefinitions(

								jaxbSlideFeatureDefs)));

			}

			Utils.logger.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;

	}

	/**

	 * 

	 * @return Map

	 */

	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.logger.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.logger.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());

		}

		def.setMultivalue(jaxbDef.isIsMultivalue());

		def.setLearned(jaxbDef.isIsLearned());

		def.setDescription(jaxbDef.getDescription());

		return def;

	}

	/**

	 * 

	 * @return Map

	 */

	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.logger.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;

	}

	/**

	 * 

	 * @return Map

	 */

	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.logger.info("Invalid file: " + this.srcFile);

			return null;

		}

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

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

		return root;

	}

	/**

	 * 

	 * @param jaxbCat

	 * @return Category

	 */

	@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.logger.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.logger.info("Parent cat: " + cat);

		// DEBUG ONLY

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

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

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

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

						csd.getSlideDefintionID());

			}

		}

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

		return cat;

	}

	/**

	 * 

	 * @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.logger.info("unit=" + unit);

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

		}

		return allUnits;

	}

	/**

	 * 

	 * @return DefinitionType

	 */

	private DefinitionType unmarshallSrcFile(String srcFile) throws Exception {

        JAXBContext jc = JAXBContext.newInstance("in.shop2020.metamodel.jaxb");

        // create an Unmarshaller

        Unmarshaller u = jc.createUnmarshaller();

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

        		new FileInputStream(srcFile));

        return (DefinitionType)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;

	}

}