Subversion Repositories SmartDukaan

Rev

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