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 
	 */
217 
	public List<SlideDefinition> getSlideDefinition(String label)
218 
		throws Exception {
219 
 
220 
		// Initialize
221 
		if(this.slideDefinitions == null) {
222 
			this.getSlideDefinitions();
223 
		}
224 
 
225 
		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
226 
		for(Iterator<SlideDefinition> it =
227 
			this.slideDefinitions.values().iterator(); it.hasNext(); ) {
228 
 
229 
			SlideDefinition def = it.next();
230 
			if(def.getLabel().equals(label)) {
231 
				matchingSlides.add(def);
232 
			}
233 
		}
234 
 
235 
		return matchingSlides;
236 
	}
237 
	/**
238 
	 *
18 naveen 239 
	 * @param categoryID
240 
	 * @param EditorialImportance imp
241 
	 * @return List<SlideDefinition>
242 
	 * @throws Exception
243 
	 */
244 
	public List<SlideDefinition> getSlides(long categoryID,
245 
			EditorialImportance imp)
246 
		throws Exception {
247 
 
248 
		List<CategorySlideDefinition> catSlideDefs =
249 
			this.getCategorySlideDefinitions(categoryID);
250 
 
251 
		Iterator<CategorySlideDefinition> itCatSlideDefs =
252 
			catSlideDefs.iterator();
253 
 
254 
		List<SlideDefinition> slideDefs = new ArrayList<SlideDefinition>();
255 
		while(itCatSlideDefs.hasNext()) {
256 
			CategorySlideDefinition catSlideDef = itCatSlideDefs.next();
257 
			if(catSlideDef.getEditorialImportance() == imp) {
258 
				long slideDefID = catSlideDef.getSlideDefintionID();
259 
				slideDefs.add(this.getSlideDefinition(slideDefID));
260 
			}
261 
		}
262 
		return slideDefs;
263 
	}
264 
 
265 
	/**
266 
	 *
267 
	 * @return Map<Long, FeatureDefinition>
268 
	 * @throws Exception
269 
	 */
270 
	@SuppressWarnings("unchecked")
271 
	public Map<Long, FeatureDefinition> getFeatureDefinitions()
272 
		throws Exception {
273 
 
274 
		// De-serialize
275 
		if(this.featureDefinitions == null) {
276 
			String dbFile = MM.DEFINITIONS_DB_PATH + "featuredefinitions" +
277 
				".ser";
278 
 
279 
			this.featureDefinitions =
280 
				(Map<Long, FeatureDefinition>) DBUtils.read(dbFile);
281 
		}
282 
		return this.featureDefinitions;
283 
	}
19 naveen 284 
 
10 shop2020 285 
	/**
18 naveen 286 
	 *
19 naveen 287 
	 * @param slideID
288 
	 * @return List<FeatureDefinition>
289 
	 * @throws Exception
290 
	 */
291 
	public List<FeatureDefinition> getFeatureDefinitions(long slideID)
292 
		throws Exception {
293 
		List<FeatureDefinition> featureDefs =
294 
			new ArrayList<FeatureDefinition>();
295 
 
296 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
297 
		List<SlideFeatureDefinition> slideFeatureDefs =
298 
			slideDef.getSlideFeatureDefinitions();
299 
 
300 
		for(int i=0; i<slideFeatureDefs.size(); i++) {
301 
			featureDefs.add(this.getFeatureDefinition(
302 
					slideFeatureDefs.get(i).getFeatureDefintionID()));
303 
		}
304 
 
305 
		return featureDefs;
306 
	}
307 
 
308 
	/**
309 
	 *
310 
	 * @param slideID
311 
	 * @param imp
312 
	 * @return List<FeatureDefinition>
313 
	 * @throws Exception
314 
	 */
315 
	public List<FeatureDefinition> getFeatureDefinitions(long slideID,
316 
			EditorialImportance imp)  throws Exception {
317 
		List<FeatureDefinition> featureDefs =
318 
			new ArrayList<FeatureDefinition>();
319 
 
320 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
321 
		List<SlideFeatureDefinition> slideFeatureDefs =
322 
			slideDef.getSlideFeatureDefinitions();
323 
 
324 
		for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {
325 
			if(slideFeatureDef.getEditorialImportance() == imp) {
326 
				featureDefs.add(this.getFeatureDefinition(
327 
						slideFeatureDef.getFeatureDefintionID()));
328 
			}
329 
		}
330 
 
331 
		return featureDefs;
332 
	}
333 
 
334 
	/**
335 
	 *
18 naveen 336 
	 * @param id
19 naveen 337 
	 * @return FeatureDefinition
18 naveen 338 
	 * @throws Exception
10 shop2020 339 
	 */
18 naveen 340 
	public FeatureDefinition getFeatureDefinition(long id) throws Exception {
341 
 
342 
		// Initialize
343 
		if(this.featureDefinitions == null) {
344 
			this.getFeatureDefinitions();
345 
		}
346 
 
347 
		return this.featureDefinitions.get(new Long(id));
348 
	}
19 naveen 349 
 
350 
	/**
351 
	 *
352 
	 * @param slideID
353 
	 * @param featureLabel
354 
	 * @return FeatureDefinition
355 
	 * @throws Exception
356 
	 */
357 
	public FeatureDefinition getFeatureDefinition(long slideID,
358 
			String featureLabel) throws Exception {
359 
		FeatureDefinition featureDef = null;
360 
 
361 
		SlideDefinition slideDef = this.getSlideDefinition(slideID);
362 
		for(SlideFeatureDefinition slideFeatureDef :
363 
			slideDef.getSlideFeatureDefinitions()) {
364 
 
365 
			long featureDefID = slideFeatureDef.getFeatureDefintionID();
366 
 
367 
			FeatureDefinition thisFeatureDef = this.getFeatureDefinition(
368 
					featureDefID);
369 
 
370 
			if(featureLabel.equals(thisFeatureDef.getLabel())) {
371 
				featureDef = thisFeatureDef;
372 
			}
373 
		}
374 
 
375 
		return featureDef;
376 
	}
24 naveen 377 
 
378 
	/**
379 
	 * @return the enumValues
380 
	 * @throws Exception
381 
	 */
382 
	@SuppressWarnings("unchecked")
383 
	public Map<Long, EnumValue> getEnumValues() throws Exception {
384 
		// De-serialise
385 
		if(this.enumValues == null) {
386 
			String dbFile = MM.DEFINITIONS_DB_PATH + "enumvalues" +
387 
				".ser";
388 
 
389 
			this.enumValues =
390 
				(Map<Long, EnumValue>) DBUtils.read(dbFile);
391 
		}
392 
 
393 
		return this.enumValues;
394 
	}
19 naveen 395 
 
24 naveen 396 
	/**
397 
	 *
398 
	 * @param enumValueID
399 
	 * @return EnumValue
400 
	 * @throws Exception
401 
	 */
402 
	public EnumValue getEnumValue(long enumValueID) throws Exception {
403 
		// Initialise
404 
		if(this.enumValues == null) {
405 
			this.getEnumValues();
406 
		}
407 
 
408 
		return this.enumValues.get(new Long(enumValueID));
409 
	}
10 shop2020 410 
}