707 lines
35 KiB
Java
707 lines
35 KiB
Java
package eu.old.eudat.migration;
|
|
|
|
import com.fasterxml.jackson.annotation.JsonValue;
|
|
import eu.eudat.commons.XmlHandlingService;
|
|
import eu.eudat.commons.enums.*;
|
|
import eu.eudat.commons.types.descriptiontemplate.*;
|
|
import eu.eudat.commons.types.descriptiontemplate.fielddata.*;
|
|
import eu.eudat.commons.types.externalfetcher.*;
|
|
import eu.eudat.commons.types.referencetype.*;
|
|
import eu.eudat.convention.ConventionService;
|
|
import eu.eudat.data.DescriptionTemplateEntity;
|
|
import eu.eudat.data.ReferenceEntity;
|
|
import eu.eudat.data.ReferenceTypeEntity;
|
|
import eu.eudat.data.converters.enums.DatabaseEnum;
|
|
import eu.eudat.model.DescriptionTemplate;
|
|
import eu.eudat.query.DescriptionTemplateQuery;
|
|
import eu.old.eudat.logic.utilities.builders.XmlBuilder;
|
|
import eu.old.eudat.models.data.components.commons.Multiplicity;
|
|
import eu.old.eudat.models.data.components.commons.Rule;
|
|
import eu.old.eudat.models.data.components.commons.datafield.*;
|
|
import eu.old.eudat.models.data.entities.xmlmodels.datasetprofiledefinition.*;
|
|
import gr.cite.tools.data.query.Ordering;
|
|
import gr.cite.tools.data.query.Paging;
|
|
import gr.cite.tools.data.query.QueryFactory;
|
|
import gr.cite.tools.exception.MyApplicationException;
|
|
import gr.cite.tools.logging.LoggerService;
|
|
import jakarta.persistence.EntityManager;
|
|
import jakarta.xml.bind.JAXBException;
|
|
import org.jetbrains.annotations.NotNull;
|
|
import org.slf4j.LoggerFactory;
|
|
import org.springframework.http.MediaType;
|
|
import org.springframework.stereotype.Service;
|
|
import org.w3c.dom.Document;
|
|
import org.xml.sax.SAXException;
|
|
|
|
import javax.management.InvalidApplicationException;
|
|
import javax.ws.rs.NotSupportedException;
|
|
import javax.xml.parsers.ParserConfigurationException;
|
|
import javax.xml.transform.TransformerException;
|
|
import java.io.IOException;
|
|
import java.net.URI;
|
|
import java.net.URISyntaxException;
|
|
import java.time.Instant;
|
|
import java.time.LocalDate;
|
|
import java.time.ZoneOffset;
|
|
import java.time.format.DateTimeParseException;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
@Service
|
|
public class DescriptionTemplateXmlMigrationService {
|
|
|
|
private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateXmlMigrationService.class));
|
|
private final EntityManager entityManager;
|
|
private final ConventionService conventionService;
|
|
private final XmlHandlingService xmlHandlingService;
|
|
private final QueryFactory queryFactory;
|
|
private final MigrationTools migrationTools;
|
|
|
|
private static final int PageSize = 500;
|
|
private static final boolean TestMode = false;
|
|
|
|
public DescriptionTemplateXmlMigrationService(EntityManager entityManager, ConventionService conventionService, XmlHandlingService xmlHandlingService, QueryFactory queryFactory, MigrationTools migrationTools) {
|
|
this.entityManager = entityManager;
|
|
this.conventionService = conventionService;
|
|
this.xmlHandlingService = xmlHandlingService;
|
|
this.queryFactory = queryFactory;
|
|
this.migrationTools = migrationTools;
|
|
}
|
|
|
|
public void migrate() throws IOException, NoSuchFieldException, IllegalAccessException, JAXBException, ParserConfigurationException, InstantiationException, SAXException, InvalidApplicationException, TransformerException, URISyntaxException {
|
|
long total = this.queryFactory.query(DescriptionTemplateQuery.class).count();
|
|
logger.debug("Migrate DescriptionTemplate Total : " + total);
|
|
int page = 0;
|
|
|
|
Map<String, ReferenceTypeEntity> referenceTypeEntityMap = new HashMap<>();
|
|
List<DescriptionTemplateEntity> items;
|
|
do {
|
|
DescriptionTemplateQuery query = this.queryFactory.query(DescriptionTemplateQuery.class);
|
|
query.setOrder(new Ordering().addDescending(DescriptionTemplate._createdAt));
|
|
query.setPage(new Paging(page * PageSize, PageSize));
|
|
items = query.collect();
|
|
if (items != null && !items.isEmpty()) {
|
|
|
|
logger.debug("Migrate DescriptionTemplate " + page * PageSize + " of " + total);
|
|
|
|
for (DescriptionTemplateEntity item : items) {
|
|
if (this.conventionService.isNullOrEmpty(item.getDefinition())) continue;
|
|
Document document = XmlBuilder.fromXml(item.getDefinition());
|
|
if (document == null){
|
|
logger.error("Migrate DescriptionTemplate " + item.getId() + " failed read xml");
|
|
throw new MyApplicationException("Migrate DescriptionTemplate " + item.getId() + " failed read xml");
|
|
}
|
|
ViewStyleModel viewStyleModel = null;
|
|
try {
|
|
viewStyleModel = new ViewStyleModel().fromXml(document.getDocumentElement());
|
|
} catch (Exception ex){
|
|
logger.error("Migrate DescriptionTemplate " + item.getId() + " failed read xml");
|
|
throw new MyApplicationException("Migrate DescriptionTemplate " + item.getId() + " failed read xml");
|
|
}
|
|
item.setDefinition(this.xmlHandlingService.toXml(this.buildDefinitionEntity(viewStyleModel, referenceTypeEntityMap)));
|
|
this.entityManager.merge(item);
|
|
}
|
|
|
|
this.entityManager.flush();
|
|
page++;
|
|
}
|
|
} while (items != null && !items.isEmpty() && !TestMode);
|
|
|
|
logger.debug("Migrate DescriptionTemplate ReferenceTypes : " + referenceTypeEntityMap.size());
|
|
for (ReferenceTypeEntity item : referenceTypeEntityMap.values()){
|
|
this.entityManager.persist(item);
|
|
}
|
|
this.entityManager.flush();
|
|
}
|
|
|
|
private @NotNull DefinitionEntity buildDefinitionEntity(ViewStyleModel persist, Map<String, ReferenceTypeEntity> referenceTypeEntityMap) throws URISyntaxException {
|
|
DefinitionEntity data = new DefinitionEntity();
|
|
if (persist == null)
|
|
return data;
|
|
if (!this.conventionService.isListNullOrEmpty(persist.getPages())) {
|
|
Map<String, List<Section>> sectionPerPage = mapSectionsToPage(persist);
|
|
data.setPages(new ArrayList<>());
|
|
for (Page pagePersist : persist.getPages()) {
|
|
data.getPages().add(this.buildPageEntity(pagePersist, sectionPerPage.get(pagePersist.getId()), referenceTypeEntityMap));
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
private @NotNull SectionEntity buildSectionEntity(Section persist, Map<String, ReferenceTypeEntity> referenceTypeEntityMap) throws URISyntaxException {
|
|
SectionEntity data = new SectionEntity();
|
|
if (persist == null)
|
|
return data;
|
|
|
|
data.setId(persist.getId());
|
|
data.setDescription(persist.getDescription());
|
|
data.setExtendedDescription(persist.getExtendedDescription());
|
|
data.setNumbering(persist.getNumbering());
|
|
data.setOrdinal(persist.getOrdinal());
|
|
data.setDefaultVisibility(persist.isDefaultVisibility());
|
|
data.setMultiplicity(persist.getMultiplicity());
|
|
data.setTitle(persist.getTitle());
|
|
|
|
if (!this.conventionService.isListNullOrEmpty(persist.getSections())) {
|
|
data.setSections(new ArrayList<>());
|
|
for (Section sectionPersist : persist.getSections()) {
|
|
data.getSections().add(this.buildSectionEntity(sectionPersist, referenceTypeEntityMap));
|
|
}
|
|
}
|
|
|
|
if (!this.conventionService.isListNullOrEmpty(persist.getFieldSets())) {
|
|
data.setFieldSets(new ArrayList<>());
|
|
for (FieldSet fieldSetPersist : persist.getFieldSets()) {
|
|
data.getFieldSets().add(this.buildFieldSetEntity(fieldSetPersist, referenceTypeEntityMap));
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
private @NotNull FieldSetEntity buildFieldSetEntity(FieldSet persist, Map<String, ReferenceTypeEntity> referenceTypeEntityMap) throws URISyntaxException {
|
|
FieldSetEntity data = new FieldSetEntity();
|
|
if (persist == null)
|
|
return data;
|
|
|
|
data.setId(persist.getId());
|
|
data.setOrdinal(persist.getOrdinal());
|
|
data.setNumbering(persist.getNumbering());
|
|
data.setTitle(persist.getTitle());
|
|
data.setExtendedDescription(persist.getExtendedDescription());
|
|
data.setAdditionalInformation(persist.getAdditionalInformation());
|
|
data.setHasCommentField(persist.getHasCommentField());
|
|
if (persist.getMultiplicity() != null) data.setMultiplicity(this.buildMultiplicityEntity(persist.getMultiplicity()));
|
|
|
|
if (!this.conventionService.isListNullOrEmpty(persist.getFields())) {
|
|
data.setFields(new ArrayList<>());
|
|
for (Field fieldPersist : persist.getFields()) {
|
|
data.getFields().add(this.buildFieldEntity(fieldPersist, referenceTypeEntityMap));
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
private @NotNull FieldEntity buildFieldEntity(Field persist, Map<String, ReferenceTypeEntity> referenceTypeEntityMap) throws URISyntaxException {
|
|
FieldEntity data = new FieldEntity();
|
|
if (persist == null)
|
|
return data;
|
|
|
|
data.setId(persist.getId());
|
|
data.setOrdinal(persist.getOrdinal());
|
|
data.setSchematics(persist.getSchematics());
|
|
data.setNumbering(persist.getNumbering());
|
|
if (persist.getDefaultValue() != null) data.setDefaultValue(persist.getDefaultValue().getValue());
|
|
if (persist.getValidations() != null) data.setValidations(persist.getValidations().stream().map(x-> {
|
|
switch (x){
|
|
case NONE -> {
|
|
return FieldValidationType.None;
|
|
}
|
|
case REQUIRED -> {
|
|
return FieldValidationType.Required;
|
|
}
|
|
case URL -> {
|
|
return FieldValidationType.Url;
|
|
}
|
|
default -> throw new MyApplicationException("Invalid type " + x);
|
|
}
|
|
|
|
}).toList());
|
|
data.setIncludeInExport(persist.getExport());
|
|
if (persist.getData() != null) {
|
|
data.setData(this.buildFieldDataEntity(persist.getData(), persist.getViewStyle().getRenderStyle(), referenceTypeEntityMap));
|
|
if (persist.getViewStyle().getRenderStyle().equals("externalDatasets")){
|
|
FieldDataExternalDatasetType type = null;
|
|
try {
|
|
type = FieldDataExternalDatasetType.of(((ExternalDatasetsData)persist.getData()).getType());
|
|
} catch (Exception e) { type = FieldDataExternalDatasetType.Other; }
|
|
if (type == null) type = FieldDataExternalDatasetType.Other;
|
|
if (data.getSchematics() == null) data.setSchematics(new ArrayList<>());
|
|
switch (type){
|
|
case Other -> data.getSchematics().add("referencetype.externaldataset.type.other");
|
|
case ProducedDataset -> data.getSchematics().add("referencetype.externaldataset.type.produced");
|
|
case ReusedDataset -> data.getSchematics().add("referencetype.externaldataset.type.reused");
|
|
default -> throw new MyApplicationException("Invalid type " + type);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (persist.getVisible() != null && !this.conventionService.isListNullOrEmpty(persist.getVisible().getRules())) {
|
|
data.setVisibilityRules(new ArrayList<>());
|
|
for (Rule fieldPersist : persist.getVisible().getRules()) {
|
|
data.getVisibilityRules().add(this.buildRuleEntity(fieldPersist, data.getData().getFieldType()));
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
private BaseFieldDataEntity buildFieldDataEntity(FieldData<?> persist, String renderStyle, Map<String, ReferenceTypeEntity> referenceTypeEntityMap) throws URISyntaxException {
|
|
if (renderStyle.equals("checkBox")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.CHECK_BOX);
|
|
}
|
|
if (renderStyle.equals("validation")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.VALIDATION);
|
|
}
|
|
if (renderStyle.equals("textarea")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.TEXT_AREA);
|
|
}
|
|
if (renderStyle.equals("tags")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.TAGS);
|
|
}
|
|
if (renderStyle.equals("richTextarea")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.RICH_TEXT_AREA);
|
|
}
|
|
if (renderStyle.equals("freetext")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.FREE_TEXT);
|
|
}
|
|
if (renderStyle.equals("datePicker")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.DATE_PICKER);
|
|
}
|
|
if (renderStyle.equals("datasetIdentifier")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.DATASET_IDENTIFIER);
|
|
}
|
|
if (renderStyle.equals("currency")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.CURRENCY);
|
|
}
|
|
if (renderStyle.equals("taxonomies")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((TaxonomiesData)persist).getMultiAutoComplete(), ReferenceTypeIds.Taxonomy);
|
|
}
|
|
if (renderStyle.equals("services")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((ServicesData)persist).getMultiAutoComplete(),ReferenceTypeIds.Services);
|
|
}
|
|
if (renderStyle.equals("researchers")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((ResearcherData)persist).getMultiAutoComplete(),ReferenceTypeIds.Researcher);
|
|
}
|
|
if (renderStyle.equals("registries")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((RegistriesData)persist).getMultiAutoComplete(),ReferenceTypeIds.Registries);
|
|
}
|
|
if (renderStyle.equals("pubRepositories")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(),ReferenceTypeIds.PubRepositories);
|
|
}
|
|
if (renderStyle.equals("publications")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((PublicationsData)persist).getMultiAutoComplete(), ReferenceTypeIds.Publication);
|
|
}
|
|
if (renderStyle.equals("organizations")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((OrganizationsData)persist).getMultiAutoComplete(), ReferenceTypeIds.Organizations);
|
|
}
|
|
if (renderStyle.equals("licenses")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((LicensesData)persist).getMultiAutoComplete(), ReferenceTypeIds.License);
|
|
}
|
|
if (renderStyle.equals("journalRepositories")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(), ReferenceTypeIds.Journal);
|
|
}
|
|
if (renderStyle.equals("dataRepositories")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(), ReferenceTypeIds.DataRepositories);
|
|
}
|
|
if (renderStyle.equals("booleanDecision")){
|
|
return this.buildLabelDataEntity(persist.getLabel(), FieldType.BOOLEAN_DECISION);
|
|
}
|
|
if (renderStyle.equals("internalDmpEntities")){
|
|
switch (((InternalDmpEntitiesData<?>)persist).getType()){
|
|
case "dmps":
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DMPsAutoCompleteData)persist).getMultiAutoComplete(),FieldType.INTERNAL_ENTRIES_DMPS);
|
|
case "datasets":
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DatasetsAutoCompleteData)persist).getMultiAutoComplete(),FieldType.INTERNAL_ENTRIES_DESCRIPTIONS);
|
|
case "researchers":
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((ResearchersAutoCompleteData)persist).getMultiAutoComplete(), ReferenceTypeIds.Researcher);
|
|
}
|
|
}
|
|
|
|
if (renderStyle.equals("externalDatasets")){
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((ExternalDatasetsData)persist).getMultiAutoComplete(), ReferenceTypeIds.Datasets);
|
|
}
|
|
|
|
|
|
|
|
if (renderStyle.equals("upload")){
|
|
UploadDataEntity data = new UploadDataEntity();
|
|
data.setLabel(persist.getLabel());
|
|
data.setMaxFileSizeInMB(((UploadData)persist).getMaxFileSizeInMB());
|
|
data.setTypes(new ArrayList<>());
|
|
if (((UploadData)persist).getTypes() != null){
|
|
for (UploadData.Option option : ((UploadData)persist).getTypes()){
|
|
UploadDataEntity.UploadDataOptionEntity optionEntity =new UploadDataEntity.UploadDataOptionEntity();
|
|
optionEntity.setValue(option.getValue());
|
|
optionEntity.setLabel(option.getLabel());
|
|
data.getTypes().add(optionEntity);
|
|
}
|
|
}
|
|
data.setFieldType(FieldType.UPLOAD);
|
|
return data;
|
|
}
|
|
|
|
if (renderStyle.equals("radiobox")){
|
|
RadioBoxDataEntity data = new RadioBoxDataEntity();
|
|
data.setLabel(persist.getLabel());
|
|
data.setOptions(new ArrayList<>());
|
|
if (((RadioBoxData)persist).getOptions() != null){
|
|
for (RadioBoxData.Option option : ((RadioBoxData)persist).getOptions()){
|
|
RadioBoxDataEntity.RadioBoxDataOptionEntity optionEntity = new RadioBoxDataEntity.RadioBoxDataOptionEntity();
|
|
optionEntity.setValue(option.getValue());
|
|
optionEntity.setLabel(option.getLabel());
|
|
data.getOptions().add(optionEntity);
|
|
}
|
|
}
|
|
data.setFieldType(FieldType.RADIO_BOX);
|
|
return data;
|
|
}
|
|
|
|
if (renderStyle.equals("combobox")){
|
|
switch (((ComboBoxData<?>)persist).getType()){
|
|
case "wordlist":{
|
|
SelectDataEntity data = new SelectDataEntity();
|
|
data.setLabel(persist.getLabel());
|
|
data.setOptions(new ArrayList<>());
|
|
data.setMultipleSelect(((WordListData)persist).getMultiList());
|
|
if (((WordListData)persist).getOptions() != null){
|
|
for (ComboBoxData.Option option : ((WordListData)persist).getOptions()){
|
|
SelectDataEntity.OptionEntity optionEntity = new SelectDataEntity.OptionEntity();
|
|
optionEntity.setValue(option.getValue());
|
|
optionEntity.setLabel(option.getLabel());
|
|
data.getOptions().add(optionEntity);
|
|
}
|
|
}
|
|
data.setFieldType(FieldType.SELECT);
|
|
return data;
|
|
}
|
|
case "autocomplete":{
|
|
ReferenceTypeEntity referenceType = this.resolveReferenceTypeEntityAutoCompleteData(((AutoCompleteData)persist), referenceTypeEntityMap);
|
|
return this.buildReferenceTypeDataEntity(persist.getLabel(), ((AutoCompleteData)persist).getMultiAutoComplete(), referenceType.getId());
|
|
}
|
|
}
|
|
}
|
|
throw new MyApplicationException("Can transform field data" + renderStyle);
|
|
}
|
|
|
|
private BaseFieldDataEntity buildLabelDataEntity(String label, FieldType fieldType) {
|
|
LabelDataEntity data = new LabelDataEntity();
|
|
data.setLabel(label);
|
|
data.setFieldType(fieldType);
|
|
return data;
|
|
}
|
|
|
|
private BaseFieldDataEntity buildLabelAndMultiplicityDataEntity(String label, Boolean multiAutoComplete, FieldType fieldType) {
|
|
LabelAndMultiplicityDataEntity data = new LabelAndMultiplicityDataEntity();
|
|
data.setLabel(label);
|
|
data.setFieldType(fieldType);
|
|
data.setMultipleSelect(multiAutoComplete);
|
|
return data;
|
|
}
|
|
|
|
private BaseFieldDataEntity buildReferenceTypeDataEntity(String label, Boolean multiAutoComplete, UUID referenceTypeId) {
|
|
ReferenceTypeDataEntity data = new ReferenceTypeDataEntity();
|
|
data.setLabel(label);
|
|
data.setFieldType(FieldType.REFERENCE_TYPES);
|
|
data.setMultipleSelect(multiAutoComplete);
|
|
data.setReferenceTypeId(referenceTypeId);
|
|
return data;
|
|
}
|
|
|
|
|
|
private @NotNull RuleEntity buildRuleEntity(Rule persist, FieldType fieldType) {
|
|
RuleEntity data = new RuleEntity();
|
|
if (persist == null)
|
|
return data;
|
|
String textValue = persist.getValue();
|
|
if (textValue == null || textValue.isEmpty()) return data;
|
|
|
|
data.setTarget(persist.getTarget());
|
|
switch (fieldType){
|
|
case FREE_TEXT, TEXT_AREA, RICH_TEXT_AREA, RADIO_BOX -> data.setTextValue(textValue.trim());
|
|
case CHECK_BOX, BOOLEAN_DECISION -> data.setTextValue(textValue.trim().toLowerCase(Locale.ROOT));
|
|
case DATE_PICKER -> {
|
|
Instant instant = null;
|
|
if(!this.conventionService.isNullOrEmpty(textValue)) {
|
|
try {
|
|
instant = Instant.parse(textValue);
|
|
} catch (DateTimeParseException ex) {
|
|
instant = LocalDate.parse(textValue).atStartOfDay().toInstant(ZoneOffset.UTC);
|
|
}
|
|
}
|
|
data.setDateValue(instant);
|
|
}
|
|
case SELECT -> {
|
|
if(!this.conventionService.isNullOrEmpty(textValue)) {
|
|
String[] valuesParsed = migrationTools.tryParseJsonAsObjectString(String[].class, textValue);
|
|
data.setTextListValue(valuesParsed == null ? List.of(textValue) : Arrays.stream(valuesParsed).toList());
|
|
}
|
|
}
|
|
case DATASET_IDENTIFIER, VALIDATION -> {
|
|
if(!this.conventionService.isNullOrEmpty(textValue)) {
|
|
eu.eudat.commons.types.descriptiontemplate.ExternalIdentifierEntity externalIdentifierEntity = migrationTools.tryParseJsonAsObjectString(eu.eudat.commons.types.descriptiontemplate.ExternalIdentifierEntity.class, textValue);
|
|
if (externalIdentifierEntity == null) throw new MyApplicationException("Could not parse dataset External Identifier : " + textValue);
|
|
data.setExternalIdentifier(externalIdentifierEntity);
|
|
}
|
|
}
|
|
case UPLOAD -> throw new NotSupportedException("Upload validator not supported");
|
|
case CURRENCY -> throw new NotSupportedException("Currency validator not supported");
|
|
case TAGS -> throw new NotSupportedException("Tags validator not supported");
|
|
|
|
case INTERNAL_ENTRIES_DMPS -> throw new NotSupportedException("INTERNAL_ENTRIES_DMPS validator not supported");
|
|
case INTERNAL_ENTRIES_DESCRIPTIONS -> throw new NotSupportedException("INTERNAL_ENTRIES_DESCRIPTIONS validator not supported");
|
|
case REFERENCE_TYPES -> throw new NotSupportedException("REFERENCE_TYPES validator not supported");
|
|
default -> throw new MyApplicationException("unrecognized type " + fieldType);
|
|
}
|
|
return data;
|
|
}
|
|
private @NotNull MultiplicityEntity buildMultiplicityEntity(Multiplicity persist) {
|
|
MultiplicityEntity data = new MultiplicityEntity();
|
|
if (persist == null)
|
|
return data;
|
|
|
|
data.setMax(persist.getMax());
|
|
data.setMin(persist.getMin());
|
|
data.setPlaceholder(persist.getPlaceholder());
|
|
data.setTableView(persist.getTableView());
|
|
return data;
|
|
}
|
|
|
|
|
|
|
|
private @NotNull PageEntity buildPageEntity(Page persist, List<Section> sections, Map<String, ReferenceTypeEntity> referenceTypeEntityMap) throws URISyntaxException {
|
|
PageEntity data = new PageEntity();
|
|
if (persist == null)
|
|
return data;
|
|
|
|
data.setId(persist.getId());
|
|
data.setOrdinal(persist.getOrdinal());
|
|
data.setTitle(persist.getTitle());
|
|
|
|
if (!this.conventionService.isListNullOrEmpty(sections)) {
|
|
data.setSections(new ArrayList<>());
|
|
for (Section sectionPersist : sections) {
|
|
data.getSections().add(this.buildSectionEntity(sectionPersist, referenceTypeEntityMap));
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
|
|
private Map<String, List<Section>> mapSectionsToPage(ViewStyleModel persist){
|
|
List<String> mappedSectionsIds = new ArrayList<>();
|
|
Map<String, List<Section>> sectionPerPage = new HashMap<>();
|
|
if (persist == null || persist.getPages() == null || persist.getSections() == null) return sectionPerPage;
|
|
|
|
for (Page page :persist.getPages()){
|
|
sectionPerPage.put(page.getId(), new ArrayList<>());
|
|
for (Section section : persist.getSections()){
|
|
if (this.isInPage(section, page)){
|
|
if (mappedSectionsIds.contains(section.getId())) throw new MyApplicationException("Multiple page section found for page " + page.getId() + " section " + section.getId());
|
|
mappedSectionsIds.add(section.getId());
|
|
sectionPerPage.get(page.getId()).add(section);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (Section section : persist.getSections()){
|
|
if (!mappedSectionsIds.contains(section.getId())) throw new MyApplicationException("Orphan section found " + section.getId());
|
|
}
|
|
|
|
return sectionPerPage;
|
|
}
|
|
|
|
private boolean isInPage(Section section, Page page){
|
|
try {
|
|
return UUID.fromString(section.getPage()).equals(UUID.fromString(page.getId()));
|
|
} catch (Exception e){
|
|
return section.getPage().toLowerCase(Locale.ROOT).equals(page.getId().toLowerCase(Locale.ROOT));
|
|
}
|
|
}
|
|
|
|
public ReferenceTypeEntity resolveReferenceTypeEntityAutoCompleteData(AutoCompleteData persist, Map<String, ReferenceTypeEntity> referenceTypeEntityMap) throws URISyntaxException {
|
|
ReferenceTypeDefinitionEntity definitionEntity = this.buildReferenceTypeDefinitionEntity(persist);
|
|
String hash = this.referenceTypeCalculatedHash(definitionEntity);
|
|
ReferenceTypeEntity data = referenceTypeEntityMap.getOrDefault(hash, null);
|
|
if (data == null) {
|
|
data = new ReferenceTypeEntity();
|
|
data.setId(UUID.randomUUID());
|
|
data.setIsActive(IsActive.Active);
|
|
data.setCreatedAt(Instant.now());
|
|
data.setName(persist.getLabel().substring(0, Math.min(persist.getLabel().length(), 199)));
|
|
data.setCode(persist.getLabel().substring(0, Math.min(persist.getLabel().length(), 99)));
|
|
data.setDefinition(this.xmlHandlingService.toXmlSafe(definitionEntity));
|
|
data.setUpdatedAt(Instant.now());
|
|
referenceTypeEntityMap.put(hash, data);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
public String referenceTypeCalculatedHash(ReferenceTypeDefinitionEntity definitionEntity) {
|
|
List<String> sourceKeys = new ArrayList<>();
|
|
if (definitionEntity.getSources() != null){
|
|
for (ExternalFetcherApiSourceConfigurationEntity source : definitionEntity.getSources().stream().map(x-> (ExternalFetcherApiSourceConfigurationEntity)x).toList()){
|
|
StringBuilder sourceStringBuilder = new StringBuilder();
|
|
sourceStringBuilder.append(source.getUrl());
|
|
sourceStringBuilder.append(source.getHttpMethod().getValue().toString());
|
|
sourceStringBuilder.append(source.getKey());
|
|
if (source.getResults() != null){
|
|
sourceStringBuilder.append(source.getResults().getResultsArrayPath());
|
|
if (source.getResults().getFieldsMapping() != null) {
|
|
sourceStringBuilder.append(source.getResults().getFieldsMapping().stream().filter(x-> x.getCode().equals(ReferenceEntity.KnownFields.ReferenceId)).map(ResultFieldsMappingConfigurationEntity::getResponsePath).findFirst().orElse(""));
|
|
sourceStringBuilder.append(source.getResults().getFieldsMapping().stream().filter(x-> x.getCode().equals(ReferenceEntity.KnownFields.Label)).map(ResultFieldsMappingConfigurationEntity::getResponsePath).findFirst().orElse(""));
|
|
}
|
|
}
|
|
sourceKeys.add(sourceStringBuilder.toString().toLowerCase(Locale.ROOT));
|
|
}
|
|
}
|
|
return sourceKeys.stream().sorted().collect(Collectors.joining(""));
|
|
}
|
|
|
|
private @NotNull ReferenceTypeDefinitionEntity buildReferenceTypeDefinitionEntity(AutoCompleteData persist) throws URISyntaxException {
|
|
ReferenceTypeDefinitionEntity data = new ReferenceTypeDefinitionEntity();
|
|
if (persist == null) return data;
|
|
data.setFields(new ArrayList<>());
|
|
|
|
if (!this.conventionService.isListNullOrEmpty(persist.getAutoCompleteSingleDataList())){
|
|
data.setSources(new ArrayList<>());
|
|
int ordinal = 0;
|
|
for (AutoCompleteData.AutoCompleteSingleData sourceBaseConfigPersist: persist.getAutoCompleteSingleDataList()) {
|
|
data.getSources().add(this.buildSourceBaseConfigEntity(sourceBaseConfigPersist, ordinal));
|
|
ordinal++;
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
private @NotNull ExternalFetcherApiSourceConfigurationEntity buildSourceBaseConfigEntity(AutoCompleteData.AutoCompleteSingleData persist, int ordinal) throws URISyntaxException {
|
|
if (persist == null) return new ExternalFetcherApiSourceConfigurationEntity();
|
|
|
|
ExternalFetcherApiSourceConfigurationEntity apiEntity = new ExternalFetcherApiSourceConfigurationEntity();
|
|
|
|
URI uri;
|
|
if (persist.getUrl().contains("?")) {
|
|
uri = new URI(persist.getUrl().substring(0, persist.getUrl().trim().lastIndexOf("?")));
|
|
} else {
|
|
uri = new URI(persist.getUrl().trim());
|
|
}
|
|
String source = persist.getAutoCompleteOptions().getSource();
|
|
source = source != null && !source.isEmpty() ? source : uri.getHost();
|
|
|
|
String parsedUrl = persist.getUrl().trim();
|
|
parsedUrl = parsedUrl.replace("%20", " ");
|
|
parsedUrl = parsedUrl.replace("%22", "\"");
|
|
while (parsedUrl.contains("&")) {
|
|
parsedUrl = parsedUrl.replace("&", "&");
|
|
}
|
|
|
|
apiEntity.setUrl(parsedUrl);
|
|
apiEntity.setResults(this.buildResultsConfigEntity(persist));
|
|
|
|
apiEntity.setPaginationPath(null);
|
|
apiEntity.setContentType(MediaType.APPLICATION_JSON_VALUE);
|
|
apiEntity.setFirstPage("1");
|
|
apiEntity.setHttpMethod(this.toReferenceTypeExternalApiHTTPMethodType(persist.getMethod()));
|
|
apiEntity.setRequestBody(null);
|
|
apiEntity.setFilterType(null);
|
|
if (persist.getHasAuth() && persist.getAuth() != null) {
|
|
apiEntity.setAuth(this.buildAuthConfigEntity(persist.getAuth()));
|
|
}
|
|
apiEntity.setQueries(new ArrayList<>());
|
|
apiEntity.getQueries().add(this.buildQueryConfigEntity(parsedUrl));
|
|
|
|
apiEntity.setType(ExternalFetcherSourceType.API);
|
|
apiEntity.setKey(source);
|
|
apiEntity.setLabel(source);
|
|
apiEntity.setOrdinal(ordinal);
|
|
apiEntity.setReferenceTypeDependencyIds(null);
|
|
|
|
return apiEntity;
|
|
}
|
|
|
|
private @NotNull ResultsConfigurationEntity buildResultsConfigEntity(AutoCompleteData.AutoCompleteSingleData persist){
|
|
ResultsConfigurationEntity data = new ResultsConfigurationEntity();
|
|
|
|
|
|
data.setResultsArrayPath(persist.getOptionsRoot());
|
|
if (persist.getAutoCompleteOptions() == null && this.conventionService.isNullOrEmpty(persist.getAutoCompleteOptions().getLabel())) {
|
|
data.setFieldsMapping(new ArrayList<>());
|
|
ResultFieldsMappingConfigurationEntity labelField = new ResultFieldsMappingConfigurationEntity();
|
|
labelField.setCode(ReferenceEntity.KnownFields.Label);
|
|
labelField.setResponsePath(persist.getAutoCompleteOptions().getLabel());
|
|
data.getFieldsMapping().add(labelField);
|
|
}
|
|
if (persist.getAutoCompleteOptions() == null && this.conventionService.isNullOrEmpty(persist.getAutoCompleteOptions().getValue())) {
|
|
ResultFieldsMappingConfigurationEntity idField = new ResultFieldsMappingConfigurationEntity();
|
|
idField.setCode(ReferenceEntity.KnownFields.ReferenceId);
|
|
idField.setResponsePath(persist.getAutoCompleteOptions().getValue());
|
|
data.getFieldsMapping().add(idField);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
private @NotNull QueryConfigEntity buildQueryConfigEntity(String path){
|
|
QueryConfigEntity data = new QueryConfigEntity();
|
|
|
|
data.setName("like");
|
|
if ((path.toLowerCase(Locale.ROOT).trim().contains("openaire") || path.toLowerCase(Locale.ROOT).trim().contains("orcid")
|
|
|| path.toLowerCase(Locale.ROOT).trim().contains("ror") || path.toLowerCase(Locale.ROOT).trim().contains("fairsharing"))) {
|
|
data.setDefaultValue("*");
|
|
} else {
|
|
data.setDefaultValue("");
|
|
}
|
|
data.setCases(new ArrayList<>());
|
|
QueryCaseConfigEntity caseConfig = new QueryCaseConfigEntity();
|
|
caseConfig.setReferenceTypeId(null);
|
|
caseConfig.setReferenceTypeSourceKey(null);
|
|
caseConfig.setSeparator(null);
|
|
caseConfig.setValue("{like}");
|
|
caseConfig.setLikePattern(null);
|
|
data.getCases().add(caseConfig);
|
|
|
|
return data;
|
|
}
|
|
|
|
private @NotNull AuthenticationConfigurationEntity buildAuthConfigEntity(AutoCompleteData.AuthAutoCompleteData persist){
|
|
AuthenticationConfigurationEntity data = new AuthenticationConfigurationEntity();
|
|
if (persist == null) return data;
|
|
|
|
data.setEnabled(true);
|
|
data.setAuthUrl(persist.getUrl());
|
|
data.setAuthMethod(this.toReferenceTypeExternalApiHTTPMethodType(persist.getMethod()));
|
|
data.setAuthRequestBody(persist.getBody());
|
|
data.setType(persist.getType());
|
|
data.setAuthTokenPath(persist.getPath());
|
|
|
|
return data;
|
|
}
|
|
|
|
private ExternalFetcherApiHTTPMethodType toReferenceTypeExternalApiHTTPMethodType(String method){
|
|
|
|
if (this.conventionService.isNullOrEmpty(method)) {
|
|
logger.error("Migrate DescriptionTemplate autocomplete method not set use default GET");
|
|
return ExternalFetcherApiHTTPMethodType.GET;
|
|
} else if (method.toLowerCase(Locale.ROOT).trim().equals("get")) {
|
|
return ExternalFetcherApiHTTPMethodType.GET;
|
|
} else if (method.toLowerCase(Locale.ROOT).trim().equals("post")) {
|
|
return ExternalFetcherApiHTTPMethodType.POST;
|
|
} else {
|
|
logger.error("Migrate DescriptionTemplate autocomplete method is invalid " + method);
|
|
throw new MyApplicationException("Migrate DescriptionTemplate autocomplete method is invalid " + method);
|
|
}
|
|
}
|
|
|
|
public enum FieldDataExternalDatasetType implements DatabaseEnum<String> {
|
|
ReusedDataset("reused_dataset"),
|
|
ProducedDataset("produced_dataset"),
|
|
Other("other");
|
|
private final String value;
|
|
|
|
FieldDataExternalDatasetType(String value) {
|
|
this.value = value;
|
|
}
|
|
|
|
@JsonValue
|
|
public String getValue() {
|
|
return value;
|
|
}
|
|
|
|
private static final Map<String, FieldDataExternalDatasetType> map = EnumUtils.getEnumValueMap(FieldDataExternalDatasetType.class);
|
|
|
|
public static FieldDataExternalDatasetType of(String i) {
|
|
return map.get(i);
|
|
}
|
|
}
|
|
}
|