EDIT

  <description>EDIT CDM library - Commons</description>

  <dependencies>

    <dependency>

      <groupId>org.springframework</groupId>

      <artifactId>spring-test</artifactId>

    private static Logger logger = Logger.getLogger(AccountStore.class);

    public static String getAccountsFileName(){

        try {

package eu.etaxonomy.cdm.common;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

/**

 * Util class for consistent access to and creation of per instance application configuration files.

 * @author a.mueller

 * @author a.kohlbecker

 */

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

    /**

     * Returns the an InputStream for a read-only source

     * @param resourceFileName the resources path within the classpath(!)

    }

    /**

     * Returns the file name for the file in which 'clazz' is to be found (helps finding according libraries)

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.nio.file.Files;

import java.util.Properties;

/**

 *

 * @author a.kohlbecker

 * @since May 8, 2017

 *

 */

    /**

     *

     */

    public static final String CDM_CONFIGFILE_OVERRIDE = "cdm.configfile.override.";

    private Properties props = null;

        if(override != null){

            return new File(override);

        } else {

            return new File(configFolder, propertiesSet + ".properties");

        }

    }

package eu.etaxonomy.cdm.common;

import java.util.regex.Pattern;

import org.apache.log4j.Level;

/************************** TESTS ****************************************/

	@Test

	public void testFindLibrary() {

		if (logger.isEnabledFor(Level.DEBUG)) {logger.debug(CdmUtils.findLibrary(CdmUtils.class));}

import au.com.bytecode.opencsv.CSVReader;

import eu.etaxonomy.cdm.common.CdmUtils;

/**

 * @author a.mueller

	private void readMapping(String filename) throws IOException {

		InputStreamReader isr = CdmUtils.getUtf8ResourceReader(strResourceFileName);

		CSVReader reader = new CSVReader(isr, separator);

import au.com.bytecode.opencsv.CSVReader;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.OrderedTermBase;

import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;

	 */

	private CSVReader getCsvReader(VocabularyEnum vocType) throws IOException {

		String filename = vocType.name()+".csv";

		if (logger.isDebugEnabled()){logger.debug("strResourceFileName is " + strResourceFileName);}

		CSVReader reader = new CSVReader(CdmUtils.getUtf8ResourceReader(strResourceFileName));

		return reader;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.common.FileCopy;

import eu.etaxonomy.cdm.config.CdmPersistentXMLSource;

                if (file.exists()){

                    fileResourceDir = file.getParentFile();

                }else{

                    file.mkdirs();

                    copyResources(file);

import org.springframework.core.io.FileSystemResource;

import org.springframework.stereotype.Component;

@Component

public class DataSourceBeanLoader {

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

    private static final String DATASOURCE_BEANDEF_FILE = "datasources.xml";

    private static String userdefinedBeanDefinitionFile = null;

            T datasource = beanFactory.getBean(beanName, requiredType);

            dataSources.put(beanName, datasource);

        }

    }

}

import au.com.bytecode.opencsv.CSVReader;

import eu.etaxonomy.cdm.common.CdmUtils;

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

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.database.update.CaseType;

			for(VocabularyEnum vocabularyEnum : VocabularyEnum.values()) {

				//read vocabulary from terms files

				String filename = vocabularyEnum.name()+".csv";

				String [] nextLine = reader.readNext();

				TermVocabulary<?> voc = TermVocabulary.NewInstance(TermType.Unknown);

				voc.readCsvLine(arrayedLine(nextLine));

import org.jdom.Document;

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

    /**

     * Returns all available stylesheets for this output module.

     *

     * @return a set of xsl files

     * @throws IOException TODO

import org.apache.log4j.Logger;

import org.jdom.Document;

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

/**

 * This abstract implementation of the {@link IPublishOutputModule} contains

 * convenience methods for file path generation. Clients should consider

 * extending this class.

 * @author n.hoffmann

 * @since Apr 20, 2010

 * @version 1.0

	/**

	 * Generates a string containing the current date followed by the given

	 * name.

	 * @param name

	 *            a string.

	 * @return a string containing the current date followed by the given name.

		 */

		if (filePath == null) {

			filePath = getNewFilePath(outputFolder);

			return filePath;

	}

	/**

	 * @author s.buers

	 */

	public String getFilePath() {

		return filePath;

	}

	/**

	 * creates new name for the output file based on the given output

	 * @author s.buers

	 * @param outputFolder

	 * @return

	/*

	 * (non-Javadoc)

	 * @see

	 * eu.etaxonomy.printpublisher.out.IPublishOutputModule#output(org.jdom.

	 * Document, java.io.File)

	 */

			IProgressMonitor progressMonitor) {

		if (progressMonitor == null) {

			throw new IllegalArgumentException(

		locationList.add(shippedStylesheetsDir);

		// TODO this should be configured in a central place, see #2387

				+ l + getOutputFileSuffix());

		locationList.add(userdir);

import org.jdom.output.XMLOutputter;

import org.jdom.xpath.XPath;

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

import eu.etaxonomy.cdm.print.IXMLEntityFactory;

import eu.etaxonomy.cdm.print.PublishConfigurator;

/**

 * fill in all parameters and you get a complete export from a cdm database to a

 * mediawiki

 * TODO would we move this class somewhere else and/or rename it?

 * @author s.buers, l.morris

 */

public class Cdm2MediawikiExporter {

			.getLogger(Cdm2MediawikiExporter.class);

	private PublishConfigurator configurator = PublishConfigurator.NewRemoteInstance();

	private IXMLEntityFactory factory;

	// where the mediawiki xml code is stored

	private List<String> localImages;

	public void export(String serviceUrl, UUID taxonNodeUuid, UUID treeNodeUuid,  String wikiUrl,

			String wikiLoginUid, String passwd, String wikiPageNamespace,

			boolean import2Mediawiki, boolean deleteOutputFiles,

	/**

	 * does the whole export process: runs cdm export to mediawiki xml-file and

	 * wiki import of this file

	 * @param serviceUrl

	 * @param taxonName

	 * @param wikiUrl

	 *            - prefix that, will be added to all pages null or "" will make

	 *            no prefix

	 * @throws MalformedURLException

	 *             TODO: make passwd "unplain" MAYDO: pass more parameters e.g.:

	 *             alternative stylesheet layout parameters (that may force the

	 *             use of different stylesheet) export folder - we use a

				// setup configurator

		setupConfigurator(serviceUrl);

		configurator.addSelectedTaxonNodeElements(factory.getTaxonNodesByName(taxonName, classificationName));

		export(portalUrl, serviceUrl, wikiUrl, wikiLoginUid, passwd,

				wikiPageNamespace, import2Mediawiki, deleteOutputFiles,

				importImages, true);

	}

	/**

	 * the mediawiki xml is created and imported to an mediawiki

	 * does step 2 and 3 out of all 3 export steps

	 * @param filename

	 * @param serviceUrl

	 * @param taxonName

		//put the document to a field:

		externalDocument = getDocument(filename);

//		setupConfigurator(serviceUrl);

		// and run export with usePublisher=false:

		export(portalUrl, serviceUrl, wikiUrl, wikiLoginUid, passwd,

				wikiPageNamespace, import2Mediawiki, deleteOutputFiles,

		// page

		// then it will be the same as the username that is used for the actual

		// mediawiki import.

		// if we actually export from the cdm and not from a file we run the

		// Publisher

		}

		// we get the whole filename that the wikiOutputModule created

				.getFilePath();

		logger.info("mediawiki xml file created and saved to"+mediawikiFileWithPath);

		if ((usePublisher && !deleteOutputFiles) || importImages) {

			// the cdm output where we want to fetch the urls of the

			// images:

					.getInputDocument();

		}

		else{

			logger.info("did not get images!");

		}

		if (import2Mediawiki && importImages && !(localImages.isEmpty())) {

			uploadImagesToMediawiki(wikiUrl, wikiLoginUid, passwd);

		}

		if (deleteOutputFiles) {

			deleteOutputFiles();

			logger.info("deleted temporary file(s)");

	}

	/**

	 */

	private void createTemporaryExportFolder() {

		if (temporaryExportFolder != null) {

			logger.info("using " + temporaryExportFolder.getAbsolutePath()

					+ " as temporary directory.");

	 */

	private void setupConfigurator(String serviceUrl)

			throws MalformedURLException {

		createTemporaryExportFolder();

		configurator.setWebserviceUrl(serviceUrl);

		factory = configurator.getFactory();

		// get feature tree from taxon name/taxon node and pass it to the

		// configurator:

		String featureTree = getDefaultFeatureTree();

		configurator.setFeatureTree(UUID.fromString(featureTree));

		//JDOMParseException Invalid byte 2 of 3-byte UTF-8 sequence which occurs for e.g.

		//with German umlauts and French accents on characters

		format.setEncoding("ISO-8859-1");//"UTF-8");

		try {

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

	/**

	 * uploads a given mediawiki xml file to a mediawiki - does only third (last) step

	 * of the whole export process

	 * @param inputFilePath

	 * @param wikiUrl

	 * @param wikiUser

	private void uploadToMediawiki(String wikiUrl, String wikiLoginUid, String passwd) {

		// login to mediawiki

		WikiBot myBot = getBotAndLogin(wikiUrl, wikiLoginUid, passwd);

		try {

			// parse wiki xml file and import pages one by one

	private void downloadImages() {

		org.jdom.Document document = wikiOutputModule.getInputDocument();

		localImages = new ArrayList<String>();

		try {

			List<Element> media_uris = XPath.selectNodes(document, "//Taxon/media/e/representations/e/parts/e/uri");

			if(media_uris.isEmpty()){

				logger.info("there are no images in the data.");

				return;

			}

			for (Element urlEl : media_uris) {

				String url=urlEl.getValue();

				URL imageUrl = new URL(url);

				String filePath = temporaryExportFolder.getAbsolutePath()

						+FILESEPARATOR + IMAGES_FOLDER +FILESEPARATOR+ filename;

				logger.info("downloading image " + url+" to "+filePath);

				FileUtils.copyURLToFile(imageUrl, new File(filePath));

				localImages.add(filePath);

			}

		} catch (JDOMException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	private void uploadImagesToMediawiki(String wikiUrl, String wikiLoginUid, String passwd) {

		// get published output file

				try {

					uploadImage(myBot, localUri);

				} catch (MalformedURLException e) {

				}

			}

		myBot.logout();

		logger.info("all images uploaded to mediawiki "+wikiUrl+" and logged out.");

	}

////		System.out.println(filePath);

//		File imageFile = new File(filePath);

//		logger.info("downloading image " + url);

//		FileUtils.copyURLToFile(imageUrl, new File(filePath));

		File imageFile = new File(filePath);

		String[] arr = filePath.split("/");

		String filename = arr[arr.length - 1];

	}

	private Document getDocument(String filePath) {

		File file = new File(filePath);

		Document document = null;

		FileInputStream fileis;

		try {

			//document = saxBuilder.build(file);

			fileis = new FileInputStream(file);

			document = saxBuilder.build(in);

		} catch (JDOMException e) {

			// TODO Auto-generated catch block

			logger.error(e.getCause().getMessage());

import com.mchange.v2.c3p0.ComboPooledDataSource;

import eu.etaxonomy.cdm.api.config.CdmConfigurationKeys;

import eu.etaxonomy.cdm.database.WrappedCdmDataSource;

import eu.etaxonomy.cdm.database.update.CdmUpdater;

import eu.etaxonomy.cdm.model.metadata.CdmMetaData;

     */

    public static final String ATTRIBUTE_FORCE_SCHEMA_UPDATE = "cdm.forceSchemaUpdate";

    protected static String beanDefinitionFile = DATASOURCE_BEANDEF_DEFAULT;

    public Properties hibernateProperties(){

        Properties props = getHibernateProperties();

        props.setProperty(HIBERNATE_DIALECT, inferHibernateDialectName());

        props.setProperty(HIBERNATE_SEARCH_DEFAULT_INDEX_BASE,

                searchPath +

                "/index/".replace("/", File.separator) +

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import net.sf.ehcache.config.DiskStoreConfiguration;

/**

    public DiskStoreConfiguration diskStoreConfiguration(){

        DiskStoreConfiguration diskStoreConfiguration = new DiskStoreConfiguration();

        String instanceName = dataSourceProperties.getCurrentDataSourceId();

        File instanceCacheFolder = new File(ehcacheFolder, instanceName);

        logger.debug("Setting ehcache diskstore location to " + instanceCacheFolder.getAbsolutePath());

import org.springframework.core.env.ConfigurableEnvironment;

import org.springframework.web.context.WebApplicationContext;

/**

 * @author a.kohlbecker

            userDefinedProperties = new Properties();

            try {

                InputStream in = new FileInputStream(

                            + java.io.File.separator

                            + CDMLIB_REMOTE_PROPERTIES

                    );

import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

/**

 *

        // Add an inMemoryUserManager to  enable access to the global ROLE_MANAGE_CLIENTs.

        // This is the casue for the need to do the configuration explicitly.

        InMemoryUserDetailsManagerConfigurer<AuthenticationManagerBuilder> inMemoryAuthConf = auth.inMemoryAuthentication();

        if(!managingUsersFile.exists()){

            makeManagingUsersPropertiesFile(managingUsersFile);

        }