TimeTrackerQueue.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2020 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.timetracker;
 
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Date;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Stream;
import org.amic.util.date.CheckDate;
import org.turro.elephant.db.ElephantPU;
import org.turro.elephant.db.WhereClause;
import org.turro.elephant.entities.db.TimeTracker;
import org.turro.elephant.entities.db.TimeTrackerPK;
import org.turro.elephant.entities.db.TimeTrackerType;
import org.turro.jpa.Dao;
import org.turro.sql.SqlClause;
 
public class TimeTrackerQueue extends TreeSet<TimeTracker> {
  
  private final String entityPath, trackedPath;
 
  public boolean hasIntegrity() {
    TimeTrackerType[] previousType = new TimeTrackerType[1];
    return stream().noneMatch(e -> {
      boolean match = !e.getTrackType().isPreviousValid(previousType[0]);
      previousType[0] = e.getTrackType();
      return match;
    });
  }
  
  public boolean correctDate(CheckDate dateTrack) {
    if(isEmpty()) return true;
    TimeTracker tt = last();
    if(tt != null) {
      return tt.getTimeTrack().before(dateTrack.getDate());
    }
    return false;
  }
 
  public TimeTracker addTrack(TimeTrackerType type, Date dateTrack) {
    if(type != null && type.isPreviousValid(getLastType())) {
      TimeTracker tt = new TimeTracker();
      tt.setEntityPath(entityPath);
      tt.setTrackedPath(trackedPath);
      tt.setTrackType(type);
      tt.setTimeTrack(dateTrack);
      if(!tt.isEmpty()) {
        tt = getDao().saveObject(tt);
        if(!tt.getTrackType().isStarts()) {
          setHours();
          tt = getDao().find(TimeTracker.class, TimeTrackerPK.from(tt));
        }
        return tt;
      }
    }
    return null;
  }
  
  public TimeTrackerType getLastType() {
    TimeTracker last = isEmpty() ? null : last();
    return last == null ? null : last.getTrackType();
  }
 
  public Set<TimeTrackerType> getNextValids() {
    TimeTracker last = isEmpty() ? null : last();
    return last == null ? EnumSet.of(TimeTrackerType.TRACK_START) : TimeTrackerType.getValidNexts(last.getTrackType());
  }
 
  public List<TimeTracker> getActiveTracks() {
    return getTracksByStatus(TimeTrackerType.getActiveTypes());
  }
  
  public List<TimeTracker> getInactiveTracks() {
    return getTracksByStatus(TimeTrackerType.getInactiveTypes());
  }
  
  public List<TimeTracker> getTracksByStatus(Set<TimeTrackerType> types) {
    WhereClause wc = new WhereClause();
    wc.addClause("select tt from TimeTracker tt");
    wc.addClause("where tt.trackedPath = :trackedPath");
    wc.addNamedValue("trackedPath", trackedPath);
    wc.addClause("and tt.trackType in (:types)");
    wc.addNamedValue("types", types);
    wc.addClause("and tt.timeTrack = (");
    wc.addClause("select max(t2.timeTrack) from TimeTracker t2");
    wc.addClause("where tt.entityPath = t2.entityPath");
    wc.addClause("and tt.trackedPath = t2.trackedPath");
    wc.addClause(")");
    return getDao().getResultList(TimeTracker.class, wc);
  }
  
  public void deleteLastTrack() {
    getDao().deleteObject(last());
  }
 
  private void setHours() {
    Date from = SqlClause.select("min(tt.timeTrack)").from("TimeTracker tt")
            .where().in("tt.trackType", List.copyOf(TimeTrackerType.getEndTypes()))
            .and().equal("tt.hours", 0.0)
            .and().equal("entityPath", entityPath)
            .and().equal("trackedPath", trackedPath)
            .dao(getDao())
            .singleResult(Date.class);
    List<TimeTracker> toSave = new ArrayList<>();
    final AssignHoursModel model = new AssignHoursModel();
    SqlClause.select("tt").from("TimeTracker tt")
            .where().greater("tt.timeTrack", new CheckDate(from).addDays(-1).getDate())
            .and().equal("entityPath", entityPath)
            .and().equal("trackedPath", trackedPath)
            .orderBy("tt.timeTrack asc")
            .dao(getDao())
            .forEach(TimeTracker.class, tt -> {
              if(tt.getTrackType().isStarts()) {
                model.assignFrom(tt);
              } else if(model.isValid()) {                
                tt.setHours(model.getFrom(tt));
                toSave.add(tt);
              }
            });
    getDao().saveCollection(toSave);
  }
  
  public boolean hasFullIntegrity() {
    WhereClause wc = new WhereClause();
    wc.addClause("select tt from TimeTracker tt");
    wc.addClause("where tt.entityPath = :entityPath");
    wc.addNamedValue("entityPath", entityPath);
    wc.addClause("and tt.trackedPath = :trackedPath");
    wc.addNamedValue("trackedPath", trackedPath);
    wc.addClause("order by tt.timeTrack ASC");
    TimeTrackerType[] previousType = new TimeTrackerType[1];
    try(Stream<TimeTracker> entries = getDao().stream(TimeTracker.class, wc)) {
      return entries.noneMatch(e -> {
        boolean match = !e.getTrackType().isPreviousValid(previousType[0]);
        previousType[0] = e.getTrackType();
        return match;
      });
    }
  }
  
  public void repairWith(Duration max) {
    WhereClause wc = new WhereClause();
    wc.addClause("select tt from TimeTracker tt");
    wc.addClause("where tt.entityPath = :entityPath");
    wc.addNamedValue("entityPath", entityPath);
    wc.addClause("and tt.trackedPath = :trackedPath");
    wc.addNamedValue("trackedPath", trackedPath);
    wc.addClause("order by tt.timeTrack ASC");
    TimeTracker[] previous = new TimeTracker[1];
    try(Stream<TimeTracker> entries = getDao().stream(TimeTracker.class, wc)) {
      entries.forEach(e -> {
        if(!e.isPreviousValid(previous[0])) {
          repair(max, previous[0], e);
        }
        previous[0] = e;
      });
    }
  }
  
  private void repair(Duration max, TimeTracker previous, TimeTracker current) {
    TimeTracker tt = new TimeTracker();
    tt.setEntityPath(current.getEntityPath());
    tt.setTrackedPath(current.getTrackedPath());
    tt.setTrackType(current.getTrackType().getValidRepair(previous));
//    tt.setTimeTrack(null);
//    if(!tt.isEmpty()) getDao().saveObject(tt);
  }
  
  /* Instance */
  
  public static TimeTrackerQueue load(String entityPath, String trackedPath) {
    TimeTrackerQueue ttq = new TimeTrackerQueue(entityPath, trackedPath);
    ttq.loadLastActiveTrack();
    return ttq;
  }
  
  public static TimeTrackerQueue load(String entityPath, String trackedPath, int hours) {
    TimeTrackerQueue ttq = new TimeTrackerQueue(entityPath, trackedPath);
    ttq.loadLastHoursEntries(hours);
    return ttq;
  }
  
  private TimeTrackerQueue(String entityPath, String trackedPath) {
    this.entityPath = entityPath;
    this.trackedPath = trackedPath;
  }
  
  private void loadLastActiveTrack() {
    WhereClause wc = new WhereClause();
    wc.addClause("select tt from TimeTracker tt");
    wc.addClause("where tt.entityPath = :entityPath");
    wc.addNamedValue("entityPath", entityPath);
    wc.addClause("and tt.trackedPath = :trackedPath");
    wc.addNamedValue("trackedPath", trackedPath);
    wc.addClause("and tt.timeTrack >= (");
    wc.addClause("select max(t2.timeTrack) from TimeTracker t2");
    wc.addClause("where tt.entityPath = t2.entityPath");
    wc.addClause("and tt.trackedPath = t2.trackedPath");
    wc.addClause("and t2.trackType = :type");
    wc.addNamedValue("type", TimeTrackerType.TRACK_START);
    wc.addClause(")");
    addAll(getDao().getResultList(TimeTracker.class, wc));
  }
  
  private void loadLastHoursEntries(int hours) {
    WhereClause wc = new WhereClause();
    wc.addClause("select tt from TimeTracker tt");
    wc.addClause("where tt.entityPath = :entityPath");
    wc.addNamedValue("entityPath", entityPath);
    wc.addClause("and tt.trackedPath = :trackedPath");
    wc.addNamedValue("trackedPath", trackedPath);
    wc.addClause("and tt.timeTrack > :date");
    wc.addNamedValue("date", Date.from(Instant.now().minus(Duration.ofHours(hours))));
    addAll(getDao().getResultList(TimeTracker.class, wc));
  }
  
  /* Dao helper */
  
  private Dao _dao;
 
  private Dao getDao() {
    if(_dao == null) {
      _dao = new ElephantPU();
    }
    return _dao;
  }
 
}