Subversion Repositories SmartDukaan

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
10 shop2020 1 
/**
2 
 *
3 
 */
4 
package in.shop2020.metamodel.definitions;
5 
 
70 naveen 6 
import in.shop2020.metamodel.util.ExpandedCMPSlideRuleDefinition;
45 naveen 7 
import in.shop2020.metamodel.util.ExpandedCategory;
62 naveen 8 
import in.shop2020.metamodel.util.ExpandedCategoryFacetDefinition;
9 
import in.shop2020.metamodel.util.ExpandedFacetDefinition;
199 naveen 10 
import in.shop2020.metamodel.util.ExpandedSlideDefinition;
64 naveen 11 
import in.shop2020.util.DBUtils;
70 naveen 12 
import in.shop2020.util.Utils;
17 naveen 13 
 
10 shop2020 14 
import java.io.Serializable;
18 naveen 15 
import java.util.ArrayList;
16 
import java.util.Iterator;
17 
import java.util.List;
10 shop2020 18 
import java.util.Map;
19 
 
20 
/**
49 naveen 21 
 * Single point of access to all definition objects
22 
 *
10 shop2020 23 
 * @author naveen
24 
 *
25 
 */
26 
public class DefinitionsContainer implements Serializable {
27 
 
41 naveen 28 
	/**
10 shop2020 29 
	 *
30 
	 */
31 
	private static final long serialVersionUID = 1L;
49 naveen 32 
 
33 
	/**
34 
	 * Hashtable of Category ID to Category object
35 
	 */
10 shop2020 36 
	private Map<Long, Category> categories;
49 naveen 37 
 
38 
	/**
39 
	 * Hashtable of Slide ID to SlideDefinition object
40 
	 */
10 shop2020 41 
	private Map<Long, SlideDefinition> slideDefinitions;
49 naveen 42 
 
43 
	/**
44 
	 * Hashtable of Feature Definition ID to FeatureDefinition object
45 
	 */
10 shop2020 46 
	private Map<Long, FeatureDefinition> featureDefinitions;
49 naveen 47 
 
48 
	/**
49 
	 * Hashtable of Datatype Definition ID to DatatypeDefinition object
50 
	 */
10 shop2020 51 
	private Map<Long, DatatypeDefinition> datatypeDefinitions;
49 naveen 52 
 
53 
	/**
54 
	 * Hashtable of Enum value ID to EnumValue object
55 
	 */
24 naveen 56 
	private Map<Long, EnumValue> enumValues;
49 naveen 57 
 
58 
	/**
59 
	 * Hashtable of Unit ID to Unit object
60 
	 */
10 shop2020 61 
	private Map<Long, Unit> units;
62 
 
63 
	/**
62 naveen 64 
	 * Hashtable of Facet Definition ID to FacetDefinition object
65 
	 */
66 
	private Map<Long, FacetDefinition> facetDefinitions;
67 
 
68 
	/**
69 
	 * Hashtable of Category Facet Definition ID to CategoryFacetDefinition
70 
	 * object
71 
	 */
72 
	private Map<Long, CategoryFacetDefinition> categoryFacetDefinitions;
73 
 
74 
	/**
75 
	 * Hashtable of IR Data Rule ID to RuleDefinition object
76 
	 */
77 
	private Map<Long, RuleDefinition> irDataRuleDefinitions;
78 
 
79 
	/**
80 
	 * Hashtable of IR Meta Data Rule ID to RuleDefinition object
81 
	 */
82 
	private Map<Long, RuleDefinition> irMetaDataRuleDefinitions;
83 
 
84 
 
85 
	/**
70 naveen 86 
	 * Hashtable of Comparison Rule ID to CMPRuleDefinition object
87 
	 */
88 
	private Map<Long, CMPRuleDefinition> cmpRuleDefinitions;
89 
 
90 
	/**
91 
	 * Hashtable of SlideDefinition ID to CMPSlideRuleDefinition object
92 
	 */
93 
	private Map<Long, CMPSlideRuleDefinition> cmpSlideRuleDefinitions;
94 
 
95 
	/**
72 naveen 96 
	 * Hashtable of Category ID to list of CMPBucketDefinition object
97 
	 */
98 
	private Map<Long, List<CMPBucketDefinition>> cmpBucketDefinitions;
102 naveen 99 
 
100 
	/**
101 
	 * Hashtable of feature definition ID to normalization rule definition ID
102 
	 */
103 
	private Map<Long, RuleDefinition> normalizationRuleDefinitions;
199 naveen 104 
 
105 
	/**
106 
	 * Hashtable of feature definition ID to normalization rule definition ID
107 
	 */
108 
	private Map<Long, List<Long>> categorySlideSequence;
72 naveen 109 
 
110 
	/**
49 naveen 111 
	 * Empty constructor. Data structures are initialised as needed
10 shop2020 112 
	 */
113 
	public DefinitionsContainer() {
17 naveen 114 
		// Lazy initialization
10 shop2020 115 
	}
116 
 
117 
	/**
199 naveen 118 
	 * Returns Slide sequence for a category in the database
119 
	 *
120 
	 * @return Map Null if Category-Slide definitions are not imported into
121 
	 * definitions db
122 
	 * (serialized java objects)
123 
	 *
124 
	 * @throws Exception
125 
	 */
126 
	@SuppressWarnings("unchecked")
127 
	public Map<Long, List<Long>> getCategorySlideSequence() throws Exception {
128 
		// De-serialize
129 
		if(this.categorySlideSequence == null) {
130 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "categoryslidesequence"+
131 
				".ser";
132 
 
133 
			this.categorySlideSequence = (Map<Long, List<Long>>)
134 
				DBUtils.read(dbFile);
135 
		}
136 
 
137 
		return this.categorySlideSequence;
138 
	}
139 
 
140 
	/**
141 
	 * Given a category ID, returns all slide definition IDs in sequence
142 
	 * provided by content editor
143 
	 *
144 
	 * @param categoryID
145 
	 * @return List of Slide Definition IDs
146 
	 * @throws Exception
147 
	 */
148 
	public List<Long> getCategorySlideSequence(long categoryID)
149 
		throws Exception {
150 
		this.getCategorySlideSequence();
151 
 
152 
		return this.categorySlideSequence.get(new Long(categoryID));
153 
	}
154 
 
155 
	/**
49 naveen 156 
	 * Returns all Unit objects in the database
10 shop2020 157 
	 *
49 naveen 158 
	 * @return Map Null if units are not imported into definitions db
159 
	 * (serialized java objects)
160 
	 *
18 naveen 161 
	 * @throws Exception
10 shop2020 162 
	 */
18 naveen 163 
	@SuppressWarnings("unchecked")
164 
	public Map<Long, Unit> getUnits() throws Exception {
17 naveen 165 
		// De-serialize
166 
		if(this.units == null) {
70 naveen 167 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "units" + ".ser";
18 naveen 168 
 
169 
			this.units = (Map<Long, Unit>) DBUtils.read(dbFile);
17 naveen 170 
		}
18 naveen 171 
 
10 shop2020 172 
		return this.units;
173 
	}
174 
 
175 
	/**
49 naveen 176 
	 * Resolves Unit ID into Unit object
10 shop2020 177 
	 *
49 naveen 178 
	 * @param unitID Unit ID
10 shop2020 179 
	 * @return Unit
18 naveen 180 
	 * @throws Exception
10 shop2020 181 
	 */
18 naveen 182 
	public Unit getUnit(long unitID) throws Exception {
183 
		// Initialize
184 
		if(this.units == null) {
185 
			this.getUnits();
186 
		}
17 naveen 187 
 
10 shop2020 188 
		return this.units.get(new Long(unitID));
189 
	}
190 
 
191 
	/**
49 naveen 192 
	 * Returns all DatatypeDefintion object in database
193 
	 *
194 
	 * @return the datatypeDefinitions List of DatatypeDefinition objects
18 naveen 195 
	 * @throws Exception
10 shop2020 196 
	 */
18 naveen 197 
	@SuppressWarnings("unchecked")
198 
	public Map<Long, DatatypeDefinition> getDatatypeDefinitions()
199 
		throws Exception {
200 
 
201 
		// De-serialize
202 
		if(this.datatypeDefinitions == null) {
70 naveen 203 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "datatypedefinitions" +
19 naveen 204 
				".ser";
18 naveen 205 
 
206 
			this.datatypeDefinitions =
207 
				(Map<Long, DatatypeDefinition>) DBUtils.read(dbFile);
208 
		}
209 
		return this.datatypeDefinitions;
10 shop2020 210 
	}
18 naveen 211 
 
212 
	/**
49 naveen 213 
	 * Resolves Datatype Definition ID into DatetypeDefinition object
18 naveen 214 
	 *
49 naveen 215 
	 * @param unitID Unit ID
18 naveen 216 
	 * @return Unit
217 
	 * @throws Exception
218 
	 */
219 
	public DatatypeDefinition getDatatypeDefinition(long id) throws Exception {
220 
 
221 
		// Initialize
222 
		if(this.datatypeDefinitions == null) {
223 
			this.getDatatypeDefinitions();
224 
		}
225 
 
226 
		return this.datatypeDefinitions.get(new Long(id));
227 
	}
19 naveen 228 
 
229 
	/**
49 naveen 230 
	 * Returns EnumValue ID for datatype definition ID and enum value string
231 
	 * to match. Match is case insensitive
19 naveen 232 
	 *
49 naveen 233 
	 * @param datatypeDefID DatatypeDefinition ID
234 
	 * @param value query enum value string
19 naveen 235 
	 * @return long enumValueID - "-1" if not found
236 
	 * @throws Exception
237 
	 */
238 
	public long getEnumValueID(long datatypeDefID, String value)
239 
		throws Exception {
240 
		long enumValueID = -1L;
241 
 
242 
		// Let the callers catch ClassCastException
243 
		EnumDefinition enumDef =
244 
			(EnumDefinition)this.getDatatypeDefinition(datatypeDefID);
245 
 
24 naveen 246 
		List<EnumValue> enumValues = enumDef.getEnumValues();
19 naveen 247 
		for(EnumValue enumValue : enumValues) {
248 
			if(value.equalsIgnoreCase(enumValue.getValue())) {
249 
				enumValueID = enumValue.getID();
250 
				break;
251 
			}
252 
		}
253 
 
254 
		return enumValueID;
255 
	}
17 naveen 256 
 
10 shop2020 257 
	/**
49 naveen 258 
	 * Returns all category objects in the database
259 
	 *
10 shop2020 260 
	 * @return the categories
17 naveen 261 
	 * @throws Exception
10 shop2020 262 
	 */
17 naveen 263 
	@SuppressWarnings("unchecked")
264 
	public Map<Long, Category> getCategories() throws Exception {
265 
 
266 
		// De-serialize
267 
		if(this.categories == null) {
70 naveen 268 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "categories" + ".ser";
17 naveen 269 
 
270 
			this.categories = (Map<Long, Category>) DBUtils.read(dbFile);
271 
		}
272 
		return this.categories;
10 shop2020 273 
	}
17 naveen 274 
 
10 shop2020 275 
	/**
49 naveen 276 
	 * Resolves Category ID into Category object
17 naveen 277 
	 *
49 naveen 278 
	 * @param categoryID Category ID
17 naveen 279 
	 * @return Category
280 
	 * @throws Exception
10 shop2020 281 
	 */
17 naveen 282 
	public Category getCategory(long categoryID) throws Exception {
283 
 
18 naveen 284 
		// Initialize
17 naveen 285 
		if(this.categories == null) {
286 
			this.getCategories();
287 
		}
288 
 
289 
		return this.categories.get(new Long(categoryID));
10 shop2020 290 
	}
17 naveen 291 
 
10 shop2020 292 
	/**
49 naveen 293 
	 * Returns expanded Category object. All numeric identifiers are resolved
294 
	 * into detailed objects
18 naveen 295 
	 *
296 
	 * @param categoryID
45 naveen 297 
	 * @return ExpandedCategory
298 
	 * @throws Exception
299 
	 */
300 
	public ExpandedCategory getExpandedCategory(long categoryID)
301 
		throws Exception {
302 
		Category category = this.getCategory(categoryID);
303 
 
304 
		ExpandedCategory expCategory = new ExpandedCategory(category);
305 
 
306 
		return expCategory;
307 
	}
308 
 
309 
	/**
49 naveen 310 
	 * Returns all children categories for a Category ID
45 naveen 311 
	 *
312 
	 * @param categoryID
49 naveen 313 
	 * @return List<Category> Children Categories
34 naveen 314 
	 * @throws Exception
315 
	 */
316 
	public List<Category> getChildrenCategories(long categoryID)
317 
		throws Exception {
318 
 
319 
		// Initialize
320 
		if(this.categories == null) {
321 
			this.getCategories();
322 
		}
323 
 
324 
		return this.categories.get(new Long(categoryID)).getChildrenCategory();
325 
	}
49 naveen 326 
 
34 naveen 327 
	/**
49 naveen 328 
	 * Returns all CategorySlideDefinition objects for a Category ID
34 naveen 329 
	 *
49 naveen 330 
	 * @param categoryID Category ID
18 naveen 331 
	 * @return List<CategorySlideDefinition>
332 
	 * @throws Exception
333 
	 */
334 
	public List<CategorySlideDefinition> getCategorySlideDefinitions(
335 
			long categoryID) throws Exception {
336 
		Category category = this.getCategory(categoryID);
337 
 
338 
		return category.getCategorySlideDefintions();
339 
	}
340 
 
341 
	/**
49 naveen 342 
	 * Returns All SlideDefinition objects in database
343 
	 *
10 shop2020 344 
	 * @return the slideDefinitions
18 naveen 345 
	 * @throws Exception
10 shop2020 346 
	 */
18 naveen 347 
	@SuppressWarnings("unchecked")
348 
	public Map<Long, SlideDefinition> getSlideDefinitions() throws Exception {
349 
 
350 
		// De-serialize
351 
		if(this.slideDefinitions == null) {
70 naveen 352 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "slidedefinitions" +
18 naveen 353 
				".ser";
354 
 
355 
			this.slideDefinitions =
356 
				(Map<Long, SlideDefinition>) DBUtils.read(dbFile);
357 
		}
358 
		return this.slideDefinitions;
10 shop2020 359 
	}
18 naveen 360 
 
361 
	/**
49 naveen 362 
	 * Resolves SlideDefinition ID into SlideDefinition object
18 naveen 363 
	 *
364 
	 * @param id
365 
	 * @return SlideDefinition
366 
	 * @throws Exception
367 
	 */
368 
	public SlideDefinition getSlideDefinition(long id) throws Exception {
369 
 
370 
		// Initialize
371 
		if(this.slideDefinitions == null) {
372 
			this.getSlideDefinitions();
373 
		}
374 
 
375 
		return this.slideDefinitions.get(new Long(id));
376 
	}
377 
 
378 
	/**
199 naveen 379 
	 *
380 
	 * @param slideID
381 
	 * @return ExpandedSlideDefinition
382 
	 * @throws Exception
383 
	 */
384 
	public ExpandedSlideDefinition getExpandedSlideDefinition(long slideID)
385 
		throws Exception {
386 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
387 
 
388 
		return new ExpandedSlideDefinition(slideDef);
389 
	}
390 
 
391 
	/**
49 naveen 392 
	 * Returns SlideDefinition objects for a category and matching slide label
18 naveen 393 
	 *
19 naveen 394 
	 * @param label
395 
	 * @return List<SlideDefinition>
396 
	 * @throws Exception
397 
	 */
32 naveen 398 
	public List<SlideDefinition> getSlideDefinitions(long categoryID,
399 
			String label) throws Exception {
400 
 
401 
		// RE-VISIT
402 
		// May be we need a new data structure, category id to slide definitions
403 
		// for now
404 
		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
19 naveen 405 
 
32 naveen 406 
		List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(
407 
				categoryID);
408 
 
409 
		for(CategorySlideDefinition csDef : csDefs) {
410 
			SlideDefinition sDef = this.getSlideDefinition(
411 
					csDef.getSlideDefintionID());
412 
 
413 
			if(sDef.getLabel().equalsIgnoreCase(label)) {
414 
				matchingSlides.add(sDef);
415 
			}
19 naveen 416 
		}
417 
 
32 naveen 418 
		return matchingSlides;
419 
	}
420 
 
421 
	/**
49 naveen 422 
	 * Resolves Category ID into Category object
32 naveen 423 
	 *
424 
	 * @param categoryID
49 naveen 425 
	 * @return List<SlideDefinition>
32 naveen 426 
	 * @throws Exception
427 
	 */
428 
	public List<SlideDefinition> getSlideDefinitions(long categoryID)
429 
		throws Exception {
430 
 
431 
		// RE-VISIT
432 
		// May be we need a new data structure, category id to slide definitions
433 
		// for now
19 naveen 434 
		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
32 naveen 435 
 
436 
		List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(
437 
				categoryID);
438 
 
439 
		for(CategorySlideDefinition csDef : csDefs) {
440 
			SlideDefinition sDef = this.getSlideDefinition(
441 
					csDef.getSlideDefintionID());
19 naveen 442 
 
32 naveen 443 
			matchingSlides.add(sDef);
19 naveen 444 
		}
445 
 
446 
		return matchingSlides;
447 
	}
49 naveen 448 
 
19 naveen 449 
	/**
49 naveen 450 
	 * Returns list of SlideDefinition objects for a category and editorial
451 
	 * importance value
19 naveen 452 
	 *
18 naveen 453 
	 * @param categoryID
454 
	 * @param EditorialImportance imp
455 
	 * @return List<SlideDefinition>
456 
	 * @throws Exception
457 
	 */
458 
	public List<SlideDefinition> getSlides(long categoryID,
459 
			EditorialImportance imp)
460 
		throws Exception {
461 
 
462 
		List<CategorySlideDefinition> catSlideDefs =
463 
			this.getCategorySlideDefinitions(categoryID);
464 
 
465 
		Iterator<CategorySlideDefinition> itCatSlideDefs =
466 
			catSlideDefs.iterator();
467 
 
468 
		List<SlideDefinition> slideDefs = new ArrayList<SlideDefinition>();
469 
		while(itCatSlideDefs.hasNext()) {
470 
			CategorySlideDefinition catSlideDef = itCatSlideDefs.next();
471 
			if(catSlideDef.getEditorialImportance() == imp) {
472 
				long slideDefID = catSlideDef.getSlideDefintionID();
473 
				slideDefs.add(this.getSlideDefinition(slideDefID));
474 
			}
475 
		}
476 
		return slideDefs;
477 
	}
478 
 
479 
	/**
49 naveen 480 
	 * Returns all FeatureDefinition object in database
18 naveen 481 
	 *
482 
	 * @return Map<Long, FeatureDefinition>
483 
	 * @throws Exception
484 
	 */
485 
	@SuppressWarnings("unchecked")
486 
	public Map<Long, FeatureDefinition> getFeatureDefinitions()
487 
		throws Exception {
488 
 
489 
		// De-serialize
490 
		if(this.featureDefinitions == null) {
70 naveen 491 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "featuredefinitions" +
18 naveen 492 
				".ser";
493 
 
494 
			this.featureDefinitions =
495 
				(Map<Long, FeatureDefinition>) DBUtils.read(dbFile);
496 
		}
497 
		return this.featureDefinitions;
498 
	}
19 naveen 499 
 
10 shop2020 500 
	/**
49 naveen 501 
	 * Returns all FeatureDefinition objects for a slide
18 naveen 502 
	 *
19 naveen 503 
	 * @param slideID
504 
	 * @return List<FeatureDefinition>
505 
	 * @throws Exception
506 
	 */
507 
	public List<FeatureDefinition> getFeatureDefinitions(long slideID)
508 
		throws Exception {
509 
		List<FeatureDefinition> featureDefs =
510 
			new ArrayList<FeatureDefinition>();
511 
 
512 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
513 
		List<SlideFeatureDefinition> slideFeatureDefs =
514 
			slideDef.getSlideFeatureDefinitions();
515 
 
516 
		for(int i=0; i<slideFeatureDefs.size(); i++) {
517 
			featureDefs.add(this.getFeatureDefinition(
518 
					slideFeatureDefs.get(i).getFeatureDefintionID()));
519 
		}
520 
 
521 
		return featureDefs;
522 
	}
523 
 
524 
	/**
49 naveen 525 
	 * Returns list of FeatureDefinition objects for a slide given editorial
526 
	 * importance
19 naveen 527 
	 *
528 
	 * @param slideID
49 naveen 529 
	 * @param imp Editorial Importance enum object
19 naveen 530 
	 * @return List<FeatureDefinition>
531 
	 * @throws Exception
532 
	 */
533 
	public List<FeatureDefinition> getFeatureDefinitions(long slideID,
534 
			EditorialImportance imp)  throws Exception {
535 
		List<FeatureDefinition> featureDefs =
536 
			new ArrayList<FeatureDefinition>();
537 
 
538 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
539 
		List<SlideFeatureDefinition> slideFeatureDefs =
540 
			slideDef.getSlideFeatureDefinitions();
541 
 
542 
		for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {
543 
			if(slideFeatureDef.getEditorialImportance() == imp) {
544 
				featureDefs.add(this.getFeatureDefinition(
545 
						slideFeatureDef.getFeatureDefintionID()));
546 
			}
547 
		}
548 
 
549 
		return featureDefs;
550 
	}
551 
 
552 
	/**
49 naveen 553 
	 * Resolves Feature Definition ID into FeatureDefinition object
19 naveen 554 
	 *
49 naveen 555 
	 * @param id Feature Definition ID
19 naveen 556 
	 * @return FeatureDefinition
18 naveen 557 
	 * @throws Exception
10 shop2020 558 
	 */
18 naveen 559 
	public FeatureDefinition getFeatureDefinition(long id) throws Exception {
560 
 
561 
		// Initialize
562 
		if(this.featureDefinitions == null) {
563 
			this.getFeatureDefinitions();
564 
		}
565 
 
566 
		return this.featureDefinitions.get(new Long(id));
567 
	}
19 naveen 568 
 
569 
	/**
49 naveen 570 
	 * Returns matching FeatureDefinition object for slide ID and feature label.
571 
	 * Label matching is case insensitive.
19 naveen 572 
	 *
49 naveen 573 
	 * @param slideID Slide ID
574 
	 * @param featureLabel label to match, case is ignored
19 naveen 575 
	 * @return FeatureDefinition
576 
	 * @throws Exception
577 
	 */
578 
	public FeatureDefinition getFeatureDefinition(long slideID,
579 
			String featureLabel) throws Exception {
580 
		FeatureDefinition featureDef = null;
581 
 
582 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
583 
		for(SlideFeatureDefinition slideFeatureDef :
584 
			slideDef.getSlideFeatureDefinitions()) {
585 
 
586 
			long featureDefID = slideFeatureDef.getFeatureDefintionID();
587 
 
588 
			FeatureDefinition thisFeatureDef = this.getFeatureDefinition(
589 
					featureDefID);
590 
 
28 naveen 591 
			if(featureLabel.equalsIgnoreCase(thisFeatureDef.getLabel())) {
19 naveen 592 
				featureDef = thisFeatureDef;
593 
			}
594 
		}
595 
 
596 
		return featureDef;
597 
	}
24 naveen 598 
 
599 
	/**
49 naveen 600 
	 * Returns all EnumValue objects in the database
601 
	 *
24 naveen 602 
	 * @return the enumValues
603 
	 * @throws Exception
604 
	 */
605 
	@SuppressWarnings("unchecked")
606 
	public Map<Long, EnumValue> getEnumValues() throws Exception {
607 
		// De-serialise
608 
		if(this.enumValues == null) {
70 naveen 609 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "enumvalues" +
24 naveen 610 
				".ser";
611 
 
612 
			this.enumValues =
613 
				(Map<Long, EnumValue>) DBUtils.read(dbFile);
614 
		}
615 
 
616 
		return this.enumValues;
617 
	}
19 naveen 618 
 
24 naveen 619 
	/**
49 naveen 620 
	 * Resolves Enum value ID into EnumValue object
24 naveen 621 
	 *
622 
	 * @param enumValueID
623 
	 * @return EnumValue
624 
	 * @throws Exception
625 
	 */
626 
	public EnumValue getEnumValue(long enumValueID) throws Exception {
627 
		// Initialise
628 
		if(this.enumValues == null) {
629 
			this.getEnumValues();
630 
		}
631 
 
632 
		return this.enumValues.get(new Long(enumValueID));
633 
	}
62 naveen 634 
 
635 
	/**
636 
	 * Returns all FacetDefinition objects in the database
637 
	 *
638 
	 * @return Map Null if facet definitions are not imported into definitions
639 
	 * db (serialized java objects)
640 
	 *
641 
	 * @throws Exception
642 
	 */
643 
	@SuppressWarnings("unchecked")
644 
	public Map<Long, FacetDefinition> getFacetDefinitions() throws Exception {
645 
 
646 
		// De-serialize
647 
		if(this.facetDefinitions == null) {
70 naveen 648 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "facetdefinitions" +
63 naveen 649 
				".ser";
62 naveen 650 
 
651 
			this.facetDefinitions =
652 
				(Map<Long, FacetDefinition>) DBUtils.read(dbFile);
653 
		}
654 
 
655 
		return this.facetDefinitions;
656 
	}
657 
 
658 
	/**
659 
	 * Resolves Facet Definition ID into FacetDefinition object
660 
	 *
661 
	 * @param facetDefinitionID
662 
	 * @return FacetDefinition
663 
	 * @throws Exception
664 
	 */
665 
	public FacetDefinition getFacetDefinition(long facetDefinitionID)
666 
		throws Exception {
667 
 
668 
		if(this.facetDefinitions == null) {
669 
			this.getFacetDefinitions();
670 
		}
671 
 
672 
		return this.facetDefinitions.get(new Long(facetDefinitionID));
673 
	}
674 
 
675 
	/**
676 
	 * Utility method to get Expanded version of ExpandedFacetDefinition object
677 
	 *
678 
	 * @param facetDefinitionID
679 
	 * @return ExpandedFacetDefinition
680 
	 * @throws Exception
681 
	 */
682 
	public ExpandedFacetDefinition getExpandedFacetDefinition(
683 
			long facetDefinitionID) throws Exception {
684 
 
685 
		FacetDefinition facetDefinition =
686 
			this.getFacetDefinition(facetDefinitionID);
687 
 
688 
		ExpandedFacetDefinition expFacetDefinition =
689 
			new ExpandedFacetDefinition(facetDefinition);
690 
 
691 
		return expFacetDefinition;
692 
	}
693 
 
694 
	/**
695 
	 * Returns all CategoryFacetDefinition objects in the database
696 
	 *
697 
	 * @return Map Null if category facet definitions are not imported into
698 
	 * definitions db (serialized java objects)
699 
	 *
700 
	 * @throws Exception
701 
	 */
702 
	@SuppressWarnings("unchecked")
703 
	public Map<Long, CategoryFacetDefinition> getCategoryFacetDefinitions()
704 
		throws Exception {
705 
 
706 
		// De-serialize
707 
		if(this.categoryFacetDefinitions == null) {
70 naveen 708 
			String dbFile = Utils.DEFINITIONS_DB_PATH +
81 naveen 709 
				"categoryfacetdefinitions.ser";
62 naveen 710 
 
711 
			this.categoryFacetDefinitions =
712 
				(Map<Long, CategoryFacetDefinition>) DBUtils.read(dbFile);
713 
		}
714 
 
715 
		return this.categoryFacetDefinitions;
716 
	}
717 
 
718 
	/**
719 
	 * Resolves Category-Facet Definition ID into CategoryFacetDefinition object
720 
	 *
721 
	 * @param categoryID
722 
	 * @return CategoryFacetDefinition
723 
	 * @throws Exception
724 
	 */
725 
	public CategoryFacetDefinition getCategoryFacetDefinition(
726 
			long categoryID) throws Exception {
727 
 
728 
		if(this.categoryFacetDefinitions == null) {
729 
			this.getCategoryFacetDefinitions();
730 
		}
731 
 
732 
		return this.categoryFacetDefinitions.get(
733 
				new Long(categoryID));
734 
	}
735 
 
736 
	/**
737 
	 * Utility method to get Expanded version of CategoryFacetDefinition object
738 
	 *
739 
	 * @param categoryID
740 
	 * @return ExpandedCategoryFacetDefinition
741 
	 * @throws Exception
742 
	 */
743 
	public ExpandedCategoryFacetDefinition getExpandedCategoryFacetDefinition(
744 
			long categoryID) throws Exception  {
745 
		CategoryFacetDefinition categoryFacetDef =
746 
			this.getCategoryFacetDefinition(categoryID);
747 
 
748 
		ExpandedCategoryFacetDefinition expCategoryFacetDef =
749 
			new ExpandedCategoryFacetDefinition(categoryFacetDef);
750 
 
751 
		return expCategoryFacetDef;
752 
	}
753 
 
754 
	/**
755 
	 * Returns all IR Data RuleDefintion objects in the database
756 
	 *
757 
	 * @return Map Null if IR data rule definitions are not imported into
758 
	 * definitions db (serialized java objects)
759 
	 *
760 
	 * @throws Exception
761 
	 */
762 
	@SuppressWarnings("unchecked")
763 
	public Map<Long, RuleDefinition> getIrDataRuleDefinitions()
764 
		throws Exception {
765 
 
766 
		// De-serialize
767 
		if(this.irDataRuleDefinitions == null) {
70 naveen 768 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "irdatarules" + ".ser";
62 naveen 769 
 
770 
			this.irDataRuleDefinitions =
771 
				(Map<Long, RuleDefinition>) DBUtils.read(dbFile);
772 
		}
773 
 
774 
		return this.irDataRuleDefinitions;
775 
	}
776 
 
777 
	/**
778 
	 * Resolves IR Data Rule Definition ID into RuleDefinition object
779 
	 *
780 
	 * @param irDataRuleDefinitionID
781 
	 * @return RuleDefinition
782 
	 * @throws Exception
783 
	 */
784 
	public RuleDefinition getIrDataRuleDefinition(
785 
			long irDataRuleDefinitionID) throws Exception {
786 
 
787 
		if(this.irDataRuleDefinitions == null) {
788 
			this.getIrDataRuleDefinitions();
789 
		}
790 
 
791 
		return this.irDataRuleDefinitions.get(new Long(irDataRuleDefinitionID));
792 
	}
793 
 
794 
	/**
795 
	 * Returns all IR Meta Data RuleDefintion objects in the database
796 
	 *
797 
	 * @return Map Null if IR meta-data rule definitions are not imported into
798 
	 * definitions db (serialized java objects)
799 
	 *
800 
	 * @throws Exception
801 
	 */
802 
	@SuppressWarnings("unchecked")
803 
	public Map<Long, RuleDefinition> getIrMetaDataRuleDefinitions()
804 
		throws Exception {
805 
 
806 
		// De-serialize
807 
		if(this.irMetaDataRuleDefinitions == null) {
70 naveen 808 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "irmetadatarules" +
809 
				".ser";
62 naveen 810 
 
811 
			this.irMetaDataRuleDefinitions =
812 
				(Map<Long, RuleDefinition>) DBUtils.read(dbFile);
813 
		}
814 
 
815 
		return this.irMetaDataRuleDefinitions;
816 
	}
817 
 
818 
	/**
819 
	 * Resolves IR Meta Data Rule Definition ID into RuleDefinition object
820 
	 *
821 
	 * @param irMetaDataRuleDefinitionID
822 
	 * @return RuleDefinition
823 
	 * @throws Exception
824 
	 */
825 
	public RuleDefinition getIrMetaDataRuleDefinition(
826 
			long irMetaDataRuleDefinitionID) throws Exception {
827 
 
828 
		if(this.irMetaDataRuleDefinitions == null) {
829 
			this.getIrMetaDataRuleDefinitions();
830 
		}
831 
 
832 
		return this.irMetaDataRuleDefinitions.get(
833 
				new Long(irMetaDataRuleDefinitionID));
834 
	}
70 naveen 835 
 
836 
	/**
837 
	 * Returns all Comparison RuleDefintion objects in the database
838 
	 *
839 
	 * @return Map Null if Comparison rule definitions are not imported into
840 
	 * definitions db (serialized java objects)
841 
	 *
842 
	 * @throws Exception
843 
	 */
844 
	@SuppressWarnings("unchecked")
845 
	public Map<Long, CMPRuleDefinition> getComparisonRuleDefinitions()
846 
		throws Exception {
847 
 
848 
		// De-serialize
849 
		if(this.cmpRuleDefinitions == null) {
850 
			String dbFile = Utils.DEFINITIONS_DB_PATH + "comparisonrules" +
851 
				".ser";
852 
 
853 
			this.cmpRuleDefinitions =
854 
				(Map<Long, CMPRuleDefinition>) DBUtils.read(dbFile);
855 
		}
856 
 
857 
		return this.cmpRuleDefinitions;
858 
	}
859 
 
860 
	/**
861 
	 * Resolves IR Data Rule Definition ID into RuleDefinition object
862 
	 *
863 
	 * @param cmpRuleDefinitionID
864 
	 * @return CMPRuleDefinition
865 
	 * @throws Exception
866 
	 */
867 
	public CMPRuleDefinition getComparisonRuleDefinition(
868 
			long cmpRuleDefinitionID) throws Exception {
869 
 
870 
		if(this.cmpRuleDefinitions == null) {
871 
			this.getComparisonRuleDefinitions();
872 
		}
873 
 
874 
		return this.cmpRuleDefinitions.get(new Long(cmpRuleDefinitionID));
875 
	}
876 
 
877 
 
878 
	/**
879 
	 * Returns all ComparisonSlideRuleDefintion objects in the database
880 
	 *
881 
	 * @return Map Null if Comparison slide-rule definitions are not imported
882 
	 * into definitions db (serialized java objects)
883 
	 *
884 
	 * @throws Exception
885 
	 */
886 
	@SuppressWarnings("unchecked")
887 
	public Map<Long, CMPSlideRuleDefinition> getComparisonSlideRuleDefinitions()
888 
		throws Exception {
889 
 
890 
		// De-serialize
891 
		if(this.cmpSlideRuleDefinitions == null) {
892 
			String dbFile = Utils.DEFINITIONS_DB_PATH +
893 
				"comparisondefinitions.ser";
71 naveen 894 
			Utils.info("dbFile=" + dbFile);
70 naveen 895 
 
896 
			this.cmpSlideRuleDefinitions =
897 
				(Map<Long, CMPSlideRuleDefinition>) DBUtils.read(dbFile);
71 naveen 898 
 
899 
			//Utils.info("this.cmpSlideRuleDefinitions=" +
900 
			//		this.cmpSlideRuleDefinitions);
70 naveen 901 
		}
902 
 
903 
		return this.cmpSlideRuleDefinitions;
904 
	}
905 
 
906 
	/**
907 
	 * Resolves Category ID into List of CMPSlideRuleDefinition object
908 
	 *
909 
	 * @param categoryID
910 
	 * @return List<CMPSlideRuleDefinition>
911 
	 * @throws Exception
912 
	 */
913 
	public CMPSlideRuleDefinition getComparisonSlideRuleDefinition(
914 
			long slideDefinitionID) throws Exception {
915 
 
916 
		if(this.cmpSlideRuleDefinitions == null) {
917 
			this.getComparisonSlideRuleDefinitions();
918 
		}
919 
 
920 
		return this.cmpSlideRuleDefinitions.get(new Long(slideDefinitionID));
921 
	}
922 
 
923 
 
924 
	/**
925 
	 * Resolves Slide Definition ID into ExpandedCMPSlideRuleDefinition object
926 
	 *
927 
	 * @param categoryID
928 
	 * @return ExpandedCMPSlideRuleDefinition
929 
	 * @throws Exception
930 
	 */
931 
	public ExpandedCMPSlideRuleDefinition
932 
		getExpandedComparisonSlideRuleDefinition(long slideDefinitionID)
933 
		throws Exception {
71 naveen 934 
		Utils.info("slideDefinitionID=" + slideDefinitionID);
70 naveen 935 
 
936 
		CMPSlideRuleDefinition cmpSlideRuleDef =
937 
			this.getComparisonSlideRuleDefinition(slideDefinitionID);
938 
 
71 naveen 939 
		if(cmpSlideRuleDef == null) {
940 
			return null;
941 
		}
942 
 
70 naveen 943 
		ExpandedCMPSlideRuleDefinition expDef =
944 
			new ExpandedCMPSlideRuleDefinition(cmpSlideRuleDef);
945 
 
946 
		return expDef;
947 
	}
72 naveen 948 
 
70 naveen 949 
 
72 naveen 950 
	/**
951 
	 * Returns all ComparisonSlideRuleDefintion objects in the database
952 
	 *
953 
	 * @return Map Null if Comparison slide-rule definitions are not imported
954 
	 * into definitions db (serialized java objects)
955 
	 *
956 
	 * @throws Exception
957 
	 */
958 
	@SuppressWarnings("unchecked")
959 
	public Map<Long, List<CMPBucketDefinition>> getComparisonBucketDefinitions()
960 
		throws Exception {
961 
 
962 
		// De-serialize
963 
		if(this.cmpBucketDefinitions == null) {
964 
			String dbFile = Utils.DEFINITIONS_DB_PATH +	"comparisonbuckets.ser";
965 
			Utils.info("dbFile=" + dbFile);
966 
 
967 
			this.cmpBucketDefinitions =
968 
				(Map<Long, List<CMPBucketDefinition>>) DBUtils.read(dbFile);
969 
		}
970 
 
971 
		return this.cmpBucketDefinitions;
972 
	}
973 
 
974 
	/**
975 
	 * Resolves Category ID into List of CMPBucketDefinition object
976 
	 *
977 
	 * @param categoryID
978 
	 * @return List<CMPBucketDefinition>
979 
	 * @throws Exception
980 
	 */
981 
	public List<CMPBucketDefinition> getComparisonBucketDefinitions(
982 
			long categoryID) throws Exception {
983 
 
984 
		if(this.cmpBucketDefinitions == null) {
985 
			this.getComparisonBucketDefinitions();
986 
		}
987 
 
988 
		return this.cmpBucketDefinitions.get(new Long(categoryID));
989 
	}
990 
 
991 
	/**
992 
	 * Resolve comparison bucket name for a slide in a particular category
993 
	 *
994 
	 * @param categoryID
995 
	 * @param slideDefintionID
996 
	 * @return Bucket Name if found else Null
997 
	 * @throws Exception
998 
	 */
999 
	public String getComparisonBucketName(long categoryID,
1000 
			long slideDefinitionID) throws Exception {
1001 
		List<CMPBucketDefinition> cmpBuckets =
1002 
			this.getComparisonBucketDefinitions(categoryID);
1003 
 
1004 
		for (CMPBucketDefinition cmpBucket : cmpBuckets) {
1005 
			List<Long> slideDefinitionIDs = cmpBucket.getSlideDefinitionIDs();
1006 
 
1007 
			if(slideDefinitionIDs.contains(new Long(slideDefinitionID))) {
1008 
				return cmpBucket.getName();
1009 
			}
1010 
		}
1011 
 
1012 
		return null;
1013 
	}
83 naveen 1014 
 
1015 
	/**
1016 
	 * Returns list of facet definition IDs for given category ID
1017 
	 *
1018 
	 * @param categoryID
1019 
	 * @return list of facet definition IDs
1020 
	 * @throws Exception
1021 
	 */
1022 
	public List<Long> getFacetDefinitionIDs(long categoryID) throws Exception {
1023 
		List<Long> facetDefIDs = new ArrayList<Long>();
1024 
 
1025 
		CategoryFacetDefinition categoryFacetDef =
1026 
			this.getCategoryFacetDefinition(categoryID);
1027 
 
1028 
		List<FacetRuleDefinition> facetRuleDefs =
1029 
			categoryFacetDef.getFacetRuleDefinitions();
1030 
 
1031 
		for(FacetRuleDefinition facetRuleDef : facetRuleDefs) {
1032 
			facetDefIDs.add(new Long(facetRuleDef.getFacetDefinitionID()));
1033 
		}
1034 
 
1035 
		return facetDefIDs;
1036 
	}
1037 
 
1038 
	/**
1039 
	 * Returns list of feature definition IDs for given category ID
1040 
	 *
1041 
	 * @param categoryID
1042 
	 * @return list of feature definition IDs
1043 
	 * @throws Exception
1044 
	 */
1045 
	public List<Long> getFeatureDefinitionIDs(long categoryID)
1046 
		throws Exception {
1047 
 
1048 
		List<Long> featureDefIDs = new ArrayList<Long>();
1049 
 
1050 
		List<SlideDefinition> slideDefs = this.getSlideDefinitions(categoryID);
1051 
 
1052 
		for(SlideDefinition slideDef : slideDefs) {
1053 
			List<Long> slideFeatureDefIDs =
1054 
				this.getFeatureDefintionIDs(slideDef);
1055 
 
1056 
			featureDefIDs.addAll(slideFeatureDefIDs);
1057 
		}
1058 
 
1059 
		return featureDefIDs;
1060 
	}
1061 
 
1062 
	/**
1063 
	 * Returns list of feature definition IDs for given slide definition ID
1064 
	 *
1065 
	 * @param slideDef
1066 
	 * @return list of feature definition IDs
1067 
	 */
1068 
	public List<Long> getFeatureDefintionIDs(SlideDefinition slideDef) {
1069 
		List<Long> featureDefIDs = new ArrayList<Long>();
1070 
 
1071 
		List<SlideFeatureDefinition> slideFeatureDefs =
1072 
			slideDef.getSlideFeatureDefinitions();
1073 
 
1074 
		for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {
1075 
			featureDefIDs.add(
1076 
					new Long(slideFeatureDef.getFeatureDefintionID()));
1077 
		}
1078 
 
1079 
		return featureDefIDs;
1080 
	}
88 naveen 1081 
 
1082 
	/**
1083 
	 *
1084 
	 * @param borrowedSlideDefID
1085 
	 * @return
1086 
	 * @throws Exception
1087 
	 */
1088 
	public boolean isValidSlideDefinitionID(long borrowedSlideDefID)
1089 
		throws Exception {
1090 
		this.getSlideDefinitions();
1091 
 
1092 
		return this.slideDefinitions.containsKey(new Long(borrowedSlideDefID));
1093 
	}
1094 
 
1095 
	/**
1096 
	 * Returns Facet-Rule definition object defined for a category and
1097 
	 * slide definition
1098 
	 *
1099 
	 * @param borrowedCategoryID
1100 
	 * @param slideDefID
1101 
	 * @return FacetRuleDefinition
1102 
	 * @throws Exception
1103 
	 */
1104 
	public FacetRuleDefinition getFacetRuleDefinitionForSlide(long categoryID,
1105 
			long slideDefinitionID) throws Exception {
1106 
		CategoryFacetDefinition categoryFacetDef =
1107 
			this.getCategoryFacetDefinition(categoryID);
1108 
 
1109 
		List<FacetRuleDefinition> facetRuleDefs =
1110 
			categoryFacetDef.getFacetRuleDefinitions();
1111 
 
1112 
		for(FacetRuleDefinition facetRuleDef : facetRuleDefs) {
1113 
			if(facetRuleDef.getSlideDefinitionID() == slideDefinitionID) {
1114 
				return facetRuleDef;
1115 
			}
1116 
		}
1117 
 
1118 
		return null;
1119 
	}
1120 
 
1121 
	/**
1122 
	 * Returns Facet-Rule definition object defined for a category and
1123 
	 * feature definition
1124 
	 *
1125 
	 * @param categoryID
1126 
	 * @param featureDefinitionID
1127 
	 * @return FacetRuleDefinition
1128 
	 * @throws Exception
1129 
	 */
1130 
	public FacetRuleDefinition getFacetRuleDefinitionForFeature(long categoryID,
1131 
			long featureDefinitionID) throws Exception {
1132 
		CategoryFacetDefinition categoryFacetDef =
1133 
			this.getCategoryFacetDefinition(categoryID);
1134 
 
1135 
		List<FacetRuleDefinition> facetRuleDefs =
1136 
			categoryFacetDef.getFacetRuleDefinitions();
1137 
 
1138 
		for(FacetRuleDefinition facetRuleDef : facetRuleDefs) {
1139 
			if(facetRuleDef.getFeatureDefinitionID() == featureDefinitionID) {
1140 
				return facetRuleDef;
1141 
			}
1142 
		}
1143 
 
1144 
		return null;
1145 
	}
102 naveen 1146 
 
1147 
	/**
1148 
	 * Returns all normalization rule defined
1149 
	 *
1150 
	 * @return Map<Long, RuleDefinition>
1151 
	 * @throws Exception
1152 
	 */
1153 
	@SuppressWarnings("unchecked")
1154 
	public Map<Long, RuleDefinition> getNormalizationRules() throws Exception {
1155 
 
1156 
		// De-serialize
1157 
		if(this.normalizationRuleDefinitions == null) {
1158 
			String dbFile = Utils.DEFINITIONS_DB_PATH +
1159 
				"normalizationrules.ser";
1160 
 
1161 
			Utils.info("dbFile=" + dbFile);
1162 
 
1163 
			this.normalizationRuleDefinitions =
1164 
				(Map<Long, RuleDefinition>) DBUtils.read(dbFile);
1165 
		}
1166 
 
1167 
		return this.normalizationRuleDefinitions;
1168 
	}
1169 
 
1170 
 
1171 
	/**
1172 
	 * True if feature has normalization rule defined
1173 
	 *
1174 
	 * @param feature
1175 
	 * @return boolean
1176 
	 * @throws Exception
1177 
	 */
1178 
	public boolean needsNormalization(long featureDefinitionID)
1179 
		throws Exception {
1180 
		this.getFeatureDefinitions();
1181 
 
1182 
		FeatureDefinition featureDef =
1183 
			this.featureDefinitions.get(new Long(featureDefinitionID));
1184 
 
1185 
		if(featureDef.getNormalizationRuleDefinitionID() != 0L) {
1186 
			return true;
1187 
		}
1188 
 
1189 
		return false;
1190 
	}
1191 
 
1192 
	/**
1193 
	 * Returns normalization rule definition for rule definition ID
1194 
	 *
1195 
	 * @param ruleID
1196 
	 * @return RuleDefinition
1197 
	 * @throws Exception
1198 
	 */
1199 
	public RuleDefinition getNormalizationRuleDefinition(
1200 
			long ruleDefinitionID) throws Exception {
1201 
		this.getNormalizationRules();
1202 
 
1203 
		return this.normalizationRuleDefinitions.get(
1204 
				new Long(ruleDefinitionID));
1205 
	}
10 shop2020 1206 
}