1311 lines
42 KiB
Java
1311 lines
42 KiB
Java
package org.gcube.application.geoportalcommon;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InvalidObjectException;
|
|
import java.time.LocalDate;
|
|
import java.time.LocalDateTime;
|
|
import java.time.format.DateTimeFormatter;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import org.bson.Document;
|
|
import org.gcube.application.geoportal.client.utils.Serialization;
|
|
import org.gcube.application.geoportal.common.model.configuration.Index;
|
|
import org.gcube.application.geoportal.common.model.document.Project;
|
|
import org.gcube.application.geoportal.common.model.document.access.Access;
|
|
import org.gcube.application.geoportal.common.model.document.accounting.AccountingInfo;
|
|
import org.gcube.application.geoportal.common.model.document.accounting.PublicationInfo;
|
|
import org.gcube.application.geoportal.common.model.document.identification.IdentificationReference;
|
|
import org.gcube.application.geoportal.common.model.document.lifecycle.LifecycleInformation;
|
|
import org.gcube.application.geoportal.common.model.document.relationships.Relationship;
|
|
import org.gcube.application.geoportal.common.model.useCaseDescriptor.HandlerDeclaration;
|
|
import org.gcube.application.geoportal.common.model.useCaseDescriptor.RelationshipDefinition;
|
|
import org.gcube.application.geoportal.common.model.useCaseDescriptor.UseCaseDescriptor;
|
|
import org.gcube.application.geoportalcommon.geoportal.GeoportalConfigUtil;
|
|
import org.gcube.application.geoportalcommon.geoportal.config.ActionDefinition;
|
|
import org.gcube.application.geoportalcommon.geoportal.config.FilePath;
|
|
import org.gcube.application.geoportalcommon.geoportal.config.GcubeProfile;
|
|
import org.gcube.application.geoportalcommon.geoportal.config.ItemField;
|
|
import org.gcube.application.geoportalcommon.geoportal.serdes.Payload;
|
|
import org.gcube.application.geoportalcommon.geoportal.util.GisUtil;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.ConfigurationDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.DocumentDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.ResultDocumentDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.config.ActionDefinitionDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.config.FilePathDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.config.GcubeProfileDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.config.ItemFieldDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.geojson.Crs;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.geojson.GeoJSON;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.materialization.IndexLayerDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.materialization.innerobject.PayloadDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.AccessDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.AccountingInfoDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.BasicLifecycleInformationDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.IdentificationReferenceDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.IdentificationReferencesTYPE;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.LifecycleInformationDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.ProjectDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.PublicationInfoDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.RelationshipDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.project.TemporalReferenceDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.ucd.GEOPORTAL_CONFIGURATION_TYPE;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.ucd.GEOPORTAL_DATA_HANDLER;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.ucd.HandlerDeclarationDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.ucd.RelationshipDefinitionDV;
|
|
import org.gcube.application.geoportalcommon.shared.geoportal.ucd.UseCaseDescriptorDV;
|
|
import org.gcube.application.geoportalcommon.util.DateUtils;
|
|
import org.json.JSONException;
|
|
import org.json.JSONObject;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import com.fasterxml.jackson.core.JsonGenerator;
|
|
import com.fasterxml.jackson.core.JsonParser;
|
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
|
import com.fasterxml.jackson.databind.DeserializationContext;
|
|
import com.fasterxml.jackson.databind.JsonDeserializer;
|
|
import com.fasterxml.jackson.databind.JsonSerializer;
|
|
import com.fasterxml.jackson.databind.SerializerProvider;
|
|
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
|
|
import com.jayway.jsonpath.DocumentContext;
|
|
import com.jayway.jsonpath.JsonPath;
|
|
import com.jayway.jsonpath.Option;
|
|
|
|
/**
|
|
* The Class ConvertToDataValueObjectModel.
|
|
*
|
|
* @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
|
|
*
|
|
* Mar 4, 2022
|
|
*/
|
|
public class ConvertToDataValueObjectModel {
|
|
|
|
private static Logger LOG = LoggerFactory.getLogger(ConvertToDataValueObjectModel.class);
|
|
|
|
private static final String NO_TIME = "T00:00";
|
|
|
|
public static final String DATE_FORMAT = "yyyy-MM-dd";
|
|
|
|
public static final String HOURS_MINUTES_SEPARATOR = ":";
|
|
|
|
public static final String TIME_FORMAT = "HH" + HOURS_MINUTES_SEPARATOR + "mm";
|
|
|
|
public static List<String> KEYSET_POSSIBLE_DATE = Arrays.asList("start", "end", "created", "updated", "inizio",
|
|
"fine", "creato", "aggiornato");
|
|
|
|
/**
|
|
* To use case descriptor DV.
|
|
*
|
|
* @param ucd the ucd
|
|
* @param handlersIds the handlers ids. If not null only returns (so filtering
|
|
* for) the handler ids. Otherwise returns all handlers
|
|
* @return the document config DV
|
|
* @throws Exception the exception
|
|
*/
|
|
public static UseCaseDescriptorDV toUseCaseDescriptorDV(UseCaseDescriptor ucd, String... handlersIds)
|
|
throws Exception {
|
|
LOG.trace("toUseCaseDescriptorDV called");
|
|
|
|
if (ucd == null) {
|
|
LOG.warn(UseCaseDescriptor.class.getSimpleName() + " is null");
|
|
return null;
|
|
}
|
|
|
|
UseCaseDescriptorDV ucdVO = new UseCaseDescriptorDV();
|
|
ucdVO.setId(ucd.getId());
|
|
ucdVO.setName(ucd.getName());
|
|
ucdVO.setDescription(ucd.getDescription());
|
|
ucdVO.setVersion(ucd.getVersion() != null ? ucd.getVersion().toString() : "");
|
|
|
|
List<HandlerDeclarationDV> listHandlersDV = new ArrayList<HandlerDeclarationDV>();
|
|
if (handlersIds != null) {
|
|
LOG.info("List of input handlersIds is " + handlersIds + ", converting it");
|
|
Map<String, List<HandlerDeclaration>> handlersMapByID = ucd.getHandlersMapByID();
|
|
|
|
if (handlersMapByID != null) {
|
|
for (String handlersId : handlersIds) {
|
|
List<HandlerDeclaration> listHandlerDeclaration = handlersMapByID.get(handlersId);
|
|
for (HandlerDeclaration handlerDeclaration : listHandlerDeclaration) {
|
|
LOG.debug("converting handler {}", handlerDeclaration);
|
|
HandlerDeclarationDV hdDV = toHandlerDeclarationDV(handlerDeclaration, ucd);
|
|
if (hdDV != null) {
|
|
LOG.debug("handler converted to {}", hdDV);
|
|
listHandlersDV.add(hdDV);
|
|
} else {
|
|
LOG.info("Skipping {} as null for {}", HandlerDeclarationDV.class.getSimpleName(),
|
|
handlerDeclaration);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
LOG.info("List of input handlersIds is null, reading all handlers");
|
|
List<HandlerDeclaration> listHandlerDeclaration = ucd.getHandlers();
|
|
for (HandlerDeclaration handlerDeclaration : listHandlerDeclaration) {
|
|
LOG.debug("converting handler {}", handlerDeclaration);
|
|
HandlerDeclarationDV hdDV = toHandlerDeclarationDV(handlerDeclaration, ucd);
|
|
if (hdDV != null) {
|
|
LOG.debug("handler converted to {}", hdDV);
|
|
listHandlersDV.add(hdDV);
|
|
} else {
|
|
LOG.info("Skipping {} as null for {}", HandlerDeclarationDV.class.getSimpleName(),
|
|
handlerDeclaration);
|
|
}
|
|
}
|
|
}
|
|
|
|
ucdVO.setHandlers(listHandlersDV);
|
|
LOG.info("returning {}", ucdVO);
|
|
return ucdVO;
|
|
|
|
}
|
|
|
|
/**
|
|
* To GEOPORTA L DAT A HANDLER.
|
|
*
|
|
* @param id the id
|
|
* @return the geoportal data handler
|
|
*/
|
|
public static GEOPORTAL_DATA_HANDLER to_GEOPORTAL_DATA_HANDLER(String id) {
|
|
|
|
if (id == null)
|
|
return null;
|
|
|
|
for (GEOPORTAL_DATA_HANDLER gdh : GEOPORTAL_DATA_HANDLER.values()) {
|
|
if (gdh.getId().equals(id)) {
|
|
return gdh;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* To handler declaration DV.
|
|
*
|
|
* @param handlerDeclaration the handler declaration
|
|
* @param ucd the ucd
|
|
* @param readConfigs the read configs
|
|
* @return the handler declaration DV
|
|
* @throws Exception the exception
|
|
*/
|
|
public static HandlerDeclarationDV toHandlerDeclarationDV(HandlerDeclaration handlerDeclaration,
|
|
UseCaseDescriptor ucd, GEOPORTAL_CONFIGURATION_TYPE... readConfigs) throws Exception {
|
|
String profileName = ucd.getName();
|
|
LOG.debug("toHandlerDeclarationDV called [handlerDeclaration: " + handlerDeclaration + "], [profileName: "
|
|
+ profileName + "], [readConfigs: " + readConfigs + "]");
|
|
|
|
if (handlerDeclaration == null) {
|
|
LOG.warn(HandlerDeclaration.class.getSimpleName() + " is null");
|
|
return null;
|
|
}
|
|
|
|
Document configuration = handlerDeclaration.getConfiguration();
|
|
|
|
HandlerDeclarationDV hdDV = new HandlerDeclarationDV();
|
|
hdDV.setId(handlerDeclaration.getId());
|
|
hdDV.setType(handlerDeclaration.getType());
|
|
hdDV.setItemType(profileName);
|
|
hdDV.setDataHandlerType(to_GEOPORTAL_DATA_HANDLER(handlerDeclaration.getId()));
|
|
if (configuration == null) {
|
|
LOG.warn("Configuration is null in the handler with id: " + handlerDeclaration.getId());
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
|
|
if (readConfigs == null || readConfigs.length == 0) {
|
|
readConfigs = GEOPORTAL_CONFIGURATION_TYPE.values();
|
|
}
|
|
|
|
List<GEOPORTAL_CONFIGURATION_TYPE> listGeoportalConfigType = new ArrayList<GEOPORTAL_CONFIGURATION_TYPE>();
|
|
ArrayList<String> jsonConfigurations = null;
|
|
|
|
// this is the 'projection' field stored in the Configuration,
|
|
// if the field exists, e.g. _theDocument, it used as suffix to get the right
|
|
// JSON path concatenating the projection + the paths
|
|
String projection = null;
|
|
for (GEOPORTAL_CONFIGURATION_TYPE configManaged : readConfigs) {
|
|
try {
|
|
LOG.debug("searching '" + configManaged.getId() + "' in the configuration " + configuration);
|
|
LOG.trace("contains " + configManaged.getId() + ": "
|
|
+ configuration.containsKey(configManaged.getId()));
|
|
|
|
try {
|
|
projection = configuration.getString("projection");
|
|
} catch (Exception e) {
|
|
// TODO: handle exception
|
|
}
|
|
|
|
ArrayList<LinkedHashMap<String, Object>> listHashMapConfig = configuration
|
|
.get(configManaged.getId(), ArrayList.class);
|
|
LOG.debug("hashMapConfig found is: {}", listHashMapConfig);
|
|
|
|
if (listHashMapConfig != null) {
|
|
|
|
jsonConfigurations = new ArrayList<String>();
|
|
|
|
for (LinkedHashMap<String, Object> config : listHashMapConfig) {
|
|
Document document = new Document(config);
|
|
|
|
// //THIS PART MUST BE REVISITED
|
|
// if(projection!=null)
|
|
// document.append("projection", projection);
|
|
|
|
String jsonValue = document.toJson();
|
|
LOG.debug("config is: {}", jsonValue);
|
|
jsonConfigurations.add(jsonValue);
|
|
}
|
|
LOG.debug("configurations found are: {}", jsonConfigurations);
|
|
listGeoportalConfigType.add(configManaged);
|
|
break;
|
|
}
|
|
} catch (Exception e) {
|
|
LOG.info(configManaged.getId() + " not found in the configuration of the handler "
|
|
+ handlerDeclaration.getId(), e);
|
|
}
|
|
}
|
|
|
|
if (jsonConfigurations == null) {
|
|
String error = "No managed configurations as '"
|
|
+ Arrays.asList(GEOPORTAL_CONFIGURATION_TYPE.values()).toString() + "' found in the handler "
|
|
+ handlerDeclaration.getId();
|
|
LOG.warn(error);
|
|
return null;
|
|
}
|
|
|
|
for (GEOPORTAL_CONFIGURATION_TYPE geoportalConfigType : listGeoportalConfigType) {
|
|
|
|
switch (geoportalConfigType) {
|
|
case gcube_profiles: {
|
|
|
|
List<GcubeProfileDV> listGcubeProfiles = new ArrayList<GcubeProfileDV>(jsonConfigurations.size());
|
|
|
|
int i = 0;
|
|
for (String asJSONString : jsonConfigurations) {
|
|
LOG.debug(++i + ") the gCubeProfile is: " + asJSONString);
|
|
GcubeProfile profile = org.gcube.application.geoportal.client.utils.Serialization
|
|
.read(asJSONString, GcubeProfile.class);
|
|
listGcubeProfiles.add(toGcubeProfileDV(profile));
|
|
}
|
|
|
|
ConfigurationDV<List<GcubeProfileDV>> dDV = new ConfigurationDV<List<GcubeProfileDV>>(
|
|
listGcubeProfiles);
|
|
dDV.setConfiguration(listGcubeProfiles);
|
|
dDV.setConfigurationType(geoportalConfigType); // -> GEOPORTAL_CONFIGURATION_TYPE.gcube_profiles
|
|
hdDV.setConfiguration(dDV);
|
|
LOG.info("returning {}", hdDV);
|
|
return hdDV;
|
|
}
|
|
case item_fields: {
|
|
|
|
List<ItemFieldDV> listItemFields = new ArrayList<ItemFieldDV>(jsonConfigurations.size());
|
|
|
|
int i = 0;
|
|
for (String asJSONString : jsonConfigurations) {
|
|
LOG.debug(++i + ") the itemField is: " + asJSONString);
|
|
ItemField itemField = org.gcube.application.geoportal.client.utils.Serialization
|
|
.read(asJSONString, ItemField.class);
|
|
listItemFields.add(toItemFieldDV(itemField));
|
|
}
|
|
|
|
ConfigurationDV<List<ItemFieldDV>> dDV = new ConfigurationDV<List<ItemFieldDV>>(listItemFields);
|
|
dDV.setConfiguration(listItemFields);
|
|
dDV.setConfigurationType(geoportalConfigType); // -> GEOPORTAL_CONFIGURATION_TYPE.item_fields
|
|
hdDV.setConfiguration(dDV);
|
|
LOG.info("returning {}", hdDV);
|
|
return hdDV;
|
|
}
|
|
|
|
case actions_definition: {
|
|
|
|
List<ActionDefinitionDV> listActionsDef = new ArrayList<ActionDefinitionDV>(
|
|
jsonConfigurations.size());
|
|
|
|
LOG.trace("Into " + GEOPORTAL_CONFIGURATION_TYPE.actions_definition + " handlers are: {}",
|
|
ucd.getHandlers());
|
|
|
|
List<HandlerDeclaration> listHandlersLC = ucd
|
|
.getHandlersByType(GEOPORTAL_DATA_HANDLER.gna_concessioni_lc.getType());
|
|
|
|
HandlerDeclaration handlerLC = null;
|
|
if (listHandlersLC != null && listHandlersLC.size() > 0) {
|
|
handlerLC = listHandlersLC.get(0);
|
|
}
|
|
LOG.debug("Into " + GEOPORTAL_CONFIGURATION_TYPE.actions_definition + " the handler "
|
|
+ GEOPORTAL_DATA_HANDLER.gna_concessioni_lc + " is: {}", handlerLC);
|
|
|
|
int i = 0;
|
|
for (String asJSONString : jsonConfigurations) {
|
|
LOG.debug(++i + ") the ActionDefinition is: " + asJSONString);
|
|
ActionDefinition actionDef = org.gcube.application.geoportal.client.utils.Serialization
|
|
.read(asJSONString, ActionDefinition.class);
|
|
|
|
Set<String> roles = new HashSet<String>();
|
|
if (handlerLC != null) {
|
|
for (String stepID : actionDef.getCall_STEPS()) {
|
|
List<String> listRoles = GeoportalConfigUtil.readRolesForSTEPId(handlerLC, stepID);
|
|
roles.addAll(listRoles);
|
|
}
|
|
}
|
|
listActionsDef.add(toActionDefinition(actionDef, roles));
|
|
}
|
|
|
|
ConfigurationDV<List<ActionDefinitionDV>> dDV = new ConfigurationDV<List<ActionDefinitionDV>>(
|
|
listActionsDef);
|
|
dDV.setConfiguration(listActionsDef);
|
|
dDV.setConfigurationType(geoportalConfigType); // -> GEOPORTAL_CONFIGURATION_TYPE.actions_definition
|
|
hdDV.setConfiguration(dDV);
|
|
LOG.info("returning {}", hdDV);
|
|
return hdDV;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
LOG.error("Error on getting " + HandlerDeclaration.class.getSimpleName(), e);
|
|
throw e;
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
/**
|
|
* To gcube profile DV.
|
|
*
|
|
* @param gCubeProfile the g cube profile
|
|
* @return the gcube profile DV
|
|
*/
|
|
public static GcubeProfileDV toGcubeProfileDV(GcubeProfile gCubeProfile) {
|
|
LOG.trace("toGcubeProfileDV called");
|
|
|
|
if (gCubeProfile == null) {
|
|
LOG.warn(GcubeProfile.class.getSimpleName() + " is null");
|
|
return null;
|
|
}
|
|
|
|
GcubeProfileDV gpVO = new GcubeProfileDV();
|
|
gpVO.setGcubeName(gCubeProfile.getGcubeName());
|
|
gpVO.setGcubeSecondaryType(gCubeProfile.getGcubeSecondaryType());
|
|
gpVO.setMinOccurs(gCubeProfile.getMinOccurs());
|
|
gpVO.setMaxOccurs(gCubeProfile.getMaxOccurs());
|
|
gpVO.setSectionName(gCubeProfile.getSectionName());
|
|
gpVO.setSectionTitle(gCubeProfile.getSectionTitle());
|
|
gpVO.setParentName(gCubeProfile.getParentName());
|
|
|
|
List<FilePath> filePaths = gCubeProfile.getFilePaths();
|
|
|
|
if (filePaths != null) {
|
|
LOG.warn("List of " + FilePath.class.getSimpleName() + " is null");
|
|
List<FilePathDV> filePathsVO = new ArrayList<FilePathDV>(filePaths.size());
|
|
for (FilePath filePath : filePaths) {
|
|
filePathsVO.add(toFilePathDV(filePath));
|
|
}
|
|
gpVO.setFilePaths(filePathsVO);
|
|
}
|
|
|
|
LOG.info("returning: " + gpVO);
|
|
return gpVO;
|
|
}
|
|
|
|
/**
|
|
* To item field DV.
|
|
*
|
|
* @param itemField the item field
|
|
* @return the item field DV
|
|
*/
|
|
public static ItemFieldDV toItemFieldDV(ItemField itemField) {
|
|
LOG.trace("toItemFieldDV called");
|
|
|
|
if (itemField == null) {
|
|
LOG.warn(ItemField.class.getSimpleName() + " is null");
|
|
return null;
|
|
}
|
|
|
|
ItemFieldDV ifDV = new ItemFieldDV();
|
|
ifDV.setDisplayAsResult(itemField.isAsResult());
|
|
ifDV.setDisplayName(itemField.getLabel());
|
|
ifDV.setJsonFields(itemField.getPaths());
|
|
ifDV.setOperator(itemField.getOperator());
|
|
ifDV.setSearchable(itemField.isSearchable());
|
|
ifDV.setSortable(itemField.isSortable());
|
|
|
|
LOG.info("returning: " + ifDV);
|
|
return ifDV;
|
|
}
|
|
|
|
/**
|
|
* To action definition.
|
|
*
|
|
* @param actionDefinition the action definition
|
|
* @param roles the roles required to perform the callable STEPS
|
|
* @return the action definition DV
|
|
*/
|
|
public static ActionDefinitionDV toActionDefinition(ActionDefinition actionDefinition, Set<String> roles) {
|
|
LOG.trace("toActionDefinition called");
|
|
|
|
if (actionDefinition == null) {
|
|
LOG.warn(ActionDefinition.class.getSimpleName() + " is null");
|
|
return null;
|
|
}
|
|
|
|
ActionDefinitionDV actDef = new ActionDefinitionDV();
|
|
actDef.setId(actionDefinition.getId());
|
|
actDef.setCallSteps(actionDefinition.getCall_STEPS());
|
|
actDef.setDescription(actionDefinition.getDescription());
|
|
actDef.setDisplayOnPhase(actionDefinition.getDisplay_on_phase());
|
|
actDef.setTitle(actionDefinition.getTitle());
|
|
actDef.setRoles(roles);
|
|
|
|
LOG.info("returning: " + actionDefinition);
|
|
return actDef;
|
|
}
|
|
|
|
/**
|
|
* To file path DV.
|
|
*
|
|
* @param filePath the file path
|
|
* @return the file path DV
|
|
*/
|
|
public static FilePathDV toFilePathDV(FilePath filePath) {
|
|
LOG.trace("toFilePathDV called");
|
|
|
|
if (filePath == null) {
|
|
LOG.warn("List of " + FilePath.class.getSimpleName() + " is null");
|
|
return null;
|
|
}
|
|
|
|
FilePathDV fpVO = new FilePathDV();
|
|
fpVO.setFieldName(filePath.getFieldName());
|
|
fpVO.setFieldDefinition(filePath.getFieldDefinition());
|
|
fpVO.setGcubeProfileFieldName(filePath.getGcubeProfileFieldName());
|
|
|
|
LOG.info("returning: " + fpVO);
|
|
return fpVO;
|
|
}
|
|
|
|
/**
|
|
* To project DV.
|
|
*
|
|
* @param project the project
|
|
* @param projectReader the project reader
|
|
* @return the project DV
|
|
*/
|
|
public static ProjectDV toProjectDV(Project project, ProjectDVBuilder projectReader) {
|
|
LOG.info("toProjectDV called");
|
|
|
|
if (project == null)
|
|
return null;
|
|
|
|
LOG.info("toProjectDV called for project id: {}, with {}", project.getId(), projectReader);
|
|
if (LOG.isTraceEnabled())
|
|
LOG.trace("Source project is: " + project);
|
|
|
|
try {
|
|
|
|
ProjectDV theProject = new ProjectDV();
|
|
theProject.setId(project.getId());
|
|
theProject.setProfileID(project.getProfileID());
|
|
theProject.setProfileVersion(
|
|
project.getProfileVersion() != null ? project.getProfileVersion().getValue() : "");
|
|
theProject.setVersion(project.getVersion() != null ? project.getVersion().getValue() : "");
|
|
|
|
theProject.setTheDocument(toGenericDocumentDV(project.getId(), project.getTheDocument(), DocumentDV.class,
|
|
projectReader.getListDocumentKeys(), projectReader.isIncludeFullDocumentMap()));
|
|
|
|
List<Relationship> relations = project.getRelationships();
|
|
|
|
if (relations != null && projectReader.isIncludeRelationships()) {
|
|
List<RelationshipDV> listRelations = new ArrayList<RelationshipDV>(relations.size());
|
|
for (Relationship relationship : relations) {
|
|
listRelations.add(toRelationshipDV(relationship));
|
|
}
|
|
|
|
theProject.setRelationships(listRelations);
|
|
}
|
|
|
|
List<IdentificationReference> identificationReferences = project.getIdentificationReferences();
|
|
|
|
if (identificationReferences != null) {
|
|
|
|
Map<String, IdentificationReferenceDV> mapIdentReferenceDV = new HashMap<String, IdentificationReferenceDV>(
|
|
identificationReferences.size());
|
|
|
|
for (IdentificationReference identificationReference : identificationReferences) {
|
|
IdentificationReferenceDV idv = toIdentificationReferenceDV(project.getId(),
|
|
identificationReference, projectReader.getListDocumentKeys(),
|
|
projectReader.isIncludeFullDocumentMap());
|
|
|
|
mapIdentReferenceDV.put(idv.getType(), idv);
|
|
}
|
|
|
|
theProject.setMapIdentReferenceDV(mapIdentReferenceDV);
|
|
}
|
|
|
|
if (projectReader.isIncludeLifecycleInformation()) {
|
|
if (project.getLifecycleInformation() != null)
|
|
theProject.setLifecycleInformationDV(toLifecycleInformationDV(project.getLifecycleInformation()));
|
|
}
|
|
|
|
if (projectReader.isIncludeSpatialReference()) {
|
|
// theProject.setMapIdentReferenceDV(project.getIdentificationReferences());
|
|
List<IdentificationReference> ids = project
|
|
.getIdentificationReferenceByType(IdentificationReferencesTYPE.SPATIAL_REFERENCE.getType());
|
|
if (ids != null && !ids.isEmpty()) {
|
|
GeoJSON geoJson = toSpatialReference(ids.get(0).toJson());
|
|
theProject.setSpatialReference(geoJson);
|
|
}
|
|
|
|
}
|
|
//
|
|
// if (projectReader.isIncludeTemporalReference()) {
|
|
// theProject.setTemporalReference(toTemporalReferenceDV(project.getTemporalReference(),
|
|
// projectReader.getListDocumentKeys(), projectReader.isIncludeFullDocumentMap()));
|
|
// }
|
|
|
|
//
|
|
// LOG.info("Returning concessioneDV with id: " + theConcessione.getItemId());
|
|
//
|
|
if (LOG.isDebugEnabled())
|
|
LOG.trace("Returning: " + theProject);
|
|
|
|
LOG.info("Returning project with id: " + theProject.getId());
|
|
return theProject;
|
|
} catch (Exception e) {
|
|
LOG.error("Error on converting project: " + project, e);
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* To spatial reference.
|
|
*
|
|
* @param geoJSONObject the geo JSON object
|
|
* @return the geo JSON
|
|
*/
|
|
public static GeoJSON toSpatialReference(String geoJSONObject) {
|
|
LOG.debug("toSpatialReference called");
|
|
|
|
if (geoJSONObject == null)
|
|
return null;
|
|
|
|
GeoJSON geoJson = null;
|
|
try {
|
|
geoJson = new GeoJSON();
|
|
JSONObject jsonObject = new JSONObject(geoJSONObject).getJSONObject("geoJSON");
|
|
geoJson.setType(jsonObject.getString("type"));
|
|
geoJson.setBbox(GisUtil.fromJSONArray(jsonObject.getJSONArray("bbox")));
|
|
Crs crs = org.gcube.application.geoportal.client.utils.Serialization
|
|
.read(jsonObject.getJSONObject("crs").toString(), Crs.class);
|
|
geoJson.setCrs(crs);
|
|
geoJson.setGeoJSON(jsonObject.toString());
|
|
LOG.debug("toSpatialReference returning " + geoJson);
|
|
} catch (JSONException | IOException e) {
|
|
LOG.warn("Error on converting " + GeoJSON.class.getSimpleName() + " from : " + geoJSONObject, e);
|
|
}
|
|
|
|
return geoJson;
|
|
|
|
}
|
|
|
|
/**
|
|
* To result document DV.
|
|
*
|
|
* @param project the project
|
|
* @return the result document DV
|
|
*/
|
|
public static ResultDocumentDV toResultDocumentDV(Project project) {
|
|
LOG.debug("toResultDocumentDV called");
|
|
|
|
if (project == null)
|
|
return null;
|
|
|
|
LOG.debug("toResultDocumentDV called for project id: {}", project.getId());
|
|
if (LOG.isTraceEnabled())
|
|
LOG.trace("Source project is: " + project);
|
|
|
|
try {
|
|
|
|
ResultDocumentDV rd = (ResultDocumentDV) toGenericDocumentDV(project.getId(), project.getTheDocument(),
|
|
ResultDocumentDV.class, null, true);
|
|
rd.setId(project.getId());
|
|
rd.setProfileID(project.getProfileID());
|
|
|
|
try {
|
|
|
|
List<IdentificationReference> ids = project
|
|
.getIdentificationReferenceByType(IdentificationReferencesTYPE.SPATIAL_REFERENCE.getType());
|
|
if (ids != null && !ids.isEmpty()) {
|
|
GeoJSON geoJson = toSpatialReference(ids.get(0).toJson());
|
|
rd.setSpatialReference(geoJson);
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
LOG.warn("Error occurred on reading spatial reference for the project: " + project.getId());
|
|
}
|
|
|
|
rd.setPublicationInfo(toPublicationInfoDV(project.getInfo()));
|
|
|
|
if (project.getLifecycleInformation() != null) {
|
|
BasicLifecycleInformationDV bld = new BasicLifecycleInformationDV();
|
|
bld.setPhase(project.getLifecycleInformation().getPhase());
|
|
bld.setLastOperationStatus(
|
|
toLifecycleInformationDVStatus(project.getLifecycleInformation().getLastOperationStatus()));
|
|
rd.setLifecycleInfo(bld);
|
|
}
|
|
|
|
if (project.getRelationships() != null) {
|
|
List<RelationshipDV> listRelDV = new ArrayList<RelationshipDV>(project.getRelationships().size());
|
|
for (Relationship relationship : project.getRelationships()) {
|
|
RelationshipDV relDV = toRelationshipDV(relationship);
|
|
listRelDV.add(relDV);
|
|
}
|
|
rd.setListRelationship(listRelDV);
|
|
}
|
|
|
|
if (LOG.isDebugEnabled())
|
|
LOG.debug("Returning: " + rd);
|
|
|
|
LOG.debug("Returning " + ResultDocumentDV.class.getSimpleName() + " with id: " + rd.getId());
|
|
return rd;
|
|
} catch (Exception e) {
|
|
LOG.error("Error on converting " + ResultDocumentDV.class.getSimpleName() + ": " + project, e);
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* To publication info DV.
|
|
*
|
|
* @param info the info
|
|
* @return the publication info DV
|
|
*/
|
|
private static PublicationInfoDV toPublicationInfoDV(PublicationInfo info) {
|
|
if (info == null)
|
|
return null;
|
|
|
|
PublicationInfoDV pidv = new PublicationInfoDV();
|
|
pidv.setCreationInfo(toAccountingInfoDV(info.getCreationInfo()));
|
|
pidv.setLastEditInfo(toAccountingInfoDV(info.getLastEditInfo()));
|
|
pidv.setAccess(toAccessDV(info.getAccess()));
|
|
|
|
return pidv;
|
|
|
|
}
|
|
|
|
/**
|
|
* To access DV.
|
|
*
|
|
* @param access the access
|
|
* @return the access DV
|
|
*/
|
|
private static AccessDV toAccessDV(Access access) {
|
|
if (access == null)
|
|
return null;
|
|
|
|
AccessDV acDV = new AccessDV();
|
|
acDV.setLicense(access.getLicense());
|
|
acDV.setPolicy(access.getPolicy() != null ? access.getPolicy().name() : null);
|
|
|
|
return acDV;
|
|
}
|
|
|
|
/**
|
|
* To accounting info DV.
|
|
*
|
|
* @param creationInfo the creation info
|
|
* @return the accounting info DV
|
|
*/
|
|
private static AccountingInfoDV toAccountingInfoDV(AccountingInfo creationInfo) {
|
|
if (creationInfo == null)
|
|
return null;
|
|
|
|
AccountingInfoDV aidv = new AccountingInfoDV();
|
|
aidv.setContext(creationInfo.getContext() != null ? creationInfo.getContext().getId() : null);
|
|
aidv.setLocalDate(toDateFormatString(creationInfo.getInstant()));
|
|
if (creationInfo.getUser() != null) {
|
|
aidv.setRoles(creationInfo.getUser().getRoles());
|
|
aidv.setUsername(creationInfo.getUser().getUsername());
|
|
}
|
|
|
|
return aidv;
|
|
}
|
|
|
|
/**
|
|
* To identification reference DV.
|
|
*
|
|
* @param projectID the project ID
|
|
* @param identificationReference the identification reference
|
|
* @param listDocumentKeys the list document keys
|
|
* @param getFullMap the get full map
|
|
* @return the identification reference DV
|
|
*/
|
|
private static IdentificationReferenceDV toIdentificationReferenceDV(String projectID,
|
|
IdentificationReference identificationReference, List<String> listDocumentKeys, boolean getFullMap) {
|
|
if (identificationReference == null)
|
|
return null;
|
|
|
|
IdentificationReferenceDV idv = (IdentificationReferenceDV) toGenericDocumentDV(projectID,
|
|
identificationReference, IdentificationReferenceDV.class, listDocumentKeys, getFullMap);
|
|
idv.setType(identificationReference.getType());
|
|
|
|
return idv;
|
|
}
|
|
|
|
/**
|
|
* To date format string.
|
|
*
|
|
* @param dateTime the date time
|
|
* @return the string
|
|
*/
|
|
public static String toDateFormatString(LocalDateTime dateTime) {
|
|
|
|
if (dateTime == null)
|
|
return null;
|
|
|
|
String time = dateTime.toString();
|
|
return instantToDateFormatString(time);
|
|
}
|
|
|
|
/**
|
|
* Instant to date format string. format dd-MM-yyyyT00:00:00.00Z to
|
|
* DateFormat.format
|
|
*
|
|
* @param instantString the instant string
|
|
* @return the string
|
|
*/
|
|
public static String instantToDateFormatString(String instantString) {
|
|
|
|
if (instantString == null)
|
|
return null;
|
|
|
|
String time = instantString.trim();
|
|
DateTimeFormatter formatter = null;
|
|
try {
|
|
|
|
if (time.contains("T")) {
|
|
formatter = DateTimeFormatter.ofPattern(DATE_FORMAT + " " + TIME_FORMAT);
|
|
LocalDateTime instant = LocalDateTime.parse(time);
|
|
return formatter.format(instant);
|
|
} else {
|
|
formatter = DateTimeFormatter.ofPattern(DATE_FORMAT);
|
|
LocalDate instant = LocalDate.parse(time, formatter);
|
|
return formatter.format(instant);
|
|
}
|
|
} catch (Exception e) {
|
|
LOG.warn("Date format error: " + e.getMessage());
|
|
}
|
|
|
|
return instantString;
|
|
}
|
|
|
|
// /**
|
|
// * To temporal reference DV.
|
|
// *
|
|
// * @param temporalReference the temporal reference
|
|
// * @param listDocumentKeys the list document keys
|
|
// * @param getFullMap the get full map
|
|
// * @return the temporal reference DV
|
|
// */
|
|
// public static TemporalReferenceDV toTemporalReferenceDV(TemporalReference temporalReference,
|
|
// List<String> listDocumentKeys, boolean getFullMap) {
|
|
// if (temporalReference == null)
|
|
// return null;
|
|
//
|
|
// TemporalReferenceDV trDV = (TemporalReferenceDV) toDocumentDV(temporalReference, TemporalReferenceDV.class,
|
|
// listDocumentKeys, getFullMap);
|
|
// trDV.setField(temporalReference.getField());
|
|
// return trDV;
|
|
// }
|
|
|
|
/**
|
|
* To generic document DV.
|
|
*
|
|
* @param <T> the generic type
|
|
* @param projectID the project ID
|
|
* @param document the document
|
|
* @param targetClass the target class
|
|
* @param listDocumentKeys the list document keys
|
|
* @param getFullMap the get full map
|
|
* @return the document DV
|
|
*/
|
|
public static <T extends DocumentDV> DocumentDV toGenericDocumentDV(String projectID, Document document,
|
|
Class<T> targetClass, List<String> listDocumentKeys, boolean getFullMap) {
|
|
if (document == null)
|
|
return null;
|
|
|
|
T documentDV;
|
|
if (targetClass == null) {
|
|
documentDV = (T) new DocumentDV();
|
|
} else {
|
|
try {
|
|
documentDV = targetClass.newInstance();
|
|
} catch (InstantiationException e) {
|
|
LOG.warn("InstantiationException: " + e.getMessage() + ". Instancing default "
|
|
+ DocumentDV.class.getSimpleName());
|
|
documentDV = (T) new DocumentDV();
|
|
} catch (IllegalAccessException e) {
|
|
LOG.warn("IllegalAccessException: " + e.getMessage() + ". Instancing default "
|
|
+ DocumentDV.class.getSimpleName());
|
|
documentDV = (T) new DocumentDV();
|
|
}
|
|
}
|
|
|
|
if (listDocumentKeys != null && !getFullMap) {
|
|
LinkedHashMap<String, Object> documentAsMap = new LinkedHashMap<String, Object>(listDocumentKeys.size());
|
|
for (String key : listDocumentKeys) {
|
|
|
|
documentAsMap = fillMapValue(document, key, documentAsMap);
|
|
}
|
|
documentDV.setDocumentAsMap(documentAsMap);
|
|
}
|
|
|
|
if (getFullMap) {
|
|
Set<String> keySet = document.keySet();
|
|
LinkedHashMap<String, Object> documentAsMap = new LinkedHashMap<String, Object>(keySet.size());
|
|
for (String key : keySet) {
|
|
// documentAsMap.put(key, document.get(key));
|
|
documentAsMap = fillMapValue(document, key, documentAsMap);
|
|
}
|
|
documentDV.setDocumentAsMap(documentAsMap);
|
|
}
|
|
|
|
documentDV.setDocumentAsJSON(document.toJson());
|
|
documentDV.setProjectID(projectID);
|
|
|
|
return documentDV;
|
|
}
|
|
|
|
public static final DateTimeFormatter FULL_FORMATTER = DateTimeFormatter.ofPattern("uuuuMMdd_HH-mm-ss");
|
|
|
|
/**
|
|
* The Class MyLocalDateSerializer.
|
|
*
|
|
* @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
|
|
*
|
|
* Sep 9, 2022
|
|
*/
|
|
public static class MyLocalDateSerializer extends JsonSerializer<LocalDate> {
|
|
|
|
/**
|
|
* Serialize.
|
|
*
|
|
* @param value the value
|
|
* @param gen the gen
|
|
* @param serializers the serializers
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
*/
|
|
@Override
|
|
public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
|
|
gen.writeString(value.format(FULL_FORMATTER));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The Class ParseDeserializer.
|
|
*
|
|
* @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
|
|
*
|
|
* Sep 9, 2022
|
|
*/
|
|
public static class ParseDeserializer extends StdDeserializer<LocalDateTime> {
|
|
|
|
/**
|
|
* Instantiates a new parses the deserializer.
|
|
*/
|
|
public ParseDeserializer() {
|
|
super(LocalDateTime.class);
|
|
}
|
|
|
|
/**
|
|
* Deserialize.
|
|
*
|
|
* @param p the p
|
|
* @param ctxt the ctxt
|
|
* @return the local date time
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
* @throws JsonProcessingException the json processing exception
|
|
*/
|
|
@Override
|
|
public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt)
|
|
throws IOException, JsonProcessingException {
|
|
return LocalDateTime.parse(p.getValueAsString()); // or overloaded with an appropriate format
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The Class MyLocalDateDeserializer.
|
|
*
|
|
* @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
|
|
*
|
|
* Sep 9, 2022
|
|
*/
|
|
public static class MyLocalDateDeserializer extends JsonDeserializer<LocalDate> {
|
|
|
|
/**
|
|
* Deserialize.
|
|
*
|
|
* @param p the p
|
|
* @param ctxt the ctxt
|
|
* @return the local date
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
*/
|
|
@Override
|
|
public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
|
|
return LocalDate.parse(p.getValueAsString(), FULL_FORMATTER);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fill map.
|
|
*
|
|
* @param document the document
|
|
* @param key the key
|
|
* @param documentAsMap the document as map
|
|
* @return the linked hash map
|
|
*/
|
|
public static LinkedHashMap<String, Object> fillMapValue(Document document, String key,
|
|
LinkedHashMap<String, Object> documentAsMap) {
|
|
|
|
Object value = document.get(key);
|
|
String keyLower = key.toLowerCase();
|
|
|
|
// checking if the key is a Date
|
|
for (String possibleDate : KEYSET_POSSIBLE_DATE) {
|
|
if (keyLower.contains(possibleDate)) {
|
|
try {
|
|
LOG.trace("value " + value + " is instance of: " + value.getClass());
|
|
|
|
String asDate = instantToDateFormatString(value.toString());
|
|
value = asDate;
|
|
break;
|
|
} catch (Exception e) {
|
|
LOG.warn("### MUST BE FIXED ### the field {} with value {} is not a date", key, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
documentAsMap.put(key, value);
|
|
return documentAsMap;
|
|
}
|
|
|
|
/**
|
|
* The Class LocalDateDeserializer.
|
|
*
|
|
* @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
|
|
*
|
|
* Sep 9, 2022
|
|
*/
|
|
public class LocalDateDeserializer extends JsonDeserializer<LocalDate> {
|
|
|
|
/**
|
|
* Deserialize.
|
|
*
|
|
* @param p the p
|
|
* @param ctxt the ctxt
|
|
* @return the local date
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
*/
|
|
@Override
|
|
public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
|
|
return LocalDate.parse(p.getValueAsString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* To relationship DV.
|
|
*
|
|
* @param relationship the relationship
|
|
* @return the relationship DV
|
|
*/
|
|
public static RelationshipDV toRelationshipDV(Relationship relationship) {
|
|
|
|
if (relationship == null)
|
|
return null;
|
|
|
|
RelationshipDV rDV = new RelationshipDV();
|
|
rDV.setRelationshipName(relationship.getRelationshipName());
|
|
rDV.setTargetID(relationship.getTargetID());
|
|
rDV.setTargetUCD(relationship.getTargetUCD());
|
|
String jsonDocument = null;
|
|
|
|
try {
|
|
jsonDocument = Serialization.asDocument(relationship).toJson();
|
|
} catch (Exception e) {
|
|
|
|
}
|
|
|
|
rDV.setAsJSON(jsonDocument);
|
|
|
|
return rDV;
|
|
}
|
|
|
|
/**
|
|
* To validation report.
|
|
*
|
|
* @param li the li
|
|
* @return the validation report DV
|
|
* @throws Exception the exception
|
|
*/
|
|
public static LifecycleInformationDV toLifecycleInformationDV(LifecycleInformation li) throws Exception {
|
|
LOG.info("toLifecycleInformationDV called");
|
|
|
|
if (li == null)
|
|
return null;
|
|
|
|
LOG.debug("toLifecycleInformationDV called for: " + li);
|
|
|
|
LifecycleInformationDV liDV = new LifecycleInformationDV();
|
|
liDV.setPhase(li.getPhase());
|
|
liDV.setErrorMessages(li.getErrorMessages());
|
|
liDV.setLastInvokedStep(li.getLastInvokedStep());
|
|
|
|
if (li.getLastEvent() != null)
|
|
liDV.setLastEvent(li.getLastEvent().getEvent());
|
|
|
|
liDV.setLastOperationStatus(toLifecycleInformationDVStatus(li.getLastOperationStatus()));
|
|
liDV.setWarningMessages(li.getWarningMessages());
|
|
liDV.setAsJSONString(toJSON(li));
|
|
LOG.debug("Returning: " + liDV);
|
|
return liDV;
|
|
}
|
|
|
|
/**
|
|
* To lifecycle information DV status.
|
|
*
|
|
* @param status the status
|
|
* @return the lifecycle information D v. status
|
|
*/
|
|
public static LifecycleInformationDV.Status toLifecycleInformationDVStatus(LifecycleInformation.Status status) {
|
|
|
|
if (status == null)
|
|
return null;
|
|
|
|
try {
|
|
return LifecycleInformationDV.Status.valueOf(status.name());
|
|
} catch (Exception e) {
|
|
LOG.error("Error on converting " + status, e);
|
|
return LifecycleInformationDV.Status.NOT_SPECIFIED;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* To list project.
|
|
*
|
|
* @param projects the projects
|
|
* @param projectBuilder the project builder
|
|
* @return the list
|
|
*/
|
|
public static List<ProjectDV> toListProject(Iterator<Project> projects, ProjectDVBuilder projectBuilder) {
|
|
List<ProjectDV> toReturnList = new ArrayList<ProjectDV>();
|
|
int i = 0;
|
|
while (projects.hasNext()) {
|
|
Project project = projects.next();
|
|
ProjectDV projectDV = ConvertToDataValueObjectModel.toProjectDV(project, projectBuilder);
|
|
toReturnList.add(projectDV);
|
|
i++;
|
|
LOG.trace(i + ") converted: " + projectDV);
|
|
}
|
|
LOG.debug("read " + toReturnList + " project/s");
|
|
|
|
return toReturnList;
|
|
|
|
}
|
|
|
|
/**
|
|
* To list result document.
|
|
*
|
|
* @param projects the projects
|
|
* @return the list
|
|
*/
|
|
public static List<ResultDocumentDV> toListResultDocument(Iterator<Project> projects) {
|
|
List<ResultDocumentDV> toReturnList = new ArrayList<ResultDocumentDV>();
|
|
int i = 0;
|
|
while (projects.hasNext()) {
|
|
Project project = projects.next();
|
|
ResultDocumentDV resultDV = ConvertToDataValueObjectModel.toResultDocumentDV(project);
|
|
toReturnList.add(resultDV);
|
|
i++;
|
|
LOG.trace(i + ") converted: " + resultDV);
|
|
}
|
|
LOG.debug("read " + toReturnList + " project/s");
|
|
|
|
return toReturnList;
|
|
|
|
}
|
|
|
|
/**
|
|
* To JSON.
|
|
*
|
|
* @param theObj the the obj
|
|
* @return the string
|
|
*/
|
|
public static String toJSON(Object theObj) {
|
|
LOG.debug("toJSON called");
|
|
try {
|
|
|
|
// if (theObj instanceof Serializable) {
|
|
return org.gcube.application.geoportal.client.utils.Serialization.write(theObj);
|
|
// }
|
|
// throw new Exception("The input object is not serializable");
|
|
|
|
} catch (Exception e) {
|
|
LOG.warn("Error on deserializing: ", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* To relationship definition.
|
|
*
|
|
* @param relationshipDefinition the relationship definition
|
|
* @return the relationship definition DV
|
|
*/
|
|
public static RelationshipDefinitionDV toRelationshipDefinition(RelationshipDefinition relationshipDefinition) {
|
|
|
|
RelationshipDefinitionDV rdv = new RelationshipDefinitionDV();
|
|
rdv.setId(relationshipDefinition.getId());
|
|
rdv.setLabel(relationshipDefinition.getLabel());
|
|
rdv.setReverseRelationId(relationshipDefinition.getReverseRelationId());
|
|
|
|
return rdv;
|
|
|
|
}
|
|
|
|
/**
|
|
* To payload DV.
|
|
*
|
|
* @param payload the payload
|
|
* @return the payload DV
|
|
*/
|
|
public static PayloadDV toPayloadDV(Payload payload) {
|
|
PayloadDV p = new PayloadDV();
|
|
p.setName(payload.getName());
|
|
p.setLink(payload.getLink());
|
|
p.setMimetype(payload.getMimetype());
|
|
p.setStorageID(payload.getStorageID());
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Convert.
|
|
*
|
|
* @param toConvert the to convert
|
|
* @return the index layer DV
|
|
* @throws InvalidObjectException the invalid object exception
|
|
*/
|
|
public static IndexLayerDV convert(Index toConvert) throws InvalidObjectException {
|
|
|
|
if (toConvert == null || toConvert.getType() == null)
|
|
throw new InvalidObjectException("Unable to convert Index. Unknown type: " + toConvert);
|
|
|
|
IndexLayerDV toReturn = null;
|
|
switch (toConvert.getType()) {
|
|
case "GIS-CENTROIDS": {
|
|
toReturn = Serialization.convert(toConvert, IndexLayerDV.class);
|
|
// toReturn.setLayer(Serialization.read(toConvert.get("layer"),
|
|
// GCubeSDILayer.class));
|
|
// toReturn.setFlag(toConvert.getString("flag"));
|
|
// toReturn.setIndexName(toConvert.getString());
|
|
break;
|
|
|
|
}
|
|
default: {
|
|
throw new InvalidObjectException("Unable to convert Index. Unknown type : " + toConvert.getType());
|
|
}
|
|
}
|
|
|
|
return toReturn;
|
|
}
|
|
|
|
/**
|
|
* To timeline JSON model.
|
|
*
|
|
* @param theProject the the project
|
|
* @param sourceJsonTemplate the source json template
|
|
* @param targetUCD the target UCD
|
|
* @param targetProjectID the target project ID
|
|
* @param relationName the relation name
|
|
* @return the JSON object
|
|
*/
|
|
public static JSONObject toTimelineJSONModel(Project theProject, JSONObject sourceJsonTemplate, String targetUCD,
|
|
String targetProjectID, String relationName) {
|
|
|
|
com.jayway.jsonpath.Configuration jsonPathConfig = com.jayway.jsonpath.Configuration.defaultConfiguration()
|
|
.addOptions(Option.ALWAYS_RETURN_LIST);
|
|
|
|
DocumentContext targetDoc = JsonPath.using(jsonPathConfig).parse(theProject.getTheDocument().toJson());
|
|
|
|
JSONObject targetJsonObject = new JSONObject();
|
|
targetJsonObject.put("id", targetUCD + "," + targetProjectID);
|
|
|
|
if (relationName != null)
|
|
targetJsonObject.put("relationship_name", relationName);
|
|
|
|
for (Object key : sourceJsonTemplate.keySet()) {
|
|
String jsonPath = null;
|
|
String theKey = null;
|
|
try {
|
|
theKey = key + "";
|
|
LOG.debug("Searching key: " + theKey);
|
|
jsonPath = sourceJsonTemplate.getString(theKey);
|
|
LOG.debug("with key: " + theKey + " read JSON path: " + jsonPath);
|
|
List<String> listValue = targetDoc.read(jsonPath);
|
|
String result = "";
|
|
for (int i = 0; i < listValue.size() - 1; i++) {
|
|
result += listValue.get(i) + ", ";
|
|
}
|
|
result += listValue.get(listValue.size() - 1);
|
|
targetJsonObject.put(theKey, result);
|
|
} catch (Exception e) {
|
|
LOG.trace("Error on setting key: {}, path: {}", theKey, jsonPath);
|
|
}
|
|
}
|
|
|
|
return targetJsonObject;
|
|
|
|
}
|
|
|
|
/**
|
|
* To temporal reference DV.
|
|
*
|
|
* @param theProject the the project
|
|
* @param timelineJSONObject the timeline JSON object
|
|
* @return the temporal reference DV
|
|
*/
|
|
public static TemporalReferenceDV toTemporalReferenceDV(Project theProject, JSONObject timelineJSONObject) {
|
|
|
|
TemporalReferenceDV tr = null;
|
|
|
|
if (timelineJSONObject != null) {
|
|
tr = new TemporalReferenceDV();
|
|
tr.setProjectID(theProject.getId());
|
|
tr.setProfileID(theProject.getProfileID());
|
|
tr.setJsonTimelineObject(timelineJSONObject.toString());
|
|
String start = timelineJSONObject.getString("start");
|
|
tr.setStart(DateUtils.toDate(start));
|
|
String end = timelineJSONObject.getString("end");
|
|
tr.setEnd(DateUtils.toDate(end));
|
|
}
|
|
|
|
return tr;
|
|
|
|
}
|
|
|
|
}
|