D-Net

package gr.uoa.di.web.utils;

import eu.dnetlib.api.data.SearchServiceException;

import eu.dnetlib.domain.ResourceType;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositorySearchCriteria;

	}

	public void init() {

		serviceImpl.subscribe(ActionType.UPDATE, ResourceType.INDEXDSRESOURCETYPE, this);

		serviceImpl.subscribe(ActionType.DELETE, ResourceType.INDEXDSRESOURCETYPE, this);

		serviceImpl.subscribe(ActionType.CREATE, ResourceType.REPOSITORYSERVICERESOURCETYPE, this);

		serviceImpl.subscribe(ActionType.UPDATE, ResourceType.REPOSITORYSERVICERESOURCETYPE, this);

		serviceImpl.subscribe(ActionType.DELETE, ResourceType.REPOSITORYSERVICERESOURCETYPE, this);

		this.executor = Executors.newSingleThreadScheduledExecutor();

		this.executor.scheduleWithFixedDelay(new Updater(), 1, 30, TimeUnit.MINUTES);

	}

		if (enableUpdate) {

			logger.debug("updating driver status...");

			try {

						.getNumberOfDocuments();

				List<Repository> repositories = repositoryLookUp.fetch(new RepositorySearchCriteria());

				Set<String> countries = new HashSet<String>();

import eu.dnetlib.domain.data.Document;

import eu.dnetlib.domain.enabling.Vocabulary;

import eu.dnetlib.domain.functionality.DocumentField.Cutpoint;

import gr.uoa.di.web.utils.webdocument.StyledValue;

import java.io.UnsupportedEncodingException;

import java.net.URLEncoder;

public class HTMLGenerator {

	public static Logger logger = Logger.getLogger(HTMLGenerator.class);

		List<StyledValue> htmlValuesList = new ArrayList<StyledValue>();

		int characterCount = 0;

		String fieldName = field.getName();

		generateHTMLValues(fieldName, fieldValues, characterCount, document,

				htmlValuesList, field, vocabulary, locale);

		return htmlValuesList;

		for (int i = 0; i < fieldValues.size()

				&& (characterCount < maxCharacters); i++) {

			if (vocabulary != null) {

				String englishName = vocabulary.getEnglishName(fieldValue);

				if (englishName != null) {

import eu.dnetlib.domain.EPR;

import eu.dnetlib.domain.data.BrowseData;

import eu.dnetlib.domain.data.Document;

import eu.dnetlib.domain.functionality.LayoutField;

import gr.uoa.di.driver.data.browsedata.BrowseDataUtil;

import gr.uoa.di.driver.enabling.resultset.ResultSet;

import gr.uoa.di.web.utils.search.query.QueryEnhancer;

import org.apache.log4j.Logger;

/**

 * Manages all searches in the the web interface. All elements in query forms

	 */

	public DocumentPage search(String query, int pageSize, int pageNumber)

			throws SearchServiceException {

		logger.debug("performing search with query = '" + query + "'");

		try {

			tLogger.debug("performing search");

			// update page from result set

			return page;

			throw new SearchServiceException(

					"Error connecting to search service.", re);

		}

		logger.info("running refine query: '" + query + "' for fields: " + fields);

		tLogger.debug("performing refine");

		tLogger.debug("Creating rs");

		BrowseData data = new BrowseData();

		tLogger.debug("Parsing browse data");

		if (indexVersion.toLowerCase().equals("new")) {

	public Document retrieveDocument(String id) throws SearchServiceException {

		try {

		} catch (Throwable t) {

			throw new SearchServiceException(

					"Cannot retrieve document with id: " + id, t);

			logger.debug("EPR : " + epr.getEpr());

		}

		return documentPage;

	}

 */

package gr.uoa.di.web.utils.search;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

/**

 * TODO : add vocabulary support in document reader

 * 

	public Document read(String xml) {

		Document document = new Document();

			String property = propertyNames.get(i);

			List<String> values = parseExprValues(xml, fieldPaths.get(i));

			//logger.debug( propertyNames.get(i) + " - " +values);

			if (document.getMap().containsKey(property)) {

				document.getMap().get(property).addAll(values);

			} else {

			}

		}	

		return document;

	}

import gr.uoa.di.web.utils.ep.EPManager;

import gr.uoa.di.web.utils.ep.EPManagerException;

import gr.uoa.di.web.utils.ep.domain.Node;

import java.util.ArrayList;

import java.util.List;

public class DocumentProvider {

	private EPManager epManager = null;

			if (xmlDoc != null) {

				Document doc = getDocumentReader().read(xmlDoc);

					logger.debug("Found indexed compound object " + id);

					logger.debug("Updating indexed compound object from dlms " + id);

					//TODO: uncomment went dlms is ready!

 */

package gr.uoa.di.web.utils.search;

import org.apache.log4j.Logger;

/**

 * @author kiatrop

		numberOfDocuments = 0;

		numberOfPages = 1;

	}

	public DocumentPage(List<Document> documents, int pageSize,

			int currentPage, int numberOfDocuments, int numberOfPages) {

		this.documents = documents.toArray(new Document[] {});

		this.pageSize = pageSize;

		this.currentPage = currentPage;

		this.numberOfDocuments = numberOfDocuments;

		this.numberOfPages = numberOfPages;

	}

		// set sizes

		this.pageSize = pageSize;

		if (numberOfDocuments == 0) {

			currentPage = 0;

			// call result set

			int from = (currentPage-1)*pageSize+1;

			int to = (currentPage)*pageSize;

			// parse documents in page

				//logger.debug("list element " + i + ": " + list.get(i));

			}

		}

	}

package gr.uoa.di.web.utils.search;

import eu.dnetlib.domain.enabling.Vocabulary;

import eu.dnetlib.domain.functionality.SearchableDate;

import gr.uoa.di.driver.enabling.vocabulary.VocabularyLoader;

import gr.uoa.di.web.utils.LocaleDescriptionUtil;

import gr.uoa.di.web.utils.search.criterion.DateCriterion;

import gr.uoa.di.web.utils.search.criterion.FieldCriterion;

import gr.uoa.di.web.utils.search.criterion.FieldCriterion.Qualifier;

import gr.uoa.di.web.utils.search.query.Query;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Map;

import java.util.regex.Pattern;

/**

 * Does all the conversions between criteria, cql, url and description of a

package gr.uoa.di.web.utils.weblayout;

import gr.uoa.di.driver.dao.DAOException;

import gr.uoa.di.web.utils.weblayout.dao.WebInterfaceLayoutDao;

public class WebInterfaceLayoutManagerImpl implements WebLayoutManager {

	// private static boolean USE_CUSTOMISED_LAYOUT = false;

                <dependency>

                        <groupId>eu.dnetlib</groupId>

                        <artifactId>uoa-commons</artifactId>

                </dependency>

                <dependency>

                        <groupId>yadda</groupId>