private boolean storeSupportsAllRequestedNamespaces( FeatureStore store, Collection<String> namespaces ) { Set<String> appNamespaces = store.getSchema().getAppNamespaces(); return appNamespaces.containsAll( namespaces ); }
public FeatureLayerData( List<Query> queries, FeatureStore featureStore, int maxFeatures, Style style, QName ftName ) { this.queries = queries; this.featureStore = featureStore; this.maxFeatures = maxFeatures; this.style = style; Map<String, QName> bindings = new HashMap<String, QName>(); Set<QName> validNames = AppSchemas.collectProperyNames( featureStore.getSchema(), ftName ); for ( QName name : validNames ) { bindings.put( name.getLocalPart(), name ); } evaluator = new TypedObjectNodeXPathEvaluator( bindings ); }
private Set<String> getExplicitlyRequestedNamespaces( DescribeFeatureType request, WfsFeatureStoreManager storeManager ) { Set<String> set = new LinkedHashSet<String>(); for ( String ns : request.getNsBindings().values() ) { for ( FeatureStore fs : storeManager.getStores() ) { AppSchema schema = fs.getSchema(); if ( schema.getNamespaceBindings().values().contains( ns ) ) { set.add( ns ); break; } } } return set; }
public Set<String> getAppSchemaNamespaces() { Set<String> set = new LinkedHashSet<String>(); for ( FeatureStore fs : format.getMaster().getStoreManager().getStores() ) { set.addAll( fs.getSchema().getAppNamespaces() ); } set.remove( GMLNS ); set.remove( GML3_2_NS ); return set; }
throw new IllegalArgumentException( msg ); for ( FeatureType ft : fs.getSchema().getFeatureTypes( null, true, false ) ) { if ( ft.getName().getNamespaceURI().equals( GMLNS ) || ft.getName().getNamespaceURI().equals( GML3_2_NS ) ) { schemaToStore.put( fs.getSchema(), fs ); for ( Entry<String, String> e : fs.getSchema().getNamespaceBindings().entrySet() ) { prefixToNs.put( e.getKey(), e.getValue() ); targetNsToPrefix.put( e.getValue(), e.getKey() );
private Set<String> findUnhandledNs( Set<String> set ) { Set<String> dependentNamespaces = new HashSet<String>(); WfsFeatureStoreManager storeManager = format.getMaster().getStoreManager(); for ( String ns : set ) { for ( FeatureStore fs : storeManager.getStores() ) { AppSchema schema = fs.getSchema(); List<String> depNs = schema.getNamespacesDependencies( ns ); for ( String n : depNs ) { if ( !set.contains( n ) ) { dependentNamespaces.add( n ); } } } } return dependentNamespaces; }
private static void insert( FeatureStore fs, String datasetFile, GMLVersion gmlVersion, IDGenMode mode ) throws XMLStreamException, FactoryConfigurationError, IOException, XMLParsingException, UnknownCRSException, FeatureStoreException { File f = new File( datasetFile ); URL url = f.toURI().toURL(); System.out.print( "- Reading dataset: '" + datasetFile + "'..." ); GMLStreamReader gmlReader = GMLInputFactory.createGMLStreamReader( gmlVersion, url ); gmlReader.setApplicationSchema( fs.getSchema() ); FeatureCollection fc = gmlReader.readFeatureCollection(); System.out.println( "done." ); FeatureStoreTransaction ta = null; try { ta = fs.acquireTransaction(); System.out.print( "- Inserting features..." ); List<String> fids = ta.performInsert( fc, mode ); System.out.println( "done." ); for ( String fid : fids ) { System.out.println( "- Inserted: " + fid ); } System.out.println( "\n- Insert succeeded (" + fids.size() + " features). Committing transaction." ); ta.commit(); } catch ( Exception e ) { e.printStackTrace(); System.err.println( "Error performing insert: " + e.getMessage() ); if ( ta != null ) { ta.rollback(); } } }
protected boolean localReferencesPossible( QueryAnalyzer analyzer, int traverseXLinkDepth ) { if ( traverseXLinkDepth == 0 && analyzer.getQueries().size() == 1 ) { List<Query> queries = analyzer.getQueries().values().iterator().next(); if ( queries.size() == 1 ) { Query query = queries.get( 0 ); if ( query.getTypeNames().length == 1 ) { TypeName typeName = query.getTypeNames()[0]; FeatureStore fs = analyzer.getQueries().keySet().iterator().next(); FeatureType ft = fs.getSchema().getFeatureType( typeName.getFeatureTypeName() ); for ( PropertyType pt : ft.getPropertyDeclarations() ) { if ( pt instanceof FeaturePropertyType ) { FeaturePropertyType fpt = (FeaturePropertyType) pt; FeatureType targetFt = fpt.getValueFt(); if ( targetFt == null || fs.getSchema().isSubType( targetFt, ft ) ) { return true; } } } LOG.debug( "Forward references can be ruled out." ); return false; } } } return true; }
List<Query> buildInfoQueries() { List<Query> queries = new ArrayList<Query>(); if ( ftName == null ) { queries.addAll( map( featureStore.getSchema().getFeatureTypes( null, false, false ), new Mapper<Query, FeatureType>() { @Override public Query apply( FeatureType u ) { Filter f; if ( filter == null ) { f = buildFilter( null, u, bbox ); } else { f = buildFilter( ( (OperatorFilter) filter ).getOperator(), u, bbox ); } return createQuery( u.getName(), f, -1, query.getFeatureCount(), -1, sortBy ); } } ) ); clearNulls( queries ); } else { Filter f; if ( filter == null ) { f = buildFilter( null, featureStore.getSchema().getFeatureType( ftName ), bbox ); } else { f = buildFilter( ( (OperatorFilter) filter ).getOperator(), featureStore.getSchema().getFeatureType( ftName ), bbox ); } queries.add( createQuery( ftName, f, -1, query.getFeatureCount(), -1, sortBy ) ); } return queries; }
private GMLSchemaInfoSet findGmlSchema( Collection<String> namespaces, GMLVersion version ) { LOG.debug( "Try to find GML schema from store supporting namespaces {}", namespaces ); WfsFeatureStoreManager storeManager = format.getMaster().getStoreManager(); for ( FeatureStore store : storeManager.getStores() ) { if ( storeSupportsAllRequestedNamespaces( store, namespaces ) ) { GMLSchemaInfoSet gmlSchema = store.getSchema().getGMLSchema(); if ( gmlSchema != null && gmlSchema.getVersion() == version ) return gmlSchema; } } return null; }
private void reencodeSchema( DescribeFeatureType request, XMLStreamWriter writer, String targetNs, Collection<String> importNs, GMLVersion version ) throws XMLStreamException { Map<String, String> importMap = buildImportMap( request, importNs ); WfsFeatureStoreManager storeManager = format.getMaster().getStoreManager(); Map<String, String> prefixToNs = storeManager.getPrefixToNs(); GMLAppSchemaWriter exporter = new GMLAppSchemaWriter( version, targetNs, importMap, prefixToNs ); List<FeatureType> fts = new ArrayList<FeatureType>(); for ( FeatureStore fs : storeManager.getStores() ) { for ( FeatureType ft : fs.getSchema().getFeatureTypes( targetNs, true, true ) ) { fts.add( ft ); } } exporter.export( writer, fts ); }
Matcher m = pattern.matcher( uri ); if ( m.find() ) { List<FeatureType> fts = fs.getSchema().getFeatureTypes( null, false, false ); TypeName[] typeNames = new TypeName[fts.size()]; for ( int i = 0; i < fts.size(); ++i ) {
List<Query> buildMapQueries() { List<Query> queries = new ArrayList<Query>(); Integer maxFeats = query.getRenderingOptions().getMaxFeatures( layerName ); final int maxFeatures = maxFeats == null ? -1 : maxFeats; if ( ftName == null && featureStore != null ) { final Filter filter2 = filter; queries.addAll( map( featureStore.getSchema().getFeatureTypes( null, false, false ), new Mapper<Query, FeatureType>() { @Override public Query apply( FeatureType u ) { Filter fil = addBBoxConstraint( bbox, filter2, geomProp, true ); return createQuery( u.getName(), fil, round( query.getScale() ), maxFeatures, query.getResolution(), sortBy ); } } ) ); } else { Query fquery = createQuery( ftName, addBBoxConstraint( bbox, filter, geomProp, true ), round( query.getScale() ), maxFeatures, query.getResolution(), sortBy ); queries.add( fquery ); } return queries; }
MultipleLayerStore createInAutoMode( AutoLayers auto ) throws ResourceInitException { LOG.debug( "Creating feature layers for all feature types automatically." ); Map<String, Layer> map = new LinkedHashMap<String, Layer>(); String id = auto.getFeatureStoreId(); FeatureStore store = workspace.getResource( FeatureStoreProvider.class, id ); if ( store == null ) { throw new ResourceInitException( "Feature layer config was invalid, feature store with id " + id + " is not available." ); } id = auto.getStyleStoreId(); StyleStore sstore = null; if ( id != null ) { sstore = workspace.getResource( StyleStoreProvider.class, id ); } if ( id != null && sstore == null ) { throw new ResourceInitException( "Feature layer config was invalid, style store with id " + id + " is not available." ); } for ( FeatureType ft : store.getSchema().getFeatureTypes() ) { addLayer( store, ft, sstore, map ); } return new MultipleLayerStore( map, metadata ); }
/** * Ignores all errors, tries to aggregate all envelopes of all feature types. * * @param fs * @return null, if none of the feature types had an envelope */ public static Envelope getCombinedEnvelope( FeatureStore fs ) { Envelope env = null; for ( FeatureType ft : fs.getSchema().getFeatureTypes() ) { if ( env == null ) { try { env = fs.getEnvelope( ft.getName() ); } catch ( Throwable e ) { // ignore it } } else { try { Envelope b = fs.getEnvelope( ft.getName() ); if ( b != null ) { env = env.merge( b ); } } catch ( Throwable e ) { // ignore it } } } return env; }
private void doReplace( Replace replace, Lock lock ) throws OWSException { LOG.debug( "doReplace: " + replace ); XMLStreamReader xmlStream = replace.getReplacementFeatureStream(); QName ftName = xmlStream.getName(); FeatureStore fs = service.getStore( ftName ); if ( fs == null ) { throw new OWSException( Messages.get( "WFS_FEATURE_TYPE_NOT_SERVED", ftName ), INVALID_PARAMETER_VALUE ); } Feature replacementFeature = null; Filter filter = null; try { GMLStreamReader gmlReader = createGMLStreamReader( GML_32, xmlStream ); gmlReader.setApplicationSchema( fs.getSchema() ); replacementFeature = gmlReader.readFeature(); filter = replace.getFilter(); // superimpose default CRS Filters.setDefaultCRS( filter, master.getDefaultQueryCrs() ); } catch ( Exception e ) { throw new OWSException( e.getMessage(), INVALID_PARAMETER_VALUE ); } FeatureStoreTransaction ta = acquireTransaction( fs ); try { String newFid = ta.performReplace( replacementFeature, filter, lock, idGenMode ); replaced.add( newFid, replace.getHandle() ); } catch ( FeatureStoreException e ) { throw new OWSException( "Error performing replace: " + e.getMessage(), e, NO_APPLICABLE_CODE ); } }
@Override public FeatureLayerData infoQuery( final LayerQuery query, List<String> headers ) throws OWSException { OperatorFilter filter = this.filter; filter = Filters.and( filter, dimFilterBuilder.getDimensionFilter( query.getDimensions(), headers ) ); StyleRef ref = query.getStyle(); if ( !ref.isResolved() ) { ref.resolve( getMetadata().getStyles().get( ref.getName() ) ); } Style style = ref.getStyle(); style = style.filter( query.getScale() ); filter = Filters.and( filter, getStyleFilters( style, query.getScale() ) ); filter = Filters.and( filter, query.getFilter() ); int layerRadius = -1; if ( getMetadata().getMapOptions() != null ) { layerRadius = getMetadata().getMapOptions().getFeatureInfoRadius(); } final Envelope clickBox = query.calcClickBox( layerRadius > -1 ? layerRadius : query.getLayerRadius() ); filter = (OperatorFilter) addBBoxConstraint( clickBox, filter, null, false ); QName featureType = this.featureType == null ? style.getFeatureType() : this.featureType; filter = Filters.repair( filter, AppSchemas.collectProperyNames( featureStore.getSchema(), featureType ) ); LOG.debug( "Querying the feature store(s)..." ); QueryBuilder builder = new QueryBuilder( featureStore, filter, featureType, clickBox, query, null, sortByFeatureInfo, getMetadata().getName() ); List<Query> queries = builder.buildInfoQueries(); LOG.debug( "Finished querying the feature store(s)." ); return new FeatureLayerData( queries, featureStore, query.getFeatureCount(), style, featureType ); }