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