Get file, POST file, POST schematic, Fulltext search

schematic-service-go/api/schematicapi.go

@@ -1,11 +1,17 @@
 package api
 
 import (
+	"bufio"
+	"fmt"
+	"log"
 	"net/http"
+	"strconv"
+	"time"
 
 	"github.com/go-chi/chi"
 	"github.com/go-chi/render"
 	"github.com/willie68/schematic-service-go/dao"
+	"github.com/willie68/schematic-service-go/model"
 )
 
 //SchematicsRoutes getting all routes for the config endpoint
@@ -16,7 +22,8 @@ func SchematicsRoutes() *chi.Mux {
 	router.Delete("/{schematicId}", DeleteSchematicEndpoint)
 	router.Put("/{schematicId}", UpdateSchematicEndpoint)
 	router.Get("/{schematicId}", GetSchematicHandler)
-	router.Get("/{schematicId}/files/{fileId}", GetSchematicFileHandler)
+	router.Get("/files/{fileId}", GetSchematicFileHandler)
+	router.Post("/files", PostFileEndpoint)
 	return router
 }
 
@@ -45,18 +52,83 @@ func GetSchematicFileHandler(response http.ResponseWriter, req *http.Request) {
 
 // GetTenantsHandler gets all tenants
 func GetSchematicsEndpoint(response http.ResponseWriter, req *http.Request) {
-	/*
-		var tenants []dto.Tenant
-		err := dao.Get().All("tenants", &tenants)
+	offset := 0
+	limit := 10
+	query := req.URL.Query().Get("query")
+	offsetStr := req.URL.Query().Get("offset")
+	limitStr := req.URL.Query().Get("limit")
+	var err error
+	if offsetStr != "" {
+		offset, err = strconv.Atoi(offsetStr)
 		if err != nil {
 			Msg(response, http.StatusBadRequest, err.Error())
 			return
 		}
-	*/
-	render.JSON(response, req, "tenants")
+	}
+
+	if limitStr != "" {
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil {
+			Msg(response, http.StatusBadRequest, err.Error())
+			return
+		}
+	}
+	log.Printf("query: %s, offset: %d, limit: %d\n", query, offset, limit)
+
+	schematics, err := dao.GetSchematics(query, offset, limit)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	render.JSON(response, req, schematics)
 }
 
 func PostSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
+	var schematic model.Schematic
+	err := render.DefaultDecoder(req, &schematic)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	schematic.CreatedAt = time.Now()
+	schematic.LastModifiedAt = time.Now()
+	id, err := dao.CreateSchematic(schematic)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	schematic, err = dao.GetSchematic(id)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	render.Status(req, http.StatusCreated)
+	render.JSON(response, req, schematic)
+}
+
+func PostFileEndpoint(response http.ResponseWriter, req *http.Request) {
+	req.ParseForm()
+	f, fileHeader, err := req.FormFile("file")
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	//mimeType := fileHeader.Header.Get("Content-type")
+	filename := fileHeader.Filename
+	reader := bufio.NewReader(f)
+
+	fileid, err := dao.AddFile(filename, reader)
+	if err != nil {
+		fmt.Printf("%v\n", err)
+	} else {
+		fmt.Printf("fileid: %s\n", fileid)
+	}
+
+	location := fmt.Sprintf("/api/v1/schematics/files/%s", fileid)
+	response.Header().Add("Location", location)
+	render.Status(req, http.StatusCreated)
+	render.JSON(response, req, fileid)
 }
 
 func DeleteSchematicEndpoint(response http.ResponseWriter, req *http.Request) {

schematic-service-go/dao/mongodao.go

@@ -109,6 +109,10 @@ func initIndexSchematics() {
 				Keys:    bson.D{{"subtitle", 1}},
 				Options: options.Index().SetName("subtitle").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
 			},
+			{
+				Keys:    bson.D{{"manufacturer", "text"}, {"model", "text"}, {"tags", "text"}, {"subtitle", "text"}, {"description", "text"}, {"owner", "text"}},
+				Options: options.Index().SetName("$text"),
+			},
 		}
 
 		// Specify the MaxTime option to limit the amount of time the operation can run on the server
@@ -286,14 +290,19 @@ func CreateSchematic(schematic model.Schematic) (string, error) {
 		fmt.Printf("error: %s\n", err.Error())
 		return "", err
 	}
-	return result.InsertedID.(string), nil
+	switch v := result.InsertedID.(type) {
+	case primitive.ObjectID:
+		return v.Hex(), nil
+	}
+	return "", nil
 }
 
 // GetSchematic getting a sdingle schematic
 func GetSchematic(schematicID string) (model.Schematic, error) {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
 	schematicCollection := database.Collection(schematicsCollectionName)
-	result := schematicCollection.FindOne(ctx, bson.M{"_id": schematicID})
+	objectId, _ := primitive.ObjectIDFromHex(schematicID)
+	result := schematicCollection.FindOne(ctx, bson.M{"_id": objectId})
 	var schematic model.Schematic
 	if err := result.Decode(&schematic); err != nil {
 		log.Print(err)
@@ -318,6 +327,45 @@ func GetFile(fileid string, stream io.Writer) error {
 	return nil
 }
 
+// GetSchematics getting a sdingle schematic
+func GetSchematics(query string, offset int, limit int) ([]model.Schematic, error) {
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	schematicCollection := database.Collection(schematicsCollectionName)
+	queryDoc := bson.M{}
+	err := bson.UnmarshalExtJSON([]byte(query), false, queryDoc)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	cursor, err := schematicCollection.Find(ctx, queryDoc, &options.FindOptions{Collation: &options.Collation{Locale: "en", Strength: 2}})
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+	schematics := make([]model.Schematic, 0)
+	count := 0
+	docs := 0
+	for cursor.Next(ctx) {
+		if count >= offset {
+			if docs < limit {
+				var schematic model.Schematic
+				if err = cursor.Decode(&schematic); err != nil {
+					log.Print(err)
+					return nil, err
+				} else {
+					schematics = append(schematics, schematic)
+					docs++
+				}
+			} else {
+				break
+			}
+		}
+		count++
+	}
+	return schematics, nil
+}
+
 // CreateTag create a new tag in the storage
 func CreateTag(tag string) error {
 	tag = strings.ToLower(tag)

schematic-service-go/devdata/mongo.txt

@@ -2,4 +2,6 @@ use schematic
 db.createUser({ user: "schematic", pwd: "schematic", roles: [ "readWrite", "dbAdmin", { role: "dbOwner", db: "schematic" } ]})
 
 
-query with Collation {locale: "en", strength : 2}
+query with Collation {locale: "en", strength : 2}
+
+{$or: [{$text : {$search : "blue"}} , { manufacturer: "swr"}, {model: "OM"}]}

schematic-service-go/model/schematic.go

@@ -3,23 +3,25 @@ package model
 import (
 	"encoding/json"
 	"time"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
 type Schematic struct {
-	ID             string    `json:"id,omitempty" bson:"_id,omitempty"`
-	Manufacturer   string    `json:"manufacturer" bson:"manufacturer,omitempty"`
-	Model          string    `json:"model" bson:"model,omitempty"`
-	SubTitle       string    `json:"subtitle" bson:"subtitle,omitempty"`
-	Tags           []string  `json:"tags" bson:"tags,omitempty"`
-	Description    string    `json:"description" bson:"description,omitempty"`
-	PrivateFile    bool      `json:"privateFile" bson:"privateFile,omitempty"`
-	Owner          string    `json:"owner" bson:"Owner,omitempty"`
-	Files          []string  `json:"files" bson:"files,omitempty"`
-	ForeignId      string    `json:"foreignId" bson:"foreignId,omitempty"`
-	CreatedAt      time.Time `json:"createdAt" bson:"createdAt,omitempty"`
-	LastModifiedAt time.Time `json:"lastModifiedAt" bson:"lastModifiedAt,omitempty"`
-	BuildIn        time.Time `json:"buildIn" bson:"buildIn,omitempty"`
-	BuildTO        time.Time `json:"buildTO" bson:"buildTO,omitempty"`
+	ID             primitive.ObjectID `json:"id,omitempty" bson:"_id,omitempty"`
+	Manufacturer   string             `json:"manufacturer" bson:"manufacturer,omitempty"`
+	Model          string             `json:"model" bson:"model,omitempty"`
+	SubTitle       string             `json:"subtitle" bson:"subtitle,omitempty"`
+	Tags           []string           `json:"tags" bson:"tags,omitempty"`
+	Description    string             `json:"description" bson:"description,omitempty"`
+	PrivateFile    bool               `json:"privateFile" bson:"privateFile,omitempty"`
+	Owner          string             `json:"owner" bson:"Owner,omitempty"`
+	Files          []string           `json:"files" bson:"files,omitempty"`
+	ForeignId      string             `json:"foreignId" bson:"foreignId,omitempty"`
+	CreatedAt      time.Time          `json:"createdAt" bson:"createdAt,omitempty"`
+	LastModifiedAt time.Time          `json:"lastModifiedAt" bson:"lastModifiedAt,omitempty"`
+	BuildIn        time.Time          `json:"buildIn" bson:"buildIn,omitempty"`
+	BuildTO        time.Time          `json:"buildTO" bson:"buildTO,omitempty"`
 }
 
 func (s *Schematic) UnmarshalJSON(data []byte) error {
@@ -28,8 +30,10 @@ func (s *Schematic) UnmarshalJSON(data []byte) error {
 	if err := json.Unmarshal(data, &dat); err != nil {
 		return err
 	}
-
-	s.ID = dat["id"].(string)
+	if dat["id"] != nil {
+		id, _ := primitive.ObjectIDFromHex(dat["id"].(string))
+		s.ID = id
+	}
 	if dat["manufacturer"] != nil {
 		s.Manufacturer = dat["manufacturer"].(string)
 	}
@@ -53,7 +57,14 @@ func (s *Schematic) UnmarshalJSON(data []byte) error {
 		s.Description = dat["description"].(string)
 	}
 	if dat["privateFile"] != nil {
-		s.PrivateFile = dat["privateFile"].(float64) > 0
+		switch v := dat["privateFile"].(type) {
+		case float64:
+			s.PrivateFile = v > 0
+		case int:
+			s.PrivateFile = v > 0
+		case bool:
+			s.PrivateFile = v
+		}
 	}
 	if dat["owner"] != nil {
 		s.Owner = dat["owner"].(string)