Subversion Repositories SmartDukaan

Rev

Rev 1365 | Rev 1443 | 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 {
1379 rajveer 197 
		entity.reorderSlides(entity.getSlideSequence());
1050 rajveer 198 
		StorageManager.getStorageManager().updateEntity(entity);
1226 rajveer 199 
 
200 
		//This should not happen here. Reordering should be done manually.
1379 rajveer 201 
 
1365 rajveer 202 
		CreationUtils.learn(entity);
479 rajveer 203 
	}
204 
 
1154 rajveer 205 
	/**
206 
	 *
207 
	 * @param entity
208 
	 * @param entityMetadata
209 
	 * @throws Exception
210 
	 */
1050 rajveer 211 
	public static void createEntity(Entity entity, EntityState entityMetadata) throws Exception {
212 
		StorageManager.getStorageManager().createEntity(entity, entityMetadata);
479 rajveer 213 
	}
1050 rajveer 214 
 
1154 rajveer 215 
	/**
216 
	 *
217 
	 * @param entityId
218 
	 * @throws Exception
219 
	 */
1050 rajveer 220 
	public static void deleteEntity(long entityId) throws Exception  {
221 
		StorageManager.getStorageManager().deleteEntity(entityId);
479 rajveer 222 
	}
223 
 
1050 rajveer 224 
 
1154 rajveer 225 
	/**
226 
	 *
227 
	 * @return
228 
	 * @throws Exception
229 
	 */
1050 rajveer 230 
	public static Map<Long, EntityState> getEntitiesState() throws Exception {
231 
		return StorageManager.getStorageManager().getEntitiesMetadata();
479 rajveer 232 
	}
233 
 
1154 rajveer 234 
	/**
235 
	 *
236 
	 * @param entityId
237 
	 * @return
238 
	 * @throws Exception
239 
	 */
1050 rajveer 240 
	public static EntityState getEntityState(long entityId) throws Exception {
241 
		return StorageManager.getStorageManager().getEntityMetadata(entityId);
242 
	}
479 rajveer 243 
 
1154 rajveer 244 
	/**
245 
	 *
246 
	 * @param entityMetadata
247 
	 * @throws Exception
248 
	 */
1050 rajveer 249 
	public static void updateEntityState(EntityState entityMetadata) throws Exception {
250 
		StorageManager.getStorageManager().updateEntityMetadata(entityMetadata);
479 rajveer 251 
	}
1050 rajveer 252 
 
1154 rajveer 253 
	/**
254 
	 *
255 
	 * @param entity
256 
	 * @throws Exception
257 
	 */
1050 rajveer 258 
	private static void learn(Entity entity) throws Exception{
259 
		CN cn = new CN();
260 
		cn.learn(entity);
261 
	}
262 
 
1154 rajveer 263 
	/**
264 
	 *
265 
	 * @return
266 
	 * @throws Exception
267 
	 */
1050 rajveer 268 
	public static Map<Long, Entity> getEntities() throws Exception {
269 
		return StorageManager.getStorageManager().getEntities();
270 
	}
271 
 
1154 rajveer 272 
	/**
273 
	 *
274 
	 * @param categoryId
275 
	 * @return
276 
	 * @throws Exception
277 
	 */
1050 rajveer 278 
	public static Collection<Entity> getEntities(long categoryId) throws Exception {
279 
		return StorageManager.getStorageManager().getEntitisByCategory(categoryId);
280 
	}
1153 rajveer 281 
 
282 
	/**
283 
	 *
284 
	 * @param slide
285 
	 * @param featureDefinitionID
286 
	 * @return Feature
287 
	 */
288 
	public static Feature getFeature(Slide slide, long featureDefinitionID) {
289 
		List<Feature> features = slide.getFeatures();
290 
 
291 
		if(features != null) {
292 
			for(Feature feature : features) {
293 
				if(feature.getFeatureDefinitionID() == featureDefinitionID) {
294 
					return feature;
295 
				}
296 
			}
297 
		}
298 
 
299 
		Feature feature = null;
300 
 
301 
		List<Slide> childrenSlides = slide.getChildrenSlides();
302 
		if(childrenSlides != null) {
303 
			for(Slide childSlide : childrenSlides) {
304 
 
305 
				feature = CreationUtils.getFeature(childSlide, featureDefinitionID);
306 
				if(feature == null) {
307 
					continue;
308 
				}
309 
				else {
310 
					break;
311 
				}
312 
			}
313 
		}
314 
 
315 
		return feature;
316 
	}
479 rajveer 317 
 
1153 rajveer 318 
 
319 
	/**
320 
	 * Utility method to find out Slide object in Entity instance
321 
	 *
322 
	 * @param entityID
323 
	 * @param slideDefinitionID
324 
	 * @return
325 
	 * @throws Exception
326 
	 */
327 
	public static Slide getSlide(long entityID, long slideDefinitionID)
328 
		throws Exception {
329 
		Entity entity = CreationUtils.getEntity(entityID);
330 
 
331 
		List<Slide> slides = entity.getSlides();
332 
 
333 
		Slide resultSlide = null;
334 
 
335 
		if(slides != null) {
336 
			for(Slide slide : slides) {
337 
 
338 
				if(slide.getSlideDefinitionID() == slideDefinitionID) {
339 
					return slide;
340 
				}
341 
 
342 
				resultSlide = CreationUtils.getSlide(slide, slideDefinitionID);
343 
 
344 
				if(resultSlide == null) {
345 
					continue;
346 
				}
347 
				else {
348 
					break;
349 
				}
350 
			}
351 
		}
352 
 
353 
		return resultSlide;
354 
	}
355 
 
356 
 
357 
	/**
358 
	 *
359 
	 * @param slide
360 
	 * @param slideDefinitionID
361 
	 * @return
362 
	 */
363 
	public static Slide getSlide(Slide slide, long slideDefinitionID) {
364 
 
365 
		List<Slide> childrenSlides = slide.getChildrenSlides();
366 
 
367 
		Slide resultSlide = null;
368 
 
369 
		if(childrenSlides != null) {
370 
			for(Slide childSlide : childrenSlides) {
371 
				if(childSlide.getSlideDefinitionID() == slideDefinitionID) {
372 
					return childSlide;
373 
				}
374 
 
375 
				resultSlide = CreationUtils.getSlide(childSlide, slideDefinitionID);
376 
				if(resultSlide == null) {
377 
					continue;
378 
				}
379 
				else {
380 
					break;
381 
				}
382 
			}
383 
		}
384 
 
385 
		return resultSlide;
386 
	}
387 
 
388 
	/**
389 
	 * Utility method to find out Feature object in Entity instance
390 
	 *
391 
	 * @param entityID
392 
	 * @param featureDefinitionID
393 
	 * @return Feature
394 
	 * @throws Exception
395 
	 */
396 
	public static Feature getFeature(long entityID, long featureDefinitionID)
397 
		throws Exception {
398 
		Entity entity = CreationUtils.getEntity(entityID);
399 
 
400 
		Feature feature = null;
401 
 
402 
		List<Slide> slides = entity.getSlides();
403 
		for(Slide slide : slides) {
404 
			feature = CreationUtils.getFeature(slide, featureDefinitionID);
405 
 
406 
			// Until all slides are searched
407 
			if(feature == null) {
408 
				continue;
409 
			}
410 
			else {
411 
				break;
412 
			}
413 
		}
414 
 
415 
		return feature;
416 
	}
417 
 
418 
 
419 
	/**
420 
	 * Returns expand form of entity object. All references are resolved into
421 
	 * corresponding detail object
422 
	 *
423 
	 * @param entityID
424 
	 * @return ExpandedEntity
425 
	 * @throws Exception
426 
	 */
427 
	public static ExpandedEntity getExpandedEntity(long entityID) throws Exception {
428 
		Entity entity = CreationUtils.getEntity(entityID);
429 
		if(entity==null){
430 
			System.out.println("Entity is null");
431 
			return null;
432 
		}
433 
		System.out.println( entity.getCategoryID());
434 
		ExpandedEntity expEntity = new ExpandedEntity(entity);
435 
		return expEntity;
436 
	}
437 
 
438 
 
439 
	/**
440 
	 * Returns list of borrowed slides
441 
	 *
442 
	 * @param entity
443 
	 * @return list of borrowed slides
444 
	 */
445 
	public static List<Slide> getBorrowedSlides(Entity entity) {
446 
		List<Slide> borrowedSlides = new ArrayList<Slide>();
447 
 
448 
		List<Slide> slides = entity.getSlides();
449 
 
450 
		for(Slide slide : slides) {
1165 rajveer 451 
			if(CreationUtils.isBorrowedSlide(slide.getSlideDefinitionID(), entity.getCategoryID())) {
1153 rajveer 452 
				borrowedSlides.add(slide);
453 
			}
454 
		}
455 
 
456 
		return borrowedSlides;
457 
	}
458 
 
459 
	/**
460 
	 * Returns first parent slide with matching label
461 
	 *
462 
	 * @param expEntity2
463 
	 * @param slideLabel
464 
	 * @return Null if not found
465 
	 */
466 
	public static ExpandedSlide getParentExpandedSlide(ExpandedEntity expEntity2, String slideLabel) {
467 
 
468 
		ExpandedSlide matchingSlide = null;
469 
		List<ExpandedSlide> expSlides = expEntity2.getExpandedSlides();
470 
 
471 
		for(ExpandedSlide expSlide : expSlides) {
472 
			if(expSlide.getSlideDefinition().getLabel().equals(slideLabel)) {
473 
				matchingSlide = expSlide;
474 
				break;
475 
			}
476 
		}
477 
 
478 
		return matchingSlide;
479 
	}
1165 rajveer 480 
 
481 
	/**
482 
	 *
483 
	 * @param slideDefinitionID
484 
	 * @param categoryID
485 
	 * @return
486 
	 */
487 
	public static boolean isBorrowedSlide(long slideDefinitionID,long categoryID) {
1226 rajveer 488 
		List<CategorySlideDefinition> slideDefinitions;
1165 rajveer 489 
		try {
1226 rajveer 490 
			slideDefinitions = Catalog.getInstance().getDefinitionsContainer().getCategorySlideDefinitions(categoryID);
491 
			for(CategorySlideDefinition slideDef: slideDefinitions){
492 
				if(slideDefinitionID == slideDef.getSlideDefintionID()){
493 
					return false;
494 
				}
1165 rajveer 495 
			}
496 
		} catch (Exception e) {
497 
			// TODO Auto-generated catch block
498 
			e.printStackTrace();
499 
		}
1226 rajveer 500 
		return true;
1165 rajveer 501 
	}
502 
 
503 
	/**
504 
	 *
505 
	 * @param slideDefinitionID
506 
	 * @param categoryID
507 
	 * @return
508 
	 */
509 
	public static long getBorrowedCategoryID(long slideDefinitionID, long categoryID) {
510 
		try {
1226 rajveer 511 
			List<CategorySlideDefinition> slideDefinitions = Catalog.getInstance().getDefinitionsContainer().getCategorySlideDefinitions(categoryID);
512 
			for(CategorySlideDefinition slideDef: slideDefinitions){
513 
				if(slideDefinitionID == slideDef.getSlideDefintionID()){
514 
					return categoryID;
515 
				}
516 
			}
517 
 
518 
 
519 
			List<Category> cats =  Catalog.getInstance().getDefinitionsContainer().getCategory(categoryID).getParentCategory().getChildrenCategory();
520 
			for(Category cat: cats){
521 
				if(cat.getID() == categoryID){
522 
					continue;
523 
				}else{
524 
					List<CategorySlideDefinition> slideDefs = Catalog.getInstance().getDefinitionsContainer().getCategorySlideDefinitions(cat.getID());
525 
					for(CategorySlideDefinition slideDef: slideDefs){
526 
						if(slideDefinitionID == slideDef.getSlideDefintionID()){
1165 rajveer 527 
							return cat.getID();
528 
						}
529 
					}
1226 rajveer 530 
 
1165 rajveer 531 
				}
532 
			}
1226 rajveer 533 
 
1165 rajveer 534 
		} catch (Exception e) {
535 
			// TODO Auto-generated catch block
536 
			e.printStackTrace();
537 
		}
1226 rajveer 538 
		return categoryID;
1165 rajveer 539 
	}
540 
 
479 rajveer 541 
}