IssueGraph.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2022 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package org.turro.dossier.graph;
 
import java.util.Set;
import org.jgrapht.Graph;
import org.jgrapht.Graphs;
import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.graph.SimpleDirectedGraph;
import org.turro.dossier.db.DossierPU;
import org.turro.dossier.entity.Dossier;
import org.turro.dossier.entity.Issue;
import org.turro.dossier.entity.IssuePredecessor;
import org.turro.jpa.Dao;
import org.turro.sql.SqlClause;
import org.turro.util.Cached;
 
public class IssueGraph extends SimpleDirectedGraph<IssueVertex, IssueEdge> {
 
  /* Initialization */
  
  private void addVertices() {
    SqlClause.select("i").from("Issue i")
            .startIf(onlyPublishable)
            .where().equal("publishable", true)
            .endIf()
            .startIf(onlyMilestones)
            .whereOrAnd().equal("i.milestone", true)
            .endIf()
            .startIf(dossier != null)
            .whereOrAnd().equal("i.dossier", dossier)
            .endIf()
            .dao(dao.get())
            .resultList(Issue.class)
            .forEach(issue -> {
              addVertex(milestoneOf(issue));
            });
  }
  
  private void addEdges() {
    // Full graph
    Graph<Long, DefaultEdge> predecessorGraph = new SimpleDirectedGraph<>(DefaultEdge.class);
    SqlClause.select("i").from("IssuePredecessor i")
            .startIf(dossier != null)
            .where().equal("i.source.dossier", dossier)
            .and().equal("i.target.dossier", dossier)
            .endIf()
            .dao(dao.get())
            .resultList(IssuePredecessor.class)
            .forEach(predecessor -> {
              Graphs.addEdgeWithVertices(predecessorGraph, predecessor.getSource().getId(), predecessor.getTarget().getId());
            });
    if(onlyMilestones) {
      // Simplify for current milestones
      Set.copyOf(predecessorGraph.vertexSet()).forEach(vertex -> {
        if(!containsVertex(milestoneOf(vertex))) {
          Graphs.removeVertexAndPreserveConnectivity(predecessorGraph, vertex);
        }
      });
    }
    // Add final edge model
    vertexSet().forEach(m1 -> {
      vertexSet().forEach(m2 -> {
        if(predecessorGraph.containsEdge(m1.getItem().getIssueId(), m2.getItem().getIssueId())) {
          Graphs.addEdgeWithVertices(this, m1, m2);
        }
      });
    });
  }
  
  private IssueVertex milestoneOf(Issue issue) {
    return new IssueVertex(this, new IssueItem(issue));
  }
  
  private IssueVertex milestoneOf(Long issueId) {
    return new IssueVertex(this, new IssueItem(dao, issueId));
  }
  
  private final Cached<Dao> dao = Cached.instance(() -> new DossierPU());
  
  /* Factory */
 
  private final Dossier dossier;
  private final boolean onlyMilestones, onlyPublishable;
 
  public static IssueGraph load(Dossier dossier) {
    return new IssueGraph(dossier, false, false);
  }
  
  public static IssueGraph loadPublishable(Dossier dossier) {
    return new IssueGraph(dossier, false, true);
  }
  
  public static IssueGraph milestones(Dossier dossier) {
    return new IssueGraph(dossier, true, false);
  }
  
  public static IssueGraph publishableMilestones(Dossier dossier) {
    return new IssueGraph(dossier, true, false);
  }
 
  public static IssueGraph all() {
    return new IssueGraph(false);
  }
  
  public static IssueGraph publishable() {
    return new IssueGraph(true);
  }
  
  private IssueGraph(boolean onlyPublishable) {
    super(IssueEdge.class);
    this.dossier = null;
    this.onlyMilestones = true;
    this.onlyPublishable = onlyPublishable;
  }
 
  private IssueGraph(Dossier dossier, boolean onlyMilestones, boolean onlyPublishable) {
    super(IssueEdge.class);
    this.dossier = dossier;
    this.onlyMilestones = onlyMilestones;
    this.onlyPublishable = onlyPublishable;
    addVertices();
    addEdges();
  }
  
}