| gvSIG desktop 1

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.File;

import java.io.IOException;

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.WebMap;

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

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.LayerException;

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

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 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;

                map = getConfigFile(dataPath);                

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

                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(LayerException e){                                        

                                }

                        }

                } 

                map.generate(mapFile);

                return map;

        }        

        private MapLayer publishSimpleLayer(FLayer layer) throws LayerException{

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

                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 LayerException{

                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 if(layers.getName().startsWith("[" + LayerLoader.GROUP_LAYER_MOSAIC)){

                        //        mapLayers.add(publishWCSLayer(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 publishWCSLayer(ConfigFile config,FLayers layers) throws LayerException{

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

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

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

                mapLayer.tileIndex = fileIndex;

                mapLayer.tileItem = "location";

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

                mapLayer.metadata.name = mapLayer.name;

                mapLayer.metadata.label = mapLayer.name;

                //maplayer.metadata.srs = mapLayer.name;

                Rectangle2D extent = map.extent;

                mapLayer.metadata.setExtent(extent);

                //mapLayer.metadata.formats = mapLayer.name;

                //mapLayer.metadata.nativeFormat = mapLayer.name;

                mapLayer.metadata.setRangeset(" ");

                //mapLayer.metadata.bandCount = mapLayer.name;

                //falta alimentar los metadata...

                return mapLayer;

        }

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

                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 LayerException{

                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);

                        Runtime.getRuntime().exec(cmd+" "+params);

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                if (times != null){

                        try {

                                Thread.sleep(200);

                        } 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();        

        }

}