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;

/**

 * Single point of access to all definition objects

 * 

 * @author naveen

 *

 */

public class DefinitionsContainer implements Serializable {

	/** 

	 * 

	 */

	private static final long serialVersionUID = 1L;

	/**

	 * Hashtable of Category ID to Category object

	 */

	private Map<Long, Category> categories;

	/**

	 * Hashtable of Slide ID to SlideDefinition object

	 */

	private Map<Long, SlideDefinition> slideDefinitions;

	/**

	 * Hashtable of Feature Definition ID to FeatureDefinition object

	 */

	private Map<Long, FeatureDefinition> featureDefinitions;

	/**

	 * Hashtable of Datatype Definition ID to DatatypeDefinition object

	 */

	private Map<Long, DatatypeDefinition> datatypeDefinitions;

	/**

	 * Hashtable of Enum value ID to EnumValue object

	 */

	private Map<Long, EnumValue> enumValues;

	/**

	 * Hashtable of Unit ID to Unit object

	 */

	private Map<Long, Unit> units;

	/**

	 * Empty constructor. Data structures are initialised as needed

	 */

	public DefinitionsContainer() {

		// Lazy initialization

	}

	/**

	 * Returns all Unit objects in the database

	 * 

	 * @return Map Null if units are not imported into definitions db 

	 * (serialized java objects)

	 * 

	 * @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;

	}

	/**

	 * Resolves Unit ID into Unit object

	 * 

	 * @param unitID Unit ID

	 * @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));

	}

	/**

	 * Returns all DatatypeDefintion object in database

	 * 

	 * @return the datatypeDefinitions List of DatatypeDefinition objects

	 * @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;

	}

	/**

	 * Resolves Datatype Definition ID into DatetypeDefinition object

	 * 

	 * @param unitID Unit ID

	 * @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));

	}

	/**

	 * Returns EnumValue ID for datatype definition ID and enum value string 

	 * to match. Match is case insensitive

	 * 

	 * @param datatypeDefID DatatypeDefinition ID

	 * @param value query enum value string

	 * @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;

	}

	/**

	 * Returns all category objects in the database

	 * 

	 * @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;

	}

	/**

	 * Resolves Category ID into Category object

	 * 

	 * @param categoryID Category ID

	 * @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));

	}

	/**

	 * Returns expanded Category object. All numeric identifiers are resolved 

	 * into detailed objects

	 * 

	 * @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;

	}

	/**

	 * Returns all children categories for a Category ID

	 * 

	 * @param categoryID

	 * @return List<Category> Children Categories

	 * @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();

	}

	/**

	 * Returns all CategorySlideDefinition objects for a Category ID

	 * 

	 * @param categoryID Category ID

	 * @return List<CategorySlideDefinition> 

	 * @throws Exception 

	 */

	public List<CategorySlideDefinition> getCategorySlideDefinitions(

			long categoryID) throws Exception {

		Category category = this.getCategory(categoryID);

		return category.getCategorySlideDefintions();

	}

	/**

	 * Returns All SlideDefinition objects in database

	 * 

	 * @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;

	}

	/**

	 * Resolves SlideDefinition ID into SlideDefinition object

	 * 

	 * @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));

	}

	/**

	 * Returns SlideDefinition objects for a category and matching slide label

	 * 

	 * @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;

	}

	/**

	 * Resolves Category ID into Category object

	 * 

	 * @param categoryID

	 * @return List<SlideDefinition> 

	 * @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;

	}

	/**

	 * Returns list of SlideDefinition objects for a category and editorial 

	 * importance value

	 * 

	 * @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;

	}

	/**

	 * Returns all FeatureDefinition object in database

	 * 

	 * @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;

	}

	/**

	 * Returns all FeatureDefinition objects for a slide

	 * 

	 * @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;

	}

	/**

	 * Returns list of FeatureDefinition objects for a slide given editorial 

	 * importance

	 * 

	 * @param slideID

	 * @param imp Editorial Importance enum object

	 * @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;

	}

	/**

	 * Resolves Feature Definition ID into FeatureDefinition object

	 * 

	 * @param id Feature Definition 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));

	}	

	/**

	 * Returns matching FeatureDefinition object for slide ID and feature label.

	 * Label matching is case insensitive.

	 * 

	 * @param slideID Slide ID

	 * @param featureLabel label to match, case is ignored

	 * @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;

	}

	/**

	 * Returns all EnumValue objects in the database

	 * 

	 * @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;

	}

	/**

	 * Resolves Enum value ID into EnumValue object

	 * 

	 * @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));

	}

}