gvSIG projects pool

package org.gvsig.online.lib.impl;

import java.awt.Dimension;

import java.io.File;

import java.io.FileInputStream;

import java.net.URL;

import java.nio.charset.StandardCharsets;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.NoSuchElementException;

import javax.json.JsonArray;

import javax.json.JsonObject;

import javax.json.JsonValue;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.json.Json;

import org.gvsig.json.SupportFromJson;

import org.gvsig.online.lib.api.OnlineDownloader;

import org.gvsig.online.lib.api.OnlineLayer;

import static org.gvsig.online.lib.api.OnlineManager.FEATUREDATE_FIELD_NAME;

import static org.gvsig.online.lib.api.OnlineManager.FEATURELASTMODIFICATION_FIELD_NAME;

import static org.gvsig.online.lib.api.OnlineManager.FEATUREMODIFIEDBY_FIELD_NAME;

import static org.gvsig.online.lib.api.OnlineManager.FEATUREVERSION_FIELD_NAME;

import org.gvsig.online.lib.api.OnlineProject;

import org.gvsig.online.lib.api.OnlineSite;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public final class OnlineLayerImpl

        implements

        OnlineLayer,

        SupportFromJson {

    private static final Logger LOGGER = LoggerFactory.getLogger(OnlineLayerImpl.class);

    private JsonObject data;

    private OnlineSiteImpl site;

    private FeatureType featureType;

    private OnlineProjectImpl project;

    private Envelope envelope;

    private IProjection projection;

    private static class LayerDataImpl implements LayerData {

        private final int totalsize;

        private final int pagesize;

        private final int page;

        private final List<JsonValue> elements;

        public LayerDataImpl(int totalsize, int pagesize, int page, List<JsonValue> elements) {

            this.elements = elements;

            this.totalsize = totalsize;

            this.pagesize = pagesize;

            this.page = page;

        }

        @Override

        public int getPageElements() {

            return this.pagesize;

        }

        @Override

        public int getPage() {

            return this.page;

        }

        @Override

        public int getTotalElemens() {

            return this.totalsize;

        }

        @Override

        public Iterator<JsonObject> iterator() {

            Iterator<JsonValue> it = this.elements.iterator();

            return new Iterator<JsonObject>() {

                @Override

                public boolean hasNext() {

                    return it.hasNext();

                }

                @Override

                public JsonObject next() {

                    return (JsonObject) it.next();

                }

            };

        }

    }

    private static class LayerDataIterator implements Iterator<JsonObject> {

        private final int pageSize;

        private final OnlineLayerImpl layer;

        private final Envelope area;

        private int page;

        private LayerData theData;

        private Iterator<JsonObject> it;

        private final SimpleTaskStatus status;

        public LayerDataIterator(OnlineLayerImpl layer, Envelope area, int pageSize, SimpleTaskStatus status) {

            this.layer = layer;

            this.area = area;

            this.pageSize = pageSize;

            this.page = 0;

            this.theData = null;

            this.it = null;

            this.status = status;

        }

        @Override

        public boolean hasNext() {

            while (true) {

                if (this.theData != null) {

                    if (this.it.hasNext()) {

                        return true;

                    }

                    if (this.theData.getPageElements() < this.pageSize) {

                        return false;

                    }

                }

                this.theData = this.layer.getDataPage(this.area, this.pageSize, this.page++);

                if( this.theData == null ) {

                    return false;

                }

                if( status!=null ) {

                    this.status.setRangeOfValues(0, this.theData.getTotalElemens());

                    this.status.setCurValue(0);

                }

                this.it = this.theData.iterator();

            }

        }

        @Override

        public JsonObject next() {

            if (this.theData == null || this.it == null ) {

                if( this.hasNext() ) {

                    if( status!=null ) {

                        this.status.incrementCurrentValue();

                    }

                    return (JsonObject) this.it.next();

                }

                throw new NoSuchElementException();

            }

            if( this.it.hasNext() ) {

                if( status!=null ) {

                    this.status.incrementCurrentValue();

                }

                return (JsonObject) this.it.next();

            }

            if( this.hasNext() ) {

                if( status!=null ) {

                    this.status.incrementCurrentValue();

                }

                return (JsonObject) this.it.next();

            }

            throw new NoSuchElementException();

        }

    }

    public OnlineLayerImpl() {

    }

    public OnlineLayerImpl(OnlineSite site) {

        this.setSite(site);

    }

    public OnlineLayerImpl(OnlineSite site, JsonObject data) {

        this.setSite(site);

        this.fromJson(data);

    }

    public OnlineLayerImpl(OnlineProject project, JsonObject data) {

        this.setProject(project);

        this.fromJson(data);

    }

    public final OnlineLayerImpl setSite(OnlineSite site) {

        this.site = (OnlineSiteImpl) site;

        return this;

    }

    public final OnlineLayerImpl setProject(OnlineProject project) {

        this.project = (OnlineProjectImpl) project;

        this.site = (OnlineSiteImpl) this.project.getSite();

        return this;

    }

    @Override

    public OnlineSite getSite() {

        return this.site;

    }

    @Override

    public boolean isHidden() {

        String name = this.getName();

        if (this.project == null) {

            return false;

        }

        return StringUtils.equalsIgnoreCase(name, this.project.getConfigTableName())

                || StringUtils.equalsIgnoreCase(name, this.project.getResourcesTablaName());

    }

    @Override

    public int getId() {

        return this.data.getInt("id", -1);

    }

    @Override

    public String getName() {

        return this.data.getString("name", null);

    }

    @Override

    public String getTitle() {

        return this.data.getString("title", null);

    }

    @Override

    public String getWorkspace() {

        return this.data.getString("workspace", null);

    }

    @Override

    public String getLabel() {

        if (StringUtils.isNotBlank(this.getTitle())) {

            return this.getTitle();

        }

        if (StringUtils.isNotBlank(this.getName())) {

            return this.getName();

        }

        return String.valueOf(this.getId());

    }

    @Override

    public String getAbstract() {

        return this.data.getString("abstract", null);

    }

    @Override

    public String getType() {

        return this.data.getString("type", null);

    }

    @Override

    public int getlayerGroupId() {

        return this.data.getInt("layer_group_id", -1);

    }

    @Override

    public void fromJson(JsonObject json) {

        this.data = json;

    }

    @Override

    public String getSRS() {

        return this.data.getString("native_srs", null);

    }

    @Override

    public int getSRSCode() {

        try {

            String srs = this.getSRS();

            if (StringUtils.isBlank(srs)) {

                return 0;

            }

            return Integer.parseInt(StringUtils.split(srs, ':')[1]);

        } catch (Exception e) {

            return 0;

        }

    }

    @Override

    public String getPkName() {

        FeatureType ft = this.getFeatureType();

        FeatureAttributeDescriptor[] pk = ft.getPrimaryKey();

        if (pk == null) {

            return null;

        }

        return pk[0].getName();

    }

    @Override

    public FeatureType getFeatureType() {

        if (this.featureType != null) {

            return this.featureType;

        }

        // Se declaran las variables aqui para poder consultarlas en el catch

        int tableId = -1;

        String tableName = "unknown";        

        EditableFeatureType ftype = null;

        JsonObject description_json = null;

        JsonObject item = null;

        GeometryType geomtype = null;

        int type = DataTypes.UNKNOWN;

        int size = 0;

        File f = null;

        int precision = 0;

        int scale = 0;

        try {

            tableId = this.getId();

            tableName = this.getName();

            // TODO: Buscar en gvsigd_resources el DAL antes de recrearlo.

            OnlineDownloader downloader = this.site.getDownloader();

            URL url = this.site.getURL("/api/v1/layers/" + tableId + "/description/");

            f = downloader.get(url);

            String description_s = FileUtils.readFileToString(f, StandardCharsets.UTF_8);

            description_json = Json.createObject(description_s);

            ftype = DALLocator.getDataManager().createFeatureType();

            for (JsonValue item0 : description_json.getJsonArray("content")) {

                item = (JsonObject) item0;

                String type_online = StringUtils.lowerCase(item.getString("type", null));

                type = DataTypes.UNKNOWN;

                size = 0;

                geomtype = null;

                if (type_online == null) {

                } else if ( StringUtils.equalsAnyIgnoreCase(type_online,"integer") ) {

                    type = DataTypes.INTEGER;

                } else if ( StringUtils.equalsAnyIgnoreCase(type_online,"bigint") ) {

                    type = DataTypes.LONG;

                } else if ( StringUtils.equalsAnyIgnoreCase(type_online,"numeric") ) {

                    precision = item.getInt("precision", 0);

                    scale = item.getInt("scale",0);

                    if( precision == 0 || (precision == 19 && scale==0 ) ) {

                        type = DataTypes.LONG;

                    } else {

                        type = DataTypes.DECIMAL;

                    }

                } else if ( StringUtils.equalsAnyIgnoreCase(type_online,"character varying") ) {

                    type = DataTypes.STRING;

                    size = item.getInt("length", 50);

                } else if ( StringUtils.equalsAnyIgnoreCase(type_online,"date") ) {

                    type = DataTypes.DATE;

                } else if ( StringUtils.containsIgnoreCase(type_online,"timestamp") ) {

                    type = DataTypes.TIMESTAMP;

                } else if ( StringUtils.equalsAnyIgnoreCase(type_online,"multipolygon") ) {

                    type = DataTypes.GEOMETRY;

                    geomtype = GeometryUtils.getGeometryType(Geometry.TYPES.MULTIPOLYGON, Geometry.SUBTYPES.GEOM2D);

                } else if ( StringUtils.equalsAnyIgnoreCase(type_online,"multilinestring") ) {

                    type = DataTypes.GEOMETRY;

                    geomtype = GeometryUtils.getGeometryType(Geometry.TYPES.MULTILINE, Geometry.SUBTYPES.GEOM2D);

                }                

                String name = item.getString("name", null);

                boolean nullable = BooleanUtils.toBoolean(item.getString("nullable", null));

                boolean pk = BooleanUtils.toBoolean(item.getString("pk", null));

                boolean mandatory = item.getBoolean("mandatory", false);

                String translate = item.getString("translate", null);

                EditableFeatureAttributeDescriptor fattr = ftype.add(name, type, size);

                fattr.setIsPrimaryKey(pk);

                fattr.setAllowNull(nullable);

                fattr.setLabel(translate);

                if( geomtype!=null ) {

                    fattr.setGeometryType(geomtype);

                    fattr.setSRS(this.getProjection());

                }

                if( type == DataTypes.DECIMAL ) {

                    fattr.setPrecision(precision);

                    fattr.setScale(scale);

                }

                switch(fattr.getName().toLowerCase()) {

                    case FEATUREMODIFIEDBY_FIELD_NAME:

                    case FEATURELASTMODIFICATION_FIELD_NAME:

                    case FEATUREDATE_FIELD_NAME:

                    case FEATUREVERSION_FIELD_NAME:

                        fattr.setHidden(true);

                        break;

                }

            }

            this.featureType = ftype;

            return this.featureType;

        } catch (Exception ex) {

            throw new RuntimeException("Can't get feature type for table '" + tableName + "' (id="  + tableId+")", ex);

        }

    }

    private long getCountElements(Envelope env) {

        LayerData layerData = this.getDataPage(env, 1, 0);

        return layerData.getTotalElemens();

    }    

    @Override

    public Iterator<JsonObject> getData(Envelope env, int pageSize, SimpleTaskStatus status) {

        return new LayerDataIterator(this, env, pageSize, status);

    }

    @Override

    public LayerData getDataPage(Envelope env, int pageSize, int page) {

        FileInputStream fis = null;

        try {

            OnlineDownloader downloader = this.site.getDownloader();

            URL url = this.site.getURL("/api/v1/layers/" + this.getId() + "/featurelist?"+

                    "minlat=" + String.format(Locale.ENGLISH,"%f", env.getMinimum(Geometry.DIMENSIONS.Y)) +

                    "&minlon=" + String.format(Locale.ENGLISH,"%f", env.getMinimum(Geometry.DIMENSIONS.X)) +

                    "&maxlat=" + String.format(Locale.ENGLISH,"%f", env.getMaximum(Geometry.DIMENSIONS.Y)) +

                    "&maxlon=" + String.format(Locale.ENGLISH,"%f", env.getMaximum(Geometry.DIMENSIONS.X)) +

                    "&epsg=" + this.getSRSCode()+

                    "&max=" + pageSize +

                    "&page=" + page

            );

            File f = downloader.get(url);

//            URL url = this.site.getURL("/api/v1/layers/" + this.getId() + "/featurelist");

//            JsonObjectBuilder postdata = Json.createObjectBuilder();

//            postdata.add("minlat", env.getMinimum(Geometry.DIMENSIONS.Y));

//            postdata.add("minlon", env.getMinimum(Geometry.DIMENSIONS.X));

//            postdata.add("maxlat", env.getMaximum(Geometry.DIMENSIONS.Y));

//            postdata.add("maxlon", env.getMaximum(Geometry.DIMENSIONS.X));

//            postdata.add("epsg", this.getSRSCode());

//            postdata.add("max", 10);//pageSize);

//            postdata.add("page", 1); //page);

//            File f = downloader.post_json(url, postdata.toString());

            if( f==null ) {

                return null;

            }

            fis = new FileInputStream(f);

            JsonObject json = Json.createObject(fis);

            if (json.containsKey("content")) {

                json = json.getJsonObject("content");

            }

            int totalfeatures = json.getInt("totalfeatures", -1);

            int lendata = json.getInt("lendata", -1);

            JsonArray features = json.getJsonArray("features");            

            return new LayerDataImpl(

                    lendata,

                    totalfeatures,

                    page,

                    features

            );

        } catch (Exception ex) {

            LOGGER.warn("Can't download data",ex);

            IOUtils.closeQuietly(fis);

            return null;

        }

    }

    @Override

    public IProjection getProjection() {

        if( this.projection == null ) {

            String srs = "unknown";

            try {

                srs = this.getSRS();

                this.projection = CRSFactory.getCRS(srs);

            } catch(Exception ex) {

                LOGGER.warn("Can't create projection from '"+srs+".",ex);

            }

        }

        return this.projection;

    }

    @Override

    public Envelope getEnvelope() {

        if (this.envelope == null) {

            String s = this.data.getString("native_extent", null);

            if (s == null) {

                return null;

            }

            String[] ss = StringUtils.split(s, ',');

            this.envelope = GeometryUtils.createEnvelope(

                    Double.parseDouble(ss[0]), 

                    Double.parseDouble(ss[1]), 

                    Double.parseDouble(ss[2]), 

                    Double.parseDouble(ss[3]), 

                    Geometry.SUBTYPES.GEOM2D

            );

        }

        return this.envelope;

    }

    @Override

    public int calculateTileSize(long maxElementsInTile, SimpleTaskStatus status) {

        OnlineLayerImpl layer = this;

        TilesCalculator.CalculatorData tileData = new TilesCalculator.CalculatorData() {

            @Override

            public Envelope getEnvelope() {

                return layer.getEnvelope();

            }

            @Override

            public double getWidth() {

                Envelope env = layer.getEnvelope();

                double w = env.getLength(Geometry.DIMENSIONS.X);

                return w;

            }

            @Override

            public double getHeight() {

                Envelope env = layer.getEnvelope();

                double h = env.getLength(Geometry.DIMENSIONS.Y);

                return h;

            }

            @Override

            public long getElements(Envelope envelope) {

                return layer.getCountElements(envelope);

            }

        };

        TilesCalculator tiles = new TilesCalculator();

        Dimension n = tiles.calculateCellSize(tileData, maxElementsInTile, status);

        return n.width;

    }

    public int update(Feature feature) {

    }

    public int insert(Feature feature) {

    }

    public int delete(Feature feature) {

    }

}