mirror of https://github.com/iSoron/uhabits.git
parent
2e19fee83c
commit
78f31a65d4
@ -1,555 +0,0 @@
|
|||||||
/*
|
|
||||||
* Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
|
|
||||||
*
|
|
||||||
* This file is part of Loop Habit Tracker.
|
|
||||||
*
|
|
||||||
* Loop Habit Tracker 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.
|
|
||||||
*
|
|
||||||
* Loop Habit Tracker 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 <http://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
package org.isoron.uhabits.core.models;
|
|
||||||
|
|
||||||
import androidx.annotation.*;
|
|
||||||
|
|
||||||
import org.apache.commons.lang3.builder.*;
|
|
||||||
import org.isoron.uhabits.core.utils.*;
|
|
||||||
|
|
||||||
import java.io.*;
|
|
||||||
import java.text.*;
|
|
||||||
import java.util.*;
|
|
||||||
|
|
||||||
import javax.annotation.concurrent.*;
|
|
||||||
|
|
||||||
import static org.isoron.uhabits.core.models.Entry.*;
|
|
||||||
import static org.isoron.uhabits.core.models.Habit.*;
|
|
||||||
import static org.isoron.uhabits.core.utils.StringUtils.*;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* The collection of {@link Entry}s belonging to a habit.
|
|
||||||
*/
|
|
||||||
@ThreadSafe
|
|
||||||
public class EntryList
|
|
||||||
{
|
|
||||||
protected Habit habit = null;
|
|
||||||
|
|
||||||
protected ArrayList<Entry> list;
|
|
||||||
|
|
||||||
public EntryList()
|
|
||||||
{
|
|
||||||
this.list = new ArrayList<>();
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setHabit(Habit habit)
|
|
||||||
{
|
|
||||||
this.habit = habit;
|
|
||||||
}
|
|
||||||
|
|
||||||
@NonNull
|
|
||||||
static List<Entry> buildEntriesFromInterval(Entry[] original,
|
|
||||||
ArrayList<Interval> intervals)
|
|
||||||
{
|
|
||||||
if (original.length == 0) throw new IllegalArgumentException();
|
|
||||||
|
|
||||||
Timestamp today = DateUtils.getTodayWithOffset();
|
|
||||||
Timestamp begin = original[0].getTimestamp();
|
|
||||||
if (intervals.size() > 0) begin = Timestamp.oldest(begin, intervals.get(0).begin);
|
|
||||||
|
|
||||||
int nDays = begin.daysUntil(today) + 1;
|
|
||||||
List<Entry> entries = new ArrayList<>(nDays);
|
|
||||||
for (int i = 0; i < nDays; i++)
|
|
||||||
entries.add(new Entry(today.minus(i), UNKNOWN));
|
|
||||||
|
|
||||||
for (Interval interval : intervals)
|
|
||||||
{
|
|
||||||
for (int i = 0; i < interval.length(); i++)
|
|
||||||
{
|
|
||||||
Timestamp date = interval.begin.plus(i);
|
|
||||||
int offset = date.daysUntil(today);
|
|
||||||
if (offset < 0) continue;
|
|
||||||
entries.set(offset, new Entry(date, YES_AUTO));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for (Entry e : original)
|
|
||||||
{
|
|
||||||
Timestamp date = e.getTimestamp();
|
|
||||||
int offset = date.daysUntil(today);
|
|
||||||
int value = e.getValue();
|
|
||||||
int prevValue = entries.get(offset).getValue();
|
|
||||||
if (prevValue < value)
|
|
||||||
entries.set(offset, new Entry(date, value));
|
|
||||||
}
|
|
||||||
|
|
||||||
return entries;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* For non-daily habits, some manual entries generate many
|
|
||||||
* automatic entries. For example, for weekly habits, each repetition generates
|
|
||||||
* seven checkmarks. For twice-a-week habits, two repetitions that are close
|
|
||||||
* enough together also generate seven checkmarks.
|
|
||||||
* <p>
|
|
||||||
* This group of generated entries is represented by an interval. This function
|
|
||||||
* computes the list of intervals for a given list of original entries. It tries
|
|
||||||
* to build the intervals as far away in the future as possible.
|
|
||||||
*/
|
|
||||||
@NonNull
|
|
||||||
static ArrayList<Interval> buildIntervals(@NonNull Frequency freq,
|
|
||||||
@NonNull Entry[] entries)
|
|
||||||
{
|
|
||||||
ArrayList<Entry> filteredEntries = new ArrayList<>();
|
|
||||||
for (Entry e : entries)
|
|
||||||
if (e.getValue() == YES_MANUAL)
|
|
||||||
filteredEntries.add(e);
|
|
||||||
|
|
||||||
int num = freq.getNumerator();
|
|
||||||
int den = freq.getDenominator();
|
|
||||||
|
|
||||||
ArrayList<Interval> intervals = new ArrayList<>();
|
|
||||||
for (int i = 0; i < filteredEntries.size() - num + 1; i++)
|
|
||||||
{
|
|
||||||
Entry first = filteredEntries.get(i);
|
|
||||||
Entry last = filteredEntries.get(i + num - 1);
|
|
||||||
|
|
||||||
long distance = first.getTimestamp().daysUntil(last.getTimestamp());
|
|
||||||
if (distance >= den) continue;
|
|
||||||
|
|
||||||
Timestamp begin = first.getTimestamp();
|
|
||||||
Timestamp center = last.getTimestamp();
|
|
||||||
Timestamp end = begin.plus(den - 1);
|
|
||||||
intervals.add(new Interval(begin, center, end));
|
|
||||||
}
|
|
||||||
|
|
||||||
return intervals;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Starting from the second newest interval, this function tries to slide the
|
|
||||||
* intervals backwards into the past, so that gaps are eliminated and
|
|
||||||
* streaks are maximized.
|
|
||||||
*/
|
|
||||||
static void snapIntervalsTogether(@NonNull ArrayList<Interval> intervals)
|
|
||||||
{
|
|
||||||
int n = intervals.size();
|
|
||||||
for (int i = n - 2; i >= 0; i--)
|
|
||||||
{
|
|
||||||
Interval curr = intervals.get(i);
|
|
||||||
Interval next = intervals.get(i + 1);
|
|
||||||
|
|
||||||
int gapNextToCurrent = next.begin.daysUntil(curr.end);
|
|
||||||
int gapCenterToEnd = curr.center.daysUntil(curr.end);
|
|
||||||
|
|
||||||
if (gapNextToCurrent >= 0)
|
|
||||||
{
|
|
||||||
int shift = Math.min(gapCenterToEnd, gapNextToCurrent + 1);
|
|
||||||
intervals.set(i, new Interval(curr.begin.minus(shift),
|
|
||||||
curr.center,
|
|
||||||
curr.end.minus(shift)));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public void add(List<Entry> entries)
|
|
||||||
{
|
|
||||||
list.addAll(entries);
|
|
||||||
Collections.sort(list,
|
|
||||||
(c1, c2) -> c2.getTimestamp().compareTo(c1.getTimestamp()));
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the values for all the checkmarks, since the oldest repetition of
|
|
||||||
* the habit until today.
|
|
||||||
* <p>
|
|
||||||
* If there are no repetitions at all, returns an empty array. The values
|
|
||||||
* are returned in an array containing one integer value for each day since
|
|
||||||
* the first repetition of the habit until today. The first entry
|
|
||||||
* corresponds to today, the second entry corresponds to yesterday, and so
|
|
||||||
* on.
|
|
||||||
*
|
|
||||||
* @return values for the checkmarks in the interval
|
|
||||||
*/
|
|
||||||
@NonNull
|
|
||||||
public synchronized final int[] getAllValues()
|
|
||||||
{
|
|
||||||
List<Entry> entries = habit.getOriginalEntries().getKnown();
|
|
||||||
if(entries.isEmpty()) return new int[0];
|
|
||||||
Entry oldestOriginal = entries.get(entries.size() - 1);
|
|
||||||
|
|
||||||
Timestamp fromTimestamp = oldestOriginal.getTimestamp();
|
|
||||||
Timestamp toTimestamp = DateUtils.getTodayWithOffset();
|
|
||||||
|
|
||||||
return getValues(fromTimestamp, toTimestamp);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the list of checkmarks that fall within the given interval.
|
|
||||||
* <p>
|
|
||||||
* There is exactly one checkmark per day in the interval. The endpoints of
|
|
||||||
* the interval are included. The list is ordered by timestamp (decreasing).
|
|
||||||
* That is, the first checkmark corresponds to the newest timestamp, and the
|
|
||||||
* last checkmark corresponds to the oldest timestamp.
|
|
||||||
*
|
|
||||||
* @param from timestamp of the beginning of the interval.
|
|
||||||
* @param to timestamp of the end of the interval.
|
|
||||||
* @return the list of checkmarks within the interval.
|
|
||||||
*/
|
|
||||||
@NonNull
|
|
||||||
public List<Entry> getByInterval(Timestamp from,
|
|
||||||
Timestamp to)
|
|
||||||
{
|
|
||||||
compute();
|
|
||||||
|
|
||||||
Timestamp newestComputed = new Timestamp(0);
|
|
||||||
Timestamp oldestComputed = new Timestamp(0).plus(1000000);
|
|
||||||
|
|
||||||
Entry newest = getNewestComputed();
|
|
||||||
Entry oldest = getOldestComputed();
|
|
||||||
if (newest != null) newestComputed = newest.getTimestamp();
|
|
||||||
if (oldest != null) oldestComputed = oldest.getTimestamp();
|
|
||||||
|
|
||||||
List<Entry> filtered = new ArrayList<>(
|
|
||||||
Math.max(0, oldestComputed.daysUntil(newestComputed) + 1));
|
|
||||||
|
|
||||||
for (int i = 0; i <= from.daysUntil(to); i++)
|
|
||||||
{
|
|
||||||
Timestamp t = to.minus(i);
|
|
||||||
if (t.isNewerThan(newestComputed) || t.isOlderThan(oldestComputed))
|
|
||||||
filtered.add(new Entry(t, Entry.UNKNOWN));
|
|
||||||
else
|
|
||||||
filtered.add(list.get(t.daysUntil(newestComputed)));
|
|
||||||
}
|
|
||||||
|
|
||||||
return filtered;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the checkmark for today.
|
|
||||||
*
|
|
||||||
* @return checkmark for today
|
|
||||||
*/
|
|
||||||
@Nullable
|
|
||||||
public synchronized final Entry getToday()
|
|
||||||
{
|
|
||||||
compute();
|
|
||||||
Timestamp today = DateUtils.getTodayWithOffset();
|
|
||||||
return getByInterval(today, today).get(0);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the value of today's checkmark.
|
|
||||||
*
|
|
||||||
* @return value of today's checkmark
|
|
||||||
*/
|
|
||||||
public synchronized int getTodayValue()
|
|
||||||
{
|
|
||||||
Entry today = getToday();
|
|
||||||
if (today != null) return today.getValue();
|
|
||||||
else return UNKNOWN;
|
|
||||||
}
|
|
||||||
|
|
||||||
public synchronized int getThisWeekValue(int firstWeekday)
|
|
||||||
{
|
|
||||||
return getThisIntervalValue(DateUtils.TruncateField.WEEK_NUMBER, firstWeekday);
|
|
||||||
}
|
|
||||||
|
|
||||||
public synchronized int getThisMonthValue()
|
|
||||||
{
|
|
||||||
return getThisIntervalValue(DateUtils.TruncateField.MONTH, Calendar.SATURDAY);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public synchronized int getThisQuarterValue()
|
|
||||||
{
|
|
||||||
return getThisIntervalValue(DateUtils.TruncateField.QUARTER, Calendar.SATURDAY);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public synchronized int getThisYearValue()
|
|
||||||
{
|
|
||||||
return getThisIntervalValue(DateUtils.TruncateField.YEAR, Calendar.SATURDAY);
|
|
||||||
}
|
|
||||||
|
|
||||||
private int getThisIntervalValue(DateUtils.TruncateField truncateField, int firstWeekday)
|
|
||||||
{
|
|
||||||
List<Entry> groups = habit.getComputedEntries().groupBy(truncateField, firstWeekday, 1);
|
|
||||||
if (groups.isEmpty()) return 0;
|
|
||||||
return groups.get(0).getValue();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the values of the checkmarks that fall inside a certain interval
|
|
||||||
* of time.
|
|
||||||
* <p>
|
|
||||||
* The values are returned in an array containing one integer value for each
|
|
||||||
* day of the interval. The first entry corresponds to the most recent day
|
|
||||||
* in the interval. Each subsequent entry corresponds to one day older than
|
|
||||||
* the previous entry. The boundaries of the time interval are included.
|
|
||||||
*
|
|
||||||
* @param from timestamp for the oldest checkmark
|
|
||||||
* @param to timestamp for the newest checkmark
|
|
||||||
* @return values for the checkmarks inside the given interval
|
|
||||||
*/
|
|
||||||
public final int[] getValues(Timestamp from, Timestamp to)
|
|
||||||
{
|
|
||||||
if (from.isNewerThan(to)) return new int[0];
|
|
||||||
|
|
||||||
List<Entry> entries = getByInterval(from, to);
|
|
||||||
int values[] = new int[entries.size()];
|
|
||||||
|
|
||||||
int i = 0;
|
|
||||||
for (Entry c : entries)
|
|
||||||
values[i++] = c.getValue();
|
|
||||||
|
|
||||||
return values;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Marks as invalid every checkmark that has timestamp either equal or newer
|
|
||||||
* than a given timestamp. These checkmarks will be recomputed at the next
|
|
||||||
* time they are queried.
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
public void recompute()
|
|
||||||
{
|
|
||||||
list.clear();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Writes the entire list of checkmarks to the given writer, in CSV format.
|
|
||||||
*
|
|
||||||
* @param out the writer where the CSV will be output
|
|
||||||
* @throws IOException in case write operations fail
|
|
||||||
*/
|
|
||||||
public final void writeCSV(Writer out) throws IOException
|
|
||||||
{
|
|
||||||
int values[];
|
|
||||||
|
|
||||||
synchronized (this)
|
|
||||||
{
|
|
||||||
compute();
|
|
||||||
values = getAllValues();
|
|
||||||
}
|
|
||||||
|
|
||||||
Timestamp timestamp = DateUtils.getToday();
|
|
||||||
SimpleDateFormat dateFormat = DateFormats.getCSVDateFormat();
|
|
||||||
|
|
||||||
for (int value : values)
|
|
||||||
{
|
|
||||||
String date = dateFormat.format(timestamp.toJavaDate());
|
|
||||||
out.write(String.format("%s,%d\n", date, value));
|
|
||||||
timestamp = timestamp.minus(1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Computes and stores one checkmark for each day, from the first habit
|
|
||||||
* repetition to today. If this list is already computed, does nothing.
|
|
||||||
*/
|
|
||||||
protected final synchronized void compute()
|
|
||||||
{
|
|
||||||
final Timestamp today = DateUtils.getTodayWithOffset();
|
|
||||||
|
|
||||||
Entry newest = getNewestComputed();
|
|
||||||
if (newest != null && newest.getTimestamp().equals(today)) return;
|
|
||||||
recompute();
|
|
||||||
|
|
||||||
List<Entry> entries = habit.getOriginalEntries().getKnown();
|
|
||||||
if(entries.isEmpty()) return;
|
|
||||||
final Timestamp from = entries.get(entries.size() - 1).getTimestamp();
|
|
||||||
|
|
||||||
if (from.isNewerThan(today)) return;
|
|
||||||
|
|
||||||
Entry[] reps = entries.stream().filter(e ->
|
|
||||||
!e.getTimestamp().isOlderThan(from) && !e.getTimestamp().isNewerThan(today)
|
|
||||||
).toArray(Entry[]::new);
|
|
||||||
List<Entry> repsAsList = Arrays.asList(reps);
|
|
||||||
Collections.reverse(repsAsList);
|
|
||||||
reps = repsAsList.toArray(reps);
|
|
||||||
|
|
||||||
if (habit.isNumerical()) computeNumerical(reps);
|
|
||||||
else computeYesNo(reps);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Nullable
|
|
||||||
protected Entry getNewestComputed()
|
|
||||||
{
|
|
||||||
if (list.isEmpty()) return null;
|
|
||||||
return list.get(0);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Nullable
|
|
||||||
protected Entry getOldestComputed()
|
|
||||||
{
|
|
||||||
if (list.isEmpty()) return null;
|
|
||||||
return list.get(list.size() - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
private void computeNumerical(Entry[] original)
|
|
||||||
{
|
|
||||||
if (original.length == 0) return;
|
|
||||||
|
|
||||||
Timestamp today = DateUtils.getTodayWithOffset();
|
|
||||||
Timestamp begin = original[0].getTimestamp();
|
|
||||||
|
|
||||||
int nDays = begin.daysUntil(today) + 1;
|
|
||||||
List<Entry> computed = new ArrayList<>(nDays);
|
|
||||||
for (int i = 0; i < nDays; i++)
|
|
||||||
computed.add(new Entry(today.minus(i), 0));
|
|
||||||
|
|
||||||
for (Entry e : original)
|
|
||||||
{
|
|
||||||
int offset = e.getTimestamp().daysUntil(today);
|
|
||||||
computed.set(offset, new Entry(e.getTimestamp(), e.getValue()));
|
|
||||||
}
|
|
||||||
|
|
||||||
add(computed);
|
|
||||||
}
|
|
||||||
|
|
||||||
private void computeYesNo(Entry[] original)
|
|
||||||
{
|
|
||||||
ArrayList<Interval> intervals;
|
|
||||||
intervals = buildIntervals(habit.getFrequency(), original);
|
|
||||||
snapIntervalsTogether(intervals);
|
|
||||||
add(buildEntriesFromInterval(original, intervals));
|
|
||||||
}
|
|
||||||
|
|
||||||
public List<Entry> getAll()
|
|
||||||
{
|
|
||||||
List<Entry> entries = habit.getOriginalEntries().getKnown();
|
|
||||||
if(entries.isEmpty()) return new ArrayList<>();
|
|
||||||
Entry oldest = entries.get(entries.size() - 1);
|
|
||||||
return getByInterval(oldest.getTimestamp(), DateUtils.getTodayWithOffset());
|
|
||||||
}
|
|
||||||
|
|
||||||
public boolean isCompletedToday()
|
|
||||||
{
|
|
||||||
int todayCheckmark = getTodayValue();
|
|
||||||
if (habit.isNumerical())
|
|
||||||
{
|
|
||||||
if (habit.getTargetType() == AT_LEAST)
|
|
||||||
return todayCheckmark / 1000.0 >= habit.getTargetValue();
|
|
||||||
else
|
|
||||||
return todayCheckmark / 1000.0 <= habit.getTargetValue();
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
return (todayCheckmark != NO && todayCheckmark != UNKNOWN);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static final class Interval
|
|
||||||
{
|
|
||||||
final Timestamp begin;
|
|
||||||
|
|
||||||
final Timestamp center;
|
|
||||||
|
|
||||||
final Timestamp end;
|
|
||||||
|
|
||||||
Interval(Timestamp begin, Timestamp center, Timestamp end)
|
|
||||||
{
|
|
||||||
if(begin.isNewerThan(center)) throw new IllegalArgumentException();
|
|
||||||
if(center.isNewerThan(end)) throw new IllegalArgumentException();
|
|
||||||
|
|
||||||
this.begin = begin;
|
|
||||||
this.center = center;
|
|
||||||
this.end = end;
|
|
||||||
}
|
|
||||||
|
|
||||||
public int length()
|
|
||||||
{
|
|
||||||
return begin.daysUntil(end) + 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public boolean equals(Object o)
|
|
||||||
{
|
|
||||||
if (this == o) return true;
|
|
||||||
|
|
||||||
if (o == null || getClass() != o.getClass()) return false;
|
|
||||||
|
|
||||||
Interval interval = (Interval) o;
|
|
||||||
|
|
||||||
return new EqualsBuilder()
|
|
||||||
.append(begin, interval.begin)
|
|
||||||
.append(center, interval.center)
|
|
||||||
.append(end, interval.end)
|
|
||||||
.isEquals();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public int hashCode()
|
|
||||||
{
|
|
||||||
return new HashCodeBuilder(17, 37)
|
|
||||||
.append(begin)
|
|
||||||
.append(center)
|
|
||||||
.append(end)
|
|
||||||
.toHashCode();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public String toString()
|
|
||||||
{
|
|
||||||
return new ToStringBuilder(this, defaultToStringStyle())
|
|
||||||
.append("begin", begin)
|
|
||||||
.append("center", center)
|
|
||||||
.append("end", end)
|
|
||||||
.toString();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@NonNull
|
|
||||||
public List<Entry> groupBy(DateUtils.TruncateField field, int firstWeekday)
|
|
||||||
{
|
|
||||||
return groupBy(field, firstWeekday, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@NonNull
|
|
||||||
public List<Entry> groupBy(DateUtils.TruncateField field,
|
|
||||||
int firstWeekday,
|
|
||||||
int maxGroups)
|
|
||||||
{
|
|
||||||
List<Entry> checks = getAll();
|
|
||||||
|
|
||||||
int count = 0;
|
|
||||||
Timestamp[] truncatedTimestamps = new Timestamp[checks.size()];
|
|
||||||
int[] values = new int[checks.size()];
|
|
||||||
|
|
||||||
for (Entry rep : checks)
|
|
||||||
{
|
|
||||||
Timestamp tt = rep.getTimestamp().truncate(field, firstWeekday);
|
|
||||||
if (count == 0 || !truncatedTimestamps[count - 1].equals(tt))
|
|
||||||
{
|
|
||||||
if (maxGroups > 0 && count >= maxGroups) break;
|
|
||||||
truncatedTimestamps[count++] = tt;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (habit.isNumerical())
|
|
||||||
values[count - 1] += rep.getValue();
|
|
||||||
else if (rep.getValue() == Entry.YES_MANUAL)
|
|
||||||
values[count - 1] += 1000;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
ArrayList<Entry> groupedEntries = new ArrayList<>();
|
|
||||||
for (int i = 0; i < count; i++)
|
|
||||||
{
|
|
||||||
Entry rep = new Entry(truncatedTimestamps[i], values[i]);
|
|
||||||
groupedEntries.add(rep);
|
|
||||||
}
|
|
||||||
|
|
||||||
return groupedEntries;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in new issue