Subversion Repositories SmartDukaan

Rev

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