D-Net

package eu.dnetlib.enabling.is;

import java.util.Date;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import javax.annotation.Resource;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.lang.math.NumberUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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

import com.google.common.base.Function;

import com.google.common.collect.Iterables;

import com.google.common.collect.Lists;

import eu.dnetlib.common.services.AbstractBaseService;

import eu.dnetlib.common.services.locators.DnetServiceLocator;

import eu.dnetlib.enabling.is.dao.DnetSimpleDao;

import eu.dnetlib.enabling.is.dao.DnetSimpleDaoFactory;

import eu.dnetlib.enabling.is.hib.objects.HibBlackboardMessage;

import eu.dnetlib.enabling.is.hib.objects.HibDatastructure;

import eu.dnetlib.enabling.is.hib.objects.HibDnetResource;

import eu.dnetlib.enabling.is.hib.objects.HibService;

import eu.dnetlib.enabling.is.hib.objects.HibSubscription;

import eu.dnetlib.enabling.is.hib.utils.HibObjectHelper;

import eu.dnetlib.enabling.is.jdbc.DatabaseUtils;

import eu.dnetlib.rmi.objects.is.BlackboardMessage;

import eu.dnetlib.rmi.objects.is.DnetDataStructure;

import eu.dnetlib.rmi.objects.is.DnetResourceFormat;

import eu.dnetlib.rmi.objects.is.DnetResourceKind;

import eu.dnetlib.rmi.objects.is.DnetResourceType;

import eu.dnetlib.rmi.objects.is.DnetService;

import eu.dnetlib.rmi.objects.is.Subscription;

import eu.dnetlib.rmi.soap.InformationService;

import eu.dnetlib.rmi.soap.exceptions.InformationServiceException;

public class InformationServiceImpl extends AbstractBaseService implements InformationService {

	@Resource

	private DnetServiceLocator serviceLocator;

	private DnetSimpleDaoFactory daoFactory;

	private DatabaseUtils dbUtils;

	private HibObjectHelper hibObjectHelper;

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

	@Override

	public String addSubscription(final Subscription subscription) throws InformationServiceException {

		if (StringUtils.isBlank(subscription.getId())) {

			subscription.setId("subscr-" + UUID.randomUUID());

		}

		hibObjectHelper.createHibSubscription(subscription);

		dbUtils.registerNotificationTrigger(subscription.getOperation(), subscription.getTable());

		return subscription.getId();

	}

	@Override

	public boolean deleteSubscription(final String subscriptionId) throws InformationServiceException {

		daoFactory.getDao(HibSubscription.class).delete(subscriptionId);

		return true;

	}

	@Override

	public boolean deleteAllServiceSubscriptions(final String serviceId) {

		dbUtils.update("delete from subscriptions where subscriber = ?", serviceId);

		return true;

	}

	@Override

	public List<Subscription> listSubcriptions() throws InformationServiceException {

		final DnetSimpleDao<HibSubscription> dao = daoFactory.getDao(HibSubscription.class);

		return Lists.transform(dao.list(), new Function<HibSubscription, Subscription>() {

			@Override

			public Subscription apply(final HibSubscription hib) {

				return hib.asDnetSubscription();

			}

		});

	}

	@Override

	public List<DnetService> listServices() throws InformationServiceException {

		final DnetSimpleDao<HibService> dao = daoFactory.getDao(HibService.class);

		return Lists.transform(dao.list(), new Function<HibService, DnetService>() {

			@Override

			public DnetService apply(final HibService hib) {

				return hib.asDnetService();

			}

		});

	}

	@Override

	public String registerService(final DnetService service) throws InformationServiceException {

		final String id = dbUtils.findServiceIdByAddress(service.getProtocols().values());

		service.setId(id != null ? id : "service-" + UUID.randomUUID());

		hibObjectHelper.createHibService(service);

		return service.getId();

	}

	@Override

	public DnetService getService(final String id) throws InformationServiceException {

		final DnetSimpleDao<HibService> dao = daoFactory.getDao(HibService.class);

		final HibService hib = dao.find(id);

		return hib != null ? hib.asDnetService() : null;

	}

	@Override

	public DnetService getServiceByAddress(final String address) throws InformationServiceException {

		final String id = dbUtils.findServiceIdByAddress(address);

		if (id != null) {

			return getService(id);

		} else {

			throw new InformationServiceException(String.format("Too many services with address %s", address));

		}

	}

	@Override

	public boolean deleteService(final String id) throws InformationServiceException {

		daoFactory.getDao(HibService.class).delete(id);

		return true;

	}

	@Override

	public boolean isRegisteredService(final String address) {

		return dbUtils.isRegisteredService(address);

	}

	@Override

	public List<String> searchSql(final String sql) throws InformationServiceException {

		return dbUtils.searchJson(sql);

	}

	@Override

	public String findOneSql(final String sql) throws InformationServiceException {

		return Iterables.getOnlyElement(dbUtils.searchJson(sql));

	}

	@Override

	public int updateSql(final String sql) throws InformationServiceException {

		return dbUtils.update(sql);

	}

	@Override

	public boolean addResourceType(final DnetResourceType type) throws InformationServiceException {

		hibObjectHelper.createHibDnetResourceType(type);

		return false;

	}

	@Override

	public List<DnetResourceType> listResourceTypes(final String kind) throws InformationServiceException {

		final String query = "select t.id as type, t.format as format, count(ds.id) as total "

				+ "from resource_types t left outer join datastructures ds on (t.id = ds.type) "

				+ "where t.kind = ?"

				+ "group by t.id, t.format";

		return Lists.transform(dbUtils.searchSimple(query, kind), new Function<Map<String, Object>, DnetResourceType>() {

			@Override

			public DnetResourceType apply(final Map<String, Object> map) {

				return new DnetResourceType(

						map.get("type").toString(),

						DnetResourceKind.valueOf(kind),

						DnetResourceFormat.valueOf(map.get("format").toString()),

						NumberUtils.toLong(map.get("total").toString(), 0)

				);

			}

		});

	}

	@Override

	public boolean addBlackBoardMessage(final String id, final BlackboardMessage message) throws InformationServiceException {

		hibObjectHelper.createHibBlackbooardMessage(id, message);

		return true;

	}

	@Override

	public boolean updateBlackBoardMessage(final BlackboardMessage message) throws InformationServiceException {

		hibObjectHelper.updateHibBlackbooardMessage(message);

		return true;

	}

	@Override

	public boolean deleteBlackBoardMessage(final BlackboardMessage message) throws InformationServiceException {

		daoFactory.getDao(HibBlackboardMessage.class).delete(message.getId());

		return true;

	}

	@Override

	public DnetDataStructure getDsById(final String id) throws InformationServiceException {

		final DnetSimpleDao<HibDatastructure> dao = daoFactory.getDao(HibDatastructure.class);

		final HibDatastructure hib = dao.find(id);

		return hib != null ? hib.asDnetDataStructure() : null;

	}

	@Override

	public DnetDataStructure getDsByCode(final String code, final String type) throws InformationServiceException {

		final String id = dbUtils.findDsIdByCode(code, type);

		if (id != null) {

			return getDsById(id);

		} else {

			throw new InformationServiceException(String.format("Missing datastructure with code %s and type %s", code, type));

		}

	}

	@Override

	public String registerDs(final DnetDataStructure ds) throws InformationServiceException {

		if (StringUtils.isBlank(ds.getId())) {

			ds.setId("ds-" + UUID.randomUUID());

			ds.setDate(new Date());

		}

		hibObjectHelper.createHibDnetDatastructure(ds);

		log.info("DS " + ds + " saved");

		return ds.getId();

	}

	@Override

	public boolean deleteDsById(final String id) throws InformationServiceException {

		daoFactory.getDao(HibDatastructure.class).delete(id);

		return true;

	}

	@Override

	public boolean deleteDsByCode(final String code, final String type) throws InformationServiceException {

		return deleteDsById(dbUtils.findDsIdByCode(code, type));

	}

	@Override

	public boolean isRegisteredDs(final String code, final String type) {

		return dbUtils.isRegisteredDs(code, type);

	}

	@Override

	public List<BlackboardMessage> listBlackboardMessages() throws InformationServiceException {

		final DnetSimpleDao<HibBlackboardMessage> dao = daoFactory.getDao(HibBlackboardMessage.class);

		return Lists.transform(dao.list(), new Function<HibBlackboardMessage, BlackboardMessage>() {

			@Override

			public BlackboardMessage apply(final HibBlackboardMessage hib) {

				return hib.asDnetBlackboardMessage();

			}

		});

	}

	@Override

	public boolean validateResource(final String id, final boolean valid) throws InformationServiceException {

		final DnetSimpleDao<HibDnetResource> dao = daoFactory.getDao(HibDnetResource.class);

		final HibDnetResource hib = dao.find(id);

		hib.setValid(valid);

		dao.save(hib);

		return true;

	}

	@Override

	public List<DnetDataStructure> listDatastructures(final String type) throws InformationServiceException {

		final DnetSimpleDao<HibDatastructure> dao = daoFactory.getDao(HibDatastructure.class);

		return Lists.transform(dao.list("type.id", type), new Function<HibDatastructure, DnetDataStructure>() {

			@Override

			public DnetDataStructure apply(final HibDatastructure hib) {

				return hib.asDnetDataStructure();

			}

		});

	}

	public DnetSimpleDaoFactory getDaoFactory() {

		return daoFactory;

	}

	@Required

	public void setDaoFactory(final DnetSimpleDaoFactory daoFactory) {

		this.daoFactory = daoFactory;

	}

	public DatabaseUtils getDbUtils() {

		return dbUtils;

	}

	@Required

	public void setDbUtils(final DatabaseUtils dbUtils) {

		this.dbUtils = dbUtils;

	}

	public HibObjectHelper getHibObjectHelper() {

		return hibObjectHelper;

	}

	@Required

	public void setHibObjectHelper(final HibObjectHelper hibObjectHelper) {

		this.hibObjectHelper = hibObjectHelper;

	}

}