Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.creation.controllers;

import in.shop2020.creation.util.ContentValidator;

import in.shop2020.metamodel.util.CreationUtils;

import in.shop2020.metamodel.core.Entity;

import in.shop2020.metamodel.core.Slide;

import in.shop2020.metamodel.definitions.Catalog;

import in.shop2020.metamodel.definitions.Category;

import in.shop2020.metamodel.definitions.CategorySlideDefinition;

import in.shop2020.metamodel.definitions.DefinitionsContainer;

import in.shop2020.metamodel.definitions.EntityContainer;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

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;

@Results({

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

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

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

})

public class SlidesController implements ParameterAware {

	/**

	 * 

	 */

	private static final long serialVersionUID = 1L;

	/**

	 * 

	 */

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

	/**

	 * 

	 */

	private String id;

	private String redirectURL;

	private Map<String, String[]> reqparams;

	private EntityContainer ents;

	private DefinitionsContainer defs;

	private List<List<String[]>> allSlidesData = 

		new ArrayList<List<String[]>>();

	private Map<Long, CategorySlideDefinition> mapAllCatSlideDefs = 

		new HashMap<Long, CategorySlideDefinition>();

	private Map<Long, List<Long>> catSlides;

	private Entity entity;

	/**

	 * 

	 * @return

	 */

    public String edit() {

    	log.info("SlidesController.edit");

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

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

    	DefinitionsContainer defs = this.getDefinitionsContainer();

    	try {

    		Entity entity = this.getEntity(entityID);

    		List<Long> selection = CreationUtils.getSlideSequence(entityID, entity.getCategoryID());

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

    		// Entity's category first

			long catID = entity.getCategoryID();

			List<String[]> slidesData = this.getSlidesData(catID, selection, 

					true);

			this.allSlidesData.add(slidesData);

			// Get slides for rest of the categories

			long parentCatID  = (defs.getCategory(catID)).getParentCategory().getID();

			List<Category> cats = defs.getChildrenCategories(parentCatID);

			for(Category cat : cats) {

				if(cat.getID() != catID) {

					List<String[]> thisSlidesData = 

						this.getSlidesData(cat.getID(), selection, false);

					this.allSlidesData.add(thisSlidesData);

				}

			}

		} catch (Exception e) {

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

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

			return "fatal";

		}

    	return "edit";

    }

    /**

     * 

     * @return

     */

    public String update() {

    	log.info("SlidesController.update");

    	for(String reqparam: this.reqparams.keySet()){

    		String[] values = this.reqparams.get(reqparam);

    		for(String value: values){

    			System.out.println("Param:   " + reqparam + "Value:   " + value);

    		}

    	}

    	if(this.reqparams.get("slideid") != null){

    		long slideId = Long.parseLong(this.reqparams.get("slideid")[0]);

    		long afterSlideId = Long.parseLong(this.reqparams.get("afterslide")[0]);

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

//	    	List<Long> slideSequence = CreationUtils.getSlideSequence(entityID);

//	    	List<Long> newSlideSequence = new ArrayList<Long>();

//	    	

//	    	for(Long slide: slideSequence){

//	    		newSlideSequence.add(slide);

//	    		if(slide.equals(new Long(afterSlideId))){

//	    			newSlideSequence.add(new Long(slideId));

//	    		}

//	    	}

    	try{

    		EntityContainer ents = this.getEntityContainer();

	    	Entity entity = this.getEntity(entityID);

	    	Long catId = new Long(entity.getCategoryID());

	    	Map<Long, List<Long>> catSlideSequence = CreationUtils.getRawSlideSequence(entityID);

	    	List<Long> allSlideSequence = catSlideSequence.get(new Long(-1));

	    	List<Long> newAllSlideSequence = new ArrayList<Long>();

	    	catSlideSequence.remove(new Long(-1));

	    	Map<Long, List<Long>> newCatSlideSequence = new HashMap<Long, List<Long>>();

	    	for(Long slide: allSlideSequence){

	    		newAllSlideSequence.add(slide);

    			if(slide.equals(new Long(afterSlideId))){

	    			newAllSlideSequence.add(new Long(slideId));

	    		}	

	    	}

	    	DefinitionsContainer defs = Catalog.getInstance().getDefinitionsContainer();

	    	for(Long cat: catSlideSequence.keySet()){

	    		List<Long> newSlideSequence = new ArrayList<Long>();

	    		List<Long> slides =  catSlideSequence.get(cat);

	    		boolean contains = false;

	    		List<CategorySlideDefinition> catdefs = defs.getCategorySlideDefinitions(cat);

	    		for(CategorySlideDefinition  catdef: catdefs){

	    			if(catdef.getSlideDefintionID()==slideId){

	    				contains = true;

	    			}

	    		}

	    		for(Long slide: slides){

	    			newSlideSequence.add(slide);

	    		}

	    		if(contains){

	    			newSlideSequence.add(new Long(slideId));	

	    		}

	    		newCatSlideSequence.put(cat, newSlideSequence);

	    	}

	    	newCatSlideSequence.put(new Long(-1), newAllSlideSequence);

	    	CreationUtils.storeSlideSequence(entityID, newCatSlideSequence);

    	}catch(Exception e){

    		e.printStackTrace();

    	}

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

	    	return "redirect";

    	}

    	try {

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

	    	EntityContainer ents = this.getEntityContainer();

	    	Entity entity = this.getEntity(entityID);

	    	Long catId = new Long(entity.getCategoryID());

	    	// Slides of entity's category

	    	String[] strSlideDefIDs = this.reqparams.get(

	    			new Long(entity.getCategoryID()).toString());

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

	    	List<Long> sequence= CreationUtils.getSlideSequence(entityID);

        	if(sequence == null){

        		sequence = new ArrayList<Long>();

        	}

	    	// To restore order of keys

	    	this.catSlides = new LinkedHashMap<Long, List<Long>>();

	    	List<Long> allSlideDefIDs = new ArrayList<Long>();

	    	// Add entity's category slides first

    		List<Long> slideDefIDs = new ArrayList<Long>();

    		for(String strSlideDefID : strSlideDefIDs) {

    			slideDefIDs.add(new Long(Long.parseLong(strSlideDefID)));

    			if(!sequence.contains(new Long(Long.parseLong(strSlideDefID)))){

    				sequence.add(new Long(Long.parseLong(strSlideDefID)));

    			}

    		}

    		this.catSlides.put(new Long(entity.getCategoryID()), slideDefIDs);

    		allSlideDefIDs.addAll(slideDefIDs);

        	DefinitionsContainer defs = this.getDefinitionsContainer();

			long parentCatID  = (defs.getCategory(entity.getCategoryID())).getParentCategory().getID();

        	List<Category> cats = defs.getChildrenCategories(parentCatID);

        	// Add slides borrowed from other categories

        	for(Category cat : cats) {

        		Long lCat = new Long(cat.getID());

        		String[] strCatSlideDefIDs = this.reqparams.get(

        				lCat.toString());

        		List<Long> catSlideDefIDs = new ArrayList<Long>();

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

            		for(String strCatSlideDefID : strCatSlideDefIDs) {

            			catSlideDefIDs.add(new Long(Long.parseLong(

            					strCatSlideDefID)));

            			if(!lCat.equals(catId) && !sequence.contains(new Long(Long.parseLong(strCatSlideDefID)))){

            				sequence.add(new Long(Long.parseLong(strCatSlideDefID)));

            			}

            		}

        		}

        		this.catSlides.put(lCat, catSlideDefIDs);

        	}

        	this.catSlides.remove(new Long(-1));

        	// to remove obsolete elements

        	List<Long> removeList = new ArrayList<Long>();

        	for(Long slideId: sequence){

        		boolean isContains = false;

        		for(List<Long> catwiseList: this.catSlides.values()){

        			if(catwiseList.contains(slideId)){

        				isContains = true;

        			}

        		}

        		if(!isContains){

        			removeList.add(slideId);

        		}

        	}

        	for(Long slideId: removeList){

        		sequence.remove(slideId);

        	}

        	// end 

        	this.catSlides.put(new Long(-1), sequence);

        	log.info("this.catSlides:" + this.catSlides);

    		// Store for sequence reference

	    	CreationUtils.storeSlideSequence(entityID, this.catSlides);

	    	this.catSlides.remove(new Long(-1));

	    	// Delete slides no longer present in the list

	    	List<Slide> slides = entity.getSlides();

	    	if(slides != null) {

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

		    	for(Slide slide : slides) {

		    		Long lSlideDefID = new Long(slide.getSlideDefinitionID());

		    		if(!allSlideDefIDs.contains(lSlideDefID)) {

		    			log.info("deleted lSlideDefID:" + lSlideDefID);

		    			deletedSlides.add(slide);

		    		}

		    	}

		    	for(Slide deletedSlide : deletedSlides) {

		    		slides.remove(deletedSlide);

		    	}

	    	}

			ContentValidator validator = new ContentValidator();

			if(!validator.validate(entity)) {

				CreationUtils.addToIncomplete(entity);

				// Delete from repository if incomplete

				ents.deleteEntity(entity);

			}

			else {

				ents.updateEntity(entity);

			}

	    	// Store

	    	CreationUtils.rewriteRepository(ents.getEntities(), 

	    			ents.getEntitiesbyCategory());

	    	if(this.reqparams.containsKey("save")) {

		    	this.redirectURL = "/entity";

	    	}

	    	else {

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

		    		"?slideDefID=" + slideDefIDs.get(0);

	    	}

	        return "redirect";

		} catch (Exception e) {

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

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

			return "fatal";

		}

    }

    /**

     * 

     */

	@Override

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

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

		this.reqparams = reqmap;

	}

	/**

	 * @param id the id to set

	 */

	public void setId(String id) {

		this.id = id;

	}

	/**

	 * @return the id

	 */

	public String getId() {

		return id;

	}

	/**

	 * 

	 * @return

	 */

	public List<List<String[]>> getAllSlidesData() {

		return this.allSlidesData;

	}

	/**

	 * 

	 * @return

	 */

    public String getUrl() {

    	return this.redirectURL;

    }

	/**

	 * @param errorString the exceptionString to set

	 */

	public void setErrorString(String errorString) {

	}

	/**

	 * 

	 * @return

	 */

	public List<String> getMandatorySlideLabels() {

		List<String[]> slidesdata = this.allSlidesData.get(0);

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

		for(String[] data : slidesdata) {

			if("Mandatory".equals(data[4])) {

				mandatorySlideLabels.add(data[3]);

			}

		}

		return mandatorySlideLabels;

	}

	/**

	 * 

	 * @param catID

	 * @param selection

	 * @return

	 * @throws Exception

	 */

    private List<String[]> getSlidesData(long catID, List<Long> selection, 

    		boolean isEntityCategory) throws Exception {

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

    	DefinitionsContainer defs = this.getDefinitionsContainer();

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

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

		List<CategorySlideDefinition> catSlideDefs = 

			defs.getCategorySlideDefinitions(catID);

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

		// Convert it into Map, this will help put CategorySlideDefinition

		// objects in sequence

		// FIXME - Quick and dirty

		List<Long> excludeList = new ArrayList<Long>();

		for(CategorySlideDefinition catSlideDef : catSlideDefs) {

			Long slideDefID = new Long(catSlideDef.getSlideDefintionID());

			if(!this.mapAllCatSlideDefs.containsKey(slideDefID)) {

				this.mapAllCatSlideDefs.put(slideDefID, catSlideDef);

			}

			else {

				excludeList.add(slideDefID);

			}

		}

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

		List<String[]> slidesData = new ArrayList<String[]>();

		String categoryLabel = defs.getCategory(catID).getLabel();

		for(Long slideDefID : slideDefIDs) {

			// Do not repeat if already covered

			if(excludeList.contains(slideDefID)) {

				continue;

			}

			CategorySlideDefinition catSlideDef = 

				this.mapAllCatSlideDefs.get(slideDefID);

			String slideLabel = defs.getSlideDefinition(

					catSlideDef.getSlideDefintionID()).getLabel();

			Long lSlideDefID = new Long(catSlideDef.getSlideDefintionID());

			String selected = "0";

			if(selection != null) {

				selected = selection.contains(lSlideDefID) ? "1" : "0";

			}

			else if(isEntityCategory) {

				String edImp = catSlideDef.getEditorialImportance().toString();

				selected = (edImp.equals("Mandatory") || 

					edImp.endsWith("Recommended")) ? "1" : "0";

			}

			String[] data = new String[] {

				new Long(catID).toString(),

				categoryLabel,

				lSlideDefID.toString(),

				slideLabel,

				catSlideDef.getEditorialImportance().toString(),

				selected

			};

			slidesData.add(data);

		}

		return slidesData;

	}

	/**

	 * 

	 * @return

	 */

    protected EntityContainer getEntityContainer() {

    	if(this.ents == null) {

    		this.ents = new EntityContainer();

    	}

	    return this.ents;

    }

    /**

     * 

     * @return

     */

    protected DefinitionsContainer getDefinitionsContainer() {

    	if(this.defs == null) {

    		this.defs = new DefinitionsContainer();

    	}

	    return this.defs;

    }

    /**

     * 

     * @param entityID

     * @return

     * @throws Exception 

     */

    private Entity getEntity(long entityID) throws Exception {

    	log.info("#### SlidesController.getEntity ####");

		if(this.entity == null) {

			this.entity = CreationUtils.getEntity(entityID);

		}

		return this.entity;

	}

}