Subversion Repositories SmartDukaan

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
10 shop2020 1 
/**
2 
 *
3 
 */
4 
package in.shop2020.metamodel.util;
5 
 
16 naveen 6 
import in.shop2020.metamodel.definitions.BulletDefinition;
69 naveen 7 
import in.shop2020.metamodel.definitions.CMPRuleDefinition;
8 
import in.shop2020.metamodel.definitions.CMPSlideRuleDefinition;
45 naveen 9 
import in.shop2020.metamodel.definitions.Catalog;
10 shop2020 10 
import in.shop2020.metamodel.definitions.Category;
57 naveen 11 
import in.shop2020.metamodel.definitions.CategoryFacetDefinition;
10 shop2020 12 
import in.shop2020.metamodel.definitions.CategorySlideDefinition;
16 naveen 13 
import in.shop2020.metamodel.definitions.CompositeDefinition;
14 
import in.shop2020.metamodel.definitions.CompositePartDefinition;
15 
import in.shop2020.metamodel.definitions.DatatypeDefinition;
45 naveen 16 
import in.shop2020.metamodel.definitions.DefinitionsContainer;
10 shop2020 17 
import in.shop2020.metamodel.definitions.EditorialImportance;
16 naveen 18 
import in.shop2020.metamodel.definitions.EnumDefinition;
19 
import in.shop2020.metamodel.definitions.EnumValue;
57 naveen 20 
import in.shop2020.metamodel.definitions.FacetDefinition;
16 naveen 21 
import in.shop2020.metamodel.definitions.FeatureDefinition;
61 naveen 22 
import in.shop2020.metamodel.definitions.RuleDefinition;
16 naveen 23 
import in.shop2020.metamodel.definitions.SlideDefinition;
24 
import in.shop2020.metamodel.definitions.SlideFeatureDefinition;
10 shop2020 25 
import in.shop2020.metamodel.definitions.Unit;
69 naveen 26 
import in.shop2020.metamodel.jaxb.comparison.CMPDefinitionType;
27 
import in.shop2020.metamodel.jaxb.comparison.CMPRuleDefinitionType;
28 
import in.shop2020.metamodel.jaxb.comparison.CMPSlideRuleDefinitionType;
57 naveen 29 
import in.shop2020.metamodel.jaxb.core.BulletDefinitionType;
30 
import in.shop2020.metamodel.jaxb.core.CategorySlideDefinitionType;
31 
import in.shop2020.metamodel.jaxb.core.CategoryType;
32 
import in.shop2020.metamodel.jaxb.core.CompositeDefinitionType;
33 
import in.shop2020.metamodel.jaxb.core.CompositePartDefinitionType;
34 
import in.shop2020.metamodel.jaxb.core.DatatypeDefinitionType;
35 
import in.shop2020.metamodel.jaxb.core.DefinitionType;
36 
import in.shop2020.metamodel.jaxb.core.EditorialImportanceType;
37 
import in.shop2020.metamodel.jaxb.core.EnumDefinitionType;
38 
import in.shop2020.metamodel.jaxb.core.EnumValueType;
39 
import in.shop2020.metamodel.jaxb.core.FeatureDefinitionType;
40 
import in.shop2020.metamodel.jaxb.core.SlideDefinitionType;
41 
import in.shop2020.metamodel.jaxb.core.SlideFeatureDefinitionType;
42 
import in.shop2020.metamodel.jaxb.core.UnitType;
61 naveen 43 
import in.shop2020.metamodel.jaxb.facets.CategoryFacetDefinitionType;
44 
import in.shop2020.metamodel.jaxb.facets.FacetDefinitionType;
57 naveen 45 
import in.shop2020.metamodel.jaxb.facets.IRDefinitionType;
61 naveen 46 
import in.shop2020.metamodel.jaxb.facets.RuleDefinitionType;
64 naveen 47 
import in.shop2020.util.DBUtils;
18 naveen 48 
import in.shop2020.util.Utils;
10 shop2020 49 
 
50 
import java.io.FileInputStream;
16 naveen 51 
import java.util.ArrayList;
10 shop2020 52 
import java.util.HashMap;
53 
import java.util.Iterator;
54 
import java.util.List;
55 
import java.util.Map;
24 naveen 56 
import java.util.TreeMap;
10 shop2020 57 
 
58 
import javax.xml.bind.JAXBContext;
59 
import javax.xml.bind.JAXBElement;
60 
import javax.xml.bind.Unmarshaller;
61 
 
62 
import org.apache.commons.lang.ArrayUtils;
63 
import org.apache.commons.lang.StringUtils;
64 
 
65 
/**
51 naveen 66 
 * Command line utility that imports model properties defined in XML
67 
 *
17 naveen 68 
 * MM - Meta-Model Tool
10 shop2020 69 
 *
51 naveen 70 
 * It can be used to do following things
71 
 *
72 
 * - Import
73 
 * 	 - Datatype definitions
74 
 * 	 - Feature definitions
75 
 * 	 - Slide definitions
76 
 * 	 - Categories
63 naveen 77 
 *   - Facet Definition
78 
 *   - Category Facet Definition
79 
 *   - IR Data Rules
80 
 *   - IR Meta-data Rules
51 naveen 81 
 *
82 
 * - Show
83 
 * 	 - Datatype definitions
84 
 * 	 - Feature definitions
85 
 * 	 - Slide definitions
86 
 * 	 - Categories
63 naveen 87 
 *   - Facet Definition
88 
 *   - Category Facet Definition
89 
 *   - IR Data Rules
90 
 *   - IR Meta-data Rules
51 naveen 91 
 *
92 
 * - Show all definition objects that define a category
93 
 *
94 
 *
10 shop2020 95 
 * @author naveen
96 
 *
97 
 */
98 
public class MM {
34 naveen 99 
 
49 naveen 100 
	/**
101 
	 *
102 
	 */
10 shop2020 103 
	private String definitionSetName;
49 naveen 104 
 
105 
	/**
106 
	 *
107 
	 */
10 shop2020 108 
	private String srcFile;
49 naveen 109 
 
110 
	/**
111 
	 *
112 
	 */
10 shop2020 113 
	private String dbFile;
114 
 
115 
	/**
69 naveen 116 
	 * Usage: MM [show|import|showcategory] [units|datatypedefinitions|
117 
	 * featuredefinitions|slidedefinitions|categories|facetdefinitions|
118 
	 * categoryfacetdefinitions|irdatarules|irmetadatarules|comparisonrules|
70 naveen 119 
	 * comparisondefinitions] {Category ID}
51 naveen 120 
	 *
10 shop2020 121 
	 * @param args
122 
	 */
123 
	public static void main(String[] args) throws Exception {
16 naveen 124 
		String[] definitionSetNames = new String[] {"units",
125 
				"datatypedefinitions", "featuredefinitions", "slidedefinitions",
61 naveen 126 
				"categories", "facetdefinitions", "categoryfacetdefinitions",
69 naveen 127 
				"irdatarules", "irmetadatarules", "comparisonrules",
70 naveen 128 
				"comparisondefinitions"};
10 shop2020 129 
 
45 naveen 130 
		String[] commands = new String[] {"show", "import", "showcategory"};
10 shop2020 131 
 
16 naveen 132 
		String usage = "Usage: MM ["+ StringUtils.join(commands, "|") +"] ["+
45 naveen 133 
			StringUtils.join(definitionSetNames, "|") + "] {Category ID}";
16 naveen 134 
 
10 shop2020 135 
		if(args.length < 2) {
136 
			System.out.println(usage);
137 
			System.exit(-1);
138 
		}
42 naveen 139 
		Utils.info("MM "+ args[0] + " " + args[1]);
17 naveen 140 
 
10 shop2020 141 
		String inputCommand = args[0];
142 
 
143 
		if(!ArrayUtils.contains(commands, inputCommand)) {
144 
			System.out.println(usage);
145 
			System.exit(-1);
146 
		}
147 
 
45 naveen 148 
		if(inputCommand.equals("show") || inputCommand.endsWith("import")) {
149 
			String inputDefinitionSet = args[1];
150 
			if(!ArrayUtils.contains(definitionSetNames, inputDefinitionSet)) {
151 
				System.out.println(usage);
152 
				System.exit(-1);
153 
			}
154 
 
155 
			MM mm = new MM(inputDefinitionSet);
156 
			if(inputCommand.equals("import")) {
157 
				mm.importDefinitionSet();
158 
			}
159 
			else if(inputCommand.equals("show")) {
160 
				mm.showDefinitionSet();
161 
			}
10 shop2020 162 
		}
163 
 
45 naveen 164 
		if(inputCommand.equals("showcategory")) {
165 
			String categoryID = args[1];
166 
			long catID = 0;
167 
			try {
168 
				catID = Long.parseLong(categoryID);
169 
			}
170 
			catch (NumberFormatException nfe) {
171 
				System.out.println("Invalid category ID");
172 
				System.exit(-1);
173 
			}
174 
 
175 
			MM mm = new MM();
176 
			mm.showCategory(catID);
10 shop2020 177 
		}
178 
	}
179 
 
180 
	/**
181 
	 *
45 naveen 182 
	 */
183 
	public MM() {
184 
	}
185 
 
186 
	/**
187 
	 *
10 shop2020 188 
	 * @param definitionSet
189 
	 */
190 
	public MM(String definitionSetName) {
191 
		this.definitionSetName = definitionSetName;
70 naveen 192 
		this.srcFile = Utils.DEFINITIONS_SRC_PATH + this.definitionSetName +
193 
			".xml";
194 
 
195 
		this.dbFile = Utils.DEFINITIONS_DB_PATH + this.definitionSetName +
196 
			".ser";
10 shop2020 197 
	}
198 
 
199 
	/**
200 
	 *
45 naveen 201 
	 * @param categoryID
202 
	 * @throws Exception
10 shop2020 203 
	 */
45 naveen 204 
	public void showCategory(long categoryID) throws Exception {
205 
		DefinitionsContainer defs =
206 
			Catalog.getInstance().getDefinitionsContainer();
207 
 
208 
		ExpandedCategory expCategory = defs.getExpandedCategory(categoryID);
209 
 
210 
		Utils.info(expCategory);
211 
	}
212 
 
213 
	/**
214 
	 *
215 
	 */
10 shop2020 216 
	@SuppressWarnings("unchecked")
217 
	public void importDefinitionSet() throws Exception {
57 naveen 218 
		String type = "core";
219 
		if(this.definitionSetName.equals("facetdefinitions") ||
61 naveen 220 
				this.definitionSetName.equals("categoryfacetdefinitions") ||
221 
				this.definitionSetName.equals("irdatarules") ||
222 
						this.definitionSetName.equals("irmetadatarules")) {
57 naveen 223 
			type = "facets";
224 
		}
69 naveen 225 
		else if(this.definitionSetName.equals("comparisonrules") ||
70 naveen 226 
				this.definitionSetName.equals("comparisondefinitions")){
69 naveen 227 
			type = "comparison";
228 
		}
57 naveen 229 
 
230 
		Object oDefType = this.unmarshallSrcFile(this.srcFile, type);
231 
		DefinitionType defType = null;
232 
		IRDefinitionType irDefType = null;
69 naveen 233 
		CMPDefinitionType cmpDefType = null;
57 naveen 234 
 
235 
		if(type.equals("core")) {
236 
			defType = (DefinitionType)oDefType;
237 
		}
238 
		else if (type.equals("facets")) {
239 
			irDefType = (IRDefinitionType)oDefType;
240 
		}
69 naveen 241 
		else if (type.equals("comparison")) {
242 
			cmpDefType = (CMPDefinitionType)oDefType;
243 
		}
57 naveen 244 
 
16 naveen 245 
		Object objectToStore = null;
10 shop2020 246 
 
57 naveen 247 
		// CORE
248 
 
10 shop2020 249 
		// Units
250 
		if(this.definitionSetName.equals("units")) {
251 
			Map unitsMap = this.convertUnits(defType);
16 naveen 252 
			objectToStore = unitsMap;
10 shop2020 253 
		}
254 
 
255 
		// Categories
256 
		else if(this.definitionSetName.equals("categories")) {
257 
			Map<Long, Category> categoriesMap = new HashMap<Long, Category>();
258 
			Category root = this.convertCategories(defType, categoriesMap);
42 naveen 259 
			//Utils.info(categoriesMap);
260 
			//Utils.info(root);
10 shop2020 261 
			//System.exit(0);
262 
 
263 
			// Tree
70 naveen 264 
			String categoryTreeDBFile = Utils.DEFINITIONS_DB_PATH +
265 
				"categorytree" + ".ser";
16 naveen 266 
 
10 shop2020 267 
			if(root != null) {
17 naveen 268 
				DBUtils.store(root, categoryTreeDBFile);
10 shop2020 269 
			}
270 
 
271 
			// Map
16 naveen 272 
			objectToStore = categoriesMap;
10 shop2020 273 
		}
16 naveen 274 
 
275 
		// Datatype Definitions
276 
		else if(this.definitionSetName.equals("datatypedefinitions")) {
24 naveen 277 
			Map<Long, DatatypeDefinition> datatypeDefsMap =
278 
				this.convertDatatypeDefinition(defType);
16 naveen 279 
 
24 naveen 280 
			// Store enum value id to value map separately
70 naveen 281 
			String enumValueDBFile = Utils.DEFINITIONS_DB_PATH + "enumvalues" +
24 naveen 282 
				".ser";
283 
 
284 
			// RE-VISIT - May not be optimal
285 
			Map<Long, EnumValue> enumValuesMap = new TreeMap<Long, EnumValue>();
286 
			for(Long datatypeDefID : datatypeDefsMap.keySet()) {
287 
				DatatypeDefinition datatypeDef =
288 
					datatypeDefsMap.get(datatypeDefID);
289 
 
290 
				if(datatypeDef instanceof EnumDefinition) {
291 
					List<EnumValue> enumValues =
292 
						((EnumDefinition) datatypeDef).getEnumValues();
293 
 
294 
					for(EnumValue enumValue : enumValues) {
295 
						enumValuesMap.put(new Long(enumValue.getID()),
296 
								enumValue);
297 
					}
298 
				}
299 
			}
42 naveen 300 
			Utils.info("enumValuesMap=" + enumValuesMap);
24 naveen 301 
			DBUtils.store(enumValuesMap, enumValueDBFile);
302 
 
16 naveen 303 
			objectToStore = datatypeDefsMap;
304 
		}
305 
 
306 
		// Feature Definitions
307 
		else if(this.definitionSetName.equals("featuredefinitions")) {
308 
			Map featureDefsMap = this.convertFeatureDefinitions(defType);
309 
 
310 
			objectToStore = featureDefsMap;
311 
		}
312 
 
313 
		// Slide Definitions
314 
		else if(this.definitionSetName.equals("slidedefinitions")) {
315 
			Map slideDefsMap = this.convertSlideDefinitions(defType);
316 
 
317 
			objectToStore = slideDefsMap;
318 
		}
319 
 
57 naveen 320 
		// FACETS
321 
 
322 
		// Facet Definitions
323 
		else if(this.definitionSetName.equals("facetdefinitions")) {
324 
			Map facetDefsMap = this.convertFacetDefinitions(irDefType);
325 
 
326 
			objectToStore = facetDefsMap;
327 
		}
328 
 
329 
 
330 
		// Category Facet Definitions
331 
		else if(this.definitionSetName.equals("categoryfacetdefinitions")) {
332 
			Map categoryFacetDefsMap =
333 
				this.convertCategoryFacetDefinitions(irDefType);
334 
 
335 
			objectToStore = categoryFacetDefsMap;
336 
		}
337 
 
61 naveen 338 
		// IR Data Rules
339 
		else if(this.definitionSetName.equals("irdatarules")) {
340 
			Map irdataRuleDefsMap =
341 
				this.convertRuleDefinitions(irDefType);
342 
 
343 
			objectToStore = irdataRuleDefsMap;
344 
		}
345 
 
346 
		// IR Meta-Data Rules
347 
		else if(this.definitionSetName.equals("irmetadatarules")) {
348 
			Map irmetadataRuleDefsMap =
349 
				this.convertRuleDefinitions(irDefType);
350 
 
351 
			objectToStore = irmetadataRuleDefsMap;
352 
		}
353 
 
69 naveen 354 
		// Comparison Rules
355 
		else if(this.definitionSetName.equals("comparisonrules")) {
356 
			Map comparisonRuleDefsMap =
357 
				this.convertComparisonRuleDefinitions(cmpDefType);
358 
 
359 
			objectToStore = comparisonRuleDefsMap;
360 
		}
361 
 
362 
		// Category Comparison Definitions
70 naveen 363 
		else if(this.definitionSetName.equals("comparisondefinitions")){
69 naveen 364 
			Map categoryCMPDefsMap =
70 naveen 365 
				this.convertComparisonDefinitions(cmpDefType);
69 naveen 366 
 
367 
			objectToStore = categoryCMPDefsMap;
368 
		}
369 
 
16 naveen 370 
		if(objectToStore != null) {
17 naveen 371 
			DBUtils.store(objectToStore, this.dbFile);
16 naveen 372 
		}
10 shop2020 373 
	}
374 
 
375 
	/**
376 
	 *
377 
	 */
378 
	public void showDefinitionSet() throws Exception {
17 naveen 379 
		Object obj = DBUtils.read(this.dbFile);
42 naveen 380 
		Utils.info(obj.toString());
10 shop2020 381 
 
382 
		if(this.definitionSetName.equals("categories")) {
70 naveen 383 
			String categoryTreeDBFile = Utils.DEFINITIONS_DB_PATH +
384 
				"categorytree" + ".ser";
16 naveen 385 
 
17 naveen 386 
			Category root = (Category)DBUtils.read(categoryTreeDBFile);
42 naveen 387 
			Utils.info(root.toString());
388 
			//Utils.info("root.getChildrenCategory().size: " +
18 naveen 389 
			//		root.getChildrenCategory().size());
10 shop2020 390 
		}
391 
	}
392 
 
393 
	/**
394 
	 *
57 naveen 395 
	 * @param defType
396 
	 * @return
397 
	 */
61 naveen 398 
	private Map<Long, RuleDefinition> convertRuleDefinitions(
399 
			IRDefinitionType defType) {
400 
		Map<Long, RuleDefinition> idRuleDef =
401 
			new TreeMap<Long, RuleDefinition>();
402 
 
403 
		List<RuleDefinitionType> jaxbRuleDefs = defType.getRuleDefinition();
404 
 
405 
		for(RuleDefinitionType jaxbRuleDef : jaxbRuleDefs) {
406 
			long id = jaxbRuleDef.getID();
407 
			String script = jaxbRuleDef.getScript();
408 
 
409 
			RuleDefinition ruleDef = new RuleDefinition(id, script);
410 
			ruleDef.setDescription(jaxbRuleDef.getDescription());
411 
 
412 
			idRuleDef.put(new Long(id), ruleDef);
413 
		}
414 
 
415 
		Utils.info("idRuleDef=" + idRuleDef);
416 
		return idRuleDef;
417 
	}
418 
 
419 
	/**
420 
	 *
421 
	 * @param defType
69 naveen 422 
	 * @return Map<Long, CMPRuleDefinition>
423 
	 */
424 
	private Map<Long, CMPRuleDefinition> convertComparisonRuleDefinitions(
425 
			CMPDefinitionType defType) {
426 
		Map<Long, CMPRuleDefinition> idRuleDef =
427 
			new TreeMap<Long, CMPRuleDefinition>();
428 
 
429 
		List<CMPRuleDefinitionType> jaxbRuleDefs =
430 
			defType.getCMPRuleDefinition();
431 
 
432 
		for(CMPRuleDefinitionType jaxbRuleDef : jaxbRuleDefs) {
433 
			long id = jaxbRuleDef.getID();
434 
			String script = jaxbRuleDef.getScript();
435 
 
436 
			CMPRuleDefinition ruleDef = new CMPRuleDefinition(id, script);
437 
			ruleDef.setDescription(jaxbRuleDef.getDescription());
438 
 
439 
			idRuleDef.put(new Long(id), ruleDef);
440 
		}
441 
 
442 
		Utils.info("idRuleDef=" + idRuleDef);
443 
		return idRuleDef;
444 
	}
445 
 
446 
	/**
447 
	 *
448 
	 * @param defType
449 
	 * @return Map<Long, CMPSlideRuleDefinition>
450 
	 */
70 naveen 451 
	private Map<Long, CMPSlideRuleDefinition> convertComparisonDefinitions(
452 
			CMPDefinitionType defType) {
69 naveen 453 
 
70 naveen 454 
		Map<Long, CMPSlideRuleDefinition> slideRuleDefs =
455 
			new TreeMap<Long, CMPSlideRuleDefinition>();
69 naveen 456 
 
70 naveen 457 
		List<CMPSlideRuleDefinitionType> jaxbDefs =
458 
			defType.getCMPSlideRuleDefinition();
459 
 
460 
		for(CMPSlideRuleDefinitionType jaxbDef : jaxbDefs) {
461 
			long ruleDefID = jaxbDef.getRuleDefinitionID();
462 
			long slideDefID = jaxbDef.getSlideDefinitionID();
69 naveen 463 
 
70 naveen 464 
			CMPSlideRuleDefinition slideRuleDef =
465 
				new CMPSlideRuleDefinition(slideDefID, ruleDefID);
69 naveen 466 
 
70 naveen 467 
			slideRuleDef.setDescription(jaxbDef.getDescription());
69 naveen 468 
 
70 naveen 469 
			slideRuleDefs.put(new Long(slideDefID), slideRuleDef);
69 naveen 470 
		}
471 
 
70 naveen 472 
		Utils.info("slideRuleDefs=" + slideRuleDefs);
473 
		return slideRuleDefs;
69 naveen 474 
	}
475 
 
476 
	/**
477 
	 *
478 
	 * @param defType
61 naveen 479 
	 * @return
480 
	 */
57 naveen 481 
	private Map<Long, FacetDefinition> convertFacetDefinitions(
482 
			IRDefinitionType defType) {
61 naveen 483 
		List<FacetDefinitionType> jaxbFacetDefs = defType.getFacetDefinition();
484 
 
485 
		Map<Long, FacetDefinition> idFacetDefs =
486 
			new TreeMap<Long, FacetDefinition>();
487 
 
488 
		for(FacetDefinitionType jaxbFacetDef : jaxbFacetDefs) {
489 
			long id = jaxbFacetDef.getID();
490 
			String target = jaxbFacetDef.getTarget();
491 
 
492 
			FacetDefinition facetDef = new FacetDefinition(id, target);
493 
 
494 
			if(jaxbFacetDef.getFeatureDefinitionID() != null) {
495 
				long featureDefID = jaxbFacetDef.getFeatureDefinitionID();
496 
				facetDef.setFeatureDefinitionID(featureDefID);
497 
			}
498 
 
499 
			if(jaxbFacetDef.getSlideDefinitionID() != null) {
500 
				long slideDefID = jaxbFacetDef.getSlideDefinitionID();
501 
				facetDef.setSlideDefinitionID(slideDefID);
502 
			}
503 
 
62 naveen 504 
			long irDataRuleID = jaxbFacetDef.getIRDataRuleID();
505 
			facetDef.setIrDataRuleID(irDataRuleID);
61 naveen 506 
 
62 naveen 507 
			long irMetaDataRuleID = jaxbFacetDef.getIRMetaDataRuleID();
508 
			facetDef.setIrMetaDataRuleID(irMetaDataRuleID);
509 
 
61 naveen 510 
			facetDef.setDescription(jaxbFacetDef.getDescription());
511 
 
512 
			idFacetDefs.put(new Long(id), facetDef);
513 
		}
514 
		Utils.info("idFacetDefs=" + idFacetDefs);
515 
		return idFacetDefs;
57 naveen 516 
	}
517 
 
518 
	/**
519 
	 *
520 
	 * @param defType
521 
	 * @return
61 naveen 522 
	 * @throws Exception
57 naveen 523 
	 */
524 
	private Map<Long, CategoryFacetDefinition> convertCategoryFacetDefinitions(
61 naveen 525 
			IRDefinitionType defType) throws Exception {
526 
		List<CategoryFacetDefinitionType> jaxbCategoryFacetDefs =
527 
			defType.getCategoryFacetDefinition();
528 
 
529 
		Map<Long, CategoryFacetDefinition> idCategoryFacetDefs =
530 
			new TreeMap<Long, CategoryFacetDefinition>();
531 
 
532 
		for(CategoryFacetDefinitionType jaxbCategoryFacetDef :
533 
			jaxbCategoryFacetDefs) {
534 
			long categoryID = jaxbCategoryFacetDef.getCategoryID();
535 
 
62 naveen 536 
			List<Long> jaxbFacetDefIDs =
537 
				jaxbCategoryFacetDef.getFacetDefinitionID();
61 naveen 538 
 
539 
			CategoryFacetDefinition categoryFacetDef =
540 
				new CategoryFacetDefinition(categoryID);
541 
 
62 naveen 542 
			categoryFacetDef.setFacetDefinitionIDs(jaxbFacetDefIDs);
61 naveen 543 
 
544 
			idCategoryFacetDefs.put(new Long(categoryID), categoryFacetDef);
545 
		}
546 
 
547 
		// Append parent's facets
548 
		// Go only one level for now
549 
		// Categories need to be imported first
550 
		DefinitionsContainer defs =
551 
			Catalog.getInstance().getDefinitionsContainer();
552 
 
553 
		for(Long categoryID : idCategoryFacetDefs.keySet()) {
554 
			Category category = defs.getCategory(categoryID.longValue());
555 
			Category parentCategory = category.getParentCategory();
556 
 
557 
			if(parentCategory != null) {
558 
				long parentCategoryID = parentCategory.getID();
559 
 
560 
				CategoryFacetDefinition parentCategoryFacetDef =
561 
					idCategoryFacetDefs.get(new Long(parentCategoryID));
562 
 
563 
				if(parentCategoryFacetDef != null) {
564 
					List<Long> parentsFacetIDs =
62 naveen 565 
						parentCategoryFacetDef.getFacetDefinitionIDs();
61 naveen 566 
 
567 
					if(parentsFacetIDs != null) {
568 
						CategoryFacetDefinition categoryFacetDef =
569 
							idCategoryFacetDefs.get(categoryID);
570 
 
62 naveen 571 
						categoryFacetDef.appendFacetDefinitionIDs(
572 
								parentsFacetIDs);
61 naveen 573 
					}
574 
				}
575 
			}
576 
		}
577 
 
578 
		Utils.info("idCategoryFacetDefs=" + idCategoryFacetDefs);
579 
		return idCategoryFacetDefs;
57 naveen 580 
	}
581 
 
582 
	/**
583 
	 *
10 shop2020 584 
	 * @return Map
585 
	 */
16 naveen 586 
	private Map<Long, SlideDefinition> convertSlideDefinitions(
587 
			DefinitionType defType) {
588 
 
589 
		Map<Long, SlideDefinition> defs =
590 
			new HashMap<Long, SlideDefinition>();
591 
 
592 
		List<SlideDefinitionType> jaxbDefs = defType.getSlideDefinition();
593 
		Iterator<SlideDefinitionType> itjaxbDefs = jaxbDefs.iterator();
594 
 
595 
		// Slide definitions
596 
		while(itjaxbDefs.hasNext()) {
597 
			SlideDefinitionType jaxbDef = itjaxbDefs.next();
598 
 
42 naveen 599 
			Utils.info("Slide label=" + jaxbDef.getLabel());
16 naveen 600 
			SlideDefinition def = new SlideDefinition(jaxbDef.getID(),
601 
					jaxbDef.getLabel());
602 
			def.setDescription(jaxbDef.getDescription());
603 
 
42 naveen 604 
			// Children Slides
605 
			Utils.info("jaxbDef.getChildSlideID=" + jaxbDef.getChildSlideID());
606 
			def.setChildrenSlideDefinitionIDs(jaxbDef.getChildSlideID());
607 
 
16 naveen 608 
			// Slide Feature Definition
609 
			List<SlideFeatureDefinitionType> jaxbSlideFeatureDefs =
610 
				jaxbDef.getSlideFeatureDefinition();
611 
 
612 
			if(jaxbSlideFeatureDefs != null) {
613 
				def.setSlideFeatureDefinitions((
614 
						this.convertSlideFeatureDefinitions(
615 
								jaxbSlideFeatureDefs)));
616 
			}
42 naveen 617 
			Utils.info("def=" + def);
16 naveen 618 
 
619 
			defs.put(new Long(jaxbDef.getID()), def);
620 
		}
621 
 
622 
		return defs;
623 
	}
624 
 
625 
	/**
626 
	 *
627 
	 * @param jaxbDefs
628 
	 * @return List<SlideFeatureDefinition>
629 
	 */
630 
	private List<SlideFeatureDefinition> convertSlideFeatureDefinitions(
631 
			List<SlideFeatureDefinitionType> jaxbDefs) {
632 
 
633 
		List<SlideFeatureDefinition> defs =
634 
			new ArrayList<SlideFeatureDefinition>();
635 
 
636 
		Iterator<SlideFeatureDefinitionType> itjaxbDefs = jaxbDefs.iterator();
637 
 
638 
		// Slide-feature definitions
639 
		while(itjaxbDefs.hasNext()) {
640 
			SlideFeatureDefinitionType jaxbDef = itjaxbDefs.next();
641 
			SlideFeatureDefinition def = new SlideFeatureDefinition(
642 
					jaxbDef.getFeatureDefinitionID());
643 
 
644 
			def.setEditorialImportance(this.convertEditorialImportance(
645 
					jaxbDef.getEditorialImportance()));
646 
 
647 
			def.setDescription(jaxbDef.getDescription());
648 
 
649 
			defs.add(def);
650 
		}
651 
 
652 
		return defs;
653 
	}
654 
 
655 
	/**
656 
	 *
49 naveen 657 
	 * @param defType
658 
	 * @return
16 naveen 659 
	 */
660 
	private Map<Long, FeatureDefinition> convertFeatureDefinitions(
661 
			DefinitionType defType) {
662 
 
663 
		Map<Long, FeatureDefinition> defs =
664 
			new HashMap<Long, FeatureDefinition>();
665 
 
666 
		List<FeatureDefinitionType> jaxbDefs = defType.getFeatureDefinition();
667 
		Iterator<FeatureDefinitionType> itjaxbDefs = jaxbDefs.iterator();
668 
 
669 
		// Feature definitions
670 
		while(itjaxbDefs.hasNext()) {
671 
			FeatureDefinitionType jaxbDef = itjaxbDefs.next();
672 
 
42 naveen 673 
			//Utils.info("Feature label=" + jaxbDef.getLabel());
16 naveen 674 
			FeatureDefinition def = new FeatureDefinition(jaxbDef.getID(),
675 
					jaxbDef.getLabel());
676 
			def.setAllowsBlank(jaxbDef.isCanbeBlank());
677 
			def.setDescription(jaxbDef.getDescription());
678 
 
679 
			// Bullet Definition
680 
			BulletDefinitionType jaxbBulletDef = jaxbDef.getBulletDefinition();
681 
			if(jaxbBulletDef != null) {
682 
				def.setBulletDefinition(this.convertBulletDefinition(
683 
						jaxbBulletDef));
684 
			}
42 naveen 685 
			Utils.info("def=" + def);
16 naveen 686 
 
687 
			defs.put(new Long(jaxbDef.getID()), def);
688 
		}
689 
 
690 
		return defs;
691 
	}
692 
 
693 
	/**
694 
	 *
695 
	 * @param jaxbDef BulletDefinitionType
696 
	 * @return BulletDefinition
697 
	 */
698 
	private BulletDefinition convertBulletDefinition(
699 
			BulletDefinitionType jaxbDef) {
700 
 
701 
		BulletDefinition def = new BulletDefinition(
702 
				jaxbDef.getDatatypeDefinitionID());
703 
 
704 
		Long unitID = jaxbDef.getUnitID();
705 
		if(unitID != null) {
706 
			def.setUnitID(unitID.longValue());
707 
		}
47 naveen 708 
		Utils.info("jaxbDef.isIsMultivalue=" + jaxbDef.isIsMultivalue());
709 
 
16 naveen 710 
		def.setMultivalue(jaxbDef.isIsMultivalue());
711 
		def.setLearned(jaxbDef.isIsLearned());
712 
		def.setDescription(jaxbDef.getDescription());
713 
 
714 
		return def;
715 
	}
49 naveen 716 
 
16 naveen 717 
	/**
718 
	 *
49 naveen 719 
	 * @param defType
720 
	 * @return
16 naveen 721 
	 */
722 
	private Map<Long, DatatypeDefinition> convertDatatypeDefinition(
723 
			DefinitionType defType) {
724 
 
725 
		Map<Long, DatatypeDefinition> defs =
726 
			new HashMap<Long, DatatypeDefinition>();
727 
 
728 
		List<DatatypeDefinitionType> jaxbDefs = defType.getDatatypeDefinition();
729 
		Iterator<DatatypeDefinitionType> it = jaxbDefs.iterator();
730 
 
731 
		while(it.hasNext()) {
732 
			DatatypeDefinitionType jaxbDef = it.next();
733 
 
734 
			DatatypeDefinition def = null;
735 
			CompositeDefinitionType compositeDefType =
736 
				jaxbDef.getCompositeDefinition();
737 
 
738 
			EnumDefinitionType enumDefType =
739 
				jaxbDef.getEnumDefinition();
740 
 
741 
			// Composite data type
742 
			if(compositeDefType != null) {
743 
				CompositeDefinition compDef = new CompositeDefinition(
20 naveen 744 
						jaxbDef.getID(), jaxbDef.getName(),
745 
						compositeDefType.getSeparator());
16 naveen 746 
 
747 
				List<CompositePartDefinitionType> jaxbPartDefs =
748 
					compositeDefType.getCompositePartDefinition();
749 
 
750 
				Iterator<CompositePartDefinitionType> itPartDefs =
751 
					jaxbPartDefs.iterator();
752 
 
753 
				// Collect parts
754 
				while(itPartDefs.hasNext()) {
755 
					CompositePartDefinitionType jaxbPartDef = itPartDefs.next();
756 
					CompositePartDefinition partDef =
757 
						this.convertCompositePartDefinition(jaxbPartDef);
758 
 
759 
					compDef.addCompositePartDefinition(partDef);
760 
				}
761 
 
762 
				def = compDef;
763 
			}
764 
 
765 
			// Enumerated values
766 
			else if(enumDefType != null) {
767 
				EnumDefinition enumDef = new EnumDefinition(jaxbDef.getID(),
768 
						jaxbDef.getName());
769 
 
770 
				List<EnumValueType> jaxbEnumValues =
771 
					enumDefType.getEnumValue();
772 
 
773 
				Iterator<EnumValueType> itEnumValues =
774 
					jaxbEnumValues.iterator();
775 
 
776 
				// Collect individual value
777 
				while(itEnumValues.hasNext()) {
778 
					EnumValueType jaxbEnumValue = itEnumValues.next();
779 
					EnumValue enumValue =
780 
						this.convertEnumValueDefinition(jaxbEnumValue);
781 
 
782 
					enumDef.addEnumValue(enumValue);
783 
				}
784 
 
785 
				def = enumDef;
786 
			}
787 
 
788 
			// Primitive
789 
			else {
790 
				def = new DatatypeDefinition(jaxbDef.getID(),
791 
						jaxbDef.getName());
792 
			}
793 
 
794 
			def.setDescription(jaxbDef.getDescription());
42 naveen 795 
			Utils.info("def=" + def);
16 naveen 796 
 
797 
			defs.put(new Long(jaxbDef.getID()), def);
798 
		}
799 
 
800 
		return defs;
801 
	}
802 
 
803 
	/**
804 
	 *
805 
	 * @param jaxbEnumValue
806 
	 * @return EnumValue
807 
	 */
808 
	private EnumValue convertEnumValueDefinition(EnumValueType jaxbEnumValue) {
809 
 
810 
		EnumValue enumValue = new EnumValue(jaxbEnumValue.getID(),
811 
				jaxbEnumValue.getValue());
812 
 
813 
		return enumValue;
814 
	}
815 
	/**
816 
	 *
817 
	 * @param jaxbPartDef
818 
	 * @return CompositePartDefinition
819 
	 */
820 
	private CompositePartDefinition convertCompositePartDefinition(
821 
			CompositePartDefinitionType jaxbPartDef) {
822 
 
823 
		CompositePartDefinition partDef = new CompositePartDefinition(
824 
				jaxbPartDef.getLabel(), jaxbPartDef.getDatatypeDefinitionID(),
825 
				jaxbPartDef.getUnitID());
826 
 
827 
		partDef.setDescription(jaxbPartDef.getDescription());
828 
 
829 
		return partDef;
830 
	}
49 naveen 831 
 
16 naveen 832 
	/**
833 
	 *
49 naveen 834 
	 * @param defType
835 
	 * @param catMap
836 
	 * @return
16 naveen 837 
	 */
838 
	private Category convertCategories(DefinitionType defType,
839 
			Map<Long, Category> catMap) {
10 shop2020 840 
 
841 
		List<CategoryType> jaxbCats = defType.getCategory();
842 
		Iterator<CategoryType> it = jaxbCats.iterator();
843 
 
844 
		// Get root category
845 
		CategoryType jaxbCat = it.next();
846 
		if(jaxbCat == null) {
42 naveen 847 
			Utils.info("Invalid file: " + this.srcFile);
10 shop2020 848 
			return null;
849 
		}
850 
 
851 
		Category root = this.convertCategoryType(jaxbCat, null, catMap);
42 naveen 852 
		Utils.info("catMap.get(10002)=" + catMap.get(new Long(10002)));
32 naveen 853 
 
10 shop2020 854 
		return root;
855 
	}
856 
 
857 
	/**
858 
	 *
859 
	 * @param jaxbCat
49 naveen 860 
	 * @param parentCat
861 
	 * @param catMap
862 
	 * @return
10 shop2020 863 
	 */
32 naveen 864 
	@SuppressWarnings("unchecked")
16 naveen 865 
	private Category convertCategoryType(CategoryType jaxbCat,
866 
			Category parentCat, Map<Long, Category> catMap) {
18 naveen 867 
 
10 shop2020 868 
		Category cat = new Category(jaxbCat.getID());
869 
		cat.setLabel(jaxbCat.getName());
870 
		cat.setDescription(jaxbCat.getDescription());
871 
		if(parentCat != null) {
872 
			cat.setParentCategory(parentCat);
32 naveen 873 
 
874 
			// Copy parent's category-slide definitions
875 
			ArrayList<CategorySlideDefinition> parentCSDef =
876 
				(ArrayList<CategorySlideDefinition>)
877 
				parentCat.getCategorySlideDefintions();
878 
 
879 
			if(parentCSDef != null) {
880 
				cat.setCategorySlideDefintions(
881 
					(List<CategorySlideDefinition>) parentCSDef.clone());
882 
			}
10 shop2020 883 
		}
884 
 
885 
		// Category Slide Definition
32 naveen 886 
		List<CategorySlideDefinitionType> jaxbDefs =
887 
			jaxbCat.getCategorySlideDefinition();
888 
 
10 shop2020 889 
		Iterator<CategorySlideDefinitionType> it = jaxbDefs.iterator();
890 
		while(it.hasNext()) {
891 
			CategorySlideDefinitionType jaxbDef = it.next();
32 naveen 892 
			CategorySlideDefinition catSlideDef
893 
			= this.convertCategorySlideDefinitionType(jaxbCat.getID(), jaxbDef);
894 
 
10 shop2020 895 
			cat.addCategorySlideDefintion(catSlideDef);
896 
		}
897 
 
898 
		// Children
899 
		List<CategoryType> jaxbChildren = jaxbCat.getChildCategory();
42 naveen 900 
		//Utils.info("jaxbChildren.size: " + jaxbChildren.size());
10 shop2020 901 
 
902 
		Iterator<CategoryType> itChildren = jaxbChildren.iterator();
903 
		while(itChildren.hasNext()) {
904 
			CategoryType jaxbChildCat = itChildren.next();
32 naveen 905 
			Category childCat = this.convertCategoryType(jaxbChildCat, cat,
906 
					catMap);
10 shop2020 907 
			cat.addChild(childCat);
908 
		}
42 naveen 909 
		//Utils.info("Parent cat: " + cat);
32 naveen 910 
		// DEBUG ONLY
42 naveen 911 
		Utils.info("####### Cat ID: " + cat.getID());
32 naveen 912 
		if(cat.getCategorySlideDefintions() != null) {
913 
			for(CategorySlideDefinition csd : cat.getCategorySlideDefintions()){
42 naveen 914 
				Utils.info("####### SlideDefintionID=" +
32 naveen 915 
						csd.getSlideDefintionID());
916 
			}
917 
		}
918 
 
10 shop2020 919 
		catMap.put(new Long(jaxbCat.getID()), cat);
920 
		return cat;
921 
	}
922 
 
923 
	/**
924 
	 *
49 naveen 925 
	 * @param categoryID
10 shop2020 926 
	 * @param jaxbDef
927 
	 * @return
928 
	 */
16 naveen 929 
	private CategorySlideDefinition convertCategorySlideDefinitionType(
930 
			long categoryID, CategorySlideDefinitionType jaxbDef) {
931 
 
10 shop2020 932 
		CategorySlideDefinition catSlideDef = new CategorySlideDefinition(
32 naveen 933 
				jaxbDef.getSlideDefinitionID());
10 shop2020 934 
 
935 
		catSlideDef.setDescription(jaxbDef.getDescription());
936 
 
937 
		EditorialImportanceType jaxbEdImp = jaxbDef.getEditorialImportance();
938 
		EditorialImportance edImp = this.convertEditorialImportance(jaxbEdImp);
939 
		catSlideDef.setEditorialImportance(edImp);
940 
 
941 
		return catSlideDef;
942 
	}
943 
 
944 
	/**
945 
	 *
946 
	 * @return Map
947 
	 */
948 
	private Map<Long, Unit> convertUnits(DefinitionType defType) {
949 
 
950 
		Map<Long, Unit> allUnits = new HashMap<Long, Unit>();
951 
		List<UnitType> jaxbUnits = defType.getUnit();
952 
		Iterator<UnitType> it = jaxbUnits.iterator();
953 
 
954 
		while(it.hasNext()) {
955 
			UnitType jaxbUnit = it.next();
956 
 
957 
			Unit unit = new Unit(jaxbUnit.getID());
958 
			unit.setDescription(jaxbUnit.getDescription());
959 
			unit.setFullForm(jaxbUnit.getFullform());
960 
			unit.setShortForm(jaxbUnit.getShortform());
42 naveen 961 
			Utils.info("unit=" + unit);
10 shop2020 962 
 
963 
			allUnits.put(new Long(jaxbUnit.getID()), unit);
964 
		}
965 
 
966 
		return allUnits;
967 
	}
49 naveen 968 
 
10 shop2020 969 
	/**
970 
	 *
49 naveen 971 
	 * @param srcFile
972 
	 * @return
973 
	 * @throws Exception
10 shop2020 974 
	 */
57 naveen 975 
	private Object unmarshallSrcFile(String srcFile, String type)
976 
		throws Exception {
10 shop2020 977 
 
57 naveen 978 
        JAXBContext jc = JAXBContext.newInstance("in.shop2020.metamodel.jaxb." +
979 
        		type);
10 shop2020 980 
 
981 
        // create an Unmarshaller
982 
        Unmarshaller u = jc.createUnmarshaller();
983 
 
16 naveen 984 
        JAXBElement<?> element = (JAXBElement<?>)u.unmarshal(
985 
        		new FileInputStream(srcFile));
10 shop2020 986 
 
57 naveen 987 
        return element.getValue();
10 shop2020 988 
	}
989 
 
990 
	/**
991 
	 *
16 naveen 992 
	 * @param jaxbEdImp
993 
	 * @return EditorialImportance
994 
	 */
995 
	private EditorialImportance convertEditorialImportance(
996 
			EditorialImportanceType jaxbEdImp) {
997 
 
998 
		String strEdImp = jaxbEdImp.value();
999 
		EditorialImportance edImp = null;
1000 
 
1001 
		if(strEdImp.equals("Mandatory"))
1002 
			edImp = EditorialImportance.MANDATORY;
1003 
		else if(strEdImp.equals("Optional"))
1004 
			edImp = EditorialImportance.OPTIONAL;
1005 
		else
1006 
			edImp = EditorialImportance.RECOMMENDED;
1007 
 
1008 
		return edImp;
1009 
	}
10 shop2020 1010 
}