Application: gvSIG desktop

package com.iver.cit.gvsig.publish.servers.mapserver;

/* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib��ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

import java.awt.geom.Rectangle2D;

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.SortedSet;

import java.util.TreeSet;

import org.gvsig.remoteservices.conf.mapserver.MapServerConfiguration.CRS;

import org.gvsig.remoteservices.conf.mapserver.MapServerConfiguration.ConfigFile;

import org.gvsig.remoteservices.conf.mapserver.MapServerConfiguration.MapLayer;

import org.gvsig.remoteservices.conf.mapserver.MapServerConfiguration.MetadataWeb;

import org.gvsig.remoteservices.conf.mapserver.MapServerConfiguration.OutputFormat;

import org.gvsig.remoteservices.conf.mapserver.MapServerConfiguration.WebMap;

import org.gvsig.remoteservices.conf.mapserver.test.AddFieldToDBF;

import com.iver.cit.gvsig.exceptions.layers.DriverLayerException;

import com.iver.cit.gvsig.exceptions.layers.FileLayerException;

import com.iver.cit.gvsig.exceptions.layers.LegendLayerException;

import com.iver.cit.gvsig.exceptions.layers.LoadLayerException;

import com.iver.cit.gvsig.exceptions.layers.NameLayerException;

import com.iver.cit.gvsig.exceptions.layers.ProjectionLayerException;

import com.iver.cit.gvsig.exceptions.layers.TypeLayerException;

import com.iver.cit.gvsig.exceptions.layers.XMLLayerException;

import com.iver.cit.gvsig.fmap.drivers.RasterDriver;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.fmap.layers.FLyrRaster;

import com.iver.cit.gvsig.publish.layers.LayerLoader;

import com.iver.cit.gvsig.publish.layers.ParamsPostGisLayerException;

import com.iver.cit.gvsig.publish.model.LayerInfo;

import com.iver.cit.gvsig.publish.model.LayerInfoFactory;

import com.iver.cit.gvsig.publish.model.ServiceInfo;

import com.iver.cit.gvsig.publish.model.ServiceInfoFactory;

import com.iver.cit.gvsig.publish.persistence.PublishPersistence;

import com.iver.cit.gvsig.publish.servers.GenericServer;

import com.iver.cit.gvsig.publish.servers.PublishControler;

import com.iver.utiles.StringUtilities;

import com.iver.utiles.swing.jcomboServer.ServerData;

/**

 * This class implements the mapserver publication. It has to

 * retrieve the current layers from gvSIG and create the

 * map file

 *

 * @author jvhigon

 *

 */

public class MapServerPublishControler extends PublishControler{

        private String dataPath = null; //"C:/ms4w/test/";

        private String fileIndex = null; //indexDir + "index.shp";

        private ConfigFile map = null;

        private String mapFile = null;

        //private String dirIndex = "/home/knoppix"; // CHANGE THIS !!: we'll use the same as the mapFile!!

        /**

         * Constructor

         */

        public MapServerPublishControler(String service) {

                super(service);

        }

        /*

         *  (non-Javadoc)

         * @see com.iver.cit.gvsig.publish.servers.PublishControler#publish(com.iver.utiles.swing.jcomboServer.ServerData)

         */

        public Object publish(ServerData serverData) {

                return publish(serverData.getServerAddress(),

                        serverData.getProperty(GenericServer.GENERIC_SERVER_PATH),

                        serverData.getProperty(MapServer.WMS_MAPFILE),

                        serverData.getProperty(MapServer.WMS_SYMBOLS),

                        serverData.getProperty(MapServer.WMS_FONTS),

                        serverData.getProperty(MapServer.WMS_IMAGEURL),

                        serverData.getProperty(MapServer.WMS_IMAGEPATH));

        }

        /**

         *

         * @param url

         * @param path

         * @param mapFile

         * @param symbolsFile

         * @param fontsFile

         * @param ImageURL

         * @param imagePath

         * @throws LayerException

         * @throws LayerException

         */

        private ConfigFile publish(String onlineResource, String path, String mapFile,

                        String symbolsFile, String fontsFile, String ImageURL,

                        String imagePath) {

                dataPath = path;

                this.mapFile = mapFile;

                map = getConfigFile(dataPath);

                map.www = getWebMapVect(onlineResource,imagePath,ImageURL);

                OutputFormat o = new OutputFormat("GEOTIFFINT16","GDAL/GTiff","INT16","tif");

                map.add(o);

                o = new OutputFormat("IMG","GDAL/HFA","BYTE","img");

                map.add(o);

                o = new OutputFormat("GEOTIFF","GDAL/GTiff","BYTE","tif");

                map.add(o);

                for (int i = 0; i < getLayers().getLayersCount(); i++) {

                        FLayer lyr = getLayers().getLayer(i);

                        if (lyr.isVisible()){

                                try{

                                        if (lyr instanceof FLayers){

                                                ArrayList layers = publishGroupLayer(map,(FLayers)lyr);

                                                for (int j=0 ; j<layers.size() ; j++){

                                                        MapLayer mapLayer = (MapLayer)layers.get(j);

                                                        if (mapLayer != null){

                                                                map.add(mapLayer);

                                                        }

                                                }

                                        }else{

                                                MapLayer mapLayer = publishSimpleLayer(lyr);

                                                if (mapLayer != null){

                                                        map.add(mapLayer);

                                                }

                                        }

                                }catch(NameLayerException e){

                                        e.printStackTrace();

                                }catch(DriverLayerException e){

                                        e.printStackTrace();

                                }catch(FileLayerException e){

                                        e.printStackTrace();

                                }catch(LegendLayerException e){

                                        e.printStackTrace();

                                }catch(ParamsPostGisLayerException e){

                                        e.printStackTrace();

                                }catch(ProjectionLayerException e){

                                        e.printStackTrace();

                                }catch(TypeLayerException e){

                                        e.printStackTrace();

                                }catch(XMLLayerException e){

                                        e.printStackTrace();

                                }catch(LoadLayerException e){

                                        e.printStackTrace();

                                }

                        }

                }

                return map;

        }

        private MapLayer publishSimpleLayer(FLayer layer) throws LoadLayerException{

                MapLayer mapLayer = new MapServerLayerFactory().getMapLayer(layer,getService());

                if (mapLayer != null){

                        if (getService().compareTo(ServerData.SERVER_TYPE_WMS) == 0){

                                mapLayer.metadata.setServiceAsWMS();

                        } else if(getService().compareTo(ServerData.SERVER_TYPE_WFS) == 0){

                                mapLayer.metadata.setServiceAsWFS();

                                mapLayer.metadata.gml_include_items = "all";

                                mapLayer.setDump(true);

                                mapLayer.classList = new ArrayList();

                        } else if(getService().compareTo(ServerData.SERVER_TYPE_WCS) == 0){

                                mapLayer.metadata.setServiceAsWCS();

                                mapLayer.setDump(true);

                        }

                }

                return mapLayer;

        }

        private ArrayList publishGroupLayer(ConfigFile config,FLayers layers) throws LoadLayerException{

                ArrayList mapLayers = new ArrayList();

                if (layers.getName().startsWith("[")){

                        if (layers.getName().startsWith("[" + LayerLoader.GROUP_LAYER_TIME)){

                                mapLayers.add(publishTimeLayer(config,layers));

                        }else if(layers.getName().startsWith("[" + LayerLoader.GROUP_LAYER_MOSAIC)){

                                mapLayers.add(publishMosaicLayer(config,layers));

                        }

                else{

                                for (int i=0 ; i<layers.getLayersCount() ; i++){

                                        mapLayers.add(publishSimpleLayer(layers.getLayer(i)));

                                }

                        }

                }else{

                        for (int i=0 ; i<layers.getLayersCount() ; i++){

                                mapLayers.add(publishSimpleLayer(layers.getLayer(i)));

                        }

                }

                return mapLayers;

        }

        private MapLayer publishMosaicLayer(ConfigFile config,FLayers layers) throws LoadLayerException{

                fileIndex = layers.getName().split("]")[1] + "_index.shp";

                MapLayer mapLayer = publishSimpleLayer(layers.getLayer(0));

                String[] sFiles = new String[layers.getLayersCount()];

                for (int i=0 ; i<sFiles.length ; i++){

                        sFiles[i] = getRasterFile(layers.getLayer(i));

                }

                mapLayer.name = layers.getName().split("]")[1];

                mapLayer.tileIndex = fileIndex;

                mapLayer.tileItem = "location";

                //mapLayer.data = layers.getName().split("]")[1];

                mapLayer.data=null;

                mapLayer.metadata.title = mapLayer.name;

                Rectangle2D extent = map.extent;

                /*try {

                        extent = layers.getFullExtent();

                } catch (DriverException e) {

                        throw new LayerException(LayerException.EXC_NO_DETECTED_EXTENT,e.getMessage());

                }*/

                mapLayer.metadata.setExtent(extent);

                //We'll write on the same directory as mapfile

                generateIndex(dataPath + "/" + fileIndex,sFiles,null);

                return mapLayer;

        }

        private MapLayer publishTimeLayer(ConfigFile config,FLayers layers) throws LoadLayerException{

                fileIndex = layers.getName().split("]")[1] + "_index.shp";

                MapLayer mapLayer = publishSimpleLayer(layers.getLayer(0));

                SortedSet times = new TreeSet();

                Hashtable files = new Hashtable();

                times.add(getTime(layers.getLayer(0).getName()));

                files.put(getTime(layers.getLayer(0).getName()),getRasterFile(layers.getLayer(0)));

                for (int i = 1; i < layers.getLayersCount(); i++) {

                        times.add(getTime(layers.getLayer(i).getName()));

                        files.put(getTime(layers.getLayer(i).getName()),getRasterFile(layers.getLayer(i)));

                }

                //Recuperar los files y los times en orden:

                Iterator it = times.iterator();

                String[] sFiles = new String[times.size()];

                String[] sTimes = new String[times.size()];

            int i = 0;

            String timeExtent = "";

                while (it.hasNext()) {

                        sTimes[i] = (String)it.next();

                        sFiles[i] = (String)files.get(sTimes[i]);

                timeExtent = timeExtent + sTimes[i];

                if (i < sTimes.length - 1){

                        timeExtent = timeExtent + ",";

                }

                i++;

            }

                String sOptions = layers.getName().split("]")[0];

                String[] options = sOptions.split(",");

                mapLayer.name = layers.getName().split("]")[1];

                config.www.metadata.timeFormat = options[1];

                mapLayer.tileIndex = fileIndex;

                mapLayer.tileItem = "location";

                //mapLayer.data = layers.getName().split("]")[1];

                mapLayer.data=null;

                mapLayer.metadata.title = mapLayer.name;

                mapLayer.metadata.timeDefault = options[2];

                mapLayer.metadata.timeExtent = timeExtent;

                mapLayer.metadata.timeItem = "date";

                generateIndex(dataPath + "/" + fileIndex,sFiles,sTimes);

                return mapLayer;

        }

        private String getRasterFile(FLayer layer){

                RasterDriver driver = ((RasterDriver)((FLyrRaster)layer).getSource().getDriver());

                return driver.getFiles()[0].getName();

        }

        private void generateIndex(String fileIndex,String[] fNames, String[] times){

                String cmd = getGDalPath() + "gdaltindex";

                String params =  fileIndex;

                for (int i=0; i<fNames.length; i++)

                        params += " "+fNames[i];

                System.out.println("Generating index.shp ...");

                try {

                        deleteIndexFile(fileIndex);

                        System.out.println(cmd+" "+params);

                        Process p = Runtime.getRuntime().exec(cmd+" "+params);

                        p.waitFor();

                        InputStream is = p.getErrorStream();

                        BufferedReader br = new BufferedReader (new InputStreamReader(is));

                        String aux = br.readLine();

                        while (aux!=null){

                                System.out.println(aux);

                                aux = br.readLine();

                        }

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }catch (InterruptedException ex){

                        ex.printStackTrace();

                }

                if (times != null){

                        try {

                                Thread.sleep(500);

                        } catch (InterruptedException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                        AddFieldToDBF dbfFile = new AddFieldToDBF();

                        String dbfFileName = fileIndex.substring(0,fileIndex.length()-4)+".dbf";

                        dbfFile.add(dbfFileName, "date", times);

                }

                System.out.println("done.");

        }

        private void deleteIndexFile(String fileIndex) {

                File f = new File(fileIndex);

                if (f.exists()) {

                        String root = fileIndex.substring(0,fileIndex.length()-4);

                        String [] exts = {"shp", "dbf", "shx"};

                        for (int i=0; i<exts.length; i++) {

                                f = new File(root+"."+exts[i]);

                                f.delete();

                        }

                }

        }

        private String getTime(String layerName){

                String time = layerName.split("]")[0];

                return StringUtilities.replace(time,"[","");

        }

        private ConfigFile getConfigFile(String path){

                ConfigFile map = new ConfigFile();

                map.mapName = "TEST_MAPSERVER";

                map.mapStatus = "ON";

                map.mapUnits = "METERS";

                map.mapShapePath = path;

                map.mapcrs = new CRS(getMapCtrl().getMapContext().getViewPort()

                                .getProjection().getAbrev(), true);

                map.setExtent(getMapCtrl().getMapContext().getViewPort().getAdjustedExtent());

                return map;

        }

        private WebMap getWebMapVect(String onlineResource,

                        String imagePath,

                        String imageURL){

                WebMap webMap = new WebMap();

                webMap.imagepath = imagePath;

                webMap.imageurl = imageURL;

                webMap.metadata = new MetadataWeb();

                webMap.metadata.crs = new CRS(getMapCtrl().getMapContext().getViewPort()

                                .getProjection().getAbrev(), false);

                webMap.metadata.title = "Published Layers";

                webMap.metadata.onlineresource = onlineResource;

                if (getService().compareTo(ServerData.SERVER_TYPE_WMS) == 0){

                        webMap.metadata.setServiceAsWMS();

                } else if(getService().compareTo(ServerData.SERVER_TYPE_WFS) == 0){

                        webMap.metadata.setServiceAsWFS();

                } else if(getService().compareTo(ServerData.SERVER_TYPE_WCS) == 0){

                        webMap.metadata.setServiceAsWCS();

                }

                return webMap;

        }

        private String getGDalPath(){

                PublishPersistence persistence = new PublishPersistence(this);

                return persistence.getGdalPath();

        }

        /*

         *  (non-Javadoc)

         * @see com.iver.cit.gvsig.publish.servers.PublishControler#getServiceInfo()

         */

        public ServiceInfo getServiceInfo() {

                if (serviceInfo == null) {

                        serviceInfo = ServiceInfoFactory.createServiceInfo(getService());

                        serviceInfo.setOws_name(map.mapName);

                        serviceInfo.setOws_SRS(map.www.metadata.crs.getCrs());

                        serviceInfo.setOws_extent(map.extent);

                        for (int i=0 ; i<map.layersCnt() ; i++){

                                MapLayer layer = map.getLayer(i);

                                LayerInfo layerInfo = LayerInfoFactory.createLayerInfo(getService());

                                layerInfo.setName(layer.name);

                                layerInfo.setTitle(layer.getTitle());

                                layerInfo.setSrs(layer.crs.getCrs());

                                layerInfo.setExtent(layer.metadata.extent);

                                serviceInfo.addLayer(layerInfo);

                        }

                }

                return serviceInfo;

        }

        /*

         *  (non-Javadoc)

         * @see com.iver.cit.gvsig.publish.servers.PublishControler#writeFile()

         */

        public void writeFile() {

                map.extent = serviceInfo.getOws_extent();

                map.www.metadata.crs.setCrs(serviceInfo.getOws_SRS());

                map.www.metadata.title = serviceInfo.getOws_title();

                map.www.metadata.abstrac = serviceInfo.getOws_abstract();

                for (int i=0 ; i<serviceInfo.getLayerList().size() ; i++){

                        LayerInfo layerInfo = serviceInfo.getLayer(i);

                        MapLayer layer = map.getLayer(i);

                        layer.name = layerInfo.getName();

                        layer.metadata.name = layerInfo.getName();

                        layer.metadata.title = layerInfo.getTitle();

                        layer.metadata.abstrac = layerInfo.getAbstrac();

                        layer.metadata.extent = layerInfo.getExtent();

                        layer.crs.setCrs(layerInfo.getSrs());

                }

                map.generate(mapFile);

        }

}