Subversion Repositories SmartDukaan

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

import in.shop2020.creation.util.ContentValidator;
import in.shop2020.creation.util.CreationUtils;
import in.shop2020.creation.util.Media;
import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.FreeformContent;
import in.shop2020.metamodel.core.Slide;
import in.shop2020.metamodel.definitions.Catalog;
import in.shop2020.metamodel.definitions.EntityContainer;
import in.shop2020.metamodel.util.ExpandedEntity;
import in.shop2020.util.DBUtils;
import in.shop2020.util.Utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLDecoder;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

import org.apache.commons.io.IOUtils;
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.rest.DefaultHttpHeaders;
import org.apache.struts2.rest.HttpHeaders;

/**
 * @author naveen
 *
 */
@Results({
    @Result(name="success", type="redirectAction", 
                params = {"actionName" , "media"}),
    @Result(name="redirect", location="${url}", type="redirect")
})
public class MediaController {
        
        /**
         * 
         */
        private static Log log = LogFactory.getLog(MediaController.class);
        
        /**
         * 
         */
        private String id;
        private String entityID;
        private String slideID;
        private String label;
        private File pic;
        private String picContentType;
        private String picFileName;
        private String fileSystemPath;
        private String redirectURL;
        private String errorString;
        private String youtubeURL;

        private Map<String, Media> rawMedia;

        
    // GET /media
    public HttpHeaders index() {
        log.info("MediaController.index");
        
        return new DefaultHttpHeaders("index").disableCaching();
    }

    // GET /media
    public String create() {
        log.info("MediaController.create");
        
        try {
                log.info("getPicFileName:" + this.getPicFileName());
                log.info("getFileSystemPath:" + this.getFileSystemPath());
                log.info("getPicContentType:" + this.getPicContentType());
                
                boolean hasdata = false;
                String location = "";
                String type = "";
                if(this.getPic() != null) {
                        type = "image";
                        location = this.storeFile();
                        hasdata = true;
                } 
                else if(this.getYoutubeURL() != null) {
                        type = "youtube";
                        location = this.getYoutubeURL();
                        hasdata = true;
                }
                
                log.info("location:" + location);
                log.info("label:" + this.getLabel());
                
                if(hasdata) {
                        Media media = new Media(this.getLabel(), type, location);
                        
                        if(this.getPic() != null) {
                                media.setFileName(this.getPicFileName());
                                media.setContentType(this.getPicContentType());
                        }
                        else {
                                media.setFileName("");
                                media.setContentType("");
                        }
                        this.addMedia(media);
                        log.info("entity ID:" + this.entityID);
                        log.info("slide ID:" + this.slideID);
                        EntityContainer enContainer = Catalog.getInstance().getEntityContainer();
                        Entity entity = enContainer.getEntity(Long.parseLong(this.entityID));
                        FreeformContent freeformContent = entity.getSlide(Long.parseLong(this.slideID)).getFreeformContent();
                        freeformContent.addMedia(media.getType(), media.getLabel());
                        entity.getSlide(Long.parseLong(slideID)).setFreeformContent(freeformContent);
                        updateEntity(entity);
                        //CreationUtils.storeEntity(entity);
                }

                } catch (Exception e) {
                        log.error(CreationUtils.getStackTrace(e));
                        this.setErrorString(CreationUtils.getStackTrace(e));
                        return "fatal";
                }

                this.redirectURL = "media?entityID=" + this.getEntityID() + "&slideID=" + this.getSlideID();;
        
                return "redirect";
    }

    // DELETE /entity/1000001
    /**
     * 
     */
    public String destroy() {
        log.info("MediaController.destroy");
        try {
                long entityID = Long.parseLong(this.getEntityID());
                long slideID = Long.parseLong(this.getSlideID());
                String label = this.getId();
                log.info("label:" + label);
                log.info("slide:" + label);
                log.info("entity:" + label);
                
                label = URLDecoder.decode(label, "UTF-8");
                
                CreationUtils.removeMedia(entityID, label);
                
                Entity entity = Catalog.getInstance().getEntityContainer().getEntity(entityID);
                        FreeformContent freeformContent = entity.getSlide(slideID).getFreeformContent(); 
                        freeformContent.removeMedia("youtube",label);
                        freeformContent.removeMedia("image",label);
                        entity.getSlide(slideID).setFreeformContent(freeformContent);
                        updateEntity(entity);
                        //CreationUtils.storeEntity(entity);
                        
                } catch (Exception e) {
                        log.error(CreationUtils.getStackTrace(e));
                        this.setErrorString(CreationUtils.getStackTrace(e));
                        return "fatal";
                }

                this.redirectURL = "media?entityID=" + this.getEntityID() + "&slideID=" + this.getSlideID();
        
                return "redirect";
    }
    /**
     * 
     * @return
     * @throws Exception 
     */
    public Collection<Media> getMedia() throws Exception {
        Collection<Media> allMedia = null;
        if(this.rawMedia == null) {
                this.rawMedia = this.getRawMedia();
                
                if(this.rawMedia != null) {
                        allMedia = rawMedia.values();
                }
        }
        
                return allMedia;
    }
        /**
         * @param id the id to set
         */
        public void setSlideID(String id) {
                this.slideID = id;
                log.info("token 2:" + this.slideID);

//              StringTokenizer tokenizer = new StringTokenizer(id,"_");
//              log.info("id:" + id);
//              log.info("token 1:" + tokenizer.nextToken());
//              log.info("token 2:" + tokenizer.nextToken());
//              this.slideID = tokenizer.nextToken();
//              log.info("token 2:" + this.slideID);
        }
        /**
         * @return the id
         */
        public String getSlideID() {
                return slideID;
        }
        /**
         * @param id the id to set
         */
        public void setEntityID(String id) {
                this.entityID = id;
                log.info("token 2:" + this.entityID);
                
//              StringTokenizer tokenizer = new StringTokenizer(id,"_");
//              this.entityID = tokenizer.nextToken();
//              log.info("id:" + id);
//              log.info("token 2:" + this.entityID);
//              log.info("token 2:" + tokenizer.nextToken());
//              this.slideID = tokenizer.nextToken();
//              log.info("token 3:" + this.slideID);
        }
        /**
         * @return the id
         */
        public String getEntityID() {
                return entityID;
        }
        /**
         * @param label the label to set
         */
        public void setLabel(String label) {
                this.label = label;
        }

        /**
         * @return the label
         */
        public String getLabel() {
                return label;
        }

        /**
         * @param pic the pic to set
         */
        public void setPic(File pic) {
                this.pic = pic;
        }
        /**
         * @return the pic
         */
        public File getPic() {
                return pic;
        }
        /**
         * @param picContentType the picContentType to set
         */
        public void setPicContentType(String picContentType) {
                this.picContentType = picContentType;
        }
        /**
         * @return the picContentType
         */
        public String getPicContentType() {
                return picContentType;
        }
        /**
         * @param picFileName the picFileName to set
         */
        public void setPicFileName(String picFileName) {
                this.picFileName = picFileName;
        }
        /**
         * @return the picFileName
         */
        public String getPicFileName() {
                return picFileName;
        }
        /**
         * @param fileSystemPath the fileSystemPath to set
         */
        public void setFileSystemPath(String fileSystemPath) {
                this.fileSystemPath = fileSystemPath;
        }
        /**
         * @return the fileSystemPath
         */
        public String getFileSystemPath() {
                return fileSystemPath;
        }

    /**
         * @param youtubeURL the youtubeURL to set
         */
        public void setYoutubeURL(String youtubeURL) {
                this.youtubeURL = youtubeURL;
        }

        /**
         * @return the youtubeURL
         */
        public String getYoutubeURL() {
                return youtubeURL;
        }

        public String getUrl() {
        return this.redirectURL;
    }

        /**
         * @param errorString the exceptionString to set
         */
        public void setErrorString(String errorString) {
                this.errorString = errorString;
        }

        /**
         * @return the exceptionString
         */
        public String getErrorString() {
                return errorString;
        }
        
        /**
         * 
         * @param media
         * @throws Exception
         */
        private void addMedia(Media media) throws Exception {
                Map<String, Media> rawMedia = this.getRawMedia();
                
                if(rawMedia == null) {
                        rawMedia = new HashMap<String, Media>();
                }
                rawMedia.put(media.getLabel(), media);
                
                DBUtils.store(rawMedia, Utils.MEDIA_DB_PATH + this.getEntityID() + 
                                ".ser");
        }

    
    /**
     * @throws Exception 
     * 
     */
    private Map<String, Media> getRawMedia() throws Exception {
        if(this.rawMedia == null) {
                this.rawMedia = CreationUtils.getRawMedia(
                                Long.parseLong(this.getEntityID()));
        }
        
        return this.rawMedia;
    }
    
        /**
         * 
         * @throws Exception
         */
        private String storeFile() throws Exception {
                String mediaDirPath = Utils.MEDIA_DB_PATH + this.getEntityID();
                File mediaDir = new File(mediaDirPath);
                if(!mediaDir.exists()) {
                        mediaDir.mkdir();
                }
                
                String mediaFileName = mediaDirPath + "/" + this.getPicFileName();
                File mediaFile = new File(mediaFileName);
                mediaFile.createNewFile();

                File uploadedPicFile = this.getPic();

                InputStream in = new FileInputStream(uploadedPicFile);
                
                // appending output stream
                OutputStream out = new FileOutputStream(mediaFile, true); 
                
                try {
                        IOUtils.copy(in, out);
                }
                finally {
                        IOUtils.closeQuietly(in);
                        IOUtils.closeQuietly(out);
                }
                
                return mediaFileName;
        }

        /**
         * @param id the id to set
         */
        public void setId(String id) {
//              StringTokenizer tokenizer = new StringTokenizer(id,"_");
//              log.info("id:" + id);
//              this.id = tokenizer.nextToken();
//              log.info("token 1:" + tokenizer.nextToken());
//              this.slideID = tokenizer.nextToken();
//              log.info("token 2:" + this.slideID);
                log.info("id:" + id);
                this.id = id;
        }

        /**
         * @return the id
         */
        public String getId() {
                return id;
        }
        
        
    /**
     * 
     * @param entity
     * @throws Exception
     */
        private void updateEntity(Entity entity) throws Exception {             
                log.info("#### EntityController.updateEntity ####");
                EntityContainer entContainer = Catalog.getInstance().getEntityContainer();
                
                ContentValidator validator = new ContentValidator();
                if(!validator.validate(entity)) {
                        CreationUtils.addToIncomplete(entity);
                        
                        // Delete from repository if incomplete
                        entContainer.deleteEntity(entity);
                }
                else {
                        CreationUtils.deleteFromIncomplete(entity);
                        
                        entContainer.updateEntity(entity);
                }
                
                CreationUtils.storeEntity(entity);
                
                this.updateRepository();
        }

        /**
         * 
         * @throws Exception
         */
        private void updateRepository() throws Exception {      
                EntityContainer entContainer = Catalog.getInstance().getEntityContainer();
                
                Map<Long, Entity> entities = entContainer.getEntities();
                log.info("entities.size():" + entities.size());
                
                Map<Long, List<Entity>> entitiesByCategory = 
                        entContainer.getEntitiesbyCategory();
                log.info("entitiesByCategory.size():" + entitiesByCategory.size());
                
                CreationUtils.rewriteRepository(entities, entitiesByCategory);
        }

}