Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.creation.controllers;

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

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

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

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

@InterceptorRefs({

    @InterceptorRef("myDefault"),

    @InterceptorRef("login")

})

@Results({

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

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

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

})

public class SlidesController extends BaseController {

	/**

	 * 

	 */

	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 DefinitionsContainer defs = Catalog.getInstance().getDefinitionsContainer();

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

	/**

	 * Key: Slide Definition Id

	 * Value: Category Slide Definition

	 */

	private Map<Long, CategorySlideDefinition> mapAllCatSlideDefs = 

		new HashMap<Long, CategorySlideDefinition>();

	private Entity entity;

	/**

	 * 

	 * @return

	 */

    public String edit() {

    	log.info("SlidesController.edit");

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

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

    	try {

    		entity = CreationUtils.getEntity(entityID);

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

    		List<Long> selection = entity.getSlideSequence();

    		if(selection == null){

    			entity.setSlideSequence(Catalog.getInstance().getDefinitionsContainer().getCategorySlideSequence(entity.getCategoryID()));

    			CreationUtils.updateEntity(entity);

    			selection = entity.getSlideSequence();

    		}

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

					if(!thisSlidesData.isEmpty()){

						this.allSlidesData.add(thisSlidesData);

					}

				}

			}

		} catch (Exception e) {

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

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

			return "fatal";

		}

    	return "edit";

    }

    public String show(){

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

			String itemlist = this.reqparams.get("sequence")[0];

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

			try {

				this.entity = CreationUtils.getEntity(entityID);

				List<Long> slideSequence = entity.getSlideSequence();

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

				String[] items = itemlist.split("-");

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

					newSlideSequence.add(slideSequence.get(Integer.parseInt(items[i]))); 

				}

				entity.setSlideSequence(newSlideSequence);

				CreationUtils.updateEntity(entity);

			} catch (Exception e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

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

    	return "redirect";

    }

    /**

     * 

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

    		}

    	}

    	//FIXME

    	/*  Need to fix me while reordering

    	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{

    		entity = CreationUtils.getEntity(entityID);

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

	    	Map<Long, List<Long>> catSlideSequence = defs.getCategorySlideSequence();

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

	    		}	

	    	}

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

	    	entity.setSlideSequence(newAllSlideSequence);

    	}catch(Exception e){

    		e.printStackTrace();

    	}

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

	    	return "redirect";

    	}

    	*/

    	try {

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

    		entity = CreationUtils.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= entity.getSlideSequence();

	    	log.info("S1"+sequence);

        	if(sequence == null){

        		sequence = new ArrayList<Long>();

        		entity.setSlideSequence(sequence);

        	}

	    	// 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)));

    			}

    		}

        	log.info("S2"+sequence);

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

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

            		for(String strCatSlideDefID : strCatSlideDefIDs) {

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

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

            				log.info("S3"+sequence);

            			}

            		}

        		}

        	}

        	//FIXME To remove not required slide ids and slides

        	// 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);

        		}

        	}

        	log.info("To remove"+removeList);

        	for(Long slideId: removeList){

        		sequence.remove(slideId);

        	}

        	*/

        	// end 

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

		    		log.info(sequence);

		    		if(!sequence.contains(lSlideDefID)) {

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

		    			deletedSlides.add(slide);

		    		}

		    	}

		    	for(Slide deletedSlide : deletedSlides) {

		    		slides.remove(deletedSlide);

		    	}

	    	}

	    	CreationUtils.updateEntity(entity);

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

		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;

			}

			// Category slide definition for the slide def id. 

			CategorySlideDefinition catSlideDef = this.mapAllCatSlideDefs.get(slideDefID);

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

			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;

	}

    public List<Long> getSlideSequence(){

    	return this.entity.getSlideSequence();

    }

}