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