Revision 2608 org.gvsig.vectorediting/trunk/org.gvsig.vectorediting/org.gvsig.vectorediting.lib/org.gvsig.vectorediting.lib.impl/src/main/java/org/gvsig/vectorediting/lib/impl/DefaultEditingProviderManager.java

View differences:

DefaultEditingProviderManager.java
25 25
package org.gvsig.vectorediting.lib.impl;
26 26

  
27 27
import java.net.URL;
28
import java.util.ArrayList;
28 29
import java.util.HashMap;
29 30
import java.util.Iterator;
31
import java.util.List;
30 32
import java.util.Map;
31 33
import java.util.Properties;
32

  
33
import org.slf4j.Logger;
34
import org.slf4j.LoggerFactory;
35

  
34
import java.util.function.Predicate;
35
import javax.json.JsonArray;
36
import javax.json.JsonObject;
37
import javax.json.JsonValue;
38
import org.apache.commons.lang3.StringUtils;
39
import org.gvsig.fmap.dal.feature.EditableFeature;
40
import org.gvsig.fmap.dal.feature.Feature;
41
import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
42
import org.gvsig.fmap.dal.feature.FeatureStore;
43
import org.gvsig.fmap.geom.DataTypes;
44
import org.gvsig.fmap.geom.Geometry;
45
import org.gvsig.fmap.geom.GeometryCoercionContext;
46
import org.gvsig.fmap.geom.GeometryLocator;
47
import org.gvsig.fmap.geom.GeometryUtils;
48
import org.gvsig.fmap.geom.type.GeometryType;
36 49
import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;
50
import org.gvsig.json.Json;
51
import org.gvsig.tools.ToolsLocator;
52
import org.gvsig.tools.dataTypes.Coercion;
53
import org.gvsig.tools.dataTypes.DataTypeUtils;
37 54
import org.gvsig.tools.dynobject.DynObject;
38 55
import org.gvsig.tools.service.Service;
39 56
import org.gvsig.tools.service.ServiceException;
......
42 59
import org.gvsig.tools.service.spi.ProviderFactory;
43 60
import org.gvsig.tools.service.spi.ProviderServices;
44 61
import org.gvsig.tools.swing.api.ToolsSwingLocator;
62
import org.gvsig.tools.swing.api.ToolsSwingManager;
45 63
import org.gvsig.tools.swing.icontheme.IconTheme;
46 64
import org.gvsig.vectorediting.lib.api.EditingServiceInfo;
47 65
import org.gvsig.vectorediting.lib.api.exceptions.ServiceInformationException;
48 66
import org.gvsig.vectorediting.lib.spi.EditingProviderFactory;
49 67
import org.gvsig.vectorediting.lib.spi.EditingProviderManager;
68
import org.gvsig.vectorediting.lib.spi.EditingProviderServices;
69
import org.slf4j.Logger;
70
import org.slf4j.LoggerFactory;
50 71

  
51 72
public class DefaultEditingProviderManager extends AbstractProviderManager
52 73
implements EditingProviderManager {
......
54 75
    private static final Logger logger = LoggerFactory
55 76
        .getLogger(DefaultEditingProviderManager.class);
56 77

  
57
    Map<String, ISymbol> symbols =
58
        new HashMap<String, ISymbol>();
78
    Map<String, ISymbol> symbols = new HashMap<>();
59 79

  
60
    Map<String, Map<String, String>> defaultValues =
61
        new HashMap<String, Map<String, String>>();
80
    Map<String, Map<String, String>> defaultValues = new HashMap<>();
81
    
82
    private String clipboardValue;
83
    private List<Geometry> geometriesFromClipboard;
84
    private List<EditableFeature> featuresFromClipboard;
62 85

  
86

  
63 87
    public ProviderServices createProviderServices(Service service) {
64 88
        // TODO Auto-generated method stub
65 89
        return null;
......
162 186
        }
163 187
    }
164 188

  
189
    @Override
165 190
    public Map<String, String> getDefaultValues(String name) {
166 191
        return this.defaultValues.get(name);
167 192
    }
193
    
194
    @Override
195
    public List<Geometry> getGeometriesFromClipboard(){
196
        ToolsSwingManager manager = ToolsSwingLocator.getToolsSwingManager();
197
        String clipboardValue = manager.getFromClipboard();
198
        
199
        if(StringUtils.isNotBlank(clipboardValue) 
200
                && StringUtils.isNotBlank(this.clipboardValue)
201
                && StringUtils.equals(clipboardValue, this.clipboardValue)){
202
            return this.geometriesFromClipboard;
203
        }
204
        
205
        this.geometriesFromClipboard = new ArrayList<>();
206
        
207
        String geometryName = null;
208
        try {
209
            JsonArray jsonArray = Json.createArray(clipboardValue);
168 210

  
211
            Coercion toGeometry = ToolsLocator.getDataTypesManager().getCoercion(DataTypes.GEOMETRY);
212

  
213
            for (JsonValue item : jsonArray) {
214
                JsonObject jsonItem = (JsonObject) item;
215
                if (StringUtils.isBlank(geometryName)) {
216
                    for (Map.Entry<String, JsonValue> field : jsonItem.entrySet()) {
217
                        Geometry geometry;
218
                        try {
219
                            geometry = (Geometry) toGeometry.coerce(field.getValue().toString().replace("\"", ""));
220
                            if (geometry != null) {
221
                                geometryName = field.getKey();
222
                                this.geometriesFromClipboard.add(geometry);
223
                                break;
224
                            }
225
                        } catch (Exception e) {
226
                            //DO NOTHING
227
                        }
228
                    }
229
                } else {
230
                    Geometry geometry;
231
                    try {
232
                        String strGeom = jsonItem.getString(geometryName);
233
                        geometry = (Geometry) toGeometry.coerce(strGeom);
234
                        if (geometry != null) {
235
                            this.geometriesFromClipboard.add(geometry);
236
                        }
237
                    } catch (Exception e) {
238
                        //DO NOTHING
239
    //                        logger.warn("Can't coerce geometry", e);
240
                    }
241
                }
242
            }
243
        } catch (Exception ex) {
244
            //DO NOTHING
245
        }
246
        return this.geometriesFromClipboard;
247
    }
248

  
249

  
250
    @Override
251
    public List<EditableFeature> getFeaturesFromClipboard(EditingProviderServices providerServices, FeatureStore store) {
252
        ToolsSwingManager manager = ToolsSwingLocator.getToolsSwingManager();
253
        String clipboardValue = manager.getFromClipboard();
254
        
255
        if(StringUtils.isNotBlank(clipboardValue) 
256
                && StringUtils.isNotBlank(this.clipboardValue)
257
                && StringUtils.equals(clipboardValue, this.clipboardValue)){
258
            return this.featuresFromClipboard;
259
        }
260
        
261
        this.featuresFromClipboard = new ArrayList<>();
262

  
263
        GeometryType storeGeomType = store.getDefaultFeatureTypeQuietly().getDefaultGeometryAttribute().getGeomType();
264
        GeometryCoercionContext context = GeometryLocator.getGeometryManager().createGeometryCoercionContext();
265
        context.setGeometryType(storeGeomType);
266
        context.setMode(GeometryCoercionContext.MODE_ONERROR_NULL);
267
        Coercion toGeometry = DataTypeUtils.getCoercion(DataTypes.GEOMETRY);
268

  
269
        
270
        String geometryName = null;
271
        try {
272
            JsonArray jsonArray = Json.createArray(clipboardValue);
273

  
274
            for (JsonValue item : jsonArray) {
275
                JsonObject jsonItem = (JsonObject) item;
276
                EditableFeature feat = providerServices.createNewFeature(store);
277
                feat.copyFrom(jsonItem, (FeatureAttributeDescriptor t) -> !t.isPrimaryKey());
278
                Geometry geometry = feat.getDefaultGeometry();
279
                if(geometry == null){
280
                    if (StringUtils.isBlank(geometryName)) {
281
                        for (Map.Entry<String, JsonValue> field : jsonItem.entrySet()) {
282
                            try {
283
                                geometry = (Geometry) toGeometry.coerce(field.getValue().toString().replace("\"", ""), context);
284
                                if (geometry != null) {
285
                                    geometryName = field.getKey();
286
                                    break;
287
                                }
288
                            } catch (Exception e) {
289
                                //DO NOTHING
290
                            }
291
                        }
292
                    } else {
293
                        try {
294
                            String strGeom = jsonItem.getString(geometryName);
295
                            geometry = (Geometry) toGeometry.coerce(strGeom, context);
296
                        } catch (Exception e) {
297
                            //DO NOTHING
298
                        }
299
                    }
300
                    
301
                } else {
302
                    geometry = (Geometry) toGeometry.coerce(geometry,context);
303
                }
304
                
305
                if (geometry != null) {
306
                    feat.setDefaultGeometry(geometry);
307
                    this.featuresFromClipboard.add(feat);
308
                }
309
            }
310
        } catch (Exception ex) {
311
            //DO NOTHING
312
        }
313
        return this.featuresFromClipboard;
314
    }
315
    
169 316
}

Also available in: Unified diff