tme

commit 636629f1c160c3819ce8aafc7015407b8446e208
parent bbff3407dd17b80df84dd11241058b48e1efb716
Author: Tomas Nemec <owl@gtms.dev>
Date:   Fri, 14 Apr 2023 06:10:35 +0200

feat(move)

Diffstat:
M
command.go
 | 
100
+++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------
M
repository.go
 | 
29
+++++++++++++++++++++++++++++

2 files changed, 99 insertions(+), 30 deletions(-)
diff --git a/command.go b/command.go
@@ -310,44 +310,31 @@ func (c Command) Status() {
 	}
 }
 
-func (c Command) Remove() {
-	if len(c.args) != 1 {
-		fmt.Fprintln(os.Stderr, "rm <group>")
-		os.Exit(1)
-	}
-
-	groupArg, _ := c.nextArg()
-	if group := NewGroup(groupArg); !c.repository.Exists(group) {
-		fmt.Fprintln(os.Stderr, "group does not exists")
-		os.Exit(1)
-	}
-
-	// TODO: most fresh entry be 1
-	groups, err := c.repository.ListGroups(groupArg)
+func (c Command) selectEntry(groupPath string) (Group, Entry, error) {
+	groups, err := c.repository.ListGroups(groupPath)
 	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
+		return Group{}, Entry{}, err
 	}
 
 	type groupEntry struct {
-		group *Group
-		entry *Entry
+		group Group
+		entry Entry
 	}
 
 	gEntries := make(map[int]groupEntry)
 
+	// TODO: most fresh entry be 1
 	counter := 1
 	for _, group := range groups {
 		entries, err := c.repository.ListEntries(group, c.timeContext)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
+			return Group{}, Entry{}, err
 		}
 
 		for _, entry := range entries {
 			gEntries[counter] = groupEntry{
-				&group,
-				&entry,
+				group,
+				entry,
 			}
 			fmt.Printf("%d. %s\n", counter, sFormatEntry(group, entry))
 			counter = counter + 1
@@ -358,12 +345,32 @@ func (c Command) Remove() {
 	var number int
 	_, err = fmt.Scanln(&number)
 	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
+		return Group{}, Entry{}, err
 	}
 
 	ge := gEntries[number]
-	fmt.Printf("\n%s\n\nConfirm removal (y/n):", sFormatEntry(*ge.group, *ge.entry))
+	return ge.group, ge.entry, nil
+}
+
+func (c Command) Remove() {
+	if len(c.args) != 1 {
+		fmt.Fprintln(os.Stderr, "rm <group>")
+		os.Exit(1)
+	}
+
+	groupArg, _ := c.nextArg()
+	if group := NewGroup(groupArg); !c.repository.Exists(group) {
+		fmt.Fprintln(os.Stderr, "group does not exists")
+		os.Exit(1)
+	}
+
+	group, entry, err := c.selectEntry(groupArg)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	fmt.Printf("\n%s\n\nConfirm removal (y/n):", sFormatEntry(group, entry))
 
 	var answer string
 	_, err = fmt.Scanln(&answer)
@@ -373,7 +380,7 @@ func (c Command) Remove() {
 	}
 
 	if strings.ToLower(answer) == "y" {
-		err = c.repository.Remove(*ge.group, *ge.entry)
+		err = c.repository.Remove(group, entry)
 		if err != nil {
 			fmt.Print(err)
 			os.Exit(1)
@@ -388,8 +395,41 @@ func (c Command) Move() {
 		os.Exit(1)
 	}
 
-	// TODO(tms) 12.04.23:
-	// - list (recursively?) numbered entries from <group-from>
-	// - ... _selection same as for removal_ ...
-	// - move
+	groupFromArg, _ := c.nextArg()
+	groupFrom := NewGroup(groupFromArg)
+	if !c.repository.Exists(groupFrom) {
+		fmt.Fprintf(os.Stderr, "group-from %q does not exists\n", groupFrom.Name)
+		os.Exit(1)
+	}
+
+	groupToArg, _ := c.nextArg()
+	groupTo := NewGroup(groupToArg)
+	if !c.repository.Exists(groupTo) {
+		fmt.Fprintf(os.Stderr, "group-to %q does not exists\n", groupTo.Name)
+		os.Exit(1)
+	}
+
+	group, entry, err := c.selectEntry(groupFromArg)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	// TODO(tms) 14.04.23: format: <from> -> <to> [overwrite]
+	fmt.Printf("\n%s\n\nConfirm move (y/n):", sFormatEntry(group, entry))
+
+	var answer string
+	_, err = fmt.Scanln(&answer)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	if strings.ToLower(answer) == "y" {
+		_, err = c.repository.Move(groupFrom, []Entry{entry}, groupTo)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+	}
 }
diff --git a/repository.go b/repository.go
@@ -202,3 +202,32 @@ func (repo FSRepository) find(entryPath string, timeContext *TimeContext) (Entry
 		return Entry{Completed: true, TimeRange: timeRange}, err
 	}
 }
+
+func (repo FSRepository) Move(from Group, entries []Entry, to Group) (int, error) {
+	if !repo.Exists(from) {
+		return -1, errors.New("Group '" + from.Name + "' does not exist")
+	}
+
+	if !repo.Exists(to) {
+		return -1, errors.New("Group '" + from.Name + "' does not exist")
+	}
+
+	counter := 0
+	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
+}