func active(d db.DB) ([]*db.Entry, error) {
if itr, err := d.Query(db.Query{Active: true}); err != nil {
return nil, err
} else {
return db.IteratorEntries(itr)
}
}
func cmdLs(d db.DB, categoryS string, asc bool) {
if categories, err := d.Categories(); err != nil {
fatal(err)
} else if path, err := d.CategoryPath(ParseCategory(categoryS), false); err != nil {
fatal(err)
} else if itr, err := d.Query(db.Query{Asc: asc, CategoryID: path.CategoryID()}); err != nil {
fatal(err)
} else {
FprintIterator(os.Stdout, itr, categories, PrintDefault)
}
}
// Last returns the last entry or an error.
func Last(d db.DB) (*db.Entry, error) {
itr, err := d.Query(db.Query{})
if err != nil {
return nil, err
}
defer itr.Close()
if entry, err := itr.Next(); err == io.EOF {
return nil, errors.New("db is empty")
} else {
return entry, err
}
}
// ById returns the entry with the given id, or an error.
func ById(d db.DB, id string) (*db.Entry, error) {
itr, err := d.Query(db.Query{IDs: []string{id}})
if err != nil {
return nil, err
}
defer itr.Close()
if entry, err := itr.Next(); err == io.EOF {
return nil, fmt.Errorf("entry does not exist: %s", id)
} else {
return entry, err
}
}
// NewSummaryIterator returns a new summary iterator producing summaries for
// the given period and firstDay of the week. If the period is datetime.Day,
// it is is ignored. Callers are required to call Close once they are done
// with the iterator.
func NewSummaryIterator(d db.DB, period datetime.Period, firstDay time.Weekday, now time.Time) (*SummaryIterator, error) {
entries, err := d.Query(db.Query{})
if err != nil {
return nil, err
}
return &SummaryIterator{
now: now,
entries: entries,
period: period,
firstDay: firstDay,
}, nil
}
func cmdReport(d db.DB, categoryS, periodS, firstDayS string) {
period, err := datetime.ParsePeriod(periodS)
if err != nil {
fatal(err)
} else if period == datetime.Day {
fatal(errors.New("bad period: day"))
}
firstDay, err := datetime.ParseWeekday(firstDayS)
if err != nil {
fatal(err)
}
path, err := d.CategoryPath(ParseCategory(categoryS), false)
if err != nil {
fatal(err)
}
entryItr, err := d.Query(db.Query{CategoryID: path.CategoryID()})
if err != nil {
fatal(err)
}
defer entryItr.Close()
entry, err := entryItr.Next()
if err == io.EOF {
return
} else if err != nil {
fatal(err)
}
// @TODO move logic into separate function
now := time.Now()
reportItr := datetime.NewIterator(entry.Start, period, false, firstDay)
report := &Report{Duration: period}
report.From, report.To = reportItr.Next()
dayItr := datetime.NewIterator(report.To, datetime.Day, false, firstDay)
day := &ReportDay{}
day.From, day.To = dayItr.Next()
report.Days = append([]*ReportDay{day}, report.Days...)
noteAssigned := false
outer:
for {
var overlap time.Duration
for {
overlap = entry.PartialDuration(now, day.From, day.To)
if overlap > 0 {
day.Tracked += overlap
if !noteAssigned {
note := strings.Trim(entry.Note, "\n")
if note != "" {
day.Notes = append([]string{note}, day.Notes...)
}
noteAssigned = true
}
}
if !entry.Start.Before(day.From) {
entry, err = entryItr.Next()
if err == io.EOF {
fmt.Fprint(os.Stdout, FormatReport(report))
break outer
} else if err != nil {
fatal(err)
}
noteAssigned = false
continue
}
day = &ReportDay{}
day.From, day.To = dayItr.Next()
if day.To.Before(report.From) {
fmt.Fprint(os.Stdout, FormatReport(report))
report = &Report{Duration: period}
report.From, report.To = reportItr.Next()
}
report.Days = append([]*ReportDay{day}, report.Days...)
}
}
}