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;
1050 rajveer 14 
import in.shop2020.metamodel.definitions.CompositeDefinition;
16 naveen 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;
1314 rajveer 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 
 
1050 rajveer 213 
		this.dbFile = Utils.CONTENT_DB_PATH + "definitions" + File.separator + this.definitionSetName + ".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
457 rajveer 283 
			String categoryTreeDBFile = Utils.CONTENT_DB_PATH + "definitions" + File.separator +
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
457 rajveer 300 
			String enumValueDBFile = Utils.CONTENT_DB_PATH + "definitions" + File.separator  + "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")) {
1314 rajveer 351 
			//Map facetDefsMap = this.convertFacetDefinitions(irDefType);
57 naveen 352 
 
1314 rajveer 353 
			//objectToStore = facetDefsMap;
57 naveen 354 
		}
355 
 
356 
 
357 
		// Category Facet Definitions
358 
		else if(this.definitionSetName.equals("categoryfacetdefinitions")) {
1314 rajveer 359 
			//Map categoryFacetDefsMap =
360 
				//this.convertCategoryFacetDefinitions(irDefType);
57 naveen 361 
 
1314 rajveer 362 
			//objectToStore = categoryFacetDefsMap;
57 naveen 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")) {
457 rajveer 477 
			String categoryTreeDBFile = Utils.CONTENT_DB_PATH + "definitions" + File.separator +
70 naveen 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 
	 */
1314 rajveer 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 
	}
1314 rajveer 650 
	*/
57 naveen 651 
	/**
652 
	 *
653 
	 * @param defType
654 
	 * @return
61 naveen 655 
	 * @throws Exception
57 naveen 656 
	 */
1314 rajveer 657 
	/*
57 naveen 658 
	private Map<Long, CategoryFacetDefinition> convertCategoryFacetDefinitions(
61 naveen 659 
			IRDefinitionType defType) throws Exception {
660 
		List<CategoryFacetDefinitionType> jaxbCategoryFacetDefs =
661 
			defType.getCategoryFacetDefinition();
662 
 
663 
		Map<Long, CategoryFacetDefinition> idCategoryFacetDefs =
664 
			new TreeMap<Long, CategoryFacetDefinition>();
665 
 
666 
		for(CategoryFacetDefinitionType jaxbCategoryFacetDef :
667 
			jaxbCategoryFacetDefs) {
668 
			long categoryID = jaxbCategoryFacetDef.getCategoryID();
669 
 
670 
			CategoryFacetDefinition categoryFacetDef =
671 
				new CategoryFacetDefinition(categoryID);
672 
 
81 naveen 673 
			List<FacetRuleDefinitionType> jaxbFacetRuleDefs =
674 
					jaxbCategoryFacetDef.getFacetRuleDefinition();
61 naveen 675 
 
81 naveen 676 
			for(FacetRuleDefinitionType jaxbFacetRuleDef : jaxbFacetRuleDefs) {
677 
 
678 
				FacetRuleDefinition facetRuleDef =
679 
					this.convertFacetRuleDefinition(jaxbFacetRuleDef);
680 
 
681 
				categoryFacetDef.addFacetRuleDefinition(facetRuleDef);
682 
			}
683 
 
61 naveen 684 
			idCategoryFacetDefs.put(new Long(categoryID), categoryFacetDef);
685 
		}
686 
 
687 
		// Append parent's facets
688 
		// Go only one level for now
689 
		// Categories need to be imported first
690 
		DefinitionsContainer defs =
691 
			Catalog.getInstance().getDefinitionsContainer();
692 
 
693 
		for(Long categoryID : idCategoryFacetDefs.keySet()) {
694 
			Category category = defs.getCategory(categoryID.longValue());
695 
			Category parentCategory = category.getParentCategory();
696 
 
697 
			if(parentCategory != null) {
698 
				long parentCategoryID = parentCategory.getID();
699 
 
700 
				CategoryFacetDefinition parentCategoryFacetDef =
701 
					idCategoryFacetDefs.get(new Long(parentCategoryID));
702 
 
703 
				if(parentCategoryFacetDef != null) {
81 naveen 704 
					List<FacetRuleDefinition> parentsFacetRuleDefs =
705 
						parentCategoryFacetDef.getFacetRuleDefinitions();
61 naveen 706 
 
81 naveen 707 
					if(parentsFacetRuleDefs != null) {
61 naveen 708 
						CategoryFacetDefinition categoryFacetDef =
709 
							idCategoryFacetDefs.get(categoryID);
710 
 
81 naveen 711 
						categoryFacetDef.appendFacetRuleDefinitions(
712 
								parentsFacetRuleDefs);
61 naveen 713 
					}
714 
				}
715 
			}
716 
		}
717 
 
718 
		Utils.info("idCategoryFacetDefs=" + idCategoryFacetDefs);
719 
		return idCategoryFacetDefs;
57 naveen 720 
	}
1314 rajveer 721 
	*/
57 naveen 722 
	/**
723 
	 *
81 naveen 724 
	 * @param jaxbFacetRuleDef
725 
	 * @return
726 
	 */
1314 rajveer 727 
	/*
81 naveen 728 
	private FacetRuleDefinition convertFacetRuleDefinition(
729 
			FacetRuleDefinitionType jaxbFacetRuleDef) {
730 
		long facetDefID = jaxbFacetRuleDef.getFacetDefinitionID();
731 
		long irDataRuleID = jaxbFacetRuleDef.getIRDataRuleID();
732 
 
733 
		FacetRuleDefinition facetRuleDef = new FacetRuleDefinition(facetDefID,
734 
				irDataRuleID);
735 
 
736 
		facetRuleDef.setDescription(jaxbFacetRuleDef.getDescription());
737 
 
738 
		if(jaxbFacetRuleDef.getFeatureDefinitionID() != null) {
739 
			facetRuleDef.setFeatureDefinitionID(
740 
					jaxbFacetRuleDef.getFeatureDefinitionID().longValue());
741 
		}
742 
 
743 
		if(jaxbFacetRuleDef.getSlideDefinitionID() != null) {
744 
			facetRuleDef.setSlideDefinitionID(
745 
					jaxbFacetRuleDef.getSlideDefinitionID().longValue());
746 
		}
747 
 
748 
		return facetRuleDef;
749 
	}
1314 rajveer 750 
*/
81 naveen 751 
	/**
752 
	 *
10 shop2020 753 
	 * @return Map
754 
	 */
16 naveen 755 
	private Map<Long, SlideDefinition> convertSlideDefinitions(
756 
			DefinitionType defType) {
757 
 
758 
		Map<Long, SlideDefinition> defs =
759 
			new HashMap<Long, SlideDefinition>();
760 
 
761 
		List<SlideDefinitionType> jaxbDefs = defType.getSlideDefinition();
762 
		Iterator<SlideDefinitionType> itjaxbDefs = jaxbDefs.iterator();
763 
 
764 
		// Slide definitions
765 
		while(itjaxbDefs.hasNext()) {
766 
			SlideDefinitionType jaxbDef = itjaxbDefs.next();
767 
 
42 naveen 768 
			Utils.info("Slide label=" + jaxbDef.getLabel());
16 naveen 769 
			SlideDefinition def = new SlideDefinition(jaxbDef.getID(),
770 
					jaxbDef.getLabel());
771 
			def.setDescription(jaxbDef.getDescription());
772 
 
42 naveen 773 
			// Children Slides
774 
			Utils.info("jaxbDef.getChildSlideID=" + jaxbDef.getChildSlideID());
775 
			def.setChildrenSlideDefinitionIDs(jaxbDef.getChildSlideID());
776 
 
16 naveen 777 
			// Slide Feature Definition
778 
			List<SlideFeatureDefinitionType> jaxbSlideFeatureDefs =
779 
				jaxbDef.getSlideFeatureDefinition();
780 
 
781 
			if(jaxbSlideFeatureDefs != null) {
782 
				def.setSlideFeatureDefinitions((
783 
						this.convertSlideFeatureDefinitions(
784 
								jaxbSlideFeatureDefs)));
785 
			}
42 naveen 786 
			Utils.info("def=" + def);
16 naveen 787 
 
788 
			defs.put(new Long(jaxbDef.getID()), def);
789 
		}
790 
 
791 
		return defs;
792 
	}
793 
 
794 
	/**
795 
	 *
796 
	 * @param jaxbDefs
797 
	 * @return List<SlideFeatureDefinition>
798 
	 */
799 
	private List<SlideFeatureDefinition> convertSlideFeatureDefinitions(
800 
			List<SlideFeatureDefinitionType> jaxbDefs) {
801 
 
802 
		List<SlideFeatureDefinition> defs =
803 
			new ArrayList<SlideFeatureDefinition>();
804 
 
805 
		Iterator<SlideFeatureDefinitionType> itjaxbDefs = jaxbDefs.iterator();
806 
 
807 
		// Slide-feature definitions
808 
		while(itjaxbDefs.hasNext()) {
809 
			SlideFeatureDefinitionType jaxbDef = itjaxbDefs.next();
810 
			SlideFeatureDefinition def = new SlideFeatureDefinition(
811 
					jaxbDef.getFeatureDefinitionID());
812 
 
813 
			def.setEditorialImportance(this.convertEditorialImportance(
814 
					jaxbDef.getEditorialImportance()));
815 
 
816 
			def.setDescription(jaxbDef.getDescription());
817 
 
818 
			defs.add(def);
819 
		}
820 
 
821 
		return defs;
822 
	}
823 
 
824 
	/**
825 
	 *
49 naveen 826 
	 * @param defType
827 
	 * @return
16 naveen 828 
	 */
829 
	private Map<Long, FeatureDefinition> convertFeatureDefinitions(
830 
			DefinitionType defType) {
831 
 
832 
		Map<Long, FeatureDefinition> defs =
833 
			new HashMap<Long, FeatureDefinition>();
834 
 
835 
		List<FeatureDefinitionType> jaxbDefs = defType.getFeatureDefinition();
836 
		Iterator<FeatureDefinitionType> itjaxbDefs = jaxbDefs.iterator();
837 
 
838 
		// Feature definitions
839 
		while(itjaxbDefs.hasNext()) {
840 
			FeatureDefinitionType jaxbDef = itjaxbDefs.next();
841 
 
42 naveen 842 
			//Utils.info("Feature label=" + jaxbDef.getLabel());
16 naveen 843 
			FeatureDefinition def = new FeatureDefinition(jaxbDef.getID(),
844 
					jaxbDef.getLabel());
845 
			def.setAllowsBlank(jaxbDef.isCanbeBlank());
846 
			def.setDescription(jaxbDef.getDescription());
847 
 
848 
			// Bullet Definition
849 
			BulletDefinitionType jaxbBulletDef = jaxbDef.getBulletDefinition();
850 
			if(jaxbBulletDef != null) {
851 
				def.setBulletDefinition(this.convertBulletDefinition(
852 
						jaxbBulletDef));
853 
			}
102 naveen 854 
 
855 
			Long normRuleDefID = jaxbDef.getNormalizationRuleDefinitionID();
856 
			if(normRuleDefID != null) {
857 
				def.setNormalizationRuleDefinitionID(normRuleDefID.longValue());
858 
			}
42 naveen 859 
			Utils.info("def=" + def);
16 naveen 860 
 
861 
			defs.put(new Long(jaxbDef.getID()), def);
862 
		}
863 
 
864 
		return defs;
865 
	}
866 
 
867 
	/**
868 
	 *
869 
	 * @param jaxbDef BulletDefinitionType
870 
	 * @return BulletDefinition
871 
	 */
872 
	private BulletDefinition convertBulletDefinition(
873 
			BulletDefinitionType jaxbDef) {
874 
 
875 
		BulletDefinition def = new BulletDefinition(
876 
				jaxbDef.getDatatypeDefinitionID());
877 
 
99 naveen 878 
		List<Long> unitIDs = jaxbDef.getUnitID();
879 
		if(unitIDs != null && !unitIDs.isEmpty()) {
880 
			def.setUnitIDs(unitIDs);
16 naveen 881 
		}
47 naveen 882 
		Utils.info("jaxbDef.isIsMultivalue=" + jaxbDef.isIsMultivalue());
883 
 
16 naveen 884 
		def.setMultivalue(jaxbDef.isIsMultivalue());
885 
		def.setLearned(jaxbDef.isIsLearned());
886 
		def.setDescription(jaxbDef.getDescription());
887 
 
888 
		return def;
889 
	}
49 naveen 890 
 
16 naveen 891 
	/**
892 
	 *
49 naveen 893 
	 * @param defType
894 
	 * @return
16 naveen 895 
	 */
896 
	private Map<Long, DatatypeDefinition> convertDatatypeDefinition(
897 
			DefinitionType defType) {
898 
 
899 
		Map<Long, DatatypeDefinition> defs =
900 
			new HashMap<Long, DatatypeDefinition>();
901 
 
902 
		List<DatatypeDefinitionType> jaxbDefs = defType.getDatatypeDefinition();
903 
		Iterator<DatatypeDefinitionType> it = jaxbDefs.iterator();
904 
 
905 
		while(it.hasNext()) {
906 
			DatatypeDefinitionType jaxbDef = it.next();
907 
 
908 
			DatatypeDefinition def = null;
909 
			CompositeDefinitionType compositeDefType =
910 
				jaxbDef.getCompositeDefinition();
911 
 
912 
			EnumDefinitionType enumDefType =
913 
				jaxbDef.getEnumDefinition();
914 
 
915 
			// Composite data type
916 
			if(compositeDefType != null) {
917 
				CompositeDefinition compDef = new CompositeDefinition(
20 naveen 918 
						jaxbDef.getID(), jaxbDef.getName(),
919 
						compositeDefType.getSeparator());
16 naveen 920 
 
921 
				List<CompositePartDefinitionType> jaxbPartDefs =
922 
					compositeDefType.getCompositePartDefinition();
923 
 
924 
				Iterator<CompositePartDefinitionType> itPartDefs =
925 
					jaxbPartDefs.iterator();
926 
 
927 
				// Collect parts
928 
				while(itPartDefs.hasNext()) {
929 
					CompositePartDefinitionType jaxbPartDef = itPartDefs.next();
930 
					CompositePartDefinition partDef =
931 
						this.convertCompositePartDefinition(jaxbPartDef);
932 
 
933 
					compDef.addCompositePartDefinition(partDef);
934 
				}
935 
 
936 
				def = compDef;
937 
			}
938 
 
939 
			// Enumerated values
940 
			else if(enumDefType != null) {
941 
				EnumDefinition enumDef = new EnumDefinition(jaxbDef.getID(),
942 
						jaxbDef.getName());
943 
 
944 
				List<EnumValueType> jaxbEnumValues =
945 
					enumDefType.getEnumValue();
946 
 
947 
				Iterator<EnumValueType> itEnumValues =
948 
					jaxbEnumValues.iterator();
949 
 
950 
				// Collect individual value
951 
				while(itEnumValues.hasNext()) {
952 
					EnumValueType jaxbEnumValue = itEnumValues.next();
953 
					EnumValue enumValue =
954 
						this.convertEnumValueDefinition(jaxbEnumValue);
955 
 
956 
					enumDef.addEnumValue(enumValue);
957 
				}
958 
 
959 
				def = enumDef;
960 
			}
961 
 
962 
			// Primitive
963 
			else {
964 
				def = new DatatypeDefinition(jaxbDef.getID(),
965 
						jaxbDef.getName());
966 
			}
967 
 
968 
			def.setDescription(jaxbDef.getDescription());
42 naveen 969 
			Utils.info("def=" + def);
16 naveen 970 
 
971 
			defs.put(new Long(jaxbDef.getID()), def);
972 
		}
973 
 
974 
		return defs;
975 
	}
976 
 
977 
	/**
978 
	 *
979 
	 * @param jaxbEnumValue
980 
	 * @return EnumValue
981 
	 */
982 
	private EnumValue convertEnumValueDefinition(EnumValueType jaxbEnumValue) {
983 
 
984 
		EnumValue enumValue = new EnumValue(jaxbEnumValue.getID(),
985 
				jaxbEnumValue.getValue());
986 
 
987 
		return enumValue;
988 
	}
989 
	/**
990 
	 *
991 
	 * @param jaxbPartDef
992 
	 * @return CompositePartDefinition
993 
	 */
994 
	private CompositePartDefinition convertCompositePartDefinition(
995 
			CompositePartDefinitionType jaxbPartDef) {
996 
 
997 
		CompositePartDefinition partDef = new CompositePartDefinition(
998 
				jaxbPartDef.getLabel(), jaxbPartDef.getDatatypeDefinitionID(),
999 
				jaxbPartDef.getUnitID());
1000 
 
1001 
		partDef.setDescription(jaxbPartDef.getDescription());
1002 
 
1003 
		return partDef;
1004 
	}
49 naveen 1005 
 
16 naveen 1006 
	/**
1007 
	 *
49 naveen 1008 
	 * @param defType
1009 
	 * @param catMap
1010 
	 * @return
16 naveen 1011 
	 */
1012 
	private Category convertCategories(DefinitionType defType,
1013 
			Map<Long, Category> catMap) {
10 shop2020 1014 
 
1015 
		List<CategoryType> jaxbCats = defType.getCategory();
1016 
		Iterator<CategoryType> it = jaxbCats.iterator();
1017 
 
1018 
		// Get root category
1019 
		CategoryType jaxbCat = it.next();
1020 
		if(jaxbCat == null) {
42 naveen 1021 
			Utils.info("Invalid file: " + this.srcFile);
10 shop2020 1022 
			return null;
1023 
		}
1024 
 
1025 
		Category root = this.convertCategoryType(jaxbCat, null, catMap);
42 naveen 1026 
		Utils.info("catMap.get(10002)=" + catMap.get(new Long(10002)));
32 naveen 1027 
 
10 shop2020 1028 
		return root;
1029 
	}
1030 
 
1031 
	/**
1032 
	 *
1033 
	 * @param jaxbCat
49 naveen 1034 
	 * @param parentCat
1035 
	 * @param catMap
1036 
	 * @return
10 shop2020 1037 
	 */
32 naveen 1038 
	@SuppressWarnings("unchecked")
16 naveen 1039 
	private Category convertCategoryType(CategoryType jaxbCat,
1040 
			Category parentCat, Map<Long, Category> catMap) {
18 naveen 1041 
 
10 shop2020 1042 
		Category cat = new Category(jaxbCat.getID());
1043 
		cat.setLabel(jaxbCat.getName());
1044 
		cat.setDescription(jaxbCat.getDescription());
1045 
		if(parentCat != null) {
1046 
			cat.setParentCategory(parentCat);
32 naveen 1047 
 
1048 
			// Copy parent's category-slide definitions
1049 
			ArrayList<CategorySlideDefinition> parentCSDef =
1050 
				(ArrayList<CategorySlideDefinition>)
1051 
				parentCat.getCategorySlideDefintions();
1052 
 
1053 
			if(parentCSDef != null) {
1054 
				cat.setCategorySlideDefintions(
1055 
					(List<CategorySlideDefinition>) parentCSDef.clone());
1056 
			}
10 shop2020 1057 
		}
1058 
 
1059 
		// Category Slide Definition
32 naveen 1060 
		List<CategorySlideDefinitionType> jaxbDefs =
1061 
			jaxbCat.getCategorySlideDefinition();
1062 
 
10 shop2020 1063 
		Iterator<CategorySlideDefinitionType> it = jaxbDefs.iterator();
1064 
		while(it.hasNext()) {
1065 
			CategorySlideDefinitionType jaxbDef = it.next();
32 naveen 1066 
			CategorySlideDefinition catSlideDef
1067 
			= this.convertCategorySlideDefinitionType(jaxbCat.getID(), jaxbDef);
1068 
 
10 shop2020 1069 
			cat.addCategorySlideDefintion(catSlideDef);
1070 
		}
1071 
 
1072 
		// Children
1073 
		List<CategoryType> jaxbChildren = jaxbCat.getChildCategory();
42 naveen 1074 
		//Utils.info("jaxbChildren.size: " + jaxbChildren.size());
10 shop2020 1075 
 
1076 
		Iterator<CategoryType> itChildren = jaxbChildren.iterator();
1077 
		while(itChildren.hasNext()) {
1078 
			CategoryType jaxbChildCat = itChildren.next();
32 naveen 1079 
			Category childCat = this.convertCategoryType(jaxbChildCat, cat,
1080 
					catMap);
10 shop2020 1081 
			cat.addChild(childCat);
1082 
		}
42 naveen 1083 
		//Utils.info("Parent cat: " + cat);
32 naveen 1084 
		// DEBUG ONLY
42 naveen 1085 
		Utils.info("####### Cat ID: " + cat.getID());
32 naveen 1086 
		if(cat.getCategorySlideDefintions() != null) {
1087 
			for(CategorySlideDefinition csd : cat.getCategorySlideDefintions()){
42 naveen 1088 
				Utils.info("####### SlideDefintionID=" +
32 naveen 1089 
						csd.getSlideDefintionID());
1090 
			}
1091 
		}
1092 
 
10 shop2020 1093 
		catMap.put(new Long(jaxbCat.getID()), cat);
1094 
		return cat;
1095 
	}
1096 
 
1097 
	/**
1098 
	 *
49 naveen 1099 
	 * @param categoryID
10 shop2020 1100 
	 * @param jaxbDef
1101 
	 * @return
1102 
	 */
16 naveen 1103 
	private CategorySlideDefinition convertCategorySlideDefinitionType(
1104 
			long categoryID, CategorySlideDefinitionType jaxbDef) {
1105 
 
10 shop2020 1106 
		CategorySlideDefinition catSlideDef = new CategorySlideDefinition(
32 naveen 1107 
				jaxbDef.getSlideDefinitionID());
10 shop2020 1108 
 
1109 
		catSlideDef.setDescription(jaxbDef.getDescription());
1110 
 
1111 
		EditorialImportanceType jaxbEdImp = jaxbDef.getEditorialImportance();
1112 
		EditorialImportance edImp = this.convertEditorialImportance(jaxbEdImp);
1113 
		catSlideDef.setEditorialImportance(edImp);
1114 
 
1115 
		return catSlideDef;
1116 
	}
1117 
 
1118 
	/**
1119 
	 *
1120 
	 * @return Map
1121 
	 */
1122 
	private Map<Long, Unit> convertUnits(DefinitionType defType) {
1123 
 
1124 
		Map<Long, Unit> allUnits = new HashMap<Long, Unit>();
1125 
		List<UnitType> jaxbUnits = defType.getUnit();
1126 
		Iterator<UnitType> it = jaxbUnits.iterator();
1127 
 
1128 
		while(it.hasNext()) {
1129 
			UnitType jaxbUnit = it.next();
1130 
 
1131 
			Unit unit = new Unit(jaxbUnit.getID());
1132 
			unit.setDescription(jaxbUnit.getDescription());
1133 
			unit.setFullForm(jaxbUnit.getFullform());
1134 
			unit.setShortForm(jaxbUnit.getShortform());
42 naveen 1135 
			Utils.info("unit=" + unit);
10 shop2020 1136 
 
1137 
			allUnits.put(new Long(jaxbUnit.getID()), unit);
1138 
		}
1139 
 
1140 
		return allUnits;
1141 
	}
49 naveen 1142 
 
10 shop2020 1143 
	/**
1144 
	 *
49 naveen 1145 
	 * @param srcFile
1146 
	 * @return
1147 
	 * @throws Exception
10 shop2020 1148 
	 */
57 naveen 1149 
	private Object unmarshallSrcFile(String srcFile, String type)
1150 
		throws Exception {
10 shop2020 1151 
 
57 naveen 1152 
        JAXBContext jc = JAXBContext.newInstance("in.shop2020.metamodel.jaxb." +
1153 
        		type);
10 shop2020 1154 
 
1155 
        // create an Unmarshaller
1156 
        Unmarshaller u = jc.createUnmarshaller();
1157 
 
16 naveen 1158 
        JAXBElement<?> element = (JAXBElement<?>)u.unmarshal(
1159 
        		new FileInputStream(srcFile));
10 shop2020 1160 
 
57 naveen 1161 
        return element.getValue();
10 shop2020 1162 
	}
1163 
 
1164 
	/**
1165 
	 *
16 naveen 1166 
	 * @param jaxbEdImp
1167 
	 * @return EditorialImportance
1168 
	 */
1169 
	private EditorialImportance convertEditorialImportance(
1170 
			EditorialImportanceType jaxbEdImp) {
1171 
 
1172 
		String strEdImp = jaxbEdImp.value();
1173 
		EditorialImportance edImp = null;
1174 
 
1175 
		if(strEdImp.equals("Mandatory"))
1176 
			edImp = EditorialImportance.MANDATORY;
1177 
		else if(strEdImp.equals("Optional"))
1178 
			edImp = EditorialImportance.OPTIONAL;
1179 
		else
1180 
			edImp = EditorialImportance.RECOMMENDED;
1181 
 
1182 
		return edImp;
1183 
	}
10 shop2020 1184 
}