de.lemo.dms.connectors.ConnectorManager.java Source code

Introduction

Here is the source code for de.lemo.dms.connectors.ConnectorManager.java

Source

/**
 * File ./src/main/java/de/lemo/dms/connectors/ConnectorManager.java
 * Lemo-Data-Management-Server for learning analytics.
 * Copyright (C) 2013
 * Leonard Kappe, Andreas Pursian, Sebastian Schwarzrock, Boris Wenzlaff
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
**/

/**
 * File ./main/java/de/lemo/dms/connectors/ConnectorManager.java
 * Date 2013-01-24
 * Project Lemo Learning Analytics
 */

package de.lemo.dms.connectors;

import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Projections;
import com.google.common.collect.Lists;
import de.lemo.dms.core.ConnectorGetDataWorkerThread;
import de.lemo.dms.core.config.ServerConfiguration;
import de.lemo.dms.db.DBConfigObject;
import de.lemo.dms.db.IDBHandler;
import de.lemo.dms.db.mapping.PlatformMining;

/**
 * Handles all connector instances.
 * 
 * @author Leonard Kappe
 * @author Boris Wenzlaff
 */
public enum ConnectorManager {

    INSTANCE;

    private final Logger logger = Logger.getLogger(this.getClass());
    private final List<IConnector> connectors = Lists.newArrayList();
    private ConnectorGetDataWorkerThread getDataThread;

    /**
     * Return the instance of the manager.
     * 
     * @return a singleton instance of the ConnectorManager
     */
    public static ConnectorManager getInstance() {
        return INSTANCE;
    }

    /**
     * @return all available connectors
     */
    public List<IConnector> getAvailableConnectors() {
        return new ArrayList<IConnector>(connectors);
    }

    /**
     * Add a connector.
     * 
     * @param connector
     */
    public void addConnector(final IConnector connector) {
        this.saveOrUpdateConnectorInfo(connector);
        this.connectors.add(connector);
    }

    public IConnector createNewConnector(Long platformId, Long prefix, String name, String platformType,
            List<String> properties, List<Long> courseIdFilter, List<String> logins) {
        ESourcePlatform platform = ESourcePlatform.valueOf(platformType);
        DBConfigObject config = new DBConfigObject();
        if (!properties.isEmpty()) {
            for (int i = 0; i < properties.size() - 1; i += 2) {
                config.setProperty(properties.get(i), properties.get(i + 1));
            }
        }
        IConnector connector = platform.newConnector(platformId, name, config, courseIdFilter, logins);
        this.addConnector(connector);
        return connector;
    }

    /**
     * Update the mining database, new data will be loaded from the platform.
     * 
     * @return true if updating has started
     */
    public boolean startUpdateData(final IConnector connector) {
        this.logger.info("Updating " + connector);
        if ((this.getDataThread == null) || (this.connectorState() == EConnectorManagerState.READY)) {
            this.getDataThread = new ConnectorGetDataWorkerThread(connector);
            this.getDataThread.start();
            return true;
        }
        return false;
    }

    /**
     * Information about the connector update process.
     * 
     * @see EConnectorManagerState
     * @return the state of the connector update process
     */
    public EConnectorManagerState connectorState() {
        if (this.connectors.isEmpty()) {
            return EConnectorManagerState.NO_CONNECTORS;
        }
        if (getDataThread != null && this.getDataThread.isAlive()) {
            return EConnectorManagerState.IN_PROGRESS;
        }
        return EConnectorManagerState.READY;
    }

    public IConnector getUpdatingConnector() {
        if (getDataThread != null) {
            return getDataThread.getConnector();
        }
        return null;
    }

    /**
     * Get a connector by its id.
     * 
     * @param connectorId
     *            a connector id
     * @return the connector with the provided id or null if none found
     */
    public IConnector getConnectorById(final Long connectorId) {
        if (connectorId != null) {
            for (final IConnector connector : this.connectors) {
                if (connectorId.equals(connector.getPlatformId())) {
                    return connector;
                }
            }
        }
        return null;
    }

    private void saveOrUpdateConnectorInfo(final IConnector connector) {
        final IDBHandler dbHandler = ServerConfiguration.getInstance().getMiningDbHandler();
        final Session session = dbHandler.getMiningSession();

        PlatformMining platform = (PlatformMining) session.get(PlatformMining.class, connector.getPlatformId());

        if (platform == null) {
            // save new platform
            final Criteria criteria = session.createCriteria(PlatformMining.class)
                    .setProjection(Projections.max("prefix"));
            Long maxPrefix = (Long) criteria.uniqueResult();
            if (maxPrefix == null) {
                maxPrefix = 10L;
            }
            platform = new PlatformMining();
            platform.setId(connector.getPlatformId());
            platform.setPrefix(maxPrefix + 1);

        }
        final AbstractConnector ac = (AbstractConnector) connector;
        ac.setPrefix(platform.getPrefix());
        // update name
        platform.setName(connector.getName());
        platform.setType(connector.getPlattformType().name());

        dbHandler.saveToDB(session, platform);
        dbHandler.closeSession(session);
    }

}