Subversion Repositories SmartDukaan

Rev

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