Subversion Repositories SmartDukaan

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

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;

import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.Feature;
import in.shop2020.metamodel.core.Slide;
import in.shop2020.metamodel.definitions.Catalog;
import in.shop2020.metamodel.definitions.Category;
import in.shop2020.metamodel.definitions.DefinitionsContainer;
import in.shop2020.metamodel.definitions.EntityContainer;
import in.shop2020.metamodel.definitions.FeatureDefinition;
import in.shop2020.metamodel.definitions.SlideDefinition;
import in.shop2020.metamodel.util.ExpandedCategoryFacetDefinition;
import in.shop2020.metamodel.util.ExpandedEntity;
import in.shop2020.metamodel.util.ExpandedFacetDefinition;
import in.shop2020.metamodel.util.ExpandedFeature;
import in.shop2020.metamodel.util.ExpandedSlide;

/**
 * Command line utility to convert IR Definitions into IR Data and IR Meta-data
 * 
 * @author naveen
 *
 */
public class IR {
        
        /**
         * Jython source path
         */
        public static String JYTHON_SRC_PATH = "src/jython/";
        
        /**
         * IR XML export path
         */
        public static String EXPORT_IR_PATH = 
                "/home/naveen/workspace/eclipse/export/ir/";
        
        /**
         * 
         */
        private long categoryID;
        
        /**
         * Level - 4, 8, 12, 16
         */
        private String[] xmlIndentation = {"", "    ", "        ", "            ", 
                        "                "};
        
        /**
         * @param args
         * @throws Exception 
         */
        public static void main(String[] args) throws Exception {
                String usage = "Usage: IR {Category ID}";
                
                if(args.length > 1) {
                        System.out.println(usage);
                        System.exit(-1);
                }

                long categoryID = 0L;
                if(args.length > 0) {
                        try {
                                categoryID = Long.parseLong(args[0]);
                        }
                        catch (NumberFormatException nfe) {
                                System.out.println(usage);
                                System.exit(-1);
                        }
                }
                
                IR ir = new IR(categoryID);
                ir.exportIRData();
        }
        
        /**
         * 
         * @param categoryID
         */
        public IR(long categoryID) {
                this.categoryID = categoryID;
        }
        
        /**
         * @throws Exception 
         * 
         */
        public void exportIRData() throws Exception {
                DefinitionsContainer defs = 
                        Catalog.getInstance().getDefinitionsContainer();
                
                EntityContainer ents = 
                        Catalog.getInstance().getEntityContainer();
                
                // <IRData>
                List<String> entityXMLSnippets = new ArrayList<String>();
                entityXMLSnippets.add("<IRData>");
                
                List<Category> categories = null;
                if(this.categoryID != 0L) {
                        categories = new ArrayList<Category>();
                        categories.add(defs.getCategory(this.categoryID));
                }
                else {
                        
                        // Get all categories
                        categories = defs.getChildrenCategories(10001);
                }
                
                for(Category cat : categories) {
                        long catID = cat.getID();
                        
                        // Get all facets for the category
                        ExpandedCategoryFacetDefinition expCategoryFacetDef = 
                                defs.getExpandedCategoryFacetDefinition(catID);
                        
                        List<ExpandedFacetDefinition> expFacetDefs = 
                                expCategoryFacetDef.getExpandedFacetDefinitions();
                        
                        // Get all entities for the category
                        List<Entity> entities = ents.getEntities(catID);
                        
                        if(entities == null) {
                                continue;
                        }

                        // For each entity 
                        for(Entity entity : entities) {
                                ExpandedEntity expEntity = 
                                        ents.getExpandedEntity(entity.getID());
                                
                                List<String> facetXMLSnippets = new ArrayList<String>();
                                
                                // For each facet execute Rule
                                for(ExpandedFacetDefinition expFacetDef : expFacetDefs) {
                                        String facetXMLSnip = 
                                                this.processFacet(expEntity, expFacetDef);
                                        
                                        if(!facetXMLSnip.isEmpty()) {
                                                facetXMLSnippets.add(facetXMLSnip);
                                                Utils.info("facetXMLSnip=" + facetXMLSnip);
                                        }
                                }
                                
                                String facetXMLSnippetsStr = 
                                        StringUtils.join(facetXMLSnippets, "\n");
                                        
                                Utils.info("facetXMLSnippets=" + facetXMLSnippetsStr);
                                
                                String entityXMLSnip = 
                                        this.getEntityXMLSnippet(expEntity, facetXMLSnippetsStr, 1);
                                
                                Utils.info(entityXMLSnip);
                                
                                entityXMLSnippets.add(entityXMLSnip);
                        }
                }
                
                // </IRData>
                entityXMLSnippets.add("</IRData>");
                
                String irDataXML = StringUtils.join(entityXMLSnippets, "\n");
                Utils.info(irDataXML);
                
                // Write it to file
                String irDataFilename = IR.EXPORT_IR_PATH + "irdata.xml";
                DBUtils.store(irDataXML, irDataFilename);
        }
        
        /**
         * 
         * @param expEntity
         * @param expFacetDef
         * @return
         * @throws Exception 
         */
        @SuppressWarnings("unchecked")
        private String processFacet(ExpandedEntity expEntity, 
                        ExpandedFacetDefinition expFacetDef) throws Exception {
                
                EntityContainer ents = 
                        Catalog.getInstance().getEntityContainer();
                
                JythonWrapper jw = new JythonWrapper();
                
                jw.setExpandedEntity(expEntity);
                jw.setExpandedFacetDefinition(expFacetDef);
                
                // Set FeatureDefinition
                FeatureDefinition featureDef = 
                        expFacetDef.getFeatureDefinition();
                if(featureDef != null) {
                        jw.setFeatureDefinition(featureDef);
                        
                        // Set Feature
                        Utils.info("featureDef.getID()=" + featureDef.getID());
                        
                        Feature feature = 
                                ents.getFeature(expEntity.getID(), featureDef.getID());
                        
                        ExpandedFeature expFeature = new ExpandedFeature(feature);
                        
                        jw.setExpandedFeature(expFeature);
                }
                
                // Set SlideDefinition
                SlideDefinition slideDef = expFacetDef.getSlideDefinition();
                if(slideDef != null) {
                        jw.setSlideDefinition(slideDef);
                        
                        // Set Slide
                        Utils.info("slideDef.getID()=" + slideDef.getID());
                        
                        Slide slide = ents.getSlide(expEntity.getID(), slideDef.getID());
                        ExpandedSlide expSlide = new ExpandedSlide(slide);
                        
                        jw.setExpandedSlide(expSlide);
                }
                
                jw.execIRDataRule();
                
                List<Object> values = (List<Object>)jw.getValues();
                Utils.info("values=" + values);
                
                String facetXMLSnip = "";
                if(values != null) {
                        
                        // Get IR Data XML snippet for this entity and facet
                        facetXMLSnip = this.getFacetXMLSnippet(expFacetDef, values, 2);
                }
                Utils.info(facetXMLSnip);
                
                return facetXMLSnip;
        }
        
        /**
         * 
         * @param expEntity
         * @param facetXMLSnippets
         * @param indent
         * @return
         */
        private String getEntityXMLSnippet(ExpandedEntity expEntity, 
                        String facetXMLSnippets, int indent) {

                //<Entity ID="40001">
                List<String> xmlSnippet = new ArrayList<String>();
                
                String entityID = new Long(expEntity.getID()).toString();
                xmlSnippet.add(this.xmlIndentation[indent] + "<Entity ID=\""+ entityID + 
                                "\">");

                //<Category>Business Phones</Category>
                String category = expEntity.getCategory().getLabel();
                xmlSnippet.add(this.xmlIndentation[indent + 1] + "<Category>" + 
                                category + "</Category>");

                //<Title>Nokia E71</Title>
                String title = expEntity.getBrand() + " " + expEntity.getModelName() + 
                        ((expEntity.getModelNumber() != null) ? 
                                        (" " + expEntity.getModelNumber())
                                        : "");

                xmlSnippet.add(this.xmlIndentation[indent + 1] + 
                                "<Title>" + title + "</Title>");
                
                xmlSnippet.add(facetXMLSnippets);
                
                //</Entity>
                xmlSnippet.add(this.xmlIndentation[indent] + "</Entity>");
                
                return StringUtils.join(xmlSnippet, "\n");
        }
        
        /**
         * 
         * @param expFacetDef
         * @param values
         * @param indent
         * @return String XML Snippet
         */
        private String getFacetXMLSnippet(ExpandedFacetDefinition expFacetDef, 
                        List<Object> values, int indent) {
                // <Facet Label="Form Factor">
                List<String> xmlSnippet = new ArrayList<String>();
                String target = expFacetDef.getTarget();
                xmlSnippet.add(this.xmlIndentation[indent] + "<Facet Label=\"" + 
                                target + "\">");
                
                //<Value>Candybar</Value>
                for(Object value : values) {
                        xmlSnippet.add(this.xmlIndentation[indent + 1] + "<Value>" + 
                                        value.toString() + "</Value>");
                }
                
                //</Facet>
                xmlSnippet.add(this.xmlIndentation[indent] + "</Facet>");
                
                return StringUtils.join(xmlSnippet, "\n");
        }
}