Subversion Repositories SmartDukaan

/**
 * 
 */
package in.shop2020.creation.controllers;

import in.shop2020.creation.util.CreationUtils;
import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.Slide;
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.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 String errorString;
        private EntityContainer ents;
        private DefinitionsContainer defs;
        private List<List<String[]>> allSlidesData = 
                new ArrayList<List<String[]>>();
        
        Map<Long, CategorySlideDefinition> mapAllCatSlideDefs = 
                new HashMap<Long, CategorySlideDefinition>();

        /**
         * 
         * @return
         */
    public String edit() {
        log.info("SlidesController.edit");

        long entityID = Long.parseLong(this.getId());
        log.info("entityID:" + entityID);
        
        EntityContainer ents = this.getEntityContainer();
        DefinitionsContainer defs = this.getDefinitionsContainer();
        
        try {
                Entity entity = ents.getEntity(entityID);
                        
                List<Long> selection = CreationUtils.getSlideSequence(entityID);
                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
                        List<Category> cats = defs.getChildrenCategories(10001);
                        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");
        
        String[] strSlideDefIDs = this.reqparams.get("slides");
        log.info("strSlideDefIDs:" + Arrays.toString(strSlideDefIDs));
        
        try {
                List<Long> slideDefIDs = new ArrayList<Long>();
                for(String strSlideDefID : strSlideDefIDs) {
                        slideDefIDs.add(new Long(Long.parseLong(strSlideDefID)));
                }
                
                // Store for sequence reference
                long entityID = Long.parseLong(this.getId());
                CreationUtils.storeSlideSequence(entityID, slideDefIDs);
                
                // Delete slides no longer present in the list
                EntityContainer ents = this.getEntityContainer();
                Entity entity = ents.getEntity(entityID);
                
                List<Slide> deletedSlides = new ArrayList<Slide>();
                
                List<Slide> slides = entity.getSlides();
                for(Slide slide : slides) {
                        Long lSlideDefID = new Long(slide.getSlideDefinitionID());
                        
                        if(!slideDefIDs.contains(lSlideDefID)) {
                                log.info("deleted lSlideDefID:" + lSlideDefID);
                                deletedSlides.add(slide);
                        }
                }
                
                for(Slide deletedSlide : deletedSlides) {
                        slides.remove(deletedSlide);
                }
                
                //entity.setSlides(slides);
                //ents.updateEntity(entity);
                
                // Store
                CreationUtils.rewriteEntityDB(ents.getEntities(), 
                                ents.getEntitiesbyCategory());
                
                this.redirectURL = "/entity/" + this.getId() + "/edit" +
                        "?slideDefID=130001";
                        
                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) {
                this.errorString = 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 {
        DefinitionsContainer defs = this.getDefinitionsContainer();
                List<Long> slideDefIDs = defs.getCategorySlideSequence(catID);
                
                List<CategorySlideDefinition> catSlideDefs = 
                        defs.getCategorySlideDefinitions(catID);
                
                // 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);
                        }
                }
                
                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;
    }
}