wip

go.mod

@@ -0,0 +1,12 @@
+module git.crumpington.com/lib/go
+
+go 1.23.2
+
+require (
+	github.com/lib/pq v1.10.9
+	github.com/mattn/go-sqlite3 v1.14.24
+	golang.org/x/crypto v0.29.0
+	golang.org/x/net v0.31.0
+)
+
+require golang.org/x/text v0.20.0 // indirect

go.sum

@@ -0,0 +1,10 @@
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
+github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
+golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
+golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
+golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
+golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
+golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=

webutil/formscanner.go

@@ -2,8 +2,8 @@ package webutil
 
 import (
 	"errors"
+	"fmt"
 	"net/url"
-	"strconv"
 )
 
 var ErrUnsupportedType = errors.New("unsupported type")
@@ -25,82 +25,10 @@ func (s *FormScanner) Scan(name string, val any) *FormScanner {
 	switch v := val.(type) {
 	case *bool:
 		*v = s.form.Has(name)
-	case *string:
-		*v = s.form.Get(name)
-	case *int:
-		if i, err := strconv.ParseInt(s.form.Get(name), 10, 64); err != nil {
-			s.err = err
-		} else {
-			*v = int(i)
-		}
-	case *int8:
-		if i, err := strconv.ParseInt(s.form.Get(name), 10, 8); err != nil {
-			s.err = err
-		} else {
-			*v = int8(i)
-		}
-	case *int16:
-		if i, err := strconv.ParseInt(s.form.Get(name), 10, 16); err != nil {
-			s.err = err
-		} else {
-			*v = int16(i)
-		}
-	case *int32:
-		if i, err := strconv.ParseInt(s.form.Get(name), 10, 32); err != nil {
-			s.err = err
-		} else {
-			*v = int32(i)
-		}
-	case *int64:
-		if i, err := strconv.ParseInt(s.form.Get(name), 10, 64); err != nil {
-			s.err = err
-		} else {
-			*v = int64(i)
-		}
-	case *uint:
-		if i, err := strconv.ParseUint(s.form.Get(name), 10, 64); err != nil {
-			s.err = err
-		} else {
-			*v = uint(i)
-		}
-	case *uint8:
-		if i, err := strconv.ParseUint(s.form.Get(name), 10, 8); err != nil {
-			s.err = err
-		} else {
-			*v = uint8(i)
-		}
-	case *uint16:
-		if i, err := strconv.ParseUint(s.form.Get(name), 10, 16); err != nil {
-			s.err = err
-		} else {
-			*v = uint16(i)
-		}
-	case *uint32:
-		if i, err := strconv.ParseUint(s.form.Get(name), 10, 32); err != nil {
-			s.err = err
-		} else {
-			*v = uint32(i)
-		}
-	case *uint64:
-		if i, err := strconv.ParseUint(s.form.Get(name), 10, 64); err != nil {
-			s.err = err
-		} else {
-			*v = uint64(i)
-		}
-	case *float32:
-		if f, err := strconv.ParseFloat(s.form.Get(name), 32); err != nil {
-			s.err = err
-		} else {
-			*v = float32(f)
-		}
-	case *float64:
-		if f, err := strconv.ParseFloat(s.form.Get(name), 64); err != nil {
-			s.err = err
-		} else {
-			*v = float64(f)
-		}
 	default:
-		s.err = ErrUnsupportedType
+		if err := scan(s.form.Get(name), v); err != nil {
+			s.err = fmt.Errorf("Error in field %s: %w", name, err)
+		}
 	}
 
 	return s

webutil/pathscaner.go

@@ -0,0 +1,31 @@
+package webutil
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type PathScanner struct {
+	r   *http.Request
+	err error
+}
+
+func NewPathScanner(r *http.Request) *PathScanner {
+	return &PathScanner{r: r}
+}
+
+func (s *PathScanner) Scan(name string, val any) *PathScanner {
+	if s.err != nil {
+		return s
+	}
+
+	if err := scan(s.r.PathValue(name), val); err != nil {
+		s.err = fmt.Errorf("Error in field %s: %w", name, err)
+	}
+
+	return s
+}
+
+func (s *PathScanner) Error() error {
+	return s.err
+}

webutil/scanner.go

@@ -0,0 +1,85 @@
+package webutil
+
+import "strconv"
+
+func scan(raw string, val any) error {
+	switch v := val.(type) {
+	case *string:
+		*v = raw
+	case *int:
+		if i, err := strconv.ParseInt(raw, 10, 64); err != nil {
+			return err
+		} else {
+			*v = int(i)
+		}
+	case *int8:
+		if i, err := strconv.ParseInt(raw, 10, 8); err != nil {
+			return err
+		} else {
+			*v = int8(i)
+		}
+	case *int16:
+		if i, err := strconv.ParseInt(raw, 10, 16); err != nil {
+			return err
+		} else {
+			*v = int16(i)
+		}
+	case *int32:
+		if i, err := strconv.ParseInt(raw, 10, 32); err != nil {
+			return err
+		} else {
+			*v = int32(i)
+		}
+	case *int64:
+		if i, err := strconv.ParseInt(raw, 10, 64); err != nil {
+			return err
+		} else {
+			*v = int64(i)
+		}
+	case *uint:
+		if i, err := strconv.ParseUint(raw, 10, 64); err != nil {
+			return err
+		} else {
+			*v = uint(i)
+		}
+	case *uint8:
+		if i, err := strconv.ParseUint(raw, 10, 8); err != nil {
+			return err
+		} else {
+			*v = uint8(i)
+		}
+	case *uint16:
+		if i, err := strconv.ParseUint(raw, 10, 16); err != nil {
+			return err
+		} else {
+			*v = uint16(i)
+		}
+	case *uint32:
+		if i, err := strconv.ParseUint(raw, 10, 32); err != nil {
+			return err
+		} else {
+			*v = uint32(i)
+		}
+	case *uint64:
+		if i, err := strconv.ParseUint(raw, 10, 64); err != nil {
+			return err
+		} else {
+			*v = uint64(i)
+		}
+	case *float32:
+		if f, err := strconv.ParseFloat(raw, 32); err != nil {
+			return err
+		} else {
+			*v = float32(f)
+		}
+	case *float64:
+		if f, err := strconv.ParseFloat(raw, 64); err != nil {
+			return err
+		} else {
+			*v = float64(f)
+		}
+	default:
+		return ErrUnsupportedType
+	}
+	return nil
+}