all: gofmt

catTracks/db.go

@@ -12,11 +12,11 @@ import (
 )
 
 var (
-	db         *bolt.DB
-	trackKey   = "tracks"
-	statsKey = "stats"
+	db           *bolt.DB
+	trackKey     = "tracks"
+	statsKey     = "stats"
 	statsDataKey = "storage" // use: bucket.Put(statsDataKey, value), bucket.Get(statsDataKey)
-	allBuckets = []string{trackKey, statsKey, "names", "geohash"}
+	allBuckets   = []string{trackKey, statsKey, "names", "geohash"}
 )
 
 // GetDB is db getter.

catTracks/handlers.go

@@ -159,7 +159,7 @@ func uploadCSV(w http.ResponseWriter, r *http.Request) {
 }
 
 func getLastKnown(w http.ResponseWriter, r *http.Request) {
-	w.Header().Add("Access-Control-Allow-Origin","*")
+	w.Header().Add("Access-Control-Allow-Origin", "*")
 	b, e := getLastKnownData()
 	//b, e := json.Marshal(lastKnownMap)
 	if e != nil {
@@ -171,7 +171,7 @@ func getLastKnown(w http.ResponseWriter, r *http.Request) {
 }
 
 func getMetaData(w http.ResponseWriter, r *http.Request) {
-	w.Header().Add("Access-Control-Allow-Origin","*")
+	w.Header().Add("Access-Control-Allow-Origin", "*")
 
 	b, e := getmetadata()
 	if e != nil {
@@ -180,4 +180,4 @@ func getMetaData(w http.ResponseWriter, r *http.Request) {
 	}
 	fmt.Println("Got metadata:", len(b), "bytes")
 	w.Write(b)
-}
+}

catTracks/models.go

@@ -10,20 +10,20 @@ import (
 	"github.com/rotblauer/trackpoints/trackPoint"
 	"log"
 	"os"
-	"path/filepath"
 	"os/user"
+	"path/filepath"
 )
 
 var punktlichTileDBPathRelHome = filepath.Join("punktlich.rotblauer.com", "tester.db")
 
 type LastKnown map[string]trackPoint.TrackPoint
 type Metadata struct {
-	KeyN int
-	KeyNUpdated time.Time
-	LastUpdatedAt time.Time
-	LastUpdatedBy string
+	KeyN               int
+	KeyNUpdated        time.Time
+	LastUpdatedAt      time.Time
+	LastUpdatedBy      string
 	LastUpdatedPointsN int
-	TileDBLastUpdated time.Time
+	TileDBLastUpdated  time.Time
 }
 
 func getmetadata() (out []byte, err error) {
@@ -75,15 +75,15 @@ func storemetadata(lastpoint trackPoint.TrackPoint, lenpointsupdated int) error
 				return e
 			}
 		}
-		if md != nil && (md.KeyNUpdated.IsZero() || time.Since(md.KeyNUpdated) > 24 * time.Hour) {
+		if md != nil && (md.KeyNUpdated.IsZero() || time.Since(md.KeyNUpdated) > 24*time.Hour) {
 			log.Println("updating bucket stats key_n...")
-			log.Println("  because", md==nil, md.KeyNUpdated, md.KeyNUpdated.IsZero(), time.Since(md.KeyNUpdated) > 24 * time.Hour)
+			log.Println("  because", md == nil, md.KeyNUpdated, md.KeyNUpdated.IsZero(), time.Since(md.KeyNUpdated) > 24*time.Hour)
 			keyN = tx.Bucket([]byte(trackKey)).Stats().KeyN
 			log.Println("updated metadata keyN:", keyN)
 			keyNUpdated = time.Now().UTC()
 		} else {
-			log.Println("dont update keyn", md==nil, md.KeyNUpdated, md.KeyNUpdated.IsZero(), time.Since(md.KeyNUpdated) > 24 * time.Hour)
-			keyN = md.KeyN+lenpointsupdated
+			log.Println("dont update keyn", md == nil, md.KeyNUpdated, md.KeyNUpdated.IsZero(), time.Since(md.KeyNUpdated) > 24*time.Hour)
+			keyN = md.KeyN + lenpointsupdated
 		}
 
 		d := &Metadata{

catTracks/stats2_test.go

@@ -15,4 +15,4 @@ func TestStorageKeySetAndGet(t *testing.T) {
 	//t.Log("key", string(k))
 	//
 
-}
+}

testParse/main.go

@@ -1,78 +1,78 @@
 package main
- 
+
 import (
-        "fmt"
-        "log"
-        "net/http"
-        "net/url"
-        "strconv"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"strconv"
 )
- 
+
 // conversion helpers
 func parseBool(s string, dest interface{}) error {
-        d, ok := dest.(*bool)
-        if !ok {
-                return fmt.Errorf("wrong type for parseBool: %T", dest)
-        }
-        // assume error = false
-        *d, _ = strconv.ParseBool(s)
-        return nil
+	d, ok := dest.(*bool)
+	if !ok {
+		return fmt.Errorf("wrong type for parseBool: %T", dest)
+	}
+	// assume error = false
+	*d, _ = strconv.ParseBool(s)
+	return nil
 }
- 
+
 func parseInt(s string, dest interface{}) error {
-        d, ok := dest.(*int)
-        if !ok {
-                return fmt.Errorf("wrong type for parseInt: %T", dest)
-        }
-        n, err := strconv.Atoi(s)
-        if err != nil {
-                return err
-        }
-        *d = n
-        return nil
+	d, ok := dest.(*int)
+	if !ok {
+		return fmt.Errorf("wrong type for parseInt: %T", dest)
+	}
+	n, err := strconv.Atoi(s)
+	if err != nil {
+		return err
+	}
+	*d = n
+	return nil
 }
- 
+
 // parsingMap
 type parsingMap []parsingMapElem
- 
+
 type parsingMapElem struct {
-        Field string
-        Fct   func(string, interface{}) error
-        Dest  interface{}
+	Field string
+	Fct   func(string, interface{}) error
+	Dest  interface{}
 }
- 
+
 func (p parsingMap) parse(form url.Values) error {
-        for _, elem := range p {
-                if err := elem.Fct(elem.Field, elem.Dest); err != nil {
-                        return err
-                }
-        }
-        return nil
+	for _, elem := range p {
+		if err := elem.Fct(elem.Field, elem.Dest); err != nil {
+			return err
+		}
+	}
+	return nil
 }
- 
+
 // http server
 type query struct {
-        Limit  int
-        DryRun bool
+	Limit  int
+	DryRun bool
 }
- 
+
 func handler(w http.ResponseWriter, req *http.Request) {
-        if err := req.ParseForm(); err != nil {
-                log.Printf("Error parsing form: %s", err)
-                return
-        }
-        q := &query{}
-        if err := (parsingMap{
-                {"limit", parseInt, &q.Limit},
-                {"dryrun", parseBool, &q.DryRun},
-        }).parse(req.Form); err != nil {
-                log.Printf("Error parsing query string: %s", err)
-                return
-        }
- 
-        fmt.Fprintf(w, "hello world. Limit: %d, Dryrun: %t\n", q.Limit, q.DryRun)
+	if err := req.ParseForm(); err != nil {
+		log.Printf("Error parsing form: %s", err)
+		return
+	}
+	q := &query{}
+	if err := (parsingMap{
+		{"limit", parseInt, &q.Limit},
+		{"dryrun", parseBool, &q.DryRun},
+	}).parse(req.Form); err != nil {
+		log.Printf("Error parsing query string: %s", err)
+		return
+	}
+
+	fmt.Fprintf(w, "hello world. Limit: %d, Dryrun: %t\n", q.Limit, q.DryRun)
 }
- 
+
 func main() {
-        log.Fatal(http.ListenAndServe(":8080", http.HandlerFunc(handler)))
+	log.Fatal(http.ListenAndServe(":8080", http.HandlerFunc(handler)))
 }

testParse/main2.go

@@ -1,42 +1,42 @@
 package main
 
 import (
-    "encoding/json"
-    "log"
-    "net/http"
-    "time"
+	"encoding/json"
+	"log"
+	"net/http"
+	"time"
 
-    "github.com/creack/httpreq"
+	"github.com/creack/httpreq"
 )
 
 // Req is the request query struct.
 type Req struct {
-    Fields    []string
-    Limit     int
-    Page      int
-    Timestamp time.Time
+	Fields    []string
+	Limit     int
+	Page      int
+	Timestamp time.Time
 }
 
 func handler(w http.ResponseWriter, req *http.Request) {
-    if err := req.ParseForm(); err != nil {
-        http.Error(w, err.Error(), http.StatusBadRequest)
-        return
-    }
-    data := &Req{}
-    if err := (httpreq.ParsingMap{
-        {Field: "limit", Fct: httpreq.ToInt, Dest: &data.Limit},
-        {Field: "page", Fct: httpreq.ToInt, Dest: &data.Page},
-        {Field: "fields", Fct: httpreq.ToCommaList, Dest: &data.Fields},
-        {Field: "timestamp", Fct: httpreq.ToTSTime, Dest: &data.Timestamp},
-    }.Parse(req.Form)); err != nil {
-        http.Error(w, err.Error(), http.StatusBadRequest)
-        return
-    }
-    _ = json.NewEncoder(w).Encode(data)
+	if err := req.ParseForm(); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	data := &Req{}
+	if err := (httpreq.ParsingMap{
+		{Field: "limit", Fct: httpreq.ToInt, Dest: &data.Limit},
+		{Field: "page", Fct: httpreq.ToInt, Dest: &data.Page},
+		{Field: "fields", Fct: httpreq.ToCommaList, Dest: &data.Fields},
+		{Field: "timestamp", Fct: httpreq.ToTSTime, Dest: &data.Timestamp},
+	}.Parse(req.Form)); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	_ = json.NewEncoder(w).Encode(data)
 }
 
 func main() {
-    http.HandleFunc("/", handler)
-    log.Fatal(http.ListenAndServe(":8080", nil))
-    // curl 'http://localhost:8080?timestamp=1437743020&limit=10&page=1&fields=a,b,c'
+	http.HandleFunc("/", handler)
+	log.Fatal(http.ListenAndServe(":8080", nil))
+	// curl 'http://localhost:8080?timestamp=1437743020&limit=10&page=1&fields=a,b,c'
 }

testcalc.go

@@ -1,11 +1,11 @@
 package main
 
 import (
+	"fmt"
+	"github.com/boltdb/bolt"
 	"github.com/rotblauer/catTracks/catTracks"
 	"log"
-	"fmt"
 	"time"
-	"github.com/boltdb/bolt"
 )
 
 func main() {