Subversion Repositories SmartDukaan

/**
 * 
 */
package in.shop2020.metamodel.util;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.LineNumberReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;

import in.shop2020.metamodel.definitions.Catalog;
import in.shop2020.metamodel.definitions.Category;
import in.shop2020.metamodel.definitions.DatatypeDefinition;
import in.shop2020.metamodel.definitions.DefinitionsContainer;
import in.shop2020.metamodel.definitions.EditorialImportance;
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;
        
        /**
         * @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);
                
                // 1 Collect all candidate slide names
                Map<Integer, String> candidateSlideNames = new HashMap<Integer, String>();
                while(true) {
                        String line = reader.readLine();
                        
                        if(line == null) {
                                break;
                        }
                        
                        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);
                        }
                }
                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 Children slides
                // TODO
                
                // 4 Features
                // TODO
                
                // 5 Bullets
                // TODO
                
                lineReader.close();
        }
        
        /**
         * 
         * @throws Exception
         */
        public void showEntity() throws Exception {
        }

        /**
         * Filter and validate parent slide names
         * 
         * @param candidateSlideNames
         * @return List<LineInfo>
         * @throws Exception 
         */
        private Map<Integer, String> processSlides(
                        Map<Integer, String> candidateSlideLines) throws Exception {
                
                Map<Integer, String> processedSlideLines = 
                        new HashMap<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());
        }
}