Subversion Repositories SmartDukaan

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

import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.Feature;
import in.shop2020.metamodel.core.Slide;
import in.shop2020.metamodel.util.CN;
import in.shop2020.metamodel.util.CreationUtils;
import in.shop2020.metamodel.util.ExpandedBullet;
import in.shop2020.metamodel.util.ExpandedEntity;
import in.shop2020.metamodel.util.ExpandedSlide;
import in.shop2020.storage.bdb.StorageManager;
import in.shop2020.util.DBUtils;
import in.shop2020.util.Utils;

import java.io.File;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * Single point access to stored shop2020 core objects
 * 
 * @author naveen
 *
 */
public class EntityContainer implements Serializable {

        /**
         * 
         */
        private static final long serialVersionUID = 1L;
        
        /**
         * Hashtable of Feature Definition ID to list of learned Bullet objects
         */
        private Map<Long, List<ExpandedBullet>> learnedBullets;
        
        /**
         * Hashtable of Facet Definition ID to list of unique facet values found 
         * across entities
         */
        private Map<Long, List<String>> facetDefinitionIDFacetValues;

        /**
         * Hashtable of Entity ID > Map(Slide ID > Score)
         */
        private Map<Long, Map<Long, Integer>> entityIDSlideIDsScore;
        
        /**
         * Hashtable of Entity ID > Final Score
         */
        private Map<Long, Integer> entityIDFinalScore;
        
        /**
         * Database path. Just in case we want to override
         */
        private String dbPath =  Utils.CONTENT_DB_PATH;
        
        /**
         * Instantiates required data structures only when needed
         */
        public EntityContainer() {
                initialize();
        }

        public EntityContainer(String dbPath) {
                this.dbPath = dbPath;
        }
        
        private void initialize(){
        }
        
        
        
        
        
        
                
        
        
        
        /**
         * Returns expand form of entity object. All references are resolved into 
         * corresponding detail object
         * 
         * @param entityID
         * @return ExpandedEntity 
         * @throws Exception 
         */
        public ExpandedEntity getExpandedEntity(long entityID) throws Exception {
                Entity entity = CreationUtils.getEntity(entityID);
                if(entity==null){
                        System.out.println("Entity is null");
                        return null;
                }
                System.out.println( entity.getCategoryID());
                ExpandedEntity expEntity = new ExpandedEntity(entity);
                return expEntity;
        }

        
        
        /**
         * Utility method to find out Feature object in Entity instance
         * 
         * @param entityID
         * @param featureDefinitionID
         * @return Feature
         * @throws Exception 
         */
        public Feature getFeature(long entityID, long featureDefinitionID) 
                throws Exception {
                Entity entity = CreationUtils.getEntity(entityID);
                
                Feature feature = null;
                
                List<Slide> slides = entity.getSlides();
                for(Slide slide : slides) {
                        feature = this.getFeature(slide, featureDefinitionID);
                        
                        // Until all slides are searched
                        if(feature == null) {
                                continue;
                        }
                        else {
                                break;
                        }
                }
                
                return feature;
        }
        
        /**
         * 
         * @param slide
         * @param featureDefinitionID
         * @return Feature
         */
        public Feature getFeature(Slide slide, long featureDefinitionID) {
                List<Feature> features = slide.getFeatures();
                
                if(features != null) {
                        for(Feature feature : features) {
                                if(feature.getFeatureDefinitionID() == featureDefinitionID) {
                                        return feature;
                                }
                        }
                }
                
                Feature feature = null;
                
                List<Slide> childrenSlides = slide.getChildrenSlides();
                if(childrenSlides != null) {
                        for(Slide childSlide : childrenSlides) {
                                
                                feature = this.getFeature(childSlide, featureDefinitionID);
                                if(feature == null) {
                                        continue;
                                }
                                else {
                                        break;
                                }
                        }
                }
                
                return feature;
        }
        
        /**
         * Utility method to find out Slide object in Entity instance
         * 
         * @param entityID
         * @param slideDefinitionID
         * @return
         * @throws Exception 
         */
        public Slide getSlide(long entityID, long slideDefinitionID) 
                throws Exception {
                Entity entity = CreationUtils.getEntity(entityID);
                
                List<Slide> slides = entity.getSlides();
                
                Slide resultSlide = null;
                
                if(slides != null) {
                        for(Slide slide : slides) {

                                if(slide.getSlideDefinitionID() == slideDefinitionID) {
                                        return slide;
                                }
                                
                                resultSlide = this.getSlide(slide, slideDefinitionID);
                                
                                if(resultSlide == null) {
                                        continue;
                                }
                                else {
                                        break;
                                }
                        }
                }
                
                return resultSlide;
        }
        
        /**
         * 
         * @param slide
         * @param slideDefinitionID
         * @return
         */
        public Slide getSlide(Slide slide, long slideDefinitionID) {
                
                List<Slide> childrenSlides = slide.getChildrenSlides();
                
                Slide resultSlide = null;
                
                if(childrenSlides != null) {
                        for(Slide childSlide : childrenSlides) {
                                if(childSlide.getSlideDefinitionID() == slideDefinitionID) {
                                        return childSlide;
                                }
                                
                                resultSlide = this.getSlide(childSlide, slideDefinitionID);
                                if(resultSlide == null) {
                                        continue;
                                }
                                else {
                                        break;
                                }
                        }
                }
                
                return resultSlide;
        }
        
        /**
         * Returns list of borrowed slides
         * 
         * @param entity
         * @return list of borrowed slides
         */
        public List<Slide> getBorrowedSlides(Entity entity) {
                List<Slide> borrowedSlides = new ArrayList<Slide>();
                
                List<Slide> slides = entity.getSlides();
                
                for(Slide slide : slides) {
                        if(slide.isBorrowed()) {
                                borrowedSlides.add(slide);
                        }
                }
                
                return borrowedSlides;
        }
        
        /**
         * Returns first parent slide with matching label
         * 
         * @param expEntity2
         * @param slideLabel
         * @return Null if not found
         */
        public ExpandedSlide getParentExpandedSlide(ExpandedEntity expEntity2,
                        String slideLabel) {
                
                ExpandedSlide matchingSlide = null;
                List<ExpandedSlide> expSlides = expEntity2.getExpandedSlides();
                
                for(ExpandedSlide expSlide : expSlides) {
                        if(expSlide.getSlideDefinition().getLabel().equals(slideLabel)) {
                                matchingSlide = expSlide;
                                break;
                        }
                }
                
                return matchingSlide;
        }

}