gime-lib/model_timeentry.go

package gime

import (
	"errors"
	"strconv"
	"time"

	"github.com/br0xen/boltease"
)

// FindTimeEntryByUUID searches all entries
// for the time entry with the given uuid, return the TimeEntry, the type, and/or and error
// Types are searched TypeCurrent -> TypeRecent -> TypeArchive
func (gdb *GimeDB) FindTimeEntryByUUID(uuid string) (*TimeEntry, string, error) {
	for i := range gdb.AllTypes {
		timeCollection := gdb.LoadTimeEntryCollection(gdb.AllTypes[i])
		for j := 0; j < timeCollection.Length(); j++ {
			if timeCollection.Get(j).GetUUID() == uuid {
				return timeCollection.Get(j), gdb.AllTypes[i], nil
			}
		}
	}
	return nil, TypeUnknown, errors.New("Unable to find time entry with uuid " + uuid)
}

// SaveTimeEntry creates a time entry in the database
// If TimeEntry.end is zero, then it puts it in TypeCurrent
func (gdb *GimeDB) SaveTimeEntry(te *TimeEntry) error {
	var err error
	var useDb *boltease.DB
	tp := TypeRecent
	if te.end.IsZero() {
		// Currently running
		tp = TypeCurrent
	} else {
		// We have an end time. Does this entry go in 'recent' or 'archive'
		// We shove times that happened 30 days ago into 'archive'
		if time.Since(te.end) > (time.Hour * 24 * 30) {
			tp = TypeArchive
		}
	}
	useDb, err = gdb.openDBType(tp)
	if err != nil {
		return err
	}
	tePath := []string{tp, te.start.Format(time.RFC3339)}
	if err = useDb.SetValue(tePath, "uuid", te.uuid); err != nil {
		return err
	}
	if err = useDb.SetTimestamp(tePath, "start", te.start); err != nil {
		return err
	}
	if err = useDb.SetTimestamp(tePath, "end", te.end); err != nil {
		return err
	}
	for i := 0; i < te.tags.Length(); i++ {
		err = useDb.SetValue(append(tePath, "tags"), strconv.Itoa(i), te.tags.Get(i))
	}
	return nil
}

// UpdateTimeEntry updates the time entry in the database
// It first finds the current entry in the database by the uuid
func (gdb *GimeDB) UpdateTimeEntry(te *TimeEntry) error {
	var err error
	if te.uuid == "" {
		return errors.New("Given time entry has no uuid")
	}
	if err = gdb.RemoveTimeEntry(te.uuid); err != nil {
		return err
	}
	return gdb.SaveTimeEntry(te)
}

// RemoveTimeEntry removes a time entry with the given uuid from the database
func (gdb *GimeDB) RemoveTimeEntry(uuid string) error {
	fndEntry, tp, err := gdb.FindTimeEntryByUUID(uuid)
	if err != nil {
		return errors.New("Unable to find time entry with uuid " + uuid)
	}

	var useDb *boltease.DB
	if useDb, err = gdb.openDBType(tp); err != nil {
		return err
	}
	defer gdb.closeDBType(tp)
	if err != nil {
		return err
	}
	return useDb.DeleteBucket([]string{tp}, fndEntry.start.Format(time.RFC3339))
}

// dbGetAllTimeEntries gets all time entries of a specific type
// tp can be:
// TypeCurrent = "current"
// TypeRecent  = "recent"
// TypeArchive = "archive"
// TypeUnknown = "unknown" - Returns _ALL_ entries
// Getting all archived time entries has the potential to be a lot of data
func (gdb *GimeDB) dbGetAllTimeEntries(tp string) []TimeEntry {
	var ret []TimeEntry
	if tp == TypeUnknown {
		for _, v := range gdb.AllTypes {
			ret = append(ret, gdb.dbGetAllTimeEntries(v)...)
		}
		return ret
	}
	var useDb *boltease.DB
	var err error
	if useDb, err = gdb.openDBType(tp); err != nil {
		return ret
	}
	defer gdb.closeDBType(tp)

	var sttimes []string
	if sttimes, err = useDb.GetBucketList([]string{tp}); err != nil {
		return ret
	}
	for _, v := range sttimes {
		if te, _ := gdb.dbGetTimeEntry(tp, v); te != nil {
			ret = append(ret, *te)
		}
	}
	return ret
}

// dbGetTimeEntry pulls a time entry of type tp with the given id
// from the db and returns it.
func (gdb *GimeDB) dbGetTimeEntry(tp, sttm string) (*TimeEntry, error) {
	var ret *TimeEntry
	var err error
	if tp == TypeUnknown {
		// Loop through the types and return the first entry found that matches
		for _, v := range gdb.AllTypes {
			ret, _ = gdb.dbGetTimeEntry(v, sttm)
			if ret != nil {
				return ret, nil
			}
		}
		return nil, errors.New("Couldn't find time entry")
	}
	var useDb *boltease.DB
	if useDb, err = gdb.openDBType(tp); err != nil {
		return ret, err
	}
	defer gdb.closeDBType(tp)

	entryPath := []string{tp, sttm}
	ret = new(TimeEntry)
	if ret.uuid, err = useDb.GetValue(entryPath, "uuid"); err != nil {
		return nil, errors.New("Unable to read entry uuid")
	}
	if ret.start, err = useDb.GetTimestamp(entryPath, "start"); err != nil {
		return nil, errors.New("Unable to read entry start time")
	}
	if ret.end, err = useDb.GetTimestamp(entryPath, "end"); err != nil {
		return nil, errors.New("Unable to read entry end time")
	}
	var keys []string
	entryTagsPath := append(entryPath, "tags")
	if keys, err = useDb.GetKeyList(entryTagsPath); err != nil {
		keys = []string{}
	}
	ret.tags = new(TagCollection)
	for i := range keys {
		var val string
		if val, err = useDb.GetValue(entryTagsPath, keys[i]); err == nil {
			ret.tags.Push(val)
		}
	}
	return ret, nil
}