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