adding effects support

schematic-service-go/api/effectsapi.go

@@ -0,0 +1,165 @@
+package api
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+	"github.com/willie68/schematic-service-go/dao"
+)
+
+//EffectTypesRoutes getting all routes for the config endpoint
+func EffectTypesRoutes() *chi.Mux {
+	router := chi.NewRouter()
+	router.Get("/", GetEffectTypesEndpoint)
+	router.Post("/", PostEffectTypeEndpoint)
+	router.Get("/{typeId}", GetEffectTypeEndpoint)
+	router.Put("/{typeId}", PutEffectTypeEndpoint)
+	router.Delete("/{typeId}", DeleteEffectTypeEndpoint)
+	return router
+}
+
+//EffectsRoutes getting all routes for the config endpoint
+func EffectsRoutes() *chi.Mux {
+	router := chi.NewRouter()
+	router.Get("/", GetEffectsEndpoint)
+	router.Get("/count", GetEffectsCountEndpoint)
+	router.Post("/", PostEffectEndpoint)
+	router.Get("/{effectId}", GetEffectEndpoint)
+	router.Put("/{effectId}", PutEffectEndpoint)
+	router.Delete("/{effectId}", DeleteEffectEndpoint)
+	return router
+}
+
+//GetEffectTypesEndpoint getting a list of effect entries
+func GetEffectTypesEndpoint(response http.ResponseWriter, req *http.Request) {
+	effectTypes, err := dao.GetStorage().GetEffectTypes()
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	m := make(map[string]interface{})
+	m["found"] = len(effectTypes)
+	m["data"] = effectTypes
+
+	render.JSON(response, req, m)
+}
+
+//PostEffectTypeEndpoint creating an effect entry
+func PostEffectTypeEndpoint(response http.ResponseWriter, req *http.Request) {
+	render.Status(req, http.StatusNotImplemented)
+	render.JSON(response, req, "POST: not im plemented yet")
+}
+
+//GetEffectTypeEndpoint getting one effect entry
+func GetEffectTypeEndpoint(response http.ResponseWriter, req *http.Request) {
+	typeID := chi.URLParam(req, "typeId")
+	fmt.Printf("typeid: %s\n", typeID)
+	render.Status(req, http.StatusNotImplemented)
+	render.JSON(response, req, "GET: not im plemented yet")
+}
+
+//PutEffectTypeEndpoint changes an effect entry
+func PutEffectTypeEndpoint(response http.ResponseWriter, req *http.Request) {
+	typeID := chi.URLParam(req, "typeId")
+	fmt.Printf("typeid: %s\n", typeID)
+	render.Status(req, http.StatusNotImplemented)
+	render.JSON(response, req, "PUT: not im plemented yet")
+}
+
+//DeleteEffectTypeEndpoint delete an effect entry
+func DeleteEffectTypeEndpoint(response http.ResponseWriter, req *http.Request) {
+	typeID := chi.URLParam(req, "typeId")
+	fmt.Printf("typeid: %s\n", typeID)
+	render.Status(req, http.StatusNotImplemented)
+	render.JSON(response, req, "DELETE: not im plemented yet")
+}
+
+//GetEffectsCountEndpoint getting a list of effect entries
+func GetEffectsCountEndpoint(response http.ResponseWriter, req *http.Request) {
+	query := req.URL.Query().Get("query")
+	n, err := dao.GetStorage().GetEffectsCount(query)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	m := make(map[string]interface{})
+	m["found"] = n
+
+	render.JSON(response, req, m)
+}
+
+//GetEffectsEndpoint getting a list of effect entries
+func GetEffectsEndpoint(response http.ResponseWriter, req *http.Request) {
+	offset := 0
+	limit := 100
+	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
+		}
+	}
+
+	if limitStr != "" {
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil {
+			Msg(response, http.StatusBadRequest, err.Error())
+			return
+		}
+	}
+	n, effects, err := dao.GetStorage().GetEffects(query, offset, limit)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	m := make(map[string]interface{})
+	m["found"] = len(effects)
+	m["count"] = n
+	m["data"] = effects
+
+	render.JSON(response, req, m)
+}
+
+//PostEffectEndpoint creating an effect entry
+func PostEffectEndpoint(response http.ResponseWriter, req *http.Request) {
+	render.Status(req, http.StatusNotImplemented)
+	render.JSON(response, req, "POST: not im plemented yet")
+}
+
+//GetEffectEndpoint getting one effect entry
+func GetEffectEndpoint(response http.ResponseWriter, req *http.Request) {
+	effectID := chi.URLParam(req, "effectId")
+	effect, err := dao.GetStorage().GetEffect(effectID)
+	if err != nil {
+		if err == dao.ErrNoDocument {
+			Msg(response, http.StatusNotFound, err.Error())
+			return
+		}
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	render.JSON(response, req, effect)
+}
+
+//PutEffectEndpoint changes an effect entry
+func PutEffectEndpoint(response http.ResponseWriter, req *http.Request) {
+	typeID := chi.URLParam(req, "effectId")
+	fmt.Printf("effectId: %s\n", typeID)
+	render.Status(req, http.StatusNotImplemented)
+	render.JSON(response, req, "PUT: not im plemented yet")
+}
+
+//DeleteEffectEndpoint delete an effect entry
+func DeleteEffectEndpoint(response http.ResponseWriter, req *http.Request) {
+	typeID := chi.URLParam(req, "effectId")
+	fmt.Printf("effectId: %s\n", typeID)
+	render.Status(req, http.StatusNotImplemented)
+	render.JSON(response, req, "DELETE: not im plemented yet")
+}

schematic-service-go/api/filesapi.go

@@ -0,0 +1,62 @@
+package api
+
+import (
+	"bufio"
+	"fmt"
+	"net/http"
+
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+	"github.com/willie68/schematic-service-go/dao"
+)
+
+//SchematicsRoutes getting all routes for the config endpoint
+func FilesRoutes() *chi.Mux {
+	router := chi.NewRouter()
+	router.Get("/{fileId}", GetFileHandler)
+	router.Post("/", PostFileEndpoint)
+	return router
+}
+
+// GetSchematicFileHandler gets a tenant
+func GetFileHandler(response http.ResponseWriter, req *http.Request) {
+	fileID := chi.URLParam(req, "fileId")
+	filename, err := dao.GetStorage().GetFilename(fileID)
+	response.Header().Add("Content-disposition", "attachment; filename=\""+filename+"\"")
+	err = dao.GetStorage().GetFile(fileID, response)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+}
+
+//PostFileEndpoint create a new file, return the id
+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.GetStorage().AddFile(filename, reader)
+	if err != nil {
+		fmt.Printf("%v\n", err)
+	} else {
+		fmt.Printf("fileid: %s\n", fileid)
+	}
+
+	location := fmt.Sprintf("/api/v1/files/%s", fileid)
+	response.Header().Add("Location", location)
+	render.Status(req, http.StatusCreated)
+
+	m := make(map[string]interface{})
+	m["fileid"] = fileid
+	m["filename"] = filename
+
+	render.JSON(response, req, m)
+}

schematic-service-go/api/schematicapi.go

@@ -1,8 +1,6 @@
 package api
 
 import (
-	"bufio"
-	"fmt"
 	"log"
 	"net/http"
 	"strconv"
@@ -23,8 +21,6 @@ func SchematicsRoutes() *chi.Mux {
 	router.Delete("/{schematicId}", DeleteSchematicEndpoint)
 	router.Put("/{schematicId}", UpdateSchematicEndpoint)
 	router.Get("/{schematicId}", GetSchematicHandler)
-	router.Get("/files/{fileId}", GetSchematicFileHandler)
-	router.Post("/files", PostFileEndpoint)
 	return router
 }
 
@@ -33,6 +29,10 @@ func GetSchematicHandler(response http.ResponseWriter, req *http.Request) {
 	schematicID := chi.URLParam(req, "schematicId")
 	schematic, err := dao.GetStorage().GetSchematic(schematicID)
 	if err != nil {
+		if err == dao.ErrNoDocument {
+			Msg(response, http.StatusNotFound, err.Error())
+			return
+		}
 		Msg(response, http.StatusBadRequest, err.Error())
 		return
 	}
@@ -44,18 +44,6 @@ func GetSchematicHandler(response http.ResponseWriter, req *http.Request) {
 	render.JSON(response, req, schematic)
 }
 
-// GetSchematicFileHandler gets a tenant
-func GetSchematicFileHandler(response http.ResponseWriter, req *http.Request) {
-	fileID := chi.URLParam(req, "fileId")
-	filename, err := dao.GetStorage().GetFilename(fileID)
-	response.Header().Add("Content-disposition", "attachment; filename=\""+filename+"\"")
-	err = dao.GetStorage().GetFile(fileID, response)
-	if err != nil {
-		Msg(response, http.StatusBadRequest, err.Error())
-		return
-	}
-}
-
 // GetSchematicsEndpoint gets all tenants
 func GetSchematicsEndpoint(response http.ResponseWriter, req *http.Request) {
 	offset := 0
@@ -165,36 +153,6 @@ func PostSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
 	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.GetStorage().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)
-
-	m := make(map[string]interface{})
-	m["fileid"] = fileid
-	m["filename"] = filename
-
-	render.JSON(response, req, m)
-}
-
 func DeleteSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
 	schematicID := chi.URLParam(req, "schematicId")
 	schematic, err := dao.GetStorage().GetSchematic(schematicID)

schematic-service-go/cmd/service.go

@@ -4,8 +4,10 @@ import (
 	"bufio"
 	"context"
 	"crypto/md5"
+	"encoding/csv"
 	"encoding/json"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"net/http"
 	"net/url"
@@ -46,6 +48,7 @@ var system string
 var serviceURL string
 var registryURL string
 var importPath string
+var effectImportPath string
 var apikey string
 var ssl bool
 var configFile string
@@ -63,6 +66,7 @@ func init() {
 	flag.StringVarP(&serviceURL, "serviceURL", "u", "", "service url from outside")
 	flag.StringVarP(&registryURL, "registryURL", "r", "", "registry url where to connect to consul")
 	flag.StringVarP(&importPath, "import", "i", "", "import data from here")
+	flag.StringVarP(&effectImportPath, "effect", "e", "", "effect import data from here")
 }
 
 func routes() *chi.Mux {
@@ -80,10 +84,13 @@ func routes() *chi.Mux {
 
 	router.Route("/", func(r chi.Router) {
 		r.Mount(baseURL+"/config", api.ConfigRoutes())
+		r.Mount(baseURL+"/files", api.FilesRoutes())
 		r.Mount(baseURL+"/tags", api.TagsRoutes())
 		r.Mount(baseURL+"/manufacturers", api.ManufacturersRoutes())
 		r.Mount(baseURL+"/schematics", api.SchematicsRoutes())
 		r.Mount(baseURL+"/users", api.UsersRoutes())
+		r.Mount(baseURL+"/effects", api.EffectsRoutes())
+		r.Mount(baseURL+"/effecttypes", api.EffectTypesRoutes())
 		r.Mount("/health", health.Routes())
 	})
 	return router
@@ -143,6 +150,10 @@ func main() {
 		go importData()
 	}
 
+	if effectImportPath != "" {
+		go effectImportData()
+	}
+
 	health.InitHealthSystem(healthCheckConfig)
 
 	apikey = getApikey()
@@ -332,6 +343,132 @@ func importData() {
 	}
 }
 
+func effectImportData() {
+	effectTypesImportData()
+	effectModelsImportData()
+}
+
+func effectTypesImportData() {
+	effectTypesFilesname := effectImportPath + "/WK_Schematic_Store$EffectType.csv"
+	effectTypesReader, err := os.Open(effectTypesFilesname)
+	if err != nil {
+		fmt.Printf("%v\n", err)
+	}
+	defer effectTypesReader.Close()
+	r := csv.NewReader(effectTypesReader)
+	r.Comma = ';'
+	r.Comment = '#'
+
+	record, err := r.Read()
+	fmt.Print(record)
+	layout := "Mon, 02 Jan 2006 15:04:05 -0700" //"2006-01-02T15:04:05.000Z"
+
+	for {
+		record, err := r.Read()
+		if err != nil {
+			break
+		}
+
+		effectType := model.NewEffectType()
+		effectType.ForeignID = record[1]
+		effectType.TypeName = record[6]
+
+		effectType.CreatedAt, err = time.Parse(layout, record[2])
+		if err != nil {
+			fmt.Printf("%v\n", err)
+			break
+		}
+		effectType.LastModifiedAt, err = time.Parse(layout, record[3])
+		if err != nil {
+			fmt.Printf("%v\n", err)
+			break
+		}
+
+		nlsString := record[4]
+		nlsString = strings.TrimPrefix(nlsString, "[de->")
+		nlsString = strings.TrimSuffix(nlsString, "]")
+		effectType.Nls["de"] = nlsString
+
+		typeImageString := record[5]
+		typeImageString = strings.TrimPrefix(typeImageString, "images://")
+		typeImageString = effectImportPath + "/" + typeImageString
+		filename := filepath.Base(typeImageString)
+
+		fileid, err := uploadFile(filename, typeImageString)
+		if err != nil {
+			fmt.Printf("%v\n", err)
+			break
+		}
+		effectType.TypeImage = fileid
+		dao.Storage.CreateEffectType(effectType)
+	}
+	if (err != nil) && (err != io.EOF) {
+		fmt.Printf("%v\n", err)
+	}
+	fmt.Println("ready reading types")
+}
+
+func effectModelsImportData() {
+	effectModelsFilesname := effectImportPath + "/WK_Schematic_Store$Effect.csv"
+	effectModelsReader, err := os.Open(effectModelsFilesname)
+	if err != nil {
+		fmt.Printf("%v\n", err)
+	}
+	defer effectModelsReader.Close()
+	r := csv.NewReader(effectModelsReader)
+	r.Comma = ';'
+	r.Comment = '#'
+
+	record, err := r.Read()
+	fmt.Print(record)
+	layout := "Mon, 02 Jan 2006 15:04:05 -0700" //"2006-01-02T15:04:05.000Z"
+
+	for {
+		record, err := r.Read()
+		if err != nil {
+			break
+		}
+
+		effect := model.NewEffect()
+		effect.ForeignID = record[1]
+		effect.CreatedAt, err = time.Parse(layout, record[2])
+		if err != nil {
+			fmt.Printf("%v\n", err)
+			break
+		}
+		effect.LastModifiedAt, err = time.Parse(layout, record[3])
+		if err != nil {
+			fmt.Printf("%v\n", err)
+			break
+		}
+		effect.Comment = record[4]
+		effect.Connector = record[5]
+		effect.Current = record[6]
+		effect.EffectType = record[7]
+
+		imageString := record[8]
+		imageString = strings.TrimPrefix(imageString, "images://")
+		imageString = effectImportPath + "/" + imageString
+		filename := filepath.Base(imageString)
+
+		fileid, err := uploadFile(filename, imageString)
+		if err != nil {
+			fmt.Printf("%v\n", err)
+			break
+		}
+		effect.Image = fileid
+		effect.Model = record[9]
+		effect.Manufacturer = record[10]
+		effect.Voltage = record[12]
+
+		dao.Storage.CreateEffect(effect)
+	}
+	if (err != nil) && (err != io.EOF) {
+		fmt.Printf("%v\n", err)
+	}
+	fmt.Println("ready reading types")
+}
+
 func getSchematic(file string) model.Schematic {
 	jsonFile, err := os.Open(file)
 	// if we os.Open returns an error then handle it
@@ -350,3 +487,18 @@ func getSchematic(file string) model.Schematic {
 	}
 	return schematic
 }
+
+func uploadFile(filename string, file string) (string, error) {
+	f, err := os.Open(file)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+	reader := bufio.NewReader(f)
+
+	fileid, err := dao.GetStorage().AddFile(filename, reader)
+	if err != nil {
+		return "", err
+	}
+	return fileid, nil
+}

schematic-service-go/configs/serviceLocal.yaml

@@ -3,24 +3,24 @@ port: 9080
 # port of the https server
 sslport: 9443
 # this is the servicURL from outside
-serviceURL: http://127.0.0.1:8080
+serviceURL: http://127.0.0.1:9080
 # this is the registry URL from inside
-registryURL: http://127.0.0.1:8500
+registryURL:
 # this is the system id of this service. services in a cluster mode should have the same system id.
 systemID: easy1
 #sercret file for storing usernames and passwords
 secretfile: configs/secret.yaml
 
 logging:
-    gelf-url: 127.0.0.1
-    gelf-port: 12201
+    gelf-url:
+    gelf-port:
 
 healthcheck:
     period: 30
 
 mongodb:
-    host: 192.168.178.12
-    port: 37017
+    host: 127.0.0.1
+    port: 27017
     username:
     password:
     authdb: schematics

schematic-service-go/dao/mongodao.go

@@ -30,6 +30,8 @@ const schematicsCollectionName = "schematics"
 const tagsCollectionName = "tags"
 const manufacturersCollectionName = "manufacturers"
 const usersCollectionName = "users"
+const effectsCollectionName = "effects"
+const effectTypesCollectionName = "effectTypes"
 
 // MongoDAO a mongodb based dao
 type MongoDAO struct {
@@ -76,6 +78,8 @@ func (m *MongoDAO) InitDAO(MongoConfig config.MongoDB) {
 	m.initIndexSchematics()
 	m.initIndexTags()
 	m.initIndexManufacturers()
+	m.initIndexEffectTypes()
+	m.initIndexEffects()
 
 	m.tags = model.NewTags()
 	m.manufacturers = model.NewManufacturers()
@@ -222,6 +226,104 @@ func (m *MongoDAO) initIndexManufacturers() {
 	}
 }
 
+func (m *MongoDAO) initIndexEffects() {
+	collection := m.database.Collection(effectsCollectionName)
+	indexView := collection.Indexes()
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	cursor, err := indexView.List(ctx)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer cursor.Close(ctx)
+	myIndexes := make([]string, 0)
+	for cursor.Next(ctx) {
+		var index bson.M
+		if err = cursor.Decode(&index); err != nil {
+			log.Fatal(err)
+		}
+		myIndexes = append(myIndexes, index["name"].(string))
+	}
+	if !slicesutils.Contains(myIndexes, "effectType") {
+		ctx, _ = context.WithTimeout(context.Background(), timeout)
+		models := []mongo.IndexModel{
+			{
+				Keys:    bson.D{{"effectType", 1}},
+				Options: options.Index().SetName("effectType").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
+			},
+			{
+				Keys:    bson.D{{"manufacturer", 1}},
+				Options: options.Index().SetName("manufacturer").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
+			},
+			{
+				Keys:    bson.D{{"model", 1}},
+				Options: options.Index().SetName("model").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
+			},
+			{
+				Keys:    bson.D{{"tags", 1}},
+				Options: options.Index().SetName("tags").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
+			},
+			{
+				Keys:    bson.D{{"comment", 1}},
+				Options: options.Index().SetName("comment").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
+			},
+			{
+				Keys:    bson.D{{"effectType", "text"}, {"manufacturer", "text"}, {"model", "text"}, {"tags", "text"}, {"comment", "text"}, {"connector", "text"}, {"current", "text"}, {"voltage", "text"}},
+				Options: options.Index().SetName("$text"),
+			},
+		}
+
+		// Specify the MaxTime option to limit the amount of time the operation can run on the server
+		opts := options.CreateIndexes().SetMaxTime(2 * time.Second)
+		names, err := indexView.CreateMany(context.TODO(), models, opts)
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Print("create indexes:")
+		for _, name := range names {
+			log.Println(name)
+		}
+	}
+}
+
+func (m *MongoDAO) initIndexEffectTypes() {
+	collection := m.database.Collection(effectTypesCollectionName)
+	indexView := collection.Indexes()
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	cursor, err := indexView.List(ctx)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer cursor.Close(ctx)
+	myIndexes := make([]string, 0)
+	for cursor.Next(ctx) {
+		var index bson.M
+		if err = cursor.Decode(&index); err != nil {
+			log.Fatal(err)
+		}
+		myIndexes = append(myIndexes, index["name"].(string))
+	}
+	if !slicesutils.Contains(myIndexes, "typeName") {
+		ctx, _ = context.WithTimeout(context.Background(), timeout)
+		models := []mongo.IndexModel{
+			{
+				Keys:    bson.D{{"typeName", 1}},
+				Options: options.Index().SetName("typeName").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
+			},
+		}
+
+		// Specify the MaxTime option to limit the amount of time the operation can run on the server
+		opts := options.CreateIndexes().SetMaxTime(2 * time.Second)
+		names, err := indexView.CreateMany(context.TODO(), models, opts)
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Print("create indexes:")
+		for _, name := range names {
+			log.Println(name)
+		}
+	}
+}
+
 func (m *MongoDAO) initTags() {
 	m.reloadTags()
 }
@@ -669,6 +771,211 @@ func (m *MongoDAO) GetManufacturersCount() int {
 	return len(m.manufacturers.List)
 }
 
+//CreateEffectType cerating a new effect type
+func (m *MongoDAO) CreateEffectType(effectType model.EffectType) (string, error) {
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	collection := m.database.Collection(effectTypesCollectionName)
+	result, err := collection.InsertOne(ctx, effectType)
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+		return "", err
+	}
+	filter := bson.M{"_id": result.InsertedID}
+	err = collection.FindOne(ctx, filter).Decode(&effectType)
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+		return "", err
+	}
+	switch v := result.InsertedID.(type) {
+	case primitive.ObjectID:
+		return v.Hex(), nil
+	}
+	return "", nil
+}
+
+// GetEffectTypes getting a sdingle schematic
+func (m *MongoDAO) GetEffectTypes() ([]model.EffectType, error) {
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	collection := m.database.Collection(effectTypesCollectionName)
+	findOptions := options.Find()
+	// Sort by `price` field descending
+	findOptions.SetSort(bson.D{{"typeName", 1}})
+	queryDoc := bson.M{}
+	cursor, err := collection.Find(ctx, queryDoc, &options.FindOptions{Collation: &options.Collation{Locale: "en", Strength: 2}, Sort: bson.D{{"typeName", 1}}})
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+	effectTypes := make([]model.EffectType, 0)
+	for cursor.Next(ctx) {
+		var effectType model.EffectType
+		if err = cursor.Decode(&effectType); err != nil {
+			log.Print(err)
+			return nil, err
+		} else {
+			effectTypes = append(effectTypes, effectType)
+		}
+	}
+	return effectTypes, nil
+}
+
+//CreateEffect cerating a new effect type
+func (m *MongoDAO) CreateEffect(effect model.Effect) (string, error) {
+
+	for _, tag := range effect.Tags {
+		if !m.tags.Contains(tag) {
+			m.CreateTag(tag)
+		}
+	}
+
+	if !m.manufacturers.Contains(effect.Manufacturer) {
+		m.CreateManufacturer(effect.Manufacturer)
+	}
+
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	collection := m.database.Collection(effectsCollectionName)
+	result, err := collection.InsertOne(ctx, effect)
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+		return "", err
+	}
+	filter := bson.M{"_id": result.InsertedID}
+	err = collection.FindOne(ctx, filter).Decode(&effect)
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+		return "", err
+	}
+	switch v := result.InsertedID.(type) {
+	case primitive.ObjectID:
+		return v.Hex(), nil
+	}
+	return "", nil
+}
+
+//GetEffectsCount getting the count  of effects regarding to the query
+func (m *MongoDAO) GetEffectsCount(query string) (int, error) {
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	collection := m.database.Collection(effectsCollectionName)
+	queryDoc := bson.M{}
+	if query != "" {
+		var queryM map[string]interface{}
+		err := json.Unmarshal([]byte(query), &queryM)
+		if err != nil {
+			log.Print(err)
+			return 0, err
+		}
+		for k, v := range queryM {
+			if k == "$fulltext" {
+				queryDoc["$text"] = bson.M{"$search": v}
+			} else {
+				switch v := v.(type) {
+				//			case float64:
+				//			case int:
+				//			case bool:
+				case string:
+					queryDoc[k] = bson.M{"$regex": v}
+				}
+				//queryDoc[k] = v
+			}
+		}
+		data, _ := json.Marshal(queryDoc)
+		log.Printf("mongoquery: %s\n", string(data))
+	}
+	n, err := collection.CountDocuments(ctx, queryDoc, &options.CountOptions{Collation: &options.Collation{Locale: "en", Strength: 2}})
+	if err != nil {
+		log.Print(err)
+		return 0, err
+	}
+	return int(n), nil
+}
+
+//GetEffects getting a list of effects regarding to the query
+func (m *MongoDAO) GetEffects(query string, offset int, limit int) (int, []model.Effect, error) {
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	collection := m.database.Collection(effectsCollectionName)
+	queryDoc := bson.M{}
+	if query != "" {
+		var queryM map[string]interface{}
+		err := json.Unmarshal([]byte(query), &queryM)
+		if err != nil {
+			log.Print(err)
+			return 0, nil, err
+		}
+		for k, v := range queryM {
+			if k == "$fulltext" {
+				queryDoc["$text"] = bson.M{"$search": v}
+			} else {
+				switch v := v.(type) {
+				//			case float64:
+				//			case int:
+				//			case bool:
+				case string:
+					queryDoc[k] = bson.M{"$regex": v}
+				}
+				//queryDoc[k] = v
+			}
+		}
+		data, _ := json.Marshal(queryDoc)
+		log.Printf("mongoquery: %s\n", string(data))
+	}
+	n, err := collection.CountDocuments(ctx, queryDoc, &options.CountOptions{Collation: &options.Collation{Locale: "en", Strength: 2}})
+	if err != nil {
+		log.Print(err)
+		return 0, nil, err
+	}
+	cursor, err := collection.Find(ctx, queryDoc, &options.FindOptions{Collation: &options.Collation{Locale: "en", Strength: 2}, Sort: bson.D{{"manufacturer", 1}, {"model", 1}}})
+	if err != nil {
+		log.Print(err)
+		return 0, nil, err
+	}
+	defer cursor.Close(ctx)
+	effects := make([]model.Effect, 0)
+	count := 0
+	docs := 0
+	for cursor.Next(ctx) {
+		if count >= offset {
+			if docs < limit {
+				var effect model.Effect
+				if err = cursor.Decode(&effect); err != nil {
+					log.Print(err)
+					return 0, nil, err
+				} else {
+					effects = append(effects, effect)
+					docs++
+				}
+			} else {
+				break
+			}
+		}
+		count++
+	}
+	return int(n), effects, nil
+}
+
+func (m *MongoDAO) GetEffect(effectID string) (model.Effect, error) {
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	collection := m.database.Collection(effectsCollectionName)
+	objectID, _ := primitive.ObjectIDFromHex(effectID)
+	result := collection.FindOne(ctx, bson.M{"_id": objectID})
+	err := result.Err()
+	if err == mongo.ErrNoDocuments {
+		log.Print(err)
+		return model.Effect{}, ErrNoDocument
+	}
+	if err != nil {
+		log.Print(err)
+		return model.Effect{}, err
+	}
+	var effect model.Effect
+	if err := result.Decode(&effect); err != nil {
+		log.Print(err)
+		return model.Effect{}, err
+	} else {
+		return effect, nil
+	}
+}
+
 // CheckUser checking username and password... returns true if the user is active and the password for this user is correct
 func (m *MongoDAO) CheckUser(username string, password string) bool {
 	username = strings.ToLower(username)

schematic-service-go/dao/storageDao.go

@@ -29,6 +29,14 @@ type StorageDao interface {
 	GetManufacturers() []model.Manufacturer
 	GetManufacturersCount() int
 
+	CreateEffectType(effectType model.EffectType) (string, error)
+	GetEffectTypes() ([]model.EffectType, error)
+
+	CreateEffect(effect model.Effect) (string, error)
+	GetEffectsCount(query string) (int, error)
+	GetEffects(query string, offset int, limit int) (int, []model.Effect, error)
+	GetEffect(effectID string) (model.Effect, error)
+
 	CheckUser(username string, password string) bool
 	GetUser(username string) (model.User, bool)
 

schematic-service-go/model/effect.go

@@ -0,0 +1,96 @@
+package model
+
+import (
+	"encoding/json"
+	"time"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+type Effect struct {
+	ID             primitive.ObjectID `json:"id,omitempty" bson:"_id,omitempty"`
+	ForeignID      string             `json:"foreignId" bson:"foreignId,omitempty"`
+	CreatedAt      time.Time          `json:"createdAt" bson:"createdAt,omitempty"`
+	LastModifiedAt time.Time          `json:"lastModifiedAt" bson:"lastModifiedAt,omitempty"`
+	EffectType     string             `json:"effectType" bson:"effectType,omitempty"`
+	Manufacturer   string             `json:"manufacturer" bson:"manufacturer,omitempty"`
+	Model          string             `json:"model" bson:"model,omitempty"`
+	Tags           []string           `json:"tags" bson:"tags,omitempty"`
+	Comment        string             `json:"comment" bson:"comment,omitempty"`
+	Image          string             `json:"image" bson:"image,omitempty"`
+	Connector      string             `json:"connector" bson:"connector,omitempty"`
+	Voltage        string             `json:"voltage" bson:"voltage,omitempty"`
+	Current        string             `json:"current" bson:"current,omitempty"`
+}
+
+func NewEffect() Effect {
+	effect := Effect{
+		Tags: make([]string, 0),
+	}
+	return effect
+}
+
+//UnmarshallJSON unmarschal function
+func (s *Effect) UnmarshalJSON(data []byte) error {
+	var dat map[string]interface{}
+	if err := json.Unmarshal(data, &dat); err != nil {
+		return err
+	}
+	if dat["id"] != nil {
+		id, _ := primitive.ObjectIDFromHex(dat["id"].(string))
+		s.ID = id
+	}
+	if dat["foreignId"] != nil {
+		s.ForeignID = dat["foreignId"].(string)
+	}
+	if dat["createdAt"] != nil {
+		switch v := dat["createdAt"].(type) {
+		case string:
+			layout := "2006-01-02T15:04:05.000Z"
+			s.CreatedAt, _ = time.Parse(layout, v)
+		case float64:
+			s.CreatedAt = time.Unix(0, int64(v)*int64(time.Millisecond))
+		}
+	}
+	if dat["lastModifiedAt"] != nil {
+		switch v := dat["lastModifiedAt"].(type) {
+		case string:
+			layout := "2006-01-02T15:04:05.000Z"
+			s.LastModifiedAt, _ = time.Parse(layout, v)
+		case float64:
+			s.LastModifiedAt = time.Unix(0, int64(v)*int64(time.Millisecond))
+		}
+	}
+	if dat["voltage"] != nil {
+		s.Manufacturer = dat["voltage"].(string)
+	}
+	if dat["manufacturer"] != nil {
+		s.Manufacturer = dat["manufacturer"].(string)
+	}
+	if dat["tags"] != nil {
+		values := dat["tags"].([]interface{})
+		s.Tags = make([]string, len(values))
+		for i, d := range values {
+			s.Tags[i] = d.(string)
+		}
+	}
+	if dat["image"] != nil {
+		s.Model = dat["image"].(string)
+	}
+	if dat["model"] != nil {
+		s.Model = dat["model"].(string)
+	}
+	if dat["comment"] != nil {
+		s.Comment = dat["comment"].(string)
+	}
+	if dat["connector"] != nil {
+		s.Connector = dat["connector"].(string)
+	}
+	if dat["current"] != nil {
+		s.Current = dat["current"].(string)
+	}
+	if dat["effectType"] != nil {
+		s.EffectType = dat["effectType"].(string)
+	}
+	return nil
+}

schematic-service-go/model/effecttype.go

@@ -0,0 +1,81 @@
+package model
+
+import (
+	"encoding/json"
+	"time"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+type EffectType struct {
+	ID             primitive.ObjectID `json:"id,omitempty" bson:"_id,omitempty"`
+	ForeignID      string             `json:"foreignId" bson:"foreignId,omitempty"`
+	CreatedAt      time.Time          `json:"createdAt" bson:"createdAt,omitempty"`
+	LastModifiedAt time.Time          `json:"lastModifiedAt" bson:"lastModifiedAt,omitempty"`
+	TypeName       string             `json:"typeName" bson:"typeName,omitempty"`
+	Nls            map[string]string  `json:"nls" bson:"nls,omitempty"`
+	TypeImage      string             `json:"typeImage" bson:"typeImage,omitempty"`
+}
+
+func NewEffectType() EffectType {
+	effectType := EffectType{
+		Nls: make(map[string]string),
+	}
+	return effectType
+}
+
+//UnmarshalJSON unmarschal function
+func (s *EffectType) UnmarshalJSON(data []byte) error {
+	var dat map[string]interface{}
+	if err := json.Unmarshal(data, &dat); err != nil {
+		return err
+	}
+	if dat["id"] != nil {
+		id, _ := primitive.ObjectIDFromHex(dat["id"].(string))
+		s.ID = id
+	}
+	if dat["foreignId"] != nil {
+		s.ForeignID = dat["foreignId"].(string)
+	}
+	if dat["createdAt"] != nil {
+		switch v := dat["createdAt"].(type) {
+		case string:
+			layout := "2006-01-02T15:04:05.000Z"
+			s.CreatedAt, _ = time.Parse(layout, v)
+		case float64:
+			s.CreatedAt = time.Unix(0, int64(v)*int64(time.Millisecond))
+		}
+	}
+	if dat["lastModifiedAt"] != nil {
+		switch v := dat["lastModifiedAt"].(type) {
+		case string:
+			layout := "2006-01-02T15:04:05.000Z"
+			s.LastModifiedAt, _ = time.Parse(layout, v)
+		case float64:
+			s.LastModifiedAt = time.Unix(0, int64(v)*int64(time.Millisecond))
+		}
+	}
+	if dat["typeName"] != nil {
+		s.TypeName = dat["typeName"].(string)
+	}
+	if dat["nls"] != nil {
+		switch v := dat["nls"].(type) {
+		case []interface{}:
+			values := v
+			s.Nls = make(map[string]string)
+			for _, d := range values {
+				s.Nls["de"] = d.(string)
+			}
+		case map[string]interface{}:
+			values := v
+			s.Nls = make(map[string]string)
+			for k, d := range values {
+				s.Nls[k] = d.(string)
+			}
+		}
+	}
+	if dat["typeImage"] != nil {
+		s.TypeImage = dat["typeImage"].(string)
+	}
+	return nil
+}

schematic-service-go/model/schematic.go

@@ -9,6 +9,9 @@ import (
 
 type Schematic struct {
 	ID             primitive.ObjectID `json:"id,omitempty" bson:"_id,omitempty"`
+	ForeignID      string             `json:"foreignId" bson:"foreignId,omitempty"`
+	CreatedAt      time.Time          `json:"createdAt" bson:"createdAt,omitempty"`
+	LastModifiedAt time.Time          `json:"lastModifiedAt" bson:"lastModifiedAt,omitempty"`
 	Manufacturer   string             `json:"manufacturer" bson:"manufacturer,omitempty"`
 	Model          string             `json:"model" bson:"model,omitempty"`
 	SubTitle       string             `json:"subtitle" bson:"subtitle,omitempty"`
@@ -17,15 +20,12 @@ type Schematic struct {
 	PrivateFile    bool               `json:"privateFile" bson:"privateFile,omitempty"`
 	Owner          string             `json:"owner" bson:"owner,omitempty"`
 	Files          map[string]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"`
 }
 
+//UnmarshalJSON unmarshall a json to a schematic with some user properties
 func (s *Schematic) UnmarshalJSON(data []byte) error {
-
 	var dat map[string]interface{}
 	if err := json.Unmarshal(data, &dat); err != nil {
 		return err
@@ -34,18 +34,36 @@ func (s *Schematic) UnmarshalJSON(data []byte) error {
 		id, _ := primitive.ObjectIDFromHex(dat["id"].(string))
 		s.ID = id
 	}
+	if dat["foreignId"] != nil {
+		s.ForeignID = dat["foreignId"].(string)
+	}
+	if dat["createdAt"] != nil {
+		switch v := dat["createdAt"].(type) {
+		case string:
+			layout := "2006-01-02T15:04:05.000Z"
+			s.CreatedAt, _ = time.Parse(layout, v)
+		case float64:
+			s.CreatedAt = time.Unix(0, int64(v)*int64(time.Millisecond))
+		}
+	}
+	if dat["lastModifiedAt"] != nil {
+		switch v := dat["lastModifiedAt"].(type) {
+		case string:
+			layout := "2006-01-02T15:04:05.000Z"
+			s.LastModifiedAt, _ = time.Parse(layout, v)
+		case float64:
+			s.LastModifiedAt = time.Unix(0, int64(v)*int64(time.Millisecond))
+		}
+	}
 	if dat["manufacturer"] != nil {
 		s.Manufacturer = dat["manufacturer"].(string)
 	}
-
 	if dat["model"] != nil {
 		s.Model = dat["model"].(string)
 	}
-
 	if dat["subtitle"] != nil {
 		s.SubTitle = dat["subtitle"].(string)
 	}
-
 	if dat["tags"] != nil {
 		values := dat["tags"].([]interface{})
 		s.Tags = make([]string, len(values))
@@ -85,34 +103,11 @@ func (s *Schematic) UnmarshalJSON(data []byte) error {
 			}
 		}
 	}
-	if dat["foreignId"] != nil {
-		s.ForeignId = dat["foreignId"].(string)
-	}
-	if dat["createdAt"] != nil {
-		switch v := dat["createdAt"].(type) {
-		case string:
-			layout := "2006-01-02T15:04:05.000Z"
-			s.CreatedAt, _ = time.Parse(layout, v)
-		case float64:
-			s.CreatedAt = time.Unix(0, int64(v)*int64(time.Millisecond))
-		}
-	}
-
-	if dat["lastModifiedAt"] != nil {
-		switch v := dat["lastModifiedAt"].(type) {
-		case string:
-			layout := "2006-01-02T15:04:05.000Z"
-			s.LastModifiedAt, _ = time.Parse(layout, v)
-		case float64:
-			s.LastModifiedAt = time.Unix(0, int64(v)*int64(time.Millisecond))
-		}
-	}
 	//	if dat["buildIn"] != nil {
 	//		s.BuildIn = dat["buildIn"].(string)
 	//	}
 	//	if dat["buildTO"] != nil {
 	//		s.BuildTO = dat["buildTO"].(string)
 	//	}
-
 	return nil
 }