Subversion Repositories SmartDukaan

Rev

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