447 lines
22 KiB
Java
447 lines
22 KiB
Java
package eu.old.eudat.migration;
|
|
|
|
import eu.eudat.commons.XmlHandlingService;
|
|
import eu.eudat.commons.enums.FieldDataExternalDatasetType;
|
|
import eu.eudat.commons.enums.FieldType;
|
|
import eu.eudat.commons.enums.FieldValidationType;
|
|
import eu.eudat.commons.types.descriptiontemplate.*;
|
|
import eu.eudat.commons.types.descriptiontemplate.fielddata.*;
|
|
import eu.eudat.convention.ConventionService;
|
|
import eu.eudat.data.DescriptionTemplateEntity;
|
|
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.stereotype.Service;
|
|
import org.w3c.dom.Document;
|
|
import org.xml.sax.SAXException;
|
|
|
|
import javax.management.InvalidApplicationException;
|
|
import javax.xml.parsers.ParserConfigurationException;
|
|
import javax.xml.transform.TransformerException;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.UUID;
|
|
|
|
@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 static final int PageSize = 500;
|
|
private static final boolean TestMode = false;
|
|
|
|
public DescriptionTemplateXmlMigrationService(EntityManager entityManager, ConventionService conventionService, XmlHandlingService xmlHandlingService, QueryFactory queryFactory) {
|
|
this.entityManager = entityManager;
|
|
this.conventionService = conventionService;
|
|
this.xmlHandlingService = xmlHandlingService;
|
|
this.queryFactory = queryFactory;
|
|
}
|
|
|
|
public void migrate() throws IOException, NoSuchFieldException, IllegalAccessException, JAXBException, ParserConfigurationException, InstantiationException, SAXException, InvalidApplicationException, TransformerException {
|
|
long total = this.queryFactory.query(DescriptionTemplateQuery.class).count();
|
|
logger.debug("Migrate DescriptionTemplate Total : " + total);
|
|
int page = 0;
|
|
|
|
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");
|
|
continue;
|
|
}
|
|
ViewStyleModel viewStyleModel = null;
|
|
try {
|
|
viewStyleModel = new ViewStyleModel().fromXml(document.getDocumentElement());
|
|
} catch (Exception ex){
|
|
logger.error("Migrate DescriptionTemplate " + item.getId() + " failed read xml");
|
|
continue;
|
|
}
|
|
item.setDefinition(this.xmlHandlingService.toXml(this.buildDefinitionEntity(viewStyleModel)));
|
|
this.entityManager.merge(item);
|
|
}
|
|
|
|
this.entityManager.flush();
|
|
page++;
|
|
}
|
|
} while (items != null && !items.isEmpty() && !TestMode);
|
|
}
|
|
|
|
private @NotNull DefinitionEntity buildDefinitionEntity(ViewStyleModel persist) {
|
|
DefinitionEntity data = new DefinitionEntity();
|
|
if (persist == null)
|
|
return data;
|
|
if (!this.conventionService.isListNullOrEmpty(persist.getPages())) {
|
|
data.setPages(new ArrayList<>());
|
|
for (Page pagePersist : persist.getPages()) {
|
|
data.getPages().add(this.buildPageEntity(pagePersist, persist.getSections()));
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
private @NotNull SectionEntity buildSectionEntity(Section persist) {
|
|
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));
|
|
}
|
|
}
|
|
|
|
if (!this.conventionService.isListNullOrEmpty(persist.getFieldSets())) {
|
|
data.setFieldSets(new ArrayList<>());
|
|
for (FieldSet fieldSetPersist : persist.getFieldSets()) {
|
|
data.getFieldSets().add(this.buildFieldSetEntity(fieldSetPersist));
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
private @NotNull FieldSetEntity buildFieldSetEntity(FieldSet persist) {
|
|
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));
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
private @NotNull FieldEntity buildFieldEntity(Field persist) {
|
|
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()));
|
|
|
|
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));
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
private BaseFieldDataEntity buildFieldDataEntity(FieldData persist, String renderStyle) {
|
|
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.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((TaxonomiesData)persist).getMultiAutoComplete(),FieldType.TAXONOMIES);
|
|
}
|
|
if (renderStyle.equals("services")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((ServicesData)persist).getMultiAutoComplete(),FieldType.SERVICES);
|
|
}
|
|
if (renderStyle.equals("researchers")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((ResearcherData)persist).getMultiAutoComplete(),FieldType.RESEARCHERS);
|
|
}
|
|
if (renderStyle.equals("registries")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((RegistriesData)persist).getMultiAutoComplete(),FieldType.REGISTRIES);
|
|
}
|
|
if (renderStyle.equals("pubRepositories")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(),FieldType.PUB_REPOSITORIES);
|
|
}
|
|
if (renderStyle.equals("publications")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((PublicationsData)persist).getMultiAutoComplete(),FieldType.PUB_REPOSITORIES);
|
|
}
|
|
if (renderStyle.equals("organizations")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((OrganizationsData)persist).getMultiAutoComplete(),FieldType.ORGANIZATIONS);
|
|
}
|
|
if (renderStyle.equals("licenses")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((LicensesData)persist).getMultiAutoComplete(),FieldType.LICENSES);
|
|
}
|
|
if (renderStyle.equals("journalRepositories")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(),FieldType.JOURNAL_REPOSITORIES);
|
|
}
|
|
if (renderStyle.equals("dataRepositories")){
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(),FieldType.DATA_REPOSITORIES);
|
|
}
|
|
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_DMP_ENTRIES_DMPS);
|
|
case "datasets":
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DatasetsAutoCompleteData)persist).getMultiAutoComplete(),FieldType.INTERNAL_DMP_ENTRIES_DATASETS);
|
|
case "researchers":
|
|
return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((ResearchersAutoCompleteData)persist).getMultiAutoComplete(),FieldType.INTERNAL_DMP_ENTRIES_RESEARCHERS);
|
|
}
|
|
}
|
|
|
|
if (renderStyle.equals("externalDatasets")){
|
|
ExternalDatasetDataEntity data = new ExternalDatasetDataEntity();
|
|
data.setLabel(persist.getLabel());
|
|
data.setMultipleSelect(((ExternalDatasetsData)persist).getMultiAutoComplete());
|
|
data.setType(FieldDataExternalDatasetType.of(((ExternalDatasetsData)persist).getType()));
|
|
data.setFieldType(FieldType.EXTERNAL_DATASETS);
|
|
return data;
|
|
}
|
|
|
|
|
|
|
|
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":{
|
|
ExternalSelectDataEntity data = new ExternalSelectDataEntity();
|
|
data.setLabel(persist.getLabel());
|
|
data.setSources(new ArrayList<>());
|
|
data.setMultipleSelect(((AutoCompleteData)persist).getMultiAutoComplete());
|
|
if (((AutoCompleteData)persist).getAutoCompleteSingleDataList() != null){
|
|
for (AutoCompleteData.AutoCompleteSingleData autoCompleteSingleData : ((AutoCompleteData)persist).getAutoCompleteSingleDataList()){
|
|
ExternalSelectDataEntity.ExternalSelectSourceEntity autoCompleteSingleDataEntity = new ExternalSelectDataEntity.ExternalSelectSourceEntity();
|
|
autoCompleteSingleDataEntity.setOptionsRoot(autoCompleteSingleData.getOptionsRoot());
|
|
autoCompleteSingleDataEntity.setUrl(autoCompleteSingleData.getUrl());
|
|
autoCompleteSingleDataEntity.setMethod(autoCompleteSingleData.getMethod());
|
|
autoCompleteSingleDataEntity.setHasAuth(autoCompleteSingleData.getHasAuth());
|
|
if (autoCompleteSingleData.getHasAuth() && autoCompleteSingleData.getAuth()!= null) {
|
|
ExternalSelectDataEntity.ExternalSelectAuthDataEntity optionEntity = new ExternalSelectDataEntity.ExternalSelectAuthDataEntity();
|
|
optionEntity.setBody(autoCompleteSingleData.getAuth().getBody());
|
|
optionEntity.setMethod(autoCompleteSingleData.getAuth().getMethod());
|
|
optionEntity.setUrl(autoCompleteSingleData.getAuth().getUrl());
|
|
optionEntity.setType(autoCompleteSingleData.getAuth().getType());
|
|
optionEntity.setBody(autoCompleteSingleData.getAuth().getBody());
|
|
autoCompleteSingleDataEntity.setAuth(optionEntity);
|
|
}
|
|
if (autoCompleteSingleData.getAutoCompleteOptions() != null) {
|
|
ExternalSelectDataEntity.ExternalSelectSourceBindingEntity optionEntity = new ExternalSelectDataEntity.ExternalSelectSourceBindingEntity();
|
|
optionEntity.setValue(autoCompleteSingleData.getAutoCompleteOptions().getValue());
|
|
optionEntity.setLabel(autoCompleteSingleData.getAutoCompleteOptions().getLabel());
|
|
optionEntity.setSource(autoCompleteSingleData.getAutoCompleteOptions().getSource());
|
|
autoCompleteSingleDataEntity.setSourceBinding(optionEntity);
|
|
}
|
|
data.getSources().add(autoCompleteSingleDataEntity);
|
|
}
|
|
}
|
|
data.setFieldType(FieldType.EXTERNAL_SELECT);
|
|
return data;
|
|
}
|
|
}
|
|
}
|
|
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 @NotNull RuleEntity buildRuleEntity(Rule persist) {
|
|
RuleEntity data = new RuleEntity();
|
|
if (persist == null)
|
|
return data;
|
|
|
|
data.setTarget(persist.getTarget());
|
|
data.setValue(persist.getValue());
|
|
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> allSections) {
|
|
PageEntity data = new PageEntity();
|
|
if (persist == null)
|
|
return data;
|
|
|
|
data.setId(persist.getId());
|
|
data.setOrdinal(persist.getOrdinal());
|
|
data.setTitle(persist.getTitle());
|
|
|
|
List<Section> sections = allSections.stream().filter(x-> this.isInPage(x, persist)).toList();
|
|
if (!this.conventionService.isListNullOrEmpty(sections)) {
|
|
data.setSections(new ArrayList<>());
|
|
for (Section sectionPersist : sections) {
|
|
data.getSections().add(this.buildSectionEntity(sectionPersist));
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
private boolean isInPage(Section section, Page page){
|
|
try {
|
|
return UUID.fromString(section.getPage()).equals(UUID.fromString(page.getId()));
|
|
} catch (Exception e){
|
|
try {
|
|
return Integer.parseInt(section.getPage().replace("page_", "")) == page.getOrdinal();
|
|
} catch (Exception e1){
|
|
return section.getPage().toLowerCase(Locale.ROOT).equals(page.getId().toLowerCase(Locale.ROOT));
|
|
}
|
|
}
|
|
}
|
|
}
|