EDIT

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.app.pesi;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.app.common.CdmDestinations;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.io.common.CdmDefaultImport;

import eu.etaxonomy.cdm.io.common.IImportConfigurator.CHECK;

import eu.etaxonomy.cdm.io.common.IImportConfigurator.DO_REFERENCES;

import eu.etaxonomy.cdm.io.pesi.fauEu2Cdm.FauEu2CdmImportConfigurator;

/**

 * @author a.mueller

 * @since 17.08.2019

 */

public class FauEu2CdmActivator {

    @SuppressWarnings("unused")

    private static final Logger logger = Logger.getLogger(FauEu2CdmActivator.class);

    static final ICdmDataSource fauEuSource = CdmDestinations.cdm_pesi_fauna_europaea();

    static final ICdmDataSource cdmDestination = CdmDestinations.cdm_test_local_mysql_erms();

    //check - import

    static final CHECK check = CHECK.IMPORT_WITHOUT_CHECK;

    static final int partitionSize = 5000;

// ***************** ALL ************************************************//

    //references

    static final DO_REFERENCES doReferences =  DO_REFERENCES.ALL;

    //taxa

    static final boolean doTaxa = true;

    private void doImport(ICdmDataSource source, ICdmDataSource destination, DbSchemaValidation hbm2dll){

        String importFrom = " import from "+ source.getDatabase() + " to "+ destination.getDatabase() + " ...";

        System.out.println("Start"+importFrom);

        FauEu2CdmImportConfigurator config = FauEu2CdmImportConfigurator.NewInstance(source,  destination);

//        config.setDoTaxa(doTaxa);

        config.setDbSchemaValidation(hbm2dll);

        config.setCheck(check);

//        config.setRecordsPerTransaction(partitionSize);

//        config.setSourceRefUuid(PesiTransformer.uuidSourceRefErms);

        // invoke import

        CdmDefaultImport<FauEu2CdmImportConfigurator> myImport = new CdmDefaultImport<>();

        myImport.invoke(config);

        System.out.println("End" + importFrom);

    }

    /**

     * @param args

     */

    public static void main(String[] args) {

        ICdmDataSource cdmDB = CdmDestinations.chooseDestination(args) != null ? CdmDestinations.chooseDestination(args) : cdmDestination;

        FauEu2CdmActivator myImport = new FauEu2CdmActivator();

        myImport.doImport(fauEuSource, cdmDB, DbSchemaValidation.VALIDATE);

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.io.pesi.fauEu2Cdm;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.io.common.TaxonNodeOutStreamPartitioner;

import eu.etaxonomy.cdm.io.common.XmlExportState;

import eu.etaxonomy.cdm.model.common.AnnotatableEntity;

import eu.etaxonomy.cdm.model.common.Annotation;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.Marker;

import eu.etaxonomy.cdm.model.common.VersionableEntity;

import eu.etaxonomy.cdm.model.taxon.Classification;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

/**

 * @author a.mueller

 * @since 17.08.2019

 */

public class FauEu2CdmImport

        extends FauEu2CdmImportBase {

    private static final long serialVersionUID = -2111102574346601573L;

    @Override

    protected boolean doCheck(FauEu2CdmImportState state) {

        return false;

    }

    @Override

    protected void doInvoke(FauEu2CdmImportState state) {

        IProgressMonitor monitor = state.getConfig().getProgressMonitor();

        FauEu2CdmImportConfigurator config = state.getConfig();

        if (config.getTaxonNodeFilter().getClassificationFilter() != null

                && !config.getTaxonNodeFilter().getClassificationFilter().isEmpty()) {

            Classification classification = getClassificationService()

                    .load(config.getTaxonNodeFilter().getClassificationFilter().get(0).getUuid());

            state.setRootId(classification.getRootNode().getUuid());

        } else if (config.getTaxonNodeFilter().getSubtreeFilter() != null

                && !config.getTaxonNodeFilter().getSubtreeFilter().isEmpty()) {

            state.setRootId(config.getTaxonNodeFilter().getSubtreeFilter().get(0).getUuid());

        }

        @SuppressWarnings("unchecked")

        TaxonNodeOutStreamPartitioner<XmlExportState> partitioner = TaxonNodeOutStreamPartitioner.NewInstance(this,

                state, state.getConfig().getTaxonNodeFilter(), 100, monitor, null);

        monitor.subTask("Start partitioning");

        TaxonNode node = partitioner.next();

        while (node != null) {

            handleTaxonNode(state, node);

            node = partitioner.next();

        }

    }

    /**

     * @param state

     * @param node

     */

    private void handleTaxonNode(FauEu2CdmImportState state, TaxonNode node) {

//        Integer id = state.getTarget(createdBy.getUuid(), createdBy.getClass());

        handleAnnotatableEntity(node);

    }

    private void handleAnnotatableEntity(AnnotatableEntity entity) {

        handleVersionableEntity(entity);

        for (Annotation a : getTargetCollection(entity.getAnnotations())){

            entity.addAnnotation(a);

        }

        for (Marker a : getTargetCollection(entity.getMarkers())){

            entity.addMarker(a);

        }

//        entity.setUpdatedBy(getTarget(entity.getUpdatedBy()));

    }

    /**

     * @param annotations

     * @return

     */

    private <T extends Collection<S>, S extends CdmBase> List<S> getTargetCollection(T sourceCollection) {

        List<S> result = new ArrayList<>();

        for (S entity : sourceCollection){

            S target = getTarget(entity);

            result.add(target);

        }

        return result;

    }

    private void handleVersionableEntity(VersionableEntity entity) {

        handleCdmBase(entity);

        entity.setUpdatedBy(getTarget(entity.getUpdatedBy()));

    }

    private void handleCdmBase(CdmBase cdmBase) {

        cdmBase.setCreatedBy(getTarget(cdmBase.getCreatedBy()));

    }

    //TODO this should be cached for partition

    private <T extends CdmBase> T getTarget(T source) {

        Class<T> clazz = (Class<T>)source.getClass();

        T result = getCommonService().find(clazz, source.getUuid());

        if (result == null){

            //TODO recursive

            //TODO session evict

            result = CdmBase.deproxy(source);

            result.setId(0);

        }

        return result;

    }

    @Override

    protected boolean isIgnore(FauEu2CdmImportState state) {

        return false;

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.io.pesi.fauEu2Cdm;

import eu.etaxonomy.cdm.api.application.CdmApplicationController;

import eu.etaxonomy.cdm.api.application.ICdmRepository;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.io.common.CdmImportBase;

/**

 * @author a.mueller

 * @since 17.08.2019

 */

public abstract class FauEu2CdmImportBase

        extends CdmImportBase<FauEu2CdmImportConfigurator, FauEu2CdmImportState> {

    private static final long serialVersionUID = 8917991155285743172L;

    protected ICdmRepository source(FauEu2CdmImportState state){

        ICdmRepository repo = state.getSourceRepository();

        if (repo == null){

            boolean omitTermLoading = true;

            repo = CdmApplicationController.NewInstance(state.getConfig().getSource(),

                    DbSchemaValidation.VALIDATE, omitTermLoading);

        }

        return repo;

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.io.pesi.fauEu2Cdm;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.filter.TaxonNodeFilter;

import eu.etaxonomy.cdm.io.common.ImportConfiguratorBase;

import eu.etaxonomy.cdm.io.common.mapping.IInputTransformer;

import eu.etaxonomy.cdm.model.reference.Reference;

/**

 * @author a.mueller

 * @since 17.08.2019

 */

public class FauEu2CdmImportConfigurator

        extends ImportConfiguratorBase<FauEu2CdmImportState, ICdmDataSource>{

    private static final long serialVersionUID = -5452466831212722546L;

    private static IInputTransformer myTransformer = null;

    private TaxonNodeFilter taxonNodeFilter = new TaxonNodeFilter();

    public static FauEu2CdmImportConfigurator NewInstance(ICdmDataSource source, ICdmDataSource destination) {

        return new FauEu2CdmImportConfigurator(source, destination);

    }

    public FauEu2CdmImportConfigurator(ICdmDataSource source, ICdmDataSource destination) {

        super(myTransformer);

        this.setSource(source);

        this.setDestination(destination);

    }

    @Override

    public FauEu2CdmImportState getNewState() {

        return new FauEu2CdmImportState(this);

    }

    @SuppressWarnings("unchecked")

    @Override

    protected void makeIoClassList() {

        ioClassList = new Class[]{

                FauEu2CdmImport.class ,

        };

    }

    @Override

    @Deprecated

    public Reference getSourceReference() {

        return null;

    }

    public TaxonNodeFilter getTaxonNodeFilter() {

        return taxonNodeFilter;

    }

    public void setTaxonNodeFilter(TaxonNodeFilter taxonNodeFilter) {

        this.taxonNodeFilter = taxonNodeFilter;

    }

}

/**

* Copyright (C) 2019 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.io.pesi.fauEu2Cdm;

import java.util.HashMap;

import java.util.Map;

import java.util.UUID;

import eu.etaxonomy.cdm.api.application.ICdmRepository;

import eu.etaxonomy.cdm.io.common.CdmImportBase;

import eu.etaxonomy.cdm.io.common.ImportStateBase;

import eu.etaxonomy.cdm.model.common.CdmBase;

/**

 * @author a.mueller

 * @since 17.08.2019

 */

public class FauEu2CdmImportState

        extends ImportStateBase<FauEu2CdmImportConfigurator,CdmImportBase>{

    private ICdmRepository sourceRepository;

    private UUID rootUuid;

    protected FauEu2CdmImportState(FauEu2CdmImportConfigurator config) {

        super(config);

    }

    public ICdmRepository getSourceRepository() {

        return sourceRepository;

    }

    public void setSourceRepository(ICdmRepository sourceRepository) {

        this.sourceRepository = sourceRepository;

    }

    public UUID getRootId() {

        return rootUuid;

    }

    public void setRootId(UUID rootId) {

        this.rootUuid = rootId;

    }

    private Map<UUID, Integer> targetMap = new HashMap<>();

    /**

     * @param uuid

     * @param class1

     */

    public <T extends CdmBase> Integer getTarget(UUID uuid, Class<T> clazz) {

        return targetMap.get(uuid);

    }

}