From 6761f8d6663c40611af977a74d5803d6c7d8fa88 Mon Sep 17 00:00:00 2001
From: Darko Luketic <2694548+dalu@users.noreply.github.com>
Date: Wed, 28 Mar 2018 04:24:06 +0200
Subject: [PATCH] params consolidation, fixed numeric params

---
 api/handler/data.go |  30 ++++++-
 api/repo/data.go    | 193 +++++++++++++++-----------------------------
 cmd/api.go          |  10 +--
 3 files changed, 99 insertions(+), 134 deletions(-)

diff --git a/api/handler/data.go b/api/handler/data.go
index ea60b35..657c8c8 100644
--- a/api/handler/data.go
+++ b/api/handler/data.go
@@ -28,7 +28,7 @@ func (h *Handler) FindData(cx *gin.Context) {
 }
 
 func (h *Handler) ListData(cx *gin.Context) {
-	p := new(repo.DataListParams)
+	p := new(repo.DataParams)
 
 	startQuery := cx.Query("start")
 	if startQuery != "" {
@@ -56,6 +56,7 @@ func (h *Handler) ListData(cx *gin.Context) {
 	location := cx.Query("location")
 	age := cx.Query("age")
 	price := cx.Query("price")
+	enabled := cx.Query("enabled")
 
 	// string
 	if name == "1" {
@@ -120,6 +121,18 @@ func (h *Handler) ListData(cx *gin.Context) {
 		p.PriceQuery.To = to
 	}
 
+	if enabled == "1" {
+		p.Enabled = true
+		p.EnabledQuery = repo.DataEnabledQuery{}
+		if cx.Query("enabled.query") == "true" {
+			p.EnabledQuery.Query = true
+		} else if cx.Query("enabled.query") == "false" {
+			p.EnabledQuery.Query = false
+		} else {
+			p.Enabled = false
+		}
+	}
+
 	m, e := h.dataRepo.List(p)
 	if e != nil {
 		cx.AbortWithError(500, e)
@@ -129,7 +142,7 @@ func (h *Handler) ListData(cx *gin.Context) {
 }
 
 func (h *Handler) GetData(cx *gin.Context) {
-	p := new(repo.DataGetParams)
+	p := new(repo.DataParams)
 
 	id := cx.Query("id")
 	name := cx.Query("name")
@@ -137,6 +150,7 @@ func (h *Handler) GetData(cx *gin.Context) {
 	location := cx.Query("location")
 	age := cx.Query("age")
 	price := cx.Query("price")
+	enabled := cx.Query("enabled")
 
 	// id
 	if id == "1" {
@@ -210,6 +224,18 @@ func (h *Handler) GetData(cx *gin.Context) {
 		p.PriceQuery.To = to
 	}
 
+	if enabled == "1" {
+		p.Enabled = true
+		p.EnabledQuery = repo.DataEnabledQuery{}
+		if cx.Query("enabled.query") == "true" {
+			p.EnabledQuery.Query = true
+		} else if cx.Query("enabled.query") == "false" {
+			p.EnabledQuery.Query = false
+		} else {
+			p.Enabled = false
+		}
+	}
+
 	m, e := h.dataRepo.Get(p)
 	if e != nil {
 		cx.AbortWithError(500, e)
diff --git a/api/repo/data.go b/api/repo/data.go
index f374444..f759cce 100644
--- a/api/repo/data.go
+++ b/api/repo/data.go
@@ -49,38 +49,31 @@ type DataPriceQuery struct {
 	To        float64
 }
 
-type DataListParams struct {
-	Start int
-	Limit int
-	Sort  string
-
-	Name     bool
-	Address  bool
-	Location bool
-	Age      bool
-	Price    bool
-
-	NameQuery     DataNameQuery
-	AddressQuery  DataAddressQuery
-	LocationQuery DataLocationQuery
-	AgeQuery      DataAgeQuery
-	PriceQuery    DataPriceQuery
+// bool
+type DataEnabledQuery struct {
+	Query bool
 }
 
-type DataGetParams struct {
-	Id       bool
+type DataParams struct {
+	Start int    // list only
+	Limit int    // list only
+	Sort  string // list only
+
+	Id       bool // get only
 	Name     bool
 	Address  bool
 	Location bool
 	Age      bool
 	Price    bool
+	Enabled  bool
 
-	IdQuery       DataIdQuery
+	IdQuery       DataIdQuery // get only
 	NameQuery     DataNameQuery
 	AddressQuery  DataAddressQuery
 	LocationQuery DataLocationQuery
 	AgeQuery      DataAgeQuery
 	PriceQuery    DataPriceQuery
+	EnabledQuery  DataEnabledQuery
 }
 
 type DataRepository struct {
@@ -102,12 +95,10 @@ func (r *DataRepository) Close() {
 	r.ms.Close()
 }
 
-func (r *DataRepository) List(p *DataListParams) ([]*model.Data, error) {
+func (r *DataRepository) List(p *DataParams) ([]*model.Data, error) {
 	ms := r.ms.Copy()
 	defer ms.Close()
-
 	c := ms.DB(r.database).C(r.collection)
-
 	q := bson.M{}
 
 	// string
@@ -130,6 +121,16 @@ func (r *DataRepository) List(p *DataListParams) ([]*model.Data, error) {
 		}
 	}
 
+	// string
+	if p.Location {
+		switch p.LocationQuery.Operation {
+		case "eq":
+			q["address"] = p.LocationQuery.Query
+		case "regex":
+			q["address"] = bson.RegEx{Pattern: p.LocationQuery.Query, Options: p.LocationQuery.Options}
+		}
+	}
+
 	// int64
 	if p.Age {
 		switch p.AgeQuery.Operation {
@@ -143,34 +144,46 @@ func (r *DataRepository) List(p *DataListParams) ([]*model.Data, error) {
 			q["age"] = bson.M{"$gte": p.AgeQuery.From, "$lt": p.AgeQuery.To}
 		case "gt-lte":
 			q["age"] = bson.M{"$gt": p.AgeQuery.From, "$lte": p.AgeQuery.To}
+		case "gt":
+			q["age"] = bson.M{"$gt": p.AgeQuery.From}
+		case "gte":
+			q["age"] = bson.M{"$gte": p.AgeQuery.From}
+		case "lt":
+			q["age"] = bson.M{"$lt": p.AgeQuery.To}
+		case "lte":
+			q["age"] = bson.M{"$lte": p.AgeQuery.To}
 		}
 	}
 
-	// string
-	if p.Location {
-		switch p.LocationQuery.Operation {
-		case "eq":
-			q["address"] = p.LocationQuery.Query
-		case "regex":
-			q["address"] = bson.RegEx{Pattern: p.LocationQuery.Query, Options: p.LocationQuery.Options}
-		}
-	}
-
+	// float64
 	if p.Price {
 		switch p.PriceQuery.Operation {
 		case "eq":
-			q["age"] = p.PriceQuery.From
+			q["price"] = p.PriceQuery.From
+		case "gt":
+			q["price"] = bson.M{"$gt": p.PriceQuery.From}
+		case "gte":
+			q["price"] = bson.M{"$gte": p.PriceQuery.From}
+		case "lt":
+			q["price"] = bson.M{"$lt": p.PriceQuery.To}
+		case "lte":
+			q["price"] = bson.M{"$lte": p.PriceQuery.To}
 		case "gt-lt":
-			q["age"] = bson.M{"$gt": p.PriceQuery.From, "$lt": p.PriceQuery.To}
+			q["price"] = bson.M{"$gt": p.PriceQuery.From, "$lt": p.PriceQuery.To}
 		case "gte-lte":
-			q["age"] = bson.M{"$gte": p.PriceQuery.From, "$lte": p.PriceQuery.To}
+			q["price"] = bson.M{"$gte": p.PriceQuery.From, "$lte": p.PriceQuery.To}
 		case "gte-lt":
-			q["age"] = bson.M{"$gte": p.PriceQuery.From, "$lt": p.PriceQuery.To}
+			q["price"] = bson.M{"$gte": p.PriceQuery.From, "$lt": p.PriceQuery.To}
 		case "gt-lte":
-			q["age"] = bson.M{"$gt": p.PriceQuery.From, "$lte": p.PriceQuery.To}
+			q["price"] = bson.M{"$gt": p.PriceQuery.From, "$lte": p.PriceQuery.To}
 		}
 	}
 
+	// bool
+	if p.Enabled {
+		q["enabled"] = p.EnabledQuery.Query
+	}
+
 	var m []*model.Data
 	rq := c.Find(q)
 
@@ -193,7 +206,7 @@ func (r *DataRepository) List(p *DataListParams) ([]*model.Data, error) {
 	return m, nil
 }
 
-func (r *DataRepository) Get(p *DataGetParams) (*model.Data, error) {
+func (r *DataRepository) Get(p *DataParams) (*model.Data, error) {
 	ms := r.ms.Copy()
 	defer ms.Close()
 
@@ -226,6 +239,16 @@ func (r *DataRepository) Get(p *DataGetParams) (*model.Data, error) {
 		}
 	}
 
+	// string
+	if p.Location {
+		switch p.LocationQuery.Operation {
+		case "eq":
+			q["address"] = p.LocationQuery.Query
+		case "regex":
+			q["address"] = bson.RegEx{Pattern: p.LocationQuery.Query, Options: p.LocationQuery.Options}
+		}
+	}
+
 	// int64
 	if p.Age {
 		switch p.AgeQuery.Operation {
@@ -242,16 +265,7 @@ func (r *DataRepository) Get(p *DataGetParams) (*model.Data, error) {
 		}
 	}
 
-	// string
-	if p.Location {
-		switch p.LocationQuery.Operation {
-		case "eq":
-			q["address"] = p.LocationQuery.Query
-		case "regex":
-			q["address"] = bson.RegEx{Pattern: p.LocationQuery.Query, Options: p.LocationQuery.Options}
-		}
-	}
-
+	// float64
 	if p.Price {
 		switch p.PriceQuery.Operation {
 		case "eq":
@@ -267,6 +281,11 @@ func (r *DataRepository) Get(p *DataGetParams) (*model.Data, error) {
 		}
 	}
 
+	// bool
+	if p.Enabled {
+		q["enabled"] = p.EnabledQuery.Query
+	}
+
 	m := new(model.Data)
 	rq := c.Find(q)
 
@@ -277,84 +296,6 @@ func (r *DataRepository) Get(p *DataGetParams) (*model.Data, error) {
 	return m, nil
 }
 
-func (r *DataRepository) GetCount(p *DataGetParams) (int, error) {
-	ms := r.ms.Copy()
-	defer ms.Close()
-
-	c := ms.DB(r.database).C(r.collection)
-
-	q := bson.M{}
-
-	// id
-	if p.Id {
-		q["_id"] = bson.ObjectIdHex(p.IdQuery.Id)
-	}
-
-	// string
-	if p.Name {
-		switch p.NameQuery.Operation {
-		case "eq":
-			q["name"] = p.NameQuery.Query
-		case "regex":
-			q["name"] = bson.RegEx{Pattern: p.NameQuery.Query, Options: p.NameQuery.Options}
-		}
-	}
-
-	// string
-	if p.Address {
-		switch p.AddressQuery.Operation {
-		case "eq":
-			q["address"] = p.AddressQuery.Query
-		case "regex":
-			q["address"] = bson.RegEx{Pattern: p.AddressQuery.Query, Options: p.AddressQuery.Options}
-		}
-	}
-
-	// int64
-	if p.Age {
-		switch p.AgeQuery.Operation {
-		case "eq":
-			q["age"] = p.AgeQuery.From
-		case "gt-lt":
-			q["age"] = bson.M{"$gt": p.AgeQuery.From, "$lt": p.AgeQuery.To}
-		case "gte-lte":
-			q["age"] = bson.M{"$gte": p.AgeQuery.From, "$lte": p.AgeQuery.To}
-		case "gte-lt":
-			q["age"] = bson.M{"$gte": p.AgeQuery.From, "$lt": p.AgeQuery.To}
-		case "gt-lte":
-			q["age"] = bson.M{"$gt": p.AgeQuery.From, "$lte": p.AgeQuery.To}
-		}
-	}
-
-	// string
-	if p.Location {
-		switch p.LocationQuery.Operation {
-		case "eq":
-			q["address"] = p.LocationQuery.Query
-		case "regex":
-			q["address"] = bson.RegEx{Pattern: p.LocationQuery.Query, Options: p.LocationQuery.Options}
-		}
-	}
-
-	if p.Price {
-		switch p.PriceQuery.Operation {
-		case "eq":
-			q["age"] = p.PriceQuery.From
-		case "gt-lt":
-			q["age"] = bson.M{"$gt": p.PriceQuery.From, "$lt": p.PriceQuery.To}
-		case "gte-lte":
-			q["age"] = bson.M{"$gte": p.PriceQuery.From, "$lte": p.PriceQuery.To}
-		case "gte-lt":
-			q["age"] = bson.M{"$gte": p.PriceQuery.From, "$lt": p.PriceQuery.To}
-		case "gt-lte":
-			q["age"] = bson.M{"$gt": p.PriceQuery.From, "$lte": p.PriceQuery.To}
-		}
-	}
-
-	rq := c.Find(q)
-	return rq.Count()
-}
-
 func (r *DataRepository) Create(m *model.Data) error {
 	ms := r.ms.Copy()
 	defer ms.Close()
diff --git a/cmd/api.go b/cmd/api.go
index d240b36..f435d8f 100644
--- a/cmd/api.go
+++ b/cmd/api.go
@@ -1,20 +1,18 @@
 package cmd
 
 import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-	"github.com/gin-gonic/gin"
 	"git.icod.de/dalu/refdata/api/handler"
 	"git.icod.de/dalu/refdata/api/repo"
+	"github.com/gin-gonic/gin"
 	"github.com/globalsign/mgo"
+	"github.com/spf13/cobra"
 )
 
 // apiCmd represents the api command
 var apiCmd = &cobra.Command{
 	Use:   "api",
 	Short: "starts serving the api",
-	Long: `starts serving the api`,
+	Long:  `starts serving the api`,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		ms, e := mgo.Dial("localhost")
 		if e != nil {
@@ -24,7 +22,7 @@ var apiCmd = &cobra.Command{
 		r := gin.Default()
 		api := r.Group("/api/v1")
 
-		dataRepo := repo.NewDataRepository(ms, "ApiName", "data")
+		dataRepo := repo.NewDataRepository(ms, "apiname", "data")
 		h := handler.NewHandler(dataRepo)
 		h.DataRoutes(api)