Subversion Repositories SmartDukaan

package in.shop2020.metamodel.util;

import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.EntityState;
import in.shop2020.metamodel.core.Feature;
import in.shop2020.metamodel.core.Slide;
import in.shop2020.metamodel.util.CN;
import in.shop2020.storage.bdb.StorageManager;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;


/**
 * @author rajveer
 * @description 
 *
 */
public class CreationUtils {
        
        private static final String LEARNED_BULLETS = "LEARNED_BULLETS";
        private static final String DEFAULT_ENTITY_SCORES = "DEFAULT_ENTITY_SCORES";
        private static final String FACET_VALUES = "FACET_VALUES";
        private static final String SLIDE_SCORES = "SLIDE_SCORES";
        

        /**
         * 
         * @param aThrowable
         * @return
         */
        public static String getStackTrace(Throwable aThrowable) {
            final Writer result = new StringWriter();
            final PrintWriter printWriter = new PrintWriter(result);
            aThrowable.printStackTrace(printWriter);
            return result.toString();
        }
        
        /**
         * 
         * @param entity
         * @throws Exception
         */
        public static void storeLearnedBullets(Map<Long, List<ExpandedBullet>> learnedBullets) throws Exception {
                StorageManager.getStorageManager().storeDataObject(CreationUtils.LEARNED_BULLETS, learnedBullets);              
        }
        
        @SuppressWarnings("unchecked")
        public static Map<Long, List<ExpandedBullet>> getLearnedBullets() throws Exception {
                return (Map<Long, List<ExpandedBullet>>) StorageManager.getStorageManager().getDataObject(CreationUtils.LEARNED_BULLETS);               
        }
        
        @SuppressWarnings("unchecked")
        public static List<ExpandedBullet> getLearnedBullets(long featureDefinitionID) throws Exception {
                Map<Long, List<ExpandedBullet>> learnedBullets = (Map<Long, List<ExpandedBullet>>) StorageManager.getStorageManager().getDataObject(CreationUtils.LEARNED_BULLETS);
                if(learnedBullets==null){
                        return null;
                }
                return learnedBullets.get(featureDefinitionID);
        }

        public static void storeFacetValues(Map<Long, List<String>> facetIDFacetValues) throws Exception {
                StorageManager.getStorageManager().storeDataObject(CreationUtils.FACET_VALUES, facetIDFacetValues);
        }

        @SuppressWarnings("unchecked")
        public static Map<Long, List<String>>  getFacetValues() throws Exception {
                return (Map<Long, List<String>>) StorageManager.getStorageManager().getDataObject(CreationUtils.FACET_VALUES);
        }

        @SuppressWarnings("unchecked")
        public static List<String>  getFacetValues(long facetDefinitionID) throws Exception {
                Map<Long, List<String>> facetValues = (Map<Long, List<String>>) StorageManager.getStorageManager().getDataObject(CreationUtils.FACET_VALUES);
                return facetValues.get(facetDefinitionID);
        }

        
        public static void storeSlideScores( Map<Long, Map<Long, Integer>> slideScoresByEntity) throws Exception {
                StorageManager.getStorageManager().storeDataObject(CreationUtils.SLIDE_SCORES, slideScoresByEntity);
        }

        @SuppressWarnings("unchecked")
        public static Map<Long, Map<Long, Integer>> getSlideScores() throws Exception {
                return (Map<Long, Map<Long, Integer>>) StorageManager.getStorageManager().getDataObject(CreationUtils.SLIDE_SCORES);
        }

        @SuppressWarnings("unchecked")
        public static Map<Long, Integer> getSlideComparisonScores(long entityID) throws Exception{
                Map<Long, Map<Long, Integer>> slideScores = (Map<Long, Map<Long, Integer>>) StorageManager.getStorageManager().getDataObject(CreationUtils.SLIDE_SCORES);
                return slideScores.get(entityID);
        }
        
        
        public static void storeDefaultEntityScores(Map<Long, Integer> finalScoreByEntityID) throws Exception {
                StorageManager.getStorageManager().storeDataObject(CreationUtils.DEFAULT_ENTITY_SCORES, finalScoreByEntityID);
        }
        
        @SuppressWarnings("unchecked")
        public static Map<Long, Integer> getDefaultEntityScores() throws Exception {
                return (Map<Long, Integer>) StorageManager.getStorageManager().getDataObject(CreationUtils.DEFAULT_ENTITY_SCORES);
        }
        
        @SuppressWarnings("unchecked")
        public static Integer getEntityComparisonScores(long entityID) throws Exception {
                Map<Long, Integer> scoresMap =  (Map<Long, Integer>) StorageManager.getStorageManager().getDataObject(CreationUtils.DEFAULT_ENTITY_SCORES);
                Integer objScore = scoresMap.get(entityID);
                if(objScore==null){
                        return -1;
                }
                return objScore;
        }
        
        
        
        /**
         * Resolves Entity ID into Entity object
         * 
         * @param entityID
         * @return Entity
         * @throws Exception 
         */
        public static Entity getEntity(long entityID) throws Exception{
                return StorageManager.getStorageManager().getEntity(entityID);
        }
        
        public static void updateEntity(Entity entity) throws Exception {
                entity.reorderSlides(entity.getSlideSequence());
                StorageManager.getStorageManager().updateEntity(entity);
                CreationUtils.learn(entity);
        }

        public static void createEntity(Entity entity, EntityState entityMetadata) throws Exception {
                StorageManager.getStorageManager().createEntity(entity, entityMetadata);
        }

        public static void deleteEntity(long entityId) throws Exception  {
                StorageManager.getStorageManager().deleteEntity(entityId);
        }


        public static Map<Long, EntityState> getEntitiesState() throws Exception {
                return StorageManager.getStorageManager().getEntitiesMetadata();
        }
        
        public static EntityState getEntityState(long entityId) throws Exception {
                return StorageManager.getStorageManager().getEntityMetadata(entityId);
        }

        public static void updateEntityState(EntityState entityMetadata) throws Exception {
                StorageManager.getStorageManager().updateEntityMetadata(entityMetadata);
        }

        private static void learn(Entity entity) throws Exception{
                CN cn = new CN();
                cn.learn(entity);       
        }

        public static Map<Long, Entity> getEntities() throws Exception {
                return StorageManager.getStorageManager().getEntities();
        }

        public static Collection<Entity> getEntities(long categoryId) throws Exception {
                return StorageManager.getStorageManager().getEntitisByCategory(categoryId);
        }

        /**
         * 
         * @param slide
         * @param featureDefinitionID
         * @return Feature
         */
        public static 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 = CreationUtils.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 static 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 = CreationUtils.getSlide(slide, slideDefinitionID);
                                
                                if(resultSlide == null) {
                                        continue;
                                }
                                else {
                                        break;
                                }
                        }
                }
                
                return resultSlide;
        }

        
        /**
         * 
         * @param slide
         * @param slideDefinitionID
         * @return
         */
        public static 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 = CreationUtils.getSlide(childSlide, slideDefinitionID);
                                if(resultSlide == null) {
                                        continue;
                                }
                                else {
                                        break;
                                }
                        }
                }
                
                return resultSlide;
        }

        /**
         * Utility method to find out Feature object in Entity instance
         * 
         * @param entityID
         * @param featureDefinitionID
         * @return Feature
         * @throws Exception 
         */
        public static 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 = CreationUtils.getFeature(slide, featureDefinitionID);
                        
                        // Until all slides are searched
                        if(feature == null) {
                                continue;
                        }
                        else {
                                break;
                        }
                }
                
                return feature;
        }
        

        /**
         * Returns expand form of entity object. All references are resolved into 
         * corresponding detail object
         * 
         * @param entityID
         * @return ExpandedEntity 
         * @throws Exception 
         */
        public static 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;
        }
        
        
        /**
         * Returns list of borrowed slides
         * 
         * @param entity
         * @return list of borrowed slides
         */
        public static 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 static 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;
        }

}