import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
/**
 * Delete style.
 *
 * @param styleToDelete the style to delete
 * @return true, if successful
 */
@Override
public boolean deleteStyle(StyleWrapper styleToDelete) {
    if (styleToDelete == null) {
        return false;
    }

    boolean result = false;
    GeoServerRESTManager manager = GeoServerRESTManagerFactory.getManager(connection);
    GeoServerRESTPublisher publisher = manager.getPublisher();

    if (publisher != null) {
        if (isDefaultWorkspace(styleToDelete.getWorkspace())) {
            result = publisher.removeStyle(styleToDelete.getStyle());
        } else {
            result = publisher.removeStyleInWorkspace(styleToDelete.getWorkspace(),
                    styleToDelete.getStyle());
        }
    }

    return result;
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
/**
 * Delete workspace.
 *
 * @param workspaceName the workspace name
 * @return true, if successful
 */
@Override
public boolean deleteWorkspace(String workspaceName) {
    if (workspaceName == null) {
        return false;
    }

    boolean result = false;
    GeoServerRESTManager manager = GeoServerRESTManagerFactory.getManager(connection);
    GeoServerRESTPublisher publisher = manager.getPublisher();

    if (publisher != null) {
        if (isDefaultWorkspace(workspaceName)) {
            ConsoleManager.getInstance().error(this, Localisation.getString(
                    GeoServerClient.class, "GeoServerClient.cannotDeleteDefaultWorkspace"));
        } else {
            result = publisher.removeWorkspace(workspaceName, false);
        }
    }

    return result;
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "shapefile publish", help = "Publish a shapefile.")
public boolean publish(
        @CliOption(key = "workspace", mandatory = true, help = "The workspace") String workspace,
        @CliOption(key = "datastore", mandatory = false, help = "The datastore") String datastore,
        @CliOption(key = "layer", mandatory = false, help = "The layer name") String layer,
        @CliOption(key = "file", mandatory = true, help = "The zipped shapefile") File file,
        @CliOption(key = "srs", mandatory = false, unspecifiedDefaultValue = "EPSG:4326", help = "The EPSG srs code") String srs,
        @CliOption(key = "style", mandatory = false, help = "The style") String style
) throws Exception {
    String baseName = file.getName().substring(0, file.getName().lastIndexOf(".zip"));
    if (datastore == null) {
        datastore = baseName;
    }
    if (layer == null) {
        layer = baseName;
    }
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    return publisher.publishShp(workspace, datastore, layer, file, srs, style);
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
public void publishWorkspace()
{
  try
  {
    GeoServerRESTPublisher publisher = GeoserverProperties.getPublisher();
    
    // IMPORTANT: The URI must match the namespace of the store or rendering doesn't work
    if (publisher.createWorkspace(GeoserverProperties.getWorkspace(), new URI(GeoserverProperties.getWorkspace())))
    {
      log.info("Created the workspace [" + GeoserverProperties.getWorkspace() + "].");
    }
    else
    {
      log.warn("Failed to create the workspace [" + GeoserverProperties.getWorkspace() + "].");
    }
  }
  catch (URISyntaxException e)
  {
    throw new ConfigurationException("The URI [" + GeoserverProperties.getWorkspace() + "] is invalid.", e);
  }
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
public boolean publishStyle(String styleName, String body, boolean force)
{
  GeoServerRESTPublisher publisher = GeoserverProperties.getPublisher();

  if (force && styleExists(styleName))
  {
    publisher.removeStyle(styleName, true);
  }

  if (publisher.publishStyle(body, styleName, true))
  {
    log.info("Published the SLD [" + styleName + "].");
    return true;
  }
  else
  {
    log.warn("Failed to publish the SLD [" + styleName + "].");
    return false;
  }
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
/**
 * Removes the layer from geoserver.
 * 
 * @param layer
 * @return
 */
public void removeLayer(String layer)
{
  if (GeoserverFacade.layerExists(layer))
  {
    String workspace = GeoserverProperties.getWorkspace();
    GeoServerRESTPublisher publisher = GeoserverProperties.getPublisher();

    if (publisher.removeLayer(workspace, layer))
    {
      log.info("Removed the layer for [" + layer + "].");
    }
    else
    {
      log.warn("Failed to remove the layer for [" + layer + "].");
    }
  }
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "geoserver reset", help = "Reset Geoserver's configuration.")
public boolean reset() {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    return publisher.reset();
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
/**
 * Update layer styles.
 *
 * @param layer the original layer
 * @return true, if successful
 */
@Override
public boolean updateLayerStyles(GeoServerLayer layer) {
    if (layer == null) {
        return false;
    }

    StyleWrapper updatedStyle = layer.getStyle();

    boolean ok = false;
    GeoServerRESTManager manager = GeoServerRESTManagerFactory.getManager(connection);
    GeoServerRESTPublisher publisher = manager.getPublisher();

    if (publisher != null) {
        GSLayerEncoder layerEncoder = new GSLayerEncoder();

        String defaultStyle;
        if (isDefaultWorkspace(updatedStyle.getWorkspace())) {
            defaultStyle = updatedStyle.getStyle();
        } else {
            defaultStyle = updatedStyle.getWorkspace() + ":" + updatedStyle.getStyle();
        }
        layerEncoder.setDefaultStyle(defaultStyle);
        ok = publisher.configureLayer(layer.getLayerWorkspace(), layer.getLayerName(),
                layerEncoder);
    }

    return ok;
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@Override
public boolean publishFromDB(String tableName, String srs) {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(GEOSERVER_URL, GEOSERVER_USERNAME, GEOSERVER_PASS);

    GSLayerEncoder layerEncoder = new GSLayerEncoder();
    layerEncoder.setEnabled(true);
    layerEncoder.setQueryable(true);
    layerEncoder.setDefaultStyle(GEOSERVER_DEFAULT_STYLE);

    GSFeatureTypeEncoder featureTypeEncoder = new GSFeatureTypeEncoder();
    featureTypeEncoder.setSRS((srs == null) ? GEOSERVER_DEFAULT_SRS : srs);
    featureTypeEncoder.setName(tableName);

    return publisher.publishDBLayer(GEOSERVER_DEFAULT_WS, GEOSERVER_DEFAULT_STORAGE, featureTypeEncoder, layerEncoder);
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "style delete", help = "Delete a style.")
public boolean delete(
        @CliOption(key = "name", mandatory = true, help = "The name") String name,
        @CliOption(key = "workspace", mandatory = false, help = "The workspace") String workspace,
        @CliOption(key = "purge", mandatory = false, help = "Whether to delete the SLD File from the server or not", unspecifiedDefaultValue = "false") boolean purge
) throws Exception {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    if (workspace == null) {
        return publisher.removeStyle(name, purge);
    } else {
        return removeStyle(name, workspace, purge);
    }
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "style create", help = "Create a style.")
public boolean create(
        @CliOption(key = "name", mandatory = true, help = "The name") String name,
        @CliOption(key = "workspace", mandatory = false, help = "The workspace") String workspace,
        @CliOption(key = "file", mandatory = true, help = "The SLD File") File sldFile
) throws Exception {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    if (workspace == null) {
        return publisher.publishStyle(sldFile, name);
    } else {
        return publishStyle(sldFile, name, workspace);
    }
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "style modify", help = "Update a style.")
public boolean modify(
        @CliOption(key = "name", mandatory = true, help = "The name") String name,
        @CliOption(key = "workspace", mandatory = false, help = "The workspace") String workspace,
        @CliOption(key = "file", mandatory = true, help = "The SLD File") File sldFile
) throws Exception {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    if (workspace == null) {
        return publisher.updateStyle(sldFile, name);
    } else {
        return updateStyle(sldFile, name, workspace);
    }
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "geoserver backup", help = "Backup Geoserver's configuration.")
public boolean backup(
        @CliOption(key = "directory", mandatory = true, help = "The backup ") String backupDir,
        @CliOption(key = "includedata", mandatory = false, unspecifiedDefaultValue = "false", help = "The include data flag") boolean includeData,
        @CliOption(key = "includegwc", mandatory = false, unspecifiedDefaultValue = "false", help = "The include GWC flag") boolean includeGwc,
        @CliOption(key = "includelog", mandatory = false, unspecifiedDefaultValue = "false", help = "The include log files flag") boolean includeLog
) {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    String result = publisher.backup(backupDir, includeData, includeGwc, includeLog);
    return result != null;
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "geoserver restore", help = "Restore Geoserver's configuration from a backup directory.")
public boolean restore(
        @CliOption(key = "directory", mandatory = true, help = "The backup ") String backupDir
) {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    String result = publisher.restore(backupDir);
    return result != null;
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "workspace create", help = "Create a workspace.")
public boolean create(
        @CliOption(key = "name", mandatory = true, help = "The name") String name
) throws Exception {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    return publisher.createWorkspace(name);
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "workspace delete", help = "Delete a workspace.")
public boolean delete(
        @CliOption(key = "name", mandatory = true, help = "The name") String name,
        @CliOption(key = "recurse", mandatory = false, unspecifiedDefaultValue = "false", help = "Whether to delete recursively") boolean recurse) {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    return publisher.removeWorkspace(name, recurse);
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "namespace create", help = "Create a namespace.")
public boolean create(
        @CliOption(key = "prefix", mandatory = true, help = "The prefix") String prefix,
        @CliOption(key = "uri", mandatory = true, help = "The uri") String uri) throws Exception {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    return publisher.createNamespace(prefix, URI.create(uri));
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "namespace modify", help = "Modify a namespace.")
public boolean update(
        @CliOption(key = "prefix", mandatory = true, help = "The prefix") String prefix,
        @CliOption(key = "uri", mandatory = true, help = "The uri") String uri) throws Exception {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    return publisher.updateNamespace(prefix, URI.create(uri));
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
@CliCommand(value = "namespace delete", help = "Delete a namespace.")
public boolean delete(
        @CliOption(key = "prefix", mandatory = true, help = "The prefix") String prefix,
        @CliOption(key = "recurse", mandatory = false, unspecifiedDefaultValue = "false", help = "Whether to delete recursively") boolean recurse) {
    GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(geoserver.getUrl(), geoserver.getUser(), geoserver.getPassword());
    return publisher.removeNamespace(prefix, recurse);
}
 

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; //导入依赖的package包/类
/**
 * Upload sld.
 *
 * @param styleWrapper the style wrapper
 * @param sldBody the sld body
 * @return true, if successful
 */
@Override
public boolean uploadSLD(StyleWrapper styleWrapper, String sldBody) {
    String workspaceName = styleWrapper.getWorkspace();
    String styleName = styleWrapper.getStyle();

    if (!workspaceValid(workspaceName)) {
        return false;
    }

    boolean result = false;
    GeoServerRESTManager manager = GeoServerRESTManagerFactory.getManager(connection);
    GeoServerRESTPublisher publisher = manager.getPublisher();

    if (publisher != null) {
        if (styleExists(workspaceName, styleName)) {
            if (isDefaultWorkspace(workspaceName)) {
                result = publisher.updateStyle(sldBody, styleName, true);
            } else {
                result = publisher.updateStyleInWorkspace(workspaceName, sldBody, styleName);
            }
        } else {
            if (isDefaultWorkspace(workspaceName)) {
                result = publisher.publishStyle(sldBody, styleName, true);
            } else {
                GeoServerRESTReader reader = manager.getReader();

                if (reader != null) {
                    if (!reader.existsWorkspace(workspaceName)) {
                        if (!publisher.createWorkspace(workspaceName)) {

                            ConsoleManager.getInstance().error(this,
                                    Localisation.getField(GeoServerClient.class,
                                            "GeoServerClient.failedToCreateWorkspace")
                                            + workspaceName);
                            return false;
                        }
                    }
                } else {
                    return false;
                }
                result = publisher.publishStyleInWorkspace(workspaceName, sldBody, styleName);
            }
        }
    }

    if (result) {
        ConsoleManager.getInstance().information(this,
                String.format("%s : %s %s/%s",
                        Localisation.getString(GeoServerClient.class,
                                "GeoServerClient.styleUploaded"),
                        connection.getConnectionName(), workspaceName, styleName));
    }
    return result;
}