diff --git a/pom.xml b/pom.xml index 1c53fe4..aa2f7a2 100644 --- a/pom.xml +++ b/pom.xml @@ -83,18 +83,28 @@ geoportal-common [1.0.0-SNAPSHOT,2.0.0) + + + org.gcube.application geoportal-logic [1.0.4-SNAPSHOT,2.0.0) - org.javassist - javassist + org.hibernate + hibernate-core + + + org.hibernate + hibernate-core + 5.2.12.Final + + @@ -169,12 +179,7 @@ --> - - + diff --git a/src/main/java/org/gcube/application/geoportal/service/engine/legacy/AbstractRecordManager.java b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/AbstractRecordManager.java new file mode 100644 index 0000000..882b377 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/AbstractRecordManager.java @@ -0,0 +1,288 @@ +package org.gcube.application.geoportal.service.engine.legacy; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.EntityTransaction; + +import org.gcube.application.geoportal.managers.DefatulEMFProvider; +import org.gcube.application.geoportal.managers.EMFProvider; +import org.gcube.application.geoportal.model.Record; +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.PersistenceException; +import org.gcube.application.geoportal.model.fault.PublishException; +import org.gcube.application.geoportal.model.fault.SDIInteractionException; +import org.gcube.application.geoportal.model.fault.ValidationException; +import org.gcube.application.geoportal.model.report.PublicationReport; +import org.gcube.application.geoportal.model.report.ValidationReport; +import org.gcube.application.geoportal.model.report.ValidationReport.ValidationStatus; +import org.gcube.application.geoportal.storage.PostgisDBManager; +import org.gcube.application.geoportal.storage.PostgisDBManagerI; + +import lombok.Synchronized; +import lombok.extern.slf4j.Slf4j; +@Slf4j +public abstract class AbstractRecordManager { + + public static void setDefaultProvider(EMFProvider provider) { + defaultProvider=provider; + } + + private static EMFProvider defaultProvider=new FixedDefaultProvider(); + + @Synchronized + protected static EntityManagerFactory getEMF() { + return defaultProvider.getFactory(); + } + + @Synchronized + public static void shutdown() { + defaultProvider.shutdown(); + } + + public static Record getByID(long id) { + EntityManager em=getEMF().createEntityManager(); + try { + log.debug("Looking for record by ID : "+id); + EntityTransaction tr=em.getTransaction(); + tr.begin(); + Record toReturn=em.find(Record.class, id); + log.debug("Loaded Record "+toReturn); + tr.commit(); + return toReturn; + }finally { + if(em.isJoinedToTransaction()) + em.flush(); + em.close(); + } + } + + + public static Collection getList(){ + EntityManager em=getEMF().createEntityManager(); + try { + log.debug("Getting entire list"); + EntityTransaction tr=em.getTransaction(); + tr.begin(); + List toReturn=em.createQuery("select r from Record r ", + Record.class).getResultList(); + log.debug("Loaded size "+toReturn.size()); + tr.commit(); + return toReturn; + }finally { + if(em.isJoinedToTransaction()) + em.flush(); + em.close(); + } + } + + public static Collection getListByClass(Class clazz){ + EntityManager em=getEMF().createEntityManager(); + try { + log.debug("Getting entire list"); + EntityTransaction tr=em.getTransaction(); + tr.begin(); + + String simpleClassName=clazz.getName().substring(clazz.getName().lastIndexOf(".")+1); + + List toReturn=em.createQuery("select r from "+simpleClassName+" r", + clazz).getResultList(); + log.debug("Loaded size "+toReturn.size()); + tr.commit(); + return toReturn; + }finally { + if(em.isJoinedToTransaction()) + em.flush(); + em.close(); + } + } +// protected T storeInfo() +// { +// log.debug("Storing Record "+theRecord); +// entityManager.persist(theRecord); +// return theRecord; +// } + + //Transaction management + + EntityTransaction transaction=null; + EntityManager entityManager=null; + + //************************ INSTANCE + + private T theRecord; + + private ContentHandler contentHandler; + + protected AbstractRecordManager(T theRecord){ + entityManager=getEMF().createEntityManager(); + transaction=entityManager.getTransaction(); + transaction.begin(); + this.theRecord=theRecord; +// log.debug("Storing Record "+theRecord); + if(theRecord.getId()==0) { + log.debug("Passed record ID = 0. Assuming new .."); + entityManager.persist(theRecord); + }else { + log.debug("Passed record ID = "+theRecord.getId()+". Mergeing.."); + entityManager.merge(theRecord); + } + + this.contentHandler=new ContentHandler(theRecord); + } + + + + + + protected ContentHandler getContentHandler() { + return contentHandler; + } + + public T getRecord() { + return theRecord; + }; + + + /** + * Commit to storages + * + * @return + * @throws PersistenceException + * @throws PublishException + */ + public T commit(boolean publish) throws PersistenceException,ValidationException, PublishException { + + log.trace("Committing record "+theRecord+" Publish is "+publish); + ValidationReport report=theRecord.validate(); + log.debug("Validated Report is "+report); + if(publish && report.getStatus().equals(ValidationStatus.ERROR)) + throw new ValidationException(report,"Cannot publish project. See validation report"); + + // storeInfo(); + + log.debug("Record is valid, storing changed content"); + contentHandler.storeChanges(publish); + // storeInfo(); + + if(publish) { + log.debug("Registering centroid of "+theRecord); + registerCentroid(); + // storeInfo(); + } + + transaction.commit(); + return theRecord; + } + + + public PublicationReport commitSafely(boolean publish) { + log.debug("Safely publishing "+theRecord); + PublicationReport toReturn=new PublicationReport("Publication Report"); + toReturn.setTheRecord(getRecord()); + + + ValidationReport validation=theRecord.validate(); + validation.setObjectName("Validation report for "+validation.getObjectName()); + if(validation.getStatus().equals(ValidationStatus.ERROR)) { + toReturn.addMessage(publish?ValidationStatus.ERROR:ValidationStatus.WARNING, "Record not valid."); + } + toReturn.addChild(validation); + + log.debug("Record is valid, storing changed content [Publish is :"+publish+"]"); + try { + toReturn.addChild(contentHandler.storeChanges(publish)); + + if(publish) { + log.debug("Registering centroid of "+theRecord); + registerCentroid(); + toReturn.addMessage(ValidationStatus.PASSED, "Inserito centroide per record "+theRecord.getId()); + } + transaction.commit(); + + } catch (PersistenceException e) { + toReturn.addChild(e.getReport()); + log.warn("Unexpected internal exception ",e); + } catch (PublishException e) { + toReturn.addMessage(ValidationStatus.WARNING, "Centroide non registrato"); + log.warn("Unexpected internal exception ",e); + } + + + try { + log.info("Report is "+toReturn.prettyPrint()); + }catch (Exception e) { + log.warn("Unable to pretty print report "+toReturn,e); + } + return toReturn; + + } + + + @Override + protected void finalize() throws Throwable { + if(transaction.isActive()) { + transaction.rollback(); + } + entityManager.flush(); + entityManager.close(); + + shutdown(); + } + + private void registerCentroid() throws PublishException{ + + try { + log.debug("Evaluating Centroid"); + Map centroidRow=evaluateCentroid(); + + log.debug("Contacting postgis DB .. "); + PostgisDBManagerI db=PostgisDBManager.get(); + + PostgisTable centroidsTable=getCentroidsTable(); + log.debug("Inserting / updated centroid Row {} ",centroidRow); + + PreparedStatement ps = db.prepareInsertStatement(centroidsTable, true, true); + + log.debug("Deleting centroid if present. ID is "+theRecord.getId()); + db.deleteByFieldValue(centroidsTable, new Field(DBConstants.Concessioni.PRODUCT_ID,FieldType.TEXT), theRecord.getId()+""); + + centroidsTable.fillCSVPreparedStatament(centroidRow, ps, false); + ps.executeUpdate(); + db.commit(); + + initCentroidLayer(); + + + }catch(SQLException e) { + log.warn("Unable to publish Centroid for record "+theRecord,e); + throw new PublishException("Unable to publish centroid.",e, null); + }catch(SDIInteractionException e) { + log.warn("Unable to publish Centroid Layer for record type "+getRecord().getRecordType(),e); + throw new PublishException("Unable to publish centroid.",e, null); + } catch (ConfigurationException e) { + log.warn("Unable to contact centroids db "+getRecord().getRecordType(),e); + throw new PublishException("Unable to publish centroid.",e, null); + } + + } + + protected abstract PostgisTable getCentroidsTable(); + protected abstract void initCentroidLayer() throws SDIInteractionException; + + protected abstract Map evaluateCentroid(); + + + + //*********** PERSISTENCE + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/engine/legacy/ContentHandler.java b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/ContentHandler.java new file mode 100644 index 0000000..6f78524 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/ContentHandler.java @@ -0,0 +1,172 @@ +package org.gcube.application.geoportal.service.engine.legacy; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; + +import org.gcube.application.geoportal.model.InputStreamDescriptor; +import org.gcube.application.geoportal.model.Record; +import org.gcube.application.geoportal.model.fault.PersistenceException; +import org.gcube.application.geoportal.model.fault.SDIInteractionException; +import org.gcube.application.geoportal.model.report.PublicationReport; +import org.gcube.application.geoportal.model.report.ValidationReport; +import org.gcube.application.geoportal.model.report.ValidationReport.ValidationStatus; +import org.gcube.application.geoportal.service.model.legacy.concessioni.AssociatedContent; +import org.gcube.application.geoportal.service.model.legacy.concessioni.GeoServerContent; +import org.gcube.application.geoportal.service.model.legacy.concessioni.LayerConcessione; +import org.gcube.application.geoportal.service.model.legacy.concessioni.OtherContent; +import org.gcube.application.geoportal.service.model.legacy.concessioni.PersistedContent; +import org.gcube.application.geoportal.service.model.legacy.concessioni.RelazioneScavo; +import org.gcube.application.geoportal.service.model.legacy.concessioni.SDILayerDescriptor; +import org.gcube.application.geoportal.service.model.legacy.concessioni.UploadedImage; +import org.gcube.application.geoportal.service.model.legacy.concessioni.WorkspaceContent; +import org.gcube.application.geoportal.utils.Files; +import org.gcube.common.storagehub.client.dsl.FolderContainer; +import org.gcube.common.storagehub.model.exceptions.StorageHubException; + +import lombok.extern.slf4j.Slf4j; + + +@Slf4j +public class ContentHandler { + + private Map> uploadedResources=new HashMap>(); + + private Map> toDeleteResources=new HashMap>(); + + private ArrayList toDeleteTemps=new ArrayList(); + + private T record; + + public ContentHandler(T record) { + this.record=record; + } + + + /** + * Register files as to be associated with content + * + * @param content + * @param files + * @throws IOException + */ + public void register(AssociatedContent content, InputStreamDescriptor...iss) throws IOException { + ArrayList tempFiles=new ArrayList(); + for(InputStreamDescriptor is:iss) + tempFiles.add(new TempFile(Files.copyToTemp(is.getStream()),is.getFilename())); + + toDeleteTemps.addAll(tempFiles); + uploadedResources.put(content, tempFiles); + } + + /** + * Unregisters files from current operation set * + * + */ + public void unregister(AssociatedContent content, InputStreamDescriptor...iss) { + + } + + public void dispose(AssociatedContent content) { + + } + + public PublicationReport storeChanges(Boolean publish) throws PersistenceException { + + // + + log.debug("Starting to persist "+uploadedResources.size()+" resources "+record.getNome()); + PublicationReport toReturn=new PublicationReport("Storage report"); + try { + + WorkspaceManager wsManager=new WorkspaceManager(record); + SDIManager sdiManager=null; + if(publish) + sdiManager=new SDIManager(); + + + for(Entry> entry:uploadedResources.entrySet()) { + AssociatedContent content=entry.getKey(); + ArrayList persisted=new ArrayList(); + FolderContainer destination=null; + String description=null; + String workspace=null; + log.debug("Storing "+content); + + if(content instanceof RelazioneScavo) { + destination= wsManager.getSubFolder("relazione"); + description="Relazione di scavo : "+content.getTitolo(); + + }else if (content instanceof UploadedImage) { + destination= wsManager.getSubFolder("imgs"); + description="Immagine significativa : "+content.getTitolo(); + }else if (content instanceof SDILayerDescriptor) { + //SDI Section + if(content instanceof LayerConcessione) { + destination= wsManager.getSubFolder("layers/"+content.getTitolo()); + description="Layer concessione : "+content.getTitolo(); + + if(publish) { + try { + //if not present create workspace for current project + if(workspace==null) + workspace=sdiManager.createWorkspace("gna_conc_"+record.getId()); + + GeoServerContent geoserverPersisted=sdiManager.pushShapeLayerFileSet((SDILayerDescriptor)content, entry.getValue(),workspace); + geoserverPersisted.setAssociated(content); + persisted.add(geoserverPersisted); + }catch(SDIInteractionException e) { + log.warn("Unable to publish layers.",e); + toReturn.addMessage(ValidationStatus.WARNING, "Layer "+content.getTitolo()+" non pubblicato."); + } + toReturn.addMessage(ValidationStatus.PASSED, "Pubblicato layer "+content.getTitolo()); + } + + }else throw new Exception("Invalid SDI Content "+content); + + + }else if (content instanceof OtherContent ) { + destination= wsManager.getSubFolder("other/"+content.getTitolo()); + description= "Other content : "+content.getTitolo(); + }else throw new Exception ("Invalid content "+content); + + log.debug("Actually Storing files to WS folder "+destination.getId()); + + + for(TempFile theFile : entry.getValue()) { + WorkspaceContent wsContent=wsManager.storeToWS(theFile.getTheFile(), destination, theFile.getOriginalFileName(), description); + wsContent.setAssociated(content); + persisted.add(wsContent); + } + + toReturn.addMessage(ValidationStatus.PASSED, "Registrati "+entry.getValue().size()+" elementi in archivio per : "+content.getTitolo()); + + content.setActualContent(persisted); + } + return toReturn; + }catch(StorageHubException e) { + toReturn.addMessage(ValidationStatus.ERROR, "Impossibile archiviare."); + log.error("Unexpected SGHUB Exception",e); + throw new PersistenceException("Unexpected Exception",e,toReturn); + }catch(Throwable t) { + toReturn.addMessage(ValidationStatus.ERROR, "Errore inatteso."); + throw new PersistenceException("Unexpected Exception",t,toReturn); + } + + } + + + @Override + protected void finalize() throws Throwable { + for(TempFile f:toDeleteTemps) + java.nio.file.Files.deleteIfExists(f.getTheFile().toPath()); + } + + + public ValidationReport validateContent() { + return null; + } + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/engine/legacy/FixedDefaultProvider.java b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/FixedDefaultProvider.java new file mode 100644 index 0000000..7bf922b --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/FixedDefaultProvider.java @@ -0,0 +1,192 @@ +package org.gcube.application.geoportal.service.engine.legacy; + +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.DefatulEMFProvider; +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 FixedDefaultProvider implements EMFProvider{ + +private static EntityManagerFactory emf=null; + + + @Override + public EntityManagerFactory getFactory() { + if(emf==null) { + try { + DatabaseConnection conn=ISUtils.queryForDB("postgresql", "internal-db"); + log.debug("Found Internal Database : "+conn); + + emf = new HibernatePersistenceProvider().createContainerEntityManagerFactory( + archiverPersistenceUnitInfo(), + ImmutableMap.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()); + + }catch(ConfigurationException e) { + throw new RuntimeException("Unable to init EMF",e); + } + } + return emf; + } + + + private static PersistenceUnitInfo archiverPersistenceUnitInfo() { + + final List MANAGED_CLASSES=Arrays.asList(new String[] { + "org.gcube.application.geoportal.model.Record", + "org.gcube.application.geoportal.service.model.legacy.concessioni.Concessione", + "org.gcube.application.geoportal.service.model.legacy.concessioni.LayerConcessione", + "org.gcube.application.geoportal.service.model.legacy.concessioni.RelazioneScavo", + + "org.gcube.application.geoportal.service.model.legacy.concessioni.AssociatedContent", + "org.gcube.application.geoportal.service.model.legacy.concessioni.GeoServerContent", + "org.gcube.application.geoportal.service.model.legacy.concessioni.OtherContent", + "org.gcube.application.geoportal.service.model.legacy.concessioni.PersistedContent", + "org.gcube.application.geoportal.service.model.legacy.concessioni.UploadedImage", + "org.gcube.application.geoportal.service.model.legacy.concessioni.WorkspaceContent", + + "org.gcube.application.geoportal.service.model.legacy.concessioni.ShapeFileLayerDescriptor", + "org.gcube.application.geoportal.service.model.legacy.concessioni.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 getMappingFileNames() { + return Collections.emptyList(); + } + + @Override + public List 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 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; + } + }; + } + + + @Override + public void shutdown() { + if(emf!=null) { + if(emf.isOpen()) emf.close(); + emf=null; + } + } + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/engine/legacy/LegacyConcessioniManager.java b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/LegacyConcessioniManager.java new file mode 100644 index 0000000..9bbdbff --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/LegacyConcessioniManager.java @@ -0,0 +1,139 @@ +package org.gcube.application.geoportal.service.engine.legacy; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +import org.gcube.application.geoportal.model.InputStreamDescriptor; +import org.gcube.application.geoportal.model.db.DBConstants; +import org.gcube.application.geoportal.model.db.PostgisTable; +import org.gcube.application.geoportal.model.fault.SDIInteractionException; +import org.gcube.application.geoportal.service.model.legacy.concessioni.Concessione; +import org.gcube.application.geoportal.service.model.legacy.concessioni.LayerConcessione; +import org.gcube.application.geoportal.service.model.legacy.concessioni.RelazioneScavo; +import org.gcube.application.geoportal.service.model.legacy.concessioni.UploadedImage; +import org.gcube.application.geoportal.service.utils.Serialization; +import org.gcube.application.geoportal.storage.SDIManager; + +import lombok.extern.slf4j.Slf4j; + +@Slf4j +public class LegacyConcessioniManager extends AbstractRecordManager { + + public LegacyConcessioniManager(Concessione theRecord) { + super(theRecord); + } + @Override + protected PostgisTable getCentroidsTable() { + return DBConstants.Concessioni.CENTROIDS; + } + + + + +@Override +protected void initCentroidLayer() throws SDIInteractionException { + log.debug("Checking for centroid layer configuration.. "); + SDIManager sdiManager=new SDIManager(); + + sdiManager.configureCentroidLayer("centroids_concessioni", "gna", "gna_postgis"); +} + + public Concessione setRelazioneScavo(RelazioneScavo rel, InputStreamDescriptor theFile) throws IOException { + ContentHandler handler=getContentHandler(); + //Check if already stored content + Concessione record=getRecord(); + if(record.getRelazioneScavo()!=null && !record.getRelazioneScavo().getActualContent().isEmpty()) { + handler.dispose(record.getRelazioneScavo()); + } + + rel.setRecord(record); + + //Register relazione + record.setRelazioneScavo(rel); + handler.register(rel, theFile); + + return record; + } + + public Concessione addImmagineRappresentativa(UploadedImage img, InputStreamDescriptor theFile) throws IOException { + ContentHandler handler=getContentHandler(); + Concessione record=getRecord(); + //Add immagine + + img.setRecord(record); + record.getImmaginiRappresentative().add(img); + handler.register(img, theFile); + + return record; + } + + // public Concessione disposeImmagineRappresentativa(UploadedImage img, InputStream theFile) { + // if(concessione.) + // } + + public Concessione setPosizionamento(LayerConcessione layer, InputStreamDescriptor...inputStreams ) throws IOException { + ContentHandler handler=getContentHandler(); + //Check if already stored content + Concessione record=getRecord(); + if(record.getPosizionamentoScavo()!=null && !record.getPosizionamentoScavo().getActualContent().isEmpty()) + handler.dispose(record.getPosizionamentoScavo()); + + layer.setRecord(record); + + //Register posizionamneot + record.setPosizionamentoScavo(layer); + handler.register(layer, inputStreams); + + return record; + } + + public Concessione addPiantaFineScavo(LayerConcessione layer, InputStreamDescriptor...inputStreams ) throws IOException { + ContentHandler handler=getContentHandler(); + Concessione record=getRecord(); + //Add pianta + layer.setRecord(record); + + + record.getPianteFineScavo().add(layer); + handler.register(layer, inputStreams); + + return record; + } + + @Override + protected Map evaluateCentroid(){ + + Concessione record=getRecord(); + + // CENTROID + Map centroidsRow=new HashMap(); + centroidsRow.put(DBConstants.Concessioni.PRODUCT_ID, record.getId()+""); + centroidsRow.put(DBConstants.Concessioni.ANNO, record.getDataInizioProgetto().getYear()+""); + centroidsRow.put(DBConstants.Concessioni.NOME, record.getNome()); + centroidsRow.put(DBConstants.Concessioni.REGIONE, ""); //TODO + centroidsRow.put(DBConstants.Defaults.XCOORD_FIELD, record.getCentroidLong()+""); + centroidsRow.put(DBConstants.Defaults.YCOORD_FIELD, record.getCentroidLat()+""); + + //Updated Schema + centroidsRow.put(DBConstants.Concessioni.DESCRIZIONE,record.getIntroduzione()); + centroidsRow.put(DBConstants.Concessioni.CONTENUTO,record.getDescrizioneContenuto()); + centroidsRow.put(DBConstants.Concessioni.AUTORE,Serialization.asString(record.getAuthors())); + centroidsRow.put(DBConstants.Concessioni.CONTRIBUTORE,record.getContributore()); + centroidsRow.put(DBConstants.Concessioni.TITOLARE,Serialization.asString(record.getTitolari())); + centroidsRow.put(DBConstants.Concessioni.RESPONSABILE,record.getResponsabile()); + centroidsRow.put(DBConstants.Concessioni.EDITORE,record.getEditore()); + centroidsRow.put(DBConstants.Concessioni.FINANZIAMENTO,Serialization.asString(record.getFontiFinanziamento())); + centroidsRow.put(DBConstants.Concessioni.SOGGETTO,Serialization.asString(record.getSoggetto())); + centroidsRow.put(DBConstants.Concessioni.RISORSE,Serialization.asString(record.getRisorseCorrelate())); + centroidsRow.put(DBConstants.Concessioni.DATE_SCAVO,Serialization.FULL_FORMATTER.format(record.getDataFineProgetto())); + centroidsRow.put(DBConstants.Concessioni.DATA_ARCHIVIAZIONE,Serialization.FULL_FORMATTER.format(record.getLastUpdateTime())); + centroidsRow.put(DBConstants.Concessioni.VERSIONE,record.getVersion()); + centroidsRow.put(DBConstants.Concessioni.LICENZA,record.getLicenzaID()); + centroidsRow.put(DBConstants.Concessioni.TITOLARE_LICENZA,record.getTitolareLicenza()); + centroidsRow.put(DBConstants.Concessioni.ACCESSO,record.getPolicy().toString()); + centroidsRow.put(DBConstants.Concessioni.PAROLE_CHIAVE,Serialization.asString(record.getParoleChiaveLibere())); + + return centroidsRow; + } +} \ No newline at end of file diff --git a/src/main/java/org/gcube/application/geoportal/service/engine/legacy/SDIManager.java b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/SDIManager.java new file mode 100644 index 0000000..671a36b --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/SDIManager.java @@ -0,0 +1,212 @@ +package org.gcube.application.geoportal.service.engine.legacy; + +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.List; + +import org.gcube.application.geoportal.model.fault.SDIInteractionException; +import org.gcube.application.geoportal.service.model.legacy.concessioni.GeoServerContent; +import org.gcube.application.geoportal.service.model.legacy.concessioni.SDILayerDescriptor; +import org.gcube.application.geoportal.utils.Files; +import org.gcube.data.transfer.library.DataTransferClient; +import org.gcube.data.transfer.library.TransferResult; +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.DestinationClashPolicy; +import org.gcube.spatial.data.gis.GISInterface; +import org.gcube.spatial.data.gis.is.AbstractGeoServerDescriptor; + +import it.geosolutions.geoserver.rest.GeoServerRESTPublisher; +import it.geosolutions.geoserver.rest.GeoServerRESTPublisher.UploadMethod; +import it.geosolutions.geoserver.rest.encoder.GSLayerEncoder; +import it.geosolutions.geoserver.rest.encoder.datastore.GSPostGISDatastoreEncoder; +import it.geosolutions.geoserver.rest.encoder.feature.GSFeatureTypeEncoder; +import lombok.extern.slf4j.Slf4j; + + +@Slf4j +public class SDIManager { + + static private String DEFAULT_CRS="EPSG:4326"; + + + private GISInterface gis; + private DataTransferClient dtGeoServer; + private String geoserverHostName; + + + public SDIManager() throws SDIInteractionException { + try{ + log.debug("Initializing GIS Interface.."); + gis=GISInterface.get(); + AbstractGeoServerDescriptor geoserver=gis.getCurrentGeoServer(); + if(geoserver==null) + throw new Exception("Unable to contact data transfer for geoserver "); + + log.debug("Found geoserver descriptor "+geoserver); + geoserverHostName=new URL(gis.getCurrentGeoServer().getUrl()).getHost(); + + log.debug("Contacting Data Transfer from geoserver {} ",geoserverHostName); + dtGeoServer=DataTransferClient.getInstanceByEndpoint("http://"+geoserverHostName); + + }catch(Exception e) { + throw new SDIInteractionException("Unable to initialize SDI Manager",e); + } + } + + public String createWorkspace(String toCreate) throws SDIInteractionException { + try { + if(!gis.getCurrentGeoServer().getPublisher().createWorkspace(toCreate)) + log.warn("Unable to create workspace "+toCreate+". Assuming already exisintg.."); + return toCreate; + } catch (IllegalArgumentException | MalformedURLException e) { + throw new SDIInteractionException("Unable to create workspace "+toCreate,e); + } + } + + + // GEOSERVER-PERSISTENCE-ID / GNA / PROJECT-ID /LAYER-ID/ FILENAME + + public GeoServerContent pushShapeLayerFileSet(SDILayerDescriptor currentElement,List files,String workspace) throws SDIInteractionException{ + try { + String remoteFolder=null; + String fileName=null; + + log.debug("Transferring "+files.size()+" files to geoserver @ "+geoserverHostName); + + GeoServerContent content=new GeoServerContent(); + content.setGeoserverHostName(geoserverHostName); + content.setWorkspace(workspace); + + + for(TempFile f:files) { + Destination destination=new Destination(f.getOriginalFileName()); + destination.setCreateSubfolders(true); + destination.setOnExistingFileName(DestinationClashPolicy.REWRITE); + destination.setOnExistingSubFolder(DestinationClashPolicy.ADD_SUFFIX); + destination.setPersistenceId("geoserver"); + destination.setSubFolder("GNA/"+currentElement.getRecord().getId()+"/"+currentElement.getLayerName()); + TransferResult result=dtGeoServer.localFile(f.getTheFile(), destination); + content.getFileNames().add(f.getOriginalFileName()); + + remoteFolder=result.getRemotePath().substring(0,result.getRemotePath().lastIndexOf("/")); + fileName=f.getOriginalFileName(); + content.setGeoserverPath(remoteFolder); + } + + + + String toSetLayerName=fileName.substring(0,fileName.lastIndexOf(".")); + + content.setStore(toSetLayerName+"_store"); + content.setFeatureType(toSetLayerName); + + GeoServerRESTPublisher publisher=gis.getCurrentGeoServer().getPublisher(); + log.debug("Trying to create remote workspace : "+workspace); + gis.getCurrentGeoServer().getPublisher().createWorkspace(workspace); + log.debug("Publishing remote folder "+remoteFolder); + + URL directoryPath=new URL("file:"+remoteFolder); + + + + //TODO Evaluate SRS + + boolean published=publisher.publishShp( + workspace, + toSetLayerName+"_store", + null, + toSetLayerName, + // UploadMethod.FILE, // neeeds zip + UploadMethod.EXTERNAL, // needs shp + directoryPath.toURI(), + DEFAULT_CRS, //SRS + ""); // default style + + if(!published) { + throw new SDIInteractionException("Unable to publish layer "+toSetLayerName+" under "+workspace+". Unknown Geoserver fault."); + } + + currentElement.setLayerName(toSetLayerName); + + + // TODO Metadata + return content; + } catch (InvalidSourceException | SourceNotSetException | FailedTransferException | InitializationException + | InvalidDestinationException | DestinationNotSetException e) { + throw new SDIInteractionException("Unable to transfer fileSet for content "+currentElement,e); + } catch (SDIInteractionException e) { + throw e; + } catch (Throwable t) { + throw new SDIInteractionException("Unexpected internal fault while interacting with SDI.",t); + } + } + + private String createStoreFromPostgisDB(String workspace,String storeName) throws SDIInteractionException { + //SET BY PROVISIONING + GSPostGISDatastoreEncoder encoder=new GSPostGISDatastoreEncoder(storeName); + encoder.setJndiReferenceName("java:comp/env/jdbc/postgres"); + encoder.setLooseBBox(true); + encoder.setDatabaseType("postgis"); + encoder.setEnabled(true); + encoder.setFetchSize(1000); + encoder.setValidateConnections(true); + try { + if(!gis.getCurrentGeoServer().getDataStoreManager().create(workspace, encoder)) + log.warn("Unable to create workspace "+storeName+". Assuming already exisintg.."); + return storeName; + } catch (IllegalArgumentException | MalformedURLException e) { + throw new SDIInteractionException("Unable to create store "+storeName,e); + } + + } + + private String publishLayer(File sldFile,String name) throws SDIInteractionException { + try { + if(!gis.getCurrentGeoServer().getPublisher().publishStyle(sldFile, name)) + log.warn("Unable to create style "+name+". Assuming already exisintg.."); + return name; + } catch (IllegalArgumentException | MalformedURLException e) { + throw new SDIInteractionException("Unable to create style "+name,e); + } + + } + + public String configureCentroidLayer(String name,String workspace,String storeName) throws SDIInteractionException { + + GSFeatureTypeEncoder fte=new GSFeatureTypeEncoder(); + fte.setAbstract("Centroid layer for "+name); + fte.setEnabled(true); + fte.setNativeCRS(DEFAULT_CRS); + fte.setTitle(name); + + String style="clustered_centroids"; + + GSLayerEncoder layerEncoder=new GSLayerEncoder(); + layerEncoder.setDefaultStyle(style); + layerEncoder.setEnabled(true); + layerEncoder.setQueryable(true); + try { + //Checking workspace + createWorkspace(workspace); + //Checking store + createStoreFromPostgisDB(workspace, storeName); + //Checkig layer + publishLayer(Files.getFileFromResources("styles/clustered_points.sld"),style); + + if(!gis.getCurrentGeoServer().getPublisher().publishDBLayer(workspace, storeName, fte, layerEncoder)) + log.warn("Unable to create layer "+name+". Assuming already exisintg.."); + return name; + } catch (IllegalArgumentException | MalformedURLException e) { + throw new SDIInteractionException("Unable to create layer "+name,e); + } + + + } +} diff --git a/src/main/java/org/gcube/application/geoportal/service/engine/legacy/TempFile.java b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/TempFile.java new file mode 100644 index 0000000..1a141e7 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/TempFile.java @@ -0,0 +1,13 @@ +package org.gcube.application.geoportal.service.engine.legacy; + +import java.io.File; + +import lombok.Data; +import lombok.NonNull; + +@Data class TempFile{ + @NonNull + File theFile; + @NonNull + String originalFileName; +} \ No newline at end of file diff --git a/src/main/java/org/gcube/application/geoportal/service/engine/legacy/WorkspaceManager.java b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/WorkspaceManager.java new file mode 100644 index 0000000..78a3198 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/engine/legacy/WorkspaceManager.java @@ -0,0 +1,110 @@ +package org.gcube.application.geoportal.service.engine.legacy; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.time.LocalDateTime; + +import org.gcube.application.geoportal.model.Record; +import org.gcube.application.geoportal.service.model.legacy.concessioni.WorkspaceContent; +import org.gcube.application.geoportal.utils.Serialization; +import org.gcube.application.geoportal.utils.Workspace; +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.extern.slf4j.Slf4j; + +@Slf4j +public class WorkspaceManager { + + + private Record record; + + public WorkspaceManager(Record record) { + this.record=record; + } + + private StorageHubClient sgClient=null; + private FolderContainer wsBase=null; + private FolderContainer appBase=null; + + private static final String APP_FOLDER=".GNA_RECORDS"; + + private StorageHubClient getSGClient() { + if(sgClient==null) + sgClient=Workspace.getClient(); + return sgClient; + } + + public FolderContainer getApplicationBaseFolder() throws StorageHubException { + if(appBase==null) { + StorageHubClient client=getSGClient(); + FolderContainer vre=client.openVREFolder(); + try { + appBase = vre.openByRelativePath(APP_FOLDER).asFolder(); + }catch(StorageHubException e) { + log.debug("APP Fodler missing. Initializing.."); + appBase = vre.newFolder(APP_FOLDER, "Base folder for GNA records"); + appBase.setHidden(); + } + } + return appBase; + } + + + private FolderContainer getWSBase() throws StorageHubException { + if(wsBase==null) { + log.debug("WSBASE not set"); + if(record.getFolderId()==null) { + //init folder + log.debug("Initializing record folder.."); + String creationTime=Serialization.FULL_FORMATTER.format(LocalDateTime.now()); + String folderName=record.getRecordType()+"_"+record.getNome()+"_"+creationTime; + log.debug("Folder name will be "+folderName); + wsBase=getApplicationBaseFolder().newFolder(folderName, "Base folder del record "+record.getNome()); + record.setFolderId(wsBase.getId()); + } + log.debug("Opening folder"); + wsBase=getSGClient().open(record.getFolderId()).asFolder(); + } + return wsBase; + } + + public FolderContainer getSubFolder(String path) throws StorageHubException { + return getSubFolder(getWSBase(),path); + } + + private FolderContainer getSubFolder(FolderContainer parentFolder,String path) throws StorageHubException { + try{ + return parentFolder.openByRelativePath(path).asFolder(); + }catch(StorageHubException e) { + log.debug("Missing subPath "+path); + FolderContainer targetParent=parentFolder; + String targetName=path; + if(path.contains("/")) { + String parent=path.substring(0, path.lastIndexOf("/")); + log.debug("Checking intermediate "+parent); + targetParent=getSubFolder(parentFolder,parent); + targetName=path.substring(path.lastIndexOf("/")+1); + } + log.debug("Creating "+targetName); + return targetParent.newFolder(targetName, ""); + } + } + + + public WorkspaceContent storeToWS(File f,FolderContainer destination,String name,String description) throws FileNotFoundException, StorageHubException { + FileContainer item=destination.uploadFile(new FileInputStream(f), name, description); + item=getSGClient().open(item.getId()).asFile(); + + WorkspaceContent content=new WorkspaceContent(); + content.setLink(item.getPublicLink().toString()); + content.setMimetype(item.get().getContent().getMimeType()); + + content.setStorageID(item.getId()); + return content; + + } +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/AssociatedContent.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/AssociatedContent.java new file mode 100644 index 0000000..f672465 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/AssociatedContent.java @@ -0,0 +1,175 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; + +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlElements; + +import org.gcube.application.geoportal.model.AccessPolicy; +import org.gcube.application.geoportal.model.Record; +import org.gcube.application.geoportal.model.report.ValidationReport; +import org.gcube.application.geoportal.utils.CollectionsUtils; +import com.fasterxml.jackson.annotation.JsonSubTypes; +import com.fasterxml.jackson.annotation.JsonSubTypes.Type; +import com.fasterxml.jackson.annotation.JsonTypeInfo; +import org.hibernate.annotations.LazyCollection; +import org.hibernate.annotations.LazyCollectionOption; + +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +@Entity +@Inheritance(strategy = InheritanceType.JOINED) +@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type") +@JsonSubTypes({ + @Type(value = OtherContent.class), + @Type(value = RelazioneScavo.class), + @Type(value = SDILayerDescriptor.class), + @Type(value = LayerConcessione.class), + @Type(value = UploadedImage.class), + }) +public abstract class AssociatedContent { + + @Id + @GeneratedValue(strategy=GenerationType.IDENTITY) + private long id; + + @XmlElement + private AccessPolicy policy; + private String licenseID; + private String titolo; + private LocalDateTime creationTime; + + + public ValidationReport validateForInsertion() { + ValidationReport toReturn=new ValidationReport("Associated Content"); + toReturn.checkMandatory(policy, "Politica di accesso"); + toReturn.checkMandatory(licenseID, "Licenza"); + toReturn.checkMandatory(titolo,"Titolo"); + toReturn.checkMandatory(creationTime, "Creation time"); + return toReturn; + } + + + public abstract void setRecord(Record r); + public abstract Record getRecord(); + + + + @LazyCollection(LazyCollectionOption.FALSE) + @OneToMany(mappedBy = "associated", cascade = CascadeType.ALL) + @XmlElements({ + @XmlElement(type=GeoServerContent.class), + @XmlElement(type=WorkspaceContent.class), + }) + private List actualContent=new ArrayList<>(); + + public void detachContent() { + if(actualContent!=null) + for(PersistedContent p:actualContent) + p.setAssociated(null); + } + + public void reattachContent() { + if(actualContent!=null) + for(PersistedContent p:actualContent) + p.setAssociated(this); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; +// result = prime * result + ((actualContent == null) ? 0 : actualContent.hashCode()); + result = prime * result + CollectionsUtils.hashCode(actualContent); + + result = prime * result + ((creationTime == null) ? 0 : creationTime.hashCode()); + result = prime * result + (int) (id ^ (id >>> 32)); + result = prime * result + ((licenseID == null) ? 0 : licenseID.hashCode()); + result = prime * result + ((policy == null) ? 0 : policy.hashCode()); + result = prime * result + ((titolo == null) ? 0 : titolo.hashCode()); + return result; + } + + + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + AssociatedContent other = (AssociatedContent) obj; +// if (actualContent == null) { +// if (other.actualContent != null) +// return false; +// } else if (!actualContent.equals(other.actualContent)) +// return false; + if(!CollectionsUtils.equalsCollections(actualContent, other.actualContent)) return false; + + if (creationTime == null) { + if (other.creationTime != null) + return false; + } else if (!creationTime.equals(other.creationTime)) + return false; + if (id != other.id) + return false; + if (licenseID == null) { + if (other.licenseID != null) + return false; + } else if (!licenseID.equals(other.licenseID)) + return false; + if (policy != other.policy) + return false; + if (titolo == null) { + if (other.titolo != null) + return false; + } else if (!titolo.equals(other.titolo)) + return false; + return true; + } + + + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("AssociatedContent [id="); + builder.append(id); + builder.append(", policy="); + builder.append(policy); + builder.append(", licenseID="); + builder.append(licenseID); + builder.append(", titolo="); + builder.append(titolo); + builder.append(", creationTime="); + builder.append(creationTime); + + builder.append(", actualContent="); + builder.append(actualContent); + builder.append("]"); + return builder.toString(); + } + + + + + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/BBOX.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/BBOX.java new file mode 100644 index 0000000..b7bbf52 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/BBOX.java @@ -0,0 +1,36 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import java.io.Serializable; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.NonNull; +import lombok.RequiredArgsConstructor; +import lombok.ToString; + +@RequiredArgsConstructor +@Getter +@NoArgsConstructor +@EqualsAndHashCode +@ToString +public class BBOX implements Serializable{ + + /** + * + */ + private static final long serialVersionUID = -159414992596542946L; + + public static BBOX WORLD_EXTENT=new BBOX(90d,180d,-90d,-180d); + + @NonNull + private Double maxLat; + @NonNull + private Double maxLong; + @NonNull + private Double minLat; + @NonNull + private Double minLong; + + +} \ No newline at end of file diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/Concessione.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/Concessione.java new file mode 100644 index 0000000..18ce9e6 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/Concessione.java @@ -0,0 +1,533 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import javax.persistence.CascadeType; +import javax.persistence.DiscriminatorValue; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.OneToMany; +import javax.persistence.OneToOne; + +import org.gcube.application.geoportal.model.AccessPolicy; +import org.gcube.application.geoportal.model.Record; +import org.gcube.application.geoportal.model.RecordType; +import org.gcube.application.geoportal.model.report.Check; +import org.gcube.application.geoportal.model.report.ConstraintCheck; +import org.gcube.application.geoportal.model.report.ValidationReport; +import org.gcube.application.geoportal.model.report.ValidationReport.ValidationStatus; +import org.gcube.application.geoportal.utils.CollectionsUtils; +import org.hibernate.annotations.LazyCollection; +import org.hibernate.annotations.LazyCollectionOption; + +import com.fasterxml.jackson.core.JsonProcessingException; + +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +@Getter +@Setter +@ToString(callSuper=true) + +@Entity +@DiscriminatorValue("CONCESSIONE") +public class Concessione extends Record{ + + + //Introduzione (descrizione del progetto) + private String introduzione; + + //Descrizione del contenuto + private String descrizioneContenuto; + + //Autori + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List authors; + + //Soggetto che materialmente invia i dati. + private String contributore; + + //Indicare il nome del titolare/i dei dati contenuti nel dataset e/o per sue specifiche parti. + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List titolari; + + private String responsabile; + private String editore; + + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List fontiFinanziamento; + + //Research Excavation; Archaeology (valori di default) + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List soggetto; + + + //Referenze bibliografiche, DOI (se esistenti) di risorse correlate all’indagine in oggetto + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List risorseCorrelate; + + + private LocalDateTime dataInizioProgetto; + private LocalDateTime dataFineProgetto; + + private String titolareLicenza; + private String titolareCopyright; + + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List paroleChiaveLibere; + + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List paroleChiaveICCD; + + + private Double centroidLat; + private Double centroidLong; + + @LazyCollection(LazyCollectionOption.FALSE) + @OneToOne(cascade = CascadeType.ALL) + private RelazioneScavo relazioneScavo; + + @LazyCollection(LazyCollectionOption.FALSE) + @OneToMany(mappedBy = "record", cascade = CascadeType.ALL) + private List immaginiRappresentative=new ArrayList(); + + @LazyCollection(LazyCollectionOption.FALSE) + @OneToOne(cascade = CascadeType.ALL) + private LayerConcessione posizionamentoScavo; + + @LazyCollection(LazyCollectionOption.FALSE) + @OneToMany(mappedBy = "record", cascade = CascadeType.ALL) + private List pianteFineScavo=new ArrayList<>(); + + @LazyCollection(LazyCollectionOption.FALSE) + @OneToMany(mappedBy = "record", cascade = CascadeType.ALL) + private List genericContent=new ArrayList<>(); + + + public Concessione() { + super(); + setRecordType(RecordType.CONCESSIONE); + } + + + @Override + public String asJson() throws JsonProcessingException { + // Detaching Content ... + if(relazioneScavo!=null) { + relazioneScavo.setRecord(null); + relazioneScavo.detachContent(); + } + if(immaginiRappresentative!=null) + for(UploadedImage img:immaginiRappresentative) { + img.setRecord(null); + img.detachContent(); + } + if(posizionamentoScavo!=null) { + posizionamentoScavo.setRecord(null); + posizionamentoScavo.detachContent(); + } + if(pianteFineScavo!=null) + for(LayerConcessione l:pianteFineScavo) { + l.setRecord(null); + l.detachContent(); + } + if(genericContent!=null) + for(OtherContent o:genericContent) { + o.setRecord(null); + o.detachContent(); + } + + try { + return super.asJson(); + }finally { + //Reattaching content + if(relazioneScavo!=null) { + relazioneScavo.setRecord(this); + relazioneScavo.reattachContent(); + } + if(immaginiRappresentative!=null) + for(UploadedImage img:immaginiRappresentative) { + img.setRecord(this); + img.reattachContent(); + } + if(posizionamentoScavo!=null) { + posizionamentoScavo.setRecord(this); + posizionamentoScavo.reattachContent(); + } + if(pianteFineScavo!=null) + for(LayerConcessione l:pianteFineScavo) { + l.setRecord(this); + l.reattachContent(); + } + if(genericContent!=null) + for(OtherContent o:genericContent) { + o.setRecord(this); + o.reattachContent(); + } + } + } + + @Override + public ValidationReport validate() { + ValidationReport validator= super.validate(); + + validator.setObjectName("Concessione"); + + setPolicy(AccessPolicy.OPEN); + + + + validator.checkMandatory(authors, "Lista Autori"); + if(validator.checkMandatory(centroidLat, "Latitudine")) + if(centroidLat>90||centroidLat<-90) validator.addMessage(ValidationStatus.ERROR, "Latitudine non valida : "+centroidLat); + + if(validator.checkMandatory(centroidLong, "Longitudine")) + if(centroidLong>180||centroidLong<-180) validator.addMessage(ValidationStatus.ERROR, "Longitudine non valida : "+centroidLong); + + validator.checkMandatory(contributore, "Contributore"); + if(validator.checkMandatory(dataFineProgetto, "Data Fine Progetto") && + validator.checkMandatory(dataInizioProgetto, "Data Inizio Progetto")) + if(dataFineProgetto.isBefore(dataInizioProgetto)) validator.addMessage(ValidationStatus.ERROR, "Data Fine Progetto non può esser prima di Data Inizio Progetto."); + + validator.checkMandatory(descrizioneContenuto, "Descrizione contenuto"); + validator.checkMandatory(editore, "Editore"); + validator.checkMandatory(fontiFinanziamento, "Fonti Finanaziamento"); + validator.checkMandatory(introduzione, "Introduzione"); + validator.checkMandatory(paroleChiaveICCD, "Parole chiave ICCD"); + validator.checkMandatory(paroleChiaveLibere, "Parole chiave libere"); + + validator.checkMandatory(responsabile,"Responsabile"); + + + + validator.checkMandatory(titolareCopyright, "Titolare Copyright"); + validator.checkMandatory(titolareLicenza,"Titolare licenza"); + validator.checkMandatory(titolari, "Titolari"); + + + + if(validator.checkMandatory(relazioneScavo, "Relazione scavo")) { + + + + validator.addChild(relazioneScavo.validateForInsertion()); + } + +// if(immaginiRappresentative!=null) +// +// for(UploadedImage img : immaginiRappresentative) { +// validator.setDefault(img.getSoggetto(),getSoggetto()); +// validator.setDefault(img.getCreationTime(),getCreationTime()); +// validator.setDefault(img.getPolicy(), getPolicy()); +// validator.setDefault(img.getLicenzaID(), getLicenzaID()); +// +// validator.addChild(img.validateForInsertion()); +// } +// + + if(validator.checkMandatory(posizionamentoScavo, "Posizionamento scavo")) { + + ValidationReport posReport=posizionamentoScavo.validateForInsertion(); + posReport.setObjectName("Posizionamento scavo"); + validator.addChild(posReport); + } + + + if(genericContent!=null) + for(OtherContent content:genericContent) + validator.addChild(content.validateForInsertion()); + + if(validator.checkMandatory(pianteFineScavo,"Piante fine scavo")) + for(LayerConcessione l:pianteFineScavo) { + validator.addChild(l.validateForInsertion()); + } + + + + + + return validator; + } + + + @Override + public void setDefaults() { + super.setDefaults(); + setSoggetto(ConstraintCheck.defaultFor(soggetto, Arrays.asList(new String[] {"Research Excavation","Archaeology"})) + .addChecks(Check.collectionSizeMin(2)).evaluate()); + + + + if(relazioneScavo!=null) { + relazioneScavo.setTitolo(ConstraintCheck.defaultFor(relazioneScavo.getTitolo(),getNome()+" relazione di scavo").evaluate()); + relazioneScavo.setSoggetto(ConstraintCheck.defaultFor(relazioneScavo.getSoggetto(),getSoggetto()).evaluate()); + relazioneScavo.setCreationTime(ConstraintCheck.defaultFor(relazioneScavo.getCreationTime(),getCreationTime()).evaluate()); + relazioneScavo.setLicenseID(getLicenzaID()); + relazioneScavo.setPolicy(getPolicy()); + } + + + if(immaginiRappresentative!=null) + for(UploadedImage img : immaginiRappresentative) { + img.setSoggetto(ConstraintCheck.defaultFor(img.getSoggetto(),getSoggetto()).evaluate()); + img.setCreationTime(ConstraintCheck.defaultFor(img.getCreationTime(),getCreationTime()).evaluate()); + img.setPolicy(ConstraintCheck.defaultFor(img.getPolicy(),getPolicy()).evaluate()); + img.setLicenseID(ConstraintCheck.defaultFor(img.getLicenseID(),getLicenzaID()).evaluate()); + } + + + if(posizionamentoScavo!=null) { + posizionamentoScavo.setTitolo(ConstraintCheck.defaultFor(posizionamentoScavo.getTitolo(), getNome()+" posizionamento scavo").evaluate()); + posizionamentoScavo.setAbstractSection( + ConstraintCheck.defaultFor(posizionamentoScavo.getAbstractSection(),"Posizionamento topografico georeferenziato dell’area interessata dalle indagini").evaluate()); + + posizionamentoScavo.setTopicCategory(ConstraintCheck.defaultFor(posizionamentoScavo.getTopicCategory(), "Society").evaluate()); + posizionamentoScavo.setSubTopic(ConstraintCheck.defaultFor(posizionamentoScavo.getSubTopic(), "Archeology").evaluate()); + + posizionamentoScavo.setParoleChiaveLibere(ConstraintCheck.defaultFor(posizionamentoScavo.getParoleChiaveLibere(),getParoleChiaveLibere()).evaluate()); + posizionamentoScavo.setParoleChiaveICCD(ConstraintCheck.defaultFor(posizionamentoScavo.getParoleChiaveICCD(),getParoleChiaveICCD()).evaluate()); + + //TODO Evaluate + posizionamentoScavo.setBbox(ConstraintCheck.defaultFor(posizionamentoScavo.getBbox(), BBOX.WORLD_EXTENT).evaluate()); + + posizionamentoScavo.setPolicy(ConstraintCheck.defaultFor(posizionamentoScavo.getPolicy(),getPolicy()).evaluate());; + posizionamentoScavo.setLicenseID("CC-BY"); + posizionamentoScavo.setResponsabile(getResponsabile()); + posizionamentoScavo.setCreationTime(ConstraintCheck.defaultFor(posizionamentoScavo.getCreationTime(), getCreationTime()).evaluate()); + + + } + + + + if(pianteFineScavo!=null) + for(LayerConcessione l:pianteFineScavo) { + + l.setTitolo(ConstraintCheck.defaultFor(l.getTitolo(), getNome()+" pianta fine scavo").evaluate()); + l.setAbstractSection( + ConstraintCheck.defaultFor(l.getAbstractSection(),"Planimetria georeferenziata dell'area indagata al termine delle attività").evaluate()); + + l.setTopicCategory(ConstraintCheck.defaultFor(l.getTopicCategory(), "Society").evaluate()); + l.setSubTopic(ConstraintCheck.defaultFor(l.getSubTopic(), "Archeology").evaluate()); + + l.setParoleChiaveLibere(ConstraintCheck.defaultFor(l.getParoleChiaveLibere(),getParoleChiaveLibere()).evaluate()); + l.setParoleChiaveICCD(ConstraintCheck.defaultFor(l.getParoleChiaveICCD(),getParoleChiaveICCD()).evaluate()); + + //TODO Evaluate + l.setBbox(ConstraintCheck.defaultFor(l.getBbox(), BBOX.WORLD_EXTENT).evaluate()); + + l.setPolicy(ConstraintCheck.defaultFor(l.getPolicy(),getPolicy()).evaluate());; + l.setLicenseID(ConstraintCheck.defaultFor(l.getLicenseID(), "CC-BY").evaluate()); + l.setResponsabile(getResponsabile()); + l.setCreationTime(ConstraintCheck.defaultFor(l.getCreationTime(), getCreationTime()).evaluate()); + } + + + + + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; +// result = prime * result + ((authors == null) ? 0 : authors.hashCode()); + result = prime * result + CollectionsUtils.hashCode(authors); +// result = prime * result + ((fontiFinanaziamento == null) ? 0 : fontiFinanaziamento.hashCode()); + result = prime * result + CollectionsUtils.hashCode(fontiFinanziamento); +// result = prime * result + ((immaginiRappresentative == null) ? 0 : immaginiRappresentative.hashCode()); + result = prime * result + CollectionsUtils.hashCode(immaginiRappresentative); +// result = prime * result + ((paroleChiaveICCD == null) ? 0 : paroleChiaveICCD.hashCode()); + result = prime * result + CollectionsUtils.hashCode(paroleChiaveICCD); +// result = prime * result + ((paroleChiaveLibere == null) ? 0 : paroleChiaveLibere.hashCode()); + result = prime * result + CollectionsUtils.hashCode(paroleChiaveLibere); +// result = prime * result + ((pianteFineScavo == null) ? 0 : pianteFineScavo.hashCode()); + result = prime * result + CollectionsUtils.hashCode(pianteFineScavo); +// result = prime * result + ((risorseCorrelate == null) ? 0 : risorseCorrelate.hashCode()); + result = prime * result + CollectionsUtils.hashCode(risorseCorrelate); +// result = prime * result + ((soggetto == null) ? 0 : soggetto.hashCode()); + result = prime * result + CollectionsUtils.hashCode(soggetto); +// result = prime * result + ((titolari == null) ? 0 : titolari.hashCode()); + result = prime * result + CollectionsUtils.hashCode(titolari); + + result = prime * result + ((centroidLat == null) ? 0 : centroidLat.hashCode()); + result = prime * result + ((centroidLong == null) ? 0 : centroidLong.hashCode()); + result = prime * result + ((contributore == null) ? 0 : contributore.hashCode()); + result = prime * result + ((dataFineProgetto == null) ? 0 : dataFineProgetto.hashCode()); + result = prime * result + ((dataInizioProgetto == null) ? 0 : dataInizioProgetto.hashCode()); + result = prime * result + ((descrizioneContenuto == null) ? 0 : descrizioneContenuto.hashCode()); + result = prime * result + ((editore == null) ? 0 : editore.hashCode()); + result = prime * result + ((genericContent == null) ? 0 : genericContent.hashCode()); + result = prime * result + ((introduzione == null) ? 0 : introduzione.hashCode()); + + result = prime * result + ((posizionamentoScavo == null) ? 0 : posizionamentoScavo.hashCode()); + result = prime * result + ((relazioneScavo == null) ? 0 : relazioneScavo.hashCode()); + result = prime * result + ((responsabile == null) ? 0 : responsabile.hashCode()); + result = prime * result + ((titolareCopyright == null) ? 0 : titolareCopyright.hashCode()); + result = prime * result + ((titolareLicenza == null) ? 0 : titolareLicenza.hashCode()); + return result; + } + + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Concessione other = (Concessione) obj; +// if (authors == null) { +// if (other.authors != null) +// return false; +// } else if (!authors.equals(other.authors)) +// return false; + if(!CollectionsUtils.equalsCollections(authors, other.authors)) return false; + +// if (fontiFinanaziamento == null) { +// if (other.fontiFinanaziamento != null) +// return false; +// } else if (!fontiFinanaziamento.equals(other.fontiFinanaziamento)) +// return false; + if (!CollectionsUtils.equalsCollections(fontiFinanziamento, other.fontiFinanziamento)) return false; + +// if (immaginiRappresentative == null) { +// if (other.immaginiRappresentative != null) +// return false; +// } else if (!immaginiRappresentative.equals(other.immaginiRappresentative)) +// return false; + if (!CollectionsUtils.equalsCollections(immaginiRappresentative, other.immaginiRappresentative)) return false; + +// if (paroleChiaveICCD == null) { +// if (other.paroleChiaveICCD != null) +// return false; +// } else if (!paroleChiaveICCD.equals(other.paroleChiaveICCD)) +// return false; + if (!CollectionsUtils.equalsCollections(paroleChiaveICCD, other.paroleChiaveICCD)) return false; + +// if (paroleChiaveLibere == null) { +// if (other.paroleChiaveLibere != null) +// return false; +// } else if (!paroleChiaveLibere.equals(other.paroleChiaveLibere)) +// return false; + if (!CollectionsUtils.equalsCollections(paroleChiaveLibere, other.paroleChiaveLibere)) return false; + +// if (piantaFineScavo == null) { +// if (other.piantaFineScavo != null) +// return false; +// } else if (!piantaFineScavo.equals(other.piantaFineScavo)) +// return false; + if (!CollectionsUtils.equalsCollections(pianteFineScavo, other.pianteFineScavo)) return false; + +// if (risorseCorrelate == null) { +// if (other.risorseCorrelate != null) +// return false; +// } else if (!risorseCorrelate.equals(other.risorseCorrelate)) +// return false; + if (!CollectionsUtils.equalsCollections(risorseCorrelate, other.risorseCorrelate)) return false; + +// if (soggetto == null) { +// if (other.soggetto != null) +// return false; +// } else if (!soggetto.equals(other.soggetto)) +// return false; + if (!CollectionsUtils.equalsCollections(soggetto, other.soggetto)) return false; + +// if (titolari == null) { +// if (other.titolari != null) +// return false; +// } else if (!titolari.equals(other.titolari)) +// return false; + if (!CollectionsUtils.equalsCollections(titolari, other.titolari)) return false; + + + if (centroidLat == null) { + if (other.centroidLat != null) + return false; + } else if (!centroidLat.equals(other.centroidLat)) + return false; + if (centroidLong == null) { + if (other.centroidLong != null) + return false; + } else if (!centroidLong.equals(other.centroidLong)) + return false; + if (contributore == null) { + if (other.contributore != null) + return false; + } else if (!contributore.equals(other.contributore)) + return false; + if (dataFineProgetto == null) { + if (other.dataFineProgetto != null) + return false; + } else if (!dataFineProgetto.equals(other.dataFineProgetto)) + return false; + if (dataInizioProgetto == null) { + if (other.dataInizioProgetto != null) + return false; + } else if (!dataInizioProgetto.equals(other.dataInizioProgetto)) + return false; + if (descrizioneContenuto == null) { + if (other.descrizioneContenuto != null) + return false; + } else if (!descrizioneContenuto.equals(other.descrizioneContenuto)) + return false; + if (editore == null) { + if (other.editore != null) + return false; + } else if (!editore.equals(other.editore)) + return false; + if (genericContent == null) { + if (other.genericContent != null) + return false; + } else if (!genericContent.equals(other.genericContent)) + return false; + if (introduzione == null) { + if (other.introduzione != null) + return false; + } else if (!introduzione.equals(other.introduzione)) + return false; + + if (posizionamentoScavo == null) { + if (other.posizionamentoScavo != null) + return false; + } else if (!posizionamentoScavo.equals(other.posizionamentoScavo)) + return false; + if (relazioneScavo == null) { + if (other.relazioneScavo != null) + return false; + } else if (!relazioneScavo.equals(other.relazioneScavo)) + return false; + if (responsabile == null) { + if (other.responsabile != null) + return false; + } else if (!responsabile.equals(other.responsabile)) + return false; + if (titolareCopyright == null) { + if (other.titolareCopyright != null) + return false; + } else if (!titolareCopyright.equals(other.titolareCopyright)) + return false; + if (titolareLicenza == null) { + if (other.titolareLicenza != null) + return false; + } else if (!titolareLicenza.equals(other.titolareLicenza)) + return false; + + return true; + } + + + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/GeoServerContent.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/GeoServerContent.java new file mode 100644 index 0000000..3d60377 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/GeoServerContent.java @@ -0,0 +1,35 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import java.util.ArrayList; +import java.util.List; + +import javax.persistence.DiscriminatorValue; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +@Getter +@Setter +@ToString(callSuper=true) + +@Entity +@DiscriminatorValue("GEOSERVER") +@EqualsAndHashCode(callSuper=true) +public class GeoServerContent extends PersistedContent{ + + //GeoServer Details + private String geoserverHostName; + private String geoserverPath; + + @ElementCollection(targetClass=String.class) + private List fileNames=new ArrayList(); + + + private String workspace; + private String store; + private String featureType; +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/LayerConcessione.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/LayerConcessione.java new file mode 100644 index 0000000..bd1b46a --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/LayerConcessione.java @@ -0,0 +1,199 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import java.util.List; + +import javax.persistence.DiscriminatorValue; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; + +import org.gcube.application.geoportal.model.Record; +import org.gcube.application.geoportal.model.report.ValidationReport; +import org.gcube.application.geoportal.utils.CollectionsUtils; +import org.hibernate.annotations.LazyCollection; +import org.hibernate.annotations.LazyCollectionOption; + +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + + +@Getter +@Setter +@ToString(callSuper=true) +@Entity +@DiscriminatorValue("LAYER_CONCESSIONE") +public class LayerConcessione extends SDILayerDescriptor{ + + //1.Identificazione + private String abstractSection; + + //2.Classificazione + private String topicCategory; + + //3.Keyword + private String subTopic; + + //4. Delimitazione geographica + private BBOX bbox; + + //5. Temporal + + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List paroleChiaveLibere; + + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List paroleChiaveICCD; + + //6. Quality + private String valutazioneQualita; + + private String metodoRaccoltaDati; + + private String scalaAcquisizione; + + //8. Responsabili + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List authors; + + private String responsabile; + + @ManyToOne + @JoinColumn(name="record_id", nullable=false) + private Record record; + + + @Override + public ValidationReport validateForInsertion() { + ValidationReport toReturn=super.validateForInsertion(); + toReturn.setObjectName("Layer Concessione"); + toReturn.checkMandatory(abstractSection, "Abstract"); + toReturn.checkMandatory(subTopic, "Categoria (Topic)"); + //TODO +// toReturn.checkMandatory(bbox, "Bounding Box"); + + toReturn.checkMandatory(valutazioneQualita, "Valutazione della qualita"); + toReturn.checkMandatory(metodoRaccoltaDati, "Metodo raccolta dati"); + toReturn.checkMandatory(scalaAcquisizione, "Scala acquisizione"); + toReturn.checkMandatory(authors, "Autori"); + return toReturn; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + result = prime * result + ((abstractSection == null) ? 0 : abstractSection.hashCode()); +// result = prime * result + ((authors == null) ? 0 : authors.hashCode()); + result = prime * result + CollectionsUtils.hashCode(authors); + + + result = prime * result + ((bbox == null) ? 0 : bbox.hashCode()); + result = prime * result + ((metodoRaccoltaDati == null) ? 0 : metodoRaccoltaDati.hashCode()); + result = prime * result + ((scalaAcquisizione == null) ? 0 : scalaAcquisizione.hashCode()); + result = prime * result + ((subTopic == null) ? 0 : subTopic.hashCode()); + result = prime * result + ((topicCategory == null) ? 0 : topicCategory.hashCode()); + result = prime * result + ((valutazioneQualita == null) ? 0 : valutazioneQualita.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (!super.equals(obj)) + return false; + if (getClass() != obj.getClass()) + return false; + LayerConcessione other = (LayerConcessione) obj; + if (abstractSection == null) { + if (other.abstractSection != null) + return false; + } else if (!abstractSection.equals(other.abstractSection)) + return false; +// if (authors == null) { +// if (other.authors != null) +// return false; +// } else if (!authors.equals(other.authors)) +// return false; + if(!CollectionsUtils.equalsCollections(authors, other.authors)) return false; + + + if (bbox == null) { + if (other.bbox != null) + return false; + } else if (!bbox.equals(other.bbox)) + return false; + if (metodoRaccoltaDati == null) { + if (other.metodoRaccoltaDati != null) + return false; + } else if (!metodoRaccoltaDati.equals(other.metodoRaccoltaDati)) + return false; + if (scalaAcquisizione == null) { + if (other.scalaAcquisizione != null) + return false; + } else if (!scalaAcquisizione.equals(other.scalaAcquisizione)) + return false; + if (subTopic == null) { + if (other.subTopic != null) + return false; + } else if (!subTopic.equals(other.subTopic)) + return false; + if (topicCategory == null) { + if (other.topicCategory != null) + return false; + } else if (!topicCategory.equals(other.topicCategory)) + return false; + if (valutazioneQualita == null) { + if (other.valutazioneQualita != null) + return false; + } else if (!valutazioneQualita.equals(other.valutazioneQualita)) + return false; + return true; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("LayerConcessione [abstractSection="); + builder.append(abstractSection); + builder.append(", topicCategory="); + builder.append(topicCategory); + builder.append(", subTopic="); + builder.append(subTopic); + builder.append(", bbox="); + builder.append(bbox); + builder.append(", paroleChiaveLibere="); + builder.append(paroleChiaveLibere); + builder.append(", paroleChiaveICCD="); + builder.append(paroleChiaveICCD); + builder.append(", valutazioneQualita="); + builder.append(valutazioneQualita); + builder.append(", metodoRaccoltaDati="); + builder.append(metodoRaccoltaDati); + builder.append(", scalaAcquisizione="); + builder.append(scalaAcquisizione); + builder.append(", authors="); + builder.append(authors); + builder.append(", responsabile="); + builder.append(responsabile); + if(record!=null) { + builder.append(", owner-record-id="); + builder.append(record.getId()); + }else { + builder.append(", record="); + builder.append(record); + } + builder.append(", toString()="); + builder.append(super.toString()); + builder.append("]"); + return builder.toString(); + } + + + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/OtherContent.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/OtherContent.java new file mode 100644 index 0000000..fc6865a --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/OtherContent.java @@ -0,0 +1,47 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import javax.persistence.DiscriminatorValue; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; + +import org.gcube.application.geoportal.model.Record; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter + + +@Entity +@DiscriminatorValue("OTHER") +public class OtherContent extends AssociatedContent { + + + + @ManyToOne + @JoinColumn(name="record_id", nullable=false) + public Record record; + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("OtherContent ["); + if(record!=null) { + builder.append(", owner-record-id="); + builder.append(record.getId()); + }else { + builder.append(", record="); + builder.append(record); + } + + builder.append(", toString()="); + builder.append(super.toString()); + builder.append("]"); + return builder.toString(); + } + + + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/PersistedContent.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/PersistedContent.java new file mode 100644 index 0000000..c0981c8 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/PersistedContent.java @@ -0,0 +1,58 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; + +import com.fasterxml.jackson.annotation.JsonSubTypes; +import com.fasterxml.jackson.annotation.JsonSubTypes.Type; +import com.fasterxml.jackson.annotation.JsonTypeInfo; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@Entity +@Inheritance(strategy = InheritanceType.JOINED) +@EqualsAndHashCode +@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type") +@JsonSubTypes({ + @Type(value = GeoServerContent.class), + @Type(value = WorkspaceContent.class), + }) +public abstract class PersistedContent { + + //Generic Info + @Id @GeneratedValue(strategy=GenerationType.IDENTITY) + private long id; + + @ManyToOne + @JoinColumn(name="content_id", nullable=false) + private AssociatedContent associated; + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("PersistedContent [id="); + builder.append(id); + if(associated==null) { + builder.append(", associated="); + builder.append(associated); + }else { + builder.append(", OWNER-associated-id="); + builder.append(associated.getId()); + } + builder.append("]"); + return builder.toString(); + } + + + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/RelazioneScavo.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/RelazioneScavo.java new file mode 100644 index 0000000..4a50625 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/RelazioneScavo.java @@ -0,0 +1,119 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import java.util.List; + +import javax.persistence.DiscriminatorValue; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; + +import org.gcube.application.geoportal.model.Record; +import org.gcube.application.geoportal.model.report.ValidationReport; +import org.gcube.application.geoportal.utils.CollectionsUtils; +import org.hibernate.annotations.LazyCollection; +import org.hibernate.annotations.LazyCollectionOption; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@Entity +@DiscriminatorValue("RELAZIONE") +public class RelazioneScavo extends AssociatedContent { + + + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("RelazioneScavo [abstractSection="); + builder.append(abstractSection); + if(record!=null) { + builder.append(", owner-record-id="); + builder.append(record.getId()); + }else { + builder.append(", record="); + builder.append(record); + } + builder.append(", responsabili="); + builder.append(responsabili); + builder.append(", soggetto="); + builder.append(soggetto); + builder.append(", toString()="); + builder.append(super.toString()); + builder.append("]"); + return builder.toString(); + } + + private String abstractSection; + + @ManyToOne + @JoinColumn(name="record_id", nullable=false) + private Record record; + + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List responsabili; + @LazyCollection(LazyCollectionOption.FALSE) + @ElementCollection(targetClass=String.class) + private List soggetto; + + + @Override + public ValidationReport validateForInsertion() { + + ValidationReport toReturn=super.validateForInsertion(); + toReturn.setObjectName("Relazione Scavo"); + toReturn.checkMandatory(responsabili, "Responsabili"); + toReturn.checkMandatory(soggetto, "Soggetto"); + return toReturn; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + result = prime * result + ((abstractSection == null) ? 0 : abstractSection.hashCode()); +// result = prime * result + ((responsabili == null) ? 0 : responsabili.hashCode()); + result = prime * result + CollectionsUtils.hashCode(responsabili); +// result = prime * result + ((soggetto == null) ? 0 : soggetto.hashCode()); + result = prime * result + CollectionsUtils.hashCode(soggetto); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (!super.equals(obj)) + return false; + if (getClass() != obj.getClass()) + return false; + RelazioneScavo other = (RelazioneScavo) obj; + if (abstractSection == null) { + if (other.abstractSection != null) + return false; + } else if (!abstractSection.equals(other.abstractSection)) + return false; +// if (responsabili == null) { +// if (other.responsabili != null) +// return false; +// } else if (!responsabili.equals(other.responsabili)) +// return false; + if(!CollectionsUtils.equalsCollections(responsabili, other.responsabili)) return false; + + +// if (soggetto == null) { +// if (other.soggetto != null) +// return false; +// } else if (!soggetto.equals(other.soggetto)) +// return false; + if(!CollectionsUtils.equalsCollections(soggetto, other.soggetto)) return false; + + + return true; + } + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/SDILayerDescriptor.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/SDILayerDescriptor.java new file mode 100644 index 0000000..28cbf17 --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/SDILayerDescriptor.java @@ -0,0 +1,29 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; + +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +@Entity +@Inheritance(strategy = InheritanceType.JOINED) +public abstract class SDILayerDescriptor extends AssociatedContent{ + + + //meta + private String layerUUID; + private Long layerID; + + //layer + private String layerName; + private String wmsLink; + + + + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/UploadedImage.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/UploadedImage.java new file mode 100644 index 0000000..f387f8d --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/UploadedImage.java @@ -0,0 +1,112 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import java.util.List; + +import javax.persistence.DiscriminatorValue; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; + +import org.gcube.application.geoportal.model.Record; +import org.gcube.application.geoportal.utils.CollectionsUtils; + +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +@Getter +@Setter + +@Entity +@DiscriminatorValue("IMAGE") +public class UploadedImage extends AssociatedContent { + + + private String didascalia; + private String format; + + @ElementCollection(targetClass=String.class) + private List responsabili; + @ElementCollection(targetClass=String.class) + private List soggetto; + + + @ManyToOne + @JoinColumn(name="record_id", nullable=false) + private Record record; + + @Override + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + result = prime * result + ((didascalia == null) ? 0 : didascalia.hashCode()); + result = prime * result + ((format == null) ? 0 : format.hashCode()); +// result = prime * result + ((responsabili == null) ? 0 : responsabili.hashCode()); + result = prime * result + CollectionsUtils.hashCode(responsabili); +// result = prime * result + ((soggetto == null) ? 0 : soggetto.hashCode()); + result = prime * result + CollectionsUtils.hashCode(soggetto); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (!super.equals(obj)) + return false; + if (getClass() != obj.getClass()) + return false; + UploadedImage other = (UploadedImage) obj; + if (didascalia == null) { + if (other.didascalia != null) + return false; + } else if (!didascalia.equals(other.didascalia)) + return false; + if (format == null) { + if (other.format != null) + return false; + } else if (!format.equals(other.format)) + return false; +// if (responsabili == null) { +// if (other.responsabili != null) +// return false; +// } else if (!responsabili.equals(other.responsabili)) +// return false; + if(!CollectionsUtils.equalsCollections(responsabili, other.responsabili)) return false; + +// if (soggetto == null) { +// if (other.soggetto != null) +// return false; +// } else if (!soggetto.equals(other.soggetto)) +// return false; + if(!CollectionsUtils.equalsCollections(soggetto, other.soggetto)) return false; + + return true; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("UploadedImage [didascalia="); + builder.append(didascalia); + builder.append(", format="); + builder.append(format); + builder.append(", responsabili="); + builder.append(responsabili); + builder.append(", soggetto="); + builder.append(soggetto); + if(record!=null) { + builder.append(", owner-record-id="); + builder.append(record.getId()); + }else { + builder.append(", record="); + builder.append(record); + } + builder.append(", toString()="); + builder.append(super.toString()); + builder.append("]"); + return builder.toString(); + } + +} diff --git a/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/WorkspaceContent.java b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/WorkspaceContent.java new file mode 100644 index 0000000..642bf4c --- /dev/null +++ b/src/main/java/org/gcube/application/geoportal/service/model/legacy/concessioni/WorkspaceContent.java @@ -0,0 +1,23 @@ +package org.gcube.application.geoportal.service.model.legacy.concessioni; + +import javax.persistence.DiscriminatorValue; +import javax.persistence.Entity; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +@Getter +@Setter +@ToString(callSuper=true) + +@Entity +@DiscriminatorValue("WORKSPACE") +@EqualsAndHashCode(callSuper=true) +public class WorkspaceContent extends PersistedContent{ + + private String mimetype; + private String storageID; + private String link; +} diff --git a/src/main/java/org/gcube/application/geoportal/service/rest/Concessioni.java b/src/main/java/org/gcube/application/geoportal/service/rest/Concessioni.java index 3970bc2..19441c4 100644 --- a/src/main/java/org/gcube/application/geoportal/service/rest/Concessioni.java +++ b/src/main/java/org/gcube/application/geoportal/service/rest/Concessioni.java @@ -11,19 +11,20 @@ import javax.ws.rs.Produces; import javax.ws.rs.WebApplicationException; import javax.ws.rs.core.MediaType; + 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.engine.legacy.LegacyConcessioniManager; 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.legacy.concessioni.Concessione; +import org.gcube.application.geoportal.service.model.legacy.concessioni.LayerConcessione; +import org.gcube.application.geoportal.service.model.legacy.concessioni.RelazioneScavo; +import org.gcube.application.geoportal.service.model.legacy.concessioni.UploadedImage; import org.gcube.application.geoportal.service.utils.Serialization; import org.json.JSONArray; @@ -42,8 +43,8 @@ public class Concessioni { 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); + Concessione conc=(Concessione) LegacyConcessioniManager.getByID(Long.parseLong(id)); + LegacyConcessioniManager manager=new LegacyConcessioniManager(conc); log.debug("Loaded object {} ",conc); PublicationReport rep=manager.commitSafely(true); @@ -66,7 +67,7 @@ public class Concessioni { 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)); + Concessione toReturn=(Concessione) LegacyConcessioniManager.getByID(Long.parseLong(id)); log.debug("Loaded object {} ",toReturn); return toReturn.asJson(); }catch(WebApplicationException e){ @@ -85,7 +86,7 @@ public class Concessioni { try { log.info("Registering new Concessione "+toRegister); Concessione conc=Serialization.read(toRegister, Concessione.class); - ConcessioneManager manager=ManagerFactory.registerNew(conc); + LegacyConcessioniManager manager=new LegacyConcessioniManager(conc); manager.commitSafely(false); return manager.getRecord().asJson(); }catch(WebApplicationException e){ @@ -105,8 +106,8 @@ public class Concessioni { AddSectionToConcessioneRequest request) { try { log.info("Adding section to Concessione {} ",id); - Concessione toReturn=(Concessione) ConcessioneManager.getByID(Long.parseLong(id)); - ConcessioneManager manager=ManagerFactory.getByRecord(toReturn); + Concessione toReturn=(Concessione) LegacyConcessioniManager.getByID(Long.parseLong(id)); + LegacyConcessioniManager manager=new LegacyConcessioniManager(toReturn); log.debug("Loaded object {} ",toReturn); log.debug("Request is {}",request); @@ -120,18 +121,18 @@ public class Concessioni { } - 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"); - } - +// 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 "+c.asJson()); @@ -152,7 +153,7 @@ public class Concessioni { @Produces(MediaType.APPLICATION_JSON) public String getList(){ try { - Collection toReturn=ManagerFactory.getList(Concessione.class); + Collection toReturn=LegacyConcessioniManager.getListByClass(Concessione.class); log.debug("Found "+toReturn.size()+" elements.."); JSONArray array=new JSONArray(); for(Concessione found:toReturn) { diff --git a/src/main/java/org/gcube/application/geoportal/service/utils/Serialization.java b/src/main/java/org/gcube/application/geoportal/service/utils/Serialization.java index d9317a2..49e9c21 100644 --- a/src/main/java/org/gcube/application/geoportal/service/utils/Serialization.java +++ b/src/main/java/org/gcube/application/geoportal/service/utils/Serialization.java @@ -1,6 +1,8 @@ package org.gcube.application.geoportal.service.utils; import java.io.IOException; +import java.time.format.DateTimeFormatter; +import java.util.Collection; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.DeserializationFeature; @@ -23,4 +25,19 @@ public class Serialization { public static String write(Object toWrite) throws JsonProcessingException { return mapper.writeValueAsString(toWrite); } + + + + // As DB String + + public static String asString(Collection coll) { + if(coll==null||coll.isEmpty()) return ""; + StringBuilder builder=new StringBuilder(); + for(Object t : coll) { + builder.append(t.toString() +","); + } + return builder.substring(0, builder.lastIndexOf(",")); + } + + public static final DateTimeFormatter FULL_FORMATTER=DateTimeFormatter.ofPattern("uuuuMMdd_HH-mm-ss"); } diff --git a/src/test/java/org/gcube/application/geoportal/service/legacy/ConcessioniTest.java b/src/test/java/org/gcube/application/geoportal/service/legacy/ConcessioniTest.java index fa4ddbc..514796c 100644 --- a/src/test/java/org/gcube/application/geoportal/service/legacy/ConcessioniTest.java +++ b/src/test/java/org/gcube/application/geoportal/service/legacy/ConcessioniTest.java @@ -17,8 +17,6 @@ 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.managers.AbstractRecordManager; -import org.gcube.application.geoportal.managers.DefatulEMFProvider; import org.gcube.application.geoportal.model.concessioni.Concessione; import org.gcube.application.geoportal.model.concessioni.LayerConcessione; import org.gcube.application.geoportal.model.content.AssociatedContent; @@ -29,6 +27,8 @@ import org.gcube.application.geoportal.model.report.ValidationReport.ValidationS import org.gcube.application.geoportal.service.GeoPortalService; import org.gcube.application.geoportal.service.engine.ImplementationProvider; import org.gcube.application.geoportal.service.engine.StorageClientProvider; +import org.gcube.application.geoportal.service.engine.legacy.AbstractRecordManager; +import org.gcube.application.geoportal.service.engine.legacy.FixedDefaultProvider; 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; @@ -56,7 +56,7 @@ public class ConcessioniTest extends JerseyTest { @BeforeClass public static void init() { String scope="/gcube/devNext/NextNext"; - AbstractRecordManager.setDefaultProvider(new DefatulEMFProvider(){ + AbstractRecordManager.setDefaultProvider(new FixedDefaultProvider(){ @Override public EntityManagerFactory getFactory() {