Subversion Repositories SmartDukaan

Rev

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