Subversion Repositories SmartDukaan

package in.shop2020.creation.controllers;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
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 in.shop2020.metamodel.core.Bullet;
import in.shop2020.metamodel.core.Entity;
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.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 org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.struts2.rest.DefaultHttpHeaders;
import org.apache.struts2.rest.HttpHeaders;

import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.apache.struts2.interceptor.ParameterAware;

import org.apache.commons.lang.StringUtils;

@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(this.getStackTrace(e));
                        this.setErrorString(this.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(this.getStackTrace(e));
                        this.setErrorString(this.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(this.getStackTrace(e));
                        this.setErrorString(this.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);
                        
                        // Save or Next or Prev - When editing a slide
                        int currentSlideIndex = 0;
                        if(currentSlideID != 0L) {
                                currentSlideIndex = slideIDs.indexOf(new Long(currentSlideID));
                                log.info("currentSlideIndex:" + currentSlideIndex);

                                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(this.reqparams.containsKey("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(this.reqparams.containsKey("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(this.getStackTrace(e));
                        this.setErrorString(this.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();

                        String featureDefIDString = 
                                new Long(featureDefinitionID).toString();

                        String[] bulletValues = this.reqparams.get(featureDefIDString);
                        if(bulletValues == null || bulletValues.length == 0) {
                                continue;
                        }
                        
                        Feature feature = new Feature(featureDefinitionID);
                        
                        // Bullets
                        List<Bullet> bullets = new ArrayList<Bullet>();
                        FeatureDefinition featureDef = defs.getFeatureDefinition(
                                        featureDefinitionID);
                        
                        ExpandedFeatureDefinition expFeatureDef = 
                                new ExpandedFeatureDefinition(featureDef);
                        
                        ExpandedBulletDefinition expBulletDef = 
                                expFeatureDef.getExpandedBulletDefinition();
                        
                        // Composite
                        if(expBulletDef.isComposite()) {
                                
                        }
                        
                        // Enumerated
                        else if(expBulletDef.isEnumerated()) {
                                
                        }
                        
                        // Primitive
                        else {
                                Bullet bullet = new Bullet(
                                                new PrimitiveDataObject(bulletValues[0]));
                                
                                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[] imgURLs = this.reqparams.get(ID + "_image_url");
                if(imgURLs != null) {
                        ffc.setImageURLs(Arrays.asList(imgURLs));
                }
                
                String[] youtubeURLs = 
                        this.reqparams.get(ID + "_youtube_url");
                if(youtubeURLs != null) {
                        ffc.setYoutubeURLs(Arrays.asList(youtubeURLs));
                }
                
                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 {
                EntityContainer ents = this.getEntityContainer();
                List<ExpandedBullet> learnedBullets = 
                        ents.getLearnedBullets(featureDefinitionID);
                
                if(learnedBullets == null) {
                        return "";
                }
                
                List<String> learnedValues = new ArrayList<String>();
                for(ExpandedBullet expBullet : learnedBullets) {
                        learnedValues.add(expBullet.getValue());
                }
                
                return "\"" + StringUtils.join(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);
        }
        
        /**
         * 
         * @param aThrowable
         * @return
         */
        private String getStackTrace(Throwable aThrowable) {
            final Writer result = new StringWriter();
            final PrintWriter printWriter = new PrintWriter(result);
            aThrowable.printStackTrace(printWriter);
            return result.toString();
        }

}