@Test
 public void testCreateAsJSON() throws Exception {
   GeoServer geoServer = getGeoServer();
   geoServer.remove(geoServer.getSettings(geoServer.getCatalog().getWorkspaceByName("sf")));
   String json =
       "{'settings':{'workspace':{'name':'sf'},"
           + "'contact':{'addressCity':'Alexandria','addressCountry':'Egypt','addressType':'Work',"
           + "'contactEmail':'*****@*****.**','contactOrganization':'The ancient geographes INC',"
           + "'contactPerson':'Claudius Ptolomaeus','contactPosition':'Chief geographer'},"
           + "'charset':'UTF-8','numDecimals':10,'onlineResource':'http://geoserver.org',"
           + "'proxyBaseUrl':'http://proxy.url','verbose':false,'verboseExceptions':'true'}}";
   MockHttpServletResponse response =
       putAsServletResponse("/rest/workspaces/sf/settings", json, "text/json");
   assertEquals(200, response.getStatusCode());
   JSON jsonMod = getAsJSON("/rest/workspaces/sf/settings.json");
   JSONObject jsonObject = (JSONObject) jsonMod;
   assertNotNull(jsonObject);
   JSONObject settings = jsonObject.getJSONObject("settings");
   assertNotNull(settings);
   JSONObject workspace = settings.getJSONObject("workspace");
   assertNotNull(workspace);
   assertEquals("sf", workspace.get("name"));
   assertEquals("10", settings.get("numDecimals").toString().trim());
   assertEquals("http://geoserver.org", settings.get("onlineResource"));
   assertEquals("http://proxy.url", settings.get("proxyBaseUrl"));
   JSONObject contact = settings.getJSONObject("contact");
   assertEquals("Claudius Ptolomaeus", contact.get("contactPerson"));
   assertEquals("The ancient geographes INC", contact.get("contactOrganization"));
   assertEquals("Work", contact.get("addressType"));
   assertEquals("*****@*****.**", contact.get("contactEmail"));
 }
 /** Creates a new WFSCapsTransformer object. */
 public Wcs10CapsTransformer(GeoServer geoServer) {
   super();
   this.geoServer = geoServer;
   this.wcs = geoServer.getService(WCSInfo.class);
   this.catalog = geoServer.getCatalog();
   setNamespaceDeclarationEnabled(false);
 }
  /**
   * Reads all the common attributes from the service info class.
   *
   * <p>This method is intended to be called by subclasses after creating an instance of
   * ServiceInfo. Example:
   *
   * <pre>
   *   // read properties
   *   Map<String,Object> props = reader.wfs();
   *
   *   // create config object
   *   WFSInfo wfs = new WFSInfoImpl();
   *
   *   //load common properties
   *   load( wfs, reader );
   *
   *   //load wfs specific properties
   *   wfs.setServiceLevel( map.get( "serviceLevel") );
   *   ...
   * </pre>
   */
  protected void readCommon(ServiceInfo service, Map<String, Object> properties, GeoServer gs)
      throws Exception {

    service.setEnabled((Boolean) properties.get("enabled"));
    service.setName((String) properties.get("name"));
    service.setTitle((String) properties.get("title"));
    service.setAbstract((String) properties.get("abstract"));

    Map metadataLink = (Map) properties.get("metadataLink");
    if (metadataLink != null) {
      MetadataLinkInfo ml = gs.getCatalog().getFactory().createMetadataLink();
      ml.setAbout((String) metadataLink.get("about"));
      ml.setMetadataType((String) metadataLink.get("metadataType"));
      ml.setType((String) metadataLink.get("type"));
      service.setMetadataLink(ml);
    }

    List<String> keywords = (List<String>) properties.get("keywords");
    if (keywords != null) {
      for (String kw : keywords) {
        service.getKeywords().add(new Keyword(kw));
      }
    }

    service.setOnlineResource((String) properties.get("onlineResource"));
    service.setFees((String) properties.get("fees"));
    service.setAccessConstraints((String) properties.get("accessConstraints"));
    service.setCiteCompliant((Boolean) properties.get("citeConformanceHacks"));
    service.setMaintainer((String) properties.get("maintainer"));
    service.setSchemaBaseURL((String) properties.get("SchemaBaseUrl"));
  }
  /**
   * Looks up a {@link LayerInfo} or {@link LayerGroupInfo} named after the {@code <layer>} in the
   * requested resource {@code <layer>.kml} name
   *
   * @see org.restlet.Finder#findTarget(org.restlet.data.Request, org.restlet.data.Response)
   */
  @Override
  public Resource findTarget(final Request request, Response response) {
    if (!Method.GET.equals(request.getMethod())) {
      response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
      return null;
    }
    final String name = RESTUtils.getAttribute(request, "layer");
    if (name == null) {
      throw new RestletException("No layer name specified", Status.CLIENT_ERROR_BAD_REQUEST);
    }
    final Catalog catalog = geoserver.getCatalog();
    CatalogInfo layer = catalog.getLayerByName(name);
    MetadataMap mdmap;
    if (layer == null) {
      layer = catalog.getLayerGroupByName(name);
      if (layer == null) {
        throw new RestletException("Layer " + name + " not found", Status.CLIENT_ERROR_NOT_FOUND);
      }
      mdmap = ((LayerGroupInfo) layer).getMetadata();
    } else {
      mdmap = ((LayerInfo) layer).getMetadata();
    }

    Boolean enabled = mdmap.get(Properties.INDEXING_ENABLED, Boolean.class);
    if (enabled == null || !enabled.booleanValue()) {
      throw new RestletException("Layer " + name + " not found", Status.CLIENT_ERROR_NOT_FOUND);
    }
    final Context context = getContext();
    return new GeoSearchLayer(context, request, response, layer, geoserver);
  }
Beispiel #5
0
  /**
   * Adds a settings configuration to the test setup. If the settings object already exists it is
   * simply reverted to its original state.
   *
   * @param workspace The optional workspace for the settings, may be <code>null</code>
   * @param geoServer The GeoServer configuration object.
   */
  public void addSettings(String workspace, GeoServer geoServer) {
    WorkspaceInfo ws =
        workspace != null ? geoServer.getCatalog().getWorkspaceByName(workspace) : null;

    GeoServerInfo global = geoServer.getGlobal();
    SettingsInfo settings = ws != null ? geoServer.getSettings(ws) : global.getSettings();
    if (settings == null) {
      settings = geoServer.getFactory().createSettings();
    }
    settings.setWorkspace(ws);
    settings.getContact().setContactPerson("Andrea Aime");
    settings.setNumDecimals(8);
    settings.setOnlineResource("http://geoserver.org");
    settings.setVerbose(false);
    settings.setVerboseExceptions(false);
    settings.setLocalWorkspaceIncludesPrefix(false);

    if (ws != null) {
      if (settings.getId() != null) {
        geoServer.save(settings);
      } else {
        geoServer.add(settings);
      }
    } else {
      // global
      geoServer.save(global);
    }
  }
Beispiel #6
0
  /**
   * Adds a service configuration to the test setup. If the service object already exists it is
   * simply reverted to its original state.
   *
   * @param serviceClass The class of the service
   * @param workspace The optional workspace for the service, may be <code>null</code>
   * @param geoServer The GeoServer configuration object.
   */
  public <T extends ServiceInfo> void addService(
      Class<T> serviceClass, String workspace, GeoServer geoServer) {

    Catalog catalog = geoServer.getCatalog();

    List<XStreamServiceLoader> loaders = GeoServerExtensions.extensions(XStreamServiceLoader.class);
    for (XStreamServiceLoader loader : loaders) {
      if (serviceClass.equals(loader.getServiceClass())) {
        // create a new one
        T created = (T) loader.create(geoServer);

        // grab the old one, if it exists
        T old = null;
        WorkspaceInfo ws = null;
        if (workspace != null) {
          ws = catalog.getWorkspaceByName(workspace);
          old = geoServer.getService(ws, serviceClass);
        } else {
          old = geoServer.getService(serviceClass);
        }

        if (old != null) {
          // update the old copy
          OwsUtils.copy(created, old, serviceClass);
          geoServer.save(old);
        } else {
          // add the new one
          created.setWorkspace(ws);
          geoServer.add(created);
        }

        break;
      }
    }
  }
Beispiel #7
0
 public Data getRawData() {
   Catalog catalog = gs.getCatalog();
   if (catalog instanceof Wrapper && ((Wrapper) catalog).isWrapperFor(Catalog.class)) {
     catalog = ((Wrapper) catalog).unwrap(Catalog.class);
   }
   return new Data(gs, catalog);
 }
  public void initialize(GeoServer geoServer) throws Exception {
    this.geoServer = geoServer;

    // we need the original catalog, not a wrapper
    Catalog catalog = geoServer.getCatalog();
    if (catalog instanceof Wrapper) {
      catalog = ((Wrapper) catalog).unwrap(Catalog.class);
    }
    this.catalog = catalog;
    active = true;
  }
  @BeforeClass
  public static void setUpData() throws Exception {
    MonitorDAO dao = new MemoryMonitorDAO();
    new MonitorTestData(dao).setup();

    MonitorConfig mc =
        new MonitorConfig() {

          @Override
          public MonitorDAO createDAO() {
            MonitorDAO dao = new MemoryMonitorDAO();
            try {
              new MonitorTestData(dao).setup();
              return dao;
            } catch (java.text.ParseException e) {
              throw new RuntimeException(e);
            }
          }

          @Override
          public BboxMode getBboxMode() {
            return BboxMode.FULL;
          }
        };

    GeoServer gs = createMock(GeoServer.class);
    monitor = new Monitor(mc);
    monitor.setServer(gs);

    catalog = new CatalogImpl();

    expect(gs.getCatalog()).andStubReturn(catalog);
    replay(gs);

    NamespaceInfo ns = catalog.getFactory().createNamespace();
    ns.setPrefix("acme");
    ns.setURI("http://acme.org");
    catalog.add(ns);
    DataStoreInfo ds = catalog.getFactory().createDataStore();
    FeatureTypeInfo ftFoo = catalog.getFactory().createFeatureType();
    ftFoo.setName("foo");
    ftFoo.setSRS("EPSG:4326");
    ftFoo.setNamespace(ns);
    ftFoo.setStore(ds);
    catalog.add(ftFoo);
    FeatureTypeInfo ftBar = catalog.getFactory().createFeatureType();
    ftBar.setName("bar");
    ftBar.setSRS("EPSG:3348");
    ftBar.setNamespace(ns);
    ftBar.setStore(ds);
    catalog.add(ftBar);
  }
  @Test
  public void testCreateAsXML() throws Exception {
    GeoServer geoServer = getGeoServer();
    geoServer.remove(geoServer.getSettings(geoServer.getCatalog().getWorkspaceByName("sf")));
    String xml =
        "<settings>"
            + "<workspace><name>sf</name></workspace>"
            + "<contact>"
            + "<addressCity>Alexandria</addressCity>"
            + "<addressCountry>Egypt</addressCountry>"
            + "<addressType>Work</addressType>"
            + "<contactEmail>[email protected]</contactEmail>"
            + "<contactOrganization>The ancient geographes INC</contactOrganization>"
            + "<contactPerson>Claudius Ptolomaeus</contactPerson>"
            + "<contactPosition>Chief geographer</contactPosition>"
            + "</contact>"
            + "<charset>UTF-8</charset>"
            + "<numDecimals>8</numDecimals>"
            + "<onlineResource>http://geoserver.org</onlineResource>"
            + "<proxyBaseUrl>http://proxy.url</proxyBaseUrl>"
            + "<verbose>false</verbose>"
            + "<verboseExceptions>false</verboseExceptions>"
            + "</settings>";
    MockHttpServletResponse response =
        putAsServletResponse("/rest/workspaces/sf/settings", xml, "text/xml");
    assertEquals(200, response.getStatusCode());

    Document dom = getAsDOM("/rest/workspaces/sf/settings.xml");
    assertEquals("settings", dom.getDocumentElement().getLocalName());
    assertXpathEvaluatesTo("sf", "/settings/workspace/name", dom);
    assertXpathEvaluatesTo("false", "/settings/verbose", dom);
    assertXpathEvaluatesTo("false", "/settings/verboseExceptions", dom);
    assertXpathEvaluatesTo("http://geoserver.org", "/settings/onlineResource", dom);
    assertXpathEvaluatesTo("http://proxy.url", "/settings/proxyBaseUrl", dom);
    assertXpathEvaluatesTo("Claudius Ptolomaeus", "/settings/contact/contactPerson", dom);
    assertXpathEvaluatesTo("*****@*****.**", "/settings/contact/contactEmail", dom);
    assertXpathEvaluatesTo("Chief geographer", "/settings/contact/contactPosition", dom);
    assertXpathEvaluatesTo(
        "The ancient geographes INC", "/settings/contact/contactOrganization", dom);
    assertXpathEvaluatesTo("Egypt", "/settings/contact/addressCountry", dom);
  }
  public void write(Object value, OutputStream output, Operation operation)
      throws IOException, ServiceException {
    final FeatureDiffReader[] diffReaders = (FeatureDiffReader[]) value;

    // create a new feature collcetion type with just the numbers
    VersioningTransactionConverter converter = new VersioningTransactionConverter();
    final TransactionType transaction = converter.convert(diffReaders, TransactionType.class);

    // declare wfs schema location
    BaseRequestType gft = (BaseRequestType) operation.getParameters()[0];

    Encoder encoder = new Encoder(configuration, configuration.schema());
    encodeWfsSchemaLocation(encoder, gft.getBaseUrl());

    encoder.setIndenting(true);
    encoder.setEncoding(Charset.forName(geoServer.getSettings().getCharset()));

    // set up schema locations
    // round up the info objects for each feature collection
    HashMap /* <String,Set> */ ns2metas = new HashMap();

    for (int i = 0; i < diffReaders.length; i++) {
      final FeatureDiffReader diffReader = diffReaders[i];
      final SimpleFeatureType featureType = diffReader.getSchema();

      // load the metadata for the feature type
      String namespaceURI = featureType.getName().getNamespaceURI();
      FeatureTypeInfo meta =
          geoServer
              .getCatalog()
              .getFeatureTypeByName(namespaceURI, featureType.getName().getLocalPart());

      // add it to the map
      Set metas = (Set) ns2metas.get(namespaceURI);

      if (metas == null) {
        metas = new HashSet();
        ns2metas.put(namespaceURI, metas);
      }

      metas.add(meta);
    }

    // declare application schema namespaces
    for (Iterator i = ns2metas.entrySet().iterator(); i.hasNext(); ) {
      Map.Entry entry = (Map.Entry) i.next();

      String namespaceURI = (String) entry.getKey();
      Set metas = (Set) entry.getValue();

      StringBuffer typeNames = new StringBuffer();

      for (Iterator m = metas.iterator(); m.hasNext(); ) {
        FeatureTypeInfo meta = (FeatureTypeInfo) m.next();
        typeNames.append(meta.getName());

        if (m.hasNext()) {
          typeNames.append(",");
        }
      }

      // set the schema location
      encodeTypeSchemaLocation(encoder, gft.getBaseUrl(), namespaceURI, typeNames);
    }

    try {
      encoder.encode(transaction, element, output);
    } finally {
      for (int i = 0; i < diffReaders.length; i++) {
        diffReaders[i].close();
      }
    }
  }
 /**
  * @param readLimits
  * @param writeLimits
  * @param hardOutputLimit
  * @param geoserver
  */
 public DownloadEstimatorProcess(
     DownloadServiceConfigurationGenerator downloadServiceConfigurationGenerator,
     GeoServer geoserver) {
   this.catalog = geoserver.getCatalog();
   this.downloadServiceConfigurationGenerator = downloadServiceConfigurationGenerator;
 }
Beispiel #13
0
 public Catalog getCatalog() {
   return geoserver.getCatalog();
 }