gCubeSystem
/
geoportal-service
Archived
16
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Removed geoportal-logic library dependency

This commit is contained in:
Fabio Sinibaldi 2021-07-30 18:21:29 +02:00
parent bbf3caf8ed
commit 815a972c82
44 changed files with 1097 additions and 1049 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
pom.xml
View File

@ -46,17 +46,6 @@
<!-- SMARTGEARS -->
<!-- <dependency> -->
<!-- <groupId>org.gcube.core</groupId> -->
<!-- <artifactId>common-smartgears-app</artifactId> -->
<!-- <exclusions> -->
<!-- <exclusion> -->
<!-- <groupId>org.javassist</groupId> -->
<!-- <artifactId>javassist</artifactId> -->
<!-- </exclusion> -->
<!-- </exclusions> -->
<!-- </dependency> -->
<dependency>
<groupId>org.gcube.core</groupId>
<artifactId>common-smartgears</artifactId>
@ -96,18 +85,47 @@
<artifactId>geoportal-common</artifactId>
<version>[1.0.0,2.0.0)</version>
</dependency>
<dependency>
<groupId>org.gcube.application</groupId>
<artifactId>geoportal-logic</artifactId>
<version>[1.0.14,2.0.0)</version>
</dependency>
<!-- &lt;!&ndash; override gis-interface &ndash;&gt;-->
<!-- <dependency>-->
<!-- <groupId>org.gcube.spatial.data</groupId>-->
<!-- <artifactId>gis-interface</artifactId>-->
<!-- <version>[2.4.6,3.0.0)</version>-->
<!-- <groupId>org.gcube.application</groupId>-->
<!-- <artifactId>geoportal-logic</artifactId>-->
<!-- <version>[1.0.14,2.0.0)</version>-->
<!-- </dependency>-->
<!-- SDI -->
<dependency>
<groupId>org.gcube.spatial.data</groupId>
<artifactId>gis-interface</artifactId>
<version>[2.4.6,3.0.0)</version>
</dependency>
<!-- POSTGRES DRIVERS -->
<dependency>
<groupId>net.postgis</groupId>
<artifactId>postgis-jdbc</artifactId>
<version>2.5.0</version>
</dependency>
<!-- GS communication -->
<dependency>
<groupId>org.gcube.spatial.data</groupId>
<artifactId>gcube-geoserver-client</artifactId>
<version>[1.0.0-SNAPSHOT,)</version>
</dependency>
<!-- DT -->
<dependency>
<groupId>org.gcube.data.transfer</groupId>
<artifactId>data-transfer-library</artifactId>
<version>[1.2.1,2.0.0]</version>
</dependency>
<!-- Storage HUB -->
<dependency>
<groupId>org.gcube.common</groupId>
<artifactId>storagehub-client-library</artifactId>
<version>[1.0.0,2.0.0)</version>
</dependency>
<!-- MONGO -->
<!-- https://mvnrepository.com/artifact/org.mongodb/mongo-java-driver -->

7
src/main/java/org/gcube/application/geoportal/service/GeoPortalService.java
View File

@ -1,15 +1,14 @@
package org.gcube.application.geoportal.service;
import javax.ws.rs.ApplicationPath;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import org.gcube.application.geoportal.service.rest.Concessioni;
import org.gcube.application.geoportal.service.rest.ConcessioniOverMongo;
import org.gcube.application.geoportal.service.rest.Profiles;
import org.gcube.application.geoportal.service.rest.Projects;
import org.gcube.application.geoportal.service.rest.Sections;
import org.glassfish.jersey.server.ResourceConfig;
import javax.ws.rs.ApplicationPath;
@ApplicationPath(InterfaceConstants.APPLICATION_PATH)
public class GeoPortalService extends ResourceConfig{
@ -18,7 +17,7 @@ public class GeoPortalService extends ResourceConfig{
public GeoPortalService() {
super();
//Register interrfaces
registerClasses(Concessioni.class);
// registerClasses(Concessioni.class);
registerClasses(ConcessioniOverMongo.class);
registerClasses(Projects.class);
registerClasses(Sections.class);

14
src/main/java/org/gcube/application/geoportal/service/engine/AbstractScopedMap.java
View File

@ -1,18 +1,16 @@
package org.gcube.application.geoportal.service.engine;
import java.time.LocalDateTime;
import java.time.temporal.TemporalAmount;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.utils.ContextUtils;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.utils.ContextUtils;
import java.time.LocalDateTime;
import java.time.temporal.TemporalAmount;
import java.util.concurrent.ConcurrentHashMap;
@Slf4j
@RequiredArgsConstructor

3
src/main/java/org/gcube/application/geoportal/service/engine/Engine.java
View File

@ -1,6 +1,7 @@
package org.gcube.application.geoportal.service.engine;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
public interface Engine <T> {

18
src/main/java/org/gcube/application/geoportal/service/engine/ImplementationProvider.java
View File

@ -1,13 +1,13 @@
package org.gcube.application.geoportal.service.engine;
import org.gcube.application.geoportal.managers.AbstractRecordManager;
import org.gcube.application.geoportal.managers.EMFProvider;
import org.gcube.application.geoportal.service.engine.cache.MongoClientProvider;
import org.gcube.application.geoportal.service.engine.cache.MongoConnectionProvider;
//import org.gcube.application.geoportal.managers.AbstractRecordManager;
//import org.gcube.application.geoportal.managers.EMFProvider;
import lombok.Getter;
import lombok.Setter;
import lombok.Synchronized;
import org.gcube.application.geoportal.service.engine.cache.MongoClientProvider;
import org.gcube.application.geoportal.service.engine.cache.MongoConnectionProvider;
public class ImplementationProvider {
@ -36,9 +36,9 @@ public class ImplementationProvider {
private StorageClientProvider storageProvider=new StorageClientProvider();
@Getter
@Setter
private EMFProvider emfProvider=new ScopedEMFProvider();
// @Getter
// @Setter
// private EMFProvider emfProvider=new ScopedEMFProvider();
@Getter
@ -47,13 +47,13 @@ public class ImplementationProvider {
public void shutdown() {
// Stop JPA
AbstractRecordManager.shutdown();
// AbstractRecordManager.shutdown();
mongoConnectionProvider.shustdown();
mongoClientProvider.shustdown();
}
public void startup() {
AbstractRecordManager.setDefaultProvider(emfProvider);
// AbstractRecordManager.setDefaultProvider(emfProvider);
mongoConnectionProvider.init();
mongoClientProvider.init();
}

5
src/main/java/org/gcube/application/geoportal/service/engine/ProfileMapCache.java
View File

@ -1,9 +1,10 @@
package org.gcube.application.geoportal.service.engine;
import org.gcube.application.geoportal.common.model.profile.Profile;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import java.util.Map;
import org.gcube.application.geoportal.common.model.profile.Profile;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
public class ProfileMapCache extends AbstractScopedMap<Map<String,Profile>> {

14
src/main/java/org/gcube/application/geoportal/service/engine/SDIManager.java
View File

@ -7,17 +7,13 @@ import it.geosolutions.geoserver.rest.decoder.RESTFeatureType;
import it.geosolutions.geoserver.rest.decoder.RESTLayer;
import it.geosolutions.geoserver.rest.encoder.GSLayerEncoder;
import it.geosolutions.geoserver.rest.encoder.datastore.GSPostGISDatastoreEncoder;
import it.geosolutions.geoserver.rest.encoder.feature.FeatureTypeAttribute;
import it.geosolutions.geoserver.rest.encoder.feature.GSAttributeEncoder;
import it.geosolutions.geoserver.rest.encoder.feature.GSFeatureTypeEncoder;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.common.model.legacy.*;
import org.gcube.application.geoportal.common.utils.Files;
import org.gcube.application.geoportal.model.db.DBConstants;
import org.gcube.application.geoportal.model.db.DatabaseConnection;
import org.gcube.application.geoportal.model.db.PostgisTable;
import org.gcube.application.geoportal.service.engine.mongo.PostgisIndex;
import org.gcube.application.geoportal.service.model.internal.db.DatabaseConnection;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable;
import org.gcube.application.geoportal.service.model.internal.faults.SDIInteractionException;
import org.gcube.common.storagehub.client.dsl.FileContainer;
import org.gcube.data.transfer.library.DataTransferClient;
@ -31,11 +27,7 @@ import org.gcube.spatial.data.gis.is.AbstractGeoServerDescriptor;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@ -315,7 +307,7 @@ public class SDIManager {
}
public String configureCentroidLayer(String name,String workspace,String storeName,PostgisTable table, DatabaseConnection connection) throws SDIInteractionException {
public String configureCentroidLayer(String name, String workspace, String storeName, PostgisTable table, DatabaseConnection connection) throws SDIInteractionException {
GSFeatureTypeEncoder fte=new GSFeatureTypeEncoder();
fte.setAbstract("Centroid layer for "+name);

205
src/main/java/org/gcube/application/geoportal/service/engine/ScopedEMFProvider.java
View File

@ -1,205 +0,0 @@
package org.gcube.application.geoportal.service.engine;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
import javax.persistence.EntityManagerFactory;
import javax.persistence.SharedCacheMode;
import javax.persistence.ValidationMode;
import javax.persistence.spi.ClassTransformer;
import javax.persistence.spi.PersistenceUnitInfo;
import javax.persistence.spi.PersistenceUnitTransactionType;
import javax.sql.DataSource;
import org.gcube.application.geoportal.managers.EMFProvider;
import org.gcube.application.geoportal.model.db.DatabaseConnection;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.utils.ISUtils;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.jpa.HibernatePersistenceProvider;
import jersey.repackaged.com.google.common.collect.ImmutableMap;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class ScopedEMFProvider extends AbstractScopedMap<EntityManagerFactory> implements EMFProvider {
public ScopedEMFProvider() {
super("EMF Cache");
// setTTL(Duration.of(10, ChronoUnit.MINUTES));
}
@Override
protected void dispose(EntityManagerFactory toDispose) {
if(toDispose!=null) {
if(toDispose.isOpen()) toDispose.close();
toDispose=null;
}
}
@Override
public EntityManagerFactory getFactory() {
try {
return getObject();
} catch (ConfigurationException e) {
throw new RuntimeException("Unable to get Factory ",e);
}
}
@Override
public void init() {
}
@Override
protected EntityManagerFactory retrieveObject() throws ConfigurationException {
DatabaseConnection conn=ISUtils.queryForDB("postgresql", "internal-db");
log.debug("Found Internal Database : "+conn);
return new HibernatePersistenceProvider().createContainerEntityManagerFactory(
archiverPersistenceUnitInfo(),
ImmutableMap.<String, Object>builder()
.put(AvailableSettings.JPA_JDBC_DRIVER, "org.postgresql.Driver")
.put(AvailableSettings.JPA_JDBC_URL, conn.getUrl())
.put(AvailableSettings.DIALECT, org.hibernate.dialect.PostgreSQLDialect.class)
.put(AvailableSettings.HBM2DDL_AUTO, org.hibernate.tool.schema.Action.UPDATE)
.put(AvailableSettings.SHOW_SQL, true)
.put(AvailableSettings.QUERY_STARTUP_CHECKING, false)
.put(AvailableSettings.GENERATE_STATISTICS, false)
.put(AvailableSettings.USE_REFLECTION_OPTIMIZER, false)
.put(AvailableSettings.USE_SECOND_LEVEL_CACHE, false)
.put(AvailableSettings.USE_QUERY_CACHE, false)
.put(AvailableSettings.USE_STRUCTURED_CACHE, false)
.put(AvailableSettings.STATEMENT_BATCH_SIZE, 20)
.put(AvailableSettings.JPA_JDBC_USER, conn.getUser())
.put(AvailableSettings.JPA_JDBC_PASSWORD, conn.getPwd())
.build());
}
@Override
public void shutdown() {
super.shustdown();
}
///** *
private static PersistenceUnitInfo archiverPersistenceUnitInfo() {
final List<String> MANAGED_CLASSES=Arrays.asList(new String[] {
"org.gcube.application.geoportal.model.Record",
"org.gcube.application.geoportal.model.concessioni.Concessione",
"org.gcube.application.geoportal.model.concessioni.LayerConcessione",
"org.gcube.application.geoportal.model.concessioni.RelazioneScavo",
"org.gcube.application.geoportal.model.content.AssociatedContent",
"org.gcube.application.geoportal.model.content.GeoServerContent",
"org.gcube.application.geoportal.model.content.OtherContent",
"org.gcube.application.geoportal.model.content.PersistedContent",
"org.gcube.application.geoportal.model.content.UploadedImage",
"org.gcube.application.geoportal.model.content.WorkspaceContent",
"org.gcube.application.geoportal.model.gis.ShapeFileLayerDescriptor",
"org.gcube.application.geoportal.model.gis.SDILayerDescriptor"});
return new PersistenceUnitInfo() {
@Override
public String getPersistenceUnitName() {
return "ApplicationPersistenceUnit";
}
@Override
public String getPersistenceProviderClassName() {
return "org.hibernate.jpa.HibernatePersistenceProvider";
}
@Override
public PersistenceUnitTransactionType getTransactionType() {
return PersistenceUnitTransactionType.RESOURCE_LOCAL;
}
@Override
public DataSource getJtaDataSource() {
return null;
}
@Override
public DataSource getNonJtaDataSource() {
return null;
}
@Override
public List<String> getMappingFileNames() {
return Collections.emptyList();
}
@Override
public List<URL> getJarFileUrls() {
try {
return Collections.list(this.getClass()
.getClassLoader()
.getResources(""));
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
@Override
public URL getPersistenceUnitRootUrl() {
return null;
}
@Override
public List<String> getManagedClassNames() {
return MANAGED_CLASSES;
}
@Override
public boolean excludeUnlistedClasses() {
return true;
}
@Override
public SharedCacheMode getSharedCacheMode() {
return null;
}
@Override
public ValidationMode getValidationMode() {
return null;
}
@Override
public Properties getProperties() {
return new Properties();
}
@Override
public String getPersistenceXMLSchemaVersion() {
return null;
}
@Override
public ClassLoader getClassLoader() {
return null;
}
@Override
public void addTransformer(ClassTransformer transformer) {
}
@Override
public ClassLoader getNewTempClassLoader() {
return null;
}
};
}
}

19
src/main/java/org/gcube/application/geoportal/service/engine/StorageClientProvider.java
View File

@ -1,16 +1,8 @@
package org.gcube.application.geoportal.service.engine;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
import org.eclipse.persistence.internal.sessions.remote.SequencingFunctionCall.GetNextValue;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.utils.ContextUtils;
import org.gcube.contentmanagement.blobstorage.service.IClient;
import org.gcube.contentmanagement.blobstorage.transport.backend.RemoteBackendException;
@ -19,7 +11,12 @@ import org.gcube.contentmanager.storageclient.wrapper.MemoryType;
import org.gcube.contentmanager.storageclient.wrapper.StorageClient;
import org.gcube.data.transfer.library.utils.Utils;
import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
@Slf4j
public class StorageClientProvider extends AbstractScopedMap<IClient>{

2
src/main/java/org/gcube/application/geoportal/service/engine/StorageHubProvider.java
View File

@ -1,6 +1,6 @@
package org.gcube.application.geoportal.service.engine;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.common.storagehub.client.dsl.StorageHubClient;
public class StorageHubProvider implements Engine<StorageHubClient>{

4
src/main/java/org/gcube/application/geoportal/service/engine/TTLObject.java
View File

@ -1,11 +1,11 @@
package org.gcube.application.geoportal.service.engine;
import java.time.LocalDateTime;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;
import java.time.LocalDateTime;
@Getter
@ToString
@AllArgsConstructor

19
src/main/java/org/gcube/application/geoportal/service/engine/WorkspaceManager.java
View File

@ -1,25 +1,18 @@
package org.gcube.application.geoportal.service.engine;
import java.io.FileNotFoundException;
import java.io.InputStream;
import javax.validation.constraints.NotNull;
import lombok.*;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.common.model.legacy.WorkspaceContent;
import org.gcube.application.geoportal.common.utils.Files;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.common.storagehub.client.dsl.FileContainer;
import org.gcube.common.storagehub.client.dsl.FolderContainer;
import org.gcube.common.storagehub.client.dsl.StorageHubClient;
import org.gcube.common.storagehub.model.exceptions.StorageHubException;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
import javax.validation.constraints.NotNull;
import java.io.FileNotFoundException;
import java.io.InputStream;
@Slf4j
public class WorkspaceManager {

10
src/main/java/org/gcube/application/geoportal/service/engine/cache/MongoClientProvider.java vendored
View File

@ -1,16 +1,14 @@
package org.gcube.application.geoportal.service.engine.cache;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.engine.AbstractScopedMap;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.model.internal.db.MongoConnection;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.service.engine.AbstractScopedMap;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.model.internal.db.MongoConnection;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
@Slf4j
public class MongoClientProvider extends AbstractScopedMap<MongoClient>{

8
src/main/java/org/gcube/application/geoportal/service/engine/cache/MongoConnectionProvider.java vendored
View File

@ -1,14 +1,14 @@
package org.gcube.application.geoportal.service.engine.cache;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.ServiceConstants;
import org.gcube.application.geoportal.service.engine.AbstractScopedMap;
import org.gcube.application.geoportal.service.model.internal.db.MongoConnection;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.utils.ISUtils;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
public class MongoConnectionProvider extends AbstractScopedMap<MongoConnection>{
public MongoConnectionProvider() {

61
src/main/java/org/gcube/application/geoportal/service/engine/mongo/ConcessioniMongoManager.java
View File

@ -1,5 +1,30 @@
package org.gcube.application.geoportal.service.engine.mongo;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.mongodb.client.MongoDatabase;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.gcube.application.geoportal.common.model.legacy.*;
import org.gcube.application.geoportal.common.model.legacy.report.ValidationReport;
import org.gcube.application.geoportal.common.model.legacy.report.ValidationReport.ValidationStatus;
import org.gcube.application.geoportal.common.rest.TempFile;
import org.gcube.application.geoportal.common.utils.Files;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.engine.SDIManager;
import org.gcube.application.geoportal.service.engine.StorageClientProvider;
import org.gcube.application.geoportal.service.engine.WorkspaceManager;
import org.gcube.application.geoportal.service.engine.WorkspaceManager.FileOptions;
import org.gcube.application.geoportal.service.engine.WorkspaceManager.FolderOptions;
import org.gcube.application.geoportal.service.engine.postgis.PostgisIndex;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.model.internal.faults.InvalidStateException;
import org.gcube.application.geoportal.service.model.internal.faults.PublishException;
import org.gcube.application.geoportal.service.model.internal.faults.SDIInteractionException;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.gcube.common.storagehub.client.dsl.FolderContainer;
import java.io.IOException;
import java.sql.SQLException;
import java.time.LocalDateTime;
@ -7,42 +32,6 @@ import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.gcube.application.geoportal.common.model.legacy.AssociatedContent;
import org.gcube.application.geoportal.common.model.legacy.Concessione;
import org.gcube.application.geoportal.common.model.legacy.GeoServerContent;
import org.gcube.application.geoportal.common.model.legacy.LayerConcessione;
import org.gcube.application.geoportal.common.model.legacy.OtherContent;
import org.gcube.application.geoportal.common.model.legacy.PersistedContent;
import org.gcube.application.geoportal.common.model.legacy.RelazioneScavo;
import org.gcube.application.geoportal.common.model.legacy.SDILayerDescriptor;
import org.gcube.application.geoportal.common.model.legacy.UploadedImage;
import org.gcube.application.geoportal.common.model.legacy.WorkspaceContent;
import org.gcube.application.geoportal.common.model.legacy.report.ValidationReport;
import org.gcube.application.geoportal.common.model.legacy.report.ValidationReport.ValidationStatus;
import org.gcube.application.geoportal.common.rest.TempFile;
import org.gcube.application.geoportal.common.utils.Files;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.model.fault.PublishException;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.engine.SDIManager;
import org.gcube.application.geoportal.service.engine.StorageClientProvider;
import org.gcube.application.geoportal.service.engine.WorkspaceManager;
import org.gcube.application.geoportal.service.engine.WorkspaceManager.FileOptions;
import org.gcube.application.geoportal.service.engine.WorkspaceManager.FolderOptions;
import org.gcube.application.geoportal.service.model.internal.faults.InvalidStateException;
import org.gcube.application.geoportal.service.model.internal.faults.SDIInteractionException;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.gcube.common.storagehub.client.dsl.FolderContainer;
import org.gcube.common.storagehub.model.exceptions.StorageHubException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.mongodb.client.MongoDatabase;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class ConcessioniMongoManager extends MongoManager{

14
src/main/java/org/gcube/application/geoportal/service/engine/mongo/MongoManager.java
View File

@ -1,13 +1,6 @@
package org.gcube.application.geoportal.service.engine.mongo;
import static com.mongodb.client.model.Filters.eq;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
@ -15,8 +8,13 @@ import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.FindOneAndReplaceOptions;
import com.mongodb.client.model.FindOneAndUpdateOptions;
import com.mongodb.client.model.ReturnDocument;
import lombok.extern.slf4j.Slf4j;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import static com.mongodb.client.model.Filters.eq;
@Slf4j
public abstract class MongoManager {

195
src/main/java/org/gcube/application/geoportal/service/engine/postgis/PostgisDBManager.java Normal file
View File

@ -0,0 +1,195 @@
package org.gcube.application.geoportal.service.engine.postgis;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.common.model.legacy.BBOX;
import org.gcube.application.geoportal.service.model.internal.db.DatabaseConnection;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.model.internal.faults.DataParsingException;
import java.io.IOException;
import java.sql.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@Slf4j
public class PostgisDBManager implements PostgisDBManagerI {
@Synchronized
public static PostgisDBManager get() throws SQLException, ConfigurationException {
if(config==null) {
log.debug("Looking for Default Configuration.. ");
DatabaseConnection defaultConfiguration= DatabaseConnection.get(DatabaseConnection.TYPE.Concessioni);
log.debug("Found configuration : "+defaultConfiguration);
config=defaultConfiguration;
}
return new PostgisDBManager();
}
public static PostgisDBManagerI get(boolean autocommit) throws SQLException, ConfigurationException {
PostgisDBManager toReturn=get();
toReturn.conn.setAutoCommit(autocommit);
return toReturn;
}
private static DatabaseConnection config;
public static void init(DatabaseConnection config) throws SQLException, IOException {
PostgisDBManager.config=config;
try{
Class.forName("org.postgresql.Driver");
Class.forName("org.postgis.DriverWrapper");
}catch(Exception e){
throw new RuntimeException(e);
}
}
private static Connection getConnection() throws SQLException {
Connection toReturn= DriverManager.getConnection(config.getUrl(),config.getUser(),config.getPwd());
toReturn.setAutoCommit(config.getAutocommit());
return toReturn;
}
private Connection conn=null;
private PostgisDBManager() throws SQLException {
conn=getConnection();
}
@Override
public void create(PostgisTable toCreate) throws SQLException {
String createStmt=toCreate.getCreateStatement();
log.debug("Executing create : "+createStmt);
conn.createStatement().executeUpdate(createStmt);
}
/* (non-Javadoc)
* @see org.gcube.application.geoportal.PostgisDBManagerI#commit()
*/
@Override
public void commit() throws SQLException {
conn.commit();
}
/* (non-Javadoc)
* @see org.gcube.application.geoportal.PostgisDBManagerI#evaluateBoundingBox(org.gcube.application.geoportal.model.PostgisTable)
*/
@Override
public BBOX evaluateBoundingBox(PostgisTable table) throws SQLException, DataParsingException {
ResultSet rs=conn.createStatement().executeQuery("Select ST_Extent("+table.getGeometryColumn()+") as extent from "+table.getTablename());
if(rs.next())
return DBUtils.parseST_Extent(rs.getString("extent"));
else throw new SQLException("No extent returned");
}
/* (non-Javadoc)
* @see org.gcube.application.geoportal.PostgisDBManagerI#evaluateBoundingBox(org.gcube.application.geoportal.model.PostgisTable)
*/
@Override
public PostgisTable.POINT evaluateCentroid(PostgisTable table) throws SQLException, DataParsingException {
ResultSet rs=conn.createStatement().executeQuery("Select ST_AsText(ST_Centroid(ST_Collect("+table.getGeometryColumn()+"))) as centroid from "+table.getTablename());
if(rs.next())
return PostgisTable.POINT.parsePOINT(rs.getString("centroid"));
else throw new SQLException("No extent returned");
}
/* (non-Javadoc)
* @see org.gcube.application.geoportal.PostgisDBManagerI#prepareInsertStatement(org.gcube.application.geoportal.model.PostgisTable, boolean, boolean)
*/
@Override
public PreparedStatement prepareInsertStatement(PostgisTable target, boolean createTable, boolean geometryAsText) throws SQLException {
if(createTable) {
create(target);
}
String insertStmt=target.getInsertionStatement(geometryAsText);
log.debug("Preparing insert statement : "+insertStmt);
return conn.prepareStatement(insertStmt);
}
@Override
public int deleteByFieldValue(PostgisTable target, PostgisTable.Field field, Object value) throws SQLException {
PreparedStatement stmt = conn.prepareStatement(target.getDeleteByFieldStatement(field));
target.setObjectInPreparedStatement(field, value, stmt, 1);
return stmt.executeUpdate();
}
@Override
public DatabaseConnection getConnectionDescriptor() {
return config;
}
/* (non-Javadoc)
* @see org.gcube.application.geoportal.PostgisDBManagerI#deleteTable(java.lang.String)
*/
@Override
public void deleteTable(String tableName) throws SQLException {
conn.createStatement().executeUpdate("DROP TABLE "+tableName);
}
/* (non-Javadoc)
* @see org.gcube.application.geoportal.PostgisDBManagerI#truncate(java.lang.String)
*/
@Override
public void truncate(String tableName) throws SQLException{
conn.createStatement().executeUpdate("TRUNCATE Table "+tableName);
}
@Override
public ResultSet queryAll(PostgisTable table) throws SQLException {
// TODO Check schema
return conn.createStatement().executeQuery("Select * from "+table.getTablename());
}
// *********************** INNER UTILS CLASS
protected static class DBUtils {
private static Pattern pattern = Pattern.compile("(?!=\\d\\.\\d\\.)([\\d.]+)");
public static BBOX parseST_Extent(String extent) throws DataParsingException {
//BOX(11.9122574810083 44.2514144864263,11.9761128271586 44.2912342569845)
try {
log.debug("Parsing BBOX "+extent);
Matcher m=pattern.matcher(extent);
// Scanner sc = new Scanner(extent);
// double minLong = sc.nextDouble(),
// minLat = sc.nextDouble(),
// maxLong = sc.nextDouble(),
// maxLat= sc.nextDouble();
if(!m.find()) throw new DataParsingException("Unable to get minLong ");
Double minLong=Double.parseDouble(m.group(1));
if(!m.find()) throw new DataParsingException("Unable to get minLat ");
Double minLat=Double.parseDouble(m.group(1));
if(!m.find()) throw new DataParsingException("Unable to get maxLong ");
Double maxLong=Double.parseDouble(m.group(1));
if(!m.find()) throw new DataParsingException("Unable to get maxLat ");
Double maxLat=Double.parseDouble(m.group(1));
return new BBOX(maxLat, maxLong, minLat, minLong);
}catch(Throwable t) {
throw new DataParsingException("Invalid BBOX "+extent,t);
}
}
}
}

40
src/main/java/org/gcube/application/geoportal/service/engine/postgis/PostgisDBManagerI.java Normal file
View File

@ -0,0 +1,40 @@
package org.gcube.application.geoportal.service.engine.postgis;
import org.gcube.application.geoportal.common.model.legacy.BBOX;
import org.gcube.application.geoportal.service.model.internal.db.DatabaseConnection;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable;
import org.gcube.application.geoportal.service.model.internal.faults.DataParsingException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public interface PostgisDBManagerI {
void commit() throws SQLException;
// int insertCentroid(CentroidRecord record) throws SQLException;
// int deleteCentroid(String uuid) throws SQLException;
BBOX evaluateBoundingBox(PostgisTable table) throws SQLException, DataParsingException;
PreparedStatement prepareInsertStatement(PostgisTable target, boolean createTable, boolean geometryAsText)
throws SQLException;
void deleteTable(String tableName) throws SQLException;
void truncate(String tableName) throws SQLException;
void create(PostgisTable toCreate) throws SQLException;
PostgisTable.POINT evaluateCentroid(PostgisTable table) throws SQLException, DataParsingException;
ResultSet queryAll(PostgisTable table) throws SQLException;
int deleteByFieldValue(PostgisTable target, PostgisTable.Field field, Object value) throws SQLException;
DatabaseConnection getConnectionDescriptor();
}

31
src/main/java/org/gcube/application/geoportal/service/engine/mongo/PostgisIndex.java → src/main/java/org/gcube/application/geoportal/service/engine/postgis/PostgisIndex.java
View File

@ -1,4 +1,16 @@
package org.gcube.application.geoportal.service.engine.mongo;
package org.gcube.application.geoportal.service.engine.postgis;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.common.model.legacy.Concessione;
import org.gcube.application.geoportal.service.engine.SDIManager;
import org.gcube.application.geoportal.service.model.internal.db.DBConstants;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable.Field;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable.FieldType;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.model.internal.faults.PublishException;
import org.gcube.application.geoportal.service.model.internal.faults.SDIInteractionException;
import org.gcube.application.geoportal.service.utils.Serialization;
import java.sql.PreparedStatement;
import java.sql.SQLException;
@ -6,22 +18,7 @@ import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.gcube.application.geoportal.common.model.legacy.Concessione;
import org.gcube.application.geoportal.model.db.DBConstants;
import org.gcube.application.geoportal.model.db.PostgisTable;
import org.gcube.application.geoportal.model.db.PostgisTable.Field;
import org.gcube.application.geoportal.model.db.PostgisTable.FieldType;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.model.fault.PublishException;
import org.gcube.application.geoportal.service.engine.SDIManager;
import org.gcube.application.geoportal.service.model.internal.faults.SDIInteractionException;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.gcube.application.geoportal.storage.PostgisDBManager;
import org.gcube.application.geoportal.storage.PostgisDBManagerI;
import lombok.Getter;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;
;
@Slf4j
public class PostgisIndex {

133
src/main/java/org/gcube/application/geoportal/service/model/internal/db/DBConstants.java Normal file
View File

@ -0,0 +1,133 @@
package org.gcube.application.geoportal.service.model.internal.db;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable.Field;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable.FieldType;
import org.gcube.application.geoportal.service.model.internal.db.PostgisTable.GeometryType;
import java.util.ArrayList;
public class DBConstants {
public static class Defaults{
public static final String DEFAULT_GEOMETRY_COLUMN_NAME="geom";
public static final String INTERNAL_ID="internal_id";
public static final String XCOORD_FIELD="xcoord";
public static final String YCOORD_FIELD="ycoord";
}
/**
* nome,anno,regione,xcentroid,ycentroid,csv,shp,
* geopackage,nome_csv,nome_shp,nome_geo,
* poligono,punti,linee,
* nome_progetto, descrizione_progetto,descrizione_contenuto,autore,contributore,
* titolare_dati,responsabile,editore,
* finanziamento,soggetto,
* risorse_correlate,
* date_scavo,data_archiviazione,
* versione,licenza,titolare_licenza_copyright,accesso_dati,parole_chiave
*
* @author FabioISTI
*
*/
public static class Concessioni{
public static final String PRODUCT_ID="product_id";
public static final String NOME="nome";
public static final String ANNO="anno";
public static final String REGIONE="regione";
public static final String GEOMETRY=Defaults.DEFAULT_GEOMETRY_COLUMN_NAME;
//Extension
public static final String DESCRIZIONE="descrizione";
public static final String CONTENUTO="contenuto";
public static final String AUTORE="autore";
public static final String CONTRIBUTORE="contributore";
public static final String TITOLARE="titolare";
public static final String RESPONSABILE="responsabile";
public static final String EDITORE="editore";
public static final String FINANZIAMENTO="finanziamento";
public static final String SOGGETTO="soggetto";
public static final String RISORSE="risorse";
public static final String DATE_SCAVO="date_scavo";
public static final String DATA_ARCHIVIAZIONE="data_archiviazione";
public static final String VERSIONE="versione";
public static final String LICENZA="licenza";
public static final String TITOLARE_LICENZA="titolare_licenza";
public static final String ACCESSO="accesso";
public static final String PAROLE_CHIAVE="parole_chiave";
public static final ArrayList<Field> COLUMNS=new ArrayList<PostgisTable.Field>();
public static final PostgisTable CENTROIDS=new PostgisTable("centroids_concessioni",
COLUMNS, GeometryType.POINT);
static {
CENTROIDS.getFields().add(new Field(Defaults.INTERNAL_ID,FieldType.AUTOINCREMENT));
CENTROIDS.getFields().add(new Field(PRODUCT_ID,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(NOME,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(ANNO,FieldType.INT));
CENTROIDS.getFields().add(new Field(REGIONE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(GEOMETRY,FieldType.GEOMETRY));
//EXtenions
CENTROIDS.getFields().add(new Field(DESCRIZIONE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(CONTENUTO,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(AUTORE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(CONTRIBUTORE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(TITOLARE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(RESPONSABILE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(EDITORE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(FINANZIAMENTO,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(SOGGETTO,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(RISORSE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(DATE_SCAVO,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(DATA_ARCHIVIAZIONE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(VERSIONE,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(LICENZA,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(TITOLARE_LICENZA,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(ACCESSO,FieldType.TEXT));
CENTROIDS.getFields().add(new Field(PAROLE_CHIAVE,FieldType.TEXT));
}
}
public static class MOSI{
public static final String CODE="code";
public static final String GEOMETRY=Defaults.DEFAULT_GEOMETRY_COLUMN_NAME;
public static final ArrayList<Field> COLUMNS=new ArrayList<PostgisTable.Field>();
public static final PostgisTable CENTROID_MOSI=new PostgisTable("centroids_mosi",
new ArrayList<Field>(), GeometryType.POINT);
static {
CENTROID_MOSI.getFields().add(new Field(Defaults.INTERNAL_ID,FieldType.AUTOINCREMENT));
CENTROID_MOSI.getFields().add(new Field(GEOMETRY,FieldType.GEOMETRY));
CENTROID_MOSI.getFields().add(new Field(CODE,FieldType.TEXT));
}
}
public static class MOPR{
public static final PostgisTable CENTROID_MOPR=new PostgisTable("centroids_mopr",
new ArrayList<Field>(), GeometryType.POINT);
}
public static class INTERNAL{
public static final String DB_NAME="gna_internal_db";
public static final String RECORD="RECORD";
// public static final String CONCESSIONE="CONCESSIONE";
// public static final String
}
}

30
src/main/java/org/gcube/application/geoportal/service/model/internal/db/DatabaseConnection.java Normal file
View File

@ -0,0 +1,30 @@
package org.gcube.application.geoportal.service.model.internal.db;
import lombok.*;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.utils.ISUtils;
@Getter
@Setter
@RequiredArgsConstructor
@ToString
public class DatabaseConnection {
public static enum TYPE{
Concessioni,Mosi,Mopr
}
public static DatabaseConnection get(TYPE type) throws ConfigurationException {
return ISUtils.queryForDB("postgis", type.toString());
}
@NonNull
private String user;
@NonNull
private String pwd;
@NonNull
private String url;
private Boolean autocommit=false;
}

4
src/main/java/org/gcube/application/geoportal/service/model/internal/db/MongoConnection.java
View File

@ -1,10 +1,10 @@
package org.gcube.application.geoportal.service.model.internal.db;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
@Data
public class MongoConnection {

314
src/main/java/org/gcube/application/geoportal/service/model/internal/db/PostgisTable.java Normal file
View File

@ -0,0 +1,314 @@
package org.gcube.application.geoportal.service.model.internal.db;
import lombok.*;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.common.model.legacy.BBOX;
import org.gcube.application.geoportal.service.model.internal.faults.DataParsingException;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.DecimalFormat;
import java.text.NumberFormat;
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;
@Slf4j
@RequiredArgsConstructor
@Getter
@ToString
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)","","");
private final String SRID;
private final String definition;
private final String InsertWKT;
private final String insertWKB;
}
@RequiredArgsConstructor
@Getter
@ToString
public static class Field{
@NonNull
private String name;
@NonNull
private FieldType type;
private Boolean isIndexed;
private Object constantValue;
}
@Getter
@AllArgsConstructor
public enum FieldType{
INT("int",java.sql.Types.INTEGER),
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;
private int sqlType;
}
@RequiredArgsConstructor
@Getter
@ToString
public static class POINT{
private static Pattern pattern = Pattern.compile("(?!=\\d\\.\\d\\.)([\\d.]+)");
public static POINT parsePOINT(String point) throws DataParsingException {
//POINT(8.30230113965909 44.8011688237011)
// x,y
try {
log.debug("Parsing POINT "+point);
Matcher m=pattern.matcher(point);
if(!m.find()) throw new DataParsingException("Unable to get x ");
Double x=Double.parseDouble(m.group(1));
if(!m.find()) throw new DataParsingException("Unable to get y ");
Double y=Double.parseDouble(m.group(1));
return new POINT(x,y);
}catch(Throwable t) {
throw new DataParsingException("Invalid POINT "+point,t);
}
}
@NonNull
private Double x;
@NonNull
private Double y;
}
private static final NumberFormat DECIMAL_FORMAT=NumberFormat.getInstance(Locale.US);
static {
((DecimalFormat) DECIMAL_FORMAT).setGroupingUsed(false);
}
public String getGeometryColumn() {
for(Field f:fields)
if(f.getType().equals(FieldType.GEOMETRY)) return f.getName();
return null;
}
@NonNull
private String tablename;
@NonNull
private List<Field> fields;
@NonNull
private GeometryType geometryColumnType;
@Setter
private BBOX boundingBox=null;
@Setter
private POINT centroid=null;
public void setTablename(String tablename) {
this.tablename = sanitizeFieldName(tablename);
}
public String getCreateStatement() {
StringBuilder stmt=new StringBuilder();
stmt.append("CREATE TABLE IF NOT EXISTS "+tablename+"( ");
for(Field field:fields){
String fieldDefinition=field.getType().getDefinition();
if(field.getType().equals(FieldType.GEOMETRY))
fieldDefinition=this.getGeometryColumnType().definition;
stmt.append(field.getName()+" "+fieldDefinition+",");
}
stmt.deleteCharAt(stmt.lastIndexOf(","));
stmt.append(")");
return stmt.toString();
}
public String getDeleteByFieldStatement(Field field) {
return "DELETE FROM "+tablename+" WHERE "+field.getName()+" = ? ";
}
public String getInsertionStatement(boolean geometryText) {
StringBuilder fieldList=new StringBuilder();
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(","));
return "Insert into "+tablename+" ("+fieldList+") VALUES ("+fieldInsertion+")";
}
public void fillObjectsPreparedStatement(Map<String,Object> row, PreparedStatement toFill) throws SQLException {
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++;
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 : {
toFill.setBytes(psFieldIndex, (byte[])value);
}
}
}
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);
// else
switch(field.getType()) {
case FLOAT :{
try{
toFill.setFloat(psFieldIndex, Float.parseFloat(value));
}catch(NumberFormatException e) {
throw new SQLException(field+" cannot be null. CSV Row is "+rowValues,e);
}
break;
}
case INT : {
try{
toFill.setInt(psFieldIndex, Integer.parseInt(value));
}catch(NumberFormatException e) {
log.warn("Skipping value for "+field+" row was "+rowValues,e);
toFill.setNull(psFieldIndex, java.sql.Types.INTEGER);
}
break;
}
case TEXT : {
toFill.setString(psFieldIndex, value.toString());
break;
}
case GEOMETRY : {
if(explicitGeometry) {
toFill.setString(psFieldIndex,value);
}else {
switch(geometryColumnType){
case POINT: {
String xRepresentation=DECIMAL_FORMAT.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+" "+
yRepresentation+")");
break;
}
default :{
toFill.setString(psFieldIndex,rowValues.get("wkt"));
break;
}
}
}
break;
}
}
}
}
}
public static String sanitizeFieldName(String fieldName) {
// return fieldName.toLowerCase().replaceAll(" ", "_").replaceAll("\\.", "").replaceAll("-", "_").replaceAll("////","_");
return fieldName.toLowerCase().replaceAll("[^a-z0-9_\\\\]", "_");
}
}

38
src/main/java/org/gcube/application/geoportal/service/model/internal/faults/ConfigurationException.java Normal file
View File

@ -0,0 +1,38 @@
package org.gcube.application.geoportal.service.model.internal.faults;
public class ConfigurationException extends Exception {
/**
*
*/
private static final long serialVersionUID = -3810929853461018566L;
public ConfigurationException() {
super();
// TODO Auto-generated constructor stub
}
public ConfigurationException(String message, Throwable cause, boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
// TODO Auto-generated constructor stub
}
public ConfigurationException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
public ConfigurationException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public ConfigurationException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}

30
src/main/java/org/gcube/application/geoportal/service/model/internal/faults/DataParsingException.java Normal file
View File

@ -0,0 +1,30 @@
package org.gcube.application.geoportal.service.model.internal.faults;
public class DataParsingException extends Exception {
public DataParsingException() {
// TODO Auto-generated constructor stub
}
public DataParsingException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public DataParsingException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
public DataParsingException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
public DataParsingException(String message, Throwable cause, boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
// TODO Auto-generated constructor stub
}
}

42
src/main/java/org/gcube/application/geoportal/service/model/internal/faults/PublishException.java Normal file
View File

@ -0,0 +1,42 @@
package org.gcube.application.geoportal.service.model.internal.faults;
import lombok.NonNull;
import org.gcube.spatial.data.gis.model.report.PublishResponse;
public class PublishException extends Exception {
/**
*
*/
private static final long serialVersionUID = -1356876669436308224L;
@NonNull
private PublishResponse resp;
public PublishException(PublishResponse resp) {
super();
this.resp=resp;
}
public PublishException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace,PublishResponse resp) {
super(message, cause, enableSuppression, writableStackTrace);
this.resp=resp;
}
public PublishException(String message, Throwable cause,PublishResponse resp) {
super(message, cause);
this.resp=resp;
}
public PublishException(String message,PublishResponse resp) {
super(message);
this.resp=resp;
}
public PublishException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}

60
src/main/java/org/gcube/application/geoportal/service/model/internal/rest/AddSectionToConcessioneRequest.java
View File

@ -1,46 +1,34 @@
package org.gcube.application.geoportal.service.model.internal.rest;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElements;
import javax.xml.bind.annotation.XmlRootElement;
import org.gcube.application.geoportal.model.concessioni.LayerConcessione;
import org.gcube.application.geoportal.model.concessioni.RelazioneScavo;
import org.gcube.application.geoportal.model.content.AssociatedContent;
import org.gcube.application.geoportal.model.content.OtherContent;
import org.gcube.application.geoportal.model.content.UploadedImage;
import org.gcube.application.geoportal.model.gis.SDILayerDescriptor;
import lombok.Data;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
@Data
public class AddSectionToConcessioneRequest {
public static enum Section{
RELAZIONE,UPLOADED_IMG,PIANTA,POSIZIONAMENTO,OTHER
}
@XmlRootElement
@Data
public static class SHUBFileDescriptor {
private String filename;
private String shubID;
}
private Section section;
@XmlElements({
@XmlElement(type=OtherContent.class),
@XmlElement(type=RelazioneScavo.class),
@XmlElement(type=SDILayerDescriptor.class),
@XmlElement(type=LayerConcessione.class),
@XmlElement(type=UploadedImage.class),
})
private AssociatedContent toRegister;
private List<SHUBFileDescriptor> streams=new ArrayList<AddSectionToConcessioneRequest.SHUBFileDescriptor>();
// public static enum Section{
// RELAZIONE,UPLOADED_IMG,PIANTA,POSIZIONAMENTO,OTHER
// }
//
// @XmlRootElement
// @Data
// public static class SHUBFileDescriptor {
// private String filename;
// private String shubID;
// }
//
//
// private Section section;
// @XmlElements({
// @XmlElement(type=OtherContent.class),
// @XmlElement(type=RelazioneScavo.class),
// @XmlElement(type=SDILayerDescriptor.class),
// @XmlElement(type=LayerConcessione.class),
// @XmlElement(type=UploadedImage.class),
// })
// private AssociatedContent toRegister;
// private List<SHUBFileDescriptor> streams=new ArrayList<AddSectionToConcessioneRequest.SHUBFileDescriptor>();
}

174
src/main/java/org/gcube/application/geoportal/service/rest/Concessioni.java
View File

@ -1,174 +0,0 @@
package org.gcube.application.geoportal.service.rest;
import java.util.Collection;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response.Status;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import org.gcube.application.geoportal.managers.ConcessioneManager;
import org.gcube.application.geoportal.managers.ManagerFactory;
import org.gcube.application.geoportal.model.InputStreamDescriptor;
import org.gcube.application.geoportal.model.concessioni.Concessione;
import org.gcube.application.geoportal.model.concessioni.LayerConcessione;
import org.gcube.application.geoportal.model.concessioni.RelazioneScavo;
import org.gcube.application.geoportal.model.content.UploadedImage;
import org.gcube.application.geoportal.model.report.PublicationReport;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.engine.StorageClientProvider;
import org.gcube.application.geoportal.service.model.internal.rest.AddSectionToConcessioneRequest;
import org.gcube.application.geoportal.service.model.internal.rest.AddSectionToConcessioneRequest.SHUBFileDescriptor;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.json.JSONArray;
import lombok.extern.slf4j.Slf4j;
@Path(InterfaceConstants.Methods.CONCESSIONI)
@Slf4j
public class Concessioni {
@PUT
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Path("publish/{"+InterfaceConstants.Parameters.PROJECT_ID+"}")
public String publish(@PathParam(InterfaceConstants.Parameters.PROJECT_ID) String id) {
try {
log.info("Publishing Concessione by id {} ",id);
Concessione conc=(Concessione) ConcessioneManager.getByID(Long.parseLong(id));
ConcessioneManager manager=ManagerFactory.getByRecord(conc);
log.debug("Loaded object {} ",conc);
PublicationReport rep=manager.commitSafely(true);
String toReturn=rep.prettyPrint();
log.debug("Publication report to send is "+toReturn);
return toReturn;
}catch(WebApplicationException e){
log.warn("Unable to serve request",e);
throw e;
}catch(Throwable e){
log.warn("Unable to serve request",e);
throw new WebApplicationException("Unable to serve request", e);
}
}
@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("{"+InterfaceConstants.Parameters.PROJECT_ID+"}")
public String getById(@PathParam(InterfaceConstants.Parameters.PROJECT_ID) String id) {
try {
log.info("Loading Concessione by id {} ",id);
Concessione toReturn=(Concessione) ConcessioneManager.getByID(Long.parseLong(id));
if(toReturn==null)
throw new WebApplicationException("Concessione non trovata",Status.NOT_FOUND);
log.debug("Loaded object {} ",toReturn);
return Serialization.write(toReturn);
}catch(WebApplicationException e){
log.warn("Unable to serve request",e);
throw e;
}catch(Throwable e){
log.warn("Unable to serve request",e);
throw new WebApplicationException("Unable to serve request", e);
}
}
@PUT
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public String registerNew(String toRegister) {
try {
log.info("Registering new Concessione "+toRegister);
Concessione conc=Serialization.read(toRegister, Concessione.class);
ConcessioneManager manager=ManagerFactory.registerNew(conc);
manager.commitSafely(false);
return Serialization.write(manager.getRecord());
}catch(WebApplicationException e){
log.warn("Unable to serve request",e);
throw e;
}catch(Throwable e){
log.warn("Unable to serve request",e);
throw new WebApplicationException("Unable to serve request", e);
}
}
@PUT
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Path("section/{"+InterfaceConstants.Parameters.PROJECT_ID+"}")
public String addSection(@PathParam(InterfaceConstants.Parameters.PROJECT_ID) String id,
AddSectionToConcessioneRequest request) {
try {
log.info("Adding section to Concessione {} ",id);
Concessione toReturn=(Concessione) ConcessioneManager.getByID(Long.parseLong(id));
ConcessioneManager manager=ManagerFactory.getByRecord(toReturn);
log.debug("Loaded object {} ",toReturn);
log.debug("Request is {}",request);
InputStreamDescriptor[] streams=new InputStreamDescriptor[request.getStreams().size()];
StorageClientProvider storage=ImplementationProvider.get().getStorageProvider();
for(int i=0;i<streams.length;i++) {
SHUBFileDescriptor sent=request.getStreams().get(i);
streams[i]=new InputStreamDescriptor(storage.open(sent.getShubID()), sent.getFilename());
}
switch(request.getSection()) {
case PIANTA :manager.addPiantaFineScavo((LayerConcessione) request.getToRegister(),streams);
break;
case POSIZIONAMENTO : manager.setPosizionamento((LayerConcessione) request.getToRegister(),streams);
break;
case RELAZIONE : manager.setRelazioneScavo((RelazioneScavo)request.getToRegister(), streams[0]);
break;
case UPLOADED_IMG : manager.addImmagineRappresentativa((UploadedImage)request.getToRegister(), streams[0]);
break;
default : throw new Exception("Unrecognized section");
}
// PublicationReport report=manager.commitSafely(false);
Concessione c=manager.commit(false);
log.debug("Published "+Serialization.write(c));
return c.validate().prettyPrint();
}catch(WebApplicationException e){
log.warn("Unable to serve request",e);
throw e;
}catch(Throwable e){
log.warn("Unable to serve request",e);
throw new WebApplicationException("Unable to serve request", e);
}
}
@GET
@Produces(MediaType.APPLICATION_JSON)
public String getList(){
try {
Collection<Concessione> toReturn=ManagerFactory.getList(Concessione.class);
log.debug("Found "+toReturn.size()+" elements..");
JSONArray array=new JSONArray();
for(Concessione found:toReturn) {
array.put(Serialization.write(found));
}
return array.toString();
}catch(WebApplicationException e){
log.warn("Unable to serve request",e);
throw e;
}catch(Throwable e){
log.warn("Unable to serve request",e);
throw new WebApplicationException("Unable to serve request", e);
}
}
}

21
src/main/java/org/gcube/application/geoportal/service/rest/ConcessioniOverMongo.java
View File

@ -1,31 +1,16 @@
package org.gcube.application.geoportal.service.rest;
import java.time.LocalDateTime;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.common.model.legacy.Concessione;
import org.gcube.application.geoportal.common.rest.AddSectionToConcessioneRequest;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import org.gcube.application.geoportal.common.rest.TempFile;
import org.gcube.application.geoportal.service.engine.WorkspaceManager;
import org.gcube.application.geoportal.service.engine.WorkspaceManager.FolderOptions;
import org.gcube.application.geoportal.service.engine.mongo.ConcessioniMongoManager;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.gcube.common.storagehub.client.dsl.FolderContainer;
import org.json.JSONArray;
import org.json.JSONObject;
import lombok.extern.slf4j.Slf4j;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
@Path(InterfaceConstants.Methods.MONGO_CONCESSIONI)
@Slf4j

4
src/main/java/org/gcube/application/geoportal/service/rest/GuardedMethod.java
View File

@ -1,10 +1,10 @@
package org.gcube.application.geoportal.service.rest;
import lombok.extern.slf4j.Slf4j;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response.Status;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public abstract class GuardedMethod<T> {

20
src/main/java/org/gcube/application/geoportal/service/rest/Projects.java
View File

@ -1,24 +1,14 @@
package org.gcube.application.geoportal.service.rest;
import java.util.Collections;
import java.util.List;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import lombok.extern.slf4j.Slf4j;
import org.bson.Document;
import org.gcube.application.geoportal.common.model.project.Project;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import lombok.extern.slf4j.Slf4j;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import java.util.Collections;
import java.util.List;
@Path(InterfaceConstants.Methods.PROJECTS)
@Slf4j

7
src/main/java/org/gcube/application/geoportal/service/rest/Sections.java
View File

@ -1,12 +1,11 @@
package org.gcube.application.geoportal.service.rest;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Path(InterfaceConstants.Methods.SECTIONS+"/{"+InterfaceConstants.Parameters.PROJECT_ID+"}")
public class Sections {

5
src/main/java/org/gcube/application/geoportal/service/utils/ContextUtils.java
View File

@ -1,12 +1,11 @@
package org.gcube.application.geoportal.service.utils;
import static org.gcube.common.authorization.client.Constants.authorizationService;
import lombok.extern.slf4j.Slf4j;
import org.gcube.common.authorization.library.AuthorizationEntry;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.common.scope.api.ScopeProvider;
import lombok.extern.slf4j.Slf4j;
import static org.gcube.common.authorization.client.Constants.authorizationService;
@Slf4j
public class ContextUtils {

18
src/main/java/org/gcube/application/geoportal/service/utils/ISUtils.java
View File

@ -1,15 +1,9 @@
package org.gcube.application.geoportal.service.utils;
import static org.gcube.resources.discovery.icclient.ICFactory.clientFor;
import static org.gcube.resources.discovery.icclient.ICFactory.queryFor;
import java.util.List;
import java.util.Map;
import org.gcube.application.geoportal.model.db.DatabaseConnection;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.ServiceConstants;
import org.gcube.application.geoportal.service.model.internal.db.DatabaseConnection;
import org.gcube.application.geoportal.service.model.internal.db.MongoConnection;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.common.encryption.encrypter.StringEncrypter;
import org.gcube.common.resources.gcore.ServiceEndpoint;
import org.gcube.common.resources.gcore.ServiceEndpoint.AccessPoint;
@ -17,9 +11,15 @@ import org.gcube.common.resources.gcore.ServiceEndpoint.Property;
import org.gcube.resources.discovery.client.api.DiscoveryClient;
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
import java.util.List;
import java.util.Map;
import static org.gcube.resources.discovery.icclient.ICFactory.clientFor;
import static org.gcube.resources.discovery.icclient.ICFactory.queryFor;
public class ISUtils {
public static DatabaseConnection queryForDB(String platform,String flag) throws ConfigurationException {
public static DatabaseConnection queryForDB(String platform, String flag) throws ConfigurationException {
List<AccessPoint> found=getAP(platform, flag);
if(found.size()>1) {

118
src/main/java/org/gcube/application/geoportal/service/utils/Serialization.java
View File

@ -1,21 +1,13 @@
package org.gcube.application.geoportal.service.utils;
import java.io.IOException;
import java.time.format.DateTimeFormatter;
import org.gcube.application.geoportal.model.Record;
import org.gcube.application.geoportal.model.concessioni.Concessione;
import org.gcube.application.geoportal.model.concessioni.LayerConcessione;
import org.gcube.application.geoportal.model.content.AssociatedContent;
import org.gcube.application.geoportal.model.content.OtherContent;
import org.gcube.application.geoportal.model.content.PersistedContent;
import org.gcube.application.geoportal.model.content.UploadedImage;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import java.io.IOException;
import java.time.format.DateTimeFormatter;
public class Serialization {
@ -34,61 +26,61 @@ public class Serialization {
}
public static String write(Object toWrite) throws JsonProcessingException {
if(toWrite instanceof Concessione)
detach((Concessione) toWrite);
// if(toWrite instanceof Concessione)
// detach((Concessione) toWrite);
String toReturn= mapper.writeValueAsString(toWrite);
if(toWrite instanceof Concessione)
reattach((Concessione) toWrite);
// if(toWrite instanceof Concessione)
// reattach((Concessione) toWrite);
return toReturn;
}
// Avoid infiniteLoop in JPA
private static void detach(Concessione c) {
if (c!=null) {
detach(c.getRelazioneScavo());
detach(c.getPosizionamentoScavo());
if(c.getPianteFineScavo()!=null)
c.getPianteFineScavo().forEach((LayerConcessione l)->{detach(l);});
if(c.getImmaginiRappresentative()!=null)
c.getImmaginiRappresentative().forEach(((UploadedImage u)->{detach(u);}));
if(c.getGenericContent()!=null)
c.getGenericContent().forEach(((OtherContent u)->{detach(u);}));
}
}
private static void detach(AssociatedContent a) {
if(a!=null) {
a.setRecord(null);
if(a.getActualContent()!=null)
a.getActualContent().forEach((PersistedContent p)->{p.setAssociated(null);});
}
}
private static void reattach(Concessione c) {
if(c!=null) {
reattach(c.getRelazioneScavo(),c);
reattach(c.getPosizionamentoScavo(),c);
if(c.getPianteFineScavo()!=null)
c.getPianteFineScavo().forEach((LayerConcessione l)->{reattach(l,c);});
if(c.getImmaginiRappresentative()!=null)
c.getImmaginiRappresentative().forEach(((UploadedImage u)->{reattach(u,c);}));
if(c.getGenericContent()!=null)
c.getGenericContent().forEach(((OtherContent u)->{reattach(u,c);}));
}
}
private static void reattach(AssociatedContent a,Record r) {
if(a!=null) {
a.setRecord(r);
if(a.getActualContent()!=null)
a.getActualContent().forEach((PersistedContent p)->{p.setAssociated(a);});
}
}
// private static void detach(Concessione c) {
// if (c!=null) {
// detach(c.getRelazioneScavo());
// detach(c.getPosizionamentoScavo());
// if(c.getPianteFineScavo()!=null)
// c.getPianteFineScavo().forEach((LayerConcessione l)->{detach(l);});
// if(c.getImmaginiRappresentative()!=null)
// c.getImmaginiRappresentative().forEach(((UploadedImage u)->{detach(u);}));
// if(c.getGenericContent()!=null)
// c.getGenericContent().forEach(((OtherContent u)->{detach(u);}));
// }
// }
//
// private static void detach(AssociatedContent a) {
// if(a!=null) {
// a.setRecord(null);
// if(a.getActualContent()!=null)
// a.getActualContent().forEach((PersistedContent p)->{p.setAssociated(null);});
// }
// }
//
//
// private static void reattach(Concessione c) {
// if(c!=null) {
// reattach(c.getRelazioneScavo(),c);
// reattach(c.getPosizionamentoScavo(),c);
// if(c.getPianteFineScavo()!=null)
// c.getPianteFineScavo().forEach((LayerConcessione l)->{reattach(l,c);});
// if(c.getImmaginiRappresentative()!=null)
// c.getImmaginiRappresentative().forEach(((UploadedImage u)->{reattach(u,c);}));
// if(c.getGenericContent()!=null)
// c.getGenericContent().forEach(((OtherContent u)->{reattach(u,c);}));
// }
// }
//
// private static void reattach(AssociatedContent a,Record r) {
// if(a!=null) {
// a.setRecord(r);
// if(a.getActualContent()!=null)
// a.getActualContent().forEach((PersistedContent p)->{p.setAssociated(a);});
// }
// }
}

25
src/test/java/org/gcube/application/geoportal/service/BasicServiceTestUnit.java
View File

@ -1,24 +1,19 @@
package org.gcube.application.geoportal.service;
import javax.persistence.EntityManagerFactory;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Response;
import org.gcube.application.geoportal.managers.AbstractRecordManager;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.model.report.PublicationReport;
import com.mongodb.MongoClient;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.engine.ScopedEMFProvider;
import org.gcube.application.geoportal.service.engine.StorageClientProvider;
import org.gcube.application.geoportal.service.engine.cache.MongoClientProvider;
import org.gcube.application.geoportal.service.engine.cache.MongoConnectionProvider;
import org.gcube.application.geoportal.service.legacy.TokenSetter;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.gcube.contentmanagement.blobstorage.service.IClient;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.BeforeClass;
import com.mongodb.MongoClient;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Response;
public class BasicServiceTestUnit extends JerseyTest {
@ -34,17 +29,7 @@ public class BasicServiceTestUnit extends JerseyTest {
@BeforeClass
public static void init() {
String scope="/gcube/devsec/devVRE";
AbstractRecordManager.setDefaultProvider(
new ScopedEMFProvider(){
@Override
public EntityManagerFactory getFactory() {
TokenSetter.set(scope);
return super.getFactory();
}
});
ImplementationProvider.get().setStorageProvider(new StorageClientProvider() {
@Override
public IClient getObject() throws ConfigurationException {

24
src/test/java/org/gcube/application/geoportal/service/ConcessioniOverMongoTest.java
View File

@ -1,19 +1,5 @@
package org.gcube.application.geoportal.service;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.gcube.application.geoportal.common.model.legacy.Concessione;
import org.gcube.application.geoportal.common.model.legacy.Concessione.Paths;
import org.gcube.application.geoportal.common.model.legacy.LayerConcessione;
@ -29,6 +15,16 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.*;
public class ConcessioniOverMongoTest extends BasicServiceTestUnit{

14
src/test/java/org/gcube/application/geoportal/service/ProjectTests.java
View File

@ -1,18 +1,14 @@
package org.gcube.application.geoportal.service;
import java.util.Collections;
import java.util.List;
import org.bson.Document;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import org.junit.Test;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import org.bson.Document;
import org.gcube.application.geoportal.common.model.project.Project;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import org.junit.Test;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Collections;
import java.util.List;
public class ProjectTests extends BasicServiceTestUnit{

6
src/test/java/org/gcube/application/geoportal/service/SDITests.java
View File

@ -1,15 +1,15 @@
package org.gcube.application.geoportal.service;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.engine.SDIManager;
import org.gcube.application.geoportal.service.engine.mongo.PostgisIndex;
import org.gcube.application.geoportal.service.engine.postgis.PostgisIndex;
import org.gcube.application.geoportal.service.legacy.TokenSetter;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.gcube.application.geoportal.service.model.internal.faults.SDIInteractionException;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import javax.validation.constraints.AssertTrue;
import java.sql.SQLException;
import java.util.regex.Matcher;

11
src/test/java/org/gcube/application/geoportal/service/TestModel.java
View File

@ -1,16 +1,11 @@
package org.gcube.application.geoportal.service;
import org.bson.types.ObjectId;
import org.gcube.application.geoportal.common.model.legacy.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.UUID;
import org.bson.types.ObjectId;
import org.gcube.application.geoportal.common.model.legacy.AccessPolicy;
import org.gcube.application.geoportal.common.model.legacy.Concessione;
import org.gcube.application.geoportal.common.model.legacy.LayerConcessione;
import org.gcube.application.geoportal.common.model.legacy.RelazioneScavo;
import org.gcube.application.geoportal.common.model.legacy.UploadedImage;

188
src/test/java/org/gcube/application/geoportal/service/legacy/ConcessioniTest.java
View File

@ -1,188 +0,0 @@
package org.gcube.application.geoportal.service.legacy;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collection;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.gcube.application.geoportal.common.rest.InterfaceConstants;
import org.gcube.application.geoportal.common.utils.Files;
import org.gcube.application.geoportal.model.concessioni.Concessione;
import org.gcube.application.geoportal.model.concessioni.LayerConcessione;
import org.gcube.application.geoportal.model.content.AssociatedContent;
import org.gcube.application.geoportal.model.content.UploadedImage;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.model.report.PublicationReport;
import org.gcube.application.geoportal.model.report.ValidationReport.ValidationStatus;
import org.gcube.application.geoportal.service.BasicServiceTestUnit;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.model.internal.rest.AddSectionToConcessioneRequest;
import org.gcube.application.geoportal.service.model.internal.rest.AddSectionToConcessioneRequest.SHUBFileDescriptor;
import org.gcube.application.geoportal.service.model.internal.rest.AddSectionToConcessioneRequest.Section;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.gcube.com.fasterxml.jackson.core.JsonProcessingException;
import org.gcube.contentmanagement.blobstorage.transport.backend.RemoteBackendException;
import org.junit.Test;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class ConcessioniTest extends BasicServiceTestUnit {
@Test
public void readId() {
WebTarget target=target(InterfaceConstants.Methods.CONCESSIONI);
try{
System.out.println(target.path("9").request(MediaType.APPLICATION_JSON).get(String.class));
}catch(WebApplicationException e) {
if(e.getResponse().getStatus()==404)
System.out.println("Object not found");
else throw e;
}
}
@Test
public void list() throws JsonProcessingException, IOException{
WebTarget target=target(InterfaceConstants.Methods.CONCESSIONI);
System.err.println(target.getUri());
Collection coll=target.request(MediaType.APPLICATION_JSON).get(Collection.class);
System.out.println("Size of collection is "+coll.size());
System.out.println("Iterating through objects.. ");
for(Object o:coll) {
System.out.println("Object class is "+o.getClass());
Concessione c=Serialization.read(o.toString(), Concessione.class);
System.out.println("Concessione is : "+Serialization.write(c));
}
}
@Test
public void failPublish() throws com.fasterxml.jackson.core.JsonProcessingException, IOException {
Concessione toCreate=OLDTestModel.prepareEmptyConcessione();
Concessione conc=pushConcessione(toCreate);
System.out.println(publish(conc.getId()+"").prettyPrint());
}
@Test
public void createNew() throws IOException {
Concessione toCreate=OLDTestModel.prepareEmptyConcessione();
pushConcessione(toCreate);
}
@Test
public void publishNew() throws IOException, RemoteBackendException, ConfigurationException {
Concessione toCreate=OLDTestModel.prepareEmptyConcessione();
Concessione registered = pushConcessione(toCreate);
System.out.println("Registered at "+Serialization.write(registered));
Concessione fullTemplate=OLDTestModel.prepareConcessione();
//Push Relazione
publishSection(registered.getId()+"",formRequest(Section.RELAZIONE,fullTemplate.getRelazioneScavo(),"concessioni/relazione.pdf"));
assertNotNull(getById(registered.getId()+"").getRelazioneScavo());
//Push Immagini
for(UploadedImage img:fullTemplate.getImmaginiRappresentative())
publishSection(registered.getId()+"",formRequest(Section.UPLOADED_IMG,img,"concessioni/immagine.png"));
assertNotNull(getById(registered.getId()+"").getImmaginiRappresentative());
assertTrue(getById(registered.getId()+"").getImmaginiRappresentative().size()==fullTemplate.getImmaginiRappresentative().size());
//Push Posizinamento
publishSection(registered.getId()+"",formRequest(Section.POSIZIONAMENTO,fullTemplate.getPosizionamentoScavo(),"concessioni/pos.dbf","concessioni/pos.shp"));
assertNotNull(getById(registered.getId()+"").getPosizionamentoScavo());
//Push piante
for(LayerConcessione l:fullTemplate.getPianteFineScavo())
publishSection(registered.getId()+"",formRequest(Section.PIANTA,l,"concessioni/pos.dbf","concessioni/pos.shp"));
assertNotNull(getById(registered.getId()+"").getPianteFineScavo());
assertTrue(getById(registered.getId()+"").getPianteFineScavo().size()==fullTemplate.getPianteFineScavo().size());
Concessione reloaded = getById(registered.getId()+"");
System.out.println("Goind to publish "+Serialization.write(reloaded));
PublicationReport report=publish(registered.getId()+"");
System.out.println("REPORT IS "+report.prettyPrint()+"");
// System.out.println("Concessione is "+report.getTheRecord().asJson());
assertTrue(report.getStatus().equals(ValidationStatus.PASSED));
}
// ACTUAL METHODS
private PublicationReport publish(String id) throws com.fasterxml.jackson.core.JsonProcessingException, IOException {
WebTarget target=target(InterfaceConstants.Methods.CONCESSIONI);
Response resp=target.path("publish").path(id).request(MediaType.APPLICATION_JSON).put(Entity.entity("sopmething", MediaType.APPLICATION_JSON));
if(resp.getStatus()<200||resp.getStatus()>=300)
System.err.println("RESP STATUS IS "+resp.getStatus());
String resString=resp.readEntity(String.class);
System.out.println("Resp String is "+resString);
PublicationReport registered=Serialization.read(resString, PublicationReport.class);
System.out.println("Registered concessione at : "+registered);
return registered;
}
private AddSectionToConcessioneRequest formRequest(Section section,AssociatedContent content,String... files) throws RemoteBackendException, FileNotFoundException, ConfigurationException {
AddSectionToConcessioneRequest toReturn=new AddSectionToConcessioneRequest();
toReturn.setSection(section);
toReturn.setToRegister(content);
for(String f:files) {
SHUBFileDescriptor desc=new SHUBFileDescriptor();
desc.setFilename(f.substring(f.lastIndexOf("/")));
String sId=ImplementationProvider.get().getStorageProvider().store(
new FileInputStream(Files.getFileFromResources(f)));
desc.setShubID(sId);
toReturn.getStreams().add(desc);
}
return toReturn;
}
private Response publishSection(String id, AddSectionToConcessioneRequest request) {
WebTarget target=target(InterfaceConstants.Methods.CONCESSIONI);
Response resp=target.path("section").path(id).request(MediaType.APPLICATION_JSON).put(Entity.entity(request, MediaType.APPLICATION_JSON));
if(resp.getStatus()<200||resp.getStatus()>=300) {
System.err.println("RESP STATUS IS "+resp.getStatus());
System.err.println("RESP IS "+resp.readEntity(String.class));
}
return resp;
}
private Concessione pushConcessione(Concessione c) throws com.fasterxml.jackson.core.JsonProcessingException, IOException {
WebTarget target=target(InterfaceConstants.Methods.CONCESSIONI);
Response resp=target.request(MediaType.APPLICATION_JSON).put(Entity.entity(Serialization.write(c), MediaType.APPLICATION_JSON));
String resString=resp.readEntity(String.class);
System.out.println("Resp String is "+resString);
Concessione registered=Serialization.read(resString, Concessione.class);
System.out.println("Registered concessione at : "+registered);
return registered;
}
private Concessione getById(String id) throws com.fasterxml.jackson.core.JsonProcessingException, IOException {
WebTarget target=target(InterfaceConstants.Methods.CONCESSIONI);
Response resp=target.path(id).request(MediaType.APPLICATION_JSON).get();
if(resp.getStatus()<200||resp.getStatus()>=300)
System.err.println("RESP STATUS IS "+resp.getStatus());
String resString=resp.readEntity(String.class);
System.out.println("Resp String is "+resString);
return Serialization.read(resString, Concessione.class);
}
}

21
src/test/java/org/gcube/application/geoportal/service/legacy/MongoTests.java
View File

@ -1,21 +1,16 @@
package org.gcube.application.geoportal.service.legacy;
import java.io.IOException;
import org.bson.Document;
import org.gcube.application.geoportal.common.model.profile.Profile;
import org.gcube.application.geoportal.common.utils.Files;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.engine.cache.MongoClientProvider;
import org.gcube.application.geoportal.service.engine.mongo.MongoManager;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.junit.BeforeClass;
import org.junit.Test;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.mongodb.Block;
import com.mongodb.MongoClient;
import org.bson.Document;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.engine.cache.MongoClientProvider;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.junit.BeforeClass;
import org.junit.Test;
import java.io.IOException;
public class MongoTests {

108
src/test/java/org/gcube/application/geoportal/service/legacy/OLDTestModel.java
View File

@ -1,108 +0,0 @@
package org.gcube.application.geoportal.service.legacy;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import org.gcube.application.geoportal.model.AccessPolicy;
import org.gcube.application.geoportal.model.concessioni.Concessione;
import org.gcube.application.geoportal.model.concessioni.LayerConcessione;
import org.gcube.application.geoportal.model.concessioni.RelazioneScavo;
import org.gcube.application.geoportal.model.content.UploadedImage;
public class OLDTestModel {
public static Concessione prepareEmptyConcessione() {
Concessione concessione=new Concessione();
// Generic fields
// Concessione fields
concessione.setNome("Italia, forse");
concessione.setIntroduzione("This is my project");
concessione.setDescrizioneContenuto("It contains this and that");
concessione.setAuthors(Arrays.asList(new String[] {"Some one","Some, oneelse"}));
concessione.setContributore("Contrib 1");
concessione.setTitolari(Arrays.asList(new String[] {"Some one","Some, oneelse"}));
concessione.setResponsabile("Someone");
concessione.setEditore("Editore");
concessione.setFontiFinanziamento(Arrays.asList(new String[] {"Big pharma","Pentagon"}));
concessione.setSoggetto(Arrays.asList(new String[] {"Research Excavation","Archeology"}));
concessione.setDataInizioProgetto(LocalDateTime.now());
concessione.setDataFineProgetto(LocalDateTime.now());
concessione.setLicenzaID("CC-BY");
concessione.setTitolareLicenza(Arrays.asList(new String[] {"Qualcun altro"}));
concessione.setTitolareCopyright(Arrays.asList(new String[] {"Chiedilo in giro"}));
concessione.setParoleChiaveLibere(Arrays.asList(new String[] {"Robba","Stuff"}));
concessione.setParoleChiaveICCD(Arrays.asList(new String[] {"vattelapesca","somthing something"}));
concessione.setCentroidLat(43.0); //N-S
concessione.setCentroidLong(9.0); //E-W
return concessione;
}
public static Concessione prepareConcessione() {
Concessione concessione=prepareEmptyConcessione();
// Attachments
// Relazione scavo
RelazioneScavo relScavo=new RelazioneScavo();
relScavo.setAbstractSection("simple abstract section");
relScavo.setResponsabili(concessione.getAuthors());
concessione.setRelazioneScavo(relScavo);
//Immagini rappresentative
ArrayList<UploadedImage> imgs=new ArrayList<>();
for(int i=0;i<5;i++) {
UploadedImage img=new UploadedImage();
img.setTitolo("My image number "+i);
img.setDidascalia("You can see my image number "+i);
img.setFormat("TIFF");
img.setCreationTime(LocalDateTime.now());
img.setResponsabili(concessione.getAuthors());
imgs.add(img);
}
concessione.setImmaginiRappresentative(imgs);
//Posizionamento
LayerConcessione posizionamento=new LayerConcessione();
posizionamento.setValutazioneQualita("Secondo me si");
posizionamento.setMetodoRaccoltaDati("Fattobbene");
posizionamento.setScalaAcquisizione("1:10000");
posizionamento.setAuthors(concessione.getAuthors());
concessione.setPosizionamentoScavo(posizionamento);
// Piante fine scavo
ArrayList<LayerConcessione> piante=new ArrayList<LayerConcessione>();
for(int i=0;i<4;i++) {
LayerConcessione pianta=new LayerConcessione();
pianta.setValutazioneQualita("Secondo me si");
pianta.setMetodoRaccoltaDati("Fattobbene");
pianta.setScalaAcquisizione("1:10000");
pianta.setAuthors(concessione.getAuthors());
pianta.setPolicy(AccessPolicy.RESTRICTED);
piante.add(pianta);
}
concessione.setPianteFineScavo(piante);
return concessione;
}
}

4
src/test/java/org/gcube/application/geoportal/service/legacy/TokenSetter.java
View File

@ -1,10 +1,10 @@
package org.gcube.application.geoportal.service.legacy;
import java.util.Properties;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.common.scope.api.ScopeProvider;
import java.util.Properties;
public class TokenSetter {