WebSVN – SmartDukaan – Diff – /trunk/ContentStore/src/main/java/in/shop2020/metamodel/definitions/DefinitionsContainer.java

 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.FacetRuleDefinitionType;
+import in.shop2020.metamodel.jaxb.facets.FacetSlideDefinitionType;
 import in.shop2020.metamodel.jaxb.facets.IRDefinitionType;
 import in.shop2020.metamodel.jaxb.facets.RuleDefinitionType;
 import in.shop2020.metamodel.util.ExpandedCMPSlideRuleDefinition;
 import in.shop2020.metamodel.util.ExpandedCategory;
 import in.shop2020.metamodel.util.ExpandedCategoryFacetDefinition;
-import in.shop2020.metamodel.util.ExpandedFacetDefinition;
 import in.shop2020.metamodel.util.ExpandedSlideDefinition;
 import in.shop2020.util.Utils;
 import java.io.File;
 import java.io.FileInputStream;
 	/**
 	 * Hashtable of Facet Definition ID to FacetDefinition object
 	 */
 	private Map<Long, FacetDefinition> facetDefinitions;
+	/**
+	 * Hashtable of Slide Definition ID to FacetDefinition object
+	 */
+	private Map<Long, List<FacetDefinition>> slideFacetDefinitions;
 	/**
 	 * Hashtable of Category Facet Definition ID to CategoryFacetDefinition
 	 * object
 	 */
 	private Map<Long, CategoryFacetDefinition> categoryFacetDefinitions;
 		srcFile = xmlDefinitionsPath+ "facetdefinitions.xml";
 		oDefType = this.unmarshallSrcFile(srcFile, "facets");
 		irDefType = (IRDefinitionType)oDefType;
 		this.facetDefinitions = this.convertFacetDefinitions(irDefType);
+		//
+		this.populateSlideFacetDefinitions();
 		//category facet definitions
 		srcFile = xmlDefinitionsPath+ "categoryfacetdefinitions.xml";
 		oDefType = this.unmarshallSrcFile(srcFile, "facets");
 		irDefType = (IRDefinitionType)oDefType;
 		this.categoryFacetDefinitions = this.convertCategoryFacetDefinitions(irDefType);
 		//ir data rules
 		srcFile = xmlDefinitionsPath+ "irdatarules.xml";
 		oDefType = this.unmarshallSrcFile(srcFile, "facets");
 		irDefType = (IRDefinitionType)oDefType;
 		irDataRuleDefinitions =  this.convertRuleDefinitions(irDefType);
 			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();
+			List<FacetSlideDefinition> facetSlideDefinitions = convertFacetSlideDefinitions(jaxbFacetDef);
-				facetDef.setSlideDefinitionID(slideDefID);
-			}
-			long irMetaDataRuleID = jaxbFacetDef.getIRMetaDataRuleID();
-			facetDef.setIrMetaDataRuleID(irMetaDataRuleID);
+			facetDef.setFacetSlideDefinitions(facetSlideDefinitions);
 			facetDef.setDescription(jaxbFacetDef.getDescription());
 			idFacetDefs.put(new Long(id), facetDef);
+		}
 		Utils.info("idFacetDefs=" + idFacetDefs);
 		return idFacetDefs;
+	}
+	private void populateSlideFacetDefinitions() {
+		this.slideFacetDefinitions = new HashMap<Long, List<FacetDefinition>>();
+		for(FacetDefinition facetDef: facetDefinitions.values())
+			for(FacetSlideDefinition facetSlideDef: facetDef.getFacetSlideDefinitions()){
+				List<FacetDefinition> facetDefs = this.slideFacetDefinitions.get(facetSlideDef.getSlideDefinitionID());
+				if(facetDefs==null){
+					facetDefs = new ArrayList<FacetDefinition>();
+				}
+				facetDefs.add(facetDef);
+				this.slideFacetDefinitions.put(facetSlideDef.getSlideDefinitionID(), facetDefs);
+			}
+	}
+	private List<FacetSlideDefinition> convertFacetSlideDefinitions(
+			FacetDefinitionType jaxbFacetDef) {
+			List<FacetSlideDefinition> facetSlideDefinitions = new ArrayList<FacetSlideDefinition>();
+			for(FacetSlideDefinitionType jaxbFacetSlideDef : jaxbFacetDef.getFacetSlideDefinition()){
+				long irDataRuleID = jaxbFacetSlideDef.getIRDataRuleID();
+				long irMetaDataRuleID = jaxbFacetSlideDef.getIRMetaDataRuleID();
+				long slideDefinitionID = jaxbFacetSlideDef.getSlideDefinitionID();
+				FacetSlideDefinition facetSlideDefinition = new FacetSlideDefinition(slideDefinitionID, irMetaDataRuleID, irDataRuleID);
+				facetSlideDefinitions.add(facetSlideDefinition);
+			}
+		return facetSlideDefinitions;
+	}
 	/**
+	 *
 	 * @param defType
 	 * @return
 	 * @throws Exception
 	 */
 	private Map<Long, CategoryFacetDefinition> convertCategoryFacetDefinitions(
 			IRDefinitionType defType) throws Exception {
-		List<CategoryFacetDefinitionType> jaxbCategoryFacetDefs =
+		 List<CategoryFacetDefinitionType> jaxbCategoryFacetDefs = defType.getCategoryFacetDefinition();
-			defType.getCategoryFacetDefinition();
 		Map<Long, CategoryFacetDefinition> idCategoryFacetDefs =
 			new TreeMap<Long, CategoryFacetDefinition>();
 		for(CategoryFacetDefinitionType jaxbCategoryFacetDef :
 			jaxbCategoryFacetDefs) {
 			long categoryID = jaxbCategoryFacetDef.getCategoryID();
 			CategoryFacetDefinition categoryFacetDef =
 				new CategoryFacetDefinition(categoryID);
-			List<FacetRuleDefinitionType> jaxbFacetRuleDefs =
-					jaxbCategoryFacetDef.getFacetRuleDefinition();
-			for(FacetRuleDefinitionType jaxbFacetRuleDef : jaxbFacetRuleDefs) {
+			List<Long> facetIDs = jaxbCategoryFacetDef.getFacetDefinitionID();
-				FacetRuleDefinition facetRuleDef =
-					this.convertFacetRuleDefinition(jaxbFacetRuleDef);
+			for(Long facetID : facetIDs) {
-				categoryFacetDef.addFacetRuleDefinition(facetRuleDef);
+				categoryFacetDef.addFacetDefinition(facetDefinitions.get(facetID));
+			}
 			idCategoryFacetDefs.put(new Long(categoryID), categoryFacetDef);
+		}
 				CategoryFacetDefinition parentCategoryFacetDef =
 					idCategoryFacetDefs.get(new Long(parentCategoryID));
 				if(parentCategoryFacetDef != null) {
-					List<FacetRuleDefinition> parentsFacetRuleDefs =
+					List<FacetDefinition> parentsFacetDefs =
-						parentCategoryFacetDef.getFacetRuleDefinitions();
+						parentCategoryFacetDef.getFacetDefinitions();
-					if(parentsFacetRuleDefs != null) {
+					if(parentsFacetDefs != null) {
 						CategoryFacetDefinition categoryFacetDef =
 							idCategoryFacetDefs.get(categoryID);
-						categoryFacetDef.appendFacetRuleDefinitions(
+						categoryFacetDef.appendFacetDefinitions(
-								parentsFacetRuleDefs);
+								parentsFacetDefs);
+					}
+				}
+			}
+		}
 		Utils.info("idCategoryFacetDefs=" + idCategoryFacetDefs);
 		return idCategoryFacetDefs;
+	}
+	private FacetDefinition convertFacetDefinition(
+			FacetDefinitionType jaxbFacetDef) {
+		long facetID = jaxbFacetDef.getID();
+		String target = jaxbFacetDef.getTarget();
+		FacetDefinition facetDefinition = new FacetDefinition(facetID, target);
+		facetDefinition.setDescription(jaxbFacetDef.getDescription());
+		facetDefinition.setFacetSlideDefinitions(convertFacetSlideDefinitions(jaxbFacetDef));
+		return facetDefinition;
+	}
 	/**
+	 *
 	 * @param jaxbFacetRuleDef
 	 * @return
 	 */
+	/*
 	private FacetRuleDefinition convertFacetRuleDefinition(
 			FacetRuleDefinitionType jaxbFacetRuleDef) {
 		long facetDefID = jaxbFacetRuleDef.getFacetDefinitionID();
 		long irDataRuleID = jaxbFacetRuleDef.getIRDataRuleID();
 					jaxbFacetRuleDef.getSlideDefinitionID().longValue());
+		}
 		return facetRuleDef;
+	}
+*/
 	private void populateEnumValues(){
 		// RE-VISIT - May not be optimal
 		Map<Long, EnumValue> enumValuesMap = new TreeMap<Long, EnumValue>();
 		for(Long datatypeDefID : datatypeDefinitions.keySet()) {
 		Iterator<FeatureDefinitionType> itjaxbDefs = jaxbDefs.iterator();
 		// Feature definitions
 		while(itjaxbDefs.hasNext()) {
 			FeatureDefinitionType jaxbDef = itjaxbDefs.next();
+			Utils.info("******"+ jaxbDef.getID());
 			//Utils.info("Feature label=" + jaxbDef.getLabel());
 			FeatureDefinition def = new FeatureDefinition(jaxbDef.getID(),
 					jaxbDef.getLabel());
 			def.setAllowsBlank(jaxbDef.isCanbeBlank());
 	public Map<Long, FacetDefinition> getFacetDefinitions(){
 		return this.facetDefinitions;
+	}
 	/**
+	 * Get List of Facets for a given slide.
+	 *
+	 * @return
+	 */
+	public Map<Long, List<FacetDefinition>> getSlideFacetDefinitions(){
+		return slideFacetDefinitions;
+	}
+	/**
 	 * Resolves Facet Definition ID into FacetDefinition object
+	 *
 	 * @param facetDefinitionID
 	 * @return FacetDefinition
 	 * @throws Exception
+	 *
 	 * @param facetDefinitionID
 	 * @return ExpandedFacetDefinition
 	 * @throws Exception
 	 */
+	/*
 	public ExpandedFacetDefinition getExpandedFacetDefinition(
 			long facetDefinitionID) throws Exception {
 		FacetDefinition facetDefinition =
 			this.getFacetDefinition(facetDefinitionID);
 		ExpandedFacetDefinition expFacetDefinition =
 			new ExpandedFacetDefinition(facetDefinition);
 		return expFacetDefinition;
+	}
+	*/
 	/**
 	 * Returns all CategoryFacetDefinition objects in the database
+	 *
 	 * @return Map Null if category facet definitions are not imported into
 	 * definitions db (serialized java objects)
 		CategoryFacetDefinition categoryFacetDef =
 			this.getCategoryFacetDefinition(categoryID);
 		if(categoryFacetDef == null)
 			return null;
-		List<FacetRuleDefinition> facetRuleDefs =
+		List<FacetDefinition> facetDefs =
-			categoryFacetDef.getFacetRuleDefinitions();
+			categoryFacetDef.getFacetDefinitions();
-		for(FacetRuleDefinition facetRuleDef : facetRuleDefs) {
+		for(FacetDefinition facetDef : facetDefs) {
-			facetDefIDs.add(new Long(facetRuleDef.getFacetDefinitionID()));
+			facetDefIDs.add(new Long(facetDef.getID()));
+		}
 		return facetDefIDs;
+	}
 	 * @param borrowedCategoryID
 	 * @param slideDefID
 	 * @return FacetRuleDefinition
 	 * @throws Exception
 	 */
+	/*
 	public FacetRuleDefinition getFacetRuleDefinitionForSlide(long categoryID,
 			long slideDefinitionID) throws Exception {
 		CategoryFacetDefinition categoryFacetDef =
 			this.getCategoryFacetDefinition(categoryID);
 		//FIXME Quick fix. Need to investigate
+			}
+		}
 		return null;
+	}
+	*/
 	/**
 	 * Returns Facet-Rule definition object defined for a category and
 	 * feature definition
+	 *
 	 * @param categoryID
 	 * @param featureDefinitionID
 	 * @return FacetRuleDefinition
 	 * @throws Exception
 	 */
+/*
 	public FacetRuleDefinition getFacetRuleDefinitionForFeature(long categoryID,
 			long featureDefinitionID) throws Exception {
 		CategoryFacetDefinition categoryFacetDef =
 			this.getCategoryFacetDefinition(categoryID);
 		if(categoryFacetDef == null){
+			}
+		}
 		return null;
+	}
+*/
 	/**
 	 * Returns all normalization rule defined
+	 *
 	 * @return Map<Long, RuleDefinition>
 	 * @throws Exception

Subversion Repositories SmartDukaan

(root)/trunk/ContentStore/src/main/java/in/shop2020/metamodel/definitions/DefinitionsContainer.java – Rev 1074 → 1314