Subversion Repositories SmartDukaan

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

import in.shop2020.metamodel.definitions.Catalog;
import in.shop2020.metamodel.definitions.EntityContainer;
import in.shop2020.metamodel.definitions.EnumDefinition;
import in.shop2020.metamodel.definitions.EnumValue;
import in.shop2020.metamodel.definitions.FeatureDefinition;
import in.shop2020.metamodel.definitions.OldEntityContainer;
import in.shop2020.metamodel.definitions.RuleDefinition;
import in.shop2020.metamodel.definitions.SlideDefinition;
import in.shop2020.metamodel.util.CreationUtils;
import in.shop2020.metamodel.util.ExpandedBulletDefinition;
import in.shop2020.metamodel.util.ExpandedFacetDefinition;
import in.shop2020.metamodel.util.ExpandedFeatureDefinition;
import in.shop2020.metamodel.util.ExpandedSlideDefinition;
import in.shop2020.metamodel.util.ExpandedSlideFeatureDefinition;

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

import org.python.core.PyObject;
import org.python.core.PyString;

/**
 * Wrapper around Jython for Meta-data related to Information Retrieval data
 * 
 * @author naveen
 *
 */
public class IRMetaDataJythonWrapper extends JythonWrapper {
        
        /**
         * Local instance of Facet Definition - Used to pick script to execute
         */
        private ExpandedFacetDefinition expandedFacetDefinition = null;
        
        /**
         * Resets current PythonInterpreter instance
         */
        public void reset() {
                super.reset();
                this.expandedFacetDefinition = null;
        }
        
        /**
         * 
         * @param expandedFacetDefinition
         */
        public void setExpandedFacetDefinition(
                        ExpandedFacetDefinition expandedFacetDefinition) {
                this.initialize();
                
                this.expandedFacetDefinition = expandedFacetDefinition;
                this.py.set("expFacetDef", expandedFacetDefinition);
        }
        
        /**
         * Executes IR Data rule from ExpandedFacetDefinition instance
         * @throws Exception 
         */
        public void executeRule() throws Exception {
                if(this.py == null || this.expandedFacetDefinition == null) {
                        throw new IllegalStateException(
                                        "Not initialized properly");
                }
                
                FeatureDefinition featureDef = 
                        this.expandedFacetDefinition.getFeatureDefinition();
                
                SlideDefinition slideDef = 
                        this.expandedFacetDefinition.getSlideDefinition();
                
                List<String> possibleValues = new ArrayList<String>();

                // expFeatureDef
                if(featureDef != null) {
                        ExpandedFeatureDefinition expFeatureDef = 
                                new ExpandedFeatureDefinition(featureDef);
                        
                        this.py.set("expFeatureDef", expFeatureDef);
                        
                        ExpandedBulletDefinition expBulletDef = 
                                expFeatureDef.getExpandedBulletDefinition();
                        
                        // Fixed
                        if (expBulletDef.isEnumerated()) {
                                EnumDefinition enumDef = 
                                        (EnumDefinition) expBulletDef.getDatatypeDefinition();
                                
                                List<EnumValue> enumValues = enumDef.getEnumValues();
                                
                                for(EnumValue enumValue : enumValues) {
                                        possibleValues.add(enumValue.getValue());
                                }

                                Utils.info("possibleValues=" + possibleValues);
                                this.py.set("possibleValues", possibleValues);
                        } 
                        
                        // Get values collected across entities
                        else {
                                EntityContainer ents = 
                                        Catalog.getInstance().getEntityContainer();
                                
                                long facetDefinitionID = this.expandedFacetDefinition.getID();
                                
                                //FIXME need to fix it according to new infra
                                //possibleValues = CreationUtils.getFacetValues(facetDefinitionID);
                                
                                OldEntityContainer oldEnts = new OldEntityContainer();
                                possibleValues = oldEnts.getFacetValues(facetDefinitionID);
                                
                                Utils.info("possibleValues=" + possibleValues);
                                this.py.set("possibleValues", possibleValues);
                        }
                }

                // expSlideDef
                else if(slideDef != null) {
                        ExpandedSlideDefinition expSlideDef = 
                                new ExpandedSlideDefinition(slideDef);
                        
                        this.py.set("expSlideDef", expSlideDef);
                        
                        List<ExpandedSlideFeatureDefinition> expSlideFeatureDefs = 
                                expSlideDef.getExpandedSlideFeatureDefinitions();
                        
                        for(ExpandedSlideFeatureDefinition expSlideFeatureDef : 
                                        expSlideFeatureDefs) {
                                
                                ExpandedFeatureDefinition expFeatureDef = 
                                        expSlideFeatureDef.getExpandedFeatureDefinition();
                                
                                possibleValues.add(expFeatureDef.getLabel());
                        }
                        
                        // Feature Labels
                        Utils.info("possibleValues=" + possibleValues);
                        this.py.set("possibleValues", possibleValues);
                }
                
                RuleDefinition ruleDef = 
                        this.expandedFacetDefinition.getIrMetadataRuleDefinition();
                
                String pyScript = ruleDef.getScript();
                String scriptFullPath = Utils.JYTHON_SRC_PATH + "irmetadatarules/" + 
                        pyScript;
                
                Utils.info("ruleDef.getID()=" + ruleDef.getID());
                Utils.info("scriptFullPath=" + scriptFullPath);
                
                this.exec(scriptFullPath);
        }
        
        /**
         * 
         * @return
         */
        public String getXMLSnippet() {
                if(this.py == null) {
                        throw new IllegalStateException("Exec is not called yet");
                }
                
                PyObject xmlsnippet = this.py.get("xmlsnippet");
                
                return ((PyString)xmlsnippet).toString();
        }
}