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 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 listHandlersDV = new ArrayList(); if (handlersIds != null) { LOG.info("List of input handlersIds is " + handlersIds + ", converting it"); Map> handlersMapByID = ucd.getHandlersMapByID(); if (handlersMapByID != null) { for (String handlersId : handlersIds) { List 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 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 listGeoportalConfigType = new ArrayList(); ArrayList 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> listHashMapConfig = configuration .get(configManaged.getId(), ArrayList.class); LOG.debug("hashMapConfig found is: {}", listHashMapConfig); if (listHashMapConfig != null) { jsonConfigurations = new ArrayList(); for (LinkedHashMap 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 listGcubeProfiles = new ArrayList(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> dDV = new ConfigurationDV>( 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 listItemFields = new ArrayList(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> dDV = new ConfigurationDV>(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 listActionsDef = new ArrayList( jsonConfigurations.size()); LOG.trace("Into " + GEOPORTAL_CONFIGURATION_TYPE.actions_definition + " handlers are: {}", ucd.getHandlers()); List 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 roles = new HashSet(); if (handlerLC != null) { for (String stepID : actionDef.getCall_STEPS()) { List listRoles = GeoportalConfigUtil.readRolesForSTEPId(handlerLC, stepID); roles.addAll(listRoles); } } listActionsDef.add(toActionDefinition(actionDef, roles)); } ConfigurationDV> dDV = new ConfigurationDV>( 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 filePaths = gCubeProfile.getFilePaths(); if (filePaths != null) { LOG.warn("List of " + FilePath.class.getSimpleName() + " is null"); List filePathsVO = new ArrayList(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 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 relations = project.getRelationships(); if (relations != null && projectReader.isIncludeRelationships()) { List listRelations = new ArrayList(relations.size()); for (Relationship relationship : relations) { listRelations.add(toRelationshipDV(relationship)); } theProject.setRelationships(listRelations); } List identificationReferences = project.getIdentificationReferences(); if (identificationReferences != null) { Map mapIdentReferenceDV = new HashMap( 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 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 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 listRelDV = new ArrayList(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 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 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 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 DocumentDV toGenericDocumentDV(String projectID, Document document, Class targetClass, List 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 documentAsMap = new LinkedHashMap(listDocumentKeys.size()); for (String key : listDocumentKeys) { documentAsMap = fillMapValue(document, key, documentAsMap); } documentDV.setDocumentAsMap(documentAsMap); } if (getFullMap) { Set keySet = document.keySet(); LinkedHashMap documentAsMap = new LinkedHashMap(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 { /** * 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 { /** * 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 { /** * 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 fillMapValue(Document document, String key, LinkedHashMap 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 { /** * 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 toListProject(Iterator projects, ProjectDVBuilder projectBuilder) { List toReturnList = new ArrayList(); 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 toListResultDocument(Iterator projects) { List toReturnList = new ArrayList(); 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 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; } }