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