BrightSide/elephant-dossier/src/main/java/org/turro/dossier/task/Tasks.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.task;
 
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;
import org.turro.collections.FlatList;
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.dossier.entity.IssueStatus;
import org.turro.jpa.Dao;
import org.turro.sql.SqlClause;
 
public class Tasks {
  
  public double getPercentTasksDone() {
    Collection<TaskItem> subtasks = getFilledFlat();
//    if(issue != null) {
//      subtasks.removeIf(ti -> Objects.equals(ti.getIssue().getId(), issue.getId()));
//    }
    if(subtasks.isEmpty()) {
      return 0;
    } else {
      double done = subtasks.stream().filter(ti -> ti.getIssue().getStatus().isFinished()).count();
      return (done / subtasks.size()) * 100.0;
    }
  }
 
  public Collection<TaskItem> getFilledFlat() {
    return getFlat(getFilledRoots());
  }
 
  public Collection<TaskItem> getFilledRoots() {
    Collection<TaskItem> model = getRoots();
    model.forEach((task) -> fillSubtasks(task));
    return model;
  }
 
  public Collection<TaskItem> getRoots() {
    if(issue != null) {
      return List.<TaskItem>of(new TaskItem(issue, null, 1));
    } else {
      try(Stream<Issue> stream = SqlClause.select("i").from("Issue i")
              .where().equal("i.dossier", dossier)
              .startIf(onlyOpen)
              .and().in("i.status", IssueStatus.selectBy(null, null, null, false))
              .endIf()
              .and().empty("i.targets")
              .dao(dao)
              .stream(Issue.class)) {
        return stream.map(i -> new TaskItem(i, null, 1)).toList();
      }
    }
  }
 
  public Collection<TaskItem> getSubtasks(TaskItem item) {
    try(Stream<IssuePredecessor> stream = SqlClause.select("p").from("IssuePredecessor p")
            .where().equal("p.target", item.getIssue())
            .startIf(onlyOpen)
            .and().in("p.target.status", IssueStatus.selectBy(null, null, null, false))
            .endIf()
            .startIf(sameDossier)
            .and("p.target.dossier = p.source.dossier")
            .endIf()
            .dao(dao)
            .stream(IssuePredecessor.class)) {
      return stream.map(p -> new TaskItem(p.getSource(), p.getType(), item.getLevel() + 1))
              .toList();
    }
  }
  
  public Collection<TaskItem> getFlat(Collection<TaskItem> items) {
    FlatList list = new FlatList<TaskItem>() {
      @Override
      protected Collection<TaskItem> subItems(TaskItem item) {
        return item.getSubtasks();
      }
    };
    items.forEach((item) -> {
      list.addItem(item);
    });
    return list;
  }
 
  /* Fill */
  
  private void fillSubtasks(TaskItem task) {
    getSubtasks(task).stream().forEach((subtask) -> {
      task.addSubtask(subtask);
      fillSubtasks(subtask);
    });
  }
 
  /* Factory */
  
  public static Tasks from(Dossier dossier, boolean onlyOpen, boolean sameDossier) {
    return new Tasks(dossier, null, onlyOpen, sameDossier);
  }
  
  public static Tasks from(Issue issue, boolean onlyOpen, boolean sameDossier) {
    return new Tasks(null, issue, onlyOpen, sameDossier);
  }
  
  private final Dao dao;
  private final Dossier dossier;
  private final Issue issue;
  private final boolean onlyOpen, sameDossier;
 
  private Tasks(Dossier dossier, Issue issue, boolean onlyOpen, boolean sameDossier) {
    this.dao = new DossierPU();
    this.dossier = dossier;
    this.issue = issue;
    this.onlyOpen = onlyOpen;
    this.sameDossier = sameDossier;
  }
 
}