org.javers.repository.sql.finders.CdoSnapshotFinder Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of javers-persistence-sql Show documentation
JaVers - object auditing and diff framework for Java
There is a newer version: 7.6.2
Show newest version
package org.javers.repository.sql.finders;

import org.javers.common.collections.Lists;
import org.javers.common.collections.Sets;
import org.javers.core.json.CdoSnapshotSerialized;
import org.javers.core.json.JsonConverter;
import org.javers.core.metamodel.object.CdoSnapshot;
import org.javers.core.metamodel.object.GlobalId;
import org.javers.core.metamodel.type.EntityType;
import org.javers.core.metamodel.type.ManagedType;
import org.javers.repository.api.QueryParams;
import org.javers.repository.api.QueryParamsBuilder;
import org.javers.repository.api.SnapshotIdentifier;
import org.javers.repository.sql.finders.SnapshotQuery.SnapshotDbIdentifier;
import org.javers.repository.sql.repositories.GlobalIdRepository;
import org.javers.repository.sql.schema.TableNameProvider;
import org.javers.repository.sql.session.Session;

import java.util.*;
import java.util.function.Consumer;

import static java.util.stream.Collectors.toList;
import static org.javers.repository.sql.schema.FixedSchemaFactory.SNAPSHOT_GLOBAL_ID_FK;
import static org.javers.repository.sql.schema.FixedSchemaFactory.SNAPSHOT_PK;

public class CdoSnapshotFinder {

    private final GlobalIdRepository globalIdRepository;
    private final CommitPropertyFinder commitPropertyFinder;
    private final CdoSnapshotsEnricher cdoSnapshotsEnricher = new CdoSnapshotsEnricher();
    private JsonConverter jsonConverter;
    private final TableNameProvider tableNameProvider;

    public CdoSnapshotFinder(GlobalIdRepository globalIdRepository, CommitPropertyFinder commitPropertyFinder, TableNameProvider tableNameProvider) {
        this.globalIdRepository = globalIdRepository;
        this.commitPropertyFinder = commitPropertyFinder;
        this.tableNameProvider = tableNameProvider;
    }

    public Optional getLatest(GlobalId globalId, Session session, boolean loadCommitProps) {
        Optional globalIdPk = globalIdRepository.findGlobalIdPk(globalId, session);
        if (!globalIdPk.isPresent()){
            return Optional.empty();
        }

        return selectMaxSnapshotPrimaryKey(globalIdPk.get(), session).map(maxSnapshotId -> {
            QueryParams oneItemLimit = QueryParamsBuilder
                    .withLimit(1)
                    .withCommitProps(loadCommitProps)
                    .build();
            return fetchCdoSnapshots(q -> q.addSnapshotPkFilter(maxSnapshotId), oneItemLimit, session).get(0);
        });
    }

    public List getSnapshots(QueryParams queryParams, Session session) {
        return fetchCdoSnapshots(q -> {}, queryParams, session);
    }

    public List getSnapshots(Collection snapshotIdentifiers, Session session) {

        List snapshotIdentifiersWithPk = snapshotIdentifiers.stream()
                .map(si -> globalIdRepository.findGlobalIdPk(si.getGlobalId(), session)
                                             .map(id -> new SnapshotDbIdentifier(si, id)))
                .filter(Optional::isPresent)
                .map(Optional::get)
                .collect(toList());

        QueryParams queryParams = QueryParamsBuilder.withLimit(Integer.MAX_VALUE).build();
        return fetchCdoSnapshots(q -> q.addSnapshotIdentifiersFilter(snapshotIdentifiersWithPk), queryParams, session);
    }

    public List getStateHistory(Set managedTypes, QueryParams queryParams, Session session) {
        Set managedTypeNames = Sets.transform(managedTypes, managedType -> managedType.getName());
        return fetchCdoSnapshots(q -> q.addManagedTypesFilter(managedTypeNames), queryParams, session);
    }

    public List getVOStateHistory(EntityType ownerEntity, String fragment, QueryParams queryParams, Session session) {
        return fetchCdoSnapshots(q -> q.addVoOwnerEntityFilter(ownerEntity.getName(), fragment), queryParams, session);
    }

    public List getStateHistory(GlobalId globalId, QueryParams queryParams, Session session) {
        Optional globalIdPk = globalIdRepository.findGlobalIdPk(globalId, session);

        return globalIdPk.map(idPk -> fetchCdoSnapshots(q -> q.addGlobalIdFilter(idPk), queryParams, session))
                         .orElse(Collections.emptyList());
    }

    private List fetchCdoSnapshots(Consumer additionalFilter,
                                                QueryParams queryParams, Session session) {
        SnapshotQuery query = new SnapshotQuery(tableNameProvider, queryParams, session);
        additionalFilter.accept(query);
        List serializedSnapshots = query.run();

        if (queryParams.isLoadCommitProps()) {
            List commitPropertyDTOs = commitPropertyFinder.findCommitPropertiesOfSnaphots(
                    serializedSnapshots.stream().map(it -> it.getCommitPk()).collect(toList()),session);
            cdoSnapshotsEnricher.enrichWithCommitProperties(serializedSnapshots, commitPropertyDTOs);
        }

        return Lists.transform(serializedSnapshots,
                serializedSnapshot -> jsonConverter.fromSerializedSnapshot(serializedSnapshot));
    }

    private Optional selectMaxSnapshotPrimaryKey(long globalIdPk, Session session) {

        Optional maxPrimaryKey =  session
                .select("MAX(" + SNAPSHOT_PK + ")")
                .from(tableNameProvider.getSnapshotTableNameWithSchema())
                .and(SNAPSHOT_GLOBAL_ID_FK, globalIdPk)
                .queryName("select max snapshot's PK")
                .queryForOptionalLong();

        if (maxPrimaryKey.isPresent() && maxPrimaryKey.get() == 0){
            return Optional.empty();
        }
        return maxPrimaryKey;
    }

    public void setJsonConverter(JsonConverter jsonConverter) {
        this.jsonConverter = jsonConverter;
    }

}