Replaced hardcoded ROLLOVER in 'get-events' with lookup based on firs…

…t/next event indices

Ref. #7

Makefile

@@ -62,7 +62,8 @@ bump:
 	go get -u github.com/uhppoted/uhppoted-lib
 
 debug: build
-	$(CLI) get-event $(SERIALNO) 17
+	$(CLI) get-event $(SERIALNO)
+	go test -v -run TestGetNextEvent* ./commands
 
 irl: build
 	$(CLI) set-time            423187757

TODO.md

@@ -1,10 +1,17 @@
 ## v0.7.x
 
-- [ ] Unit/integration test for door control
 - [ ] Fix get-events to handle rollover a la uhppoted-lib
+      - [x] Rework get-events
+      - [ ] Remove 'rollover' throughout
+      - [ ] Test rollover with simulator
+
+- [ ] Unit/integration test for door control
 
 ## TODO
 
+- [ ] --changelog
+      - https://bhupesh-v.github.io/why-how-add-changelog-in-your-next-cli/
+- [ ] https://capiche.com/e/consumer-dev-tools-command-palette
 - [ ] Check card number field for get-event
 - [ ] Route debugging to stderr
 - [ ] get-events --fetch

commands/get_event.go

@@ -3,28 +3,54 @@ package commands
 import (
 	"flag"
 	"fmt"
+	"regexp"
+	"strconv"
 )
 
 var GetEventCmd = GetEvent{}
 
 type GetEvent struct {
 }
 
-const ROLLOVER = 100000
-
 func (c *GetEvent) Execute(ctx Context) error {
 	serialNumber, err := getSerialNumber(ctx)
 	if err != nil {
 		return err
 	}
 
-	index, err := c.getIndex(ctx, serialNumber)
+	first, err := c.getFirstIndex(ctx, serialNumber)
+	if err != nil {
+		return err
+	}
+
+	last, err := c.getLastIndex(ctx, serialNumber)
+	if err != nil {
+		return err
+	}
+
+	current, err := c.getCurrentIndex(ctx, serialNumber)
 	if err != nil {
 		return err
 	}
 
-	if index > ROLLOVER {
-		index = 1
+	index := c.getNextIndex(first, last, current)
+	if len(flag.Args()) > 2 {
+		switch clean(flag.Args()[2]) {
+		case "first":
+			index = first
+
+		case "last":
+			index = last
+
+		case "next":
+
+		default:
+			if ix, err := c.getUint32(flag.Args()[2]); err != nil {
+				return err
+			} else {
+				index = ix
+			}
+		}
 	}
 
 	event, err := ctx.uhppote.GetEvent(serialNumber, index)
@@ -70,21 +96,21 @@ func (c *GetEvent) Help() {
 	fmt.Println(" Retrieves the event stored at the supplied index. If a specific index is not provided, the command")
 	fmt.Println(" defaults to the the current controller event-index and 'bumps' the controller index to the next.")
 	fmt.Println(" event. Fails with an error if the supplied index or current controller index is out of range to facilitate")
-	fmt.Println(" use with scripts that 'scrape' the event log.")
+	fmt.Println(" use with scripts that scrape the event log.")
 	fmt.Println()
 	fmt.Println(" NOTE: the event index 'wraps around' at 100000 and should not be used as a primary key")
 	fmt.Println()
 	fmt.Println("  serial-number  (required) controller serial number")
-	fmt.Println("  index          (optional) Event index. Defaults to the current controller event index if not provided.")
-	fmt.Println("                            Valid index values are:")
-	fmt.Println("                            - a number in the range 'first' to 'last' stored event. The event index 'wraps")
-	fmt.Println("                              around' at 100000 so if the 'last' index returned by get-events is less than")
-	fmt.Println("                              the 'first' index the event log has wrapped and any index in the range 1..100000")
-	fmt.Println("                              is valid")
+	fmt.Println("  index          (optional) Event index. Defaults to the index of the 'next' controller event if not provided.")
+	fmt.Println("                            Valid values are:")
+	fmt.Println("                            - a number in the range 'first' to 'last' stored event. Returns the 'last' event")
+	fmt.Println("                              if the index is greater than the index of the 'last' event.")
 	fmt.Println("                            - 'first' - retrieves the event corresponding to the event at the 'first' event index")
 	fmt.Println("                              returned by get-events")
 	fmt.Println("                            - 'last' - retrieves the event corresponding to the event at the 'last' event index")
 	fmt.Println("                              returned by get-events")
+	fmt.Println("                            - 'next' - retrieves the event corresponding to the event immediatedly subsequent to")
+	fmt.Println("                              event at the controller current event index")
 	fmt.Println()
 	fmt.Println("  Examples:")
 	fmt.Println()
@@ -119,39 +145,58 @@ func (c *GetEvent) RequiresConfig() bool {
 	return false
 }
 
-func (c *GetEvent) getIndex(ctx Context, serialNumber uint32) (uint32, error) {
-	if len(flag.Args()) > 2 {
-		if clean(flag.Args()[2]) == "first" {
-			first, err := ctx.uhppote.GetEvent(serialNumber, 0)
-			if err != nil {
-				return 0, err
-			} else if first == nil {
-				return 0, fmt.Errorf("Failed to retrieve 'first' event index")
-			}
-
-			return first.Index, nil
-		}
-
-		if clean(flag.Args()[2]) == "last" {
-			last, err := ctx.uhppote.GetEvent(serialNumber, 0xffffffff)
-			if err != nil {
-				return 0, err
-			} else if last == nil {
-				return 0, fmt.Errorf("Failed to retrieve 'last' event index")
-			}
-
-			return last.Index, nil
-		}
+func (c *GetEvent) getFirstIndex(ctx Context, serialNumber uint32) (uint32, error) {
+	if first, err := ctx.uhppote.GetEvent(serialNumber, 0); err != nil {
+		return 0, err
+	} else if first == nil {
+		return 0, fmt.Errorf("Failed to retrieve 'first' event index")
+	} else {
+		return first.Index, nil
+	}
+}
 
-		return getUint32(2, "Missing event index", "Invalid event index: %v")
+func (c *GetEvent) getLastIndex(ctx Context, serialNumber uint32) (uint32, error) {
+	if last, err := ctx.uhppote.GetEvent(serialNumber, 0xffffffff); err != nil {
+		return 0, err
+	} else if last == nil {
+		return 0, fmt.Errorf("Failed to retrieve 'last' event index")
+	} else {
+		return last.Index, nil
 	}
+}
 
-	index, err := ctx.uhppote.GetEventIndex(serialNumber)
-	if err != nil {
+func (c *GetEvent) getCurrentIndex(ctx Context, serialNumber uint32) (uint32, error) {
+	if index, err := ctx.uhppote.GetEventIndex(serialNumber); err != nil {
 		return 1, err
 	} else if index == nil {
 		return 1, fmt.Errorf("Failed to retrieve controller event index")
+	} else {
+		return index.Index, nil
 	}
+}
+
+func (c *GetEvent) getNextIndex(first, last, current uint32) uint32 {
+	next := current + 1
+
+	if last >= first {
+		if next < first {
+			return first
+		} else if next > last {
+			return last
+		}
+	} else if next < first && next > last {
+		return last
+	}
+
+	return next
+}
 
-	return index.Index + 1, nil
+func (c *GetEvent) getUint32(arg string) (uint32, error) {
+	if valid, _ := regexp.MatchString("[0-9]+", arg); !valid {
+		return 0, fmt.Errorf("Invalid event index: %v", arg)
+	} else if N, err := strconv.ParseUint(arg, 10, 32); err != nil {
+		return 0, fmt.Errorf("Invalid event index: %v", arg)
+	} else {
+		return uint32(N), nil
+	}
 }

commands/get_event_test.go

@@ -0,0 +1,32 @@
+package commands
+
+import (
+	"testing"
+)
+
+func TestGetNextEventIndex(t *testing.T) {
+	tests := []struct {
+		first    uint32
+		last     uint32
+		current  uint32
+		expected uint32
+	}{
+		// normal (last >= first)
+		{first: 5, last: 37, current: 17, expected: 18},
+		{first: 5, last: 37, current: 57, expected: 37},
+		{first: 5, last: 37, current: 3, expected: 5},
+
+		// rolled over (last < first)
+		{first: 37, last: 5, current: 57, expected: 58},
+		{first: 37, last: 5, current: 17, expected: 5},
+	}
+
+	cmd := GetEvent{}
+
+	for _, v := range tests {
+		next := cmd.getNextIndex(v.first, v.last, v.current)
+		if next != v.expected {
+			t.Errorf("Incorrect 'next' event - expected:%v, got:%v", v.expected, next)
+		}
+	}
+}