EDIT

/**

* Copyright (C) 2007 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.common;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;

import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.api.service.IService;

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

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

import eu.etaxonomy.cdm.io.common.events.IIoObserver;

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

/**

 * This class is an default exporter class that is a spring bean and therefore it knows all other IO classes that are beans

 *

 * @author a.mueller

 * @since 20.06.2008

 */

@Component("defaultExport")

public class CdmApplicationAwareDefaultExport<T extends IExportConfigurator>

        implements ICdmExporter<T>, ApplicationContextAware {

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

	protected ApplicationContext applicationContext;

	@Override

    public void setApplicationContext(ApplicationContext applicationContext)

			throws BeansException {

		this.applicationContext = applicationContext;

	}

	//Constants

	final static boolean OBLIGATORY = true;

	final static boolean FACULTATIVE = false;

	final int modCount = 1000;

	private final IService service = null;

	//different type of stores that are used by the known imports

	Map<String, MapWrapper<? extends CdmBase>> stores = new HashMap<>();

	public CdmApplicationAwareDefaultExport(){

		stores.put(ICdmIO.TEAM_STORE, new MapWrapper<>(service));

		stores.put(ICdmIO.REFERENCE_STORE, new MapWrapper<>(service));

		stores.put(ICdmIO.NOMREF_STORE, new MapWrapper<>(service));

		stores.put(ICdmIO.TAXONNAME_STORE, new MapWrapper<>(service));

		stores.put(ICdmIO.TAXON_STORE, new MapWrapper<>(service));

		stores.put(ICdmIO.SPECIMEN_STORE, new MapWrapper<>(service));

	}

	@Override

    public ExportResult invoke(T config){

	    ExportResult result;

	    if (config.getCheck().equals(IExportConfigurator.CHECK.CHECK_ONLY)){

		    result = ExportResult.NewInstance(config.getResultType());

		    boolean success =  doCheck(config);

		    if (! success){

		        result.setAborted();

		    }

		}else if (config.getCheck().equals(IExportConfigurator.CHECK.CHECK_AND_EXPORT)){

		    boolean success = doCheck(config);

		    if (success){

		        result = doExport(config);

		    }else{

		        result = ExportResult.NewInstance(config.getResultType());

	            result.setAborted();

		    }

		}else if (config.getCheck().equals(IExportConfigurator.CHECK.EXPORT_WITHOUT_CHECK)){

			result = doExport(config);

		}else{

		    result = ExportResult.NewInstance(config.getResultType());

            String message = "Unknown CHECK type";

            logger.error(message);

            result.addError(message);

 		}

		return result;

	}

    public ExportResult execute(T config) {

	    ExportResult result = ExportResult.NewInstance(config.getResultType());

	    if (config.getCheck().equals(IExportConfigurator.CHECK.CHECK_ONLY)){

	        boolean success =  doCheck(config);

            if (! success){

                result.setAborted();

            }

        } else if (config.getCheck().equals(IExportConfigurator.CHECK.CHECK_AND_EXPORT)){

            boolean success = doCheck(config);

            if (success){

                result = doExport(config);

            }else{

                result.setAborted();

            }

        } else if (config.getCheck().equals(IExportConfigurator.CHECK.EXPORT_WITHOUT_CHECK)){

            result = doExport(config);

        } else{

            String message = "Unknown CHECK type";

            logger.error(message);

            result.addError(message);

        }

	    return result;

	}

	@SuppressWarnings("unchecked")

	protected <S extends IExportConfigurator> boolean doCheck(S  config){

	    boolean result = true;

		//check

		if (config == null){

			logger.warn("CdmExportConfiguration is null");

//			result.setState(ExportResultState.ABORTED);

			return false;

		}else if (! config.isValid()){

			logger.warn("CdmExportConfiguration is not valid");

//			result.setState(ExportResultState.ABORTED);

            return false;

		}

		System.out.println("Start checking Source ("+ config.getSourceNameString() + ") ...");

		ExportStateBase state = config.getNewState();

		state.initialize(config);

		//do check for each class

		for (Class<ICdmExport> ioClass: config.getIoClassList()){

			try {

				String ioBeanName = getComponentBeanName(ioClass);

				ICdmIO cdmIo = applicationContext.getBean(ioBeanName, ICdmIO.class);

				if (cdmIo != null){

					registerObservers(config, cdmIo);

					result &= cdmIo.check(state);

					unRegisterObservers(config, cdmIo);

				}else{

				    String message = "cdmIO for class " + (ioClass == null ? "(null)" : ioClass.getSimpleName()) + " was null";

					logger.error(message);

					return false;

				}

			} catch (Exception e) {

					logger.error(e);

					e.printStackTrace();

					return false;

			}

		}

		//return

		System.out.println("End checking Source ("+ config.getSourceNameString() + ") for export from Cdm");

		return result;

	}

	private void registerObservers(IExportConfigurator config, ICdmIO io){

		for (IIoObserver observer : config.getObservers()){

			io.addObserver(observer);

		}

	}

	private void unRegisterObservers(IExportConfigurator config, ICdmIO io){

		for (IIoObserver observer : config.getObservers()){

			io.removeObserver(observer);

		}

	}

	/**

	 * Executes the whole

	 */

	protected <CONFIG extends T>  ExportResult doExport(CONFIG config){

		//validate

		if (config == null){

		    ExportResult result = ExportResult.NewInstance(null);

		    String message = "Configuration is null";

			logger.error(message);

			result.addError(message);

			result.setAborted();

			return result;

		}

		ExportResult result = ExportResult.NewInstance(config.getResultType());

		if (! config.isValid()){

			String message = "Configuration is not valid";

		    logger.error(message);

		    result.addError(message);

			result.setAborted();

			return result;

		}

		ExportStateBase state = config.getNewState();

		state.initialize(config);

		state.setResult(result);

		List<ICdmExport> ioList = makeIoList(state, config);

		List<Integer> stepCounts = countSteps(state, ioList);

		Integer totalCount = stepCounts.get(stepCounts.size()-1);

		config.getProgressMonitor().beginTask(config.getUserFriendlyIOName() != null? config.getUserFriendlyIOName():"Start Export", totalCount);

		config.getProgressMonitor().worked(1);

		IProgressMonitor parentMonitor = SubProgressMonitor

		        .NewStarted(config.getProgressMonitor(), 99, "Process data", totalCount);

		//do invoke for each class

		for (int i = 0; i< ioList.size(); i++){

		    ICdmExport export = ioList.get(i);

		    Integer counts = stepCounts.get(i);

			try {

			    String ioName = export.getClass().getSimpleName();

			    SubProgressMonitor ioMonitor = SubProgressMonitor

			            .NewStarted(parentMonitor, counts, ioName, counts );

//			    state.getConfig().setProgressMonitor(ioMonitor);

			    state.setCurrentIO(export);

				export.invoke(state);

				ioMonitor.done();

			} catch (Exception e) {

				String message = "Unexpected exception in " + export.getClass().getSimpleName()+ ": " + e.getMessage();

				logger.error(message);

				e.printStackTrace();

		        result.addException(e, message);

			}

		}

		System.out.println("End export from source '" + config.getSourceNameString()

				+ "' to destination '" + config.getDestinationNameString() + "' "

				+ "("+ result.toString() + ")"

				) ;

		return result;

	}

	/**

     * @param state

     * @param ioList

     * @return

     */

    private List<Integer> countSteps(ExportStateBase state, List<ICdmExport> ioList) {

        //do invoke for each class

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

        int sum = 0;

        for (ICdmExport export: ioList){

            int count = 1;

            try {

//                state.setCurrentIO(export);

                count = ((Long)export.countSteps(state)).intValue();

            } catch (Exception e) {

                String message = "Unexpected exception when count steps for progress monitoring " + export.getClass().getSimpleName()+ ": " + e.getMessage();

                logger.error(message);

                e.printStackTrace();

                state.getResult().addException(e, message);

            }

            result.add(count);

            sum += count;

        }

        result.add(sum);

        return result;

    }

    /**

     * @param state

     * @param config

     * @return

     */

    private <CONFIG extends T>  List<ICdmExport> makeIoList(ExportStateBase state, CONFIG config) {

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

        for (Class<ICdmExport> ioClass: config.getIoClassList()){

            try {

                String ioBeanName = getComponentBeanName(ioClass);

                ICdmExport cdmIo = applicationContext.getBean(ioBeanName, ICdmExport.class);

                if (cdmIo != null){

                    result.add(cdmIo);

                }else{

                    String message = "cdmIO was null: " + ioBeanName;

                    logger.error(message);

                    state.getResult().addError(message);

                }

            } catch (Exception e) {

                    String message = "Unexpected exception in " + ioClass.getSimpleName()+ ": " + e.getMessage();

                    logger.error(message);

                    e.printStackTrace();

                    state.getResult().addException(e, message);

            }

        }

        return result;

    }

    private String getComponentBeanName(Class<ICdmExport> ioClass){

		Component component = ioClass.getAnnotation(Component.class);

		String ioBean = component.value();

		if ("".equals(ioBean)){

			ioBean = ioClass.getSimpleName();

			ioBean = ioBean.substring(0, 1).toLowerCase() + ioBean.substring(1); //make camelcase

		}

		return ioBean;

	}

}

/**

* Copyright (C) 2009 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.common;

import java.util.UUID;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.database.ICdmDataSource;

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

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

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

/**

 * @author a.mueller

 * @since 29.01.2009

 */

public interface IImportConfigurator extends IIoConfigurator {

    public static enum SOURCE_TYPE {

        URI,

        INPUTSTREAM

    }

    public static enum CHECK{

        CHECK_ONLY,

        IMPORT_WITHOUT_CHECK,

        CHECK_AND_IMPORT;

        public boolean isImport(){

            return this == IMPORT_WITHOUT_CHECK || this == CHECK_AND_IMPORT ;

        }

    }

    public static enum EDITOR{

        NO_EDITORS,  //leaves out createdBy and updatedBy information

        EDITOR_AS_ANNOTATION,//save createdBy and updatedBy in annotations

        EDITOR_AS_EDITOR, //save createdBy and updatedBy in createdBy and updatedBy

    }

    public static enum DO_REFERENCES{

        NONE,

        NOMENCLATURAL,

        CONCEPT_REFERENCES,

        ALL;

        public DO_REFERENCES invers(){

        	if (this == DO_REFERENCES.NONE){

        		return ALL;

        	}else if (this == ALL){

        		return NONE;

        	}else if (this == NOMENCLATURAL){  //don't change

        		return NOMENCLATURAL;

        	}else if (this == CONCEPT_REFERENCES){  //don't change

        		return CONCEPT_REFERENCES;

        	}else{

        		throw new RuntimeException("inverse for DO_REFERENCE type: " + this + " not yet handled");

        	}

        }

    }

    public boolean isValid();

    /**

     * Factory method. Creates a new state for the import type and adds this configuration to it.

     * @return

     */

    public <STATE extends ImportStateBase> STATE getNewState();

    /* ****************** GETTER/SETTER **************************/

    /**

     * @return the doReferences

     */

    public CHECK getCheck();

    /**

     * @param doReferences the doReferences to set

     */

    public void setCheck(CHECK check);

    /**

     * @return the editor

     */

    public EDITOR getEditor();

    /**

     * @param editor sets the way how editing (created, updated) information is handled

     */

    public void setEditor(EDITOR editor);

    /**

     * The destination data source for the import

     * Don't use when using a spring data source

     * @return

     */

    public ICdmDataSource getDestination();

    public void setDestination(ICdmDataSource destination);

    @Override

    public DbSchemaValidation getDbSchemaValidation();

    @Override

    public void setDbSchemaValidation(

            DbSchemaValidation dbSchemaValidation);

    /**

     * The reference that represents the source. E.g. if the import source is a database

     * the returned reference should be of type eu.etaxonomy.cdm.model.reference.Database and

     * should represent the according database.

     * If the import comes from a file (e.g. XML) the returned value should best represent the

     * source of this file (e.g. if the source of an XML file is a certain database this database

     * should be mentioned as the source. Otherwise a eu.etaxonomy.cdm.model.reference.Generic

     * reference with the name of the XML file should be returned value

     * @return

     */

    public Reference getSourceReference();

    /**

     * Any object that represents the Source. The implementing class must cast this to

     * the correct class type

     * @return

     */

    public Object getSource();

    //public abstract void setSource(Object url);

    public void setSourceReference(Reference sourceReference);

    public String getSourceReferenceTitle();

    public void setSourceReferenceTitle(String sourceReferenceTitle);

    public Person getCommentator();

    public void setCommentator(Person commentator);

    public NomenclaturalCode getNomenclaturalCode();

    public void setNomenclaturalCode(NomenclaturalCode nomenclaturalCode);

    public Class<ICdmImport>[] getIoClassList();

    public Object getSourceSecId();

     /**

      * If this import implicitly represents a classification in the destination CDM database

      * one can define the classification's uuid here. The congrete import class must support this

      * functionality otherwise it will have no effect.

      * @return

      */

    public UUID getClassificationUuid();

    public void setClassificationUuid(UUID treeUuid);

    /**

      * If one wants do define the uuid of the accepted taxa (except for missaplied names) this can be

      * done here

      * @return

      */

     public UUID getSecUuid();

    public void setSecUuid(UUID secUuid);

    /**

     * Returns the transformer used during import

     * @return

     */

    public IInputTransformer getTransformer();

    /**

     * Sets the transformer used during import

     * @param transformer

     */

    public void setTransformer(IInputTransformer transformer);

    /**

     * Defines if term loading should take place if a new application controller

     * is created. Usually should return false as imports run into existing databases.

     * However, some imports like the current implementation of the JAXB import require

     * to create ALL data anew and import the data itself. Therefore they need to

     * allow omitting term loading.

     * This may be replaced by a more sophisticated solution in future.

     * @return

     */

    public boolean isOmitTermLoading();

    /**

     * Defines if the database will be created anew. Usually should return false as imports

     * run into existing databases.

     * However, some imports like the current implementation of the JAXB import require

     * to create ALL data anew. Therefore they need to allow to create all data anew.

     * This may be replaced by a more sophisticated solution in future.

     * @return

     */

    public boolean isCreateNew();

}

}

/**

* Copyright (C) 2007 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.common;

import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;

import eu.etaxonomy.cdm.common.IoResultBase;

/**

 * @author a.mueller

 * @since 11.05.2009

 */

public abstract class IoStateBase<CONFIG

        extends IIoConfigurator, IO extends ICdmIO, RESULT extends IoResultBase> {

	@SuppressWarnings("unused")

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

	private IO currentIO;

	protected CONFIG config;

	private RESULT result;

    //TODO config not necessary ones it it implemented in constructor for IOs too.

	public void initialize(CONFIG config){

	    this.config = config;

	}

	public CONFIG getConfig() {

		return config;

	}

	public void setConfig(CONFIG config) {

		this.config = config;

	}

	public void setCurrentIO(IO currentIO) {

		this.currentIO = currentIO;

	}

	public IO getCurrentIO() {

		return currentIO;

	}

    public RESULT getResult() {

        return result;

    }

    public void setResult(RESULT result) {

        this.result = result;

    }

//    public IProgressMonitor getCurrentMonitor() {

//        return currentMonitor;

//    }

//    public void setCurrentMonitor(IProgressMonitor currentMonitor) {

//        this.currentMonitor = currentMonitor;

//    }

}

/**

* Copyright (C) 2009 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.common;

import eu.etaxonomy.cdm.common.URI;

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

/**

 * @author a.mueller

 * @since 28.06.2011

 */

//<ImportConfiguratorBase, XmlImportBase>

public abstract class XmlImportConfiguratorBase<STATE extends XmlImportState> extends ImportConfiguratorBase<STATE, URI> {

	public XmlImportConfiguratorBase(IInputTransformer transformer) {

		super(transformer);

	}

/**

* Copyright (C) 2007 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.common;

import javax.xml.stream.XMLEventReader;

import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;

/**

 * @author a.mueller

 * @since 11.05.2009

 */

public class XmlImportState<CONFIG extends XmlImportConfiguratorBase, IO extends XmlImportBase> extends ImportStateBase<CONFIG, IO> {

	@SuppressWarnings("unused")

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

	private XMLEventReader reader;

	public XmlImportState(CONFIG config) {

		super(config);

	}

	/**

	 * @return the reader

	 */

	public XMLEventReader getReader() {

		return reader;

	}

	public void setReader(XMLEventReader reader) {

		this.reader = reader;

	}

}

}

/**

* Copyright (C) 2007 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.sdd.in;

import java.io.InputStream;

import java.net.MalformedURLException;

import eu.etaxonomy.cdm.common.URI;

import java.net.URL;

import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;

import org.jdom.Element;

import org.jdom.Namespace;

import eu.etaxonomy.cdm.common.XmlHelp;

import eu.etaxonomy.cdm.database.ICdmDataSource;

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

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

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

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

import eu.etaxonomy.cdm.io.sdd.SDDTransformer;

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

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

/**

 * @author h.fradin

 * @since 24.10.2008

 */

public class SDDImportConfigurator extends XmlImportConfiguratorBase<SDDImportState> implements IImportConfigurator, IMatchingImportConfigurator {

    private static final long serialVersionUID = -960998183005112130L;

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

	//TODO

	private static IInputTransformer defaultTransformer = new SDDTransformer();

	private boolean doMatchTaxa = true;

	//xml xmlNamespace

	Namespace sddNamespace;

	@Override

    protected void makeIoClassList(){

		ioClassList = new Class[]{

				SDDImport.class

		};

	};

	public static SDDImportConfigurator NewInstance(URI uri, ICdmDataSource destination){

		return new SDDImportConfigurator(uri, destination);

	}

	/**

	 * @param berlinModelSource

	 * @param sourceReference

	 * @param destination

	 */

	private SDDImportConfigurator(URI uri, ICdmDataSource destination) {

		super(defaultTransformer);

		setSource(uri);

		setDestination(destination);

	}

	@Override

    public SDDImportState getNewState() {

		return new SDDImportState(this);

	}

	/**

	 * @return

	 */

	public Element getSourceRoot(){

		try {

			URL url;

			url = getSource().toURL();

			Object o = url.getContent();

			InputStream is = (InputStream)o;

			Element root = XmlHelp.getRoot(is);

			makeNamespaces(root);

			return root;

		} catch (MalformedURLException e) {

			e.printStackTrace();

		}catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

	private boolean makeNamespaces(Element root){

		sddNamespace = root.getNamespace();

		return true;

	}

	@Override

	public Reference getSourceReference() {

		//TODO

		if (this.sourceReference == null){

			logger.warn("getSource Reference not yet fully implemented");

			sourceReference = ReferenceFactory.newDatabase();

			sourceReference.setTitleCache("XXX", true);

		}

		return sourceReference;

	}

	@Override

    public String getSourceNameString() {

		if (this.getSource() == null){

			return null;

		}else{

			return this.getSource().toString();

		}

	}

	public Namespace getSddNamespace() {

		return sddNamespace;

	}

	public void setSddNamespace(Namespace xmlNamespace) {

		this.sddNamespace = xmlNamespace;

	}