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