Subversion Repositories SmartDukaan

Rev

Rev 1154 | Rev 1226 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
479 rajveer 1 
package in.shop2020.metamodel.util;
2 
 
3 
import in.shop2020.metamodel.core.Entity;
1050 rajveer 4 
import in.shop2020.metamodel.core.EntityState;
1153 rajveer 5 
import in.shop2020.metamodel.core.Feature;
6 
import in.shop2020.metamodel.core.Slide;
1165 rajveer 7 
import in.shop2020.metamodel.definitions.Catalog;
8 
import in.shop2020.metamodel.definitions.Category;
9 
import in.shop2020.metamodel.definitions.CategorySlideDefinition;
479 rajveer 10 
import in.shop2020.metamodel.util.CN;
1050 rajveer 11 
import in.shop2020.storage.bdb.StorageManager;
479 rajveer 12 
 
13 
import java.io.PrintWriter;
14 
import java.io.StringWriter;
15 
import java.io.Writer;
1153 rajveer 16 
import java.util.ArrayList;
1050 rajveer 17 
import java.util.Collection;
479 rajveer 18 
import java.util.List;
19 
import java.util.Map;
20 
 
21 
/**
1154 rajveer 22 
 * All storage and retrival utility methods
1050 rajveer 23 
 * @author rajveer
479 rajveer 24 
 *
25 
 */
26 
public class CreationUtils {
1050 rajveer 27 
 
28 
	private static final String LEARNED_BULLETS = "LEARNED_BULLETS";
29 
	private static final String DEFAULT_ENTITY_SCORES = "DEFAULT_ENTITY_SCORES";
30 
	private static final String FACET_VALUES = "FACET_VALUES";
31 
	private static final String SLIDE_SCORES = "SLIDE_SCORES";
32 
 
479 rajveer 33 
 
34 
	/**
35 
	 *
1050 rajveer 36 
	 * @param aThrowable
479 rajveer 37 
	 * @return
38 
	 */
1050 rajveer 39 
	public static String getStackTrace(Throwable aThrowable) {
40 
	    final Writer result = new StringWriter();
41 
	    final PrintWriter printWriter = new PrintWriter(result);
42 
	    aThrowable.printStackTrace(printWriter);
43 
	    return result.toString();
479 rajveer 44 
	}
45 
 
46 
	/**
47 
	 *
1050 rajveer 48 
	 * @param entity
479 rajveer 49 
	 * @throws Exception
50 
	 */
1050 rajveer 51 
	public static void storeLearnedBullets(Map<Long, List<ExpandedBullet>> learnedBullets) throws Exception {
52 
		StorageManager.getStorageManager().storeDataObject(CreationUtils.LEARNED_BULLETS, learnedBullets);
479 rajveer 53 
	}
54 
 
1154 rajveer 55 
	/**
56 
	 *
57 
	 * @return
58 
	 * @throws Exception
59 
	 */
479 rajveer 60 
	@SuppressWarnings("unchecked")
1050 rajveer 61 
	public static Map<Long, List<ExpandedBullet>> getLearnedBullets() throws Exception {
62 
		return (Map<Long, List<ExpandedBullet>>) StorageManager.getStorageManager().getDataObject(CreationUtils.LEARNED_BULLETS);
479 rajveer 63 
	}
64 
 
1154 rajveer 65 
	/**
66 
	 *
67 
	 * @param featureDefinitionID
68 
	 * @return
69 
	 * @throws Exception
70 
	 */
1050 rajveer 71 
	@SuppressWarnings("unchecked")
72 
	public static List<ExpandedBullet> getLearnedBullets(long featureDefinitionID) throws Exception {
73 
		Map<Long, List<ExpandedBullet>> learnedBullets = (Map<Long, List<ExpandedBullet>>) StorageManager.getStorageManager().getDataObject(CreationUtils.LEARNED_BULLETS);
74 
		if(learnedBullets==null){
75 
			return null;
479 rajveer 76 
		}
1050 rajveer 77 
		return learnedBullets.get(featureDefinitionID);
479 rajveer 78 
	}
1050 rajveer 79 
 
1154 rajveer 80 
	/**
81 
	 *
82 
	 * @param facetIDFacetValues
83 
	 * @throws Exception
84 
	 */
1050 rajveer 85 
	public static void storeFacetValues(Map<Long, List<String>> facetIDFacetValues) throws Exception {
86 
		StorageManager.getStorageManager().storeDataObject(CreationUtils.FACET_VALUES, facetIDFacetValues);
479 rajveer 87 
	}
1050 rajveer 88 
 
1154 rajveer 89 
	/**
90 
	 *
91 
	 * @return
92 
	 * @throws Exception
93 
	 */
1050 rajveer 94 
	@SuppressWarnings("unchecked")
95 
	public static Map<Long, List<String>>  getFacetValues() throws Exception {
96 
		return (Map<Long, List<String>>) StorageManager.getStorageManager().getDataObject(CreationUtils.FACET_VALUES);
479 rajveer 97 
	}
98 
 
1154 rajveer 99 
	/**
100 
	 *
101 
	 * @param facetDefinitionID
102 
	 * @return
103 
	 * @throws Exception
104 
	 */
1050 rajveer 105 
	@SuppressWarnings("unchecked")
106 
	public static List<String>  getFacetValues(long facetDefinitionID) throws Exception {
107 
		Map<Long, List<String>> facetValues = (Map<Long, List<String>>) StorageManager.getStorageManager().getDataObject(CreationUtils.FACET_VALUES);
108 
		return facetValues.get(facetDefinitionID);
479 rajveer 109 
	}
1050 rajveer 110 
 
1154 rajveer 111 
	/**
112 
	 *
113 
	 * @param slideScoresByEntity
114 
	 * @throws Exception
115 
	 */
1050 rajveer 116 
	public static void storeSlideScores( Map<Long, Map<Long, Integer>> slideScoresByEntity) throws Exception {
117 
		StorageManager.getStorageManager().storeDataObject(CreationUtils.SLIDE_SCORES, slideScoresByEntity);
118 
	}
119 
 
1154 rajveer 120 
	/**
121 
	 *
122 
	 * @return
123 
	 * @throws Exception
124 
	 */
479 rajveer 125 
	@SuppressWarnings("unchecked")
1050 rajveer 126 
	public static Map<Long, Map<Long, Integer>> getSlideScores() throws Exception {
127 
		return (Map<Long, Map<Long, Integer>>) StorageManager.getStorageManager().getDataObject(CreationUtils.SLIDE_SCORES);
479 rajveer 128 
	}
129 
 
1154 rajveer 130 
	/**
131 
	 *
132 
	 * @param entityID
133 
	 * @return
134 
	 * @throws Exception
135 
	 */
1050 rajveer 136 
	@SuppressWarnings("unchecked")
137 
	public static Map<Long, Integer> getSlideComparisonScores(long entityID) throws Exception{
138 
		Map<Long, Map<Long, Integer>> slideScores = (Map<Long, Map<Long, Integer>>) StorageManager.getStorageManager().getDataObject(CreationUtils.SLIDE_SCORES);
139 
		return slideScores.get(entityID);
479 rajveer 140 
	}
141 
 
1050 rajveer 142 
 
1154 rajveer 143 
	/**
144 
	 *
145 
	 * @param finalScoreByEntityID
146 
	 * @throws Exception
147 
	 */
1050 rajveer 148 
	public static void storeDefaultEntityScores(Map<Long, Integer> finalScoreByEntityID) throws Exception {
149 
		StorageManager.getStorageManager().storeDataObject(CreationUtils.DEFAULT_ENTITY_SCORES, finalScoreByEntityID);
479 rajveer 150 
	}
151 
 
1154 rajveer 152 
	/**
153 
	 *
154 
	 * @return
155 
	 * @throws Exception
156 
	 */
1050 rajveer 157 
	@SuppressWarnings("unchecked")
158 
	public static Map<Long, Integer> getDefaultEntityScores() throws Exception {
159 
		return (Map<Long, Integer>) StorageManager.getStorageManager().getDataObject(CreationUtils.DEFAULT_ENTITY_SCORES);
479 rajveer 160 
	}
161 
 
1154 rajveer 162 
	/**
163 
	 *
164 
	 * @param entityID
165 
	 * @return
166 
	 * @throws Exception
167 
	 */
1050 rajveer 168 
	@SuppressWarnings("unchecked")
169 
	public static Integer getEntityComparisonScores(long entityID) throws Exception {
170 
		Map<Long, Integer> scoresMap =  (Map<Long, Integer>) StorageManager.getStorageManager().getDataObject(CreationUtils.DEFAULT_ENTITY_SCORES);
171 
		Integer objScore = scoresMap.get(entityID);
172 
		if(objScore==null){
173 
			return -1;
479 rajveer 174 
		}
1050 rajveer 175 
		return objScore;
479 rajveer 176 
	}
177 
 
178 
 
179 
 
180 
	/**
1050 rajveer 181 
	 * Resolves Entity ID into Entity object
479 rajveer 182 
	 *
183 
	 * @param entityID
1050 rajveer 184 
	 * @return Entity
185 
	 * @throws Exception
479 rajveer 186 
	 */
1050 rajveer 187 
	public static Entity getEntity(long entityID) throws Exception{
188 
		return StorageManager.getStorageManager().getEntity(entityID);
479 rajveer 189 
	}
190 
 
1154 rajveer 191 
	/**
192 
	 *
193 
	 * @param entity
194 
	 * @throws Exception
195 
	 */
1050 rajveer 196 
	public static void updateEntity(Entity entity) throws Exception {
197 
		entity.reorderSlides(entity.getSlideSequence());
198 
		StorageManager.getStorageManager().updateEntity(entity);
199 
		CreationUtils.learn(entity);
479 rajveer 200 
	}
201 
 
1154 rajveer 202 
	/**
203 
	 *
204 
	 * @param entity
205 
	 * @param entityMetadata
206 
	 * @throws Exception
207 
	 */
1050 rajveer 208 
	public static void createEntity(Entity entity, EntityState entityMetadata) throws Exception {
209 
		StorageManager.getStorageManager().createEntity(entity, entityMetadata);
479 rajveer 210 
	}
1050 rajveer 211 
 
1154 rajveer 212 
	/**
213 
	 *
214 
	 * @param entityId
215 
	 * @throws Exception
216 
	 */
1050 rajveer 217 
	public static void deleteEntity(long entityId) throws Exception  {
218 
		StorageManager.getStorageManager().deleteEntity(entityId);
479 rajveer 219 
	}
220 
 
1050 rajveer 221 
 
1154 rajveer 222 
	/**
223 
	 *
224 
	 * @return
225 
	 * @throws Exception
226 
	 */
1050 rajveer 227 
	public static Map<Long, EntityState> getEntitiesState() throws Exception {
228 
		return StorageManager.getStorageManager().getEntitiesMetadata();
479 rajveer 229 
	}
230 
 
1154 rajveer 231 
	/**
232 
	 *
233 
	 * @param entityId
234 
	 * @return
235 
	 * @throws Exception
236 
	 */
1050 rajveer 237 
	public static EntityState getEntityState(long entityId) throws Exception {
238 
		return StorageManager.getStorageManager().getEntityMetadata(entityId);
239 
	}
479 rajveer 240 
 
1154 rajveer 241 
	/**
242 
	 *
243 
	 * @param entityMetadata
244 
	 * @throws Exception
245 
	 */
1050 rajveer 246 
	public static void updateEntityState(EntityState entityMetadata) throws Exception {
247 
		StorageManager.getStorageManager().updateEntityMetadata(entityMetadata);
479 rajveer 248 
	}
1050 rajveer 249 
 
1154 rajveer 250 
	/**
251 
	 *
252 
	 * @param entity
253 
	 * @throws Exception
254 
	 */
1050 rajveer 255 
	private static void learn(Entity entity) throws Exception{
256 
		CN cn = new CN();
257 
		cn.learn(entity);
258 
	}
259 
 
1154 rajveer 260 
	/**
261 
	 *
262 
	 * @return
263 
	 * @throws Exception
264 
	 */
1050 rajveer 265 
	public static Map<Long, Entity> getEntities() throws Exception {
266 
		return StorageManager.getStorageManager().getEntities();
267 
	}
268 
 
1154 rajveer 269 
	/**
270 
	 *
271 
	 * @param categoryId
272 
	 * @return
273 
	 * @throws Exception
274 
	 */
1050 rajveer 275 
	public static Collection<Entity> getEntities(long categoryId) throws Exception {
276 
		return StorageManager.getStorageManager().getEntitisByCategory(categoryId);
277 
	}
1153 rajveer 278 
 
279 
	/**
280 
	 *
281 
	 * @param slide
282 
	 * @param featureDefinitionID
283 
	 * @return Feature
284 
	 */
285 
	public static Feature getFeature(Slide slide, long featureDefinitionID) {
286 
		List<Feature> features = slide.getFeatures();
287 
 
288 
		if(features != null) {
289 
			for(Feature feature : features) {
290 
				if(feature.getFeatureDefinitionID() == featureDefinitionID) {
291 
					return feature;
292 
				}
293 
			}
294 
		}
295 
 
296 
		Feature feature = null;
297 
 
298 
		List<Slide> childrenSlides = slide.getChildrenSlides();
299 
		if(childrenSlides != null) {
300 
			for(Slide childSlide : childrenSlides) {
301 
 
302 
				feature = CreationUtils.getFeature(childSlide, featureDefinitionID);
303 
				if(feature == null) {
304 
					continue;
305 
				}
306 
				else {
307 
					break;
308 
				}
309 
			}
310 
		}
311 
 
312 
		return feature;
313 
	}
479 rajveer 314 
 
1153 rajveer 315 
 
316 
	/**
317 
	 * Utility method to find out Slide object in Entity instance
318 
	 *
319 
	 * @param entityID
320 
	 * @param slideDefinitionID
321 
	 * @return
322 
	 * @throws Exception
323 
	 */
324 
	public static Slide getSlide(long entityID, long slideDefinitionID)
325 
		throws Exception {
326 
		Entity entity = CreationUtils.getEntity(entityID);
327 
 
328 
		List<Slide> slides = entity.getSlides();
329 
 
330 
		Slide resultSlide = null;
331 
 
332 
		if(slides != null) {
333 
			for(Slide slide : slides) {
334 
 
335 
				if(slide.getSlideDefinitionID() == slideDefinitionID) {
336 
					return slide;
337 
				}
338 
 
339 
				resultSlide = CreationUtils.getSlide(slide, slideDefinitionID);
340 
 
341 
				if(resultSlide == null) {
342 
					continue;
343 
				}
344 
				else {
345 
					break;
346 
				}
347 
			}
348 
		}
349 
 
350 
		return resultSlide;
351 
	}
352 
 
353 
 
354 
	/**
355 
	 *
356 
	 * @param slide
357 
	 * @param slideDefinitionID
358 
	 * @return
359 
	 */
360 
	public static Slide getSlide(Slide slide, long slideDefinitionID) {
361 
 
362 
		List<Slide> childrenSlides = slide.getChildrenSlides();
363 
 
364 
		Slide resultSlide = null;
365 
 
366 
		if(childrenSlides != null) {
367 
			for(Slide childSlide : childrenSlides) {
368 
				if(childSlide.getSlideDefinitionID() == slideDefinitionID) {
369 
					return childSlide;
370 
				}
371 
 
372 
				resultSlide = CreationUtils.getSlide(childSlide, slideDefinitionID);
373 
				if(resultSlide == null) {
374 
					continue;
375 
				}
376 
				else {
377 
					break;
378 
				}
379 
			}
380 
		}
381 
 
382 
		return resultSlide;
383 
	}
384 
 
385 
	/**
386 
	 * Utility method to find out Feature object in Entity instance
387 
	 *
388 
	 * @param entityID
389 
	 * @param featureDefinitionID
390 
	 * @return Feature
391 
	 * @throws Exception
392 
	 */
393 
	public static Feature getFeature(long entityID, long featureDefinitionID)
394 
		throws Exception {
395 
		Entity entity = CreationUtils.getEntity(entityID);
396 
 
397 
		Feature feature = null;
398 
 
399 
		List<Slide> slides = entity.getSlides();
400 
		for(Slide slide : slides) {
401 
			feature = CreationUtils.getFeature(slide, featureDefinitionID);
402 
 
403 
			// Until all slides are searched
404 
			if(feature == null) {
405 
				continue;
406 
			}
407 
			else {
408 
				break;
409 
			}
410 
		}
411 
 
412 
		return feature;
413 
	}
414 
 
415 
 
416 
	/**
417 
	 * Returns expand form of entity object. All references are resolved into
418 
	 * corresponding detail object
419 
	 *
420 
	 * @param entityID
421 
	 * @return ExpandedEntity
422 
	 * @throws Exception
423 
	 */
424 
	public static ExpandedEntity getExpandedEntity(long entityID) throws Exception {
425 
		Entity entity = CreationUtils.getEntity(entityID);
426 
		if(entity==null){
427 
			System.out.println("Entity is null");
428 
			return null;
429 
		}
430 
		System.out.println( entity.getCategoryID());
431 
		ExpandedEntity expEntity = new ExpandedEntity(entity);
432 
		return expEntity;
433 
	}
434 
 
435 
 
436 
	/**
437 
	 * Returns list of borrowed slides
438 
	 *
439 
	 * @param entity
440 
	 * @return list of borrowed slides
441 
	 */
442 
	public static List<Slide> getBorrowedSlides(Entity entity) {
443 
		List<Slide> borrowedSlides = new ArrayList<Slide>();
444 
 
445 
		List<Slide> slides = entity.getSlides();
446 
 
447 
		for(Slide slide : slides) {
1165 rajveer 448 
			if(CreationUtils.isBorrowedSlide(slide.getSlideDefinitionID(), entity.getCategoryID())) {
1153 rajveer 449 
				borrowedSlides.add(slide);
450 
			}
451 
		}
452 
 
453 
		return borrowedSlides;
454 
	}
455 
 
456 
	/**
457 
	 * Returns first parent slide with matching label
458 
	 *
459 
	 * @param expEntity2
460 
	 * @param slideLabel
461 
	 * @return Null if not found
462 
	 */
463 
	public static ExpandedSlide getParentExpandedSlide(ExpandedEntity expEntity2, String slideLabel) {
464 
 
465 
		ExpandedSlide matchingSlide = null;
466 
		List<ExpandedSlide> expSlides = expEntity2.getExpandedSlides();
467 
 
468 
		for(ExpandedSlide expSlide : expSlides) {
469 
			if(expSlide.getSlideDefinition().getLabel().equals(slideLabel)) {
470 
				matchingSlide = expSlide;
471 
				break;
472 
			}
473 
		}
474 
 
475 
		return matchingSlide;
476 
	}
1165 rajveer 477 
 
478 
	/**
479 
	 *
480 
	 * @param slideDefinitionID
481 
	 * @param categoryID
482 
	 * @return
483 
	 */
484 
	public static boolean isBorrowedSlide(long slideDefinitionID,long categoryID) {
485 
		List<CategorySlideDefinition> slideDefinitionIds;
486 
		try {
487 
			slideDefinitionIds = Catalog.getInstance().getDefinitionsContainer().getCategorySlideDefinitions(categoryID);
488 
			if(slideDefinitionIds.contains(slideDefinitionIds)){
489 
				return false;
490 
			}else{
491 
				return true;
492 
			}
1153 rajveer 493 
 
1165 rajveer 494 
		} catch (Exception e) {
495 
			// TODO Auto-generated catch block
496 
			e.printStackTrace();
497 
		}
498 
		return false;
499 
	}
500 
 
501 
	/**
502 
	 *
503 
	 * @param slideDefinitionID
504 
	 * @param categoryID
505 
	 * @return
506 
	 */
507 
	public static long getBorrowedCategoryID(long slideDefinitionID, long categoryID) {
508 
		try {
509 
			List<CategorySlideDefinition> slideDefinitionIds = Catalog.getInstance().getDefinitionsContainer().getCategorySlideDefinitions(categoryID);
510 
			if(slideDefinitionIds.contains(slideDefinitionID)){
511 
				return -1;
512 
			}else{
513 
				List<Category> cats =  Catalog.getInstance().getDefinitionsContainer().getCategory(categoryID).getParentCategory().getChildrenCategory();
514 
				for(Category cat: cats){
515 
					if(cat.getID() == categoryID){
516 
						continue;
517 
					}else{
518 
						if(Catalog.getInstance().getDefinitionsContainer().getCategorySlideDefinitions(cat.getID()).contains(slideDefinitionID)){
519 
							return cat.getID();
520 
						}
521 
					}
522 
				}
523 
			}
524 
		} catch (Exception e) {
525 
			// TODO Auto-generated catch block
526 
			e.printStackTrace();
527 
		}
528 
		return -1;
529 
	}
530 
 
479 rajveer 531 
}