/**
    * This file Copyright (c) 2013 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.commands.impl;
  
  import info.magnolia.cms.security.AccessDeniedException;
  import info.magnolia.cms.security.AccessManager;
  import info.magnolia.cms.security.Permission;
  import info.magnolia.context.Context;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.importexport.DataTransporter;
  import info.magnolia.repository.RepositoryConstants;
  
  import java.io.OutputStream;
  
  import org.apache.commons.lang.StringEscapeUtils;
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Generic Export Command.<br>
   * <br>
   * 
   * Get as Input parameter: <br>
   * Workspace and node path to export <br>
   * <br>
   * Set as output: <br>
   * Fill the OutputStream with an XML representation of the Node structure<br>
   * Define the MimeType and File name.
   */
  public class ExportCommand extends BaseRepositoryCommand {
  
      private static final Logger log = LoggerFactory.getLogger(ExportCommand.class);
  
      public static final String MIME_TEXT_XML = "application/octet-stream";
      public static final String MIME_GZIP = "application/x-gzip";
      public static final String MIME_APPLICATION_ZIP = "application/zip";
  
      private String ext = ".xml";
      public static final String EXPORT_EXTENSION = "ext";
      private boolean format = true;
      public static final String EXPORT_FORMAT = "format";
      private boolean keepHistory = true;
      public static final String EXPORT_KEEP_HISTORY = "keepHistory";
      private String fileName;
      public static final String EXPORT_FILE_NAME = "fileName";
      private String mimeExtension;
      public static final String EXPORT_MIME_EXTENSION = "mimeExtension";
      private OutputStream outputStream;
      public static final String EXPORT_OUTPUT_STREAM = "outputStream";
  
      @Override
      public boolean execute(Context context) throws Exception {
          setRepository(StringUtils.isBlank(getRepository()) ? RepositoryConstants.WEBSITE : getRepository());
          setPath(StringUtils.isBlank(getPath()) ? "/" : getPath());
  
          log.debug("Will export content from {} repository with uuid {} and path {}", new Object[] { getRepository(), getUuid(), getPath() });
  
          // Check Permission
          if (!checkPermissions(getRepository(), getPath(), Permission.READ)) {
              // escape to prevent XSS attack
              throw new AccessDeniedException("Read permission needed for export. User not allowed to READ path [" + StringEscapeUtils.escapeHtml(getPath()) + "]");
          }
          // Define the MimeType based on the extension
          setMimeExtension(getContentType(ext));
  
          String pathName = DataTransporter.createExportPath(getPath());
          pathName = DataTransporter.encodePath(pathName, DataTransporter.DOT, DataTransporter.UTF8);
         if (DataTransporter.DOT.equals(pathName)) {
             // root node
             pathName = StringUtils.EMPTY;
         }
 
         try {
             // Create the XML representation of the Node structure
             DataTransporter.executeExport(getOutputStream(), keepHistory, format, MgnlContext.getJCRSession(getRepository()), getPath(), getRepository(), getExt());
             // Set the file name.
             setFileName(getRepository() + pathName + getExt());
         } catch (RuntimeException e) {
             throw e;
         }
 
         return true;
     }
 
     /**
      * Uses access manager to authorize this request.
      * 
      * @return boolean true if read access is granted
      */
     public boolean checkPermissions(String repository, String basePath, long permissionType) {
 
         AccessManager accessManager = MgnlContext.getAccessManager(repository);
         if (accessManager != null) {
             if (!accessManager.isGranted(basePath, permissionType)) {
                 return false;
             }
         }
         return true;
     }
 
     /**
      * Define the Content Type based on the requested extension.
      */
     private String getContentType(String ext) {
         if (ext.equalsIgnoreCase(DataTransporter.ZIP)) {
             return MIME_APPLICATION_ZIP;
         } else if (ext.equalsIgnoreCase(DataTransporter.GZ)) {
             return MIME_GZIP;
         } else {
             return MIME_TEXT_XML;
         }
     }
 
     /**
      * @return the ext
      */
     public String getExt() {
         return ext;
     }
 
     /**
      * @param ext
      *            the ext to set
      */
     public void setExt(String ext) {
         this.ext = ext;
     }
 
     /**
      * @return the format
      */
     public boolean isFormat() {
         return format;
     }
 
     /**
      * @param format
      *            the format to set
      */
     public void setFormat(boolean format) {
         this.format = format;
     }
 
     /**
      * @return the keepHistory
      */
     public boolean isKeepHistory() {
         return keepHistory;
     }
 
     /**
      * @param keepHistory
      *            the keepHistory to set
      */
     public void setKeepHistory(boolean keepHistory) {
         this.keepHistory = keepHistory;
     }
 
     /**
      * @return the fileName
      */
     public String getFileName() {
         return fileName;
     }
 
     /**
      * @param fileName
      *            the fileName to set
      */
     public void setFileName(String fileName) {
         this.fileName = fileName;
     }
 
     /**
      * @return the outputStream
      */
     public OutputStream getOutputStream() {
         return outputStream;
     }
 
     /**
      * @param outputStream
      *            the outputStream to set
      */
     public void setOutputStream(OutputStream outputStream) {
         this.outputStream = outputStream;
     }
 
     /**
      * @return the mimeExtension
      */
     public String getMimeExtension() {
         return mimeExtension;
     }
 
     /**
      * @param mimeExtension
      *            the mimeExtension to set
      */
     public void setMimeExtension(String mimeExtension) {
         this.mimeExtension = mimeExtension;
     }
 
 }