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;

	}

}