argos/dmp-migration-tool/web/src/main/java/eu/old/eudat/migration/DmpMigrationService.java

package eu.old.eudat.migration;

import com.fasterxml.jackson.core.JsonProcessingException;
import eu.eudat.commons.JsonHandlingService;
import eu.eudat.commons.enums.DmpAccessType;
import eu.eudat.commons.enums.DmpStatus;
import eu.eudat.commons.enums.DmpVersionStatus;
import eu.eudat.commons.enums.IsActive;
import eu.eudat.commons.types.dmp.DmpBlueprintValueEntity;
import eu.eudat.commons.types.dmp.DmpContactEntity;
import eu.eudat.commons.types.dmp.DmpPropertiesEntity;
import eu.eudat.commons.types.dmpblueprint.DefinitionEntity;
import eu.eudat.data.DmpBlueprintEntity;
import eu.eudat.data.DmpDescriptionTemplateEntity;
import eu.eudat.data.DmpEntity;
import eu.eudat.query.DmpBlueprintQuery;
import eu.old.eudat.data.dao.entities.DMPDao;
import eu.old.eudat.data.dao.entities.DmpDatasetProfileDao;
import eu.old.eudat.data.entities.DMP;
import eu.old.eudat.data.entities.DMPDatasetProfile;
import eu.old.eudat.logic.services.operations.DatabaseRepository;
import eu.old.eudat.models.data.dmp.DataManagementPlan;
import eu.old.eudat.queryable.QueryableList;
import gr.cite.tools.exception.MyApplicationException;
import gr.cite.tools.logging.LoggerService;
import jakarta.persistence.EntityManager;
import jakarta.xml.bind.JAXBException;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PathVariable;
import org.xml.sax.SAXException;

import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.time.Instant;
import java.util.*;

@Service
public class DmpMigrationService {

    private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DmpMigrationService.class));
    private final DatabaseRepository databaseRepository;

    private final JsonHandlingService jsonHandlingService;

    private final EntityManager entityManager;
    private static final int PageSize = 500;
    private static final boolean TestMode = false;

    public DmpMigrationService(DatabaseRepository databaseRepository, JsonHandlingService jsonHandlingService, EntityManager entityManager) {
        this.databaseRepository = databaseRepository;
        this.jsonHandlingService = jsonHandlingService;
        this.entityManager = entityManager;
    }

    public void migrate() throws JsonProcessingException {
        DMPDao dmpDao = databaseRepository.getDmpDao();
        long total = dmpDao.asQueryable().count();
        logger.debug("Migrate Dmp Total : " + total);
        int page = 0;

        List<DMP> items;
        do {
            items = dmpDao.asQueryable().orderBy((builder, root) -> builder.asc(root.get("created"))).orderBy((builder, root) -> builder.asc(root.get("ID"))).skip(page * PageSize).take(PageSize).toList();
            if (items != null && !items.isEmpty()) {
                logger.debug("Migrate Dmp " + page * PageSize + " of " + total);

                for (DMP item : items) {
                    //entityManager.detach(item);
                    
                    DataManagementPlan model = new DataManagementPlan();
                    model.fromDataModel(item);

                    DmpPropertiesEntity dmpProperties = new DmpPropertiesEntity();
                    dmpProperties.setDmpBlueprintValues(new ArrayList<>());
                    dmpProperties.setContacts(new ArrayList<>());

                    DmpEntity data = new DmpEntity();
                    data.setId(model.getId());
                    data.setLabel(model.getLabel());
                    data.setDescription(model.getDescription());
                    if (model.getCreator() != null)
                        data.setCreatorId(model.getCreator().getId());
                    data.setGroupId(model.getGroupId());
                    data.setVersion((short) model.getVersion());
                    data.setVersionStatus(DmpVersionStatus.of((short) model.getVersionStatus()));
                    if (model.getCreated() != null)
                        data.setCreatedAt(model.getCreated().toInstant());
                    if (model.getModified() != null)
                        data.setUpdatedAt(model.getModified().toInstant());
                    if (model.getFinalized() != null)
                        data.setFinalizedAt(model.getFinalized().toInstant());
                    data.setBlueprintId(model.getProfile().getId());
                    if (model.getExtraProperties() != null) {
                        if (model.getExtraProperties().containsKey("language") && model.getExtraProperties().get("language") != null)
                            data.setLanguage((String) model.getExtraProperties().get("language"));
                        if (model.getExtraProperties().containsKey("visible") && model.getExtraProperties().get("visible") != null)
                            data.setAccessType((boolean) model.getExtraProperties().get("visible") ? DmpAccessType.Public : DmpAccessType.Restricted);
                        if (model.getExtraProperties().containsKey("contact") && model.getExtraProperties().get("contact") != null) {
                            DmpContactEntity contactEntity = new DmpContactEntity();
                            contactEntity.setUserId((String) model.getExtraProperties().get("contact"));
                            dmpProperties.getContacts().add(contactEntity);
                        }
                    }
                    if (model.getProperties() != null) {
                        model.getProperties().forEach((key,val) -> {
                            DmpBlueprintValueEntity valueEntity = new DmpBlueprintValueEntity();
                            valueEntity.setFieldId(key);
                            valueEntity.setValue((String) val);
                            dmpProperties.getDmpBlueprintValues().add(valueEntity);
                        });
                    }
                    if (model.getStatus() == 99) {
                        data.setIsActive(IsActive.Inactive);
                        data.setStatus(DmpStatus.Draft);
                    } else {
                        data.setIsActive(IsActive.Active);
                        data.setStatus(DmpStatus.of((short) model.getStatus()));
                    }
                    data.setProperties(jsonHandlingService.toJson(dmpProperties));


                    if (data.getAccessType() == null) {
                        logger.warn("AccessType not found set to default for dmp " + item.getId());
                        data.setAccessType(DmpAccessType.Restricted); //TODO
                    }
                    if (data.getLanguage() == null) {
                        logger.warn("Language not found set to default for dmp " + item.getId());
                        data.setLanguage(""); //TODO
                    }
                    if (data.getCreatorId() == null){
                        logger.warn("Migration skipped creator not found " + item.getId());
                        continue;
                    }
                    

                    this.entityManager.persist(data);
                    this.entityManager.flush();
                }

                page++;
            }
        } while (items != null && !items.isEmpty() && !TestMode);
    }

//    public QueryableList<DMP> dmpQueryableList() {
//        return databaseRepository.getDmpDao().asQueryable();
//    }
//
//    public List<DataManagementPlan> getDmps(Integer skip, Integer take) {
//        List<DMP> dmps = dmpQueryableList()
//                .orderBy((builder, root) -> builder.desc(root.get("created")))
//                .skip(skip)
//                .take(take)
//                .toList();
//
//        return dmps.stream().map(x -> {
//            DataManagementPlan dmp = new DataManagementPlan();
//            dmp.fromDataModel(x);
//            return dmp;
//        }).toList();
//    }

//    public List<DmpMigrationCollectedInfo> collectDmpsInfo() throws JsonProcessingException {
//        List<DmpMigrationCollectedInfo> collectedInfoList = new ArrayList<>();
//        List<DataManagementPlan> dmps = getDmps(0, Integer.MAX_VALUE);
//        for (DataManagementPlan dataManagementPlan : dmps) {
//            DmpMigrationCollectedInfo dmpMigrationCollectedInfo = new DmpMigrationCollectedInfo();
//
//            DmpPropertiesEntity dmpProperties = new DmpPropertiesEntity();
//            dmpProperties.setDmpBlueprintValues(new ArrayList<>());
//            dmpProperties.setContacts(new ArrayList<>());
//
//            //Collect basic dmp information
//            DmpEntity dmpEntity = new DmpEntity();
//            dmpEntity.setId(dataManagementPlan.getId());
//            dmpEntity.setLabel(dataManagementPlan.getLabel());
//            dmpEntity.setDescription(dataManagementPlan.getDescription());
//            if (dataManagementPlan.getCreator() != null)
//                dmpEntity.setCreatorId(dataManagementPlan.getCreator().getId());
//            dmpEntity.setGroupId(dataManagementPlan.getGroupId());
//            dmpEntity.setVersion((short) dataManagementPlan.getVersion());
//            dmpEntity.setVersionStatus(DmpVersionStatus.of((short) dataManagementPlan.getVersionStatus()));
//            if (dataManagementPlan.getCreated() != null)
//                dmpEntity.setCreatedAt(dataManagementPlan.getCreated().toInstant());
//            if (dataManagementPlan.getModified() != null)
//                dmpEntity.setUpdatedAt(dataManagementPlan.getModified().toInstant());
//            if (dataManagementPlan.getFinalized() != null)
//                dmpEntity.setFinalizedAt(dataManagementPlan.getFinalized().toInstant());
//            dmpEntity.setBlueprintId(dataManagementPlan.getProfile().getId());
//            if (dataManagementPlan.getExtraProperties() != null) {
//                if (dataManagementPlan.getExtraProperties().containsKey("language") && dataManagementPlan.getExtraProperties().get("language") != null)
//                    dmpEntity.setLanguage((String) dataManagementPlan.getExtraProperties().get("language"));
//                if (dataManagementPlan.getExtraProperties().containsKey("visible") && dataManagementPlan.getExtraProperties().get("visible") != null)
//                    dmpEntity.setAccessType((boolean) dataManagementPlan.getExtraProperties().get("visible") ? DmpAccessType.Public : DmpAccessType.Restricted);
//                if (dataManagementPlan.getExtraProperties().containsKey("contact") && dataManagementPlan.getExtraProperties().get("contact") != null) {
//                    DmpContactEntity contactEntity = new DmpContactEntity();
//                    contactEntity.setUserId((String) dataManagementPlan.getExtraProperties().get("contact"));
//                    dmpProperties.getContacts().add(contactEntity);
//                }
//            }
//            if (dataManagementPlan.getProperties() != null) {
//                dataManagementPlan.getProperties().forEach((key,val) -> {
//                    DmpBlueprintValueEntity valueEntity = new DmpBlueprintValueEntity();
//                    valueEntity.setFieldId(key);
//                    valueEntity.setValue((String) val);
//                    dmpProperties.getDmpBlueprintValues().add(valueEntity);
//                });
//            }
//            if (dataManagementPlan.getStatus() == 99) {
//                dmpEntity.setIsActive(IsActive.Inactive);
//                dmpEntity.setStatus(DmpStatus.Draft);
//            } else {
//                dmpEntity.setIsActive(IsActive.Active);
//                dmpEntity.setStatus(DmpStatus.of((short) dataManagementPlan.getStatus()));
//            }
//            dmpEntity.setProperties(jsonHandlingService.toJson(dmpProperties));
//            dmpMigrationCollectedInfo.dmpEntity = dmpEntity;
//
//            //Collect dmp Organization info
//
//            collectedInfoList.add(dmpMigrationCollectedInfo);
//        }
//        return collectedInfoList;
//    }
//
//    public String migrate() throws JsonProcessingException {
//        for (DmpMigrationCollectedInfo collectedInfo : collectDmpsInfo()) {
//            this.entityManager.persist(collectedInfo.dmpEntity);
//        }
//        this.entityManager.flush();
//        return "Migrated dmps";
//    }
//
//    public static class DmpMigrationCollectedInfo {
//
//        public DmpEntity dmpEntity;
//
//    }

}