org.nuiton.topia.service.sql.usage.TopiaUsageEntity Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of api Show documentation
ToPIA API module
The newest version!
package org.nuiton.topia.service.sql.usage;

/*-
 * #%L
 * ToPIA Extension :: API
 * %%
 * Copyright (C) 2018 - 2022 Ultreia.io
 * %%
 * 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 (at your option) 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
 * .
 * #L%
 */


import org.nuiton.topia.persistence.TopiaDaoSupplier;
import org.nuiton.topia.persistence.TopiaEntity;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * Describes all usages of an entity type.
 *
 * @author Tony Chemit - [email protected]
 * @since ?
 */
public class TopiaUsageEntity {

    private final List reverseCompositions;
    private final List reverseManyToManyAssociations;
    private final List reverseOneToManyAssociations;
    private final List reverseOneToOneCompositions;
    private final List reverseAssociations;

    protected TopiaUsageEntity(List reverseCompositions,
                               List reverseManyToManyAssociations,
                               List reverseOneToManyAssociations,
                               List reverseOneToOneCompositions,
                               List reverseAssociations) {
        this.reverseCompositions = reverseCompositions;
        this.reverseManyToManyAssociations = reverseManyToManyAssociations;
        this.reverseOneToManyAssociations = reverseOneToManyAssociations;
        this.reverseOneToOneCompositions = reverseOneToOneCompositions;
        this.reverseAssociations = reverseAssociations;
    }

    public void countReverseCompositions(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Predicate> entityTypeFilter, Map, Long> result) {
        compositions(entityTypeFilter).ifPresent(links -> count(daoSupplier, links, entity, result));
    }

    public void countReverseAssociations(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Predicate> entityTypeFilter, Map, Long> result) {
        associations(entityTypeFilter).ifPresent(links -> count(daoSupplier, links, entity, result));
    }

    public void countReverseManyToManyAssociations(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Predicate> entityTypeFilter, Map, Long> result) {
        manyToManyAssociations(entityTypeFilter).ifPresent(links -> count(daoSupplier, links, entity, result));
    }

    public void countReverseOneToManyAssociations(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Predicate> entityTypeFilter, Map, Long> result) {
        oneToManyAssociations(entityTypeFilter).ifPresent(links -> count(daoSupplier, links, entity, result));
    }

    public void countReverseOneToOneCompositions(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Predicate> entityTypeFilter, Map, Long> result) {
        oneToOneCompositions(entityTypeFilter).ifPresent(links -> count(daoSupplier, links, entity, result));
    }

    public  void findReverseComposition(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Class entityType, List result) {
        compositions(entityType::equals).ifPresent(links -> find(daoSupplier, links, entity, result));
    }

    public  void findReverseOneToManyAssociation(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Class entityType, List result) {
        oneToManyAssociations(entityType::equals).ifPresent(links -> find(daoSupplier, links, entity, result));
    }

    public  void findReverseOneToOneComposition(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Class entityType, List result) {
        oneToOneCompositions(entityType::equals).ifPresent(links -> find(daoSupplier, links, entity, result));
    }

    public  void findReverseManyToManyAssociation(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Class entityType, List result) {
        manyToManyAssociations(entityType::equals).ifPresent(links -> find(daoSupplier, links, entity, result));
    }

    public  void findReverseAssociation(TopiaDaoSupplier daoSupplier, TopiaEntity entity, Class entityType, List result) {
        associations(entityType::equals).ifPresent(links -> find(daoSupplier, links, entity, result));
    }

    protected void count(TopiaDaoSupplier daoSupplier, Stream links, TopiaEntity entity, Map, Long> result) {
        links.forEach(link -> {
            long count = link.count(daoSupplier, entity);
            if (count > 0) {
                Long orDefault = result.getOrDefault(link.getType(), 0L);
                result.put(link.getType(), orDefault + count);
            }
        });
    }

    protected  void find(TopiaDaoSupplier daoSupplier, Stream links, TopiaEntity entity, List result) {
        links.forEach(link -> {
            List count = link.find(daoSupplier, entity);
            result.addAll(count);
        });
    }

    protected Optional> compositions(Predicate> entityTypeFilter) {
        return reverseCompositions().map(p -> p.stream().filter(l -> entityTypeFilter.test(l.getType())));
    }

    protected Optional> associations(Predicate> entityTypeFilter) {
        return reverseAssociations().map(p -> p.stream().filter(l -> entityTypeFilter.test(l.getType())));
    }

    protected Optional> manyToManyAssociations(Predicate> entityTypeFilter) {
        return reverseManyToManyAssociations().map(p -> p.stream().filter(l -> entityTypeFilter.test(l.getType())));
    }

    protected Optional> oneToManyAssociations(Predicate> entityTypeFilter) {
        return reverseOneToManyAssociations().map(p -> p.stream().filter(l -> entityTypeFilter.test(l.getType())));
    }

    protected Optional> oneToOneCompositions(Predicate> entityTypeFilter) {
        return reverseOneToOneCompositions().map(p -> p.stream().filter(l -> entityTypeFilter.test(l.getType())));
    }

    protected Optional> reverseCompositions() {
        return Optional.ofNullable(reverseCompositions);
    }

    protected Optional> reverseManyToManyAssociations() {
        return Optional.ofNullable(reverseManyToManyAssociations);
    }

    protected Optional> reverseOneToManyAssociations() {
        return Optional.ofNullable(reverseOneToManyAssociations);
    }

    protected Optional> reverseOneToOneCompositions() {
        return Optional.ofNullable(reverseOneToOneCompositions);
    }

    protected Optional> reverseAssociations() {
        return Optional.ofNullable(reverseAssociations);
    }
}