Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.metamodel.util;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.io.LineNumberReader;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.TreeMap;

import java.util.logging.Level;

import in.shop2020.metamodel.definitions.BulletDefinition;

import in.shop2020.metamodel.definitions.Catalog;

import in.shop2020.metamodel.definitions.Category;

import in.shop2020.metamodel.definitions.CompositeDefinition;

import in.shop2020.metamodel.definitions.DatatypeDefinition;

import in.shop2020.metamodel.definitions.DefinitionsContainer;

import in.shop2020.metamodel.definitions.EditorialImportance;

import in.shop2020.metamodel.definitions.EnumDefinition;

import in.shop2020.metamodel.definitions.FeatureDefinition;

import in.shop2020.metamodel.definitions.SlideDefinition;

import in.shop2020.metamodel.definitions.Unit;

import in.shop2020.util.Utils;

import org.apache.commons.lang.ArrayUtils;

import org.apache.commons.lang.StringUtils;

/**

 * CN - Content Tool

 * Imports and exports content. Validates against content model

 * 

 * @author naveen

 *

 */

public class CN {

	public static final String CONTENT_SRC_TXT_PATH = 

		"/home/naveen/workspace/eclipse/webapp/src/content/txt/";

	public static final String CONTENT_SRC_HTML_PATH = 

		"/home/naveen/workspace/eclipse/webapp/src/content/html/";

	public static final String CONTENT_SRC_XML_PATH = 

		"/home/naveen/workspace/eclipse/webapp/src/content/xml/";

	public static final String CONTENT_DB_PATH =  

		"/home/naveen/workspace/eclipse/webapp/db/entities/";

	// Known patterns

	public static final String PATTERN_LEVEL_1 = "* ";

	public static final String PATTERN_LEVEL_2 = "   * ";

	public static final String PATTERN_LEVEL_3 = "      * ";

	public static final String PATTERN_LEVEL_4 = "         * ";

	private long categoryID;

	private String srcFile;

	private String dbFile;

	private Map<String, Long> slideNameToSlideDefID = 

		new HashMap<String, Long>();

	private Map<String, Long> slideNameFeatureNameToFeatureDefID =

		new HashMap<String, Long>();

	private Map<String, Long> slideNameFeatureNameToEnumValueID =

		new HashMap<String, Long>();

	/**

	 * @param args

	 */

	public static void main(String[] args) throws Exception {

		String[] commands = new String[] {"show", "import"};

		String usage = "Usage: CN ["+ StringUtils.join(commands, "|") +

			"] {Category ID} {Content file name}\n" + 

			"Note:Only text files for now";

		if(args.length < 3) {

			System.out.println(usage);

			System.exit(-1);

		}

		Utils.logger.info("CN "+ args[0] + " " + args[1]+ " " + args[2]);

		String inputCommand = args[0];

		String inputCategoryID = args[1];

		String inputFilename = args[2];

		if(!ArrayUtils.contains(commands, inputCommand)) {

			System.out.println(usage);

			System.exit(-1);

		}

		long categoryID = new Long(inputCategoryID).longValue();

		CN cn = new CN(categoryID, inputFilename);

		if(inputCommand.equals("import")) {

			cn.importEntity();

		}

		else if(inputCommand.equals("show")) {

			cn.showEntity();

		}

	}

	/**

	 * 

	 * @param categoryID

	 * @param fileName

	 */

	public CN(long categoryID, String fileName) {

		this.categoryID = categoryID;

		this.srcFile = CONTENT_SRC_TXT_PATH + fileName + ".txt";

		this.dbFile = CONTENT_DB_PATH + "entities" + ".ser";

	}

	/**

	 * 

	 * @throws Exception

	 */

	public void importEntity() throws Exception {		

		//this.test();

		Utils.logger.info(this.srcFile);

		FileReader fileReader = new FileReader(this.srcFile);

		BufferedReader lineReader = new BufferedReader(fileReader);

		LineNumberReader reader = new LineNumberReader(lineReader);

		List<String> allLines = new ArrayList<String>();

		// 1 Collect all candidate slide names

		// Order of keys need to be restored

		Map<Integer, String> candidateSlideNames = 

			new TreeMap<Integer, String>();

		int lineCount = 0;

		while(true) {

			String line = reader.readLine();			

			if(line == null) {

				break;

			}

			allLines.add(line);

			lineCount++;

			if(line.isEmpty()) {

				continue;

			}

			int lineNumber = reader.getLineNumber();

			//Utils.logger.info(line);

			//Utils.logger.info("lineNumber="+lineNumber);

			// RE-VISIT

			// 1.1 Slide names starting with Alpha

			//Utils.logger.info(line.substring(0, 1));

			if(StringUtils.isAlpha((line.substring(0, 1)))) {

				//Utils.logger.info(line);

				//Utils.logger.info("Level 0");

				candidateSlideNames.put(new Integer(lineNumber), line);

			}

		}

		lineReader.close();

		Utils.logger.info("lineCount=" + lineCount);

		Utils.logger.info(candidateSlideNames.toString());

		// 2 Filter and validate parent slide names

		Map<Integer, String> slideNames = 

			this.processSlides(candidateSlideNames);

		Utils.logger.info(slideNames.toString());

		// 3 Collect all children slides

		// 4 Filter and validate children slide names

		// TODO

		// 5 Collect all Features for a slide

		// 5.1 Find line number range between which content for feature is found

		Map<String, int[]> featureLineNumberRangePerSlide = 

			new HashMap<String, int[]>();

		Utils.logger.info("slideNames.keySet=" + 

				slideNames.keySet().toString());

		Integer[] slideLineNumbers = slideNames.keySet().toArray(

				new Integer[0]);

		for(int i=0; i<slideLineNumbers.length-1; i++) {

			int from = slideLineNumbers[i]+1;

			int to = slideLineNumbers[i+1]-1;

			Utils.logger.info("from=" + from + " to=" + to);

			String tSlideName = slideNames.get(

					new Integer(slideLineNumbers[i]));

			Utils.logger.info("tSlideName=" + tSlideName);

			featureLineNumberRangePerSlide.put(tSlideName, 

					new int[] {from, to});

		}

		// For last slide

		Utils.logger.info("tSlideName=" + 

				slideNames.get(new Integer(

						slideLineNumbers[slideLineNumbers.length-1])));

		Utils.logger.info("lineNumbers[lineNumbers.length-1]=" + 

				slideLineNumbers[slideLineNumbers.length-1]);

		Utils.logger.info(

			"from=" + (slideLineNumbers[slideLineNumbers.length-1]+1) + " to=" +

			(lineCount-1));

		featureLineNumberRangePerSlide.put(

			slideNames.get(

				new Integer(slideLineNumbers[slideLineNumbers.length-1])), 

				new int[] {(slideLineNumbers[slideLineNumbers.length-1] + 1), 

				(lineCount-1)});

		Utils.logger.info("featureLineNumberRangePerSlide=" + 

				featureLineNumberRangePerSlide.toString());

		// 6 Filter and validate features

		DefinitionsContainer defs = 

			Catalog.getInstance().getDefinitionsContainer();

		Map<String, Map> slideFeatureLabels = 

			new HashMap<String, Map>();

		for(String slideName : slideNames.values()) {

			//Utils.logger.info("slideName=" + slideName);

			List<SlideDefinition> slideDefs = 

				defs.getSlideDefinition(slideName);

			if(slideDefs == null) {

				continue;

			}

			if (slideDefs.isEmpty()) {

				continue;

			} 

			// RE-VISIT

			// Pick the first

			Utils.logger.info("slideDef=" + slideDefs.get(0));

			Long slideID = slideDefs.get(0).getID();

			this.slideNameToSlideDefID.put(slideName, slideID);

			Map<Integer, String> featureLabels = 

				this.processFeature(allLines, slideDefs.get(0), 

					featureLineNumberRangePerSlide.get(slideName));

			// Find feature definition IDs

			for(String featureLabel : featureLabels.values()) {

				FeatureDefinition featureDef = defs.getFeatureDefinition(

						slideID.longValue(), featureLabel);

				this.slideNameFeatureNameToFeatureDefID.put(

						(slideName + "_" + featureLabel), 

						new Long(featureDef.getID()));

			}

			slideFeatureLabels.put(slideName, featureLabels);

		}

		Utils.logger.info("slideFeatureLabels=" + slideFeatureLabels);

		Utils.logger.info("slideNameToSlideDefID=" + 

				this.slideNameToSlideDefID);

		Utils.logger.info("slideNameFeatureNameToFeatureDefID=" + 

				this.slideNameFeatureNameToFeatureDefID);

		// 7 Bullets

		// Collect all bullets

		for(String slideName : slideFeatureLabels.keySet()) {

			Map<Integer, String> featureLabels = 

				slideFeatureLabels.get(slideName);

			// 7.1 Find line number range between which content for bullets 

			// is found (per feature on this slide)

			Map<String, int[]> bulletLineNumberRangePerFeature = 

				this.getBulletLineRange(allLines, featureLabels);

			for(String featureLabel : bulletLineNumberRangePerFeature.keySet()){

				String key = slideName + "_" + featureLabel;

				Long featureDefID = 

					this.slideNameFeatureNameToFeatureDefID.get(key);

				FeatureDefinition featureDef = 

					defs.getFeatureDefinition(featureDefID.longValue());

				Long slideDefID = this.slideNameToSlideDefID.get(slideName);

				SlideDefinition slideDef = defs.getSlideDefinition(slideDefID);

				this.processBullets(allLines, 

						bulletLineNumberRangePerFeature.get(featureLabel), 

						featureDef, slideDef);

			}

		}

	}

	/**

	 * 

	 * @throws Exception

	 */

	public void showEntity() throws Exception {

	}

	/**

	 * 

	 * @param allLines

	 * @param bulletLineNumberRange

	 * @param featureDef

	 * @throws Exception 

	 */

	private void processBullets(List<String> allLines, 

			int[] bulletLineNumberRange, FeatureDefinition featureDef, 

			SlideDefinition slideDef) throws Exception {

		int from = bulletLineNumberRange[0];

		int to = bulletLineNumberRange[1];

		BulletDefinition bulletDef = featureDef.getBulletDefinition();

		Utils.logger.info("bulletDefinition=" + bulletDef);

		DefinitionsContainer defs = 

			Catalog.getInstance().getDefinitionsContainer();

		String crumb = "\"" + slideDef.getLabel() + "\" > \"" + 

			featureDef.getLabel() + "\"";

		// Enforce isMultivalue

		if(!bulletDef.isMultivalue() && (from != to)) {

			Utils.logger.severe("Only one bullet is allowed for " + crumb);

			return;

		}

		// If unit is defined

		Unit unitDef =  null;

		if(bulletDef.getUnitID() != 0L) {

			long unitID = bulletDef.getUnitID();

			unitDef = defs.getUnit(unitID);

			Utils.logger.info("unitDef=" + unitDef);

		}

		long datatypeDefID = bulletDef.getDatatypeDefinitionID();

		DatatypeDefinition datatypeDef = 

			defs.getDatatypeDefinition(datatypeDefID);

		Utils.logger.info("datatypeDef=" + datatypeDef);

		// If primitive

		boolean isEnum = false;

		boolean isComposite = false;

		boolean isPrimitive = false;

		if(datatypeDef instanceof EnumDefinition) {

			isEnum = true;

		}

		else if(datatypeDef instanceof CompositeDefinition) {

			isComposite = true;

		}

		else {

			isPrimitive = true;

		}

		Utils.logger.info("isEnum=" + isEnum + " isComposite=" + isComposite +

				" isPrimitive=" + isPrimitive);

		for(int i=from; i<to+1; i++) {

			String line = allLines.get(i);

			if(!StringUtils.startsWith(line, CN.PATTERN_LEVEL_2)) {

				continue;

			}

			String bulletText = StringUtils.strip(StringUtils.stripStart(line, 

					CN.PATTERN_LEVEL_2));

			Utils.logger.info("bulletText=" + bulletText);

			// if no unit is defined for this bullet whole is treated as value

			String bulletValue = bulletText;

			// If unit is defined

			if(bulletDef.getUnitID() != 0L) {

				// Validate unit

				String[] parts = StringUtils.split(bulletText, " ");

				if(parts.length < 2) {

					Utils.logger.severe("Unit is missing, " + crumb + " = " + 

							bulletText);

					continue;

				}

				if(parts.length > 2) {

					Utils.logger.severe("Invalid value, " + crumb + " = " + 

							bulletText);

					continue;

				}

				bulletValue = parts[0];

				String unitValue = parts[1];

				Utils.logger.info("unitValue="+unitValue);

				if(!(unitValue.equalsIgnoreCase(unitDef.getShortForm()) ||

						unitValue.equalsIgnoreCase(unitDef.getFullForm()))) {

					Utils.logger.severe("Invalid unit, " + crumb + " = " + 

							bulletText);

					continue;

				}

			}

			// Validate bullet value

			Utils.logger.info("bulletValue=" + bulletValue);

			if(isPrimitive) {

				String dt = datatypeDef.getName();

				// integer

				if(dt.equals("integer")) {

					try {

						Integer.parseInt(bulletValue);

					}

					catch(NumberFormatException nfe) {

						Utils.logger.severe("Invalide integer value, " + crumb +

								" = " + bulletValue);

					}

				}

				// decimal

				else if(dt.endsWith("decimal")) {

					try {

						Float.parseFloat(bulletValue);

					}

					catch(NumberFormatException nfe) {

						Utils.logger.severe("Invalide decimal value, " + crumb +

								" = " + bulletValue);

					}

				}

				// string

				// any thing goes

			}

			// Enum and fixed

			else if(isEnum && !bulletDef.isLearned()) {

				long enumValueID = defs.getEnumValueID(datatypeDef.getID(), 

						bulletValue);

				if(enumValueID == -1L) {

					Utils.logger.severe("Invalid value, " + crumb + " = " + 

							bulletValue);

					continue;

				}

				String key = slideDef.getLabel() + "_" + featureDef.getLabel() +

					"_" + bulletValue;

				this.slideNameFeatureNameToEnumValueID.put(key, 

						new Long(enumValueID));

			}

			// Composite

			else if(isComposite) {

			}

		}

		Utils.logger.info("slideNameFeatureNameToEnumValueID=" + 

				this.slideNameFeatureNameToEnumValueID);

	}

	/**

	 * 

	 * @param allLines

	 * @param featureLabels

	 * @return

	 */

	private Map<String, int[]> getBulletLineRange(List<String> allLines, 

			Map<Integer, String> featureLabels) {

		Utils.logger.info("allLines=" + allLines);

		Utils.logger.info("featureLabels=" + featureLabels);

		// 5.1 Find line number range between which content for feature is found

		Map<String, int[]> bulletLineNumberRangePerFeature = 

			new HashMap<String, int[]>();

		Utils.logger.info("featureLabels.keySet=" + 

				featureLabels.keySet().toString());

		Integer[] featureLineNumbers = featureLabels.keySet().toArray(

				new Integer[0]);

		for(int i=0; i<featureLineNumbers.length-1; i++) {

			String tFeatureLabel = featureLabels.get(

					new Integer(featureLineNumbers[i]));

			Utils.logger.info("tFeatureLabel=" + tFeatureLabel);

			int from = featureLineNumbers[i]+1;

			int to = featureLineNumbers[i+1]-1;

			Utils.logger.info("from=" + from + " to=" + to);

			bulletLineNumberRangePerFeature.put(tFeatureLabel, 

					new int[] {from, to});

		}

		// For last feature

		String lastFeatureLabel = featureLabels.get(

			new Integer(featureLineNumbers[featureLineNumbers.length-1]));

		Utils.logger.info("lastFeatureLabel=" + lastFeatureLabel);

		int lastFrom = featureLineNumbers[featureLineNumbers.length-1] + 1;

		Utils.logger.info("lastFrom=" + lastFrom);

		// First empty line from "lastFrom"

		int lastTo = lastFrom;

		while(true) {

			if(lastTo == (allLines.size() - 1)) {

				break;

			}

			String tLastLine = allLines.get(lastTo + 1);

			Utils.logger.info("tLastLine=" + tLastLine);

			if(tLastLine == null) {

				break;

			}

			if(!StringUtils.startsWith(tLastLine, CN.PATTERN_LEVEL_2)) {

				break;

			}

			lastTo++;

			Utils.logger.info("running lastTo=" + lastTo);

		}

		Utils.logger.info("lastFrom=" + lastFrom + " lastTo=" + lastTo);

		bulletLineNumberRangePerFeature.put(lastFeatureLabel, 

				new int[] {lastFrom, lastTo});

		Utils.logger.info("featureLineNumberRangePerSlide=" + 

				bulletLineNumberRangePerFeature.toString());		

		return bulletLineNumberRangePerFeature;

	}

	/**

	 * 

	 * @param allLines

	 * @param slideDef

	 * @param lineNumberRange

	 * @throws Exception

	 */

	private Map<Integer, String> processFeature(List<String> allLines, 

			SlideDefinition slideDef, 

			int[] lineNumberRange) throws Exception {

		int from = lineNumberRange[0];

		int to = lineNumberRange[1];

		Utils.logger.info("from=" + from + " to=" + to);

		int numberOfLines = (to - from);

		Utils.logger.info("numberOfLines=" + numberOfLines);

		Map<Integer, String> candidateFeatures = new TreeMap<Integer, String>();

		for(int i=from; i<(to+1); i++) {

			String line = allLines.get(i);

			if(StringUtils.startsWith(line, CN.PATTERN_LEVEL_1)) {

				//Utils.logger.info(line);

				//Utils.logger.info("Level 1");

				candidateFeatures.put(new Integer(i), 

						StringUtils.strip(StringUtils.strip(line, 

								CN.PATTERN_LEVEL_1)));

			}

		}

		Utils.logger.info("candidateFeatures=" + candidateFeatures);

		// Get all feature definitions for the slide

		DefinitionsContainer defs = 

			Catalog.getInstance().getDefinitionsContainer();

		List<FeatureDefinition> featureDefs = 

			defs.getFeatureDefinitions(slideDef.getID());

		Utils.logger.info("featureDefs=" + featureDefs);

		List<String> validFeatureLabels = new ArrayList<String>();

		for(int i=0; i<featureDefs.size(); i++) {

			validFeatureLabels.add(featureDefs.get(i).getLabel());

		}

		Utils.logger.info("validFeatureLabels=" + validFeatureLabels);

		// Filter valid features

		Map<Integer, String> featureLabels = new TreeMap<Integer, String>();

		// Discard if feature is not one of the valids

		// RE-VISIT

		for(Integer lineNumber : candidateFeatures.keySet()) {

			if(validFeatureLabels.contains(candidateFeatures.get(lineNumber))) {

				featureLabels.put(lineNumber, 

						candidateFeatures.get(lineNumber));

			}

		}

		Utils.logger.info("featureLabels=" + featureLabels);

		// Fetch all mandatory features

		List<FeatureDefinition> mandatoryFeatureDefs = 

			defs.getFeatureDefinitions(slideDef.getID(),

			EditorialImportance.MANDATORY);

		Utils.logger.info("mandatoryFeatureDefs=" + mandatoryFeatureDefs);

		// Severe error if mandatory features are not included

		for(FeatureDefinition featureDef : mandatoryFeatureDefs) {

			if(!featureLabels.values().contains(featureDef.getLabel())) {

				Utils.logger.severe("Mandatory feature \"" + 

						featureDef.getLabel() + "\" is missing");

			}

		}

		// Fetch all recommended features

		List<FeatureDefinition> recommendedFeatureDefs = 

			defs.getFeatureDefinitions(slideDef.getID(),

			EditorialImportance.RECOMMENDED);

		Utils.logger.info("recommendedFeatureDefs=" + recommendedFeatureDefs);

		// Warn if recommended features are not included

		for(FeatureDefinition featureDef : recommendedFeatureDefs) {

			if(!featureLabels.values().contains(featureDef.getLabel())) {

				Utils.logger.warning("Recommended feature \"" + 

						featureDef.getLabel() + "\" is missing");

			}

		}

		return featureLabels;

	}

	/**

	 * Filter and validate parent slide names

	 * 

	 * @param candidateSlideNames

	 * @return List<LineInfo>

	 * @throws Exception 

	 */

	private Map<Integer, String> processSlides(

			Map<Integer, String> candidateSlideLines) throws Exception {

		// Order of keys need to be restored

		Map<Integer, String> processedSlideLines = 

			new TreeMap<Integer, String>();

		// 1 Retrieve meta-data

		// 1.1 Retrieve all valid slide names in the content model

		DefinitionsContainer defs = 

			Catalog.getInstance().getDefinitionsContainer();

		Map<Long, SlideDefinition> slideDefs = defs.getSlideDefinitions();

		Iterator<SlideDefinition> itSlideDefs = slideDefs.values().iterator();

		List<String> validSlideNames = new ArrayList<String>();

		while(itSlideDefs.hasNext()) {

			SlideDefinition slideDef = itSlideDefs.next();

			// To avoid Introduction slide

			if(!slideDef.getLabel().isEmpty()) {

				validSlideNames.add(slideDef.getLabel());

			}

		}

		Utils.logger.info("validSlideNames=" + validSlideNames.toString());

		// 2 Rules

		// 2.1 Discard if slide is not one of the valids

		// REVISIT

		for(Integer lineNumber : candidateSlideLines.keySet()) {

			if(validSlideNames.contains(candidateSlideLines.get(lineNumber))) {

				processedSlideLines.put(lineNumber, 

						candidateSlideLines.get(lineNumber));

			}

		}

		Utils.logger.info("processedSlideLines=" + 

				processedSlideLines.toString());

		// 3 Retrieve "Mandatory" slide names for the category

		List<SlideDefinition> mandatorySlideDefs = 

			defs.getSlides(this.categoryID, EditorialImportance.MANDATORY);

		Utils.logger.info("mandatorySlideDefs=" + 

				mandatorySlideDefs.toString());

		// 3.1 All mandatory slides exist - Severe

		for(SlideDefinition mandatorySlideDef : mandatorySlideDefs) {

			// Avoid introduction slide

			if(mandatorySlideDef.getLabel().isEmpty()) {

				continue;

			}

			if(!processedSlideLines.values().contains(

					mandatorySlideDef.getLabel())) {

				Utils.logger.severe("Mandatory slide \"" + 

						mandatorySlideDef.getLabel() + "\" is missing");

			}

		}

		// 4 Retrieve "Recommended" slide names for the category

		List<SlideDefinition> recommendedSlideDefs = 

			defs.getSlides(this.categoryID, EditorialImportance.RECOMMENDED);

		Utils.logger.info("recommendedSlideDefs=" + 

				recommendedSlideDefs.toString());

		// 4.1 All recommended slides exist - Warn	

		for(SlideDefinition recommendedSlideDef : recommendedSlideDefs) {

			if(!processedSlideLines.values().contains(

					recommendedSlideDef.getLabel())) {

				Utils.logger.warning("Recommended slide \"" + 

						recommendedSlideDef.getLabel() + "\" is missing");

			}

		}

		return processedSlideLines;

	}

	/**

	 * @throws Exception 

	 * 

	 */

	@SuppressWarnings("unused")

	private void test() throws Exception {

		// test category

		DefinitionsContainer allDefs = 

			Catalog.getInstance().getDefinitionsContainer();

		Category category = allDefs.getCategory(this.categoryID);

		Utils.logger.info(category.toString());

		// test data type defs

		DatatypeDefinition datatypeDef = allDefs.getDatatypeDefinition(70004L);

		Utils.logger.info(datatypeDef.toString());

		// test units

		Unit unit = allDefs.getUnit(50004L);

		Utils.logger.info(unit.toString());

		// test slide defs

		SlideDefinition slideDef = allDefs.getSlideDefinition(130002L);

		Utils.logger.info(slideDef.toString());

		// test feature defs

		FeatureDefinition featureDef = allDefs.getFeatureDefinition(120002L);

		Utils.logger.info(featureDef.toString());

	}

}