D-Net

package eu.dnetlib.enabling.tools;

import java.io.IOException;

import java.util.Date;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.io.SAXReader;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.ResourceLoaderAware;

import org.springframework.core.io.Resource;

import org.springframework.core.io.ResourceLoader;

import org.springframework.core.io.support.ResourcePatternUtils;

import eu.dnetlib.DnetConstants;

import eu.dnetlib.enabling.is.DnetInformationServiceException;

import eu.dnetlib.enabling.is.registry.schema.ProfileValidator;

import eu.dnetlib.enabling.is.store.ISStore;

import eu.dnetlib.miscutils.datetime.DateUtils;

public class BulkResourceImporter implements ResourceLoaderAware {

	static final Log log = LogFactory.getLog(BulkResourceImporter.class);

	private static boolean initialized = false;

	@Autowired

	private XQueryUtils xqueryUtils;

	@Autowired

	private ProfileValidator profileValidator;

	@Autowired

	private ISStore isStore;

	@Value("TODO")

	private String bootstrapDir;

	private ResourceLoader resourceLoader;

	public void startImport() throws DnetInformationServiceException {

		if (isInitialized()) { return; }

		log.info("Initializing store with some profiles and schemas ...");

		log.info("Loading profiles and schemas from " + bootstrapDir);

		try {

			final long start = System.currentTimeMillis();

			for (final Resource res : ResourcePatternUtils.getResourcePatternResolver(getResourceLoader()).getResources(bootstrapDir + "/**/*.xsd")) {

				registerSchema(res);

			}

			for (final Resource res : ResourcePatternUtils.getResourcePatternResolver(getResourceLoader()).getResources(bootstrapDir + "/**/*.xml")) {

				registerProfile(res);

			}

			log.info("bulk registration finished in: " + ((System.currentTimeMillis() - start) / 1000) + "s");

		} catch (final IOException e) {

			throw new DnetInformationServiceException(e);

		} finally {

			log.info("INITIALIZED");

			setInitialized(true);

		}

	}

	private void registerSchema(final Resource res) throws DnetInformationServiceException {

		final String resourceType = FilenameUtils.getBaseName(res.getFilename());

		try {

			isStore.insertXML(resourceType, xqueryUtils.getRootCollection() + DnetConstants.RESOURCE_TYPES, IOUtils.toString(res.getInputStream()));

			log.info("new schema imported: " + resourceType);

		} catch (final Throwable e) {

			log.error("error importing schema " + res.getFilename(), e);

			throw new DnetInformationServiceException(e);

		}

	}

	private void registerProfile(final Resource res) throws DnetInformationServiceException {

		log.debug("registering profile");

		try {

			final Document doc = (new SAXReader()).read(res.getInputStream());

			final String id = doc.valueOf("//RESOURCE_IDENTIFIER/@value");

			final String type = doc.valueOf("//RESOURCE_TYPE/@value");

			final String coll = xqueryUtils.getCollectionPath(doc);

			final String fileName = xqueryUtils.getFileName(id);

			final String date = new DateUtils(new Date()).getDateAsISO8601String();

			doc.selectSingleNode("//DATE_OF_CREATION/@value").setText(date);

			final String finalDoc = doc.asXML();

			if (profileValidator.isValid(type, finalDoc)) {

				isStore.insertXML(fileName, xqueryUtils.getRootCollection() + coll, finalDoc);

			} else {

				throw new DnetInformationServiceException("Invalid profile");

			}

			log.info("new profile imported: " + xqueryUtils.getRootCollection() + coll + fileName);

		} catch (final Throwable e) {

			log.error("error importing profile " + res.getFilename());

			throw new DnetInformationServiceException(e);

		}

	}

	public boolean isInitialized() {

		return initialized;

	}

	public void setInitialized(final boolean initialized) {

		BulkResourceImporter.initialized = initialized;

	}

	public ResourceLoader getResourceLoader() {

		return resourceLoader;

	}

	@Override

	public void setResourceLoader(final ResourceLoader resourceLoader) {

		this.resourceLoader = resourceLoader;

	}

}

package eu.dnetlib.enabling.tools;

import org.dom4j.Document;

import org.springframework.stereotype.Component;

import eu.dnetlib.miscutils.functional.hash.Hashing;

@Component

public class XQueryUtils {

	public String getCollectionAbsPath(final Document doc) {

		return getRootCollection() + getCollectionPath(doc);

	}

	public String getCollectionPath(final Document doc) {

		final StringBuilder buffer = new StringBuilder();

		buffer.append(doc.valueOf("//RESOURCE_KIND/@value"));

		buffer.append('/');

		buffer.append(doc.valueOf("//RESOURCE_TYPE/@value"));

		return buffer.toString();

	}

	public String getRootCollection() {

		return "/db/DRIVER/";

	}

	public String getFileName(final Document doc) {

		return doc.valueOf("//RESOURCE_IDENTIFIER/@value").split("_")[0];

	}

	public String getCollectionName(final String resId) {

		final String[] components = resId.split("_");

		if (components.length == 1) { return "DefaultCollection"; }

		return Hashing.decodeBase64(components[1]);

	}

	public String getFileName(final String resId) {

		return resId.split("_")[0];

	}

	public String createResourceId(final String fileName, final String coll) {

		return fileName + "_" + Hashing.encodeBase64(coll);

	}

}

package eu.dnetlib.enabling.is;

/**

 * Created by sandro on 3/16/16.

 */

public class DnetInformationServiceException extends Exception {

	/**

	 *

	 */

	private static final long serialVersionUID = 1L;

	public DnetInformationServiceException() {

		super();

	}

	public DnetInformationServiceException(final String message) {

		super(message);

	}

	public DnetInformationServiceException(final Throwable e) {

		super(e);

	}

	public DnetInformationServiceException(final String message, final Throwable cause) {

		super(message, cause);

	}

}

package eu.dnetlib.enabling.is.controller; // NOPMD

import java.io.StringReader;

import java.util.Date;

import java.util.UUID;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.io.SAXReader;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Required;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;

import eu.dnetlib.DnetConstants;

import eu.dnetlib.enabling.annotations.DnetService;

import eu.dnetlib.enabling.annotations.DnetServiceType;

import eu.dnetlib.enabling.is.DnetInformationServiceException;

import eu.dnetlib.enabling.is.registry.schema.ProfileValidator;

import eu.dnetlib.enabling.is.store.ISStore;

import eu.dnetlib.enabling.tools.XQueryUtils;

import eu.dnetlib.miscutils.datetime.DateUtils;

import eu.dnetlib.miscutils.functional.hash.Hashing;

import eu.dnetlib.services.BaseService;

@RestController("/register")

@DnetService(DnetServiceType.IS_REGISTRY)

public class ISRegistryController extends BaseService {

	private static final Log log = LogFactory.getLog(ISRegistryController.class); // NOPMD by marko on 11/24/08 5:02 PM

	@Autowired

	private ISStore isStore;

	@Autowired

	private ProfileValidator profileValidator;

	@Autowired

	private XQueryUtils xqueryUtils;

	@RequestMapping(value = "schema/{name}", method = RequestMethod.POST)

	public boolean registerSchema(@PathVariable("name") final String resourceType, @RequestBody final String resourceSchema)

			throws DnetInformationServiceException {

		return isStore.insertXML(resourceType, xqueryUtils.getRootCollection() + DnetConstants.RESOURCE_TYPES, resourceSchema);

	}

	@RequestMapping(value = "schema/{name}", method = RequestMethod.DELETE)

	public boolean deleteSchema(@PathVariable("name") final String resourceType) throws DnetInformationServiceException {

		return isStore.deleteXML(resourceType, xqueryUtils.getRootCollection() + DnetConstants.RESOURCE_TYPES);

	}

	@RequestMapping(value = "profile/{id}", method = RequestMethod.DELETE)

	public boolean deleteProfile(@PathVariable("id") final String resId) throws DnetInformationServiceException {

		final boolean res = isStore.deleteXML(xqueryUtils.getFileName(resId), "/db/DRIVER/" + xqueryUtils.getCollectionName(resId));

		if (!res) { throw new DnetInformationServiceException("document " + resId + " not found"); }

		return true;

	}

	@RequestMapping(value = "profile", method = RequestMethod.POST)

	public String registerProfile(@RequestBody final String profile) throws DnetInformationServiceException {

		log.debug("registering profile");

		try {

			final Document doc = (new SAXReader()).read(new StringReader(profile));

			final String coll = xqueryUtils.getCollectionPath(doc);

			final String fileName = UUID.randomUUID().toString();

			final String newId = fileName + "_" + Hashing.encodeBase64(coll);

			final String date = new DateUtils(new Date()).getDateAsISO8601String();

			final String type = doc.valueOf("//RESOURCE_TYPE/@value");

			doc.selectSingleNode("//RESOURCE_IDENTIFIER/@value").setText(newId);

			doc.selectSingleNode("//DATE_OF_CREATION/@value").setText(date);

			final String finalDoc = doc.asXML();

			if (profileValidator.isValid(type, finalDoc)) {

				isStore.insertXML(fileName, xqueryUtils.getRootCollection() + coll, finalDoc);

				return newId;

			} else {

				throw new DnetInformationServiceException("Invalid profile");

			}

		} catch (final DocumentException e) {

			throw new DnetInformationServiceException(e);

		}

	}

	@RequestMapping(value = "profile/{id}", method = RequestMethod.POST)

	public boolean updateProfile(@PathVariable("id") final String resId, @RequestBody final String profile) throws DnetInformationServiceException {

		try {

			final String fileName = xqueryUtils.getFileName(resId);

			final String fileColl = xqueryUtils.getRootCollection() + xqueryUtils.getCollectionName(resId);

			final String oldProfileSrc = isStore.getXML(fileName, fileColl);

			if (oldProfileSrc == null) { throw new DnetInformationServiceException("cannot update a non existing profile " + resId); }

			final Document doc = (new SAXReader()).read(new StringReader(profile));

			final String coll = xqueryUtils.getCollectionPath(doc);

			final String date = new DateUtils(new Date()).getDateAsISO8601String();

			final String type = doc.valueOf("//RESOURCE_TYPE/@value");

			doc.selectSingleNode("//RESOURCE_IDENTIFIER/@value").setText(resId);

			doc.selectSingleNode("//DATE_OF_CREATION/@value").setText(date);

			final String finalDoc = doc.asXML();

			if (profileValidator.isValid(type, finalDoc)) {

				isStore.insertXML(fileName, xqueryUtils.getRootCollection() + coll, finalDoc);

				return true;

			} else {

				throw new DnetInformationServiceException("Invalid profile");

			}

		} catch (final DocumentException e) {

			throw new DnetInformationServiceException(e);

		}

	}

	@RequestMapping("xupdate")

	public boolean executeXUpdate(@RequestParam("q") final String xquery) throws DnetInformationServiceException {

		return isStore.executeXUpdate(xquery);

	}

	public XQueryUtils getXqueryUtils() {

		return xqueryUtils;

	}

	@Required

	public void setXqueryUtils(final XQueryUtils xqueryUtils) {

		this.xqueryUtils = xqueryUtils;

	}

}

package eu.dnetlib.enabling.is.controller;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.MediaType;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;

import eu.dnetlib.DnetConstants;

import eu.dnetlib.enabling.annotations.DnetService;

import eu.dnetlib.enabling.annotations.DnetServiceType;

import eu.dnetlib.enabling.is.DnetInformationServiceException;

import eu.dnetlib.enabling.is.store.ISStore;

import eu.dnetlib.enabling.tools.XQueryUtils;

import eu.dnetlib.services.BaseService;

@RestController("/lookup")

@DnetService(DnetServiceType.IS_LOOKUP)

public class ISLookUpController extends BaseService {

	// private static final String DB_BASE_DIR = "/db/DRIVER";

	private static final String PROFILE_NOT_FOUND = "Profile not found";

	private static final Log log = LogFactory.getLog(ISLookUpController.class); // NOPMD by marko on 11/24/08 5:02 PM

	@Autowired

	private ISStore isStore;

	@Autowired

	private XQueryUtils xqueryUtils;

	@RequestMapping(value = "profile/{id}", produces = MediaType.APPLICATION_XML_VALUE)

	public String getProfile(@PathVariable("id") final String profId) throws DnetInformationServiceException {

		if (StringUtils.isBlank(profId)) { throw new DnetInformationServiceException("Invalid null profile ID: " + profId); }

		final String res = isStore.getXML(

				xqueryUtils.getFileName(profId),

				xqueryUtils.getRootCollection() + xqueryUtils.getCollectionName(profId));

		if (res == null) { throw new DnetInformationServiceException("document " + profId + " not found"); }

		return res;

	}

	@RequestMapping(value = "findOne", produces = MediaType.TEXT_PLAIN_VALUE)

	public String findOne(@RequestParam("q") final String xquery) throws DnetInformationServiceException {

		final String resource = isStore.getXMLbyQuery(xquery);

		if ((resource == null) || resource.isEmpty()) { throw new DnetInformationServiceException(PROFILE_NOT_FOUND); }

		return resource;

	}

	@RequestMapping(value = "schema/{name}", produces = MediaType.APPLICATION_XML_VALUE)

	public String getSchema(@PathVariable("name") final String resourceType) throws DnetInformationServiceException {

		if (StringUtils.isBlank(resourceType)) { throw new DnetInformationServiceException("Invalid resourceType"); }

		return isStore.getXML(resourceType, xqueryUtils.getRootCollection() + DnetConstants.RESOURCE_TYPES);

	}

	@RequestMapping("schemas")

	public List<String> listSchemas() throws DnetInformationServiceException {

		return isStore.getFileNames(xqueryUtils.getRootCollection() + "/" + DnetConstants.RESOURCE_TYPES);

	}

	@RequestMapping(value = "find", produces = MediaType.TEXT_PLAIN_VALUE)

	public List<String> find(@RequestParam("q") final String xquery) throws DnetInformationServiceException {

		return isStore.quickSearchXML(xquery);

	}

}

package eu.dnetlib.enabling.is;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class DnetInformationServiceApplication {

	public static void main(final String[] args) {

		SpringApplication.run(DnetInformationServiceApplication.class, args);

	}

}

package eu.dnetlib.enabling.is.registry;

import javax.xml.xpath.XPathExpressionException;

public interface ResourceKindResolver {

	String getNormalKindForType(final String resourceType) throws XPathExpressionException;

	String getPendingKindForType(final String resourceType) throws XPathExpressionException;

}

package eu.dnetlib.enabling.is.registry;

import javax.xml.xpath.XPathExpressionException;

/**

 * Uses current driver convention and tries to guess the correct resource kinds (both normal and pending) depending on

 * the resource type name.

 * 

 * @author marko

 * 

 */

public class NameBasedResourceKindResolver implements ResourceKindResolver {

	/** 

	 * {@inheritDoc}

	 * @see eu.dnetlib.enabling.is.registry.ResourceKindResolver#getNormalKindForType(java.lang.String)

	 */

	@Override

	public String getNormalKindForType(final String resourceType) throws XPathExpressionException {

		if (isService(resourceType))

			return "ServiceResources";

		return generateKind(resourceType);

	}

	/** 

	 * {@inheritDoc}

	 * @see eu.dnetlib.enabling.is.registry.ResourceKindResolver#getPendingKindForType(java.lang.String)

	 */

	@Override

	public String getPendingKindForType(final String resourceType) throws XPathExpressionException {

		if (isService(resourceType))

			return "PendingServiceResources";

		return "PendingDSResources";

	}

	private boolean isService(final String resourceType) {

		return resourceType.matches(".*ServiceResourceType$");

	}

	private String generateKind(final String resourceType) {

		return resourceType.replaceAll("ResourceType$", "Resources");

	}

}

package eu.dnetlib.enabling.is.registry.schema;

import java.io.StringReader;

import javax.xml.XMLConstants;

import javax.xml.transform.stream.StreamSource;

import javax.xml.validation.Schema;

import javax.xml.validation.SchemaFactory;

import javax.xml.validation.Validator;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import org.xml.sax.SAXException;

import eu.dnetlib.DnetConstants;

import eu.dnetlib.enabling.is.DnetInformationServiceException;

import eu.dnetlib.enabling.is.store.ISStore;

import eu.dnetlib.enabling.tools.XQueryUtils;

@Component

public class ProfileValidator {

	private static final Log log = LogFactory.getLog(ProfileValidator.class);

	@Autowired

	private ISStore isStore;

	@Autowired

	private XQueryUtils xqueryUtils;

	public boolean isValid(final String type, final String profile) {

		final Schema schema = getSchema(type);

		if (schema == null) { return false; }

		final Validator validator = schema.newValidator();

		try {

			// hack to workaround for #1500

			validator.validate(new StreamSource(new StringReader(profile)));

			return true;

		} catch (final Throwable e) {

			log.warn("The profile is not valid");

			return false;

		}

	}

	private Schema getSchema(final String resourceType) {

		try {

			if (StringUtils.isBlank(resourceType)) { throw new DnetInformationServiceException("Invalid resourceType"); }

			final String schemaSource = isStore.getXML(resourceType, xqueryUtils.getRootCollection() + DnetConstants.RESOURCE_TYPES);

			if ((schemaSource == null) || schemaSource.isEmpty()) {

				log.warn("cannot find resource type " + resourceType);

				return null;

			}

			return SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI).newSchema(new StreamSource(new StringReader(schemaSource)));

		} catch (final DnetInformationServiceException e) {

			log.warn("cannot find resource type " + resourceType, e);

			return null;

		} catch (final SAXException e) {

			log.fatal("cannot parse resource type schema " + resourceType, e);

			return null;

		}

	}

}

package eu.dnetlib.enabling.is.registry;

public class NoSuchPendingCategoryException extends IllegalStateException {

	public NoSuchPendingCategoryException(String message) {

		super(message);

	}

	/**

	 * 

	 */

	private static final long serialVersionUID = 6934748076388947172L;

}

package eu.dnetlib.enabling.is.registry;

import java.util.List;

import javax.xml.xpath.XPathExpressionException;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Required;

/**

 * Returns the first resource resolver

 * 

 * @author marko

 * 

 */

public class ResourceKindResolverChain implements ResourceKindResolver {

	private static final Log log = LogFactory.getLog(ResourceKindResolverChain.class); // NOPMD by marko on 11/24/08 5:02 PM

	/**

	 * resolvers.

	 */

	private List<ResourceKindResolver> resolvers;

	@Override

	public String getNormalKindForType(final String resourceType) throws XPathExpressionException {

		for (final ResourceKindResolver resolver : resolvers) {

			final String res = resolver.getNormalKindForType(resourceType);

			if (res != null)

				return res;

		}

		return null;

	}

	@Override

	public String getPendingKindForType(final String resourceType) throws XPathExpressionException {

		for (final ResourceKindResolver resolver : resolvers) {

			try {

				final String res = resolver.getPendingKindForType(resourceType);

				if (res != null)

					return res;

			} catch (NoSuchPendingCategoryException e) {

				log.debug("resolver didn't find pending category", e);

				continue;

			}

		}

		log.debug("cannot find pending category because no resolver found a pending category");

		throw new NoSuchPendingCategoryException("no pending category for " + resourceType);

	}

	public List<ResourceKindResolver> getResolvers() {

		return resolvers;

	}

	@Required

	public void setResolvers(final List<ResourceKindResolver> resolvers) {

		this.resolvers = resolvers;

	}

}

package eu.dnetlib.enabling.is.registry;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathExpressionException;

import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;

import org.xml.sax.SAXException;

/**

 * Resolves resource kinds (pending and normal from the application profile xml file).

 * 

 * @author marko

 * 

 */

public class ApplicationProfileResourceKindResolver implements ResourceKindResolver {

	/**

	 * information space application profile. Contains, among others, mappings for the.. TODO: move to a DAO.

	 * 

	 */

	private Document appProfile;

	public ApplicationProfileResourceKindResolver() {

		try {

			appProfile = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(

					getClass().getResourceAsStream("DRIVERInformationSpaceApplicationProfile.xml"));

		} catch (SAXException e) {

			throw new IllegalStateException("cannot parse information space application profile", e);

		} catch (IOException e) {

			throw new IllegalStateException("cannot parse information space application profile", e);

		} catch (ParserConfigurationException e) {

			throw new IllegalStateException("cannot parse information space application profile", e);

		}

	}

	/**

	 * get the default resource kind associated with a given resource type.

	 * 

	 * @param resourceType

	 *            resource type

	 * @return resourceType

	 * @throws XPathExpressionException

	 *             happens?

	 */

	@Override

	public String getNormalKindForType(final String resourceType) throws XPathExpressionException {

		final XPath xpath = XPathFactory.newInstance().newXPath();

		final String res = xpath.evaluate("//RESOURCE_TYPE[text() = '" + resourceType + "']/../../RESOURCE_KIND", appProfile);

		if (res.isEmpty())

			return null;

		return res;

	}

	/**

	 * find the associated pending typology for a given resource type.

	 * 

	 * @param resourceType

	 *            resource type

	 * @return pending resource kind

	 * @throws XPathExpressionException

	 *             shouldn't happen

	 */

	@Override

	public String getPendingKindForType(final String resourceType) throws XPathExpressionException {

		final XPath xpath = XPathFactory.newInstance().newXPath();

		final String res = xpath.evaluate("//RESOURCE_TYPE[text() = '" + resourceType + "']/../../PENDING_TYPOLOGY", appProfile);

		if (res.isEmpty())

			throw new NoSuchPendingCategoryException("no pending category for " + resourceType);

		return res;

	}

}

package eu.dnetlib.enabling.is.store;

import java.util.List;

import eu.dnetlib.enabling.is.DnetInformationServiceException;

public interface ISStore {

	boolean createFileColl(String fileColl) throws DnetInformationServiceException;

	boolean deleteFileColl(String fileColl) throws DnetInformationServiceException;

	boolean deleteXML(String fileName, String fileColl) throws DnetInformationServiceException;

	boolean executeXUpdate(String query) throws DnetInformationServiceException;

	List<String> getFileColls() throws DnetInformationServiceException;

	List<String> getFileNames(String fileColl) throws DnetInformationServiceException;

	String getXML(String fileName, String fileColl) throws DnetInformationServiceException;

	String getXMLbyQuery(String query) throws DnetInformationServiceException;

	boolean insertXML(String fileName, String fileColl, String file) throws DnetInformationServiceException;

	List<String> quickSearchXML(String query) throws DnetInformationServiceException;

	boolean updateXML(String fileName, String fileColl, String file) throws DnetInformationServiceException;

	String backup() throws DnetInformationServiceException;

}

package eu.dnetlib.enabling.is.store;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.xmldb.api.base.XMLDBException;

import eu.dnetlib.enabling.is.DnetInformationServiceException;

import eu.dnetlib.xml.database.XMLDatabase;

public class ISStoreImpl implements ISStore {

	private static final Log log = LogFactory.getLog(ISStoreImpl.class); // NOPMD by marko on 11/24/08 4:46 PM

	private XMLDatabase xmlDatabase;

	@Override

	public boolean createFileColl(final String fileColl) throws DnetInformationServiceException {

		try {

			xmlDatabase.createCollection(fileColl);

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

		return true;

	}

	@Override

	public boolean deleteFileColl(final String fileColl) throws DnetInformationServiceException {

		try {

			xmlDatabase.removeCollection(fileColl);

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

		return true;

	}

	@Override

	public boolean deleteXML(final String fileName, final String fileColl) throws DnetInformationServiceException {

		try {

			return xmlDatabase.remove(fileName, fileColl);

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

	}

	@Override

	public boolean executeXUpdate(final String query) throws DnetInformationServiceException {

		try {

			xmlDatabase.xupdate(query);

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException("Error while executing xupdate " + query, e);

		}

		return true;

	}

	@Override

	public List<String> getFileColls() throws DnetInformationServiceException {

		try {

			return xmlDatabase.listChildCollections(xmlDatabase.getRootCollection());

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

	}

	@Override

	public List<String> getFileNames(final String fileColl) throws DnetInformationServiceException {

		try {

			return xmlDatabase.list(fileColl);

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

	}

	@Override

	public String getXML(final String fileName, final String fileColl) throws DnetInformationServiceException {

		try {

			return xmlDatabase.read(fileName, fileColl);

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

	}

	@Override

	public String getXMLbyQuery(final String query) throws DnetInformationServiceException {

		log.debug(query);

		try {

			final Iterator<String> xquery = xmlDatabase.xquery(query);

			if ((xquery != null) && xquery.hasNext()) { return xquery.next(); }

			return null;

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

	}

	@Override

	public boolean insertXML(final String fileName, final String fileColl, final String file) throws DnetInformationServiceException {

		try {

			xmlDatabase.create(fileName, fileColl, file);

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

		return true;

	}

	@Override

	public List<String> quickSearchXML(final String query) throws DnetInformationServiceException {

		log.debug(query);

		try {

			final Iterator<String> res = xmlDatabase.xquery(query);

			if (res == null) { return new ArrayList<>(); }

			final ArrayList<String> ans = new ArrayList<>();

			res.forEachRemaining(ans::add);

			return ans;

		} catch (final XMLDBException e) {

			log.fatal("searching", e);

			throw new DnetInformationServiceException(e);

		}

	}

	@Override

	public boolean updateXML(final String fileName, final String fileColl, final String file) throws DnetInformationServiceException {

		try {

			xmlDatabase.update(fileName, fileColl, file);

		} catch (final XMLDBException e) {

			throw new DnetInformationServiceException(e);

		}

		return true;

	}

	@Override

	public String backup() throws DnetInformationServiceException {

		try {

			return xmlDatabase.backup();

		} catch (final Exception e) {

			throw new DnetInformationServiceException(e);

		}

	}

	public XMLDatabase getXmlDatabase() {

		return xmlDatabase;

	}

	public void setXmlDatabase(final XMLDatabase xmlDatabase) {

		this.xmlDatabase = xmlDatabase;

	}

}

package eu.dnetlib.xml.database; // NOPMD

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringReader;

import java.io.StringWriter;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.exist.util.DatabaseConfigurationException;

import org.exist.xmldb.DatabaseImpl;

import org.exist.xmldb.DatabaseInstanceManager;

import org.exist.xmldb.EXistResource;

import org.exist.xmldb.XmldbURI;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Required;

import org.springframework.context.Lifecycle;

import org.xmldb.api.DatabaseManager;

import org.xmldb.api.base.Collection;

import org.xmldb.api.base.Database;

import org.xmldb.api.base.Resource;

import org.xmldb.api.base.ResourceIterator;

import org.xmldb.api.base.ResourceSet;

import org.xmldb.api.base.XMLDBException;

import org.xmldb.api.modules.CollectionManagementService;

import org.xmldb.api.modules.XPathQueryService;

import eu.dnetlib.enabling.is.DnetInformationServiceException;

import eu.dnetlib.enabling.tools.BulkResourceImporter;

import eu.dnetlib.exceptions.DnetGenericRuntimeException;

import eu.dnetlib.miscutils.datetime.DateUtils;

/**

 * eXist database wrapper.

 *

 * @author marko

 *

 */

public abstract class ExistDatabase implements XMLDatabase, Lifecycle { // NOPMD by marko

	private static final Log log = LogFactory.getLog(ExistDatabase.class); // NOPMD

	private static final String XML_RESOURCE = "XMLResource";

	private static final String CONFIG_TEMPLATE_FILE = "default-exist-conf.xml";

	private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

	private final Lock readLock = rwl.readLock();

	private final Lock writeLock = rwl.writeLock();

	private Database database;

	private Collection root;

	private DatabaseInstanceManager manager;

	private XPathQueryService queryService;

	private CollectionManagementService colman;

	private String configFile;

	private String backupDir;

	@Autowired

	private BulkResourceImporter bulkImporter;

	private transient File dbDirectory;

	private File existConfigFile;

	private boolean xQueryJavaEnabled;

	@Override

	public void start() {

		log.info("starting database");

		try {

			dbDirectory = getDatabaseDirectory();

			if (dbDirectory.exists()) {

				existConfigFile = new File(dbDirectory, "conf.xml");

				enableJava(existConfigFile, isXQueryJavaEnabled());

				setConfigFile(existConfigFile.getAbsolutePath());

				bulkImporter.setInitialized(true);

			} else {

				createDatabase();

			}

			if (getDatabase() == null) {

				setDatabase(new DatabaseImpl());

				getDatabase().setProperty("configuration", getConfigFile());

				getDatabase().setProperty("create-database", "true");

			}

			DatabaseManager.registerDatabase(getDatabase());

			setRoot(DatabaseManager.getCollection("xmldb:exist://" + getRootCollection(), "admin", ""));

			setManager((DatabaseInstanceManager) getRoot().getService("DatabaseInstanceManager", "1.0"));

			setQueryService((XPathQueryService) getRoot().getService("XPathQueryService", "1.0"));

			setColman((CollectionManagementService) getRoot().getService("CollectionManagementService", "1.0"));

			if (!bulkImporter.isInitialized()) {

				bulkImporter.startImport();

			}

		} catch (final XMLDBException | DnetInformationServiceException e) {

			throw new DnetGenericRuntimeException("cannot open eXist database", e);

		}

	}

	abstract protected File getDatabaseDirectory();

	protected void enableJava(final File conf, final boolean enabled) {

		final StringWriter buffer = new StringWriter();

		if (conf.exists()) {

			try {

				IOUtils.copy(new FileReader(conf), buffer);

				final String newConf = patchConfigFileEnableJava(buffer.toString(), enabled);

				if (!newConf.equals(buffer.toString())) {

					final FileWriter writer = new FileWriter(conf);

					try {

						IOUtils.copy(new StringReader(newConf), writer);

					} finally {

						writer.close();

					}

				}

			} catch (final FileNotFoundException e) {

				log.warn("cannot patch eXist conf file", e);

			} catch (final IOException e) {

				log.warn("cannot patch eXist conf file", e);

			}

		}

	}

	protected String patchConfigFileEnableJava(final String conf, final boolean enabled) {

		return conf.replaceAll("enable-java-binding=\"[^\"]*\"", "enable-java-binding=\"" + (enabled ? "yes" : "no") + "\"");

	}

	protected Collection getCollection(final String collection) throws XMLDBException {

		readLock.lock();

		try {

			if (!collection.startsWith("/db")) { throw new XMLDBException(0, "collection path should begin with /db"); }

			return database.getCollection("exist://" + collection, "admin", "");

		} finally {

			readLock.unlock();

		}

	}

	protected void createDatabase() {

		log.debug("creating database in " + dbDirectory.getAbsolutePath());

		try {

			new File(dbDirectory, "data").mkdirs();

			final InputStream defaultConf = getClass().getResourceAsStream(CONFIG_TEMPLATE_FILE);

			if (defaultConf == null) { throw new IOException("cannot find " + CONFIG_TEMPLATE_FILE); }

			existConfigFile = new File(dbDirectory, "conf.xml");

			final FileOutputStream confOutput = new FileOutputStream(existConfigFile);

			try {

				IOUtils.copy(defaultConf, confOutput);

			} finally {

				confOutput.close();

			}

			enableJava(existConfigFile, isXQueryJavaEnabled());

			setConfigFile(existConfigFile.getAbsolutePath());

		} catch (final IOException e) {

			log.fatal("Error creating database dir", e);

			throw new DnetGenericRuntimeException(e);

		}

		log.debug("database created");

	}

	@Override

	public void create(final String name, final String collection, final String content) throws XMLDBException {

		writeLock.lock();

		try {

			if ("".equals(name)) { throw new XMLDBException(0, "cannot create a xml file with an empty file name"); }

			Collection col = getCollection(collection);

			if (col == null) {

				// create parent collections

				createCollection(collection, true);

				col = getCollection(collection);

			}

			final Resource res = col.createResource(name, XML_RESOURCE);

			res.setContent(content);

			col.storeResource(res);

			((EXistResource) res).freeResources();

			col.close();

		} finally {

			writeLock.unlock();

		}

	}

	@Override

	public boolean remove(final String name, final String collection) throws XMLDBException {

		writeLock.lock();

		try {

			final Collection col = getCollection(collection);

			final Resource res = col.getResource(name);

			if (res == null) { return false; }

			col.removeResource(res);

			col.close();

			return true;

		} finally {

			writeLock.unlock();

		}

	}

	@Override

	public void update(final String name, final String collection, final String content) throws XMLDBException {

		writeLock.lock();

		try {

			final Collection col = getCollection(collection);

			final Resource res = col.getResource(name);

			if (res == null) { throw new XMLDBException(0, "resource doesn't exist"); }

			res.setContent(content);

			col.storeResource(res);

			((EXistResource) res).freeResources();

			col.close();

		} finally {

			writeLock.unlock();

		}

	}

	@Override

	public String read(final String name, final String collection) throws XMLDBException {

		readLock.lock();

		try {

			Resource res = null;

			final Collection coll = getCollection(collection);

			try {

				if (coll == null) { return null; }

				res = coll.getResource(name);

				if (res != null) { return (String) res.getContent(); }

				return null;

			} finally {

				if (res != null) {

					((EXistResource) res).freeResources();

				}

				coll.close();

			}

		} finally {

			readLock.unlock();

		}

	}

	@Override

	public Iterator<String> xquery(final String query) throws XMLDBException {

		readLock.lock();

		try {

			final ResourceSet result = getQueryService().query(query);

			if (result == null) { return null; }

			final ResourceIterator iterator = result.getIterator();

			return new Iterator<String>() {

				@Override

				public boolean hasNext() {

					try {

						return iterator.hasMoreResources();

					} catch (final XMLDBException e) {

						throw new RuntimeException("Error while getting next element", e);

					}

				}

				@Override

				public String next() {

					Resource res = null;

					try {

						res = iterator.nextResource();

						return (String) res.getContent();

					} catch (final XMLDBException e) {

						throw new RuntimeException("Error while getting next element", e);

					} finally {

						if (res != null) {

							try {

								((EXistResource) res).freeResources();

							} catch (final XMLDBException e) {

								log.error("error on free resource");

							}

						}

					}

				}

			};

		} finally {

			readLock.unlock();

		}

	}

	@Override

	public void xupdate(final String query) throws XMLDBException {

		writeLock.lock();

		try {

			getQueryService().query(query);

		} finally {

			writeLock.unlock();

		}

	}

	@Override

	public void stop() {

		log.info("shutting down xmldb...");

		try {

			getManager().shutdown();

			DatabaseManager.deregisterDatabase(database);

			log.info("...xmldb closed");

		} catch (final XMLDBException e) {

			log.fatal("...cannot close database", e);

		}

	}

	@Override

	public boolean collectionExists(final String collection) throws XMLDBException {

		Collection col = null;

		try {

			col = getCollection(collection);

			return col != null;

		} finally {

			if (col != null) {

				col.close();

			}

		}

	}

	@Override

	public void createCollection(final String collection) throws XMLDBException {

		writeLock.lock();

		try {

			createCollection(collection, false);

		} finally {

			writeLock.unlock();

		}

	}

	private void createCollection(final String collection, final boolean recursive) throws XMLDBException {

		if (recursive) {

			final XmldbURI uri = XmldbURI.create(collection).removeLastSegment();

			if (!collectionExists(uri.toString())) {

				createCollection(uri.toString(), true);

			}

		}

		getColman().createCollection(collection);

	}

	@Override

	public void removeCollection(final String collection) throws XMLDBException {

		writeLock.lock();

		try {

			getColman().removeCollection(collection);

		} finally {

			writeLock.unlock();

		}

	}

	public String getConfigFile() {

		return configFile;

	}

	public void setConfigFile(final String configFile) {

		this.configFile = configFile;

	}

	@Override

	public String getBackupDir() {

		return backupDir;

	}

	@Required

	public void setBackupDir(final String backupDir) {

		this.backupDir = backupDir;

	}

	@Override

	public boolean isRunning() {

		return false;

	}

	protected Database getDatabase() {

		return database;

	}

	protected void setDatabase(final Database database) {

		this.database = database;

	}

	protected Collection getRoot() {

		return root;

	}

	protected void setRoot(final Collection root) {

		this.root = root;

	}

	protected DatabaseInstanceManager getManager() {

		return manager;

	}

	protected void setManager(final DatabaseInstanceManager manager) {

		this.manager = manager;

	}

	protected XPathQueryService getQueryService() {

		return queryService;

	}

	protected void setQueryService(final XPathQueryService queryService) {

		this.queryService = queryService;

	}

	protected CollectionManagementService getColman() {

		return colman;

	}

	protected void setColman(final CollectionManagementService colman) {

		this.colman = colman;

	}

	@Override

	public String getRootCollection() {

		return "/db";

	}

	@Override

	public List<String> listChildCollections(final String collection) throws XMLDBException {

		readLock.lock();

		try {

			final Collection col = getCollection(collection);

			if (col == null) { return new ArrayList<>(); }

			return Arrays.asList(col.listChildCollections());

		} finally {

			readLock.unlock();

		}

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.xml.database.XMLDatabase#list(java.lang.String)

	 */

	@Override

	public List<String> list(final String collection) throws XMLDBException {

		readLock.lock();

		try {

			final Collection col = getCollection(collection);

			if (col == null) { return new ArrayList(); }

			return Arrays.asList(col.listResources());

		} finally {

			readLock.unlock();

		}

	}

	@Override

	public String backup() throws XMLDBException, DatabaseConfigurationException {

		log.info("Starting backup...");

		readLock.lock();

		try {

			verifyBackupDir();

			final String seq = (new SimpleDateFormat("yyyyMMdd-HHmm")).format(new Date());

			final ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(backupDir + "/data-" + seq + ".zip"));

			final FileWriter logFile = new FileWriter(backupDir + "/report-" + seq + ".log");

			logFile.write("Backup started at: " + DateUtils.now_ISO8601() + "\n\n");

			backup(getRoot().getName(), zip, logFile);

			logFile.write("\nBackup finished at: " + DateUtils.now_ISO8601() + "\n");

			logFile.flush();

			logFile.close();

			zip.flush();

			zip.close();

			log.info("Backup finished");

			return backupDir;

		} catch (final Exception e) {

			log.error("Backup failed", e);

			throw new XMLDBException(0, "cannot backup", e);

		} finally {

			readLock.unlock();

		}

	}

	private void verifyBackupDir() {

		final File d = new File(backupDir);

		if (!d.exists()) {

			d.mkdirs();

		}

	}

	private void backup(final String coll, final ZipOutputStream zip, final FileWriter logFile) throws XMLDBException, IOException {

		readLock.lock();

		logFile.write("COLLECTION: " + coll + "\n");

		log.info("Backup of collection " + coll);

		try {

			for (final String file : list(coll)) {

				zip.putNextEntry(new ZipEntry(coll + "/" + file + ".xml"));

				final Resource resource = getCollection(coll).getResource(file);

				zip.write(resource.getContent().toString().getBytes());

				zip.closeEntry();