Subversion Repositories SmartDukaan

package in.shop2020.creation.controllers;

import in.shop2020.creation.util.CreationUtils;

import in.shop2020.metamodel.core.Bullet;

import in.shop2020.metamodel.core.CompositeDataObject;

import in.shop2020.metamodel.core.Entity;

import in.shop2020.metamodel.core.EnumDataObject;

import in.shop2020.metamodel.core.Feature;

import in.shop2020.metamodel.core.FreeformContent;

import in.shop2020.metamodel.core.PrimitiveDataObject;

import in.shop2020.metamodel.core.Slide;

import in.shop2020.metamodel.definitions.Category;

import in.shop2020.metamodel.definitions.CategorySlideDefinition;

import in.shop2020.metamodel.definitions.CompositeDefinition;

import in.shop2020.metamodel.definitions.CompositePartDefinition;

import in.shop2020.metamodel.definitions.DefinitionsContainer;

import in.shop2020.metamodel.definitions.EntityContainer;

import in.shop2020.metamodel.definitions.FeatureDefinition;

import in.shop2020.metamodel.definitions.SlideDefinition;

import in.shop2020.metamodel.definitions.SlideFeatureDefinition;

import in.shop2020.metamodel.util.ExpandedBullet;

import in.shop2020.metamodel.util.ExpandedBulletDefinition;

import in.shop2020.metamodel.util.ExpandedEntity;

import in.shop2020.metamodel.util.ExpandedFeature;

import in.shop2020.metamodel.util.ExpandedFeatureDefinition;

import in.shop2020.metamodel.util.ExpandedSlide;

import in.shop2020.metamodel.util.ExpandedSlideDefinition;

import in.shop2020.metamodel.util.SequenceGenerator;

import in.shop2020.util.DBUtils;

import in.shop2020.util.Utils;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang.StringUtils;

import org.apache.juli.logging.Log;

import org.apache.juli.logging.LogFactory;

import org.apache.struts2.convention.annotation.Result;

import org.apache.struts2.convention.annotation.Results;

import org.apache.struts2.interceptor.ParameterAware;

import org.apache.struts2.rest.DefaultHttpHeaders;

import org.apache.struts2.rest.HttpHeaders;

@Results({

    @Result(name="success", type="redirectAction", 

    		params = {"actionName" , "entity"}),

    @Result(name="redirect", location="${url}", type="redirect")

})

public class EntityController implements ParameterAware {

	/**

	 * 

	 */

	private static Log log = LogFactory.getLog(EntityController.class);

	/**

	 * 

	 */

	private String id;

	private ExpandedEntity expEntity;

	private Collection<Entity> entities;

	private Map<String, String[]> reqparams;

	private EntityContainer ents;

	private DefinitionsContainer defs;

	private long firstSlideDefID;

	private ExpandedSlideDefinition expSlideDef;

	private ExpandedSlide expSlide;

	private String redirectURL;

	private Exception exception;

	private String errorString;

	private long newCurrentSlideDefinitionID;

	private long newNextSlideDefinitionID;

	private long newPrevSlideDefinitionID;

    // GET /entity

    public HttpHeaders index() {

    	log.info("EntityController.index");

    	EntityContainer ents = new EntityContainer();

    	try {

			this.entities = ents.getEntities().values();

		} catch (Exception e) {

			log.error(CreationUtils.getStackTrace(e));

			this.setErrorString(CreationUtils.getStackTrace(e));

			return new DefaultHttpHeaders("fatal");

		}

        return new DefaultHttpHeaders("index").disableCaching();

    }

    // GET /entity

    public String create() {

    	log.info("EntityController.create");

		SequenceGenerator sg;

		try {

			sg = SequenceGenerator.getInstance();

			long entityID = sg.getNextSequence(SequenceGenerator.ENTITY);

			String categoryID = this.reqparams.get("category")[0];

			Entity entity = new Entity(entityID, Long.parseLong(categoryID));

			entity.setBrand(this.reqparams.get("brand")[0]);

			entity.setModelName(this.reqparams.get("modelname")[0]);

			entity.setModelNumber(this.reqparams.get("modelnumber")[0]);

			this.addEntity(entity);

	    	this.setId(new Long(entityID).toString());

		} catch (Exception e) {

			log.error(CreationUtils.getStackTrace(e));

			this.setErrorString(CreationUtils.getStackTrace(e));

			return "fatal";

		}

		this.redirectURL = "entity/" + this.getId() + "/edit";

		return "redirect";

    }

    // GET /entity/1/edit

    public String edit() {

    	log.info("EntityController.edit");

    	long entityID = Long.parseLong(this.getId());

    	log.info("entityID:" + entityID);

    	EntityContainer ents = this.getEntityContainer();

    	DefinitionsContainer defs = this.getDefinitionsContainer();

    	try {

			this.expEntity = ents.getExpandedEntity(entityID);

			//log.info("this.expEntity:" + this.expEntity);

			long catID = this.expEntity.getCategoryID();

			List<Long> slideDefIDs = defs.getCategorySlideSequence(catID);

			this.firstSlideDefID = slideDefIDs.get(0);

		} catch (Exception e) {

			log.error(CreationUtils.getStackTrace(e));

			this.setErrorString(CreationUtils.getStackTrace(e));

			return "fatal";

		}

        return "edit";

    }

    public String getUrl() {

    	return this.redirectURL;

    }

    // GET /entity/new

    public String editNew() {

    	log.info("EntityController.editNew");

        return "editNew";

    }

    // GET /entity/1

    public String update() {

    	log.info("EntityController.update");

    	long entityID = Long.parseLong(this.getId());

    	log.info("entityID:" + entityID);

    	EntityContainer ents = this.getEntityContainer();

    	DefinitionsContainer defs = this.getDefinitionsContainer();

    	try {

			this.expEntity = ents.getExpandedEntity(entityID);

			//log.info("this.expEntity:" + this.expEntity);

			long currentSlideDefID = 0L;

			long nextSlideDefID = 0L;

			long prevSlideDefID = 0L;

			String[] currentslideDefIDStrings = 

				this.reqparams.get("currentslideDefID");

			String[] nextslideDefIDStrings = 

				this.reqparams.get("nextslideDefID");

			String[] prevslideDefIDStrings = 

				this.reqparams.get("prevslideDefID");

			// Current Slide ID

			if(currentslideDefIDStrings != null && 

					currentslideDefIDStrings.length > 0) {

				try {

					currentSlideDefID = Long.parseLong(

							currentslideDefIDStrings[0]);

				}

				catch (NumberFormatException nfe) {}

			}

			// Next Slide ID

			if(nextslideDefIDStrings != null && 

					nextslideDefIDStrings.length > 0) {

				try {

					nextSlideDefID = Long.parseLong(nextslideDefIDStrings[0]);

				}

				catch (NumberFormatException nfe) {}

			}

			// Prev Slide ID

			if(prevslideDefIDStrings != null && 

					prevslideDefIDStrings.length > 0) {

				try {

					prevSlideDefID = Long.parseLong(prevslideDefIDStrings[0]);

				}

				catch (NumberFormatException nfe) {}

			}

			log.info("currentSlideDefID:" + currentSlideDefID);

			log.info("nextSlideDefID:" + nextSlideDefID);

			log.info("prevSlideDefID:" + prevSlideDefID);

			// Save on basic info page

			if (this.reqparams.containsKey("save") && currentSlideDefID == 0L) {

				log.info("Save");

				Entity entity = this.expEntity.getEntity();

				String categoryID = this.reqparams.get("category")[0];

				entity.setCategoryID(Long.parseLong(categoryID));

				entity.setBrand(this.reqparams.get("brand")[0]);

				entity.setModelName(this.reqparams.get("modelname")[0]);

				entity.setModelNumber(this.reqparams.get("modelnumber")[0]);

				this.updateEntity(entity);

				return "success";

			}

			long catID = this.expEntity.getCategoryID();

			List<Long> slideIDs = defs.getCategorySlideSequence(catID);

			log.info("slideIDs:"+slideIDs);

			boolean skip = false;

			if(this.reqparams.containsKey("skipprev") || 

					this.reqparams.containsKey("skipnext")) {

				skip = true;

			}

			boolean next = this.reqparams.containsKey("skipnext") || 

				this.reqparams.containsKey("next");

			boolean prev = this.reqparams.containsKey("skipprev") || 

			this.reqparams.containsKey("prev");

			// Save or Next or Prev - When editing a slide

			int currentSlideIndex = 0;

			currentSlideIndex = slideIDs.indexOf(new Long(currentSlideDefID));

			log.info("currentSlideIndex:" + currentSlideIndex);

			if(!skip && currentSlideDefID != 0L) {

				Entity entity = this.expEntity.getEntity();

				// Create new instance and override existing

				Slide currentSlide = this.createSlide(currentSlideDefID);

				entity.addSlide(currentSlide);

				// Store

				this.updateEntity(entity);

				//log.info("entity:" + entity);

			}

			// Skip will delete current slide from entity

			else if(skip && currentSlideDefID != 0L) {

				Entity entity = this.expEntity.getEntity();

				entity.removeSlide(currentSlideDefID);

				// Store

				this.updateEntity(entity);

				//log.info("entity:" + entity);

			}

			boolean showAnotherSlide = false;

			// -2 : Not set

			// -1 : Not found

			int newCurrentIndex = -2;  

			int newNextIndex = -2;

			int newPrevIndex = -2;

			// Next

			if(next && nextSlideDefID != 0L) {

				log.info("Next");

				// Decide on next slide ID

				int nextSlideIndex = slideIDs.indexOf(new Long(nextSlideDefID));

				log.info("nextSlideIndex:"+nextSlideIndex);

				// New Current

				if (nextSlideIndex == -1) {

					this.setErrorString("Invalid Next slide ID " + 

							nextSlideDefID);

					return "fatal";

				}

				newCurrentIndex = nextSlideIndex;

				// New Next

				if (newCurrentIndex != slideIDs.size()-1) {

					newNextIndex = newCurrentIndex + 1;

				}

				// New Prev.

				if(currentSlideDefID != 0L) {

					newPrevIndex = currentSlideIndex;

				}

				showAnotherSlide = true;

			}

			// Prev

			if(prev && prevSlideDefID != 0L) {

				log.info("Prev");

				// Decide on prev slide ID

				int prevSlideIndex = slideIDs.indexOf(new Long(prevSlideDefID));

				log.info("prevSlideIndex:" + prevSlideIndex);

				if (prevSlideIndex == -1) {

					this.setErrorString("Invalid Prev slide ID " + 

							prevSlideDefID);

					return "fatal";

				}

				// New Next

				if(currentSlideDefID != 0L) {

					newNextIndex = currentSlideIndex;

				}

				// New Current

				newCurrentIndex = prevSlideIndex;

				// New Prev.

				if (newCurrentIndex != 0) {

					newPrevIndex = newCurrentIndex - 1;

				}

				showAnotherSlide = true;

			}

			if(showAnotherSlide) {

 				log.info("newCurrentIndex:" + newCurrentIndex);

				log.info("newNextIndex:" + newNextIndex);

				log.info("newPrevIndex:" + newPrevIndex);

				if(newCurrentIndex != -2) {

					this.setNewCurrentSlideDefinitionID(

							slideIDs.get(newCurrentIndex).longValue());

				}

				if(newNextIndex != -2) {

					this.setNewNextSlideDefinitionID(

							slideIDs.get(newNextIndex).longValue());

				}

				if(newPrevIndex != -2) {

					this.setNewPrevSlideDefinitionID(

							slideIDs.get(newPrevIndex).longValue());

				}

				// Current Slide Definition

				this.expSlideDef = defs.getExpandedSlideDefinition(

						this.getNewCurrentSlideDefinitionID());

				// Current Slide Instance

				this.expSlide = this.expEntity.getExpandedSlide(

						this.getNewCurrentSlideDefinitionID());

				//log.info("this.expSlide:" + this.expSlide);

				return "editSlide";

			}

		}

    	catch (Exception e) {

			log.error(CreationUtils.getStackTrace(e));

			this.setErrorString(CreationUtils.getStackTrace(e));

			return "fatal";

    	}

        return "success";

    }

    /**

     * 

     * @param slideDefID

     * @return

     * @throws Exception

     */

    private Slide createSlide(long slideDefID) throws Exception {

		Slide slide = new Slide(slideDefID);

		// Slide free-form content

		FreeformContent slideFFC = this.getFreeformContent(

				"slide_" + slideDefID);

		log.info("slideFFC:" + slideFFC);

		slide.setFreeformContent(slideFFC);

		//log.info("currentSlide:" + currentSlide);

		// Collect Feature bullets

		List<Feature> features = this.createFeatures(slide);

		log.info("features:" + features);

		slide.setFeatures(features);

		// Collect children slides

		SlideDefinition slideDef = 

			this.getDefinitionsContainer().getSlideDefinition(slideDefID);

		List<Long> childrenSlideIDs = slideDef.getChildrenSlideDefinitionIDs();

		if(childrenSlideIDs != null) {

			List<Slide> childrenSlides = new ArrayList<Slide>();

			for (Long childSlideID : childrenSlideIDs) {

				Slide childSlide = this.createSlide(childSlideID.longValue());

				if(childSlide != null) {

					childrenSlides.add(childSlide);

				}

			}

			slide.setChildrenSlides(childrenSlides);

		}

		return slide;

    }

    /**

     * 

     * @param slide

     * @return

     * @throws Exception

     */

    private List<Feature> createFeatures(Slide slide) throws Exception {

		long slideDefID = slide.getSlideDefinitionID();

		SlideDefinition slideDef = defs.getSlideDefinition(slideDefID);

		List<SlideFeatureDefinition> slideFeatureDefs = 

			slideDef.getSlideFeatureDefinitions();

		DefinitionsContainer defs = this.getDefinitionsContainer();

		List<Feature> features = new ArrayList<Feature>();	

		for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {

			long featureDefinitionID = slideFeatureDef.getFeatureDefintionID();

			log.info("featureDefinitionID:" + featureDefinitionID);

			// Ignore skipped featured

			String[] skipvalue = 

				this.reqparams.get(featureDefinitionID + "_skip");

			log.info("skipvalue:" + Arrays.toString(skipvalue));

			if(skipvalue != null && skipvalue.length > 0 && 

					skipvalue[0].equals("on")) {

				continue;

			}

			String featureDefIDString = 

				new Long(featureDefinitionID).toString();

			Feature feature = new Feature(featureDefinitionID);

			// Bullets

			List<Bullet> bullets = new ArrayList<Bullet>();

			FeatureDefinition featureDef = defs.getFeatureDefinition(

					featureDefinitionID);

			log.info("featureDef:" + featureDef);

			ExpandedFeatureDefinition expFeatureDef = 

				new ExpandedFeatureDefinition(featureDef);

			ExpandedBulletDefinition expBulletDef = 

				expFeatureDef.getExpandedBulletDefinition();

			// Collect unit

			String[] unitIDs = this.reqparams.get(featureDefIDString + "_unit");

			long unitID = 0L;

			if(unitIDs != null && unitIDs.length > 0) {

				unitID = Long.parseLong(unitIDs[0]);

			}

			// Composite

			if(expBulletDef.isComposite()) {

				log.info("Composite");

				CompositeDataObject compositeDataObject = 

					new CompositeDataObject();

				CompositeDefinition compositeDef = 

					(CompositeDefinition)expBulletDef.getDatatypeDefinition(); 

				List<CompositePartDefinition> compositeParts = 

					compositeDef.getCompositePartDefinitions();

				for(int j=0;j<compositeParts.size();j++) {

					String[] partValues = this.reqparams.get(

							featureDefIDString + "_" + (j + 1));

					if(partValues != null && partValues.length > 0) {

						compositeDataObject.addPrimitiveDataObject(

							new PrimitiveDataObject(partValues[0]));

					}

				}

				Bullet bullet = new Bullet(compositeDataObject);

				if(unitID != 0L) {

					bullet.setUnitID(unitID);

				}

				bullets.add(bullet);

			}

			// Enumerated

			else if(expBulletDef.isEnumerated()) {

				log.info("Enumerated");

				String[] bulletValues = this.reqparams.get(featureDefIDString);

				if(bulletValues == null || bulletValues.length == 0) {

					continue;

				}

				log.info("bulletValues:" + Arrays.toString(bulletValues));

				for(int i=0;i<bulletValues.length;i++) {

					EnumDataObject enumDataObject = 

						new EnumDataObject(Long.parseLong(bulletValues[i]));

					Bullet bullet = new Bullet(enumDataObject);

					if(unitID != 0L) {

						bullet.setUnitID(unitID);

					}

					bullets.add(bullet);

				}

			}

			// Primitive

			else {

				log.info("Primitive");

				String[] bulletValues = this.reqparams.get(featureDefIDString);

				if(bulletValues == null || bulletValues.length == 0) {

					continue;

				}

				log.info("bulletValues:" + Arrays.toString(bulletValues));

				for(int i=0;i<bulletValues.length;i++) {

					Bullet bullet = new Bullet(

							new PrimitiveDataObject(bulletValues[i]));

					if(unitID != 0L) {

						bullet.setUnitID(unitID);

					}

					bullets.add(bullet);

				}

			}

			feature.setBullets(bullets);

			// FFC

			FreeformContent featureFFC = 

				this.getFreeformContent(featureDefIDString);

			feature.setFreeformContent(featureFFC);

			features.add(feature);

		}

		return features;

	}

	/**

     * 

     * @param ID

     * @return

     */

    private FreeformContent getFreeformContent(String ID) {

		FreeformContent ffc = new FreeformContent();

		String[] ffts = this.reqparams.get(ID + "_fft");

		if(ffts != null) {

			ffc.setFreeformTexts(Arrays.asList(ffts));

		}

		String[] imgRefs = this.reqparams.get(ID + "_image_references");

		if(imgRefs != null) {

			ffc.setMedia("image", Arrays.asList(imgRefs));

		}

		String[] youtubeRefs = 

			this.reqparams.get(ID + "_youtube_references");

		if(youtubeRefs != null) {

			ffc.setMedia("youtube", Arrays.asList(youtubeRefs));

		}

		log.info("ffc:" + ffc);

		return ffc;

	}

    /**

     * 

     * @param slideDefinitionID

     * @return

     */

	public ExpandedSlide getChildSlide(long slideDefinitionID) {

		return this.getChildSlide(this.expSlide, slideDefinitionID);

	}

    /**

     * 

     * @param expSlide

     * @param slideDefinitionID

     * @return

     */

	public ExpandedSlide getChildSlide(ExpandedSlide expSlide, 

			long slideDefinitionID) {

		List<ExpandedSlide> childrenSlides = 

			expSlide.getExpandedChildrenSlides();

		ExpandedSlide resultSlide = null;

		if(childrenSlides != null) {

			for(ExpandedSlide childSlide : childrenSlides) {

				if(childSlide.getSlideDefinitionID() == slideDefinitionID) {

					return childSlide;

				}

				resultSlide = this.getChildSlide(childSlide, slideDefinitionID);

				if(resultSlide == null) {

					continue;

				}

				else {

					break;

				}

			}

		}

		return resultSlide;

	}

	/**

	 * @return the entities

	 */

	public Collection<Entity> getEntities() {

		return entities;

	}

    /**

	 * @return the entities

	 */

	public ExpandedEntity getEntity() {

		return expEntity;

	}

    /**

	 * @return the current slide to edit

	 */

	public ExpandedSlideDefinition getExpandedSlideDefinition() {

		return expSlideDef;

	}

	/**

	 * 

	 * @param slideDefID

	 * @return

	 */

	public ExpandedSlideDefinition getExpandedSlideDefinition(long slideDefID) {

		DefinitionsContainer defs = this.getDefinitionsContainer();

		try {

			return defs.getExpandedSlideDefinition(slideDefID);

		} catch (Exception e) {

			return null;

		}

	}

	/**

     * 

     * @param id

     */

    public void setId(String id) {

        this.id = id;

    }

    /**

     * 

     */

    public String getId() {

    	return this.id;

    }

	/**

	 * @return the firstSlideID

	 */

	public long getFirstSlideDefID() {

		return firstSlideDefID;

	}

	@Override

	public void setParameters(Map<String, String[]> reqmap) {

		log.info("setParameters:" + reqmap);

		this.reqparams = reqmap;

	}

	public Map<String, String> getCategories() throws Exception {

		DefinitionsContainer defs = this.getDefinitionsContainer();

		Map<String, String> cats = new HashMap<String, String>();

		List<Category> children = defs.getChildrenCategories(10001L);

		for(Category child : children) {

			cats.put(new Long(child.getID()).toString(), child.getLabel());

		}

		return cats;

	}

	public String getBrandString() throws Exception {

		List<String> brands = this.getBrands();

		return "\"" + StringUtils.join(brands, "\", \"") + "\"";

	}

	public List<String> getBrands() throws Exception {

		EntityContainer ents = this.getEntityContainer();

		List<String> brands = new ArrayList<String>();

		List<ExpandedBullet> expBullets;

		expBullets = ents.getLearnedBullets(

				Utils.BRAND_FEATURE_DEFINITION_ID);

		for(ExpandedBullet expBullet : expBullets) {

			brands.add(expBullet.getValue());

		}

		return brands;

	}

    private EntityContainer getEntityContainer() {

    	if(this.ents == null) {

    		this.ents = new EntityContainer();

    	}

	    return this.ents;

    }

    private DefinitionsContainer getDefinitionsContainer() {

    	if(this.defs == null) {

    		this.defs = new DefinitionsContainer();

    	}

	    return this.defs;

    }

    /**

     * 

     * @param entity

     * @throws Exception

     */

	private void addEntity(Entity entity) throws Exception {			

		EntityContainer entContainer = new EntityContainer();

		entContainer.addEntity(entity);

		DBUtils.store(entContainer.getEntities(), Utils.ENTITIES_DB_PATH + 

				"entities" + ".ser");

		String entitiesbycategoryDBFile = Utils.ENTITIES_DB_PATH + 

			"entitiesbycategory" + ".ser";

		DBUtils.store(entContainer.getEntitiesbyCategory(), 

				entitiesbycategoryDBFile);

	}

    /**

     * 

     * @param entity

     * @throws Exception

     */

	private void updateEntity(Entity entity) throws Exception {			

		EntityContainer entContainer = new EntityContainer();

		entContainer.updateEntity(entity);

		DBUtils.store(entContainer.getEntities(), Utils.ENTITIES_DB_PATH + 

				"entities" + ".ser");

		String entitiesbycategoryDBFile = Utils.ENTITIES_DB_PATH + 

			"entitiesbycategory" + ".ser";

		DBUtils.store(entContainer.getEntitiesbyCategory(), 

				entitiesbycategoryDBFile);

	}

	/**

	 * @param exception the exception to set

	 */

	public void setException(Exception exception) {

		this.exception = exception;

	}

	/**

	 * @return the exception

	 */

	public Exception getException() {

		return exception;

	}

	/**

	 * @param errorString the exceptionString to set

	 */

	public void setErrorString(String errorString) {

		this.errorString = errorString;

	}

	/**

	 * @return the exceptionString

	 */

	public String getErrorString() {

		return errorString;

	}

	/**

	 * @param newCurrentSlideID the newCurrentSlideID to set

	 */

	public void setNewCurrentSlideDefinitionID(

			long newCurrentSlideDefinitionID) {

		this.newCurrentSlideDefinitionID = newCurrentSlideDefinitionID;

	}

	/**

	 * @return the newCurrentSlideID

	 */

	public long getNewCurrentSlideDefinitionID() {

		return newCurrentSlideDefinitionID;

	}

	/**

	 * @param newNextSlideID the newNextSlideID to set

	 */

	public void setNewNextSlideDefinitionID(long newNextSlideDefinitionID) {

		this.newNextSlideDefinitionID = newNextSlideDefinitionID;

	}

	/**

	 * @return the newNextSlideID

	 */

	public long getNewNextSlideDefinitionID() {

		return newNextSlideDefinitionID;

	}

	/**

	 * @param expSlide the expSlide to set

	 */

	public void setExpandedSlide(ExpandedSlide expSlide) {

		this.expSlide = expSlide;

	}

	/**

	 * @return the expSlide

	 */

	public ExpandedSlide getExpandedSlide() {

		return expSlide;

	}

	/**

	 * @param newPrevSlideDefinitionID the newPrevSlideDefinitionID to set

	 */

	public void setNewPrevSlideDefinitionID(long newPrevSlideDefinitionID) {

		this.newPrevSlideDefinitionID = newPrevSlideDefinitionID;

	}

	/**

	 * @return the newPrevSlideDefinitionID

	 */

	public long getNewPrevSlideDefinitionID() {

		return newPrevSlideDefinitionID;

	}

	/**

	 * 

	 * @param featureDefinitionID

	 * @return

	 * @throws Exception

	 */

	public String getLearnedValuesString(long featureDefinitionID) 

			throws Exception {

		List<String> learnedValues = this.getLearnedValues(featureDefinitionID);

		if(learnedValues == null) {

			return "";

		}

		return "\"" + StringUtils.join(learnedValues, "\", \"") + "\"";

	}

	/**

	 * 

	 * @param featureDefinitionID

	 * @return

	 * @throws Exception

	 */

	public List<String> getLearnedValues(long featureDefinitionID) 

			throws Exception {

		EntityContainer ents = this.getEntityContainer();

		List<ExpandedBullet> learnedBullets = 

			ents.getLearnedBullets(featureDefinitionID);

		if(learnedBullets == null) {

			return null;

		}

		List<String> learnedValues = new ArrayList<String>();

		for(ExpandedBullet expBullet : learnedBullets) {

			learnedValues.add(expBullet.getValue());

		}

		return learnedValues;

	}

	/**

	 * 

	 * @param featureDefinitionID

	 * @return

	 * @throws Exception

	 */

	public ExpandedFeature getFeature(long featureDefinitionID) 

		throws Exception {

		EntityContainer ents = this.getEntityContainer();

		if(this.expSlide != null) {

			Feature feature = ents.getFeature(

					this.expSlide, featureDefinitionID);

			if(feature == null) {

				return null;

			}

			return new ExpandedFeature(feature);

		}

		return null;

	}

	/**

	 * 

	 * @return

	 */

	public String getEditorialImportance() {

		long catID = this.expEntity.getCategoryID();

		long slideDefID = this.getNewCurrentSlideDefinitionID();

		try {

			List<CategorySlideDefinition> catSlideDefs =

				defs.getCategorySlideDefinitions(catID);

			for(CategorySlideDefinition catSlideDef : catSlideDefs) {

				if(catSlideDef.getSlideDefintionID() == slideDefID) {

					return catSlideDef.getEditorialImportance().toString();

				}

			}