Subversion Repositories SmartDukaan

Rev

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