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
167 
	 * @return List<CategorySlideDefinition>
168 
	 * @throws Exception
169 
	 */
170 
	public List<CategorySlideDefinition> getCategorySlideDefinitions(
171 
			long categoryID) throws Exception {
172 
		Category category = this.getCategory(categoryID);
173 
 
174 
		return category.getCategorySlideDefintions();
175 
	}
176 
 
177 
	/**
10 shop2020 178 
	 * @return the slideDefinitions
18 naveen 179 
	 * @throws Exception
10 shop2020 180 
	 */
18 naveen 181 
	@SuppressWarnings("unchecked")
182 
	public Map<Long, SlideDefinition> getSlideDefinitions() throws Exception {
183 
 
184 
		// De-serialize
185 
		if(this.slideDefinitions == null) {
186 
			String dbFile = MM.DEFINITIONS_DB_PATH + "slidedefinitions" +
187 
				".ser";
188 
 
189 
			this.slideDefinitions =
190 
				(Map<Long, SlideDefinition>) DBUtils.read(dbFile);
191 
		}
192 
		return this.slideDefinitions;
10 shop2020 193 
	}
18 naveen 194 
 
195 
	/**
196 
	 *
197 
	 * @param id
198 
	 * @return SlideDefinition
199 
	 * @throws Exception
200 
	 */
201 
	public SlideDefinition getSlideDefinition(long id) throws Exception {
202 
 
203 
		// Initialize
204 
		if(this.slideDefinitions == null) {
205 
			this.getSlideDefinitions();
206 
		}
207 
 
208 
		return this.slideDefinitions.get(new Long(id));
209 
	}
210 
 
211 
	/**
212 
	 *
19 naveen 213 
	 * @param label
214 
	 * @return List<SlideDefinition>
215 
	 * @throws Exception
216 
	 */
32 naveen 217 
	public List<SlideDefinition> getSlideDefinitions(long categoryID,
218 
			String label) throws Exception {
219 
 
220 
		// RE-VISIT
221 
		// May be we need a new data structure, category id to slide definitions
222 
		// for now
223 
		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
19 naveen 224 
 
32 naveen 225 
		List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(
226 
				categoryID);
227 
 
228 
		for(CategorySlideDefinition csDef : csDefs) {
229 
			SlideDefinition sDef = this.getSlideDefinition(
230 
					csDef.getSlideDefintionID());
231 
 
232 
			if(sDef.getLabel().equalsIgnoreCase(label)) {
233 
				matchingSlides.add(sDef);
234 
			}
19 naveen 235 
		}
236 
 
32 naveen 237 
		return matchingSlides;
238 
	}
239 
 
240 
	/**
241 
	 *
242 
	 * @param categoryID
243 
	 * @return
244 
	 * @throws Exception
245 
	 */
246 
	public List<SlideDefinition> getSlideDefinitions(long categoryID)
247 
		throws Exception {
248 
 
249 
		// RE-VISIT
250 
		// May be we need a new data structure, category id to slide definitions
251 
		// for now
19 naveen 252 
		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
32 naveen 253 
 
254 
		List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(
255 
				categoryID);
256 
 
257 
		for(CategorySlideDefinition csDef : csDefs) {
258 
			SlideDefinition sDef = this.getSlideDefinition(
259 
					csDef.getSlideDefintionID());
19 naveen 260 
 
32 naveen 261 
			matchingSlides.add(sDef);
19 naveen 262 
		}
263 
 
264 
		return matchingSlides;
265 
	}
266 
	/**
267 
	 *
18 naveen 268 
	 * @param categoryID
269 
	 * @param EditorialImportance imp
270 
	 * @return List<SlideDefinition>
271 
	 * @throws Exception
272 
	 */
273 
	public List<SlideDefinition> getSlides(long categoryID,
274 
			EditorialImportance imp)
275 
		throws Exception {
276 
 
277 
		List<CategorySlideDefinition> catSlideDefs =
278 
			this.getCategorySlideDefinitions(categoryID);
279 
 
280 
		Iterator<CategorySlideDefinition> itCatSlideDefs =
281 
			catSlideDefs.iterator();
282 
 
283 
		List<SlideDefinition> slideDefs = new ArrayList<SlideDefinition>();
284 
		while(itCatSlideDefs.hasNext()) {
285 
			CategorySlideDefinition catSlideDef = itCatSlideDefs.next();
286 
			if(catSlideDef.getEditorialImportance() == imp) {
287 
				long slideDefID = catSlideDef.getSlideDefintionID();
288 
				slideDefs.add(this.getSlideDefinition(slideDefID));
289 
			}
290 
		}
291 
		return slideDefs;
292 
	}
293 
 
294 
	/**
295 
	 *
296 
	 * @return Map<Long, FeatureDefinition>
297 
	 * @throws Exception
298 
	 */
299 
	@SuppressWarnings("unchecked")
300 
	public Map<Long, FeatureDefinition> getFeatureDefinitions()
301 
		throws Exception {
302 
 
303 
		// De-serialize
304 
		if(this.featureDefinitions == null) {
305 
			String dbFile = MM.DEFINITIONS_DB_PATH + "featuredefinitions" +
306 
				".ser";
307 
 
308 
			this.featureDefinitions =
309 
				(Map<Long, FeatureDefinition>) DBUtils.read(dbFile);
310 
		}
311 
		return this.featureDefinitions;
312 
	}
19 naveen 313 
 
10 shop2020 314 
	/**
18 naveen 315 
	 *
19 naveen 316 
	 * @param slideID
317 
	 * @return List<FeatureDefinition>
318 
	 * @throws Exception
319 
	 */
320 
	public List<FeatureDefinition> getFeatureDefinitions(long slideID)
321 
		throws Exception {
322 
		List<FeatureDefinition> featureDefs =
323 
			new ArrayList<FeatureDefinition>();
324 
 
325 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
326 
		List<SlideFeatureDefinition> slideFeatureDefs =
327 
			slideDef.getSlideFeatureDefinitions();
328 
 
329 
		for(int i=0; i<slideFeatureDefs.size(); i++) {
330 
			featureDefs.add(this.getFeatureDefinition(
331 
					slideFeatureDefs.get(i).getFeatureDefintionID()));
332 
		}
333 
 
334 
		return featureDefs;
335 
	}
336 
 
337 
	/**
338 
	 *
339 
	 * @param slideID
340 
	 * @param imp
341 
	 * @return List<FeatureDefinition>
342 
	 * @throws Exception
343 
	 */
344 
	public List<FeatureDefinition> getFeatureDefinitions(long slideID,
345 
			EditorialImportance imp)  throws Exception {
346 
		List<FeatureDefinition> featureDefs =
347 
			new ArrayList<FeatureDefinition>();
348 
 
349 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
350 
		List<SlideFeatureDefinition> slideFeatureDefs =
351 
			slideDef.getSlideFeatureDefinitions();
352 
 
353 
		for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {
354 
			if(slideFeatureDef.getEditorialImportance() == imp) {
355 
				featureDefs.add(this.getFeatureDefinition(
356 
						slideFeatureDef.getFeatureDefintionID()));
357 
			}
358 
		}
359 
 
360 
		return featureDefs;
361 
	}
362 
 
363 
	/**
364 
	 *
18 naveen 365 
	 * @param id
19 naveen 366 
	 * @return FeatureDefinition
18 naveen 367 
	 * @throws Exception
10 shop2020 368 
	 */
18 naveen 369 
	public FeatureDefinition getFeatureDefinition(long id) throws Exception {
370 
 
371 
		// Initialize
372 
		if(this.featureDefinitions == null) {
373 
			this.getFeatureDefinitions();
374 
		}
375 
 
376 
		return this.featureDefinitions.get(new Long(id));
377 
	}
19 naveen 378 
 
379 
	/**
380 
	 *
381 
	 * @param slideID
382 
	 * @param featureLabel
383 
	 * @return FeatureDefinition
384 
	 * @throws Exception
385 
	 */
386 
	public FeatureDefinition getFeatureDefinition(long slideID,
387 
			String featureLabel) throws Exception {
388 
		FeatureDefinition featureDef = null;
389 
 
390 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
391 
		for(SlideFeatureDefinition slideFeatureDef :
392 
			slideDef.getSlideFeatureDefinitions()) {
393 
 
394 
			long featureDefID = slideFeatureDef.getFeatureDefintionID();
395 
 
396 
			FeatureDefinition thisFeatureDef = this.getFeatureDefinition(
397 
					featureDefID);
398 
 
28 naveen 399 
			if(featureLabel.equalsIgnoreCase(thisFeatureDef.getLabel())) {
19 naveen 400 
				featureDef = thisFeatureDef;
401 
			}
402 
		}
403 
 
404 
		return featureDef;
405 
	}
24 naveen 406 
 
407 
	/**
408 
	 * @return the enumValues
409 
	 * @throws Exception
410 
	 */
411 
	@SuppressWarnings("unchecked")
412 
	public Map<Long, EnumValue> getEnumValues() throws Exception {
413 
		// De-serialise
414 
		if(this.enumValues == null) {
415 
			String dbFile = MM.DEFINITIONS_DB_PATH + "enumvalues" +
416 
				".ser";
417 
 
418 
			this.enumValues =
419 
				(Map<Long, EnumValue>) DBUtils.read(dbFile);
420 
		}
421 
 
422 
		return this.enumValues;
423 
	}
19 naveen 424 
 
24 naveen 425 
	/**
426 
	 *
427 
	 * @param enumValueID
428 
	 * @return EnumValue
429 
	 * @throws Exception
430 
	 */
431 
	public EnumValue getEnumValue(long enumValueID) throws Exception {
432 
		// Initialise
433 
		if(this.enumValues == null) {
434 
			this.getEnumValues();
435 
		}
436 
 
437 
		return this.enumValues.get(new Long(enumValueID));
438 
	}
10 shop2020 439 
}