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 firstSlideID;

	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> slideIDs = defs.getCategorySlideSequence(catID);

			this.firstSlideID = slideIDs.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 currentSlideID = 0L;

			long nextSlideID = 0L;

			long prevSlideID = 0L;

			String[] currentslideIDStrings = 

				this.reqparams.get("currentslideID");

			String[] nextslideIDStrings = this.reqparams.get("nextslideID");

			String[] prevslideIDStrings = this.reqparams.get("prevslideID");

			// Current Slide ID

			if(currentslideIDStrings != null && 

					currentslideIDStrings.length > 0) {

				try {

					currentSlideID = Long.parseLong(currentslideIDStrings[0]);

				}

				catch (NumberFormatException nfe) {}

			}

			// Next Slide ID

			if(nextslideIDStrings != null && 

					nextslideIDStrings.length > 0) {

				try {

					nextSlideID = Long.parseLong(nextslideIDStrings[0]);

				}

				catch (NumberFormatException nfe) {}

			}

			// Prev Slide ID

			if(prevslideIDStrings != null && 

					prevslideIDStrings.length > 0) {

				try {

					prevSlideID = Long.parseLong(prevslideIDStrings[0]);

				}

				catch (NumberFormatException nfe) {}

			}

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

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

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

			// Save on basic info page

			if (this.reqparams.containsKey("save") && currentSlideID == 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(currentSlideID));

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

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

				Entity entity = this.expEntity.getEntity();

				// Update Entity Record

				Slide currentSlide = entity.getSlide(currentSlideID);

				// Slide free-form content

				FreeformContent slideFFC = this.getFreeformContent("slide");

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

				currentSlide.setFreeformContent(slideFFC);

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

				// Collect Feature bullets

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

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

				currentSlide.setFeatures(features);

				// 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 && nextSlideID != 0L) {

				log.info("Next");

				// Decide on next slide ID

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

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

				// New Current

				if (nextSlideIndex == -1) {

					this.setErrorString("Invalid Next slide ID " + nextSlideID);

					return "fatal";

				}

				newCurrentIndex = nextSlideIndex;

				// New Next

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

					newNextIndex = newCurrentIndex + 1;

				}

				// New Prev.

				if(currentSlideID != 0L) {

					newPrevIndex = currentSlideIndex;

				}

				showAnotherSlide = true;

			}

			// Prev

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

				log.info("Prev");

				// Decide on prev slide ID

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

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

				if (prevSlideIndex == -1) {

					this.setErrorString("Invalid Prev slide ID " + prevSlideID);

					return "fatal";

				}

				// New Next

				if(currentSlideID != 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 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);

			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;

	}

	/**

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

     */

    public void setId(String id) {

        this.id = id;

    }

    /**

     * 

     */

    public String getId() {

    	return this.id;

    }

	/**

	 * @return the firstSlideID

	 */

	public long getFirstSlideID() {

		return firstSlideID;

	}

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

		Feature feature = ents.getFeature(this.expSlide, featureDefinitionID);

		if(feature == null) {

			return null;

		}

		return new ExpandedFeature(feature);

	}

	/**

	 * 

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

				}

			}

		} catch (Exception e) {

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

    	}

		return "";

	}

	/**

	 * 

	 * @return

	 * @throws Exception 

	 * @throws NumberFormatException 

	 */

	public List<String> getMediaLabels(String type) {

		try {

			return CreationUtils.getMediaLabels(Long.parseLong(this.getId()), 

					type);

		}

		catch(Exception nfe) {

			return null;

		}

	}

}