gvSIG tools: Web publishing

package org.gvsig.publish.swing.impl.gui;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.IOException;

import java.security.SecureRandom;

import java.security.cert.CertificateException;

import java.security.cert.X509Certificate;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import javax.swing.BoxLayout;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JDialog;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTabbedPane;

import javax.swing.border.EmptyBorder;

import javax.swing.border.TitledBorder;

import org.apache.commons.lang.StringUtils;

import org.apache.http.conn.ssl.SSLSocketFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.ui.mdiManager.WindowInfo;

import org.gvsig.publish.PublishProperties;

import org.gvsig.publish.swing.PublishSwingManager;

import org.gvsig.publish.swing.gui.JPublishOptionPanel;

import org.gvsig.publish.swing.gui.JPublishPanel;

import org.gvsig.publish.swing.impl.gui.panels.JGeneralOptionsPanel;

import org.gvsig.publish.swing.impl.gui.panels.JMapCacheOptionsPanel;

import org.gvsig.publish.swing.impl.gui.panels.JMapProxyOptionsPanel;

import org.gvsig.publish.swing.impl.gui.panels.JPublishRemoteOptionsPanel;

import org.gvsig.publish.swing.impl.gui.panels.JServiceOptionsPanel;

import org.gvsig.publish.swing.impl.gui.panels.JTinyOWSOptionsPanel;

import org.gvsig.publish.swing.impl.gui.utils.JFileField;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.googlecode.sardine.Sardine;

import com.googlecode.sardine.impl.SardineImpl;

public class DefaultJPublishPanel extends JPanel implements JPublishPanel, Observer{

        /**

         * 

         */

        private static final long serialVersionUID = -7691929833669579018L;

        private Logger logger = LoggerFactory.getLogger(DefaultJPublishPanel.class);

        private PublishSwingManager swingManager;

        private JFileField jFileField;

        private JCheckBox options;

        private JPanel optionPanel;

        private JButton acceptButton;

        private JButton cancelButton;

        private boolean isAccepted;

        private static final String WMS_PATH = "wms";

        private static final String WFS_PATH = "wfs";

        private static final String WCS_PATH = "wcs";

        private static final String WFST_PATH = "wfst";

        private static final String WMTS_PATH = "wmts";

        private static final String MAPPROXY_PATH = "wmts";

        private JDialog dialogParent;

        private List<JPublishOptionPanel> panels = null;

        private PublishProperties properties;

        private JTabbedPane tabbed;

        private JPanel blankPanel;

        private I18nManager i18nManager;

        public DefaultJPublishPanel(PublishSwingManager manager, PublishProperties props){

                this(manager);

                if(props != null){

                        this.properties = props;

                        loadData();

                        refreshPanel();

                }

        }

        public DefaultJPublishPanel(PublishSwingManager manager){

                this.swingManager = manager;

                this.panels = new ArrayList<JPublishOptionPanel>();

                initialize();

                refreshPanel();

        }

        private void initialize() {

                setLayout(new BorderLayout());

                JPanel centerPanel = new JPanel(new BorderLayout());

                JPanel fileContainer = new JPanel();

                fileContainer.setLayout(new BoxLayout(fileContainer,BoxLayout.Y_AXIS));

                fileContainer.setBorder(new TitledBorder(this.swingManager.getTranslation("Output_folder")));

                fileContainer.add(getJFileField());

                JPanel statusPanel = new JPanel();

                statusPanel.setPreferredSize(new Dimension(450, 25));

                options = new JCheckBox(this.swingManager.getTranslation("Advanced_options"));

                options.setSelected(getPublishProperties().onlyUploadFolderContent());

                options.setEnabled(!getPublishProperties().onlyUploadFolderContent());

                options.setBorder(new EmptyBorder(0, 0, 0, 300));

                options.addActionListener(new ActionListener() {

                        public void actionPerformed(ActionEvent arg0) {

                                refreshPanel();

                        }

                });

                statusPanel.add(options);        

                fileContainer.add(statusPanel);

                centerPanel.add(fileContainer, BorderLayout.NORTH);

                blankPanel = new JPanel();

                centerPanel.add(blankPanel,BorderLayout.CENTER);

                centerPanel.add(getOptionPanel(), BorderLayout.SOUTH);

                add(centerPanel, BorderLayout.CENTER);

                add(getButtonsPanel(), BorderLayout.PAGE_END);

                setBorder(new EmptyBorder(10, 10, 0, 10));

        }

        private JPanel getButtonsPanel() {

                JPanel buttonPanel = new JPanel();

        buttonPanel.setLayout(new FlowLayout(FlowLayout.TRAILING));

                acceptButton = new JButton(this.swingManager.getTranslation("accept"));

                acceptButton.setEnabled(!StringUtils.isBlank(getJFileField().getSelectedFilePath()));

                acceptButton.addActionListener(new ActionListener() {

                        public void actionPerformed(ActionEvent arg0) {

                                if(!acceptForm()){

                                        //JOptionPane.showMessageDialog(getAsJComponent(), "Some errors.....");

                                }else{

                                        updateData();

                                        isAccepted = true;

                                        closeMainWindow();

                                }

                        }

                });

        cancelButton = new JButton(this.swingManager.getTranslation("cancel"));

        cancelButton.addActionListener(new ActionListener() {

                        public void actionPerformed(ActionEvent arg0) {

                                isAccepted = false;

                                closeMainWindow();

                        }

                });

        buttonPanel.add(cancelButton);

        buttonPanel.add(acceptButton);

        buttonPanel.setBorder(new EmptyBorder(10,0,0,0));

                return buttonPanel;

        }

        private boolean acceptForm() {

                boolean success = accept();

                Iterator<JPublishOptionPanel> it = panels.iterator();

                while(it.hasNext()){

                        JPublishOptionPanel p = (JPublishOptionPanel) it.next();

                        success = success && p.accept();

                }

                return success;

        }

        private boolean accept(){

                String servicePath = "";

                File file = new File(this.jFileField.getSelectedFilePath()

                                +servicePath

                                +File.separator+"mapfile.map");

                boolean fileExists = file.exists();

                if(!fileExists && getPublishProperties().isWMSService()){

                        servicePath = File.separator + WMS_PATH;

                        file = new File(this.jFileField.getSelectedFilePath()

                                        +servicePath

                                        +File.separator+"mapfile.map");

                        fileExists = fileExists || file.exists();

                }

                if(!fileExists && getPublishProperties().isWFSService()){

                        servicePath = File.separator + WFS_PATH;

                        file = new File(this.jFileField.getSelectedFilePath()

                                        +servicePath

                                        +File.separator+"mapfile.map");

                        fileExists = fileExists || file.exists();

                }

                if(!fileExists && getPublishProperties().isWCSService()){

                        servicePath = File.separator + WCS_PATH;

                        file = new File(this.jFileField.getSelectedFilePath()

                                        +servicePath

                                        +File.separator+"mapfile.map");

                        fileExists = fileExists || file.exists();

                }

                if(!fileExists && getPublishProperties().isWFSTService()){

                        servicePath = File.separator + WFST_PATH;

                        file = new File(this.jFileField.getSelectedFilePath()

                                        +servicePath

                                        +File.separator+"mapfile.map");

                        fileExists = fileExists || file.exists();

                }

                if(!fileExists && getPublishProperties().isWMTSService()){

                        servicePath = File.separator + WMTS_PATH;

                        file = new File(this.jFileField.getSelectedFilePath()

                                        +servicePath

                                        +File.separator+"mapfile.map");

                        fileExists = fileExists || file.exists();

                }

                if(!fileExists && getPublishProperties().isMapProxyService()){

                        servicePath = File.separator + MAPPROXY_PATH;

                        file = new File(this.jFileField.getSelectedFilePath()

                                        +servicePath

                                        +File.separator+"mapfile.map");

                        fileExists = fileExists || file.exists();

                }

                if(fileExists && !getPublishProperties().onlyUploadFolderContent()){

                        if(getPublishProperties().allowMerge() && !getPublishProperties().onlyUploadFolderContent()){

                                Object[] options = {

                                        this.swingManager.getTranslation("override"),

                                        this.swingManager.getTranslation("join_to_current"),

        //                                this.swingManager.getTranslation("merge_with_current"),

                                        this.swingManager.getTranslation("cancel")};

                                int n = JOptionPane.showOptionDialog(this,

                                        this.swingManager.getTranslation("file_exists3")+"\n"+

                                                        this.swingManager.getTranslation("file_exists2"),

                                        this.swingManager.getTranslation("file_exists"),

                                    JOptionPane.YES_NO_OPTION,

                                    JOptionPane.WARNING_MESSAGE,

                                    null,

                                    options,

                                    options[0]);

                                if(n==0){

                                        this.getPublishProperties().setOverrideCurrentProject(true);

                                        return true;

                                }

                                if(n==1){

                                        this.getPublishProperties().setOverrideCurrentProject(false);

                                        this.getPublishProperties().setJoinToCurrent(true);

                                        return true;

                                }

                                if(n==2){

        //                                 this.getPublishProperties().setOverrideCurrentProject(false);

        //                                this.getPublishProperties().setJoinToCurrent(true);

        //                        }

        //                        if(n==3){

                                        return false;

                                }

                        }else{

                                Object[] options = {

                                                this.swingManager.getTranslation("accept"),

                                                this.swingManager.getTranslation("cancel")};

                                int n = JOptionPane.showOptionDialog(this,

                                        this.swingManager.getTranslation("file_exists3")+"\n"+

                                                        this.swingManager.getTranslation("file_exists2"),

                                        this.swingManager.getTranslation("file_exists"),

                                    JOptionPane.YES_NO_OPTION,

                                    JOptionPane.WARNING_MESSAGE,

                                    null,

                                    options,

                                    options[0]);

                                if(n==1){

                                        return false;

                                }

                        }

                }

                this.getPublishProperties().setOverrideCurrentProject(true);

                return true;

        }

        protected void closeMainWindow() {

                if(this.dialogParent!=null){

                        this.dialogParent.dispose();

                }else{

                        PluginServices.getMDIManager().closeWindow(this);

                }

        }

        public PublishProperties getPublishProperties(){

                if(this.properties==null){

                        this.properties = getSwingManager().getPublishManager().createProperties("Mapserver");

                }

                return this.properties;

        }

        private JPanel getOptionPanel() {

                if(this.optionPanel == null){

                        initializeOptionPanels();

                        this.optionPanel = new JPanel();

                        this.optionPanel.setBorder(new TitledBorder(this.swingManager.getTranslation("Advanced_options")+":"));

                        this.optionPanel.setPreferredSize(new Dimension(464, 250));

                        tabbed = new JTabbedPane();

                        Iterator<JPublishOptionPanel> it = panels.iterator();

                        while(it.hasNext()){

                                JPublishOptionPanel p = (JPublishOptionPanel) it.next();

                                tabbed.add(p.getName(), p.getAsJComponent());

                        }

                        this.optionPanel.add(tabbed);

                        this.optionPanel.setVisible(false);

                }

                return optionPanel;

        }

        public JTabbedPane getTabPanel(){

                return tabbed;

        }

        private void initializeOptionPanels() {

                if(!getPublishProperties().onlyUploadFolderContent()){

                        panels.add(new JServiceOptionsPanel(getSwingManager()));

                        panels.add(new JTinyOWSOptionsPanel((getSwingManager())));

                        panels.add(new JMapCacheOptionsPanel((getSwingManager())));

                        panels.add(new JMapProxyOptionsPanel((getSwingManager())));

                        panels.add(new JGeneralOptionsPanel(getSwingManager()));

                }else{

                        panels.add(new JPublishRemoteOptionsPanel(getSwingManager()));

                        panels.add(new JGeneralOptionsPanel(getSwingManager()));

                        options.setVisible(false);

                }

        }

        private JFileField getJFileField(){

                if(this.jFileField==null){

                        jFileField = new JFileField(null, "...");

                        jFileField.setMode(JFileField.MODE_OPEN);

                        jFileField.getFileChooser().setCurrentDirectory(new File(System.getProperty("user.home")));

                        jFileField.addObserver(this);

                }

                return this.jFileField;

        }

        public void update(Observable observable, Object notification) {

                if(observable instanceof JFileField){

                        acceptButton.setEnabled(true);

                 }

        }

        public PublishSwingManager getSwingManager() {

                return this.swingManager;

        }

        public void setParentDialog(JDialog parent){

                this.dialogParent = parent;

        }

        private void loadData() {

                if(!StringUtils.isBlank(getPublishProperties().getMapFile())){

                        this.jFileField.setFile(getPublishProperties().getMapFile());

                        this.acceptButton.setEnabled(true);

                }

                Iterator<JPublishOptionPanel> it = panels.iterator();

                while(it.hasNext()){

                        JPublishOptionPanel p = (JPublishOptionPanel) it.next();

                        p.loadData();

                }

        }

        private void updateData(){

                getPublishProperties().setMapFile(this.jFileField.getSelectedFilePath());

                Iterator<JPublishOptionPanel> it = panels.iterator();

                while(it.hasNext()){

                        JPublishOptionPanel p = (JPublishOptionPanel) it.next();

                        p.updateData();

                }

        }

        public void addPublishServicePropertiesPanel(JPublishOptionPanel panel){

                panels.add(panel);

                tabbed.add(panel.getName(), panel.getAsJComponent());

                refreshPanel();

        }

        private void refreshPanel() {

                this.optionPanel.setVisible(options.isSelected());

                optionPanel.setEnabled(options.isSelected());

                tabbed.setEnabled(options.isSelected());

                Iterator<JPublishOptionPanel> it = panels.iterator();

                while(it.hasNext()){

                        JPublishOptionPanel p = (JPublishOptionPanel) it.next();

                        p.refreshPanel(options.isSelected());

                }

                if(dialogParent != null){

                        if(options.isSelected()){

                                this.blankPanel.setBorder(new EmptyBorder(10,0,0,0));

                                this.dialogParent.setSize(510, 500);

                                this.dialogParent.pack();

                        }else{

                                this.blankPanel.setBorder(new EmptyBorder(0,0,0,0));

                                this.dialogParent.setSize(510, 150);

                                this.dialogParent.pack();

                        }

                }

                this.getAsJComponent().repaint();

                this.getAsJComponent().revalidate();

        }

        public JPanel getAsJComponent() {

                return this;

        }

        public WindowInfo getWindowInfo() {

                WindowInfo m_viewinfo = new WindowInfo(WindowInfo.MODALDIALOG

                                | WindowInfo.RESIZABLE);

                m_viewinfo

                                .setTitle(PluginServices.getText(this, this.swingManager.getTranslation("_publish_resource")));

                m_viewinfo.setWidth(510);

                m_viewinfo.setHeight(560);

                return m_viewinfo;

        }

        public Object getWindowProfile() {

                return WindowInfo.PROPERTIES_PROFILE;

        }

        public boolean isAccepted() {

                return this.isAccepted;

        }

}