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