de.factoryfx.server.Microservice Maven / Gradle / Ivy

Go to download
package de.factoryfx.server;

import java.util.Collection;
import java.util.function.Function;

import de.factoryfx.data.merge.DataMerger;
import de.factoryfx.data.merge.MergeDiffInfo;
import de.factoryfx.factory.FactoryBase;
import de.factoryfx.factory.FactoryManager;
import de.factoryfx.data.storage.DataAndNewMetadata;
import de.factoryfx.data.storage.DataAndStoredMetadata;
import de.factoryfx.data.storage.DataStorage;
import de.factoryfx.data.storage.StoredDataMetadata;
import de.factoryfx.factory.log.FactoryUpdateLog;

/**
 * starting point for factoryfx application
 *
 * @param  Visitor
 * @param  Root
 * @param  Summary Data for factory history
 */
public class Microservice,S> {
    private final FactoryManager factoryManager;
    private final DataStorage dataStorage;

    public Microservice(FactoryManager factoryManager, DataStorage dataStorage) {
        this.factoryManager = factoryManager;
        this.dataStorage = dataStorage;
    }

    public MergeDiffInfo getDiffToPreviousVersion(StoredDataMetadata storedDataMetadata) {
        R historyFactory = getHistoryFactory(storedDataMetadata.id);
        R historyFactoryPrevious = getPreviousHistoryFactory(storedDataMetadata.id);
        return new DataMerger<>(historyFactoryPrevious,historyFactoryPrevious,historyFactory).createMergeResult((permission)->true).executeMerge();
    }

    public FactoryUpdateLog revertTo(StoredDataMetadata storedDataMetadata, String user) {
        R historyFactory = getHistoryFactory(storedDataMetadata.id);
        DataAndNewMetadata current = prepareNewFactory();
        current = new DataAndNewMetadata<>(historyFactory,current.metadata);
        return updateCurrentFactory(current,user,"revert",s->true);
    }

    public FactoryUpdateLog updateCurrentFactory(DataAndNewMetadata update, String user, String comment, Function permissionChecker) {
        R commonVersion = dataStorage.getHistoryFactory(update.metadata.baseVersionId);
        FactoryUpdateLog factoryLog = factoryManager.update(commonVersion, update.root, permissionChecker);
        if (factoryLog.mergeDiffInfo.successfullyMerged()){
            DataAndNewMetadata copy = new DataAndNewMetadata<>(factoryManager.getCurrentFactory().internal().copyFromRoot(),update.metadata);
            dataStorage.updateCurrentFactory(copy,user,comment,factoryLog.mergeDiffInfo);
        }
        return factoryLog;
    }

    public MergeDiffInfo simulateUpdateCurrentFactory(DataAndNewMetadata possibleUpdate, Function permissionChecker){
        R commonVersion = dataStorage.getHistoryFactory(possibleUpdate.metadata.baseVersionId);
        return factoryManager.simulateUpdate(commonVersion , possibleUpdate.root, permissionChecker);
    }

    /**
     * @return creates a new factory update which is ready for editing mainly assign the right ids
     * */
    public DataAndNewMetadata prepareNewFactory() {
        return dataStorage.getPrepareNewFactory();
    }

    public R getHistoryFactory(String id) {
        return dataStorage.getHistoryFactory(id);
    }

    private R getPreviousHistoryFactory(String id) {
        return dataStorage.getPreviousHistoryFactory(id);
    }

    public Collection> getHistoryFactoryList() {
        return dataStorage.getHistoryFactoryList();
    }

    public void start() {
        dataStorage.loadInitialFactory();
        final DataAndStoredMetadata currentFactory = dataStorage.getCurrentFactory();
        currentFactory.root.internalFactory().setMicroservice(this);

        factoryManager.start(currentFactory.root);
    }

    public void stop() {
        factoryManager.stop();
    }

    public V query(V visitor) {
        return factoryManager.query(visitor);
    }
}