Subversion Repositories SmartDukaan

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
36 naveen 1 
/**
2 
 *
3 
 */
4 
package in.shop2020.metamodel.util;
5 
 
6 
import in.shop2020.metamodel.core.Bullet;
37 naveen 7 
import in.shop2020.metamodel.core.CompositeDataObject;
38 naveen 8 
import in.shop2020.metamodel.core.Entity;
37 naveen 9 
import in.shop2020.metamodel.core.EnumDataObject;
38 naveen 10 
import in.shop2020.metamodel.core.Feature;
11 
import in.shop2020.metamodel.core.FreeformContent;
37 naveen 12 
import in.shop2020.metamodel.core.PrimitiveDataObject;
13 
import in.shop2020.metamodel.definitions.BulletDefinition;
14 
import in.shop2020.metamodel.definitions.Catalog;
15 
import in.shop2020.metamodel.definitions.CompositeDefinition;
16 
import in.shop2020.metamodel.definitions.CompositePartDefinition;
17 
import in.shop2020.metamodel.definitions.DatatypeDefinition;
18 
import in.shop2020.metamodel.definitions.DefinitionsContainer;
19 
import in.shop2020.metamodel.definitions.EditorialImportance;
20 
import in.shop2020.metamodel.definitions.EntityContainer;
21 
import in.shop2020.metamodel.definitions.EnumDefinition;
22 
import in.shop2020.metamodel.definitions.FeatureDefinition;
23 
import in.shop2020.metamodel.definitions.SlideDefinition;
24 
import in.shop2020.metamodel.definitions.Unit;
64 naveen 25 
import in.shop2020.util.DBUtils;
37 naveen 26 
import in.shop2020.util.Utils;
36 naveen 27 
 
28 
import java.util.ArrayList;
29 
import java.util.HashMap;
30 
import java.util.List;
31 
import java.util.Map;
32 
 
37 naveen 33 
import org.apache.commons.lang.ArrayUtils;
36 naveen 34 
import org.apache.commons.lang.StringUtils;
35 
import org.apache.poi.hslf.HSLFSlideShow;
36 
import org.apache.poi.hslf.extractor.PowerPointExtractor;
37 
import org.apache.poi.hslf.model.Slide;
38 
import org.apache.poi.hslf.model.TextRun;
39 
import org.apache.poi.hslf.usermodel.RichTextRun;
40 
import org.apache.poi.hslf.usermodel.SlideShow;
41 
 
42 
/**
51 naveen 43 
 * Command line utility to convert MS PPT into shop2020 content model objects.
44 
 * It can be used to
45 
 *
46 
 * - Validate PPT file
47 
 * - Import PPT file
48 
 * - Show Java objects from already imported PPT
49 
 *
50 
 *
51 
 * HSLF - Horrible slide show format (POI API term)
52 
 *
36 naveen 53 
 * @author naveen
54 
 *
55 
 */
56 
public class HSLF {
43 naveen 57 
 
49 naveen 58 
	/**
59 
	 *
60 
	 */
61 
	public static final int BLUE = -16776961;
62 
 
63 
	/**
64 
	 *
65 
	 */
38 naveen 66 
	public static final int PURPLE = -6749953;
49 naveen 67 
 
68 
	/**
69 
	 *
70 
	 */
38 naveen 71 
	public static final int GREEN = -16711936;
49 naveen 72 
 
73 
	/**
74 
	 *
75 
	 */
38 naveen 76 
	public static final int ORANGE = -26368;
43 naveen 77 
 
49 naveen 78 
	/**
79 
	 *
80 
	 */
36 naveen 81 
	private List<String> slideNames = new ArrayList<String>();
49 naveen 82 
 
83 
	/**
84 
	 *
85 
	 */
36 naveen 86 
	private Map<String, List<String>> slideNameChildrenSlideNames =
87 
		new HashMap<String, List<String>>();
49 naveen 88 
	/**
89 
	 *
90 
	 */
36 naveen 91 
	private Map<String, List<String>> slideNameFeatureNames =
92 
		new HashMap<String, List<String>>();
93 
 
49 naveen 94 
	/**
95 
	 *
96 
	 */
37 naveen 97 
	private Map<String, Long> slideNameSlideDefID =
36 naveen 98 
		new HashMap<String, Long>();
99 
 
49 naveen 100 
	/**
101 
	 *
102 
	 */
37 naveen 103 
	private Map<String, Long> slideNameFeatureNameFeatureDefID =
36 naveen 104 
		new HashMap<String, Long>();
49 naveen 105 
 
106 
	/**
107 
	 *
108 
	 */
37 naveen 109 
	private Map<String, List<String>> slideNameFeatureNameBulletTexts =
110 
		new HashMap<String, List<String>>();
111 
 
49 naveen 112 
	/**
113 
	 *
114 
	 */
37 naveen 115 
	private Map<String, List<Bullet>> slideNameFeatureNameBullets =
36 naveen 116 
		new HashMap<String, List<Bullet>>();
117 
 
49 naveen 118 
	/**
119 
	 *
120 
	 */
37 naveen 121 
	private Map<String, List<String>> containerFCCs =
36 naveen 122 
		new HashMap<String, List<String>>();
123 
 
49 naveen 124 
	/**
125 
	 *
126 
	 */
37 naveen 127 
	private long categoryID;
49 naveen 128 
 
129 
	/**
130 
	 *
131 
	 */
37 naveen 132 
	private String srcFile;
49 naveen 133 
 
134 
	/**
135 
	 *
136 
	 */
37 naveen 137 
	private String dbFile;
49 naveen 138 
 
139 
	/**
140 
	 *
141 
	 */
38 naveen 142 
	private String introductionTitle;
49 naveen 143 
 
144 
	/**
145 
	 *
146 
	 */
38 naveen 147 
	private String introductionText;
148 
 
36 naveen 149 
	/**
51 naveen 150 
	 * Usage: HSLF [validate|import|show] [{Entity ID}|{Category ID} {PPT file name}]
151 
	 *
36 naveen 152 
	 * @param args
153 
	 */
154 
	public static void main(String[] args) throws Exception {
40 naveen 155 
		String[] commands = new String[] {"validate", "import", "show"};
36 naveen 156 
 
37 naveen 157 
		String usage = "Usage: HSLF ["+ StringUtils.join(commands, "|") +
158 
			"] [{Entity ID}|{Category ID} {PPT file name}]\n";
159 
 
160 
		if(args.length < 2) {
161 
			System.out.println(usage);
162 
			System.exit(-1);
163 
		}
164 
 
165 
		String inputCommand = args[0];
166 
 
167 
		if(!ArrayUtils.contains(commands, inputCommand)) {
168 
			System.out.println(usage);
169 
			System.exit(-1);
170 
		}
40 naveen 171 
 
172 
		if (inputCommand.equals("validate")) {
173 
			String inputCategoryID = args[1];
174 
			if(args.length < 3) {
175 
				System.out.println(usage);
176 
				System.exit(-1);
177 
			}
37 naveen 178 
 
40 naveen 179 
			String inputFilename = args[2];
180 
			long categoryID = new Long(inputCategoryID).longValue();
181 
			HSLF hslf = new HSLF(categoryID, inputFilename);
182 
			hslf.validateEntity();
37 naveen 183 
			System.exit(0);
184 
		}
185 
 
186 
		if (inputCommand.equals("import")) {
187 
			String inputCategoryID = args[1];
188 
			if(args.length < 3) {
189 
				System.out.println(usage);
190 
				System.exit(-1);
191 
			}
192 
 
193 
			String inputFilename = args[2];
194 
			long categoryID = new Long(inputCategoryID).longValue();
195 
			HSLF hslf = new HSLF(categoryID, inputFilename);
196 
			hslf.importEntity();
197 
			System.exit(0);
198 
		}
40 naveen 199 
 
200 
		if (inputCommand.equals("show")) {
201 
			String entityID = args[1];
202 
			HSLF hslf = new HSLF();
203 
			hslf.showEntity(new Long(entityID).longValue());
204 
			System.exit(0);
205 
		}
37 naveen 206 
 
36 naveen 207 
	}
208 
 
37 naveen 209 
	/**
210 
	 *
211 
	 */
212 
	public HSLF() {
213 
	}
214 
 
215 
	/**
216 
	 *
217 
	 * @param categoryID
218 
	 * @param fileName
219 
	 */
220 
	public HSLF(long categoryID, String fileName) {
221 
		this.categoryID = categoryID;
222 
 
70 naveen 223 
		this.srcFile = Utils.CONTENT_SRC_PPT_PATH + fileName + ".ppt";
224 
		this.dbFile = Utils.ENTITIES_DB_PATH + "entities" + ".ser";
37 naveen 225 
	}
49 naveen 226 
 
37 naveen 227 
	/**
228 
	 *
49 naveen 229 
	 * @param entityID
37 naveen 230 
	 * @throws Exception
231 
	 */
232 
	public void showEntity(long entityID) throws Exception {
233 
		EntityContainer entContainer =
234 
			Catalog.getInstance().getEntityContainer();
43 naveen 235 
		/*
40 naveen 236 
		Entity entity = entContainer.getEntity(entityID);
41 naveen 237 
		Utils.info("Entity=" + entity);
43 naveen 238 
		*/
40 naveen 239 
 
37 naveen 240 
		ExpandedEntity expandedEntity =
241 
			entContainer.getExpandedEntity(entityID);
242 
 
41 naveen 243 
		Utils.info("expandedEntity=" + expandedEntity);
37 naveen 244 
	}
245 
 
40 naveen 246 
	/**
247 
	 *
248 
	 * @throws Exception
249 
	 */
250 
	public void validateEntity() throws Exception {
37 naveen 251 
		HSLFSlideShow hslfSS = new HSLFSlideShow(this.srcFile);
36 naveen 252 
		SlideShow ss = new SlideShow(hslfSS);
253 
		Slide[] ssarr = ss.getSlides();
38 naveen 254 
 
255 
		// Introduction page
256 
		this.processIntroductionSlide(ssarr[0]);
257 
 
258 
		// Rest of the content page
259 
		for(int i=1; i < ssarr.length; i++) {
36 naveen 260 
			TextRun[] trs = ssarr[i].getTextRuns();
44 naveen 261 
			Utils.info("trs.length=" + trs.length);
36 naveen 262 
 
44 naveen 263 
			/* DEBUG ONLY
264 
			for(int j=0;j<trs.length;j++) {
265 
				Utils.info("trs["+ j +"].getRawText=" + trs[j].getRawText());
266 
				Utils.info("trs[" + j + "].getRichTextRuns().length=" +
267 
						trs[j].getRichTextRuns().length);
268 
			}
269 
			*/
270 
 
37 naveen 271 
			String title = StringUtils.lowerCase(
272 
					StringUtils.strip(StringUtils.trim(ssarr[i].getTitle())));
36 naveen 273 
 
274 
			this.slideNames.add(title);
44 naveen 275 
			Utils.info("title=" + title);
36 naveen 276 
 
40 naveen 277 
			// Hack to get to TextRun where bullets are!
44 naveen 278 
 
279 
			// Assume second textrun will have all the content
36 naveen 280 
			TextRun contentTextRun = trs[1];
44 naveen 281 
 
36 naveen 282 
			RichTextRun[] richTextRuns = contentTextRun.getRichTextRuns();
44 naveen 283 
			//Utils.info("richTextRuns.length=" + richTextRuns.length);
284 
 
285 
			String rawContent = contentTextRun.getRawText();
286 
			Utils.info("rawContent=" + rawContent);
287 
 
288 
			// richTextRuns.length == 1
289 
			if(title.equalsIgnoreCase(StringUtils.strip(rawContent)) &&
290 
					trs.length > 2) {
40 naveen 291 
				contentTextRun = trs[2];
292 
				richTextRuns = contentTextRun.getRichTextRuns();
293 
			}
44 naveen 294 
 
295 
			Utils.info("contentTextRun.getRawText=" +
296 
					contentTextRun.getRawText());
297 
 
36 naveen 298 
			int startIndex = 0;
299 
			int indent = 1;
300 
			Map<String, Object[]> info = getContents(richTextRuns, startIndex,
301 
					indent);
302 
 
41 naveen 303 
			Utils.info(info);
36 naveen 304 
			//System.exit(0);
305 
 
306 
			drilldown(richTextRuns, info, indent, title);
44 naveen 307 
 
36 naveen 308 
		}
44 naveen 309 
		//System.exit(0);
36 naveen 310 
 
41 naveen 311 
		Utils.info("this.slideNames=" + this.slideNames);
312 
		Utils.info("this.slideNameChildrenSlideNames=" +
36 naveen 313 
				this.slideNameChildrenSlideNames);
314 
 
41 naveen 315 
		Utils.info("this.slideNameFeatureNames=" +
37 naveen 316 
				this.slideNameFeatureNames);
317 
 
41 naveen 318 
		Utils.info("this.slideNameFeatureNameBulletTexts=" +
37 naveen 319 
				this.slideNameFeatureNameBulletTexts);
320 
 
41 naveen 321 
		Utils.info("this.containerFCCs=" + this.containerFCCs);
37 naveen 322 
 
323 
		// Start validation and import
324 
 
325 
		// Validate slides
326 
		this.processSlides();
327 
 
328 
		// Collect Slide Definition IDs
329 
		this.collectSlideDefinitionIDs();
41 naveen 330 
		Utils.info("this.slideNameSlideDefID=" +
37 naveen 331 
				this.slideNameSlideDefID);
332 
 
333 
		// Validate features
334 
		for(String slideName : this.slideNames) {
42 naveen 335 
			this.processFeatures(slideName, slideName);
37 naveen 336 
		}
337 
 
338 
		// Collect Feature Definition IDs
42 naveen 339 
		this.collectAllFeatureDefinitionIDs();
41 naveen 340 
		Utils.info("this.slideNameFeatureNameFeatureDefID=" +
37 naveen 341 
				this.slideNameFeatureNameFeatureDefID);
42 naveen 342 
 
37 naveen 343 
		DefinitionsContainer defs =
344 
			Catalog.getInstance().getDefinitionsContainer();
345 
 
346 
		// Validate bullets
347 
		for(String slideName : this.slideNames) {
348 
 
40 naveen 349 
			Long slideDefID = this.slideNameSlideDefID.get(slideName);
350 
			SlideDefinition slideDef =
351 
				defs.getSlideDefinition(slideDefID.longValue());
352 
 
42 naveen 353 
			this.processBullets(slideName, slideDef.getLabel());
354 
		}
355 
 
356 
		Utils.info("this.slideNameFeatureNameBullets=" +
357 
				this.slideNameFeatureNameBullets);
358 
 
359 
	}
360 
 
361 
	/**
362 
	 *
363 
	 * @param slideName
364 
	 * @param displayTextPrefix
365 
	 * @throws Exception
366 
	 */
367 
	private void processBullets(String slideName, String displayTextPrefix)
368 
		throws Exception {
369 
		Utils.info("Process bullets for " + slideName);
370 
 
371 
		DefinitionsContainer defs =
372 
			Catalog.getInstance().getDefinitionsContainer();
373 
 
374 
		List<String> featureLabels =
375 
			this.slideNameFeatureNames.get(slideName);
376 
 
377 
		// Feature-less slide
378 
		if(featureLabels != null) {
37 naveen 379 
			for(String featureLabel : featureLabels) {
380 
				String key = slideName + "_" + featureLabel;
44 naveen 381 
				Utils.info("key=" + key);
382 
 
37 naveen 383 
				List<String> bulletTexts =
384 
					this.slideNameFeatureNameBulletTexts.get(key);
385 
 
386 
				// Bullet-less feature
387 
				if(bulletTexts == null) {
388 
					continue;
389 
				}
390 
 
391 
				Long featureDefID =
392 
					this.slideNameFeatureNameFeatureDefID.get(key);
393 
 
394 
				FeatureDefinition featureDef =
395 
					defs.getFeatureDefinition(featureDefID.longValue());
396 
 
42 naveen 397 
				String crumb = displayTextPrefix + " > " +
40 naveen 398 
					featureDef.getLabel();
399 
 
38 naveen 400 
				String prefix = slideName + "_" + featureLabel;
37 naveen 401 
				for(String bulletText : bulletTexts) {
402 
					Bullet bullet =
38 naveen 403 
						this.processBulletText(bulletText, featureDef, crumb,
404 
								prefix);
37 naveen 405 
 
40 naveen 406 
					// Can't be imported has errors, skip
37 naveen 407 
					if(bullet == null) {
408 
						continue;
409 
					}
410 
 
411 
					List<Bullet> bullets =
412 
						this.slideNameFeatureNameBullets.get(key);
413 
 
414 
					if(bullets == null) {
415 
						bullets = new ArrayList<Bullet>();
416 
						this.slideNameFeatureNameBullets.put(key, bullets);
417 
					}
418 
 
419 
					bullets.add(bullet);
420 
				}
421 
			}
422 
		}
423 
 
42 naveen 424 
		// Process bullets of children slides
425 
		List<String> childrenSlideNames =
426 
			this.slideNameChildrenSlideNames.get(slideName);
427 
		Utils.info("childrenSlideNames=" + childrenSlideNames);
40 naveen 428 
 
42 naveen 429 
		if(childrenSlideNames != null) {
430 
			for(String childSlideName : childrenSlideNames) {
431 
				String fullSlideName = slideName + "_" + childSlideName;
432 
				Utils.info("fullSlideName=" + fullSlideName);
433 
 
434 
				Long slideDefID =
435 
					this.slideNameSlideDefID.get(fullSlideName);
436 
				Utils.info("slideDefID=" + slideDefID);
437 
 
47 naveen 438 
				if(slideDefID == null) {
439 
					Utils.severe("Unexpected slide " + fullSlideName);
440 
					continue;
441 
				}
442 
 
42 naveen 443 
				SlideDefinition childSlideDef =
444 
					defs.getSlideDefinition(slideDefID.longValue());
445 
 
446 
				String newDisplayTextPrefix = displayTextPrefix + " > " +
447 
					childSlideDef.getLabel();
448 
 
449 
				this.processBullets(fullSlideName, newDisplayTextPrefix);
450 
			}
451 
		}
40 naveen 452 
	}
453 
 
454 
	/**
455 
	 *
456 
	 * @throws Exception
457 
	 */
458 
	public void importEntity() throws Exception {
459 
 
460 
		// Parse and Validate
461 
		this.validateEntity();
462 
 
38 naveen 463 
		// Construct Content Model
464 
		Entity entity = this.contructEntityObject();
41 naveen 465 
		Utils.info("entity="+entity);
38 naveen 466 
 
467 
		EntityContainer entContainer =
468 
			Catalog.getInstance().getEntityContainer();
469 
 
470 
		entContainer.addEntity(entity);
471 
 
472 
		// RE-VISIT
473 
		// Store it back
474 
		DBUtils.store(entContainer.getEntities(), this.dbFile);
475 
 
476 
		// Store the index separately
70 naveen 477 
		String entitiesbycategoryDBFile = Utils.ENTITIES_DB_PATH +
38 naveen 478 
			"entitiesbycategory" + ".ser";
479 
 
480 
		DBUtils.store(entContainer.getEntitiesbyCategory(),
481 
				entitiesbycategoryDBFile);
482 
 
36 naveen 483 
	}
38 naveen 484 
	/**
485 
	 *
486 
	 * @param hslfSlide
487 
	 */
488 
	private void processIntroductionSlide(Slide hslfSlide) {
489 
		TextRun[] trs = hslfSlide.getTextRuns();
490 
		StringBuffer sbTitle = new StringBuffer();
491 
		StringBuffer sbText = new StringBuffer();
492 
 
493 
		for(int i=0;i<trs.length;i++) {
494 
			RichTextRun[] rtrs = trs[i].getRichTextRuns();
495 
 
496 
			for(int j=0;j<rtrs.length;j++) {
497 
				int rgb = rtrs[j].getFontColor().getRGB();
498 
				if(rgb == HSLF.ORANGE) {
499 
					sbTitle.append(rtrs[j].getRawText());
500 
				}
501 
				else if(rgb == HSLF.PURPLE) {
502 
					sbText.append(rtrs[j].getRawText());
503 
				}
504 
			}
505 
		}
506 
 
507 
		this.introductionTitle = sbTitle.toString();
508 
		this.introductionText = sbText.toString();
41 naveen 509 
		Utils.info("this.introductionTitle=" + this.introductionTitle);
510 
		Utils.info("this.introductionText=" + this.introductionText);
38 naveen 511 
	}
36 naveen 512 
 
37 naveen 513 
	/**
514 
	 *
38 naveen 515 
	 * @return Entity
516 
	 * @throws Exception
517 
	 */
518 
	private Entity contructEntityObject() throws Exception {
519 
		SequenceGenerator sg = SequenceGenerator.getInstance();
520 
		long entityID = sg.getNextSequence(SequenceGenerator.ENTITY);
521 
 
522 
		Entity entity = new Entity(entityID, this.categoryID);
523 
		String brandModel[] = StringUtils.split(this.introductionTitle, " ");
524 
 
525 
		if(brandModel.length == 1) {
526 
			entity.setBrand(StringUtils.strip(brandModel[0]));
527 
		}
528 
		else if(brandModel.length == 2) {
529 
			entity.setBrand(StringUtils.strip(brandModel[0]));
530 
			entity.setModelName(StringUtils.strip(brandModel[1]));
531 
		}
532 
		else if(brandModel.length == 3) {
533 
			entity.setBrand(StringUtils.strip(brandModel[0]));
534 
			entity.setModelNumber(StringUtils.strip(brandModel[1]));
535 
			entity.setModelName(StringUtils.strip(brandModel[2]));
536 
		}
537 
		else if(brandModel.length == 4) {
538 
			entity.setBrand(StringUtils.strip(brandModel[0]) + " " +
539 
					StringUtils.strip(brandModel[1]));
540 
 
541 
			entity.setModelNumber(StringUtils.strip(brandModel[2]));
542 
			entity.setModelName(StringUtils.strip(brandModel[3]));
543 
		}
544 
 
545 
		// Add introduction slide
546 
		DefinitionsContainer defs =
547 
			Catalog.getInstance().getDefinitionsContainer();
548 
 
549 
		List<SlideDefinition> introSlideDefs =
40 naveen 550 
			defs.getSlideDefinitions(this.categoryID, "Introduction");
38 naveen 551 
 
552 
		// It will only be one
553 
		long introSlideDefID = introSlideDefs.get(0).getID();
41 naveen 554 
		Utils.info("introSlideDefID=" + introSlideDefID);
38 naveen 555 
 
556 
		in.shop2020.metamodel.core.Slide introSlide =
557 
			new in.shop2020.metamodel.core.Slide(introSlideDefID);
558 
 
559 
		introSlide.setFreeformContent(
560 
				new FreeformContent(this.introductionText));
41 naveen 561 
		Utils.info("introSlide=" + introSlide);
40 naveen 562 
 
563 
		entity.addSlide(introSlide);
38 naveen 564 
 
565 
		// Add rest of the slides
566 
		for(String slideName : this.slideNames) {
567 
			in.shop2020.metamodel.core.Slide slide =
43 naveen 568 
				this.constructSlideObject(slideName);
38 naveen 569 
 
43 naveen 570 
			entity.addSlide(slide);
571 
		}
572 
 
573 
		return entity;
574 
	}
575 
 
576 
	/**
577 
	 *
578 
	 * @param slideName
579 
	 * @return
580 
	 */
581 
	private in.shop2020.metamodel.core.Slide constructSlideObject(
582 
			String slideName) {
583 
		Utils.info("Constructing slide object for " + slideName);
584 
 
585 
		List<String> featureNames =
586 
			this.slideNameFeatureNames.get(slideName);
587 
 
588 
		Long slideDefID = this.slideNameSlideDefID.get(slideName);
47 naveen 589 
 
590 
		if(slideDefID == null) {
591 
			Utils.severe("Unexpected slide " + slideName);
592 
			return null;
593 
		}
594 
 
43 naveen 595 
		in.shop2020.metamodel.core.Slide slide =
596 
			new in.shop2020.metamodel.core.Slide(slideDefID.longValue());
597 
 
598 
		// Only if there are features
599 
		if(featureNames != null) {
38 naveen 600 
			List<Feature> features = new ArrayList<Feature>();
601 
 
43 naveen 602 
			for(String featureName : featureNames) {
603 
				String key = slideName + "_" + featureName;
38 naveen 604 
				Long featureDefID =
605 
					this.slideNameFeatureNameFeatureDefID.get(key);
606 
 
607 
				List<Bullet> bullets =
608 
					this.slideNameFeatureNameBullets.get(key);
609 
 
610 
				Feature feature = new Feature(featureDefID.longValue());
611 
				feature.setBullets(bullets);
612 
 
613 
				// Free-form content
614 
				List<String> featureFFCs = this.containerFCCs.get(key);
615 
				FreeformContent featureFFC =
616 
					new FreeformContent(StringUtils.join(featureFFCs, "|"));
617 
 
618 
				feature.setFreeformContent(featureFFC);
619 
 
620 
				features.add(feature);
621 
			}
622 
 
623 
			slide.setFeatures(features);
43 naveen 624 
		}
625 
 
626 
		// Add children slides
627 
		List<String> childrenSlideNames =
628 
			this.slideNameChildrenSlideNames.get(slideName);
629 
 
630 
		if(childrenSlideNames != null) {
631 
			for(String childSlideName : childrenSlideNames) {
632 
				in.shop2020.metamodel.core.Slide childSlide =
633 
					this.constructSlideObject(slideName + "_" + childSlideName);
634 
 
47 naveen 635 
				if(childSlide != null) {
636 
					slide.addChild(childSlide);
637 
				}
43 naveen 638 
			}
639 
		}
640 
 
641 
		// Add free-form content is collect above
642 
		List<String> slideFFCs = this.containerFCCs.get(slideName);
643 
		Utils.info("slideName=" + slideName +
644 
				" slideFFCs=" + slideFFCs);
645 
 
646 
		if(slideFFCs != null) {
38 naveen 647 
			FreeformContent slideFFC =
648 
				new FreeformContent(StringUtils.join(slideFFCs, "|"));
649 
 
650 
			slide.setFreeformContent(slideFFC);
651 
		}
652 
 
43 naveen 653 
		return slide;
38 naveen 654 
	}
655 
 
656 
	/**
657 
	 *
37 naveen 658 
	 * @throws Exception
659 
	 */
42 naveen 660 
	private void collectAllFeatureDefinitionIDs() throws Exception {
661 
 
662 
		for(String slideName : this.slideNames) {
663 
			this.collectFeatureDefinitionIDs(slideName);
664 
		}
665 
	}
666 
 
667 
	/**
668 
	 *
669 
	 * @param slideName
670 
	 * @throws Exception
671 
	 */
44 naveen 672 
	private void collectFeatureDefinitionIDs(String slideName)
673 
		throws Exception {
674 
		Utils.info("collectFeatureDefinitionIDs for " + slideName);
675 
 
37 naveen 676 
		DefinitionsContainer defs =
677 
			Catalog.getInstance().getDefinitionsContainer();
678 
 
42 naveen 679 
		Long slideDefID = this.slideNameSlideDefID.get(slideName);
680 
		Utils.info("slideName=" + slideName);
681 
 
47 naveen 682 
		if(slideDefID == null) {
683 
			Utils.severe("Unexpected slide " + slideName);
684 
			return;
685 
		}
686 
 
42 naveen 687 
		List<String> featureLabels =
688 
			this.slideNameFeatureNames.get(slideName);
689 
		Utils.info("featureLabels=" + featureLabels);
690 
 
691 
		// Feature-less slide
44 naveen 692 
		if(featureLabels != null && !featureLabels.isEmpty()) {
693 
			for(String featureLabel : featureLabels) {
47 naveen 694 
				Utils.info("defs=" + defs);
695 
				Utils.info("slideDefID=" + slideDefID);
696 
				Utils.info("featureLabel=" + featureLabel);
697 
 
44 naveen 698 
				FeatureDefinition featureDef =
699 
					defs.getFeatureDefinition(slideDefID, featureLabel);
700 
				String key = slideName + "_" + featureLabel;
701 
 
47 naveen 702 
				if(featureDef == null) {
703 
					Utils.severe("Unexpected feature " + key);
704 
					continue;
705 
				}
706 
 
44 naveen 707 
				this.slideNameFeatureNameFeatureDefID.put(key,
708 
						new Long(featureDef.getID()));
709 
			}
42 naveen 710 
		}
711 
 
712 
		List<String> childrenSlideNames =
713 
			this.slideNameChildrenSlideNames.get(slideName);
714 
 
715 
		if(childrenSlideNames != null && !childrenSlideNames.isEmpty()) {
716 
			for(String childSlideName : childrenSlideNames) {
717 
				String fullSlideName = slideName + "_" + childSlideName;
37 naveen 718 
 
42 naveen 719 
				this.collectFeatureDefinitionIDs(fullSlideName);
37 naveen 720 
			}
721 
		}
722 
	}
723 
 
724 
	/**
725 
	 *
726 
	 * @throws Exception
727 
	 */
728 
	private void collectSlideDefinitionIDs() throws Exception {
729 
		for(String slideName : this.slideNames) {
42 naveen 730 
			SlideDefinition slideDef = this.getSlideDefinition(slideName);
731 
			//Utils.info("slideDef=" + slideDef);
37 naveen 732 
 
42 naveen 733 
			if(slideDef == null) {
37 naveen 734 
				continue;
735 
			}
736 
 
737 
			Long slideID = slideDef.getID();
738 
			this.slideNameSlideDefID.put(slideName, slideID);
42 naveen 739 
 
740 
			if(slideDef.hasChildren()) {
741 
				this.collectChidrenSlideDefinitionIDs(slideName, slideDef);
742 
			}
37 naveen 743 
		}
744 
	}
745 
 
746 
	/**
747 
	 *
42 naveen 748 
	 * @param parentSlideName
749 
	 * @param paretnSlideDef
750 
	 * @throws Exception
751 
	 */
752 
	private void collectChidrenSlideDefinitionIDs(String parentSlideName,
753 
			SlideDefinition parentSlideDef) throws Exception {
45 naveen 754 
		Utils.info("collectChidrenSlideDefinitionIDs for " + parentSlideName);
42 naveen 755 
 
756 
		// May not be needed as validations have already filtered correct
757 
		// children slide names
758 
		List<String> childrenSlideNames =
759 
			this.slideNameChildrenSlideNames.get(parentSlideName);
45 naveen 760 
		Utils.info("childrenSlideNames=" + childrenSlideNames);
42 naveen 761 
 
762 
		List<Long> childrenSlideDefinitionIDs =
763 
			parentSlideDef.getChildrenSlideDefinitionIDs();
45 naveen 764 
		Utils.info("childrenSlideDefinitionIDs=" + childrenSlideDefinitionIDs);
42 naveen 765 
 
766 
		DefinitionsContainer defs =
767 
			Catalog.getInstance().getDefinitionsContainer();
768 
 
769 
		for(Long childSlideDefID : childrenSlideDefinitionIDs) {
770 
			SlideDefinition childSlideDef =
771 
				defs.getSlideDefinition(childSlideDefID.longValue());
772 
 
773 
			String label = childSlideDef.getLabel();
45 naveen 774 
			Utils.info("label="+label);
42 naveen 775 
 
776 
			if(childrenSlideNames.contains(StringUtils.lowerCase(label))) {
777 
				String key = parentSlideName + "_" +
778 
					StringUtils.lowerCase(label);
779 
 
780 
 				this.slideNameSlideDefID.put(key, childSlideDefID);
781 
 
782 
 				if(childSlideDef.hasChildren()) {
783 
 					this.collectChidrenSlideDefinitionIDs(key, childSlideDef);
784 
 				}
785 
			}
786 
		}
787 
	}
788 
 
789 
	/**
790 
	 *
791 
	 * @param slideName
792 
	 * @return
793 
	 * @throws Exception
794 
	 */
795 
	private SlideDefinition getSlideDefinition(String slideName)
796 
		throws Exception {
797 
		DefinitionsContainer  defs =
798 
			Catalog.getInstance().getDefinitionsContainer();
799 
 
800 
		List<SlideDefinition> slideDefs =
801 
			defs.getSlideDefinitions(this.categoryID, slideName);
802 
 
803 
		if(slideDefs == null) {
804 
			return null;
805 
		}
806 
 
807 
		if (slideDefs.isEmpty()) {
808 
			return null;
809 
		}
810 
 
811 
		// RE-VISIT
812 
		// Pick the first
813 
		SlideDefinition slideDef = slideDefs.get(0);
814 
		//Utils.info("slideDef=" + slideDef);
815 
 
816 
		return slideDef;
817 
	}
49 naveen 818 
 
42 naveen 819 
	/**
820 
	 *
49 naveen 821 
	 * @param slideName
822 
	 * @param displayTextPrefix
37 naveen 823 
	 * @throws Exception
824 
	 */
42 naveen 825 
	private void processFeatures(String slideName, String displayTextPrefix)
37 naveen 826 
		throws Exception {
42 naveen 827 
		Utils.info("Processing features for " + slideName);
37 naveen 828 
 
47 naveen 829 
		if(this.slideNameSlideDefID.get(slideName) == null) {
830 
			Utils.severe("Unexpected slide \"" + displayTextPrefix + "\"");
831 
			return;
832 
		}
833 
 
37 naveen 834 
		long slideDefID = this.slideNameSlideDefID.get(slideName).longValue();
41 naveen 835 
		Utils.info("slideID=" + slideDefID);
37 naveen 836 
 
837 
		List<String> candidateFeatures =
838 
			this.slideNameFeatureNames.get(slideName);
839 
 
41 naveen 840 
		Utils.info("slideName=" + slideName);
841 
		Utils.info("candidateFeatures=" + candidateFeatures);
37 naveen 842 
 
843 
		// Get all feature definitions for the slide
844 
		DefinitionsContainer defs =
845 
			Catalog.getInstance().getDefinitionsContainer();
846 
 
847 
		SlideDefinition slideDef = defs.getSlideDefinition(slideDefID);
41 naveen 848 
		Utils.info("slideDef=" + slideDef);
37 naveen 849 
 
850 
		List<FeatureDefinition> featureDefs =
851 
			defs.getFeatureDefinitions(slideDefID);
41 naveen 852 
		Utils.info("featureDefs=" + featureDefs);
37 naveen 853 
 
45 naveen 854 
		// Feature less slide
855 
		if(featureDefs == null || featureDefs.isEmpty()) {
856 
			Utils.info("Feature-less slide");
857 
			return;
858 
		}
859 
 
37 naveen 860 
		List<String> validFeatureLabels = new ArrayList<String>();
861 
		for(int i=0; i<featureDefs.size(); i++) {
862 
			validFeatureLabels.add(
863 
					StringUtils.lowerCase(featureDefs.get(i).getLabel()));
864 
 
865 
		}
41 naveen 866 
		Utils.info("validFeatureLabels=" + validFeatureLabels);
45 naveen 867 
 
868 
		// Missing features check
869 
		if(candidateFeatures == null || candidateFeatures.isEmpty()) {
54 naveen 870 
			Utils.info("No features found on the slide");
871 
			candidateFeatures = new ArrayList<String>();
45 naveen 872 
		}
47 naveen 873 
 
54 naveen 874 
		// Discard if feature is not one of the valids
875 
		List<String> processedFeatureLabels = new ArrayList<String>();
876 
		for(String featureLabel : candidateFeatures) {
37 naveen 877 
 
54 naveen 878 
			if(validFeatureLabels.contains(featureLabel)) {
879 
				processedFeatureLabels.add(featureLabel);
37 naveen 880 
			}
54 naveen 881 
			else {
882 
				Utils.severe("Invalid feature \"" + displayTextPrefix +
883 
						" > " + featureLabel + "\"");
884 
			}
37 naveen 885 
 
54 naveen 886 
		}
887 
		Utils.info("processedFeatureLabels=" + processedFeatureLabels);
888 
 
889 
		// For all further processing
890 
		this.slideNameFeatureNames.put(slideName, processedFeatureLabels);
891 
 
892 
		// Fetch all mandatory features
893 
		List<FeatureDefinition> mandatoryFeatureDefs =
894 
			defs.getFeatureDefinitions(slideDefID,
895 
			EditorialImportance.MANDATORY);
896 
 
897 
		Utils.info("mandatoryFeatureDefs=" + mandatoryFeatureDefs);
898 
 
899 
		// Severe error if mandatory features are not included
900 
		for(FeatureDefinition featureDef : mandatoryFeatureDefs) {
901 
			if(!processedFeatureLabels.contains(StringUtils.lowerCase(
902 
					featureDef.getLabel()))) {
903 
				Utils.severe("Mandatory feature \"" + displayTextPrefix
904 
						+ " > " + featureDef.getLabel() + "\" is missing");
37 naveen 905 
			}
906 
		}
907 
 
54 naveen 908 
		// Fetch all recommended features
909 
		List<FeatureDefinition> recommendedFeatureDefs =
910 
			defs.getFeatureDefinitions(slideDef.getID(),
911 
			EditorialImportance.RECOMMENDED);
912 
 
913 
		Utils.info("recommendedFeatureDefs=" + recommendedFeatureDefs);
914 
 
915 
		// Warn if recommended features are not included
916 
		for(FeatureDefinition featureDef : recommendedFeatureDefs) {
917 
			if(!processedFeatureLabels.contains(StringUtils.lowerCase(
918 
					featureDef.getLabel()))) {
919 
				Utils.warning("Recommended feature \"" + displayTextPrefix +
920 
						" > " + featureDef.getLabel() +
921 
						"\" is missing");
922 
			}
923 
		}
924 
 
42 naveen 925 
		// Process features of children slides
926 
		List<String> childrenSlideNames =
927 
			this.slideNameChildrenSlideNames.get(slideName);
928 
 
929 
		if(childrenSlideNames != null && !childrenSlideNames.isEmpty()) {
930 
			for(String childSlideName : childrenSlideNames) {
931 
				String fullChildSlideName = slideName + "_" + childSlideName;
932 
 
933 
				String newDisplayTextPrefix = displayTextPrefix + " > " +
934 
					childSlideName;
935 
 
936 
				this.processFeatures(fullChildSlideName, newDisplayTextPrefix);
937 
			}
938 
		}
939 
 
37 naveen 940 
	}
941 
 
942 
	/**
943 
	 * Filter and validate parent slide names
944 
	 *
945 
	 * @throws Exception
946 
	 */
947 
	private void processSlides() throws Exception {
948 
 
949 
		// 1 Retrieve meta-data
950 
		// 1.1 Retrieve all valid slide names in the content model
951 
		DefinitionsContainer defs =
952 
			Catalog.getInstance().getDefinitionsContainer();
953 
 
954 
		List<SlideDefinition> slideDefs = defs.getSlideDefinitions(
955 
				this.categoryID);
956 
 
957 
		List<String> validSlideNames = new ArrayList<String>();
958 
		for (SlideDefinition slideDef : slideDefs) {
959 
 
960 
			// To avoid Introduction slide
961 
			if(!slideDef.getLabel().isEmpty()) {
962 
				validSlideNames.add(StringUtils.lowerCase(slideDef.getLabel()));
963 
			}
964 
		}
41 naveen 965 
		Utils.info("validSlideNames=" + validSlideNames.toString());
37 naveen 966 
 
967 
		// 2 Rules
968 
		// 2.1 Discard if slide is not one of the valids
969 
		List<String> processedSlideNames = new ArrayList<String>();
970 
		for(String slideName : this.slideNames) {
971 
			if(validSlideNames.contains(slideName)) {
972 
				processedSlideNames.add(slideName);
973 
			}
40 naveen 974 
			else if(slideName.equals("resource urls") ||
975 
					slideName.equals("reference urls")) {
976 
				// ignore
977 
				continue;
978 
			}
37 naveen 979 
			else {
41 naveen 980 
				Utils.severe("Invalid slide \"" + slideName + "\"");
37 naveen 981 
			}
982 
		}
983 
 
42 naveen 984 
		Utils.info("processedSlideNames=" + processedSlideNames.toString());
37 naveen 985 
 
986 
		// For all further processing use processed slide names only
987 
		this.slideNames = processedSlideNames;
988 
 
989 
		// 3 Retrieve "Mandatory" slide names for the category
990 
		List<SlideDefinition> mandatorySlideDefs =
991 
			defs.getSlides(this.categoryID, EditorialImportance.MANDATORY);
992 
 
41 naveen 993 
		Utils.info("mandatorySlideDefs=" +
37 naveen 994 
				mandatorySlideDefs.toString());
995 
 
996 
		// 3.1 All mandatory slides exist - Severe
997 
		for(SlideDefinition mandatorySlideDef : mandatorySlideDefs) {
998 
 
999 
			// Avoid introduction slide
1000 
			if(mandatorySlideDef.getLabel().isEmpty()) {
1001 
				continue;
1002 
			}
1003 
 
40 naveen 1004 
			if(mandatorySlideDef.getLabel().equals("Introduction")) {
1005 
				continue;
1006 
			}
1007 
 
37 naveen 1008 
			if(!this.slideNames.contains(
1009 
					StringUtils.lowerCase(mandatorySlideDef.getLabel()))) {
1010 
 
41 naveen 1011 
				Utils.severe("Mandatory slide \"" +
37 naveen 1012 
						mandatorySlideDef.getLabel() + "\" is missing");
1013 
			}
1014 
		}
1015 
 
1016 
		// 4 Retrieve "Recommended" slide names for the category
1017 
		List<SlideDefinition> recommendedSlideDefs =
1018 
			defs.getSlides(this.categoryID, EditorialImportance.RECOMMENDED);
1019 
 
42 naveen 1020 
		Utils.info("recommendedSlideDefs=" + recommendedSlideDefs.toString());
37 naveen 1021 
 
1022 
		// 4.1 All recommended slides exist - Warn
1023 
		for(SlideDefinition recommendedSlideDef : recommendedSlideDefs) {
1024 
			if(!this.slideNames.contains(
1025 
					StringUtils.lowerCase(recommendedSlideDef.getLabel()))) {
1026 
 
41 naveen 1027 
				Utils.warning("Recommended slide \"" +
37 naveen 1028 
						recommendedSlideDef.getLabel() + "\" is missing");
1029 
			}
1030 
		}
42 naveen 1031 
 
1032 
		// Process children slides
1033 
		for(String parentSlideName : this.slideNames) {
1034 
			Utils.info("Process children slides for parentSlideName=" +
1035 
					parentSlideName);
1036 
 
1037 
			SlideDefinition parentSlideDef =
1038 
				this.getSlideDefinition(parentSlideName);
1039 
 
1040 
			// ignore for now
1041 
			if(parentSlideDef == null) {
1042 
				continue;
1043 
			}
1044 
 
1045 
			this.processChildrenSlides(parentSlideDef, parentSlideName,
1046 
					parentSlideDef.getLabel());
1047 
		}
1048 
 
1049 
		Utils.info("slideNameChildrenSlideNames=" +
1050 
				slideNameChildrenSlideNames);
37 naveen 1051 
	}
1052 
 
1053 
	/**
1054 
	 *
42 naveen 1055 
	 * @param slideName
1056 
	 * @param parentSlideDefinition
1057 
	 * @param crumb
1058 
	 * @throws Exception
1059 
	 */
1060 
	private void processChildrenSlides(SlideDefinition parentSlideDef,
1061 
			String crumb, String displayTextPrefix) throws Exception {
1062 
 
1063 
		List<Long> childrenSlideDefinitionIDs =
1064 
			parentSlideDef.getChildrenSlideDefinitionIDs();
1065 
 
1066 
		if(childrenSlideDefinitionIDs == null ||
1067 
				childrenSlideDefinitionIDs.isEmpty()) {
1068 
			return;
1069 
		}
1070 
 
1071 
		DefinitionsContainer defs =
1072 
			Catalog.getInstance().getDefinitionsContainer();
1073 
 
1074 
		String parentSlideName = parentSlideDef.getLabel();
1075 
		Utils.info("parentSlideName=" + parentSlideName + " has " +
1076 
				childrenSlideDefinitionIDs + " children slides to process");
1077 
 
1078 
		Utils.info("crumb=" + crumb);
1079 
 
1080 
		List<String> childrenSlideNames =
1081 
			this.slideNameChildrenSlideNames.get(crumb);
1082 
		Utils.info("childrenSlideNames=" + childrenSlideNames);
1083 
 
1084 
		// Collect allowed children slide labels
1085 
		List<String> validChildrenSlideNames = new ArrayList<String>();
1086 
 
1087 
		Map<String, SlideDefinition> childSlideNameSlideDefinition =
1088 
			new HashMap<String, SlideDefinition>();
1089 
 
1090 
		for(Long childSlideDefID : childrenSlideDefinitionIDs) {
1091 
			Utils.info("childSlideDefID=" + childSlideDefID);
1092 
 
1093 
			SlideDefinition childSlideDef =
1094 
				defs.getSlideDefinition(childSlideDefID.longValue());
1095 
			Utils.info("childSlideDef=" + childSlideDef);
1096 
 
1097 
			String displaytext = displayTextPrefix + " > " +
1098 
				childSlideDef.getLabel();
1099 
 
1100 
			// All children slides defined are mandatory
1101 
			String childSlideName =
1102 
				StringUtils.lowerCase(childSlideDef.getLabel());
1103 
			Utils.info("childSlideName=" + childSlideName);
1104 
 
1105 
			if(childrenSlideNames == null ||
1106 
					!childrenSlideNames.contains(childSlideName)) {
1107 
				Utils.severe("Missing child slide \"" + displaytext + "\"");
1108 
				continue;
1109 
			}
1110 
 
1111 
			validChildrenSlideNames.add(childSlideName);
1112 
			childSlideNameSlideDefinition.put(childSlideName, childSlideDef);
1113 
		}
1114 
 
1115 
		this.slideNameChildrenSlideNames.put(crumb, validChildrenSlideNames);
1116 
		Utils.info("validChildrenSlideNames=" + validChildrenSlideNames);
1117 
 
1118 
		for(String childSlideName : childSlideNameSlideDefinition.keySet()) {
1119 
			SlideDefinition slideDef =
1120 
				childSlideNameSlideDefinition.get(childSlideName);
1121 
 
1122 
			String newcrumb = crumb + "_" +
1123 
				StringUtils.lowerCase(childSlideName);
1124 
 
1125 
			String newDisplayTextPrefix = displayTextPrefix + " > " +
1126 
				slideDef.getLabel();
1127 
 
1128 
			this.processChildrenSlides(slideDef, newcrumb,
1129 
					newDisplayTextPrefix);
1130 
		}
1131 
	}
49 naveen 1132 
 
42 naveen 1133 
	/**
1134 
	 *
37 naveen 1135 
	 * @param bulletText
49 naveen 1136 
	 * @param featureDef
1137 
	 * @param crumb
1138 
	 * @param prefix
1139 
	 * @return
1140 
	 * @throws Exception
37 naveen 1141 
	 */
1142 
	private Bullet processBulletText(String bulletText,
38 naveen 1143 
			FeatureDefinition featureDef, String crumb, String prefix)
1144 
			throws Exception {
41 naveen 1145 
		Utils.info("featureDef.getLabel=" + featureDef.getLabel());
1146 
		Utils.info("bulletText=" + bulletText);
40 naveen 1147 
 
37 naveen 1148 
		BulletDefinition bulletDef = featureDef.getBulletDefinition();
41 naveen 1149 
		Utils.info("bulletDefinition=" + bulletDef);
37 naveen 1150 
 
1151 
		DefinitionsContainer defs =
1152 
			Catalog.getInstance().getDefinitionsContainer();
1153 
 
1154 
		// If unit is defined
1155 
		Unit unitDef =  null;
1156 
		if(bulletDef.getUnitID() != 0L) {
1157 
			long unitID = bulletDef.getUnitID();
1158 
			unitDef = defs.getUnit(unitID);
41 naveen 1159 
			Utils.info("unitDef=" + unitDef);
37 naveen 1160 
		}
1161 
 
1162 
		long datatypeDefID = bulletDef.getDatatypeDefinitionID();
1163 
		DatatypeDefinition datatypeDef =
1164 
			defs.getDatatypeDefinition(datatypeDefID);
41 naveen 1165 
		Utils.info("datatypeDef=" + datatypeDef);
37 naveen 1166 
 
1167 
		// If primitive
1168 
		boolean isEnum = false;
1169 
		boolean isComposite = false;
1170 
		boolean isPrimitive = false;
1171 
		if(datatypeDef instanceof EnumDefinition) {
1172 
			isEnum = true;
1173 
		}
1174 
		else if(datatypeDef instanceof CompositeDefinition) {
1175 
			isComposite = true;
1176 
		}
1177 
		else {
1178 
			isPrimitive = true;
1179 
		}
1180 
 
41 naveen 1181 
		Utils.info("isEnum=" + isEnum + " isComposite=" + isComposite +
37 naveen 1182 
				" isPrimitive=" + isPrimitive);
1183 
 
1184 
		// if no unit is defined for this bullet whole is treated as value
1185 
		String bulletValue = bulletText;
1186 
		Bullet bullet = null;
1187 
 
1188 
		// If unit is defined
1189 
		if(bulletDef.getUnitID() != 0L) {
1190 
 
1191 
			// Validate unit
1192 
			String[] parts = StringUtils.split(bulletText, " ");
1193 
			if(parts.length < 2) {
41 naveen 1194 
				Utils.severe("Unit is missing, \"" + crumb + "\" = " +
37 naveen 1195 
						bulletText);
1196 
 
1197 
				return null;
1198 
			}
1199 
 
1200 
			else if(parts.length > 2) {
41 naveen 1201 
				Utils.severe("Invalid value, \"" + crumb + "\" = " +
37 naveen 1202 
						bulletText);
1203 
 
1204 
				return null;
1205 
			}
1206 
 
1207 
			bulletValue = parts[0];
1208 
			String unitValue = parts[1];
41 naveen 1209 
			Utils.info("unitValue="+unitValue);
37 naveen 1210 
 
1211 
			if(!(unitValue.equalsIgnoreCase(unitDef.getShortForm()) ||
1212 
					unitValue.equalsIgnoreCase(unitDef.getFullForm()))) {
1213 
 
41 naveen 1214 
				Utils.severe("Invalid unit, \"" + crumb + "\" = " +
37 naveen 1215 
						bulletText);
1216 
 
1217 
			}
1218 
		}
1219 
 
1220 
		// Validate bullet value
41 naveen 1221 
		Utils.info("bulletValue=" + bulletValue);
37 naveen 1222 
		if(isPrimitive) {
1223 
			if(!this.validatePrimitive(bulletValue, datatypeDef, crumb)) {
1224 
				return null;
1225 
			}
1226 
 
1227 
			bullet = new Bullet(new PrimitiveDataObject(bulletValue));
1228 
		}
1229 
 
1230 
		// Enum and fixed
1231 
		else if(isEnum && !bulletDef.isLearned()) {
1232 
			long enumValueID = defs.getEnumValueID(datatypeDef.getID(),
1233 
					bulletValue);
41 naveen 1234 
			Utils.info("enumValueID=" + enumValueID);
37 naveen 1235 
 
1236 
			// Treat it to be free-form
1237 
			if(enumValueID == -1L) {
41 naveen 1238 
				Utils.severe("Not one of the valid enum values, \"" +
40 naveen 1239 
						crumb + "\" = " + bulletValue);
37 naveen 1240 
 
1241 
				return null;
1242 
			}
1243 
 
1244 
			EnumDataObject enumDataObject = new EnumDataObject(enumValueID);
1245 
			bullet = new Bullet(enumDataObject);
1246 
		}
1247 
 
1248 
		// Composite
1249 
		else if(isComposite) {
1250 
			CompositeDefinition compositeDef =
1251 
				(CompositeDefinition)datatypeDef;
1252 
 
1253 
			String separator = compositeDef.getSeparator();
1254 
			String[] compositeParts =
1255 
				StringUtils.split(bulletValue, separator);
1256 
 
1257 
			List<CompositePartDefinition> compositePartDefs =
1258 
				compositeDef.getCompositePartDefinitions();
1259 
 
1260 
			// Validate number of parts
1261 
			if(compositeParts.length != compositePartDefs.size()) {
41 naveen 1262 
				Utils.severe("Invalid value, " + crumb + " = " +
37 naveen 1263 
						bulletValue);
1264 
 
1265 
				return null;
1266 
			}
1267 
 
1268 
			// Remove spurious whitespaces
1269 
			boolean validPart = true;
1270 
			for(int j=0;j<compositeParts.length;j++) {
1271 
				compositeParts[j] = StringUtils.strip(compositeParts[j]);
41 naveen 1272 
				Utils.info("compositeParts["+ j + "]=" +
37 naveen 1273 
						compositeParts[j]);
1274 
 
1275 
				// Validate each part
1276 
				// Each part can be enum or composite in itself
1277 
				// We will stick to primitive for now
1278 
				long partDatatypeDefID =
1279 
					compositePartDefs.get(j).getDatatypeDefinitionID();
1280 
 
1281 
				DatatypeDefinition partDatatypeDef =
1282 
					defs.getDatatypeDefinition(partDatatypeDefID);
41 naveen 1283 
				Utils.info("partDatatypeDef=" + partDatatypeDef);
37 naveen 1284 
 
1285 
				if(!this.validatePrimitive(compositeParts[j],
1286 
						partDatatypeDef, crumb)) {
1287 
					validPart = false;
1288 
					break;
1289 
				}
1290 
			}
1291 
 
1292 
			if(!validPart) {
1293 
				return null;
1294 
			}
1295 
 
1296 
			CompositeDataObject compositeDataObject =
1297 
				new CompositeDataObject();
1298 
 
1299 
			for(int j=0;j<compositeParts.length;j++) {
1300 
				compositeDataObject.addPrimitiveDataObject(
1301 
						new PrimitiveDataObject(compositeParts[j]));
1302 
			}
1303 
 
1304 
			bullet = new Bullet(compositeDataObject);
1305 
		}
1306 
 
38 naveen 1307 
		// Free-form content at bullet level
1308 
		String key = prefix + "_" + bulletText;
1309 
		List<String> bulletFFCs = this.containerFCCs.get(key);
1310 
		bullet.setFreeformContent(new FreeformContent(StringUtils.join(
1311 
				bulletFFCs, "|")));
1312 
 
37 naveen 1313 
		return bullet;
1314 
	}
1315 
 
1316 
 
1317 
	/**
1318 
	 *
1319 
	 * @param bulletValue
1320 
	 * @param datatypeDef
1321 
	 * @param crumb
1322 
	 */
1323 
	private boolean validatePrimitive(String bulletValue,
1324 
			DatatypeDefinition datatypeDef, String crumb) {
1325 
		String dt = datatypeDef.getName();
1326 
 
1327 
		// integer
1328 
		if(dt.equals("integer")) {
1329 
			try {
1330 
				Integer.parseInt(bulletValue);
1331 
			}
1332 
			catch(NumberFormatException nfe) {
41 naveen 1333 
				Utils.severe("Invalid integer value, \"" + crumb +
40 naveen 1334 
						"\" = " + bulletValue);
39 naveen 1335 
				return false;
37 naveen 1336 
			}
1337 
		}
1338 
 
1339 
		// decimal
39 naveen 1340 
		else if(dt.equals("decimal")) {
37 naveen 1341 
			try {
1342 
				Float.parseFloat(bulletValue);
1343 
			}
1344 
			catch(NumberFormatException nfe) {
41 naveen 1345 
				Utils.severe("Invalid decimal value, \"" + crumb +
40 naveen 1346 
						"\" = " + bulletValue);
39 naveen 1347 
				return false;
37 naveen 1348 
			}
1349 
		}
1350 
 
39 naveen 1351 
		// hours_mins e.g. 2 hours 40 mins
1352 
		else if(dt.equals("hours_mins")) {
1353 
			String[]  parts = StringUtils.split(bulletValue, " ");
1354 
			if(!(parts.length == 2 || parts.length == 4)) {
42 naveen 1355 
				Utils.severe("Invalid value, \"" + crumb +
1356 
						"\" = " + bulletValue);
39 naveen 1357 
				return false;
1358 
			}
1359 
			// parts[0]
1360 
			try {
1361 
				Integer.parseInt(StringUtils.strip(parts[0]));
1362 
			}
1363 
			catch (NumberFormatException nfe) {
41 naveen 1364 
				Utils.severe("Invalid value, \"" + crumb +
40 naveen 1365 
						"\" = " + bulletValue);
39 naveen 1366 
				return false;
1367 
			}
1368 
 
1369 
			// parts[1]
42 naveen 1370 
			if(!"hours".equalsIgnoreCase(StringUtils.strip(parts[1]))) {
41 naveen 1371 
				Utils.severe("Invalid value, \"" + crumb +
40 naveen 1372 
						"\" = " + bulletValue);
39 naveen 1373 
				return false;
1374 
			}
1375 
 
1376 
			if(parts.length == 4) {
1377 
				// parts[2]
1378 
				try {
1379 
					Integer.parseInt(StringUtils.strip(parts[2]));
1380 
				}
1381 
				catch (NumberFormatException nfe) {
41 naveen 1382 
					Utils.severe("Invalid value, \"" + crumb +
40 naveen 1383 
							"\" = " + bulletValue);
39 naveen 1384 
					return false;
1385 
				}
1386 
 
1387 
				// parts[3]
42 naveen 1388 
				if(!"mins".equalsIgnoreCase(StringUtils.strip(parts[3]))) {
41 naveen 1389 
					Utils.severe("Invalid value, \"" + crumb +
40 naveen 1390 
							"\" = " + bulletValue);
39 naveen 1391 
					return false;
1392 
				}
1393 
			}
1394 
		}
1395 
 
1396 
		// days_hours e.g. 9 days 14 hours
1397 
		else if(dt.equals("days_hours")) {
1398 
			String[]  parts = StringUtils.split(bulletValue, " ");
1399 
			if(!(parts.length == 2 || parts.length == 4)) {
42 naveen 1400 
				Utils.severe("Invalid value, \"" + crumb +
1401 
						"\" = " + bulletValue);
39 naveen 1402 
				return false;
1403 
			}
1404 
 
1405 
			// parts[0]
1406 
			try {
1407 
				Integer.parseInt(StringUtils.strip(parts[0]));
1408 
			}
1409 
			catch (NumberFormatException nfe) {
41 naveen 1410 
				Utils.severe("Invalid value, \"" + crumb +
40 naveen 1411 
						"\" = " + bulletValue);
39 naveen 1412 
				return false;
1413 
			}
1414 
 
1415 
			// parts[1]
42 naveen 1416 
			if(!"days".equalsIgnoreCase(StringUtils.strip(parts[1]))) {
41 naveen 1417 
				Utils.severe("Invalid value, \"" + crumb +
40 naveen 1418 
						"\" = " + bulletValue);
39 naveen 1419 
				return false;
1420 
			}
1421 
 
1422 
			if(parts.length == 4) {
1423 
				// parts[2]
1424 
				try {
1425 
					Integer.parseInt(StringUtils.strip(parts[2]));
1426 
				}
1427 
				catch (NumberFormatException nfe) {
41 naveen 1428 
					Utils.severe("Invalid value, \"" + crumb +
40 naveen 1429 
							"\" = " + bulletValue);
39 naveen 1430 
					return false;
1431 
				}
1432 
 
1433 
				// parts[3]
42 naveen 1434 
				if("hours".equalsIgnoreCase(StringUtils.strip(parts[3]))) {
41 naveen 1435 
					Utils.severe("Invalid value, \"" + crumb +
40 naveen 1436 
							"\" = " + bulletValue);
39 naveen 1437 
					return false;
1438 
				}
1439 
			}
1440 
		}
1441 
 
1442 
		return true;
37 naveen 1443 
	}
1444 
 
1445 
	/**
1446 
	 *
1447 
	 * @param richTextRuns
1448 
	 * @param info
1449 
	 * @param indent
1450 
	 * @param prefix
1451 
	 */
36 naveen 1452 
	@SuppressWarnings("unchecked")
1453 
	private void drilldown(RichTextRun[] richTextRuns,
37 naveen 1454 
			Map<String, Object[]> info, int indent, String prefix) {
41 naveen 1455 
		Utils.info("drilldown");
36 naveen 1456 
		//System.exit(0);
1457 
 
1458 
 
40 naveen 1459 
		Object[] featuresInfo = info.get("features");
1460 
		if(featuresInfo != null) {
1461 
			List<String> featureLabels = (List<String>) featuresInfo[0];
1462 
			List<Integer> featureIndices = (List<Integer>) featuresInfo[1];
41 naveen 1463 
			Utils.info("featureLabels=" + featureLabels);
1464 
			Utils.info("featureIndices=" + featureIndices);
36 naveen 1465 
 
41 naveen 1466 
			Utils.info("processing features");
40 naveen 1467 
			for(int i=0;i<featureLabels.size();i++) {
1468 
				String featureLabel = featureLabels.get(i);
41 naveen 1469 
				Utils.info("featureLabel="+featureLabel);
40 naveen 1470 
 
1471 
				featureLabels.set(i, StringUtils.lowerCase(
1472 
						StringUtils.strip(StringUtils.trim(featureLabel))));
1473 
 
1474 
				int contentStartIndex = featureIndices.get(i) + 1;
1475 
				int contentIndent = indent + 1;
1476 
 
1477 
				Map<String, Object[]> info1 =
1478 
					getContents(richTextRuns, contentStartIndex, contentIndent);
1479 
 
1480 
				String newprefix = StringUtils.lowerCase(prefix + "_" +
1481 
						featureLabel);
1482 
 
1483 
				drilldown(richTextRuns, info1, contentIndent, newprefix);
1484 
			}
36 naveen 1485 
 
40 naveen 1486 
			if(featureLabels.size() > 0) {
44 naveen 1487 
				Utils.info("prefix=" + prefix);
1488 
				Utils.info("featureLabels=" + featureLabels);
1489 
 
40 naveen 1490 
				this.slideNameFeatureNames.put(prefix, featureLabels);
1491 
			}
36 naveen 1492 
		}
1493 
		//System.exit(0);
1494 
 
40 naveen 1495 
 
1496 
		Object[] bulletsInfo = info.get("bullets");
1497 
		if(bulletsInfo != null) {
1498 
			List<String> bulletLabels = (List<String>) bulletsInfo[0];
1499 
			List<Integer> bulletIndices = (List<Integer>) bulletsInfo[1];
41 naveen 1500 
			Utils.info("bulletLabels=" + bulletLabels);
1501 
			Utils.info("bulletIndices=" + bulletIndices);
36 naveen 1502 
 
41 naveen 1503 
			Utils.info("processing bullets");
40 naveen 1504 
			for(int i=0;i<bulletLabels.size();i++) {
1505 
				String bulletLabel = bulletLabels.get(i);
41 naveen 1506 
				Utils.info("bulletLabel="+bulletLabel);
40 naveen 1507 
 
1508 
				int contentStartIndex = bulletIndices.get(i) + 1;
1509 
				int contentIndent = indent + 1;
1510 
 
1511 
				Map<String, Object[]> info1 = getContents(richTextRuns,
1512 
						contentStartIndex, contentIndent);
1513 
 
1514 
				drilldown(richTextRuns, info1, contentIndent, prefix);
1515 
			}
36 naveen 1516 
 
40 naveen 1517 
			if(bulletLabels.size() > 0) {
1518 
				this.slideNameFeatureNameBulletTexts.put(prefix, bulletLabels);
1519 
			}
36 naveen 1520 
		}
1521 
		//System.exit(0);
1522 
 
40 naveen 1523 
 
1524 
		Object[] childrenSlidesInfo = info.get("childrenSlides");
1525 
		if(childrenSlidesInfo != null) {
1526 
			List<String> childrenSlideLabels =
1527 
				(List<String>) childrenSlidesInfo[0];
36 naveen 1528 
 
40 naveen 1529 
			List<Integer> childrenSlideIndices =
1530 
				(List<Integer>) childrenSlidesInfo[1];
36 naveen 1531 
 
41 naveen 1532 
			Utils.info("childrenSlideLabels=" +
40 naveen 1533 
					childrenSlideLabels);
36 naveen 1534 
 
41 naveen 1535 
			Utils.info("childrenSlideIndices=" +
40 naveen 1536 
					childrenSlideIndices);
36 naveen 1537 
 
41 naveen 1538 
			Utils.info("processing children slides");
40 naveen 1539 
			for(int i=0;i<childrenSlideLabels.size();i++) {
1540 
				String slideLabel = childrenSlideLabels.get(i);
41 naveen 1541 
				Utils.info("slideLabel="+slideLabel);
40 naveen 1542 
 
1543 
				childrenSlideLabels.set(i, StringUtils.lowerCase(slideLabel));
1544 
 
1545 
				int contentStartIndex = childrenSlideIndices.get(i) + 1;
1546 
				int contentIndent = indent + 1;
1547 
 
1548 
				Map<String, Object[]> info1 = getContents(richTextRuns,
1549 
						contentStartIndex, contentIndent);
1550 
 
1551 
				String newprefix = StringUtils.lowerCase(prefix + "_" +
1552 
						slideLabel);
1553 
 
1554 
				drilldown(richTextRuns, info1, contentIndent, newprefix);
1555 
			}
37 naveen 1556 
 
40 naveen 1557 
			if(childrenSlideLabels.size() > 0) {
1558 
				this.slideNameChildrenSlideNames.put(prefix,
1559 
						childrenSlideLabels);
1560 
			}
36 naveen 1561 
		}
40 naveen 1562 
 
36 naveen 1563 
 
40 naveen 1564 
		Object[] ffcInfo = info.get("ffc");
1565 
		if(ffcInfo != null) {
1566 
			List<String> ffcTexts = (List<String>) ffcInfo[0];
1567 
			List<Integer> ffcIndices = (List<Integer>) ffcInfo[1];
41 naveen 1568 
			Utils.info("ffcTexts=" + ffcTexts);
1569 
			Utils.info("ffcIndices=" + ffcIndices);
40 naveen 1570 
 
41 naveen 1571 
			Utils.info("processing ffc");
40 naveen 1572 
			if(ffcTexts.size() > 0) {
1573 
				this.containerFCCs.put(prefix, ffcTexts);
1574 
			}
37 naveen 1575 
		}
36 naveen 1576 
	}
1577 
 
37 naveen 1578 
	/**
1579 
	 *
1580 
	 * @param richTextRuns
1581 
	 * @param startIndex
1582 
	 * @param indent
1583 
	 * @return
1584 
	 */
36 naveen 1585 
	private Map<String, Object[]> getContents(RichTextRun[] richTextRuns,
1586 
			int startIndex, int indent) {
1587 
		Map<String, Object[]> info = new HashMap<String, Object[]>();
1588 
 
1589 
		Object[] childrenSlidesInfo = getChildrenSlides(richTextRuns,
1590 
				startIndex, indent);
1591 
		info.put("childrenSlides", childrenSlidesInfo);
1592 
 
40 naveen 1593 
		if(childrenSlidesInfo != null) {
41 naveen 1594 
			Utils.info("childrenSlidesInfo[0]=" +
40 naveen 1595 
					childrenSlidesInfo[0]);
1596 
 
41 naveen 1597 
			Utils.info("childrenSlidesInfo[1]=" +
40 naveen 1598 
					childrenSlidesInfo[1]);
1599 
		}
1600 
 
36 naveen 1601 
		Object[] featuresInfo = getFeatures(richTextRuns,
1602 
				startIndex, indent);
1603 
		info.put("features", featuresInfo);
1604 
 
40 naveen 1605 
		if(featuresInfo != null) {
41 naveen 1606 
			Utils.info("featuresInfo[0]=" + featuresInfo[0]);
1607 
			Utils.info("featuresInfo[1]=" + featuresInfo[1]);
40 naveen 1608 
		}
36 naveen 1609 
 
1610 
		Object[] bulletsInfo = getBulletInfo(richTextRuns,
1611 
				startIndex, indent);
1612 
		info.put("bullets", bulletsInfo);
1613 
 
40 naveen 1614 
		if(bulletsInfo != null) {
41 naveen 1615 
			Utils.info("bulletsInfo[0]=" + bulletsInfo[0]);
1616 
			Utils.info("bulletsInfo[1]=" + bulletsInfo[1]);
40 naveen 1617 
		}
36 naveen 1618 
 
1619 
		Object[] ffcInfo = getFreeformContent(richTextRuns,
1620 
				startIndex, indent);
1621 
		info.put("ffc", ffcInfo);
1622 
 
40 naveen 1623 
		if(ffcInfo != null) {
41 naveen 1624 
			Utils.info("ffcInfo[0]=" + ffcInfo[0]);
1625 
			Utils.info("ffcInfo[1]=" + ffcInfo[1]);
40 naveen 1626 
		}
36 naveen 1627 
 
1628 
		return info;
1629 
	}
1630 
 
37 naveen 1631 
	/**
1632 
	 *
1633 
	 * @param richTextRuns
1634 
	 * @param startIndex
1635 
	 * @param indent
1636 
	 * @return
1637 
	 */
36 naveen 1638 
	private Object[] getBulletInfo(RichTextRun[] richTextRuns,
1639 
			int startIndex, int indent) {
1640 
 
37 naveen 1641 
		// -16776961 - Blue
36 naveen 1642 
		Object[] bulletsInfo = this.getInfo(richTextRuns, startIndex, indent,
38 naveen 1643 
				HSLF.BLUE, true);
36 naveen 1644 
 
1645 
		return bulletsInfo;
1646 
	}
1647 
 
37 naveen 1648 
	/**
1649 
	 *
1650 
	 * @param richTextRuns
1651 
	 * @param startIndex
1652 
	 * @param indent
1653 
	 * @return
1654 
	 */
36 naveen 1655 
	private Object[] getFreeformContent(RichTextRun[] richTextRuns,
1656 
			int startIndex, int indent) {
1657 
 
37 naveen 1658 
		// -6749953 - Purple
36 naveen 1659 
		Object[] ffcInfo = this.getInfo(richTextRuns, startIndex,
40 naveen 1660 
				indent, HSLF.PURPLE, true);
36 naveen 1661 
 
1662 
 
1663 
		return ffcInfo;
1664 
	}
1665 
 
37 naveen 1666 
	/**
1667 
	 *
1668 
	 * @param richTextRuns
1669 
	 * @param startIndex
1670 
	 * @param indent
1671 
	 * @return
1672 
	 */
36 naveen 1673 
	private Object[] getFeatures(RichTextRun[] richTextRuns,
1674 
			int startIndex, int indent) {
1675 
 
37 naveen 1676 
		// -16711936 - Green
36 naveen 1677 
		Object[] featuresInfo = this.getInfo(richTextRuns, startIndex,
40 naveen 1678 
				indent, HSLF.GREEN, true);
36 naveen 1679 
 
1680 
		return featuresInfo;
1681 
	}
1682 
 
37 naveen 1683 
	/**
1684 
	 *
1685 
	 * @param richTextRuns
1686 
	 * @param startIndex
1687 
	 * @param indent
1688 
	 * @return
1689 
	 */
36 naveen 1690 
	private Object[] getChildrenSlides(RichTextRun[] richTextRuns,
1691 
			int startIndex, int indent) {
1692 
 
37 naveen 1693 
		// -26368 - Orange
36 naveen 1694 
		Object[] childrenSlidesInfo = this.getInfo(richTextRuns, startIndex,
40 naveen 1695 
				indent, HSLF.ORANGE, true);
36 naveen 1696 
 
1697 
		return childrenSlidesInfo;
1698 
	}
1699 
 
37 naveen 1700 
	/**
1701 
	 *
1702 
	 * @param rts
1703 
	 * @param startIndex
1704 
	 * @param indent
1705 
	 * @param rgb
1706 
	 * @param debug
1707 
	 * @return
1708 
	 */
36 naveen 1709 
	private Object[] getInfo(RichTextRun[] rts, int startIndex,
1710 
			int indent, int rgb, boolean debug) {
1711 
		List<String> labels = new ArrayList<String>();
1712 
		List<Integer> indices = new ArrayList<Integer>();
40 naveen 1713 
 
1714 
		if(startIndex >= rts.length) {
1715 
			return null;
1716 
		}
1717 
 
36 naveen 1718 
		int i = startIndex;
1719 
		while(true) {
1720 
			if(debug) {
41 naveen 1721 
				Utils.info("rts["+i+"].getRawText=" +
36 naveen 1722 
						rts[i].getRawText());
1723 
 
41 naveen 1724 
				Utils.info("rts["+i+"].isBullet=" + rts[i].isBullet());
1725 
				Utils.info("rts["+i+"].getIndentLevel=" +
36 naveen 1726 
						rts[i].getIndentLevel());
1727 
 
41 naveen 1728 
				Utils.info("rts["+i+"].getBulletColor().getRGB=" +
36 naveen 1729 
						rts[i].getBulletColor().getRGB());
1730 
 
1731 
 
41 naveen 1732 
				Utils.info("rts["+i+"].getFontColor().getRGB=" +
36 naveen 1733 
						rts[i].getFontColor().getRGB());
1734 
 
41 naveen 1735 
				Utils.info("rgb=" + rgb);
1736 
				Utils.info("indent=" + indent);
37 naveen 1737 
 
41 naveen 1738 
				Utils.info("rts.length=" + rts.length);
36 naveen 1739 
			}
40 naveen 1740 
			// rts[i].isBullet() &&
1741 
			// rts[i].getBulletColor().getRGB() == rgb
1742 
			// rts[i].getFontColor().getRGB()
1743 
			if(rts[i].getIndentLevel() == indent &&
1744 
					(rts[i].getBulletColor().getRGB() == rgb ||
1745 
							rts[i].getFontColor().getRGB() == rgb)) {
1746 
 
41 naveen 1747 
				Utils.info("Criteria of color, indent etc. is met");
36 naveen 1748 
				i = this.getValidLabel(i, rts, labels, indices, debug);
41 naveen 1749 
				if(debug) Utils.info("new i="+ i);
36 naveen 1750 
			}
41 naveen 1751 
			Utils.info("labels=" + labels);
1752 
			Utils.info("indices=" + indices);
36 naveen 1753 
 
41 naveen 1754 
			Utils.info("(i >= (rts.length-1))" + (i >= (rts.length-1)));
40 naveen 1755 
			if(i >= (rts.length-1)) {
1756 
				break;
1757 
			}
36 naveen 1758 
 
40 naveen 1759 
			// rts[i+1].isBullet() &&
1760 
			if(rts[i+1].getIndentLevel() < indent) {
1761 
				break;
1762 
			}
1763 
 
36 naveen 1764 
			i++;
1765 
		}
1766 
		return new Object[] {labels, indices};
1767 
	}
1768 
 
37 naveen 1769 
	/**
1770 
	 *
1771 
	 * @param index
1772 
	 * @param rts
1773 
	 * @param labels
1774 
	 * @param indices
1775 
	 * @param debug
1776 
	 * @return
1777 
	 */
36 naveen 1778 
	private int getValidLabel(int index, RichTextRun[] rts,
1779 
		List<String> labels, List<Integer> indices, boolean debug){
1780 
		StringBuffer sb = new StringBuffer();
1781 
		while(true) {
37 naveen 1782 
			if(index > rts.length - 1) {
1783 
				break;
1784 
			}
1785 
 
36 naveen 1786 
			String text = rts[index].getRawText();
1787 
		    if(text.equals("\r")) {
1788 
		    	break;
1789 
		    }
1790 
		    sb.append(text);
1791 
		    index++;
1792 
		}
41 naveen 1793 
		if(debug)Utils.info("before label=]"+sb.toString()+"[");
36 naveen 1794 
		String label = StringUtils.strip(StringUtils.trim(sb.toString()));
41 naveen 1795 
		if(debug)Utils.info("after label=]"+label+"[");
36 naveen 1796 
 
41 naveen 1797 
		//for(int i=0;i<label.length();i++) Utils.info(label.charAt(i));
36 naveen 1798 
 
1799 
		if(!label.isEmpty()) {
1800 
			indices.add(new Integer(index));
37 naveen 1801 
 
1802 
			// Remove hardspace character \xa0
1803 
			char hardspace = (char)160;
1804 
			char softspace = (char)32;
1805 
			label = StringUtils.strip(StringUtils.replaceChars(label,
1806 
					hardspace, softspace));
1807 
 
36 naveen 1808 
			labels.add(label);
1809 
		}
1810 
 
1811 
		return index;
1812 
	}
41 naveen 1813 
 
37 naveen 1814 
	/**
1815 
	 * TEST ONLY
1816 
	 *
1817 
	 * @param filename
1818 
	 * @throws Exception
1819 
	 */
36 naveen 1820 
	public static void showAllRichText(String filename) throws Exception {
1821 
		HSLFSlideShow hslfSS = new HSLFSlideShow(filename);
1822 
		SlideShow ss = new SlideShow(hslfSS);
1823 
		Slide[] ssarr = ss.getSlides();
1824 
 
1825 
		for(int i=0; i < ssarr.length; i++) {
1826 
			TextRun[] trarr = ssarr[i].getTextRuns();
1827 
			//System.out.println("\nTitle=" + ssarr[i].getTitle());
1828 
			//System.out.println(ssarr[i].getTitle());
1829 
 
1830 
			for(int j=0; j < trarr.length; j++) {
1831 
				System.out.println("\ntrarr[" + j + "].getRawText=" +
1832 
						trarr[j].getRawText());
1833 
 
1834 
				RichTextRun[] rtrarr = trarr[j].getRichTextRuns();
1835 
 
1836 
				StringBuffer indent2 = new StringBuffer();
1837 
 
1838 
				for(int k=0; k < rtrarr.length; k++) {
1839 
					String rawText = rtrarr[k].getRawText();
1840 
					System.out.println("\nrtrarr[" + k + "].getRawText=" +
1841 
							rawText);
1842 
					System.out.println("rtrarr[" + k + "].isBullet=" +
1843 
							rtrarr[k].isBullet());
1844 
 
1845 
					System.out.println("rtrarr[" + k + "].isUnderlined=" +
1846 
							rtrarr[k].isUnderlined());
1847 
 
1848 
					//System.out.println("Ends with CR=" +
1849 
					//		StringUtils.endsWith(rawText, "\r"));
1850 
 
1851 
					//System.out.println("\nRawText=" + rawText);
1852 
 
1853 
					/*
1854 
					if(StringUtils.strip(rawText).isEmpty()) {
1855 
						continue;
1856 
					}
1857 
					*/
1858 
 
1859 
					int indent = rtrarr[k].getIndentLevel();
1860 
					System.out.println("indent=" + indent);
1861 
					if(indent == 2) {
1862 
						indent2.append(rawText);
1863 
					}
1864 
 
1865 
					int rgb = rtrarr[k].getBulletColor().getRGB();
1866 
					System.out.println("rgb=" + rgb);
1867 
 
1868 
					int fontrgb = rtrarr[k].getFontColor().getRGB();
1869 
					System.out.println("font rgb=" + fontrgb);
1870 
 
1871 
					String fontname = rtrarr[k].getFontName();
1872 
					System.out.println("font rgb=" + fontname);
1873 
 
1874 
				}
1875 
			}
1876 
		}
1877 
	}
1878 
 
37 naveen 1879 
	/**
1880 
	 * TEST ONLY
1881 
	 *
1882 
	 * @param filename
1883 
	 * @throws Exception
1884 
	 */
36 naveen 1885 
	public static void showAllText(String filename) throws Exception {
1886 
		PowerPointExtractor ppe = new PowerPointExtractor(filename);
1887 
		System.out.println(ppe.getText());
1888 
	}
1889 
}