[WIP] 7 - Implementar HTTP DELETE/plants/{id}

elastic/client.go

@@ -0,0 +1,36 @@
+package elastic
+
+import (
+	es "github.com/elastic/go-elasticsearch/v8"
+	log "github.com/sirupsen/logrus"
+)
+
+var esInstance *es.Client
+
+// GetClient returns a client connected to the running elasticseach cluster
+func GetClient() (*es.Client, error) {
+	if esInstance != nil {
+		return esInstance, nil
+	}
+
+	cfg := es.Config{
+		Addresses: []string{
+			"http://elasticsearch:9200",
+			"http://elasticsearch2:9200",
+			"http://elasticsearch3:9200",
+		},
+	}
+	esClient, err := es.NewClient(cfg)
+	if err != nil {
+		log.WithFields(log.Fields{
+			"config": cfg,
+			"error":  err,
+		}).Error("Could not obtain an Elasticsearch client")
+
+		return nil, err
+	}
+
+	esInstance = esClient
+
+	return esInstance, nil
+}

elastic/dao/delete.go

@@ -0,0 +1,41 @@
+package elastic
+
+import (
+	"bytes"
+	"encoding/json"
+
+	"github.com/gdgtoledo/linneo/elastic"
+	"github.com/gdgtoledo/linneo/plants"
+	log "github.com/sirupsen/logrus"
+)
+
+func (id string) getQuery() map[string]interface{} {
+	query := map[string]interface{}{"query": {
+		match: {
+			id: id,
+		},
+	}}
+
+	return query
+}
+
+// Delete a plant by id
+func Delete(id string) (plants.DeleteByIDResult, error) {
+	result := plants.DeleteByIDResult{}
+
+	esClient, err := elastic.GetClient()
+
+	if err != nil {
+		return result, err
+	}
+
+	var buf bytes.Buffer
+
+	if err := json.NewEncoder(&buf).Encode(query); err != nil {
+		log.WithFields(log.Fields{
+			"error": err,
+		}).Error("Error encoding Elasticsearch query")
+
+		return result, err
+	}
+}

dao/elasticsearch.go → elastic/dao/search.go

@@ -1,52 +1,21 @@
-package dao
+package elastic
 
 import (
 	"bytes"
 	"encoding/json"
 	"fmt"
 
-	es "github.com/elastic/go-elasticsearch/v8"
+	"github.com/gdgtoledo/linneo/elastic"
+	"github.com/gdgtoledo/linneo/plants"
 	log "github.com/sirupsen/logrus"
 )
 
-var esInstance *es.Client
-
-// SearchResult wraps a search result
-type SearchResult map[string]interface{}
-
-// getElasticsearchClient returns a client connected to the running elasticseach cluster
-func getElasticsearchClient() (*es.Client, error) {
-	if esInstance != nil {
-		return esInstance, nil
-	}
-
-	cfg := es.Config{
-		Addresses: []string{
-			"http://elasticsearch:9200",
-			"http://elasticsearch2:9200",
-			"http://elasticsearch3:9200",
-		},
-	}
-	esClient, err := es.NewClient(cfg)
-	if err != nil {
-		log.WithFields(log.Fields{
-			"config": cfg,
-			"error":  err,
-		}).Error("Could not obtain an Elasticsearch client")
-
-		return nil, err
-	}
-
-	esInstance = esClient
-
-	return esInstance, nil
-}
-
 // Search executes a query in the proper index
-func Search(indexName string, query map[string]interface{}) (SearchResult, error) {
-	result := SearchResult{}
+func Search(query plants.SearchQueryByIndexName) (plants.SearchQueryByIndexNameResult, error) {
+	result := plants.SearchQueryByIndexNameResult{}
+
+	esClient, err := elastic.GetClient()
 
-	esClient, err := getElasticsearchClient()
 	if err != nil {
 		return result, err
 	}
@@ -65,7 +34,7 @@ func Search(indexName string, query map[string]interface{}) (SearchResult, error
 	}).Debug("Elasticsearch query")
 
 	res, err := esClient.Search(
-		esClient.Search.WithIndex(indexName),
+		esClient.Search.WithIndex(query.IndexName),
 		esClient.Search.WithBody(&buf),
 		esClient.Search.WithTrackTotalHits(true),
 		esClient.Search.WithPretty(),

main.go

@@ -3,28 +3,54 @@ package main
 import (
 	"net/http"
 
-	"github.com/gdgtoledo/linneo/dao"
+	"github.com/gdgtoledo/linneo/plants"
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
 )
 
-func searchPlants(c *gin.Context) {
-	res, err := dao.Search("plants", map[string]interface{}{})
+var routes = map[string]string{"plants": "/plants", "plant": "/plants/:id"}
+
+func handleSearchItems(c *gin.Context) {
+	searchQueryByIndexName := plants.SearchQueryByIndexName{
+		IndexName: "plants",
+		Query:     map[string]interface{}{},
+	}
+
+	res, err := plants.Search(searchQueryByIndexName)
+
 	log.WithFields(log.Fields{
 		"result": res,
 	}).Info("Query Result")
+
 	if err != nil {
 		log.WithFields(log.Fields{
 			"error": err,
 		}).Error("Error querying database")
 	}
+
 	c.String(http.StatusNoContent, "There are no plants in the primary storage")
 }
 
+func handleDeleteItem(c *gin.Context) {
+	var plant plants.Model
+	result, err := plants.Delete(plant.ID)
+
+	log.WithFields(log.Fields{
+		"result": result,
+	}).Info("Delete Query Result")
+
+	if err != nil {
+		log.WithFields(log.Fields{
+			"error": err,
+		}).Error("Error deleting a plant")
+	}
+}
+
 func setupRouter() *gin.Engine {
 	r := gin.Default()
 
-	r.GET("/plants", searchPlants)
+	r.GET(routes["plants"], handleSearchItems)
+	r.DELETE(routes["plant"], handleDeleteItem)
 
 	return r
 }

plants/delete.go

@@ -0,0 +1,9 @@
+package plants
+
+import dao "github.com/gdgtoledo/linneo/elastic/dao"
+
+// Delete by id
+func Delete(id string) (DeleteQueryByIDResult, error) {
+	result, err := dao.Delete(id)
+	return result, err
+}

plants/model.go

@@ -0,0 +1,27 @@
+package plants
+
+// Model for an item
+type Model struct {
+	ID      string
+	Name    string
+	Species string
+	Genere  string
+	Geo     string
+}
+
+// SearchQueryByIndexName struct
+type SearchQueryByIndexName struct {
+	IndexName string
+	Query     map[string]interface{}
+}
+
+// SearchQueryByIndexNameResult wraps a search result
+type SearchQueryByIndexNameResult map[string]interface{}
+
+// DeleteByIDResult wraps a delete item result
+type DeleteQueryByID interface {
+	getQuery() map[string]interface{}
+}
+
+// DeleteByIDResult wraps a delete item result
+type DeleteQueryByIDResult map[string]interface{}

plants/search.go

@@ -0,0 +1,11 @@
+package plants
+
+import (
+	dao "github.com/gdgtoledo/linneo/elastic/dao"
+)
+
+// Search by query with an indexName
+func Search(searchQueryByIndexName SearchQueryByIndexName) (SearchQueryByIndexNameResult, error) {
+	response, err := dao.Search(searchQueryByIndexName)
+	return response, err
+}