Subversion Repositories SmartDukaan

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

import in.shop2020.metamodel.util.DBUtils;
import in.shop2020.metamodel.util.ExpandedCategory;
import in.shop2020.metamodel.util.MM;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @author naveen
 *
 */
public class DefinitionsContainer implements Serializable {

        /** 
         * 
         */
        private static final long serialVersionUID = 1L;
        private Map<Long, Category> categories;
        private Map<Long, SlideDefinition> slideDefinitions;
        private Map<Long, FeatureDefinition> featureDefinitions;
        private Map<Long, DatatypeDefinition> datatypeDefinitions;
        private Map<Long, EnumValue> enumValues;
        private Map<Long, Unit> units;
        
        /**
         * 
         */
        public DefinitionsContainer() {
                // Lazy initialization
        }
        
        /**
         * 
         * @return Map
         * @throws Exception 
         */
        @SuppressWarnings("unchecked")
        public Map<Long, Unit> getUnits() throws Exception {            
                // De-serialize
                if(this.units == null) {
                        String dbFile = MM.DEFINITIONS_DB_PATH + "units" + ".ser";
                        
                        this.units = (Map<Long, Unit>) DBUtils.read(dbFile);
                }
                
                return this.units;
        }

        /**
         * 
         * @param unitID
         * @return Unit
         * @throws Exception 
         */
        public Unit getUnit(long unitID) throws Exception {             
                // Initialize 
                if(this.units == null) {
                        this.getUnits();
                }
                
                return this.units.get(new Long(unitID));
        }

        /**
         * @return the datatypeDefinitions
         * @throws Exception 
         */
        @SuppressWarnings("unchecked")
        public Map<Long, DatatypeDefinition> getDatatypeDefinitions() 
                throws Exception {
                
                // De-serialize
                if(this.datatypeDefinitions == null) {
                        String dbFile = MM.DEFINITIONS_DB_PATH + "datatypedefinitions" + 
                                ".ser";
                        
                        this.datatypeDefinitions = 
                                (Map<Long, DatatypeDefinition>) DBUtils.read(dbFile);
                }
                return this.datatypeDefinitions;
        }

        /**
         * 
         * @param unitID
         * @return Unit
         * @throws Exception 
         */
        public DatatypeDefinition getDatatypeDefinition(long id) throws Exception {
                
                // Initialize 
                if(this.datatypeDefinitions == null) {
                        this.getDatatypeDefinitions();
                }
                
                return this.datatypeDefinitions.get(new Long(id));
        }

        /**
         * 
         * @param datatypeDefID
         * @param value
         * @return long enumValueID - "-1" if not found
         * @throws Exception 
         */
        public long getEnumValueID(long datatypeDefID, String value) 
                throws Exception {
                long enumValueID = -1L;
                
                // Let the callers catch ClassCastException
                EnumDefinition enumDef = 
                        (EnumDefinition)this.getDatatypeDefinition(datatypeDefID);
                
                List<EnumValue> enumValues = enumDef.getEnumValues();
                for(EnumValue enumValue : enumValues) {
                        if(value.equalsIgnoreCase(enumValue.getValue())) {
                                enumValueID = enumValue.getID();
                                break;
                        }
                }
                
                return enumValueID;
        }
        
        /**
         * @return the categories
         * @throws Exception 
         */
        @SuppressWarnings("unchecked")
        public Map<Long, Category> getCategories() throws Exception {
                
                // De-serialize
                if(this.categories == null) {
                        String dbFile = MM.DEFINITIONS_DB_PATH + "categories" + ".ser";
                        
                        this.categories = (Map<Long, Category>) DBUtils.read(dbFile);
                }
                return this.categories;
        }
        
        /**
         * 
         * @param categoryID
         * @return Category
         * @throws Exception 
         */
        public Category getCategory(long categoryID) throws Exception {
                
                // Initialize 
                if(this.categories == null) {
                        this.getCategories();
                }
                
                return this.categories.get(new Long(categoryID));
        }
        
        /**
         * 
         * @param categoryID
         * @return ExpandedCategory
         * @throws Exception
         */
        public ExpandedCategory getExpandedCategory(long categoryID) 
                throws Exception {
                Category category = this.getCategory(categoryID);
                
                ExpandedCategory expCategory = new ExpandedCategory(category);
                
                return expCategory;
        }
        
        /**
         * 
         * @param categoryID
         * @return List<Category> 
         * @throws Exception
         */
        public List<Category> getChildrenCategories(long categoryID) 
                throws Exception {
                
                // Initialize 
                if(this.categories == null) {
                        this.getCategories();
                }
                
                return this.categories.get(new Long(categoryID)).getChildrenCategory();
        }
        /**
         * 
         * @param categoryID
         * @return List<CategorySlideDefinition> 
         * @throws Exception 
         */
        public List<CategorySlideDefinition> getCategorySlideDefinitions(
                        long categoryID) throws Exception {
                Category category = this.getCategory(categoryID);
                
                return category.getCategorySlideDefintions();
        }
        
        /**
         * @return the slideDefinitions
         * @throws Exception 
         */
        @SuppressWarnings("unchecked")
        public Map<Long, SlideDefinition> getSlideDefinitions() throws Exception {
                
                // De-serialize
                if(this.slideDefinitions == null) {
                        String dbFile = MM.DEFINITIONS_DB_PATH + "slidedefinitions" + 
                                ".ser";
                        
                        this.slideDefinitions = 
                                (Map<Long, SlideDefinition>) DBUtils.read(dbFile);
                }
                return this.slideDefinitions;
        }
        
        /**
         * 
         * @param id
         * @return SlideDefinition
         * @throws Exception
         */
        public SlideDefinition getSlideDefinition(long id) throws Exception {
                
                // Initialize 
                if(this.slideDefinitions == null) {
                        this.getSlideDefinitions();
                }
                
                return this.slideDefinitions.get(new Long(id));
        }
        
        /**
         * 
         * @param label
         * @return List<SlideDefinition>
         * @throws Exception
         */
        public List<SlideDefinition> getSlideDefinitions(long categoryID, 
                        String label) throws Exception {

                // RE-VISIT
                // May be we need a new data structure, category id to slide definitions
                // for now
                List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
                
                List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(
                                categoryID);
                
                for(CategorySlideDefinition csDef : csDefs) {
                        SlideDefinition sDef = this.getSlideDefinition(
                                        csDef.getSlideDefintionID());
                        
                        if(sDef.getLabel().equalsIgnoreCase(label)) {
                                matchingSlides.add(sDef);
                        }
                }
                
                return matchingSlides;
        }
        
        /**
         * 
         * @param categoryID
         * @return
         * @throws Exception
         */
        public List<SlideDefinition> getSlideDefinitions(long categoryID) 
                throws Exception {

                // RE-VISIT
                // May be we need a new data structure, category id to slide definitions
                // for now
                List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();
                
                List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(
                                categoryID);
                
                for(CategorySlideDefinition csDef : csDefs) {
                        SlideDefinition sDef = this.getSlideDefinition(
                                        csDef.getSlideDefintionID());
                        
                        matchingSlides.add(sDef);
                }
                
                return matchingSlides;
        }
        /**
         * 
         * @param categoryID
         * @param EditorialImportance imp
         * @return List<SlideDefinition>
         * @throws Exception 
         */
        public List<SlideDefinition> getSlides(long categoryID, 
                        EditorialImportance imp) 
                throws Exception {
                
                List<CategorySlideDefinition> catSlideDefs = 
                        this.getCategorySlideDefinitions(categoryID);
                
                Iterator<CategorySlideDefinition> itCatSlideDefs = 
                        catSlideDefs.iterator();
                
                List<SlideDefinition> slideDefs = new ArrayList<SlideDefinition>();
                while(itCatSlideDefs.hasNext()) {
                        CategorySlideDefinition catSlideDef = itCatSlideDefs.next();
                        if(catSlideDef.getEditorialImportance() == imp) {
                                long slideDefID = catSlideDef.getSlideDefintionID();
                                slideDefs.add(this.getSlideDefinition(slideDefID));
                        }
                }
                return slideDefs;
        }
        
        /**
         * 
         * @return Map<Long, FeatureDefinition>
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public Map<Long, FeatureDefinition> getFeatureDefinitions() 
                throws Exception {
                
                // De-serialize
                if(this.featureDefinitions == null) {
                        String dbFile = MM.DEFINITIONS_DB_PATH + "featuredefinitions" + 
                                ".ser";
                        
                        this.featureDefinitions = 
                                (Map<Long, FeatureDefinition>) DBUtils.read(dbFile);
                }
                return this.featureDefinitions;
        }
        
        /**
         * 
         * @param slideID
         * @return List<FeatureDefinition> 
         * @throws Exception
         */
        public List<FeatureDefinition> getFeatureDefinitions(long slideID) 
                throws Exception {
                List<FeatureDefinition> featureDefs = 
                        new ArrayList<FeatureDefinition>();
                
                SlideDefinition slideDef = this.getSlideDefinition(slideID);
                List<SlideFeatureDefinition> slideFeatureDefs = 
                        slideDef.getSlideFeatureDefinitions();
                
                for(int i=0; i<slideFeatureDefs.size(); i++) {
                        featureDefs.add(this.getFeatureDefinition(
                                        slideFeatureDefs.get(i).getFeatureDefintionID()));
                }
                
                return featureDefs;
        }
        
        /**
         * 
         * @param slideID
         * @param imp
         * @return List<FeatureDefinition>
         * @throws Exception
         */
        public List<FeatureDefinition> getFeatureDefinitions(long slideID, 
                        EditorialImportance imp)  throws Exception {
                List<FeatureDefinition> featureDefs = 
                        new ArrayList<FeatureDefinition>();
                
                SlideDefinition slideDef = this.getSlideDefinition(slideID);
                List<SlideFeatureDefinition> slideFeatureDefs = 
                        slideDef.getSlideFeatureDefinitions();
                
                for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {
                        if(slideFeatureDef.getEditorialImportance() == imp) {
                                featureDefs.add(this.getFeatureDefinition(
                                                slideFeatureDef.getFeatureDefintionID()));
                        }
                }
                
                return featureDefs;
        }
        
        /**
         * 
         * @param id
         * @return FeatureDefinition
         * @throws Exception
         */
        public FeatureDefinition getFeatureDefinition(long id) throws Exception {
                
                // Initialize 
                if(this.featureDefinitions == null) {
                        this.getFeatureDefinitions();
                }
                
                return this.featureDefinitions.get(new Long(id));
        }       

        /**
         * 
         * @param slideID
         * @param featureLabel
         * @return FeatureDefinition 
         * @throws Exception
         */
        public FeatureDefinition getFeatureDefinition(long slideID, 
                        String featureLabel) throws Exception {
                FeatureDefinition featureDef = null;
                
                SlideDefinition slideDef = this.getSlideDefinition(slideID);
                for(SlideFeatureDefinition slideFeatureDef : 
                        slideDef.getSlideFeatureDefinitions()) {
                        
                        long featureDefID = slideFeatureDef.getFeatureDefintionID();
                        
                        FeatureDefinition thisFeatureDef = this.getFeatureDefinition(
                                        featureDefID);
                        
                        if(featureLabel.equalsIgnoreCase(thisFeatureDef.getLabel())) {
                                featureDef = thisFeatureDef;
                        }
                }
                
                return featureDef;
        }

        /**
         * @return the enumValues
         * @throws Exception 
         */
        @SuppressWarnings("unchecked")
        public Map<Long, EnumValue> getEnumValues() throws Exception {
                // De-serialise
                if(this.enumValues == null) {
                        String dbFile = MM.DEFINITIONS_DB_PATH + "enumvalues" + 
                                ".ser";
                        
                        this.enumValues = 
                                (Map<Long, EnumValue>) DBUtils.read(dbFile);
                }
                
                return this.enumValues;
        }
        
        /**
         * 
         * @param enumValueID
         * @return EnumValue
         * @throws Exception
         */
        public EnumValue getEnumValue(long enumValueID) throws Exception {
                // Initialise
                if(this.enumValues == null) {
                        this.getEnumValues();
                }
                
                return this.enumValues.get(new Long(enumValueID));
        }
}