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.ExpandedBullet;

import in.shop2020.metamodel.util.ExpandedEntity;

import in.shop2020.metamodel.util.ExpandedSlide;

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 OldEntityContainer implements Serializable {

	/**

	 * 

	 */

	private static final long serialVersionUID = 1L;

	/**

	 * Hashtable of Entity ID to Entity object

	 */

	private Map<Long, Entity> entities;

	/**

	 * Hashtable of Category ID to list of Entity objects

	 */

	private Map<Long, List<Entity>> entitiesbycategory;

	/**

	 * 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 OldEntityContainer() {

		// Lazy initialization

	}

	public OldEntityContainer(String dbPath) {

		this.dbPath = dbPath;

		// Lazy initialization

	}

	/**

	 * Returns all stored Entity objects 

	 * 

	 * @return Map

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, Entity> getEntities() throws Exception {

		// De-serialize

		if(this.entities == null) {

			String entitiesDBFile = this.dbPath + "entities" + File.separator + "entities.ser";

			String entitiesbycategoryDBFile = this.dbPath + "entities" + File.separator + 

				"entitiesbycategory.ser";

			this.entities = (Map<Long, Entity>) DBUtils.read(entitiesDBFile);

			this.entitiesbycategory = (Map<Long, List<Entity>>) 

				DBUtils.read(entitiesbycategoryDBFile);

		}

		if(this.entities == null) {

			// A sorted map to ensure sequence

			this.entities = new TreeMap<Long, Entity>();

			this.entitiesbycategory = new TreeMap<Long, List<Entity>>();

		}

		return this.entities;

	}

	/**

	 * Returns hashtable of list bullet objects to feature definition ID

	 * 

	 * @return Map<Long, List<ExpandedBullet>> 

	 * @throws Exception

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, List<ExpandedBullet>> getLearnedBullets() throws Exception{

		// De-serialize

		if(this.learnedBullets == null) {

			String dbFile = this.dbPath + "entities" + File.separator + "learnedbullets.ser";

			this.learnedBullets = 

				(Map<Long, List<ExpandedBullet>>) DBUtils.read(dbFile);

		}

		if(this.learnedBullets == null) {

			this.learnedBullets = new HashMap<Long, List<ExpandedBullet>>();

		}

		return this.learnedBullets;

	}

	/**

	 * Resolves Feature Definition ID into list of learned Bullet objects

	 * 

	 * @param featureDefinitionID

	 * @return list of ExpandedBullets

	 * @throws Exception

	 */

	public List<ExpandedBullet> getLearnedBullets(long featureDefinitionID) 

		throws Exception {

		if(this.learnedBullets == null) {

			this.getLearnedBullets();

		}

		return this.learnedBullets.get(new Long(featureDefinitionID));

	}

	/** 

	 * Returns hashtable of list entities to category ID

	 * 

	 * @return the entitiesbycategory Entities by category

	 * @throws Exception 

	 */

	public Map<Long, List<Entity>> getEntitiesbyCategory() throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		String entitiesbycategoryDBFile = this.dbPath + "entities" + File.separator + 

		"entitiesbycategory.ser";

		this.entitiesbycategory = (Map<Long, List<Entity>>)DBUtils.read(entitiesbycategoryDBFile);

		return this.entitiesbycategory;

	}

	/**

	 * Resolves Entity ID into Entity object

	 * 

	 * @param entityID

	 * @return Entity

	 * @throws Exception 

	 */

	public Entity getEntity(long entityID) throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		return this.entities.get(new Long(entityID));

	}

	/**

	 * Returns list of entities for a category ID

	 * 

	 * @param categoryID

	 * @return List<Entity>

	 * @throws Exception 

	 */

	public List<Entity> getEntities(long categoryID) throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		//Utils.info("this.entitiesbycategory=" + this.entitiesbycategory);

		return this.entitiesbycategory.get(new Long(categoryID));

	}

	/**

	 * Convenience method to add new Entity 

	 * 

	 * @param newEntity

	 * @throws Exception 

	 */

	public void addEntity(Entity newEntity) throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		this.entities.put(new Long(newEntity.getID()), newEntity);

		// Keep index by category ID

		List<Entity> catentities = 

			this.entitiesbycategory.get(newEntity.getCategoryID());

		if(catentities == null) {

			catentities = new ArrayList<Entity>();

		}

		catentities.add(newEntity);

		this.entitiesbycategory.put(new Long(newEntity.getCategoryID()), 

				catentities);

	}

	/**

	 * Convenience method to add new Entity 

	 * 

	 * @param newEntity

	 * @throws Exception 

	 */

	public void updateEntity(Entity newEntity) throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		this.entities.remove(new Long(newEntity.getID()));

		// Keep index by category ID

		List<Entity> catentities = 

			this.entitiesbycategory.get(newEntity.getCategoryID());

		// As it is the reference, remove(obj) should work

		catentities.remove(newEntity);

		this.addEntity(newEntity);

	}

	/**

	 * Convenience method to remove an Entity 

	 * 

	 * @param newEntity

	 * @throws Exception 

	 */

	public void deleteEntity(Entity newEntity) throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		this.entities.remove(new Long(newEntity.getID()));

		// Keep index by category ID

		List<Entity> catentities = 

			this.entitiesbycategory.get(newEntity.getCategoryID());

		// As it is the reference, remove(obj) should work

		catentities.remove(newEntity);

	}

	/**

	 * 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 = this.getEntity(entityID);

		// Changed by Rajveer to handle null value

		if(entity==null){

			System.out.println("Entity is null");

			return null;

		}

		System.out.println( entity.getCategoryID());

		ExpandedEntity expEntity = new ExpandedEntity(entity);

		return expEntity;

	}

	/**

	 * Returns hashtable of list facet values to facet definition ID

	 * 

	 * @return

	 * @throws Exception

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, List<String>> getFacetValues() throws Exception {

		// De-serialize

		if(this.facetDefinitionIDFacetValues == null) {

			String dbFile = this.dbPath + "entities" + File.separator + "facetvalues.ser";

			this.facetDefinitionIDFacetValues = 

				(Map<Long, List<String>>) DBUtils.read(dbFile);

		}

		if(this.facetDefinitionIDFacetValues == null) {

			this.facetDefinitionIDFacetValues = new HashMap<Long, 

				List<String>>();

		}

		return this.facetDefinitionIDFacetValues;

	}

	/**

	 * Returns list of facet values for a facet definition ID

	 * 

	 * @param facetDefinitionID

	 * @return List<String> 

	 * @throws Exception

	 */

	public List<String> getFacetValues(long facetDefinitionID) 

		throws Exception {

		this.getFacetValues();

		return this.facetDefinitionIDFacetValues.get(

				new Long(facetDefinitionID));

	}

	/**

	 * 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 = this.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 = this.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;

	}

	/**

	 * Returns per slide comparison score for all entities in DB

	 * 

	 * @return Map<Long, Map<Long, Integer>> Entity ID > Map(Slide ID > Score)

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, Map<Long, Integer>> getEntitySlideComparisonScores() 

		throws Exception {

		// De-serialize

		if(this.entityIDSlideIDsScore == null) {

			String dbFile = this.dbPath + "comparisons" + File.separator + "slidescores.ser";

			this.entityIDSlideIDsScore = 

				(Map<Long, Map<Long, Integer>>) DBUtils.read(dbFile);

		}

		if(this.entityIDSlideIDsScore == null) {

			this.entityIDSlideIDsScore = new HashMap<Long, 

				Map<Long, Integer>>();

		}

		return this.entityIDSlideIDsScore;

	}

	/**

	 * Returns final comparison score for all entities in DB

	 * 

	 * @return Map<Long, Integer> Entity ID > Final Score

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, Integer> getEntityComparisonScores() throws Exception {

		// De-serialize

		if(this.entityIDFinalScore == null) {

			String dbFile = this.dbPath + "comparisons" + File.separator + 

				"defaultentityscores.ser";

			this.entityIDFinalScore = 

				(Map<Long, Integer>) DBUtils.read(dbFile);

		}

		if(this.entityIDFinalScore == null) {

			this.entityIDFinalScore = new HashMap<Long, Integer>();

		}

		return this.entityIDFinalScore;

	}

	/**

	 * Returns slide wise comparison scores for an entity

	 * 

	 * @param entityID

	 * @return Map<Long, Integer> Slide ID to Comparison score, Null if no data

	 * @throws Exception

	 */

	public Map<Long, Integer> getSlideComparisonScores(long entityID) 

		throws Exception {

		this.getEntitySlideComparisonScores();

		return this.entityIDSlideIDsScore.get(new Long(entityID));

	}

	/**

	 * 

	 * @param entityID

	 * @return int Comparison score

	 * @throws Exception

	 */

	public int getEntityComparisonScore(long entityID) throws Exception {

		this.getEntityComparisonScores();

		Integer objScore = this.entityIDFinalScore.get(new Long(entityID));

		if(objScore != null) {

			return objScore.intValue();

		}

		return -1;

	}

}