gCubeSystem
/
gcube-cms-suite
15
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request 'task_24859' (#13) from task_24859 into master 

Reviewed-on: #13
This commit is contained in:
Francesco Mangiacrapa 2023-03-30 11:00:17 +02:00
parent 5ac8725594 4964056fb4
commit e7722548d6
26 changed files with 777 additions and 677 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
default-lc-managers/CHANGELOG.md
View File

@ -1,5 +1,10 @@
# Changelog for org.gcube.application.cms.ckan-plugin # Changelog for org.gcube.application.cms.ckan-plugin
## [v1.2.0-SNAPSHOT]
- Integrated the field 'geov_link' (Geoportal GisViewer link) in the centroid layer [#24859]
- Fixed Draft execution step executing dematerialization and de-indexing actions [#24877]
## [v1.1.1] - 2023-03-06 ## [v1.1.1] - 2023-03-06
- [#24570] Integrated the UnPublish operation - [#24570] Integrated the UnPublish operation

2
default-lc-managers/pom.xml
View File

@ -5,7 +5,7 @@
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<artifactId>default-lc-managers</artifactId> <artifactId>default-lc-managers</artifactId>
<version>1.1.1</version> <version>1.2.0-SNAPSHOT</version>
<name>gCube CMS - Default LC Managers</name> <name>gCube CMS - Default LC Managers</name>

2
default-lc-managers/src/main/java/org/gcube/application/cms/plugins/implementations/AbstractLifeCycleManager.java
View File

@ -41,7 +41,7 @@ import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public abstract class AbstractLifeCycleManager extends AbstractPlugin implements LifecycleManager { public abstract class AbstractLifeCycleManager extends AbstractPlugin implements LifecycleManager {
protected static class Events{ protected static class Events{
public static final OperationDescriptor INIT=new OperationDescriptor(EventExecutionRequest.Events.ON_INIT_DOCUMENT,"Sets defaults and validate"); public static final OperationDescriptor INIT=new OperationDescriptor(EventExecutionRequest.Events.ON_INIT_DOCUMENT,"Sets defaults and validate");
public static final OperationDescriptor UPDATE=new OperationDescriptor(EventExecutionRequest.Events.ON_UPDATE_DOCUMENT,"Sets defaults and validate"); public static final OperationDescriptor UPDATE=new OperationDescriptor(EventExecutionRequest.Events.ON_UPDATE_DOCUMENT,"Sets defaults and validate");

89
default-lc-managers/src/main/java/org/gcube/application/cms/plugins/implementations/Default3PhaseManager.java
View File

@ -29,7 +29,7 @@ import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public class Default3PhaseManager extends SimpleLifeCycleManager implements LifecycleManager { public class Default3PhaseManager extends SimpleLifeCycleManager implements LifecycleManager {
protected static class Phases { protected static class Phases {
public static final String PENDING_APPROVAL="Pending Approval"; public static final String PENDING_APPROVAL="Pending Approval";
public static final String PUBLISHED=SimpleLifeCycleManager.Phases.PUBLISHED; public static final String PUBLISHED=SimpleLifeCycleManager.Phases.PUBLISHED;
@ -171,42 +171,69 @@ public class Default3PhaseManager extends SimpleLifeCycleManager implements Life
protected Document getInternalIndexParams(BaseRequest req){ protected Document getInternalIndexParams(BaseRequest req){
Document callParameters = new Document(); Document callParameters = new Document();
callParameters.put("workspace", Files.fixFilename(req.getUseCaseDescriptor().getId()+"_internal_"+req.getContext().getName())); callParameters.put(IndexConstants.INDEX_PARAMETER_WORKSPACE, Files.fixFilename(req.getUseCaseDescriptor().getId()+"_internal_"+req.getContext().getName()));
callParameters.put("indexName",Files.fixFilename(req.getUseCaseDescriptor().getId()+"_internal_"+req.getContext().getName()+"_centroids")); callParameters.put(IndexConstants.INDEX_PARAMETER_INDEXNAME,Files.fixFilename(req.getUseCaseDescriptor().getId()+"_internal_"+req.getContext().getName()+"_centroids"));
//Added by Francesco
callParameters.put(IndexConstants.INDEX_PARAMETER_FLAGINTERNALINDEX, Boolean.TRUE);
return callParameters; return callParameters;
} }
protected StepExecutionReport executeSubmit(StepExecutionReport theReport) throws Exception { protected StepExecutionReport executeSubmit(StepExecutionReport theReport) throws Exception {
// Materialize log.info(STEPS.SUBMIT + " running...");
for(MaterializationPlugin mat : getMaterializers(theReport.getTheRequest())) // Materialize
theReport = materializeDocument(theReport,mat,getMaterializationParameters(theReport.getTheRequest())); for (MaterializationPlugin mat : getMaterializers(theReport.getTheRequest()))
if(theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK)){ theReport = materializeDocument(theReport, mat, getMaterializationParameters(theReport.getTheRequest()));
// Index if (theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK)) {
for(IndexerPluginInterface indexer : getIndexers(theReport.getTheRequest())) // Index
theReport = index(theReport,indexer,getInternalIndexParams(theReport.getTheRequest())); for (IndexerPluginInterface indexer : getIndexers(theReport.getTheRequest()))
// setPhase theReport = index(theReport, indexer, getInternalIndexParams(theReport.getTheRequest()));
if(theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK)) // setPhase
theReport.getToSetLifecycleInformation().setPhase(Phases.PENDING_APPROVAL); if (theReport.getToSetLifecycleInformation().getLastOperationStatus()
} .equals(LifecycleInformation.Status.OK))
return theReport; theReport.getToSetLifecycleInformation().setPhase(Phases.PENDING_APPROVAL);
} }
return theReport;
}
protected StepExecutionReport executeApprove(StepExecutionReport theReport) throws Exception { protected StepExecutionReport executeApprove(StepExecutionReport theReport) throws Exception {
// Index log.info(STEPS.APPROVE + " running...");
for(IndexerPluginInterface indexer : getIndexers(theReport.getTheRequest()))
theReport = index(theReport,indexer,getPublicIndexParams(theReport.getTheRequest()));
// setPhase
if(theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK))
theReport.getToSetLifecycleInformation().setPhase(Phases.PUBLISHED);
return theReport;
}
protected StepExecutionReport executeReject(StepExecutionReport theReport) throws Exception { // Index
if(theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK)) for (IndexerPluginInterface indexer : getIndexers(theReport.getTheRequest()))
theReport.getToSetLifecycleInformation().setPhase(LifecycleInformation.CommonPhases.DRAFT_PHASE); theReport = index(theReport, indexer, getPublicIndexParams(theReport.getTheRequest()));
return theReport; // setPhase
} if (theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK))
theReport.getToSetLifecycleInformation().setPhase(Phases.PUBLISHED);
return theReport;
}
//Updated by Francesco, see #24877
protected StepExecutionReport executeReject(StepExecutionReport theReport) throws Exception {
log.info(STEPS.REJECT + " running...");
// DeMaterialize
JSONPathWrapper wrapper = new JSONPathWrapper(theReport.getTheRequest().getDocument().getTheDocument().toJson());
for (String s : wrapper.getMatchingPaths("$..[?(@." + RegisteredFileSet.PAYLOADS + ")]")) {
log.info("Requesting dematerialization for {} ", s);
for (MaterializationPlugin mat : getMaterializers(theReport.getTheRequest()))
theReport = deMaterialize(theReport, mat, new Document("fileSetPath", s));
if (!theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK))
break;
}
// DeIndexing
if (theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK)) {
for (IndexerPluginInterface indexer : getIndexers(theReport.getTheRequest())) {
log.info("Requesting deindexing for {} ", indexer.getDescriptor());
theReport = deIndex(theReport, indexer, getInternalIndexParams(theReport.getTheRequest()));
}
}
if (theReport.getToSetLifecycleInformation().getLastOperationStatus().equals(LifecycleInformation.Status.OK))
theReport.getToSetLifecycleInformation().setPhase(LifecycleInformation.CommonPhases.DRAFT_PHASE);
return theReport;
}
} }

16
default-lc-managers/src/main/java/org/gcube/application/cms/plugins/implementations/IndexConstants.java Normal file
View File

@ -0,0 +1,16 @@
package org.gcube.application.cms.plugins.implementations;
/**
* The Class IndexConstants.
*
* @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
*
* Mar 29, 2023
*/
public class IndexConstants {
public static final String INDEX_PARAMETER_FLAGINTERNALINDEX = "flagInternalIndex";
public static final String INDEX_PARAMETER_INDEXNAME = "indexName";
public static final String INDEX_PARAMETER_WORKSPACE = "workspace";
}

5
default-lc-managers/src/main/java/org/gcube/application/cms/plugins/implementations/SimpleLifeCycleManager.java
View File

@ -93,8 +93,9 @@ public class SimpleLifeCycleManager extends AbstractLifeCycleManager implements
protected Document getPublicIndexParams(BaseRequest req){ protected Document getPublicIndexParams(BaseRequest req){
Document callParameters = new Document(); Document callParameters = new Document();
callParameters.put("workspace",Files.fixFilename(req.getUseCaseDescriptor().getId()+req.getContext().getName())); callParameters.put(IndexConstants.INDEX_PARAMETER_WORKSPACE,Files.fixFilename(req.getUseCaseDescriptor().getId()+req.getContext().getName()));
callParameters.put("indexName",Files.fixFilename(req.getUseCaseDescriptor().getId()+req.getContext().getName()+"_centroids")); callParameters.put(IndexConstants.INDEX_PARAMETER_INDEXNAME,Files.fixFilename(req.getUseCaseDescriptor().getId()+req.getContext().getName()+"_centroids"));
callParameters.put(IndexConstants.INDEX_PARAMETER_FLAGINTERNALINDEX, Boolean.FALSE);
return callParameters; return callParameters;
} }

3
geoportal-service/CHANGELOG.md
View File

@ -1,5 +1,8 @@
# Changelog for org.gcube.application.geoportal-service # Changelog for org.gcube.application.geoportal-service
## [v1.0.14-SNAPSHOT]
- Fixed deploying of multiple versions of the default-lc-managers [#24875]
## [v1.0.13] - 2023-02-23 ## [v1.0.13] - 2023-02-23
- Integrating new facilities and bug fixing released in the Plugins - Integrating new facilities and bug fixing released in the Plugins

9
geoportal-service/pom.xml
View File

@ -4,7 +4,7 @@
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>org.gcube.application</groupId> <groupId>org.gcube.application</groupId>
<artifactId>geoportal-service</artifactId> <artifactId>geoportal-service</artifactId>
<version>1.0.13</version> <version>1.0.14-SNAPSHOT</version>
<name>Geoportal Service</name> <name>Geoportal Service</name>
<packaging>war</packaging> <packaging>war</packaging>
@ -21,16 +21,12 @@
<webappDirectory>${project.basedir}${file.separator}${project.artifactId}${file.separator}src${file.separator}main${file.separator}webapp${file.separator}WEB-INF</webappDirectory> <webappDirectory>${project.basedir}${file.separator}${project.artifactId}${file.separator}src${file.separator}main${file.separator}webapp${file.separator}WEB-INF</webappDirectory>
</properties> </properties>
<scm> <scm>
<connection>scm:git:${gitBaseUrl}/gcube-cms-suite</connection> <connection>scm:git:${gitBaseUrl}/gcube-cms-suite</connection>
<developerConnection>scm:git:${gitBaseUrl}/gcube-cms-suite</developerConnection> <developerConnection>scm:git:${gitBaseUrl}/gcube-cms-suite</developerConnection>
<url>${gitBaseUrl}/gcube-cms-suite</url> <url>${gitBaseUrl}/gcube-cms-suite</url>
</scm> </scm>
<dependencyManagement> <dependencyManagement>
<dependencies> <dependencies>
<dependency> <dependency>
@ -94,7 +90,6 @@
</dependency> </dependency>
<!-- enunciate deps --> <!-- enunciate deps -->
<dependency> <dependency>
<groupId>com.webcohesion.enunciate</groupId> <groupId>com.webcohesion.enunciate</groupId>
@ -173,7 +168,7 @@
<build> <build>
<plugins> <plugins>
<!-- SPHINX PLUGIN triggered at 'compile'--> <!-- SPHINX PLUGIN triggered at 'compile' -->
<plugin> <plugin>
<groupId>kr.motd.maven</groupId> <groupId>kr.motd.maven</groupId>
<artifactId>sphinx-maven-plugin</artifactId> <artifactId>sphinx-maven-plugin</artifactId>

4
sdi-plugins/CHANGELOG.md
View File

@ -1,5 +1,9 @@
# Changelog for org.gcube.application.cms.sdi-plugins # Changelog for org.gcube.application.cms.sdi-plugins
## [v1.1.0-SNAPSHOT]
- Integrated the field 'geov_link' (Geoportal GisViewer link) in the centroid layer [#24859]
## [v1.0.4] - 2023-03-06 ## [v1.0.4] - 2023-03-06
- Fixed the import from joda-time to java.time - Fixed the import from joda-time to java.time
- [#24702] Fixed the default-lc-managers dependency - [#24702] Fixed the default-lc-managers dependency

9
sdi-plugins/pom.xml
View File

@ -5,7 +5,7 @@
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<artifactId>sdi-plugins</artifactId> <artifactId>sdi-plugins</artifactId>
<version>1.0.4</version> <version>1.1.0-SNAPSHOT</version>
<name>gCube CMS - SDI Plugins</name> <name>gCube CMS - SDI Plugins</name>
@ -85,12 +85,19 @@
<version>1.14</version> <version>1.14</version>
</dependency> </dependency>
<dependency>
<groupId>org.gcube.portlets.user</groupId>
<artifactId>uri-resolver-manager</artifactId>
<version>[1.0.0,2.0.0-SNAPSHOT)</version>
</dependency>
<dependency> <dependency>
<groupId>org.gcube.application.cms</groupId> <groupId>org.gcube.application.cms</groupId>
<artifactId>cms-test-commons</artifactId> <artifactId>cms-test-commons</artifactId>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
</dependencies> </dependencies>
<build> <build>

6
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/DBConstants.java
View File

@ -2,7 +2,9 @@ package org.gcube.application.cms.sdi.engine;
import java.util.ArrayList; import java.util.ArrayList;
import static org.gcube.application.cms.sdi.engine.PostgisTable.*; import org.gcube.application.cms.sdi.engine.PostgisTable.Field;
import org.gcube.application.cms.sdi.engine.PostgisTable.FieldType;
import org.gcube.application.cms.sdi.engine.PostgisTable.GeometryType;
public class DBConstants { public class DBConstants {
@ -18,6 +20,8 @@ public class DBConstants {
public static final String PROJECT_ID="projectid"; public static final String PROJECT_ID="projectid";
public static final String DISPLAYED="displayed_project"; public static final String DISPLAYED="displayed_project";
public static final String GEOVIEWER_LINK_FIELD="geov_link";
public static final String XCOORD_FIELD="xcoord"; public static final String XCOORD_FIELD="xcoord";

9
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/PostgisDBManager.java
View File

@ -1,9 +1,5 @@
package org.gcube.application.cms.sdi.engine; package org.gcube.application.cms.sdi.engine;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.cms.sdi.faults.DataParsingException;
import org.gcube.application.geoportal.common.model.legacy.BBOX;
import java.sql.Connection; import java.sql.Connection;
import java.sql.PreparedStatement; import java.sql.PreparedStatement;
import java.sql.ResultSet; import java.sql.ResultSet;
@ -11,6 +7,11 @@ import java.sql.SQLException;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import org.gcube.application.cms.sdi.faults.DataParsingException;
import org.gcube.application.geoportal.common.model.legacy.BBOX;
import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public class PostgisDBManager implements PostgisDBManagerI { public class PostgisDBManager implements PostgisDBManagerI {

26
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/PostgisIndexer.java
View File

@ -1,16 +1,5 @@
package org.gcube.application.cms.sdi.engine; package org.gcube.application.cms.sdi.engine;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;
import org.bson.Document;
import org.gcube.application.cms.sdi.faults.SDIInteractionException;
import org.gcube.application.cms.sdi.model.CrossReferencedLayer;
import org.gcube.application.cms.sdi.plugins.SDIIndexerPlugin;
import org.gcube.application.geoportal.common.model.configuration.Index;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.rest.DatabaseConnection;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import java.sql.DriverManager; import java.sql.DriverManager;
import java.sql.PreparedStatement; import java.sql.PreparedStatement;
import java.sql.SQLException; import java.sql.SQLException;
@ -18,6 +7,17 @@ import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import org.bson.Document;
import org.gcube.application.cms.sdi.faults.SDIInteractionException;
import org.gcube.application.cms.sdi.model.CrossReferencedLayer;
import org.gcube.application.geoportal.common.model.configuration.Index;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.rest.DatabaseConnection;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public class PostgisIndexer { public class PostgisIndexer {
@ -39,8 +39,8 @@ public class PostgisIndexer {
public static class StandardFields{ public static class StandardFields{
public static final PostgisTable.Field PROJECT_ID= new PostgisTable.Field(DBConstants.Defaults.PROJECT_ID, PostgisTable.FieldType.TEXT); public static final PostgisTable.Field PROJECT_ID= new PostgisTable.Field(DBConstants.Defaults.PROJECT_ID, PostgisTable.FieldType.TEXT);
public static final PostgisTable.Field GEOM= new PostgisTable.Field(DBConstants.Defaults.DEFAULT_GEOMETRY_COLUMN_NAME, PostgisTable.FieldType.GEOMETRY); public static final PostgisTable.Field GEOM= new PostgisTable.Field(DBConstants.Defaults.DEFAULT_GEOMETRY_COLUMN_NAME, PostgisTable.FieldType.GEOMETRY);
public static final PostgisTable.Field DISPLAY=new PostgisTable.Field(DBConstants.Defaults.DISPLAYED,PostgisTable.FieldType.BOOLEAN); public static final PostgisTable.Field DISPLAY=new PostgisTable.Field(DBConstants.Defaults.DISPLAYED,PostgisTable.FieldType.BOOLEAN);
public static final PostgisTable.Field GEOV_LINK=new PostgisTable.Field(DBConstants.Defaults.GEOVIEWER_LINK_FIELD,PostgisTable.FieldType.TEXT);
} }
@ -85,10 +85,10 @@ public class PostgisIndexer {
tableFields.add(StandardFields.GEOM); tableFields.add(StandardFields.GEOM);
tableFields.add(StandardFields.PROJECT_ID); tableFields.add(StandardFields.PROJECT_ID);
tableFields.add(StandardFields.DISPLAY); tableFields.add(StandardFields.DISPLAY);
tableFields.add(StandardFields.GEOV_LINK);
tableFields.addAll(customFields); tableFields.addAll(customFields);
table = new PostgisTable(indexName,tableFields, PostgisTable.GeometryType.POINT); table = new PostgisTable(indexName,tableFields, PostgisTable.GeometryType.POINT);
log.trace("Index Postgis Table is {} ",table); log.trace("Index Postgis Table is {} ",table);
log.debug("Create if missing.."); log.debug("Create if missing..");

548
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/PostgisTable.java
View File

@ -1,20 +1,29 @@
package org.gcube.application.cms.sdi.engine; package org.gcube.application.cms.sdi.engine;
import lombok.*; import java.sql.PreparedStatement;
import lombok.extern.slf4j.Slf4j; import java.sql.SQLException;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.gcube.application.cms.sdi.faults.DataParsingException; import org.gcube.application.cms.sdi.faults.DataParsingException;
import org.gcube.application.cms.sdi.model.MappingObject; import org.gcube.application.cms.sdi.model.MappingObject;
import org.gcube.application.geoportal.common.model.legacy.BBOX; import org.gcube.application.geoportal.common.model.legacy.BBOX;
import java.sql.Array; import lombok.AllArgsConstructor;
import java.sql.PreparedStatement; import lombok.Getter;
import java.sql.SQLException; import lombok.NonNull;
import java.sql.Types; import lombok.RequiredArgsConstructor;
import java.text.DecimalFormat; import lombok.Setter;
import java.text.NumberFormat; import lombok.ToString;
import java.util.*; import lombok.extern.slf4j.Slf4j;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@Slf4j @Slf4j
@RequiredArgsConstructor @RequiredArgsConstructor
@ -22,315 +31,314 @@ import java.util.regex.Pattern;
@ToString @ToString
public class PostgisTable { public class PostgisTable {
@Getter
@AllArgsConstructor
public static enum GeometryType {
MULTIPOINT("4326", "geometry (MULTIPOINT,4326)", "", ""), POINT("4326", "geometry (POINT,4326)", "", ""),
LINE("4326", "geometry (MULTILINESTRING,4326)", "", ""),
POLYGON("4326", "geometry (MULTIPOLYGON,4326)", "", "");
@Getter private final String SRID;
@AllArgsConstructor private final String definition;
public static enum GeometryType{ private final String InsertWKT;
MULTIPOINT("4326","geometry (MULTIPOINT,4326)","",""), private final String insertWKB;
POINT("4326","geometry (POINT,4326)","",""),
LINE("4326","geometry (MULTILINESTRING,4326)","",""),
POLYGON("4326","geometry (MULTIPOLYGON,4326)","","");
private final String SRID;
private final String definition;
private final String InsertWKT;
private final String insertWKB;
}
} @RequiredArgsConstructor
@Getter
@Setter
@ToString
public static class Field {
@NonNull
private String name;
@NonNull
private FieldType type;
private Boolean isIndexed;
private Object constantValue;
@RequiredArgsConstructor public static final Field fromMapping(MappingObject m) {
@Getter return new PostgisTable.Field(m.getName(), PostgisTable.FieldType.valueOf(m.getType()));
@Setter }
@ToString
public static class Field{
@NonNull
private String name;
@NonNull
private FieldType type;
private Boolean isIndexed;
private Object constantValue;
public static final Field fromMapping(MappingObject m){ public static final List<Field> fromMappings(Collection<MappingObject> coll) {
return new PostgisTable.Field(m.getName(), PostgisTable.FieldType.valueOf(m.getType())); ArrayList<Field> toReturn = new ArrayList<>();
} if (coll != null)
coll.forEach(m -> toReturn.add(fromMapping(m)));
return toReturn;
}
}
public static final List<Field> fromMappings (Collection<MappingObject> coll){ @Getter
ArrayList<Field> toReturn = new ArrayList<>(); @AllArgsConstructor
if(coll!=null) public enum FieldType {
coll.forEach(m -> toReturn.add(fromMapping(m))); INT("int", java.sql.Types.INTEGER), BOOLEAN("boolean", java.sql.Types.BOOLEAN),
return toReturn; TEXT("text", java.sql.Types.LONGVARCHAR), FLOAT("float", java.sql.Types.FLOAT), GEOMETRY("", 0),
} AUTOINCREMENT("BIGSERIAL PRIMARY KEY", java.sql.Types.BIGINT);
}
@Getter private String definition;
@AllArgsConstructor private int sqlType;
public enum FieldType{ }
INT("int",java.sql.Types.INTEGER),
BOOLEAN("boolean", java.sql.Types.BOOLEAN),
TEXT("text",java.sql.Types.LONGVARCHAR),
FLOAT("float",java.sql.Types.FLOAT),
GEOMETRY("",0),
AUTOINCREMENT("BIGSERIAL PRIMARY KEY",java.sql.Types.BIGINT);
private String definition; @RequiredArgsConstructor
private int sqlType; @Getter
} @ToString
public static class POINT {
private static Pattern pattern = Pattern.compile("(?!=\\d\\.\\d\\.)([\\d.]+)");
@RequiredArgsConstructor public static POINT parsePOINT(String point) throws DataParsingException {
@Getter // POINT(8.30230113965909 44.8011688237011)
@ToString // x,y
public static class POINT{ try {
log.debug("Parsing POINT " + point);
Matcher m = pattern.matcher(point);
private static Pattern pattern = Pattern.compile("(?!=\\d\\.\\d\\.)([\\d.]+)"); if (!m.find())
throw new DataParsingException("Unable to get x ");
Double x = Double.parseDouble(m.group(1));
public static POINT parsePOINT(String point) throws DataParsingException { if (!m.find())
//POINT(8.30230113965909 44.8011688237011) throw new DataParsingException("Unable to get y ");
// x,y Double y = Double.parseDouble(m.group(1));
try {
log.debug("Parsing POINT "+point);
Matcher m=pattern.matcher(point);
if(!m.find()) throw new DataParsingException("Unable to get x "); return new POINT(x, y);
Double x=Double.parseDouble(m.group(1)); } catch (Throwable t) {
throw new DataParsingException("Invalid POINT " + point, t);
}
}
if(!m.find()) throw new DataParsingException("Unable to get y "); @NonNull
Double y=Double.parseDouble(m.group(1)); private Double x;
@NonNull
private Double y;
return new POINT(x,y); }
}catch(Throwable t) {
throw new DataParsingException("Invalid POINT "+point,t);
}
}
@NonNull private static final NumberFormat DECIMAL_FORMAT = NumberFormat.getInstance(Locale.US);
private Double x;
@NonNull
private Double y;
} static {
((DecimalFormat) DECIMAL_FORMAT).setGroupingUsed(false);
}
public String getGeometryColumn() {
for (Field f : fields)
if (f.getType().equals(FieldType.GEOMETRY))
return f.getName();
return null;
}
private static final NumberFormat DECIMAL_FORMAT=NumberFormat.getInstance(Locale.US); @NonNull
private String tablename;
static { @NonNull
((DecimalFormat) DECIMAL_FORMAT).setGroupingUsed(false); private List<Field> fields;
}
@NonNull
private GeometryType geometryColumnType;
public String getGeometryColumn() { @Setter
for(Field f:fields) private BBOX boundingBox = null;
if(f.getType().equals(FieldType.GEOMETRY)) return f.getName();
return null;
}
@NonNull @Setter
private String tablename; private POINT centroid = null;
@NonNull public void setTablename(String tablename) {
private List<Field> fields; this.tablename = sanitizeFieldName(tablename);
}
public String getCreateStatement() {
StringBuilder stmt = new StringBuilder();
stmt.append("CREATE TABLE IF NOT EXISTS " + tablename + "( ");
for (Field field : fields) {
@NonNull String fieldDefinition = field.getType().getDefinition();
private GeometryType geometryColumnType; if (field.getType().equals(FieldType.GEOMETRY))
fieldDefinition = this.getGeometryColumnType().definition;
@Setter stmt.append(field.getName() + " " + fieldDefinition + ",");
private BBOX boundingBox=null; }
stmt.deleteCharAt(stmt.lastIndexOf(","));
stmt.append(")");
return stmt.toString();
}
@Setter public String getDeleteByFieldStatement(Field field) {
private POINT centroid=null; return "DELETE FROM " + tablename + " WHERE " + field.getName() + " = ? ";
}
public void setTablename(String tablename) { public String getInsertionStatement(boolean geometryText) {
this.tablename = sanitizeFieldName(tablename); StringBuilder fieldList = new StringBuilder();
} StringBuilder fieldInsertion = new StringBuilder();
public String getCreateStatement() { for (Field field : fields) {
StringBuilder stmt=new StringBuilder(); switch (field.getType()) {
stmt.append("CREATE TABLE IF NOT EXISTS "+tablename+"( "); case AUTOINCREMENT:
for(Field field:fields){ break;
case GEOMETRY: {
fieldList.append(field.getName() + ",");
if (geometryText)
fieldInsertion.append("ST_GeomFromText(?, 4326),");
else
fieldInsertion.append("ST_GeomFromWKB(?, 4326),");
break;
}
default: {
fieldList.append(field.getName() + ",");
fieldInsertion.append("?,");
}
}
}
String fieldDefinition=field.getType().getDefinition(); fieldList.deleteCharAt(fieldList.lastIndexOf(","));
if(field.getType().equals(FieldType.GEOMETRY)) fieldInsertion.deleteCharAt(fieldInsertion.lastIndexOf(","));
fieldDefinition=this.getGeometryColumnType().definition;
stmt.append(field.getName()+" "+fieldDefinition+","); return "Insert into " + tablename + " (" + fieldList + ") VALUES (" + fieldInsertion + ")";
} }
stmt.deleteCharAt(stmt.lastIndexOf(","));
stmt.append(")");
return stmt.toString();
}
public String getDeleteByFieldStatement(Field field) { public void fillObjectsPreparedStatement(Map<String, Object> row, PreparedStatement toFill) throws SQLException {
return "DELETE FROM "+tablename+" WHERE "+field.getName()+" = ? "; int psFieldIndex = 0;
} HashMap<String, Object> rowValues = new HashMap<String, Object>();
for (Map.Entry<String, Object> entry : row.entrySet())
rowValues.put(sanitizeFieldName(entry.getKey()), entry.getValue());
for (Field field : fields) {
if (!field.getType().equals(FieldType.AUTOINCREMENT)) {
psFieldIndex++;
public String getInsertionStatement(boolean geometryText) { Object value = rowValues.get(field.getName());
StringBuilder fieldList=new StringBuilder(); setObjectInPreparedStatement(field, value, toFill, psFieldIndex);
StringBuilder fieldInsertion=new StringBuilder();
for(Field field:fields) { }
switch(field.getType()) {
case AUTOINCREMENT : break;
case GEOMETRY : {
fieldList.append(field.getName()+",");
if(geometryText)
fieldInsertion.append("ST_GeomFromText(?, 4326),");
else
fieldInsertion.append("ST_GeomFromWKB(?, 4326),");
break;
}
default : {
fieldList.append(field.getName()+",");
fieldInsertion.append("?,");
}
}
}
fieldList.deleteCharAt(fieldList.lastIndexOf(",")); }
fieldInsertion.deleteCharAt(fieldInsertion.lastIndexOf(",")); }
public void setObjectInPreparedStatement(Field field, Object value, PreparedStatement toFill, int psFieldIndex)
throws SQLException {
if (value == null) {
try {
toFill.setNull(psFieldIndex, field.getType().sqlType);
} catch (SQLException e) {
log.error("Unable to set null for field " + field);
throw e;
}
} else {
switch (field.getType()) {
case FLOAT: {
toFill.setFloat(psFieldIndex, (Float) value);
break;
}
case INT: {
toFill.setInt(psFieldIndex, (Integer) value);
break;
}
case TEXT: {
toFill.setString(psFieldIndex, value.toString());
break;
}
case GEOMETRY: {
if (value instanceof String)
toFill.setString(psFieldIndex, ((String) value));
else
toFill.setBytes(psFieldIndex, (byte[]) value);
break;
}
case BOOLEAN: {
if (value instanceof String)
toFill.setBoolean(psFieldIndex, Boolean.parseBoolean(value.toString()));
if (value instanceof Boolean)
toFill.setBoolean(psFieldIndex, (Boolean) value);
break;
}
// Added by Francesco
default: {
if (value instanceof String) {
toFill.setString(psFieldIndex, ((String) value));
} else {
try {
String toStringValue = value.toString();
toFill.setString(psFieldIndex, toStringValue);
} catch (Exception e) {
// silence
}
}
}
}
}
}
return "Insert into "+tablename+" ("+fieldList+") VALUES ("+fieldInsertion+")"; public void fillCSVPreparedStatament(Map<String, String> row, PreparedStatement toFill, boolean explicitGeometry)
} throws SQLException {
int psFieldIndex = 0;
HashMap<String, String> rowValues = new HashMap<String, String>();
for (Map.Entry<String, String> entry : row.entrySet())
rowValues.put(sanitizeFieldName(entry.getKey()), entry.getValue());
public void fillObjectsPreparedStatement(Map<String,Object> row, PreparedStatement toFill) throws SQLException { for (Field field : fields) {
int psFieldIndex=0;
HashMap<String,Object> rowValues=new HashMap<String,Object>();
for(Map.Entry<String,Object> entry:row.entrySet())
rowValues.put(sanitizeFieldName(entry.getKey()), entry.getValue());
if (!field.getType().equals(FieldType.AUTOINCREMENT)) {
psFieldIndex++;
for(Field field:fields) { String value = rowValues.get(field.getName());
if(!field.getType().equals(FieldType.AUTOINCREMENT)) {
psFieldIndex++;
Object value=rowValues.get(field.getName());
setObjectInPreparedStatement(field,value,toFill,psFieldIndex);
}
}
}
public void setObjectInPreparedStatement(Field field,Object value, PreparedStatement toFill, int psFieldIndex) throws SQLException {
if(value==null) {
try{
toFill.setNull(psFieldIndex, field.getType().sqlType);
}catch(SQLException e) {
log.error("Unable to set null for field "+field);
throw e;
}
}
else
switch(field.getType()) {
case FLOAT :{
toFill.setFloat(psFieldIndex, (Float)value);
break;
}
case INT : {
toFill.setInt(psFieldIndex, (Integer)value);
break;
}
case TEXT : {
toFill.setString(psFieldIndex, value.toString());
break;
}
case GEOMETRY : {
if(value instanceof String)
toFill.setString(psFieldIndex, ((String) value));
else toFill.setBytes(psFieldIndex, (byte[])value);
break;
}
case BOOLEAN: {
if(value instanceof String)
toFill.setBoolean(psFieldIndex,Boolean.parseBoolean(value.toString()));
if(value instanceof Boolean)
toFill.setBoolean(psFieldIndex,(Boolean) value);
break;
}
}
}
public void fillCSVPreparedStatament(Map<String,String> row, PreparedStatement toFill,boolean explicitGeometry) throws SQLException {
int psFieldIndex=0;
HashMap<String,String> rowValues=new HashMap<String,String>();
for(Map.Entry<String,String> entry:row.entrySet())
rowValues.put(sanitizeFieldName(entry.getKey()), entry.getValue());
for(Field field:fields) {
if(!field.getType().equals(FieldType.AUTOINCREMENT)) {
psFieldIndex++;
String value=rowValues.get(field.getName());
// if(value==null||value.equalsIgnoreCase("null")) toFill.setNull(psFieldIndex, field.getType().sqlType); // if(value==null||value.equalsIgnoreCase("null")) toFill.setNull(psFieldIndex, field.getType().sqlType);
// else // else
switch(field.getType()) { switch (field.getType()) {
case FLOAT :{ case FLOAT: {
try{ try {
toFill.setFloat(psFieldIndex, Float.parseFloat(value)); toFill.setFloat(psFieldIndex, Float.parseFloat(value));
}catch(NumberFormatException e) { } catch (NumberFormatException e) {
throw new SQLException(field+" cannot be null. CSV Row is "+rowValues,e); throw new SQLException(field + " cannot be null. CSV Row is " + rowValues, e);
} }
break; break;
} }
case INT : { case INT: {
try{ try {
toFill.setInt(psFieldIndex, Integer.parseInt(value)); toFill.setInt(psFieldIndex, Integer.parseInt(value));
}catch(NumberFormatException e) { } catch (NumberFormatException e) {
log.warn("Skipping value for "+field+" row was "+rowValues,e); log.warn("Skipping value for " + field + " row was " + rowValues, e);
toFill.setNull(psFieldIndex, java.sql.Types.INTEGER); toFill.setNull(psFieldIndex, java.sql.Types.INTEGER);
} }
break; break;
} }
case TEXT : { case TEXT: {
toFill.setString(psFieldIndex, value.toString()); toFill.setString(psFieldIndex, value.toString());
break; break;
} }
case GEOMETRY : { case GEOMETRY: {
if(explicitGeometry) { if (explicitGeometry) {
toFill.setString(psFieldIndex,value); toFill.setString(psFieldIndex, value);
}else { } else {
switch(geometryColumnType){ switch (geometryColumnType) {
case POINT: { case POINT: {
String xRepresentation=DECIMAL_FORMAT.format(Double.parseDouble(rowValues.get(DBConstants.Defaults.XCOORD_FIELD))); String xRepresentation = DECIMAL_FORMAT
String yRepresentation=DECIMAL_FORMAT.format(Double.parseDouble(rowValues.get(DBConstants.Defaults.YCOORD_FIELD))); .format(Double.parseDouble(rowValues.get(DBConstants.Defaults.XCOORD_FIELD)));
String yRepresentation = DECIMAL_FORMAT
.format(Double.parseDouble(rowValues.get(DBConstants.Defaults.YCOORD_FIELD)));
toFill.setString(psFieldIndex, "POINT("+xRepresentation+" "+ toFill.setString(psFieldIndex, "POINT(" + xRepresentation + " " + yRepresentation + ")");
yRepresentation+")"); break;
break; }
} default: {
default :{ toFill.setString(psFieldIndex, rowValues.get("wkt"));
toFill.setString(psFieldIndex,rowValues.get("wkt")); break;
break; }
} }
} }
} break;
break; }
} }
} }
}
}
}
public static String sanitizeFieldName(String fieldName) {
}
}
public static String sanitizeFieldName(String fieldName) {
// return fieldName.toLowerCase().replaceAll(" ", "_").replaceAll("\\.", "").replaceAll("-", "_").replaceAll("////","_"); // return fieldName.toLowerCase().replaceAll(" ", "_").replaceAll("\\.", "").replaceAll("-", "_").replaceAll("////","_");
return fieldName.toLowerCase().replaceAll("[^a-z0-9_\\\\]", "_"); return fieldName.toLowerCase().replaceAll("[^a-z0-9_\\\\]", "_");
} }
} }

19
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/SDIManager.java
View File

@ -1,21 +1,22 @@
package org.gcube.application.cms.sdi.engine; package org.gcube.application.cms.sdi.engine;
import it.geosolutions.geoserver.rest.encoder.datastore.GSPostGISDatastoreEncoder;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.cms.sdi.faults.SDIInteractionException;
import org.gcube.application.geoportal.common.model.rest.DatabaseConnection;
import org.gcube.data.transfer.library.DataTransferClient;
import org.gcube.spatial.data.gis.GISInterface;
import org.gcube.spatial.data.gis.is.AbstractGeoServerDescriptor;
import java.io.File; import java.io.File;
import java.net.MalformedURLException; import java.net.MalformedURLException;
import java.net.URL; import java.net.URL;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import org.gcube.application.cms.sdi.faults.SDIInteractionException;
import org.gcube.application.geoportal.common.model.rest.DatabaseConnection;
import org.gcube.data.transfer.library.DataTransferClient;
import org.gcube.spatial.data.gis.GISInterface;
import org.gcube.spatial.data.gis.is.AbstractGeoServerDescriptor;
import it.geosolutions.geoserver.rest.encoder.datastore.GSPostGISDatastoreEncoder;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public class SDIManager { public class SDIManager {

42
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/SDIManagerWrapper.java
View File

@ -1,13 +1,15 @@
package org.gcube.application.cms.sdi.engine; package org.gcube.application.cms.sdi.engine;
import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; import static it.geosolutions.geoserver.rest.encoder.GSResourceEncoder.ProjectionPolicy.REPROJECT_TO_DECLARED;
import it.geosolutions.geoserver.rest.GeoServerRESTReader; import static org.gcube.application.cms.sdi.model.GCubeSDILayerBuilder.EPSG_4326;
import it.geosolutions.geoserver.rest.decoder.RESTFeatureType; import static org.gcube.application.cms.sdi.model.GCubeSDILayerBuilder.WGS84_FULL;
import it.geosolutions.geoserver.rest.decoder.RESTLayer;
import it.geosolutions.geoserver.rest.encoder.GSLayerEncoder; import java.io.File;
import it.geosolutions.geoserver.rest.encoder.feature.GSAttributeEncoder; import java.net.MalformedURLException;
import it.geosolutions.geoserver.rest.encoder.feature.GSFeatureTypeEncoder; import java.net.URL;
import lombok.extern.slf4j.Slf4j; import java.util.ArrayList;
import java.util.List;
import org.bson.Document; import org.bson.Document;
import org.gcube.application.cms.plugins.requests.BaseExecutionRequest; import org.gcube.application.cms.plugins.requests.BaseExecutionRequest;
import org.gcube.application.cms.sdi.faults.SDIInteractionException; import org.gcube.application.cms.sdi.faults.SDIInteractionException;
@ -21,23 +23,25 @@ import org.gcube.application.geoportal.common.model.document.filesets.sdi.GeoSer
import org.gcube.application.geoportal.common.model.document.filesets.sdi.PlatformInfo; import org.gcube.application.geoportal.common.model.document.filesets.sdi.PlatformInfo;
import org.gcube.application.geoportal.common.model.rest.DatabaseConnection; import org.gcube.application.geoportal.common.model.rest.DatabaseConnection;
import org.gcube.application.geoportal.common.utils.Files; import org.gcube.application.geoportal.common.utils.Files;
import org.gcube.data.transfer.library.DataTransferClient;
import org.gcube.data.transfer.library.TransferResult; import org.gcube.data.transfer.library.TransferResult;
import org.gcube.data.transfer.library.client.Client; import org.gcube.data.transfer.library.client.Client;
import org.gcube.data.transfer.library.faults.*; import org.gcube.data.transfer.library.faults.DestinationNotSetException;
import org.gcube.data.transfer.library.faults.FailedTransferException;
import org.gcube.data.transfer.library.faults.InitializationException;
import org.gcube.data.transfer.library.faults.InvalidDestinationException;
import org.gcube.data.transfer.library.faults.InvalidSourceException;
import org.gcube.data.transfer.library.faults.SourceNotSetException;
import org.gcube.data.transfer.model.Destination; import org.gcube.data.transfer.model.Destination;
import org.gcube.data.transfer.model.DestinationClashPolicy; import org.gcube.data.transfer.model.DestinationClashPolicy;
import org.gcube.spatial.data.gis.is.AbstractGeoServerDescriptor; import org.gcube.spatial.data.gis.is.AbstractGeoServerDescriptor;
import java.io.File; import it.geosolutions.geoserver.rest.GeoServerRESTPublisher;
import java.net.MalformedURLException; import it.geosolutions.geoserver.rest.GeoServerRESTReader;
import java.net.URL; import it.geosolutions.geoserver.rest.decoder.RESTFeatureType;
import java.util.ArrayList; import it.geosolutions.geoserver.rest.decoder.RESTLayer;
import java.util.List; import it.geosolutions.geoserver.rest.encoder.GSLayerEncoder;
import it.geosolutions.geoserver.rest.encoder.feature.GSFeatureTypeEncoder;
import static it.geosolutions.geoserver.rest.encoder.GSResourceEncoder.ProjectionPolicy.REPROJECT_TO_DECLARED; import lombok.extern.slf4j.Slf4j;
import static org.gcube.application.cms.sdi.model.GCubeSDILayerBuilder.EPSG_4326;
import static org.gcube.application.cms.sdi.model.GCubeSDILayerBuilder.WGS84_FULL;
@Slf4j @Slf4j
public class SDIManagerWrapper extends SDIManager{ public class SDIManagerWrapper extends SDIManager{

9
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/bboxes/BBOXByCoordinatePaths.java
View File

@ -1,15 +1,16 @@
package org.gcube.application.cms.sdi.engine.bboxes; package org.gcube.application.cms.sdi.engine.bboxes;
import lombok.Data; import java.util.List;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.bson.Document; import org.bson.Document;
import org.gcube.application.cms.serialization.Serialization; import org.gcube.application.cms.serialization.Serialization;
import org.gcube.application.geoportal.common.model.JSONPathWrapper; import org.gcube.application.geoportal.common.model.JSONPathWrapper;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer; import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor; import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import java.util.List; import lombok.Data;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public class BBOXByCoordinatePaths extends BBOXEvaluator{ public class BBOXByCoordinatePaths extends BBOXEvaluator{

9
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/bboxes/BBOXEvaluator.java
View File

@ -1,13 +1,14 @@
package org.gcube.application.cms.sdi.engine.bboxes; package org.gcube.application.cms.sdi.engine.bboxes;
import org.bson.Document;
import org.gcube.application.geoportal.common.model.JSONPathWrapper;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import lombok.NonNull; import lombok.NonNull;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.ToString; import lombok.ToString;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.bson.Document;
import org.gcube.application.geoportal.common.model.JSONPathWrapper;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
@RequiredArgsConstructor @RequiredArgsConstructor
@ToString @ToString

5
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/engine/bboxes/BBOXPathScanner.java
View File

@ -1,13 +1,14 @@
package org.gcube.application.cms.sdi.engine.bboxes; package org.gcube.application.cms.sdi.engine.bboxes;
import lombok.extern.slf4j.Slf4j; import java.util.List;
import org.bson.Document; import org.bson.Document;
import org.gcube.application.cms.serialization.Serialization; import org.gcube.application.cms.serialization.Serialization;
import org.gcube.application.geoportal.common.model.JSONPathWrapper; import org.gcube.application.geoportal.common.model.JSONPathWrapper;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer; import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor; import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import java.util.List; import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public class BBOXPathScanner extends BBOXEvaluator{ public class BBOXPathScanner extends BBOXEvaluator{

13
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/model/GCubeSDILayerBuilder.java
View File

@ -1,16 +1,17 @@
package org.gcube.application.cms.sdi.model; package org.gcube.application.cms.sdi.model;
import lombok.Getter;
import org.bson.Document;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GeoServerPlatform;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.PlatformInfo;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import org.bson.Document;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GCubeSDILayer;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.GeoServerPlatform;
import org.gcube.application.geoportal.common.model.document.filesets.sdi.PlatformInfo;
import lombok.Getter;
public class GCubeSDILayerBuilder { public class GCubeSDILayerBuilder {
public static enum OGC_TYPE{ public static enum OGC_TYPE{

9
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/model/MappingObject.java
View File

@ -1,15 +1,16 @@
package org.gcube.application.cms.sdi.model; package org.gcube.application.cms.sdi.model;
import lombok.Data; import java.util.ArrayList;
import lombok.extern.slf4j.Slf4j; import java.util.List;
import org.bson.Document; import org.bson.Document;
import org.gcube.application.cms.plugins.faults.InvalidProfileException; import org.gcube.application.cms.plugins.faults.InvalidProfileException;
import org.gcube.application.cms.serialization.Serialization; import org.gcube.application.cms.serialization.Serialization;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.HandlerDeclaration; import org.gcube.application.geoportal.common.model.useCaseDescriptor.HandlerDeclaration;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor; import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import java.util.ArrayList; import lombok.Data;
import java.util.List; import lombok.extern.slf4j.Slf4j;
@Data @Data
@Slf4j @Slf4j

4
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/model/SDIConfiguration.java
View File

@ -1,10 +1,10 @@
package org.gcube.application.cms.sdi.model; package org.gcube.application.cms.sdi.model;
import org.bson.Document;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.bson.Document;
public class SDIConfiguration { public class SDIConfiguration {
public static final String GEOSERVER_PLATFORM="GeoServer"; public static final String GEOSERVER_PLATFORM="GeoServer";

7
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/model/SupportedFormat.java
View File

@ -1,11 +1,12 @@
package org.gcube.application.cms.sdi.model; package org.gcube.application.cms.sdi.model;
import java.util.ArrayList;
import org.gcube.application.geoportal.common.model.document.filesets.RegisteredFile;
import lombok.Getter; import lombok.Getter;
import lombok.NonNull; import lombok.NonNull;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.gcube.application.geoportal.common.model.document.filesets.RegisteredFile;
import java.util.ArrayList;
@Getter @Getter
@RequiredArgsConstructor @RequiredArgsConstructor
public abstract class SupportedFormat { public abstract class SupportedFormat {

9
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/plugins/SDIAbstractPlugin.java
View File

@ -1,7 +1,8 @@
package org.gcube.application.cms.sdi.plugins; package org.gcube.application.cms.sdi.plugins;
import lombok.Synchronized; import java.time.Duration;
import lombok.extern.slf4j.Slf4j; import java.time.temporal.ChronoUnit;
import org.gcube.application.cms.caches.AbstractScopedMap; import org.gcube.application.cms.caches.AbstractScopedMap;
import org.gcube.application.cms.implementations.ISInterface; import org.gcube.application.cms.implementations.ISInterface;
import org.gcube.application.cms.implementations.ImplementationProvider; import org.gcube.application.cms.implementations.ImplementationProvider;
@ -16,8 +17,8 @@ import org.gcube.application.cms.sdi.engine.SDIManagerWrapper;
import org.gcube.application.geoportal.common.model.rest.ConfigurationException; import org.gcube.application.geoportal.common.model.rest.ConfigurationException;
import org.gcube.application.geoportal.common.model.rest.DatabaseConnection; import org.gcube.application.geoportal.common.model.rest.DatabaseConnection;
import java.time.Duration; import lombok.Synchronized;
import java.time.temporal.ChronoUnit; import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public abstract class SDIAbstractPlugin extends AbstractPlugin implements InitializablePlugin { public abstract class SDIAbstractPlugin extends AbstractPlugin implements InitializablePlugin {

576
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/plugins/SDIIndexerPlugin.java
View File

@ -1,13 +1,18 @@
package org.gcube.application.cms.sdi.plugins; package org.gcube.application.cms.sdi.plugins;
import com.vdurmont.semver4j.Semver; import java.sql.SQLException;
import lombok.extern.slf4j.Slf4j; import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.bson.Document; import org.bson.Document;
import org.gcube.application.cms.plugins.IndexerPluginInterface; import org.gcube.application.cms.plugins.IndexerPluginInterface;
import org.gcube.application.cms.plugins.faults.IndexingException; import org.gcube.application.cms.plugins.faults.IndexingException;
import org.gcube.application.cms.plugins.faults.InitializationException; import org.gcube.application.cms.plugins.faults.InitializationException;
import org.gcube.application.cms.plugins.faults.InvalidPluginRequestException; import org.gcube.application.cms.plugins.faults.InvalidPluginRequestException;
import org.gcube.application.cms.plugins.faults.InvalidProfileException; import org.gcube.application.cms.plugins.faults.InvalidProfileException;
import org.gcube.application.cms.plugins.implementations.IndexConstants;
import org.gcube.application.cms.plugins.reports.IndexDocumentReport; import org.gcube.application.cms.plugins.reports.IndexDocumentReport;
import org.gcube.application.cms.plugins.reports.InitializationReport; import org.gcube.application.cms.plugins.reports.InitializationReport;
import org.gcube.application.cms.plugins.reports.Report; import org.gcube.application.cms.plugins.reports.Report;
@ -33,292 +38,303 @@ import org.gcube.application.geoportal.common.model.plugins.IndexerPluginDescrip
import org.gcube.application.geoportal.common.model.plugins.PluginDescriptor; import org.gcube.application.geoportal.common.model.plugins.PluginDescriptor;
import org.gcube.application.geoportal.common.model.rest.ConfigurationException; import org.gcube.application.geoportal.common.model.rest.ConfigurationException;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor; import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import org.gcube.portlets.user.uriresolvermanager.UriResolverManager;
import org.gcube.portlets.user.uriresolvermanager.resolvers.query.GeoportalResolverQueryStringBuilder;
import org.gcube.portlets.user.uriresolvermanager.resolvers.query.GeoportalResolverQueryStringBuilder.RESOLVE_AS;
import org.geojson.Crs; import org.geojson.Crs;
import org.geojson.GeoJsonObject; import org.geojson.GeoJsonObject;
import org.geojson.LngLatAlt; import org.geojson.LngLatAlt;
import org.geojson.Point; import org.geojson.Point;
import java.sql.SQLException; import com.vdurmont.semver4j.Semver;
import java.util.ArrayList;
import java.util.Collection; import lombok.extern.slf4j.Slf4j;
import java.util.List;
@Slf4j @Slf4j
public class SDIIndexerPlugin extends SDIAbstractPlugin implements IndexerPluginInterface { public class SDIIndexerPlugin extends SDIAbstractPlugin implements IndexerPluginInterface {
static final PluginDescriptor DESCRIPTOR = new PluginDescriptor(Constants.INDEXER_PLUGIN_ID,
static final PluginDescriptor DESCRIPTOR=new PluginDescriptor(Constants.INDEXER_PLUGIN_ID, IndexerPluginDescriptor.INDEXER);
IndexerPluginDescriptor.INDEXER);
static final ArrayList<BBOXEvaluator> BBOX_EVALUATORS = new ArrayList<>();
static {
DESCRIPTOR.setDescription("SDI Indexer. " + "Manage Centroids layers.");
static final ArrayList<BBOXEvaluator> BBOX_EVALUATORS=new ArrayList<>(); DESCRIPTOR.setVersion(new Semver("1.0.0"));
static { BBOX_EVALUATORS.add(new BBOXPathScanner());
DESCRIPTOR.setDescription("SDI Indexer. " + BBOX_EVALUATORS.add(new BBOXByCoordinatePaths());
"Manage Centroids layers.");
DESCRIPTOR.setVersion(new Semver("1.0.0")); }
BBOX_EVALUATORS.add(new BBOXPathScanner()); @Override
BBOX_EVALUATORS.add(new BBOXByCoordinatePaths()); public PluginDescriptor getDescriptor() {
return DESCRIPTOR;
}
} @Override
public InitializationReport initInContext() throws InitializationException {
@Override InitializationReport report = new InitializationReport();
public PluginDescriptor getDescriptor() { report.setStatus(Report.Status.OK);
return DESCRIPTOR; return report;
} }
/**
@Override * Expected parameters : - indexName (unique) - workspace - flagInternalIndex as
public InitializationReport initInContext() throws InitializationException { * Boolean; boolean - centroidRecord (OPT).
InitializationReport report = new InitializationReport(); *
report.setStatus(Report.Status.OK); * @param request the request
return report; * @return the index document report
} * @throws InvalidPluginRequestException the invalid plugin request exception
*/
/**
* Expected parameters : @Override
* - indexName (unique) public IndexDocumentReport index(IndexDocumentRequest request) throws InvalidPluginRequestException {
* - workspace
* - centroidRecord (OPT) log.info("Indexer {} : Serving Index Request {} ", this.getDescriptor().getId(), request);
*
* @param request Project project = request.getDocument();
* @return UseCaseDescriptor useCaseDescriptor = request.getUseCaseDescriptor();
*/ Document requestArguments = request.getCallParameters();
@Override log.debug("requestArguments is {} ", requestArguments);
public IndexDocumentReport index(IndexDocumentRequest request) throws InvalidPluginRequestException {
IndexDocumentReport report = new IndexDocumentReport(request);
log.info("Indexer {} : Serving Index Request {} ",this.getDescriptor().getId(),request);
try {
Project project =request.getDocument(); // ********* INIT INDEX
UseCaseDescriptor useCaseDescriptor = request.getUseCaseDescriptor(); // TODO CACHE
Document requestArguments=request.getCallParameters(); PostgisIndexer indexer = getIndexer(useCaseDescriptor, requestArguments);
IndexDocumentReport report= new IndexDocumentReport(request); Document profileConfiguration = getConfigurationFromProfile(useCaseDescriptor).getConfiguration();
log.debug("UseCaseDescriptor Configuration is {} ", profileConfiguration);
// ************* PREPARE RECORD
try{
// ********* INIT INDEX JSONPathWrapper documentNavigator = new JSONPathWrapper(Serialization.write(project));
// TODO CACHE
PostgisIndexer indexer = getIndexer(useCaseDescriptor,requestArguments); Document centroidDoc = new Document();
if (requestArguments.containsKey("centroidRecord"))
Document profileConfiguration =getConfigurationFromProfile(useCaseDescriptor).getConfiguration(); centroidDoc.putAll(requestArguments.get("centroidRecords", Document.class));
log.debug("UseCaseDescriptor Configuration is {} ",profileConfiguration); // DEFAULT VALUES
centroidDoc.put(DBConstants.Defaults.PROJECT_ID, project.getId());
centroidDoc.put(DBConstants.Defaults.DISPLAYED, true);
// ************* PREPARE RECORD
// Added by Francesco. Creating Gis Viewer Link as public or private
Boolean isInternalIndex = null;
JSONPathWrapper documentNavigator=new JSONPathWrapper(Serialization.write(project)); try {
isInternalIndex = requestArguments
Document centroidDoc = new Document(); .getBoolean(IndexConstants.INDEX_PARAMETER_FLAGINTERNALINDEX);
if(requestArguments.containsKey("centroidRecord")) log.debug(IndexConstants.INDEX_PARAMETER_FLAGINTERNALINDEX + " read as {} ", isInternalIndex);
centroidDoc.putAll(requestArguments.get("centroidRecords",Document.class)); } catch (Exception e) {
// DEFAULT VALUES // TODO: handle exception
centroidDoc.put(DBConstants.Defaults.PROJECT_ID, project.getId()); }
centroidDoc.put(DBConstants.Defaults.DISPLAYED,true); log.info(IndexConstants.INDEX_PARAMETER_FLAGINTERNALINDEX + " is {} ", isInternalIndex);
if (isInternalIndex != null) {
try {
// ********************** EVALAUTE POSITION log.debug("Trying to generate Geoportal Gis Link...");
log.debug("indexing UseCaseDescriptor {} : Evaluating Centroid... ", useCaseDescriptor.getId()); // Contacting the Geoportal-Resolver via UriResolverManager
SpatialReference reference =null; UriResolverManager uriResolverManager = new UriResolverManager("GEO");
List<IdentificationReference> refs=project.getIdentificationReferenceByType(SpatialReference.SPATIAL_REFERENCE_TYPE); GeoportalResolverQueryStringBuilder builder = new GeoportalResolverQueryStringBuilder(
if(!refs.isEmpty()){ project.getProfileID(), project.getId());
builder.scope(request.getContext().getId());
// Use existing Reference
if (isInternalIndex) {
reference = Serialization.convert(refs.get(0), SpatialReference.class); builder.resolverAs(RESOLVE_AS.PRIVATE);
} else {
log.debug("Using already defined spatial reference " + reference); builder.resolverAs(RESOLVE_AS.PUBLIC);
}
Map<String, String> params = builder.buildQueryParameters();
GeoJsonObject object = Serialization.convert(reference.getGeoJson(), GeoJsonObject.class); String shortLink = uriResolverManager.getLink(params, true);
log.info("Geoportal GisViewer link is {} ", shortLink);
GCubeSDILayer.BBOX bbox = GCubeSDILayer.BBOX.fromGeoJSON(object.getBbox()); centroidDoc.put(DBConstants.Defaults.GEOVIEWER_LINK_FIELD, shortLink);
} catch (Exception e) {
log.info("Found declared BBOX {} ", bbox); log.error("Error on creating the Geoportal GisViewer link for project id {}", project.getId(), e);
Double pointX = (bbox.getMaxX() + bbox.getMinX())/2; }
Double pointY = (bbox.getMaxY() + bbox.getMinY())/2; }
String wkt = String.format("POINT (%1$f %2$f) ",
pointX, pointY); // ********************** EVALAUTE POSITION
log.debug("indexing UseCaseDescriptor {} : Evaluating Centroid... ", useCaseDescriptor.getId());
SpatialReference reference = null;
centroidDoc.put("geom", wkt); List<IdentificationReference> refs = project
.getIdentificationReferenceByType(SpatialReference.SPATIAL_REFERENCE_TYPE);
} else{ if (!refs.isEmpty()) {
// unable to use current Spatial reference, try evaluating it
log.debug("UseCaseDescriptor {} : Getting evaluation paths from useCaseDescriptor.. ", useCaseDescriptor.getId()); // Use existing Reference
// for each configuration option try until found reference = Serialization.convert(refs.get(0), SpatialReference.class);
GCubeSDILayer.BBOX toSet = null;
for(BBOXEvaluator evaluator : BBOX_EVALUATORS){ log.debug("Using already defined spatial reference " + reference);
log.trace("UCD {}, Project {}. Evaluating BBOX with {}",useCaseDescriptor.getId(),project.getId(),evaluator);
try{ GeoJsonObject object = Serialization.convert(reference.getGeoJson(), GeoJsonObject.class);
if(evaluator.isConfigured(profileConfiguration)){
toSet=evaluator.evaluate(profileConfiguration,useCaseDescriptor,documentNavigator); GCubeSDILayer.BBOX bbox = GCubeSDILayer.BBOX.fromGeoJSON(object.getBbox());
if(toSet!=null) {
log.info("UCD {}, Project {}. Evaluated BBOX {} with method {}", log.info("Found declared BBOX {} ", bbox);
useCaseDescriptor.getId(),project.getId(),toSet,evaluator); Double pointX = (bbox.getMaxX() + bbox.getMinX()) / 2;
break; Double pointY = (bbox.getMaxY() + bbox.getMinY()) / 2;
} String wkt = String.format("POINT (%1$f %2$f) ", pointX, pointY);
}
}catch (Throwable t){ centroidDoc.put("geom", wkt);
log.warn("UCD {}, Project {}. Exception with {}",
useCaseDescriptor.getId(),project.getId(),evaluator,t); } else {
} // unable to use current Spatial reference, try evaluating it
} log.debug("UseCaseDescriptor {} : Getting evaluation paths from useCaseDescriptor.. ",
if(toSet== null) useCaseDescriptor.getId());
throw new IndexingException("No BBOX has been evaluated from project");
// for each configuration option try until found
Double pointX=(toSet.getMaxX()+toSet.getMinX())/2; GCubeSDILayer.BBOX toSet = null;
Double pointY = (toSet.getMaxY()+toSet.getMinY())/2; for (BBOXEvaluator evaluator : BBOX_EVALUATORS) {
log.info("Evaluated BBOX {} ",toSet); log.trace("UCD {}, Project {}. Evaluating BBOX with {}", useCaseDescriptor.getId(), project.getId(),
String wkt = String .format("POINT (%1$f %2$f) ", evaluator);
pointX, pointY); try {
//TODO support altitude if (evaluator.isConfigured(profileConfiguration)) {
Double pointZ= 0d; toSet = evaluator.evaluate(profileConfiguration, useCaseDescriptor, documentNavigator);
if (toSet != null) {
log.info("UCD {}, Project {}. Evaluated BBOX {} with method {}",
centroidDoc.put("geom",wkt); useCaseDescriptor.getId(), project.getId(), toSet, evaluator);
break;
Point point = new Point(); }
point.setCoordinates(new LngLatAlt(pointX,pointY,pointZ)); }
point.setBbox(toSet.asGeoJSONArray()); } catch (Throwable t) {
log.warn("UCD {}, Project {}. Exception with {}", useCaseDescriptor.getId(), project.getId(),
//TODO Manage CRS evaluator, t);
point.setCrs(new Crs()); }
reference = new SpatialReference(Serialization.asDocument(point)); }
log.info("UCD {} project {}, Setting Spatial Reference {} ",useCaseDescriptor.getId(),project.getId(),Serialization.write(reference)); if (toSet == null)
report.addIdentificationReference(reference); throw new IndexingException("No BBOX has been evaluated from project");
}
Double pointX = (toSet.getMaxX() + toSet.getMinX()) / 2;
Double pointY = (toSet.getMaxY() + toSet.getMinY()) / 2;
log.info("Evaluated BBOX {} ", toSet);
//*********** Additional Values from useCaseDescriptor String wkt = String.format("POINT (%1$f %2$f) ", pointX, pointY);
// TODO support altitude
log.info("Setting additional values to centroid from mappings .."); Double pointZ = 0d;
for(MappingObject m : getMappings(useCaseDescriptor)){
List<Object> foundValues = documentNavigator.getByPath(m.getPath()); centroidDoc.put("geom", wkt);
Object toSetValue=null;
if(!foundValues.isEmpty()) { Point point = new Point();
// NB CSV for multiple values point.setCoordinates(new LngLatAlt(pointX, pointY, pointZ));
StringBuilder b=new StringBuilder(); point.setBbox(toSet.asGeoJSONArray());
foundValues.forEach(o-> {
// Parser returns list of list // TODO Manage CRS
if (o instanceof Collection) ((Collection<?>) o).forEach(v ->b.append(v + ",")); point.setCrs(new Crs());
else b.append(o+","); reference = new SpatialReference(Serialization.asDocument(point));
}); log.info("UCD {} project {}, Setting Spatial Reference {} ", useCaseDescriptor.getId(), project.getId(),
b.deleteCharAt(b.length()-1); Serialization.write(reference));
toSetValue = b.toString(); report.addIdentificationReference(reference);
} }
log.trace("Setting {} = {} in centroid doc ",m.getName(),toSetValue);
centroidDoc.put(m.getName(),toSetValue); // *********** Additional Values from useCaseDescriptor
}
log.info("Setting additional values to centroid from mappings ..");
log.info("Inserting Centroid {} into {} ",Serialization.write(centroidDoc.toJson()),indexer); for (MappingObject m : getMappings(useCaseDescriptor)) {
indexer.insert(centroidDoc); List<Object> foundValues = documentNavigator.getByPath(m.getPath());
Object toSetValue = null;
// Support to HIDE AND DISPLAY as requested by invoker if (!foundValues.isEmpty()) {
if(requestArguments.containsKey("_toHideIds")){ // NB CSV for multiple values
StringBuilder b = new StringBuilder();
List<String> ids = Serialization.convert(requestArguments.get("_toHideIds"),List.class); foundValues.forEach(o -> {
log.info("Requested to hide centroids {} ",ids); // Parser returns list of list
indexer.updateIsVisible(false,ids); if (o instanceof Collection)
} ((Collection<?>) o).forEach(v -> b.append(v + ","));
else
if(requestArguments.containsKey("_toDisplayIds")){ b.append(o + ",");
List<String> ids = Serialization.convert(requestArguments.get("_toDisplayIds"),List.class); });
b.deleteCharAt(b.length() - 1);
log.info("Requested to display centroids {} ",ids); toSetValue = b.toString();
indexer.updateIsVisible(true,ids); }
} log.trace("Setting {} = {} in centroid doc ", m.getName(), toSetValue);
centroidDoc.put(m.getName(), toSetValue);
}
report.setStatus(Report.Status.OK); log.info("Inserting Centroid {} into {} ", Serialization.write(centroidDoc.toJson()), indexer);
}catch (SDIInteractionException e){ indexer.insert(centroidDoc);
log.error("Unable to index "+request,e);
report.setStatus(Report.Status.ERROR); // Support to HIDE AND DISPLAY as requested by invoker
report.putMessage(e.getMessage()); if (requestArguments.containsKey("_toHideIds")) {
}catch (Throwable t){
log.error("Unable to index "+request,t); List<String> ids = Serialization.convert(requestArguments.get("_toHideIds"), List.class);
report.setStatus(Report.Status.ERROR); log.info("Requested to hide centroids {} ", ids);
report.putMessage(t.getMessage()); indexer.updateIsVisible(false, ids);
}finally{ }
return report;
} if (requestArguments.containsKey("_toDisplayIds")) {
} List<String> ids = Serialization.convert(requestArguments.get("_toDisplayIds"), List.class);
private List<MappingObject> getMappings(UseCaseDescriptor useCaseDescriptor) throws InvalidProfileException { log.info("Requested to display centroids {} ", ids);
return MappingObject.getMappingsFromUCD(useCaseDescriptor, getDescriptor().getId()); indexer.updateIsVisible(true, ids);
} }
@Override report.setStatus(Report.Status.OK);
public IndexDocumentReport deindex(IndexDocumentRequest request) throws InvalidPluginRequestException { } catch (SDIInteractionException e) {
log.info("Indexer {} : Serving Index Request {} ",this.getDescriptor().getId(),request); log.error("Unable to index " + request, e);
IndexDocumentReport report= new IndexDocumentReport(request); report.setStatus(Report.Status.ERROR);
try{ report.putMessage(e.getMessage());
PostgisIndexer indexer = getIndexer(request.getUseCaseDescriptor(),request.getCallParameters()); } catch (Throwable t) {
indexer.removeByFieldValue(PostgisIndexer.StandardFields.PROJECT_ID,request.getDocument().getId()); log.error("Unable to index " + request, t);
}catch (SDIInteractionException e){ report.setStatus(Report.Status.ERROR);
log.error("Unable to index "+request,e); report.putMessage(t.getMessage());
report.setStatus(Report.Status.ERROR); } finally {
report.putMessage(e.getMessage()); return report;
}catch (Throwable t){ }
log.error("Unable to index "+request,t); }
report.setStatus(Report.Status.ERROR);
report.putMessage(t.getMessage()); private List<MappingObject> getMappings(UseCaseDescriptor useCaseDescriptor) throws InvalidProfileException {
}finally{ return MappingObject.getMappingsFromUCD(useCaseDescriptor, getDescriptor().getId());
return report; }
}
} @Override
public IndexDocumentReport deindex(IndexDocumentRequest request) throws InvalidPluginRequestException {
/** log.info("Indexer {} : Serving Index Request {} ", this.getDescriptor().getId(), request);
* Expected parameters : IndexDocumentReport report = new IndexDocumentReport(request);
* workspace try {
* indexName PostgisIndexer indexer = getIndexer(request.getUseCaseDescriptor(), request.getCallParameters());
* indexer.removeByFieldValue(PostgisIndexer.StandardFields.PROJECT_ID, request.getDocument().getId());
* @param request } catch (SDIInteractionException e) {
* @return log.error("Unable to index " + request, e);
* @throws ConfigurationException report.setStatus(Report.Status.ERROR);
*/ report.putMessage(e.getMessage());
@Override } catch (Throwable t) {
public Index getIndex(BaseRequest request) throws ConfigurationException { log.error("Unable to index " + request, t);
try { report.setStatus(Report.Status.ERROR);
return getIndexer(request.getUseCaseDescriptor(), request.getCallParameters()).getIndexConfiguration(); report.putMessage(t.getMessage());
}catch(Throwable t ){ } finally {
throw new ConfigurationException("Unable to get Postgis index for ucd "+request.getUseCaseDescriptor().getId()+" in "+ request.getContext(),t); return report;
} }
} }
// Inits index /**
// TODO CACHE * Expected parameters : workspace indexName
private PostgisIndexer getIndexer(UseCaseDescriptor ucd,Document params) throws ConfigurationException, SQLException, InvalidProfileException, SDIInteractionException { *
PostgisIndexer indexer = new PostgisIndexer(sdiCache.getObject(), ucd, postgisCache.getObject()); * @param request
* @return
List<MappingObject> mappingObjects = getMappings(ucd); * @throws ConfigurationException
List<PostgisTable.Field> fields = PostgisTable.Field.fromMappings(mappingObjects); */
@Override
indexer.initIndex(params.getString("indexName"), public Index getIndex(BaseRequest request) throws ConfigurationException {
fields, try {
params.getString("workspace"), return getIndexer(request.getUseCaseDescriptor(), request.getCallParameters()).getIndexConfiguration();
params.getString("indexName")); } catch (Throwable t) {
return indexer; throw new ConfigurationException("Unable to get Postgis index for ucd "
} + request.getUseCaseDescriptor().getId() + " in " + request.getContext(), t);
}
}
// Inits index
// TODO CACHE
private PostgisIndexer getIndexer(UseCaseDescriptor ucd, Document params)
throws ConfigurationException, SQLException, InvalidProfileException, SDIInteractionException {
PostgisIndexer indexer = new PostgisIndexer(sdiCache.getObject(), ucd, postgisCache.getObject());
List<MappingObject> mappingObjects = getMappings(ucd);
List<PostgisTable.Field> fields = PostgisTable.Field.fromMappings(mappingObjects);
indexer.initIndex(params.getString(IndexConstants.INDEX_PARAMETER_INDEXNAME), fields,
params.getString(IndexConstants.INDEX_PARAMETER_WORKSPACE),
params.getString(IndexConstants.INDEX_PARAMETER_INDEXNAME));
return indexer;
}
} }

19
sdi-plugins/src/main/java/org/gcube/application/cms/sdi/plugins/SDIMaterializerPlugin.java
View File

@ -1,9 +1,10 @@
package org.gcube.application.cms.sdi.plugins; package org.gcube.application.cms.sdi.plugins;
import com.vdurmont.semver4j.Semver; import java.util.ArrayList;
import lombok.Data; import java.util.HashMap;
import lombok.Synchronized; import java.util.List;
import lombok.extern.slf4j.Slf4j; import java.util.Map;
import org.bson.Document; import org.bson.Document;
import org.gcube.application.cms.implementations.utils.UserUtils; import org.gcube.application.cms.implementations.utils.UserUtils;
import org.gcube.application.cms.plugins.MaterializationPlugin; import org.gcube.application.cms.plugins.MaterializationPlugin;
@ -28,12 +29,12 @@ import org.gcube.application.geoportal.common.model.plugins.MaterializerPluginDe
import org.gcube.application.geoportal.common.model.plugins.PluginDescriptor; import org.gcube.application.geoportal.common.model.plugins.PluginDescriptor;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.Field; import org.gcube.application.geoportal.common.model.useCaseDescriptor.Field;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor; import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
import org.gcube.application.geoportal.common.utils.ContextUtils;
import java.util.ArrayList; import com.vdurmont.semver4j.Semver;
import java.util.HashMap;
import java.util.List; import lombok.Data;
import java.util.Map; import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
@Slf4j @Slf4j
public class SDIMaterializerPlugin extends AbstractPlugin implements MaterializationPlugin { public class SDIMaterializerPlugin extends AbstractPlugin implements MaterializationPlugin {