tme

repository.go (5633B)

---

 package main
 
 import (
 	"errors"
 	"fmt"
 	"io"
 	"io/fs"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 	"time"
 )
 
 type FSRepository struct {
 	rootPath string
 }
 
 func NewFSRepository(rootPath string) FSRepository {
 	return FSRepository{rootPath}
 }
 
 func (repo FSRepository) RunningEntry(group Group, entryTime *TimeContext) (Entry, error) {
 	entryPath := path.Join(repo.rootPath, group.Name, activeFile)
 	if _, err := os.Stat(entryPath); os.IsNotExist(err) {
 		return Entry{}, err
 	}
 
 	data, err := os.ReadFile(entryPath)
 	if err != nil {
 		return Entry{}, err
 	}
 
 	firstLine := strings.Split(string(data), "\n")[0]
 	start, _ := entryTime.ParseEntry(firstLine)
 
 	timeRange, err := NewTimeRange(start, time.Now())
 	if err != nil {
 		return Entry{}, err
 	}
 
 	return Entry{
 		TimeRange: timeRange,
 		Completed: false,
 	}, nil
 }
 
 func (r FSRepository) Save(group Group, entry Entry) error {
 	// TODO(tms) 22.10.22: maybe ask if user want create new folder (fe: typo)
 	groupPath := path.Join(r.rootPath, group.Name)
 	if err := os.MkdirAll(groupPath, os.ModePerm); err != nil {
 		return err
 	}
 
 	entryPath := path.Join(r.rootPath, group.Name, r.EntryName(entry))
 	if err := os.WriteFile(entryPath, []byte(r.EntryData(entry)), os.ModePerm); err != nil {
 		return err
 	}
 
 	return nil
 }
 
 func (repo FSRepository) EntryData(entry Entry) string {
 	if entry.Completed {
 		return fmt.Sprintf("%s\n%s\n", entry.TimeRange.Start.Format(DataTimeLayout), entry.TimeRange.Stop.Format(DataTimeLayout))
 	}
 
 	return fmt.Sprintf("%s\n", entry.TimeRange.Start.Format(DataTimeLayout))
 }
 
 func (r FSRepository) EntryName(entry Entry) string {
 	if entry.Completed {
 		return strings.Join([]string{entry.TimeRange.Start.Format(FileNameLayout), entry.TimeRange.Stop.Format(FileNameLayout)}, "_")
 	}
 
 	return activeFile
 }
 
 func (repo FSRepository) Remove(group Group, entry Entry) error {
 	entryPath := path.Join(repo.rootPath, group.Name, repo.EntryName(entry))
 	err := os.Remove(entryPath)
 	if err != nil {
 		return err
 	}
 
 	groupPath := path.Join(repo.rootPath, group.Name)
 	if empty, _ := repo.IsEmpty(groupPath); empty {
 		err = os.Remove(groupPath)
 		if err != nil {
 			return err
 		}
 	}
 
 	return nil
 }
 
 func (repo FSRepository) IsEmpty(groupPath string) (bool, error) {
 	f, err := os.Open(groupPath)
 	if err != nil {
 		return false, err
 	}
 	defer f.Close()
 
 	_, err = f.Readdirnames(1) // Or f.Readdir(1)
 	if err == io.EOF {
 		return true, nil
 	}
 
 	return false, err // Either not empty or error, suits both cases
 }
 
 func (repo FSRepository) ExistsEntry(group Group, entry Entry) bool {
 	fullPath := path.Join(repo.rootPath, group.Name, repo.EntryName(entry))
 	if _, err := os.Stat(fullPath); !os.IsNotExist(err) {
 		return true
 	}
 	return false
 }
 
 func (repo FSRepository) Exists(group Group) bool {
 	groupPath := path.Join(repo.rootPath, group.Name)
 	if _, err := os.Stat(groupPath); !os.IsNotExist(err) {
 		return true
 	}
 	return false
 }
 
 func (repo FSRepository) ListEntries(group Group, entryTime *TimeContext) ([]Entry, error) {
 	if !repo.Exists(group) {
 		return []Entry{}, errors.New("Group '" + group.Name + "' does not exist")
 	}
 
 	var entries []Entry
 	groupPath := path.Join(repo.rootPath, group.Name)
 	err := filepath.WalkDir(groupPath, func(path string, d fs.DirEntry, err error) error {
 		if d.IsDir() {
 			if path == groupPath {
 				return nil
 			}
 			return fs.SkipDir
 		}
 
 		entry, err := repo.find(path, entryTime)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			os.Exit(1)
 		}
 		entries = append(entries, entry)
 		return nil
 	})
 	if err != nil {
 		return []Entry{}, err
 	}
 
 	return entries, nil
 }
 
 func (repo FSRepository) ListGroups(groupPath string) ([]Group, error) {
 	var groups []Group
 	err := filepath.WalkDir(path.Join(repo.rootPath, groupPath), func(path string, d fs.DirEntry, err error) error {
 		if d.IsDir() {
 			if path == groupPath {
 				return nil
 			}
 			gp := strings.TrimPrefix(path, repo.rootPath)
 			gp = strings.TrimPrefix(gp, string(os.PathSeparator))
 			group := NewGroup(gp)
 			groups = append(groups, group)
 		}
 		return nil
 	})
 	if err != nil {
 		return []Group{}, err
 	}
 
 	return groups, nil
 }
 
 func (repo FSRepository) find(entryPath string, timeContext *TimeContext) (Entry, error) {
 	if _, err := os.Stat(entryPath); os.IsNotExist(err) {
 		return Entry{}, err
 	}
 
 	data, err := os.ReadFile(entryPath)
 	if err != nil {
 		return Entry{}, err
 	}
 
 	// TODO(tms) 11.11.22: format check
 	base := path.Base(entryPath)
 
 	lines := strings.Split(string(data), "\n")
 
 	if base == activeFile {
 		start, _ := timeContext.ParseEntry(lines[0])
 		timeRange, err := NewTimeRange(start, start.Add(time.Second))
 		return Entry{Completed: false, TimeRange: timeRange}, err
 	} else {
 		start, _ := timeContext.ParseEntry(lines[0])
 		stop, _ := timeContext.ParseEntry(lines[1])
 		timeRange, err := NewTimeRange(start, stop)
 		return Entry{Completed: true, TimeRange: timeRange}, err
 	}
 }
 
 func (repo FSRepository) Move(from Group, entries []Entry, to Group) (int, error) {
 	counter := 0
 
 	if !repo.Exists(from) {
 		return counter, errors.New("Group '" + from.Name + "' does not exist")
 	}
 
 	if !repo.Exists(to) {
 		return counter, errors.New("Group '" + from.Name + "' does not exist")
 	}
 
 	for _, entry := range entries {
 		entryPath := path.Join(repo.rootPath, from.Name, repo.EntryName(entry))
 		if !repo.ExistsEntry(from, entry) {
 			return counter, errors.New("Entry '" + entryPath + "' does not exist")
 		}
 
 		newEntryPath := path.Join(repo.rootPath, to.Name, repo.EntryName(entry))
 
 		err := os.Rename(entryPath, newEntryPath)
 		if err != nil {
 			return counter, err
 		}
 
 		counter = counter + 1
 	}
 
 	return counter, nil
 }