Subversion Repositories SmartDukaan

Rev

Rev 18 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 18 Rev 19
Line 3... Line 3...
3 
 */
 3 
 */
4 
package in.shop2020.metamodel.util;
 4 
package in.shop2020.metamodel.util;
5 
 
 5 
 
6 
import java.io.BufferedReader;
 6 
import java.io.BufferedReader;
7 
import java.io.FileReader;
 7 
import java.io.FileReader;
- 
 
 8 
import java.io.IOException;
8 
import java.io.LineNumberReader;
 9 
import java.io.LineNumberReader;
9 
import java.util.ArrayList;
 10 
import java.util.ArrayList;
- 
 
 11 
import java.util.Collection;
10 
import java.util.HashMap;
 12 
import java.util.HashMap;
11 
import java.util.Iterator;
 13 
import java.util.Iterator;
12 
import java.util.List;
 14 
import java.util.List;
13 
import java.util.Map;
 15 
import java.util.Map;
- 
 
 16 
import java.util.TreeMap;
14 
import java.util.logging.Level;
 17 
import java.util.logging.Level;
15 
 
 18 
 
- 
 
 19 
import in.shop2020.metamodel.definitions.BulletDefinition;
16 
import in.shop2020.metamodel.definitions.Catalog;
 20 
import in.shop2020.metamodel.definitions.Catalog;
17 
import in.shop2020.metamodel.definitions.Category;
 21 
import in.shop2020.metamodel.definitions.Category;
- 
 
 22 
import in.shop2020.metamodel.definitions.CompositeDefinition;
18 
import in.shop2020.metamodel.definitions.DatatypeDefinition;
 23 
import in.shop2020.metamodel.definitions.DatatypeDefinition;
19 
import in.shop2020.metamodel.definitions.DefinitionsContainer;
 24 
import in.shop2020.metamodel.definitions.DefinitionsContainer;
20 
import in.shop2020.metamodel.definitions.EditorialImportance;
 25 
import in.shop2020.metamodel.definitions.EditorialImportance;
- 
 
 26 
import in.shop2020.metamodel.definitions.EnumDefinition;
21 
import in.shop2020.metamodel.definitions.FeatureDefinition;
 27 
import in.shop2020.metamodel.definitions.FeatureDefinition;
22 
import in.shop2020.metamodel.definitions.SlideDefinition;
 28 
import in.shop2020.metamodel.definitions.SlideDefinition;
23 
import in.shop2020.metamodel.definitions.Unit;
 29 
import in.shop2020.metamodel.definitions.Unit;
24 
import in.shop2020.util.Utils;
 30 
import in.shop2020.util.Utils;
25 
 
 31 
 
Line 51... Line 57...
51 
 
 57 
 
52 
	private long categoryID;
 58 
	private long categoryID;
53 
	private String srcFile;
 59 
	private String srcFile;
54 
	private String dbFile;
 60 
	private String dbFile;
55
61
- 
 
 62 
	private Map<String, Long> slideNameToSlideDefID =
- 
 
 63 
		new HashMap<String, Long>();
- 
 
 64
- 
 
 65 
	private Map<String, Long> slideNameFeatureNameToFeatureDefID =
- 
 
 66 
		new HashMap<String, Long>();
- 
 
 67 
 
- 
 
 68 
	private Map<String, Long> slideNameFeatureNameToEnumValueID =
- 
 
 69 
		new HashMap<String, Long>();
- 
 
 70
56 
	/**
 71 
	/**
57 
	 * @param args
 72 
	 * @param args
58 
	 */
 73 
	 */
59 
	public static void main(String[] args) throws Exception {
 74 
	public static void main(String[] args) throws Exception {
60 
		String[] commands = new String[] {"show", "import"};
 75 
		String[] commands = new String[] {"show", "import"};
Line 110... Line 125...
110
125
111 
		FileReader fileReader = new FileReader(this.srcFile);
 126 
		FileReader fileReader = new FileReader(this.srcFile);
112 
		BufferedReader lineReader = new BufferedReader(fileReader);
 127 
		BufferedReader lineReader = new BufferedReader(fileReader);
113 
		LineNumberReader reader = new LineNumberReader(lineReader);
 128 
		LineNumberReader reader = new LineNumberReader(lineReader);
114
129
- 
 
 130 
		List<String> allLines = new ArrayList<String>();
- 
 
 131
115 
		// 1 Collect all candidate slide names
 132 
		// 1 Collect all candidate slide names
- 
 
 133 
		// Order of keys need to be restored
116 
		Map<Integer, String> candidateSlideNames = new HashMap<Integer, String>();
 134 
		Map<Integer, String> candidateSlideNames =
- 
 
 135 
			new TreeMap<Integer, String>();
- 
 
 136
- 
 
 137 
		int lineCount = 0;
117 
		while(true) {
 138 
		while(true) {
118 
			String line = reader.readLine();
 139 
			String line = reader.readLine();
119
- 
 
120 
			if(line == null) {
 140 
			if(line == null) {
121 
				break;
 141 
				break;
122 
			}
 142 
			}
123
143
- 
 
 144 
			allLines.add(line);
- 
 
 145 
			lineCount++;
- 
 
 146
124 
			if(line.isEmpty()) {
 147 
			if(line.isEmpty()) {
125 
				continue;
 148 
				continue;
126 
			}
 149 
			}
127 
 
 150 
 
128 
			int lineNumber = reader.getLineNumber();
 151 
			int lineNumber = reader.getLineNumber();
Line 138... Line 161...
138 
				//Utils.logger.info("Level 0");
 161 
				//Utils.logger.info("Level 0");
139
162
140 
				candidateSlideNames.put(new Integer(lineNumber), line);
 163 
				candidateSlideNames.put(new Integer(lineNumber), line);
141 
			}
 164 
			}
142 
		}
 165 
		}
- 
 
 166 
 
- 
 
 167 
		lineReader.close();
- 
 
 168
- 
 
 169 
		Utils.logger.info("lineCount=" + lineCount);
143 
		Utils.logger.info(candidateSlideNames.toString());
 170 
		Utils.logger.info(candidateSlideNames.toString());
144
171
145 
		// 2 Filter and validate parent slide names
 172 
		// 2 Filter and validate parent slide names
146 
		Map<Integer, String> slideNames =
173 
		Map<Integer, String> slideNames =
147 
			this.processSlides(candidateSlideNames);
 174 
			this.processSlides(candidateSlideNames);
148
175
149 
		Utils.logger.info(slideNames.toString());
 176 
		Utils.logger.info(slideNames.toString());
150
177
151 
		// 3 Children slides
 178 
		// 3 Collect all children slides
- 
 
 179 
		// 4 Filter and validate children slide names
152 
		// TODO
 180 
		// TODO
153
181
154 
		// 4 Features
 182 
		// 5 Collect all Features for a slide
- 
 
 183 
		// 5.1 Find line number range between which content for feature is found
- 
 
 184 
		Map<String, int[]> featureLineNumberRangePerSlide =
- 
 
 185 
			new HashMap<String, int[]>();
155 
		// TODO
 186
- 
 
 187 
		Utils.logger.info("slideNames.keySet=" +
- 
 
 188 
				slideNames.keySet().toString());
156
189
- 
 
 190 
		Integer[] slideLineNumbers = slideNames.keySet().toArray(
- 
 
 191 
				new Integer[0]);
- 
 
 192
- 
 
 193 
		for(int i=0; i<slideLineNumbers.length-1; i++) {
- 
 
 194 
			int from = slideLineNumbers[i]+1;
- 
 
 195 
			int to = slideLineNumbers[i+1]-1;
- 
 
 196 
			Utils.logger.info("from=" + from + " to=" + to);
- 
 
 197
- 
 
 198 
			String tSlideName = slideNames.get(
- 
 
 199 
					new Integer(slideLineNumbers[i]));
- 
 
 200
- 
 
 201 
			Utils.logger.info("tSlideName=" + tSlideName);
- 
 
 202
- 
 
 203 
			featureLineNumberRangePerSlide.put(tSlideName,
- 
 
 204 
					new int[] {from, to});
- 
 
 205 
		}
- 
 
 206 
 
- 
 
 207 
		// For last slide
- 
 
 208 
		Utils.logger.info("tSlideName=" +
- 
 
 209 
				slideNames.get(new Integer(
- 
 
 210 
						slideLineNumbers[slideLineNumbers.length-1])));
- 
 
 211
- 
 
 212 
		Utils.logger.info("lineNumbers[lineNumbers.length-1]=" +
- 
 
 213 
				slideLineNumbers[slideLineNumbers.length-1]);
- 
 
 214
- 
 
 215 
		Utils.logger.info(
- 
 
 216 
			"from=" + (slideLineNumbers[slideLineNumbers.length-1]+1) + " to=" +
- 
 
 217 
			(lineCount-1));
- 
 
 218
- 
 
 219 
		featureLineNumberRangePerSlide.put(
- 
 
 220 
			slideNames.get(
- 
 
 221 
				new Integer(slideLineNumbers[slideLineNumbers.length-1])),
- 
 
 222 
				new int[] {(slideLineNumbers[slideLineNumbers.length-1] + 1),
- 
 
 223 
				(lineCount-1)});
- 
 
 224
- 
 
 225 
		Utils.logger.info("featureLineNumberRangePerSlide=" +
- 
 
 226 
				featureLineNumberRangePerSlide.toString());
- 
 
 227
- 
 
 228 
		// 6 Filter and validate features
- 
 
 229 
		DefinitionsContainer defs =
- 
 
 230 
			Catalog.getInstance().getDefinitionsContainer();
- 
 
 231
- 
 
 232 
		Map<String, Map> slideFeatureLabels =
- 
 
 233 
			new HashMap<String, Map>();
- 
 
 234
- 
 
 235 
		for(String slideName : slideNames.values()) {
- 
 
 236 
			//Utils.logger.info("slideName=" + slideName);
- 
 
 237 
			List<SlideDefinition> slideDefs =
- 
 
 238 
				defs.getSlideDefinition(slideName);
- 
 
 239
- 
 
 240 
			if(slideDefs == null) {
- 
 
 241 
				continue;
- 
 
 242 
			}
- 
 
 243
- 
 
 244 
			if (slideDefs.isEmpty()) {
- 
 
 245 
				continue;
- 
 
 246 
			}
- 
 
 247
- 
 
 248 
			// RE-VISIT
- 
 
 249 
			// Pick the first
- 
 
 250 
			Utils.logger.info("slideDef=" + slideDefs.get(0));
- 
 
 251 
			Long slideID = slideDefs.get(0).getID();
- 
 
 252 
			this.slideNameToSlideDefID.put(slideName, slideID);
- 
 
 253
- 
 
 254 
			Map<Integer, String> featureLabels =
- 
 
 255 
				this.processFeature(allLines, slideDefs.get(0),
- 
 
 256 
					featureLineNumberRangePerSlide.get(slideName));
- 
 
 257
- 
 
 258 
			// Find feature definition IDs
- 
 
 259 
			for(String featureLabel : featureLabels.values()) {
- 
 
 260 
				FeatureDefinition featureDef = defs.getFeatureDefinition(
- 
 
 261 
						slideID.longValue(), featureLabel);
- 
 
 262
- 
 
 263 
				this.slideNameFeatureNameToFeatureDefID.put(
- 
 
 264 
						(slideName + "_" + featureLabel),
- 
 
 265 
						new Long(featureDef.getID()));
- 
 
 266 
			}
- 
 
 267
- 
 
 268 
			slideFeatureLabels.put(slideName, featureLabels);
- 
 
 269 
		}
- 
 
 270
- 
 
 271 
		Utils.logger.info("slideFeatureLabels=" + slideFeatureLabels);
- 
 
 272
- 
 
 273 
		Utils.logger.info("slideNameToSlideDefID=" +
- 
 
 274 
				this.slideNameToSlideDefID);
- 
 
 275
- 
 
 276 
		Utils.logger.info("slideNameFeatureNameToFeatureDefID=" +
- 
 
 277 
				this.slideNameFeatureNameToFeatureDefID);
- 
 
 278
157 
		// 5 Bullets
 279 
		// 7 Bullets
- 
 
 280 
		// Collect all bullets
- 
 
 281 
		for(String slideName : slideFeatureLabels.keySet()) {
- 
 
 282 
			Map<Integer, String> featureLabels =
- 
 
 283 
				slideFeatureLabels.get(slideName);
- 
 
 284 
 
- 
 
 285 
			// 7.1 Find line number range between which content for bullets
- 
 
 286 
			// is found (per feature on this slide)
- 
 
 287 
			Map<String, int[]> bulletLineNumberRangePerFeature =
- 
 
 288 
				this.getBulletLineRange(allLines, featureLabels);
- 
 
 289
- 
 
 290 
			for(String featureLabel : bulletLineNumberRangePerFeature.keySet()){
- 
 
 291 
 
- 
 
 292 
				String key = slideName + "_" + featureLabel;
- 
 
 293 
				Long featureDefID =
- 
 
 294 
					this.slideNameFeatureNameToFeatureDefID.get(key);
- 
 
 295 
				FeatureDefinition featureDef =
- 
 
 296 
					defs.getFeatureDefinition(featureDefID.longValue());
- 
 
 297
- 
 
 298 
				Long slideDefID = this.slideNameToSlideDefID.get(slideName);
- 
 
 299 
				SlideDefinition slideDef = defs.getSlideDefinition(slideDefID);
- 
 
 300
- 
 
 301 
				this.processBullets(allLines,
- 
 
 302 
						bulletLineNumberRangePerFeature.get(featureLabel),
- 
 
 303 
						featureDef, slideDef);
158 
		// TODO
 304 
			}
- 
 
 305 
		}
159
306
160 
		lineReader.close();
 - 
 
161 
	}
 307 
	}
162
308
163 
	/**
 309 
	/**
164 
	 *
310 
	 *
165 
	 * @throws Exception
 311 
	 * @throws Exception
166 
	 */
 312 
	 */
167 
	public void showEntity() throws Exception {
 313 
	public void showEntity() throws Exception {
168 
	}
 314 
	}
- 
 
 315
- 
 
 316 
	/**
- 
 
 317 
	 *
- 
 
 318 
	 * @param allLines
- 
 
 319 
	 * @param bulletLineNumberRange
- 
 
 320 
	 * @param featureDef
- 
 
 321 
	 * @throws Exception
- 
 
 322 
	 */
- 
 
 323 
	private void processBullets(List<String> allLines,
- 
 
 324 
			int[] bulletLineNumberRange, FeatureDefinition featureDef,
- 
 
 325 
			SlideDefinition slideDef) throws Exception {
- 
 
 326
- 
 
 327 
		int from = bulletLineNumberRange[0];
- 
 
 328 
		int to = bulletLineNumberRange[1];
- 
 
 329
- 
 
 330 
		BulletDefinition bulletDef = featureDef.getBulletDefinition();
- 
 
 331 
		Utils.logger.info("bulletDefinition=" + bulletDef);
- 
 
 332
- 
 
 333 
		DefinitionsContainer defs =
- 
 
 334 
			Catalog.getInstance().getDefinitionsContainer();
- 
 
 335
- 
 
 336 
		String crumb = "\"" + slideDef.getLabel() + "\" > \"" +
- 
 
 337 
			featureDef.getLabel() + "\"";
- 
 
 338
- 
 
 339 
		// Enforce isMultivalue
- 
 
 340 
		if(!bulletDef.isMultivalue() && (from != to)) {
- 
 
 341 
			Utils.logger.severe("Only one bullet is allowed for " + crumb);
- 
 
 342 
			return;
- 
 
 343 
		}
- 
 
 344 
 
- 
 
 345 
		// If unit is defined
- 
 
 346 
		Unit unitDef =  null;
- 
 
 347 
		if(bulletDef.getUnitID() != 0L) {
- 
 
 348 
			long unitID = bulletDef.getUnitID();
- 
 
 349 
			unitDef = defs.getUnit(unitID);
- 
 
 350 
			Utils.logger.info("unitDef=" + unitDef);
- 
 
 351 
		}
- 
 
 352 
 
- 
 
 353 
		long datatypeDefID = bulletDef.getDatatypeDefinitionID();
- 
 
 354 
		DatatypeDefinition datatypeDef =
- 
 
 355 
			defs.getDatatypeDefinition(datatypeDefID);
- 
 
 356 
		Utils.logger.info("datatypeDef=" + datatypeDef);
- 
 
 357 
 
- 
 
 358 
		// If primitive
- 
 
 359 
		boolean isEnum = false;
- 
 
 360 
		boolean isComposite = false;
- 
 
 361 
		boolean isPrimitive = false;
- 
 
 362 
		if(datatypeDef instanceof EnumDefinition) {
- 
 
 363 
			isEnum = true;
- 
 
 364 
		}
- 
 
 365 
		else if(datatypeDef instanceof CompositeDefinition) {
- 
 
 366 
			isComposite = true;
- 
 
 367 
		}
- 
 
 368 
		else {
- 
 
 369 
			isPrimitive = true;
- 
 
 370 
		}
- 
 
 371
- 
 
 372 
		Utils.logger.info("isEnum=" + isEnum + " isComposite=" + isComposite +
- 
 
 373 
				" isPrimitive=" + isPrimitive);
- 
 
 374
- 
 
 375 
		for(int i=from; i<to+1; i++) {
- 
 
 376 
			String line = allLines.get(i);
- 
 
 377
- 
 
 378 
			if(!StringUtils.startsWith(line, CN.PATTERN_LEVEL_2)) {
- 
 
 379 
				continue;
- 
 
 380 
			}
- 
 
 381
- 
 
 382 
			String bulletText = StringUtils.strip(StringUtils.stripStart(line,
- 
 
 383 
					CN.PATTERN_LEVEL_2));
- 
 
 384 
			Utils.logger.info("bulletText=" + bulletText);
- 
 
 385
- 
 
 386 
			// if no unit is defined for this bullet whole is treated as value
- 
 
 387 
			String bulletValue = bulletText;
- 
 
 388
- 
 
 389 
			// If unit is defined
- 
 
 390 
			if(bulletDef.getUnitID() != 0L) {
- 
 
 391
- 
 
 392 
				// Validate unit
- 
 
 393 
				String[] parts = StringUtils.split(bulletText, " ");
- 
 
 394 
				if(parts.length < 2) {
- 
 
 395 
					Utils.logger.severe("Unit is missing, " + crumb + " = " +
- 
 
 396 
							bulletText);
- 
 
 397
- 
 
 398 
					continue;
- 
 
 399 
				}
- 
 
 400
- 
 
 401 
				if(parts.length > 2) {
- 
 
 402 
					Utils.logger.severe("Invalid value, " + crumb + " = " +
- 
 
 403 
							bulletText);
- 
 
 404
- 
 
 405 
					continue;
- 
 
 406 
				}
- 
 
 407
- 
 
 408 
				bulletValue = parts[0];
- 
 
 409 
				String unitValue = parts[1];
- 
 
 410 
				Utils.logger.info("unitValue="+unitValue);
- 
 
 411
- 
 
 412 
				if(!(unitValue.equalsIgnoreCase(unitDef.getShortForm()) ||
- 
 
 413 
						unitValue.equalsIgnoreCase(unitDef.getFullForm()))) {
- 
 
 414 
					Utils.logger.severe("Invalid unit, " + crumb + " = " +
- 
 
 415 
							bulletText);
- 
 
 416
- 
 
 417 
					continue;
- 
 
 418 
				}
- 
 
 419 
			}
- 
 
 420
- 
 
 421 
			// Validate bullet value
- 
 
 422 
			Utils.logger.info("bulletValue=" + bulletValue);
- 
 
 423 
			if(isPrimitive) {
- 
 
 424 
				String dt = datatypeDef.getName();
- 
 
 425
- 
 
 426 
				// integer
- 
 
 427 
				if(dt.equals("integer")) {
- 
 
 428 
					try {
- 
 
 429 
						Integer.parseInt(bulletValue);
- 
 
 430 
					}
- 
 
 431 
					catch(NumberFormatException nfe) {
- 
 
 432 
						Utils.logger.severe("Invalide integer value, " + crumb +
- 
 
 433 
								" = " + bulletValue);
- 
 
 434 
					}
- 
 
 435 
				}
- 
 
 436
- 
 
 437 
				// decimal
- 
 
 438 
				else if(dt.endsWith("decimal")) {
- 
 
 439 
					try {
- 
 
 440 
						Float.parseFloat(bulletValue);
- 
 
 441 
					}
- 
 
 442 
					catch(NumberFormatException nfe) {
- 
 
 443 
						Utils.logger.severe("Invalide decimal value, " + crumb +
- 
 
 444 
								" = " + bulletValue);
- 
 
 445 
					}
- 
 
 446 
				}
- 
 
 447
- 
 
 448 
				// string
- 
 
 449 
				// any thing goes
- 
 
 450 
			}
- 
 
 451
- 
 
 452 
			// Enum and fixed
- 
 
 453 
			else if(isEnum && !bulletDef.isLearned()) {
- 
 
 454 
				long enumValueID = defs.getEnumValueID(datatypeDef.getID(),
- 
 
 455 
						bulletValue);
- 
 
 456
- 
 
 457 
				if(enumValueID == -1L) {
- 
 
 458 
					Utils.logger.severe("Invalid value, " + crumb + " = " +
- 
 
 459 
							bulletValue);
- 
 
 460
- 
 
 461 
					continue;
- 
 
 462 
				}
- 
 
 463
- 
 
 464 
				String key = slideDef.getLabel() + "_" + featureDef.getLabel() +
- 
 
 465 
					"_" + bulletValue;
- 
 
 466
- 
 
 467 
				this.slideNameFeatureNameToEnumValueID.put(key,
- 
 
 468 
						new Long(enumValueID));
- 
 
 469 
			}
- 
 
 470
- 
 
 471 
			// Composite
- 
 
 472 
			else if(isComposite) {
- 
 
 473
- 
 
 474 
			}
- 
 
 475 
		}
- 
 
 476
- 
 
 477 
		Utils.logger.info("slideNameFeatureNameToEnumValueID=" +
- 
 
 478 
				this.slideNameFeatureNameToEnumValueID);
- 
 
 479 
	}
- 
 
 480
- 
 
 481 
	/**
- 
 
 482 
	 *
- 
 
 483 
	 * @param allLines
- 
 
 484 
	 * @param featureLabels
- 
 
 485 
	 * @return
- 
 
 486 
	 */
- 
 
 487 
	private Map<String, int[]> getBulletLineRange(List<String> allLines,
- 
 
 488 
			Map<Integer, String> featureLabels) {
- 
 
 489 
		Utils.logger.info("allLines=" + allLines);
- 
 
 490 
		Utils.logger.info("featureLabels=" + featureLabels);
- 
 
 491
- 
 
 492 
		// 5.1 Find line number range between which content for feature is found
- 
 
 493 
		Map<String, int[]> bulletLineNumberRangePerFeature =
- 
 
 494 
			new HashMap<String, int[]>();
- 
 
 495
- 
 
 496 
		Utils.logger.info("featureLabels.keySet=" +
- 
 
 497 
				featureLabels.keySet().toString());
- 
 
 498
- 
 
 499 
		Integer[] featureLineNumbers = featureLabels.keySet().toArray(
- 
 
 500 
				new Integer[0]);
- 
 
 501
- 
 
 502 
		for(int i=0; i<featureLineNumbers.length-1; i++) {
- 
 
 503 
			String tFeatureLabel = featureLabels.get(
- 
 
 504 
					new Integer(featureLineNumbers[i]));
- 
 
 505
- 
 
 506 
			Utils.logger.info("tFeatureLabel=" + tFeatureLabel);
- 
 
 507
- 
 
 508 
			int from = featureLineNumbers[i]+1;
- 
 
 509 
			int to = featureLineNumbers[i+1]-1;
- 
 
 510 
			Utils.logger.info("from=" + from + " to=" + to);
- 
 
 511
- 
 
 512 
			bulletLineNumberRangePerFeature.put(tFeatureLabel,
- 
 
 513 
					new int[] {from, to});
- 
 
 514 
		}
- 
 
 515 
 
- 
 
 516 
		// For last feature
- 
 
 517 
		String lastFeatureLabel = featureLabels.get(
- 
 
 518 
			new Integer(featureLineNumbers[featureLineNumbers.length-1]));
- 
 
 519 
		Utils.logger.info("lastFeatureLabel=" + lastFeatureLabel);
- 
 
 520
- 
 
 521 
		int lastFrom = featureLineNumbers[featureLineNumbers.length-1] + 1;
- 
 
 522 
		Utils.logger.info("lastFrom=" + lastFrom);
- 
 
 523
- 
 
 524 
		// First empty line from "lastFrom"
- 
 
 525 
		int lastTo = lastFrom;
- 
 
 526 
		while(true) {
- 
 
 527 
			if(lastTo == (allLines.size() - 1)) {
- 
 
 528 
				break;
- 
 
 529 
			}
- 
 
 530
- 
 
 531 
			String tLastLine = allLines.get(lastTo + 1);
- 
 
 532 
			Utils.logger.info("tLastLine=" + tLastLine);
- 
 
 533 
			if(tLastLine == null) {
- 
 
 534 
				break;
- 
 
 535 
			}
- 
 
 536
- 
 
 537 
			if(!StringUtils.startsWith(tLastLine, CN.PATTERN_LEVEL_2)) {
- 
 
 538 
				break;
- 
 
 539 
			}
- 
 
 540 
			lastTo++;
- 
 
 541 
			Utils.logger.info("running lastTo=" + lastTo);
- 
 
 542 
		}
- 
 
 543
- 
 
 544 
		Utils.logger.info("lastFrom=" + lastFrom + " lastTo=" + lastTo);
- 
 
 545
- 
 
 546 
		bulletLineNumberRangePerFeature.put(lastFeatureLabel,
- 
 
 547 
				new int[] {lastFrom, lastTo});
- 
 
 548
- 
 
 549 
		Utils.logger.info("featureLineNumberRangePerSlide=" +
- 
 
 550 
				bulletLineNumberRangePerFeature.toString());
- 
 
 551
- 
 
 552 
		return bulletLineNumberRangePerFeature;
- 
 
 553 
	}
169 
 
 554 
 
- 
 
 555
- 
 
 556 
	/**
- 
 
 557 
	 *
- 
 
 558 
	 * @param allLines
- 
 
 559 
	 * @param slideDef
- 
 
 560 
	 * @param lineNumberRange
- 
 
 561 
	 * @throws Exception
- 
 
 562 
	 */
- 
 
 563 
	private Map<Integer, String> processFeature(List<String> allLines,
- 
 
 564 
			SlideDefinition slideDef,
- 
 
 565 
			int[] lineNumberRange) throws Exception {
- 
 
 566
- 
 
 567 
		int from = lineNumberRange[0];
- 
 
 568 
		int to = lineNumberRange[1];
- 
 
 569
- 
 
 570 
		Utils.logger.info("from=" + from + " to=" + to);
- 
 
 571
- 
 
 572 
		int numberOfLines = (to - from);
- 
 
 573 
		Utils.logger.info("numberOfLines=" + numberOfLines);
- 
 
 574 
 
- 
 
 575 
		Map<Integer, String> candidateFeatures = new TreeMap<Integer, String>();
- 
 
 576 
		for(int i=from; i<(to+1); i++) {
- 
 
 577 
			String line = allLines.get(i);
- 
 
 578 
 
- 
 
 579 
			if(StringUtils.startsWith(line, CN.PATTERN_LEVEL_1)) {
- 
 
 580 
				//Utils.logger.info(line);
- 
 
 581 
				//Utils.logger.info("Level 1");
- 
 
 582 
				candidateFeatures.put(new Integer(i),
- 
 
 583 
						StringUtils.strip(StringUtils.strip(line,
- 
 
 584 
								CN.PATTERN_LEVEL_1)));
- 
 
 585 
			}
- 
 
 586 
		}
- 
 
 587
- 
 
 588 
		Utils.logger.info("candidateFeatures=" + candidateFeatures);
- 
 
 589
- 
 
 590 
		// Get all feature definitions for the slide
- 
 
 591 
		DefinitionsContainer defs =
- 
 
 592 
			Catalog.getInstance().getDefinitionsContainer();
- 
 
 593
- 
 
 594 
		List<FeatureDefinition> featureDefs =
- 
 
 595 
			defs.getFeatureDefinitions(slideDef.getID());
- 
 
 596 
		Utils.logger.info("featureDefs=" + featureDefs);
- 
 
 597
- 
 
 598 
		List<String> validFeatureLabels = new ArrayList<String>();
- 
 
 599 
		for(int i=0; i<featureDefs.size(); i++) {
- 
 
 600 
			validFeatureLabels.add(featureDefs.get(i).getLabel());
- 
 
 601 
		}
- 
 
 602 
		Utils.logger.info("validFeatureLabels=" + validFeatureLabels);
- 
 
 603
- 
 
 604 
		// Filter valid features
- 
 
 605 
		Map<Integer, String> featureLabels = new TreeMap<Integer, String>();
- 
 
 606 
 
- 
 
 607 
		// Discard if feature is not one of the valids
- 
 
 608 
		// RE-VISIT
- 
 
 609 
		for(Integer lineNumber : candidateFeatures.keySet()) {
- 
 
 610 
			if(validFeatureLabels.contains(candidateFeatures.get(lineNumber))) {
- 
 
 611 
				featureLabels.put(lineNumber,
- 
 
 612 
						candidateFeatures.get(lineNumber));
- 
 
 613 
			}
- 
 
 614 
		}
- 
 
 615 
		Utils.logger.info("featureLabels=" + featureLabels);
- 
 
 616
- 
 
 617 
		// Fetch all mandatory features
- 
 
 618 
		List<FeatureDefinition> mandatoryFeatureDefs =
- 
 
 619 
			defs.getFeatureDefinitions(slideDef.getID(),
- 
 
 620 
			EditorialImportance.MANDATORY);
- 
 
 621 
 
- 
 
 622 
		Utils.logger.info("mandatoryFeatureDefs=" + mandatoryFeatureDefs);
- 
 
 623
- 
 
 624 
		// Severe error if mandatory features are not included
- 
 
 625 
		for(FeatureDefinition featureDef : mandatoryFeatureDefs) {
- 
 
 626 
			if(!featureLabels.values().contains(featureDef.getLabel())) {
- 
 
 627 
				Utils.logger.severe("Mandatory feature \"" +
- 
 
 628 
						featureDef.getLabel() + "\" is missing");
- 
 
 629 
			}
- 
 
 630 
		}
- 
 
 631
- 
 
 632 
		// Fetch all recommended features
- 
 
 633 
		List<FeatureDefinition> recommendedFeatureDefs =
- 
 
 634 
			defs.getFeatureDefinitions(slideDef.getID(),
- 
 
 635 
			EditorialImportance.RECOMMENDED);
- 
 
 636 
 
- 
 
 637 
		Utils.logger.info("recommendedFeatureDefs=" + recommendedFeatureDefs);
- 
 
 638
- 
 
 639 
		// Warn if recommended features are not included
- 
 
 640 
		for(FeatureDefinition featureDef : recommendedFeatureDefs) {
- 
 
 641 
			if(!featureLabels.values().contains(featureDef.getLabel())) {
- 
 
 642 
				Utils.logger.warning("Recommended feature \"" +
- 
 
 643 
						featureDef.getLabel() + "\" is missing");
- 
 
 644 
			}
- 
 
 645 
		}
- 
 
 646
- 
 
 647 
		return featureLabels;
- 
 
 648 
	}
- 
 
 649
170 
	/**
 650 
	/**
171 
	 * Filter and validate parent slide names
 651 
	 * Filter and validate parent slide names
172 
	 *
652 
	 *
173 
	 * @param candidateSlideNames
 653 
	 * @param candidateSlideNames
174 
	 * @return List<LineInfo>
 654 
	 * @return List<LineInfo>
175 
	 * @throws Exception
655 
	 * @throws Exception
176 
	 */
 656 
	 */
177 
	private Map<Integer, String> processSlides(
 657 
	private Map<Integer, String> processSlides(
178 
			Map<Integer, String> candidateSlideLines) throws Exception {
 658 
			Map<Integer, String> candidateSlideLines) throws Exception {
179
659
- 
 
 660 
		// Order of keys need to be restored
180 
		Map<Integer, String> processedSlideLines =
661 
		Map<Integer, String> processedSlideLines =
181 
			new HashMap<Integer, String>();
 662 
			new TreeMap<Integer, String>();
182
663
183 
		// 1 Retrieve meta-data
 664 
		// 1 Retrieve meta-data
184 
		// 1.1 Retrieve all valid slide names in the content model
 665 
		// 1.1 Retrieve all valid slide names in the content model
185 
		DefinitionsContainer defs =
666 
		DefinitionsContainer defs =
186 
			Catalog.getInstance().getDefinitionsContainer();
 667 
			Catalog.getInstance().getDefinitionsContainer();