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 
 
17 naveen 6 
import in.shop2020.metamodel.util.DBUtils;
45 naveen 7 
import in.shop2020.metamodel.util.ExpandedCategory;
17 naveen 8 
import in.shop2020.metamodel.util.MM;
9 
 
10 shop2020 10 
import java.io.Serializable;
18 naveen 11 
import java.util.ArrayList;
12 
import java.util.Iterator;
13 
import java.util.List;
10 shop2020 14 
import java.util.Map;
15 
 
16 
/**
17 
 * @author naveen
18 
 *
19 
 */
20 
public class DefinitionsContainer implements Serializable {
21 
 
41 naveen 22 
	/**
10 shop2020 23 
	 *
24 
	 */
25 
	private static final long serialVersionUID = 1L;
26 
	private Map<Long, Category> categories;
27 
	private Map<Long, SlideDefinition> slideDefinitions;
28 
	private Map<Long, FeatureDefinition> featureDefinitions;
29 
	private Map<Long, DatatypeDefinition> datatypeDefinitions;
24 naveen 30 
	private Map<Long, EnumValue> enumValues;
10 shop2020 31 
	private Map<Long, Unit> units;
32 
 
33 
	/**
34 
	 *
35 
	 */
36 
	public DefinitionsContainer() {
17 naveen 37 
		// Lazy initialization
10 shop2020 38 
	}
39 
 
40 
	/**
41 
	 *
42 
	 * @return Map
18 naveen 43 
	 * @throws Exception
10 shop2020 44 
	 */
18 naveen 45 
	@SuppressWarnings("unchecked")
46 
	public Map<Long, Unit> getUnits() throws Exception {
17 naveen 47 
		// De-serialize
48 
		if(this.units == null) {
18 naveen 49 
			String dbFile = MM.DEFINITIONS_DB_PATH + "units" + ".ser";
50 
 
51 
			this.units = (Map<Long, Unit>) DBUtils.read(dbFile);
17 naveen 52 
		}
18 naveen 53 
 
10 shop2020 54 
		return this.units;
55 
	}
56 
 
57 
	/**
58 
	 *
59 
	 * @param unitID
60 
	 * @return Unit
18 naveen 61 
	 * @throws Exception
10 shop2020 62 
	 */
18 naveen 63 
	public Unit getUnit(long unitID) throws Exception {
64 
		// Initialize
65 
		if(this.units == null) {
66 
			this.getUnits();
67 
		}
17 naveen 68 
 
10 shop2020 69 
		return this.units.get(new Long(unitID));
70 
	}
71 
 
72 
	/**
17 naveen 73 
	 * @return the datatypeDefinitions
18 naveen 74 
	 * @throws Exception
10 shop2020 75 
	 */
18 naveen 76 
	@SuppressWarnings("unchecked")
77 
	public Map<Long, DatatypeDefinition> getDatatypeDefinitions()
78 
		throws Exception {
79 
 
80 
		// De-serialize
81 
		if(this.datatypeDefinitions == null) {
19 naveen 82 
			String dbFile = MM.DEFINITIONS_DB_PATH + "datatypedefinitions" +
83 
				".ser";
18 naveen 84 
 
85 
			this.datatypeDefinitions =
86 
				(Map<Long, DatatypeDefinition>) DBUtils.read(dbFile);
87 
		}
88 
		return this.datatypeDefinitions;
10 shop2020 89 
	}
18 naveen 90 
 
91 
	/**
92 
	 *
93 
	 * @param unitID
94 
	 * @return Unit
95 
	 * @throws Exception
96 
	 */
97 
	public DatatypeDefinition getDatatypeDefinition(long id) throws Exception {
98 
 
99 
		// Initialize
100 
		if(this.datatypeDefinitions == null) {
101 
			this.getDatatypeDefinitions();
102 
		}
103 
 
104 
		return this.datatypeDefinitions.get(new Long(id));
105 
	}
19 naveen 106 
 
107 
	/**
108 
	 *
109 
	 * @param datatypeDefID
110 
	 * @param value
111 
	 * @return long enumValueID - "-1" if not found
112 
	 * @throws Exception
113 
	 */
114 
	public long getEnumValueID(long datatypeDefID, String value)
115 
		throws Exception {
116 
		long enumValueID = -1L;
117 
 
118 
		// Let the callers catch ClassCastException
119 
		EnumDefinition enumDef =
120 
			(EnumDefinition)this.getDatatypeDefinition(datatypeDefID);
121 
 
24 naveen 122 
		List<EnumValue> enumValues = enumDef.getEnumValues();
19 naveen 123 
		for(EnumValue enumValue : enumValues) {
124 
			if(value.equalsIgnoreCase(enumValue.getValue())) {
125 
				enumValueID = enumValue.getID();
126 
				break;
127 
			}
128 
		}
129 
 
130 
		return enumValueID;
131 
	}
17 naveen 132 
 
10 shop2020 133 
	/**
134 
	 * @return the categories
17 naveen 135 
	 * @throws Exception
10 shop2020 136 
	 */
17 naveen 137 
	@SuppressWarnings("unchecked")
138 
	public Map<Long, Category> getCategories() throws Exception {
139 
 
140 
		// De-serialize
141 
		if(this.categories == null) {
142 
			String dbFile = MM.DEFINITIONS_DB_PATH + "categories" + ".ser";
143 
 
144 
			this.categories = (Map<Long, Category>) DBUtils.read(dbFile);
145 
		}
146 
		return this.categories;
10 shop2020 147 
	}
17 naveen 148 
 
10 shop2020 149 
	/**
17 naveen 150 
	 *
151 
	 * @param categoryID
152 
	 * @return Category
153 
	 * @throws Exception
10 shop2020 154 
	 */
17 naveen 155 
	public Category getCategory(long categoryID) throws Exception {
156 
 
18 naveen 157 
		// Initialize
17 naveen 158 
		if(this.categories == null) {
159 
			this.getCategories();
160 
		}
161 
 
162 
		return this.categories.get(new Long(categoryID));
10 shop2020 163 
	}
17 naveen 164 
 
10 shop2020 165 
	/**
18 naveen 166 
	 *
167 
	 * @param categoryID
45 naveen 168 
	 * @return ExpandedCategory
169 
	 * @throws Exception
170 
	 */
171 
	public ExpandedCategory getExpandedCategory(long categoryID)
172 
		throws Exception {
173 
		Category category = this.getCategory(categoryID);
174 
 
175 
		ExpandedCategory expCategory = new ExpandedCategory(category);
176 
 
177 
		return expCategory;
178 
	}
179 
 
180 
	/**
181 
	 *
182 
	 * @param categoryID
34 naveen 183 
	 * @return List<Category>
184 
	 * @throws Exception
185 
	 */
186 
	public List<Category> getChildrenCategories(long categoryID)
187 
		throws Exception {
188 
 
189 
		// Initialize
190 
		if(this.categories == null) {
191 
			this.getCategories();
192 
		}
193 
 
194 
		return this.categories.get(new Long(categoryID)).getChildrenCategory();
195 
	}
196 
	/**
197 
	 *
198 
	 * @param categoryID
18 naveen 199 
	 * @return List<CategorySlideDefinition>
200 
	 * @throws Exception
201 
	 */
202 
	public List<CategorySlideDefinition> getCategorySlideDefinitions(
203 
			long categoryID) throws Exception {
204 
		Category category = this.getCategory(categoryID);
205 
 
206 
		return category.getCategorySlideDefintions();
207 
	}
208 
 
209 
	/**
10 shop2020 210 
	 * @return the slideDefinitions
18 naveen 211 
	 * @throws Exception
10 shop2020 212 
	 */
18 naveen 213 
	@SuppressWarnings("unchecked")
214 
	public Map<Long, SlideDefinition> getSlideDefinitions() throws Exception {
215 
 
216 
		// De-serialize
217 
		if(this.slideDefinitions == null) {
218 
			String dbFile = MM.DEFINITIONS_DB_PATH + "slidedefinitions" +
219 
				".ser";
220 
 
221 
			this.slideDefinitions =
222 
				(Map<Long, SlideDefinition>) DBUtils.read(dbFile);
223 
		}
224 
		return this.slideDefinitions;
10 shop2020 225 
	}
18 naveen 226 
 
227 
	/**
228 
	 *
229 
	 * @param id
230 
	 * @return SlideDefinition
231 
	 * @throws Exception
232 
	 */
233 
	public SlideDefinition getSlideDefinition(long id) throws Exception {
234 
 
235 
		// Initialize
236 
		if(this.slideDefinitions == null) {
237 
			this.getSlideDefinitions();
238 
		}
239 
 
240 
		return this.slideDefinitions.get(new Long(id));
241 
	}
242 
 
243 
	/**
244 
	 *
19 naveen 245 
	 * @param label
246 
	 * @return List<SlideDefinition>
247 
	 * @throws Exception
248 
	 */
32 naveen 249 
	public List<SlideDefinition> getSlideDefinitions(long categoryID,
250 
			String label) throws Exception {
251 
 
252 
		// RE-VISIT
253 
		// May be we need a new data structure, category id to slide definitions
254 
		// for now
255 
		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
19 naveen 256 
 
32 naveen 257 
		List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(
258 
				categoryID);
259 
 
260 
		for(CategorySlideDefinition csDef : csDefs) {
261 
			SlideDefinition sDef = this.getSlideDefinition(
262 
					csDef.getSlideDefintionID());
263 
 
264 
			if(sDef.getLabel().equalsIgnoreCase(label)) {
265 
				matchingSlides.add(sDef);
266 
			}
19 naveen 267 
		}
268 
 
32 naveen 269 
		return matchingSlides;
270 
	}
271 
 
272 
	/**
273 
	 *
274 
	 * @param categoryID
275 
	 * @return
276 
	 * @throws Exception
277 
	 */
278 
	public List<SlideDefinition> getSlideDefinitions(long categoryID)
279 
		throws Exception {
280 
 
281 
		// RE-VISIT
282 
		// May be we need a new data structure, category id to slide definitions
283 
		// for now
19 naveen 284 
		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
32 naveen 285 
 
286 
		List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(
287 
				categoryID);
288 
 
289 
		for(CategorySlideDefinition csDef : csDefs) {
290 
			SlideDefinition sDef = this.getSlideDefinition(
291 
					csDef.getSlideDefintionID());
19 naveen 292 
 
32 naveen 293 
			matchingSlides.add(sDef);
19 naveen 294 
		}
295 
 
296 
		return matchingSlides;
297 
	}
298 
	/**
299 
	 *
18 naveen 300 
	 * @param categoryID
301 
	 * @param EditorialImportance imp
302 
	 * @return List<SlideDefinition>
303 
	 * @throws Exception
304 
	 */
305 
	public List<SlideDefinition> getSlides(long categoryID,
306 
			EditorialImportance imp)
307 
		throws Exception {
308 
 
309 
		List<CategorySlideDefinition> catSlideDefs =
310 
			this.getCategorySlideDefinitions(categoryID);
311 
 
312 
		Iterator<CategorySlideDefinition> itCatSlideDefs =
313 
			catSlideDefs.iterator();
314 
 
315 
		List<SlideDefinition> slideDefs = new ArrayList<SlideDefinition>();
316 
		while(itCatSlideDefs.hasNext()) {
317 
			CategorySlideDefinition catSlideDef = itCatSlideDefs.next();
318 
			if(catSlideDef.getEditorialImportance() == imp) {
319 
				long slideDefID = catSlideDef.getSlideDefintionID();
320 
				slideDefs.add(this.getSlideDefinition(slideDefID));
321 
			}
322 
		}
323 
		return slideDefs;
324 
	}
325 
 
326 
	/**
327 
	 *
328 
	 * @return Map<Long, FeatureDefinition>
329 
	 * @throws Exception
330 
	 */
331 
	@SuppressWarnings("unchecked")
332 
	public Map<Long, FeatureDefinition> getFeatureDefinitions()
333 
		throws Exception {
334 
 
335 
		// De-serialize
336 
		if(this.featureDefinitions == null) {
337 
			String dbFile = MM.DEFINITIONS_DB_PATH + "featuredefinitions" +
338 
				".ser";
339 
 
340 
			this.featureDefinitions =
341 
				(Map<Long, FeatureDefinition>) DBUtils.read(dbFile);
342 
		}
343 
		return this.featureDefinitions;
344 
	}
19 naveen 345 
 
10 shop2020 346 
	/**
18 naveen 347 
	 *
19 naveen 348 
	 * @param slideID
349 
	 * @return List<FeatureDefinition>
350 
	 * @throws Exception
351 
	 */
352 
	public List<FeatureDefinition> getFeatureDefinitions(long slideID)
353 
		throws Exception {
354 
		List<FeatureDefinition> featureDefs =
355 
			new ArrayList<FeatureDefinition>();
356 
 
357 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
358 
		List<SlideFeatureDefinition> slideFeatureDefs =
359 
			slideDef.getSlideFeatureDefinitions();
360 
 
361 
		for(int i=0; i<slideFeatureDefs.size(); i++) {
362 
			featureDefs.add(this.getFeatureDefinition(
363 
					slideFeatureDefs.get(i).getFeatureDefintionID()));
364 
		}
365 
 
366 
		return featureDefs;
367 
	}
368 
 
369 
	/**
370 
	 *
371 
	 * @param slideID
372 
	 * @param imp
373 
	 * @return List<FeatureDefinition>
374 
	 * @throws Exception
375 
	 */
376 
	public List<FeatureDefinition> getFeatureDefinitions(long slideID,
377 
			EditorialImportance imp)  throws Exception {
378 
		List<FeatureDefinition> featureDefs =
379 
			new ArrayList<FeatureDefinition>();
380 
 
381 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
382 
		List<SlideFeatureDefinition> slideFeatureDefs =
383 
			slideDef.getSlideFeatureDefinitions();
384 
 
385 
		for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {
386 
			if(slideFeatureDef.getEditorialImportance() == imp) {
387 
				featureDefs.add(this.getFeatureDefinition(
388 
						slideFeatureDef.getFeatureDefintionID()));
389 
			}
390 
		}
391 
 
392 
		return featureDefs;
393 
	}
394 
 
395 
	/**
396 
	 *
18 naveen 397 
	 * @param id
19 naveen 398 
	 * @return FeatureDefinition
18 naveen 399 
	 * @throws Exception
10 shop2020 400 
	 */
18 naveen 401 
	public FeatureDefinition getFeatureDefinition(long id) throws Exception {
402 
 
403 
		// Initialize
404 
		if(this.featureDefinitions == null) {
405 
			this.getFeatureDefinitions();
406 
		}
407 
 
408 
		return this.featureDefinitions.get(new Long(id));
409 
	}
19 naveen 410 
 
411 
	/**
412 
	 *
413 
	 * @param slideID
414 
	 * @param featureLabel
415 
	 * @return FeatureDefinition
416 
	 * @throws Exception
417 
	 */
418 
	public FeatureDefinition getFeatureDefinition(long slideID,
419 
			String featureLabel) throws Exception {
420 
		FeatureDefinition featureDef = null;
421 
 
422 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
423 
		for(SlideFeatureDefinition slideFeatureDef :
424 
			slideDef.getSlideFeatureDefinitions()) {
425 
 
426 
			long featureDefID = slideFeatureDef.getFeatureDefintionID();
427 
 
428 
			FeatureDefinition thisFeatureDef = this.getFeatureDefinition(
429 
					featureDefID);
430 
 
28 naveen 431 
			if(featureLabel.equalsIgnoreCase(thisFeatureDef.getLabel())) {
19 naveen 432 
				featureDef = thisFeatureDef;
433 
			}
434 
		}
435 
 
436 
		return featureDef;
437 
	}
24 naveen 438 
 
439 
	/**
440 
	 * @return the enumValues
441 
	 * @throws Exception
442 
	 */
443 
	@SuppressWarnings("unchecked")
444 
	public Map<Long, EnumValue> getEnumValues() throws Exception {
445 
		// De-serialise
446 
		if(this.enumValues == null) {
447 
			String dbFile = MM.DEFINITIONS_DB_PATH + "enumvalues" +
448 
				".ser";
449 
 
450 
			this.enumValues =
451 
				(Map<Long, EnumValue>) DBUtils.read(dbFile);
452 
		}
453 
 
454 
		return this.enumValues;
455 
	}
19 naveen 456 
 
24 naveen 457 
	/**
458 
	 *
459 
	 * @param enumValueID
460 
	 * @return EnumValue
461 
	 * @throws Exception
462 
	 */
463 
	public EnumValue getEnumValue(long enumValueID) throws Exception {
464 
		// Initialise
465 
		if(this.enumValues == null) {
466 
			this.getEnumValues();
467 
		}
468 
 
469 
		return this.enumValues.get(new Long(enumValueID));
470 
	}
10 shop2020 471 
}