Subversion Repositories SmartDukaan

Rev

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