implemetation ready für the first schematics part.

schematic-service-go/api/listsendpoint.go

@@ -27,23 +27,37 @@ func ManufacturersRoutes() *chi.Mux {
 //GetTagsEndpoint getting all tags back. No paging...
 func GetTagsEndpoint(response http.ResponseWriter, req *http.Request) {
 	tags := dao.GetStorage().GetTags()
-	render.JSON(response, req, tags)
-}
+	m := make(map[string]interface{})
+	m["found"] = len(tags)
+	m["data"] = tags
 
-//GetManufacturersEndpoint getting all manufacturers back. No paging...
-func GetManufacturersEndpoint(response http.ResponseWriter, req *http.Request) {
-	manufacturers := dao.GetStorage().GetManufacturers()
-	render.JSON(response, req, manufacturers)
+	render.JSON(response, req, m)
 }
 
 //GetTagsCountEndpoint getting all tags back. No paging...
 func GetTagsCountEndpoint(response http.ResponseWriter, req *http.Request) {
 	tagsCount := dao.GetStorage().GetTagsCount()
-	render.JSON(response, req, tagsCount)
+	m := make(map[string]interface{})
+	m["found"] = tagsCount
+
+	render.JSON(response, req, m)
+}
+
+//GetManufacturersEndpoint getting all manufacturers back. No paging...
+func GetManufacturersEndpoint(response http.ResponseWriter, req *http.Request) {
+	manufacturers := dao.GetStorage().GetManufacturers()
+	m := make(map[string]interface{})
+	m["found"] = len(manufacturers)
+	m["data"] = manufacturers
+
+	render.JSON(response, req, m)
 }
 
 //GetManufacturersCountEndpoint getting all manufacturers back. No paging...
 func GetManufacturersCountEndpoint(response http.ResponseWriter, req *http.Request) {
 	manufacturersCount := dao.GetStorage().GetManufacturersCount()
-	render.JSON(response, req, manufacturersCount)
+	m := make(map[string]interface{})
+	m["found"] = manufacturersCount
+
+	render.JSON(response, req, m)
 }

schematic-service-go/api/schematicapi.go

@@ -19,6 +19,7 @@ func SchematicsRoutes() *chi.Mux {
 	router := chi.NewRouter()
 	router.Post("/", PostSchematicEndpoint)
 	router.Get("/", GetSchematicsEndpoint)
+	router.Get("/count", GetSchematicsCountEndpoint)
 	router.Delete("/{schematicId}", DeleteSchematicEndpoint)
 	router.Put("/{schematicId}", UpdateSchematicEndpoint)
 	router.Get("/{schematicId}", GetSchematicHandler)
@@ -46,7 +47,9 @@ func GetSchematicHandler(response http.ResponseWriter, req *http.Request) {
 // GetSchematicFileHandler gets a tenant
 func GetSchematicFileHandler(response http.ResponseWriter, req *http.Request) {
 	fileID := chi.URLParam(req, "fileId")
-	err := dao.GetStorage().GetFile(fileID, response)
+	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
@@ -95,6 +98,46 @@ func GetSchematicsEndpoint(response http.ResponseWriter, req *http.Request) {
 	render.JSON(response, req, m)
 }
 
+// GetSchematicsCountEndpoint gets all tenants
+func GetSchematicsCountEndpoint(response http.ResponseWriter, req *http.Request) {
+	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
+		}
+	}
+
+	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)
+	owner, _, _ := req.BasicAuth()
+
+	n, err := dao.GetStorage().GetSchematicsCount(query, owner)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	m := make(map[string]interface{})
+	m["found"] = n
+	m["query"] = query
+	m["offset"] = offset
+	m["limit"] = limit
+
+	render.JSON(response, req, m)
+}
+
 func PostSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
 	var schematic model.Schematic
 	err := render.DefaultDecoder(req, &schematic)
@@ -144,7 +187,12 @@ func PostFileEndpoint(response http.ResponseWriter, req *http.Request) {
 	location := fmt.Sprintf("/api/v1/schematics/files/%s", fileid)
 	response.Header().Add("Location", location)
 	render.Status(req, http.StatusCreated)
-	render.JSON(response, req, fileid)
+
+	m := make(map[string]interface{})
+	m["fileid"] = fileid
+	m["filename"] = filename
+
+	render.JSON(response, req, m)
 }
 
 func DeleteSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
@@ -168,13 +216,28 @@ func DeleteSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
 }
 
 func UpdateSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
-	/*
-		schematicID := chi.URLParam(req, "schematicId")
-		err := dao.Get().One("tenants", chi.URLParam(req, "schematicId"), &tenant)
-		if err != nil {
-			Msg(response, http.StatusBadRequest, err.Error())
-			return
-		}
-	*/
-	render.JSON(response, req, "tenant")
+	var schematic model.Schematic
+	err := render.DefaultDecoder(req, &schematic)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	username, _, _ := req.BasicAuth()
+	if username != "" {
+		schematic.Owner = username
+	}
+	schematic.CreatedAt = time.Now()
+	schematic.LastModifiedAt = time.Now()
+	id, err := dao.GetStorage().UpdateSchematic(schematic)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	schematic, err = dao.GetStorage().GetSchematic(id)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	render.Status(req, http.StatusCreated)
+	render.JSON(response, req, schematic)
 }

schematic-service-go/api/userapi.go

@@ -13,12 +13,26 @@ import (
 // TagsRoutes getting all routes for the tags endpoint
 func UsersRoutes() *chi.Mux {
 	router := chi.NewRouter()
+	router.Get("/", GetUserEndpoint)
 	router.Post("/", PostUserEndpoint)
 	router.Put("/{username}", PutUserEndpoint)
 	router.Delete("/{username}", DeleteUserEndpoint)
 	return router
 }
 
+//PutUserEndpoint getting all tags back. No paging...
+func GetUserEndpoint(response http.ResponseWriter, req *http.Request) {
+	username, _, _ := req.BasicAuth()
+	user, ok := dao.GetStorage().GetUser(username)
+	user.Password = ""
+	user.NewPassword = ""
+	if !ok {
+		Msg(response, http.StatusInternalServerError, "")
+		return
+	}
+	render.JSON(response, req, user)
+}
+
 //PutUserEndpoint getting all tags back. No paging...
 func PostUserEndpoint(response http.ResponseWriter, req *http.Request) {
 	var user model.User
@@ -66,7 +80,7 @@ func PutUserEndpoint(response http.ResponseWriter, req *http.Request) {
 		Msg(response, http.StatusInternalServerError, "")
 		return
 	}
-	if !admin.Admin {
+	if (adminusername != username) && !admin.Admin {
 		Msg(response, http.StatusForbidden, "permission denied")
 		return
 	}

schematic-service-go/cmd/service.go

@@ -298,8 +298,8 @@ func importData() {
 					if schematic.Owner == "" {
 						schematic.Owner = "w.klaas@gmx.de"
 					}
-					fileids := make([]string, 0)
-					for _, filename := range schematic.Files {
+					fileids := make(map[string]string)
+					for filename, _ := range schematic.Files {
 						file := path + "/" + filename
 						f, err := os.Open(file)
 						if err != nil {
@@ -313,7 +313,7 @@ func importData() {
 							fmt.Printf("%v\n", err)
 						} else {
 							fmt.Printf("fileid: %s\n", fileid)
-							fileids = append(fileids, fileid)
+							fileids[filename] = fileid
 						}
 					}
 					schematic.Files = fileids

schematic-service-go/configs/serviceLocal.yaml

@@ -1,7 +1,7 @@
 # port of the http server
-port: 8080 
+port: 9080 
 # port of the https server
-sslport: 8443
+sslport: 9443
 # this is the servicURL from outside
 serviceURL: http://127.0.0.1:8080
 # this is the registry URL from inside
@@ -19,8 +19,8 @@ healthcheck:
     period: 30
 
 mongodb:
-    host: 127.0.0.1
-    port: 27017
+    host: 192.168.178.12
+    port: 37017
     username:
     password:
     authdb: schematics

schematic-service-go/dao/mongodao.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"sort"
 	"strings"
 	"time"
 
@@ -37,8 +38,8 @@ type MongoDAO struct {
 	mongoConfig   config.MongoDB
 	bucket        gridfs.Bucket
 	database      mongo.Database
-	tags          []string
-	manufacturers []string
+	tags          model.Tags
+	manufacturers model.Manufacturers
 	users         map[string]string
 	ticker        time.Ticker
 	done          chan bool
@@ -76,8 +77,8 @@ func (m *MongoDAO) InitDAO(MongoConfig config.MongoDB) {
 	m.initIndexTags()
 	m.initIndexManufacturers()
 
-	m.tags = make([]string, 0)
-	m.manufacturers = make([]string, 0)
+	m.tags = model.NewTags()
+	m.manufacturers = model.NewManufacturers()
 	m.users = make(map[string]string)
 	m.initTags()
 	m.initManufacturers()
@@ -103,10 +104,7 @@ func (m *MongoDAO) initIndexSchematics() {
 		myIndexes = append(myIndexes, index["name"].(string))
 	}
 
-	for _, name := range myIndexes {
-		log.Println(name)
-	}
-	if !slicesutils.Contains(myIndexes, "manufaturer") {
+	if !slicesutils.Contains(myIndexes, "manufacturer") {
 		ctx, _ = context.WithTimeout(context.Background(), timeout)
 		models := []mongo.IndexModel{
 			{
@@ -162,9 +160,6 @@ func (m *MongoDAO) initIndexTags() {
 		myIndexes = append(myIndexes, index["name"].(string))
 	}
 
-	for _, name := range myIndexes {
-		log.Println(name)
-	}
 	if !slicesutils.Contains(myIndexes, "name") {
 		ctx, _ = context.WithTimeout(context.Background(), timeout)
 		models := []mongo.IndexModel{
@@ -205,9 +200,6 @@ func (m *MongoDAO) initIndexManufacturers() {
 		myIndexes = append(myIndexes, index["name"].(string))
 	}
 
-	for _, name := range myIndexes {
-		log.Println(name)
-	}
 	if !slicesutils.Contains(myIndexes, "name") {
 		ctx, _ = context.WithTimeout(context.Background(), timeout)
 		models := []mongo.IndexModel{
@@ -238,14 +230,31 @@ func (m *MongoDAO) initTags() {
 		log.Fatal(err)
 	}
 	defer cursor.Close(ctx)
+	tagList := make([]string, 0)
 	for cursor.Next(ctx) {
 		var tag bson.M
 		if err = cursor.Decode(&tag); err != nil {
 			log.Fatal(err)
 		} else {
-			m.tags = append(m.tags, tag["name"].(string))
+			tagList = append(tagList, tag["name"].(string))
+		}
+	}
+
+	ctx, _ = context.WithTimeout(context.Background(), timeout)
+	schematicCollection := m.database.Collection(schematicsCollectionName)
+
+	for _, tagName := range tagList {
+		queryDoc := bson.M{
+			"tags": tagName,
+		}
+		n, err := schematicCollection.CountDocuments(ctx, queryDoc, &options.CountOptions{Collation: &options.Collation{Locale: "en", Strength: 2}})
+		if err != nil {
+			log.Println(err)
 		}
+		//log.Printf("tag: %s has %d schematics.", tagName, n)
+		m.tags.Add(tagName, int(n))
 	}
+
 }
 
 func (m *MongoDAO) initManufacturers() {
@@ -256,13 +265,29 @@ func (m *MongoDAO) initManufacturers() {
 		log.Fatal(err)
 	}
 	defer cursor.Close(ctx)
+	manuList := make([]string, 0)
 	for cursor.Next(ctx) {
 		var manufacturer bson.M
 		if err = cursor.Decode(&manufacturer); err != nil {
 			log.Fatal(err)
 		} else {
-			m.manufacturers = append(m.manufacturers, manufacturer["name"].(string))
+			manuList = append(manuList, manufacturer["name"].(string))
+		}
+	}
+
+	ctx, _ = context.WithTimeout(context.Background(), timeout)
+	schematicCollection := m.database.Collection(schematicsCollectionName)
+
+	for _, manuName := range manuList {
+		queryDoc := bson.M{
+			"manufacturer": manuName,
+		}
+		n, err := schematicCollection.CountDocuments(ctx, queryDoc, &options.CountOptions{Collation: &options.Collation{Locale: "en", Strength: 2}})
+		if err != nil {
+			log.Println(err)
 		}
+		//log.Printf("manufacturer: %s has %d schematics.", manuName, n)
+		m.manufacturers.Add(manuName, int(n))
 	}
 }
 
@@ -297,6 +322,21 @@ func (m *MongoDAO) reloadUsers() {
 		}
 	}
 	m.users = localUsers
+	if len(m.users) == 0 {
+		admin := model.User{
+			Name:     "w.klaas@gmx.de",
+			Password: "akteon0000",
+			Admin:    true,
+		}
+		m.AddUser(admin)
+		guest := model.User{
+			Name:     "gast",
+			Password: "gast1234",
+			Admin:    false,
+			Guest:    true,
+		}
+		m.AddUser(guest)
+	}
 }
 
 // AddFile adding a file to the storage, stream like
@@ -317,12 +357,12 @@ func (m *MongoDAO) AddFile(filename string, reader io.Reader) (string, error) {
 func (m *MongoDAO) CreateSchematic(schematic model.Schematic) (string, error) {
 
 	for _, tag := range schematic.Tags {
-		if !slicesutils.Contains(m.tags, tag) {
+		if !m.tags.Contains(tag) {
 			m.CreateTag(tag)
 		}
 	}
 
-	if !slicesutils.Contains(m.manufacturers, schematic.Manufacturer) {
+	if !m.manufacturers.Contains(schematic.Manufacturer) {
 		m.CreateManufacturer(schematic.Manufacturer)
 	}
 
@@ -346,6 +386,39 @@ func (m *MongoDAO) CreateSchematic(schematic model.Schematic) (string, error) {
 	return "", nil
 }
 
+// UpdateSchematic creating a new schematic in the database
+func (m *MongoDAO) UpdateSchematic(schematic model.Schematic) (string, error) {
+
+	for _, tag := range schematic.Tags {
+		if !m.tags.Contains(tag) {
+			m.CreateTag(tag)
+		}
+	}
+
+	if !m.manufacturers.Contains(schematic.Manufacturer) {
+		m.CreateManufacturer(schematic.Manufacturer)
+	}
+
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	collection := m.database.Collection(schematicsCollectionName)
+	filter := bson.M{"_id": schematic.ID}
+	updateDoc := bson.D{{"$set", schematic}}
+	result, err := collection.UpdateOne(ctx, filter, updateDoc)
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+		return "", err
+	}
+	if result.ModifiedCount != 1 {
+		return "", errors.New("can't update document.")
+	}
+	err = collection.FindOne(ctx, filter).Decode(&schematic)
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+		return "", err
+	}
+	return schematic.ID.Hex(), nil
+}
+
 // GetSchematic getting a sdingle schematic
 func (m *MongoDAO) GetSchematic(schematicID string) (model.Schematic, error) {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
@@ -387,6 +460,32 @@ func (m *MongoDAO) DeleteSchematic(schematicID string) error {
 	}
 }
 
+//GetFile getting a single from the database with the id
+func (m *MongoDAO) GetFilename(fileid string) (string, error) {
+	objectID, err := primitive.ObjectIDFromHex(fileid)
+	if err != nil {
+		log.Print(err)
+		return "", err
+	}
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	cursor, err := m.bucket.Find(bson.M{"_id": objectID})
+	if err != nil {
+		log.Print(err)
+		return "", err
+	}
+	defer cursor.Close(ctx)
+	cursor.Next(ctx)
+	var file bson.M
+	var filename string
+	if err = cursor.Decode(&file); err != nil {
+		log.Print(err)
+		return "", err
+	} else {
+		filename = file["filename"].(string)
+	}
+	return filename, nil
+}
+
 //GetFile getting a single from the database with the id
 func (m *MongoDAO) GetFile(fileid string, stream io.Writer) error {
 	objectID, err := primitive.ObjectIDFromHex(fileid)
@@ -466,6 +565,44 @@ func (m *MongoDAO) GetSchematics(query string, offset int, limit int, owner stri
 	return n, schematics, nil
 }
 
+// GetSchematicsCount getting a sdingle schematic
+func (m *MongoDAO) GetSchematicsCount(query string, owner string) (int64, error) {
+	ctx, _ := context.WithTimeout(context.Background(), timeout)
+	schematicCollection := m.database.Collection(schematicsCollectionName)
+	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 := schematicCollection.CountDocuments(ctx, queryDoc, &options.CountOptions{Collation: &options.Collation{Locale: "en", Strength: 2}})
+	if err != nil {
+		log.Print(err)
+		return 0, err
+	}
+	return n, nil
+}
+
 // CreateTag create a new tag in the storage
 func (m *MongoDAO) CreateTag(tag string) error {
 	tag = strings.ToLower(tag)
@@ -477,10 +614,21 @@ func (m *MongoDAO) CreateTag(tag string) error {
 		fmt.Printf("error: %s\n", err.Error())
 		return err
 	}
-	m.tags = append(m.tags, tag)
+	m.tags.Add(tag, 1)
 	return nil
 }
 
+//GetTags getting a list of all tags
+func (m *MongoDAO) GetTags() []model.Tag {
+	sort.Slice(m.tags.List, func(i, j int) bool { return m.tags.List[i].Name < m.tags.List[j].Name })
+	return m.tags.List
+}
+
+// GetTagsCount getting the count of all tags
+func (m *MongoDAO) GetTagsCount() int {
+	return len(m.tags.List)
+}
+
 // CreateManufacturer create a new manufacturer in the storage
 func (m *MongoDAO) CreateManufacturer(manufacturer string) error {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
@@ -491,28 +639,19 @@ func (m *MongoDAO) CreateManufacturer(manufacturer string) error {
 		fmt.Printf("error: %s\n", err.Error())
 		return err
 	}
-	m.manufacturers = append(m.manufacturers, manufacturer)
+	m.manufacturers.Add(manufacturer, 1)
 	return nil
 }
 
-//GetTags getting a list of all tags
-func (m *MongoDAO) GetTags() []string {
-	return m.tags
-}
-
 // GetManufacturers getting a list of all manufacturers
-func (m *MongoDAO) GetManufacturers() []string {
-	return m.manufacturers
-}
-
-// GetTagsCount getting the count of all tags
-func (m *MongoDAO) GetTagsCount() int {
-	return len(m.tags)
+func (m *MongoDAO) GetManufacturers() []model.Manufacturer {
+	sort.Slice(m.manufacturers.List, func(i, j int) bool { return m.manufacturers.List[i].Name < m.manufacturers.List[j].Name })
+	return m.manufacturers.List
 }
 
 // GetManufacturersCount getting the count of all manufacturers
 func (m *MongoDAO) GetManufacturersCount() int {
-	return len(m.manufacturers)
+	return len(m.manufacturers.List)
 }
 
 // CheckUser checking username and password... returns true if the user is active and the password for this user is correct
@@ -568,10 +707,12 @@ func (m *MongoDAO) DropAll() {
 		log.Fatal(err)
 	}
 	for _, name := range collectionNames {
-		collection := m.database.Collection(name)
-		err = collection.Drop(ctx)
-		if err != nil {
-			log.Fatal(err)
+		if name != usersCollectionName {
+			collection := m.database.Collection(name)
+			err = collection.Drop(ctx)
+			if err != nil {
+				log.Fatal(err)
+			}
 		}
 	}
 }

schematic-service-go/dao/storageDao.go

@@ -16,14 +16,17 @@ type StorageDao interface {
 	AddFile(filename string, reader io.Reader) (string, error)
 	CreateSchematic(schematic model.Schematic) (string, error)
 	GetSchematic(schematicID string) (model.Schematic, error)
+	UpdateSchematic(schematic model.Schematic) (string, error)
+	GetFilename(fileid string) (string, error)
 	GetFile(fileid string, stream io.Writer) error
 	GetSchematics(query string, offset int, limit int, owner string) (int64, []model.Schematic, error)
+	GetSchematicsCount(query string, owner string) (int64, error)
 	DeleteSchematic(schematicID string) error
 	CreateTag(tag string) error
-	GetTags() []string
+	GetTags() []model.Tag
 	GetTagsCount() int
 	CreateManufacturer(manufacturer string) error
-	GetManufacturers() []string
+	GetManufacturers() []model.Manufacturer
 	GetManufacturersCount() int
 
 	CheckUser(username string, password string) bool

schematic-service-go/deployments/build.cmd

@@ -1,2 +1,2 @@
 @echo off
-go build -ldflags="-s -w" -o gomicro.exe cmd/service.go
+go build -ldflags="-s -w" -o schematic-service-go.exe cmd/service.go

schematic-service-go/deployments/buildDocker.cmd

@@ -1,3 +1,3 @@
 @echo off
-docker build ./ -t easy_software/gomicro:V1
-docker run --name GoMicro -p 8443:443 -p 8080:80 easy_software/gomicro:V1
+docker build ./ -t mcs/schematic-service-go:V1
+docker run --name schematic-service-go -p 8443:443 -p 8080:80 mcs/schematic-service-go:V1

schematic-service-go/deployments/setup_schematicsserver.md

@@ -0,0 +1,23 @@
+# Installation of the schematics server #
+
+The schematics server is a microservice written in go for serving all data related to the schematics database.
+
+All data is stored into a mongodb backend. The frontend will only present the data from this service.
+
+for the installtion you have to do the following steps.
+
+1. copy the binary, cmd and the config files on the server. binary in a base sub folder, config files beneth this in a folder config
+
+2. Install a mangodb version >4.x
+
+3. Create a database schematics and a user as dbadmin
+
+   start the mongo shell on the seleted server
+   the 
+
+   > use schematics
+   > db.createUser({ user: "schematic", pwd: "schematic", roles: [ "readWrite", "dbAdmin", { role: "dbOwner", db: "schematic" } ]})
+
+4. start the service with the start.cmd
+
+5. ready.

schematic-service-go/deployments/start.cmd

@@ -1 +1 @@
-gomicro.exe -p 8080
+schematic-service-go.exe -c configs/serviceLocal.yaml

schematic-service-go/devdata/mongo.txt

@@ -10,3 +10,6 @@ query with Collation {locale: "en", strength : 2}
 
 {$or: [{$text : {$search : "blue"}} , { manufacturer: "swr"}, {model: "OM"}]}
 
+https://127.0.0.1:9443/api/v1/schematics?query={"$fulltext":"\"blue \" \"Mesa\""}&offset=0&limit=10
+
+{"name": "w.klaas@gmx.de", "password":"akteon0000", "admin": true}

schematic-service-go/model/manufacturer.go

@@ -0,0 +1,40 @@
+package model
+
+import "go.mongodb.org/mongo-driver/bson/primitive"
+
+type Manufacturer struct {
+	ID    primitive.ObjectID `json:"-" bson:"_id,omitempty"`
+	Name  string             `json:"name" bson:"name,omitempty"`
+	Count int                `json:"count" bson:"count,omitempty"`
+}
+
+type Manufacturers struct {
+	List []Manufacturer
+}
+
+func NewManufacturers() Manufacturers {
+	m := Manufacturers{
+		List: make([]Manufacturer, 0),
+	}
+	return m
+}
+
+//Contains checking if the manufacturer name is present in the list of manufacturers
+func (m *Manufacturers) Contains(name string) bool {
+	for _, a := range m.List {
+		if a.Name == name {
+			return true
+		}
+	}
+	return false
+}
+
+//Add adding a new manufacturer to the list
+func (m *Manufacturers) Add(name string, count int) {
+	if !m.Contains(name) {
+		m.List = append(m.List, Manufacturer{
+			Name:  name,
+			Count: count,
+		})
+	}
+}

schematic-service-go/model/schematic.go

@@ -16,7 +16,7 @@ type Schematic struct {
 	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"`
+	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"`
@@ -70,21 +70,42 @@ func (s *Schematic) UnmarshalJSON(data []byte) error {
 		s.Owner = dat["owner"].(string)
 	}
 	if dat["files"] != nil {
-		values := dat["files"].([]interface{})
-		s.Files = make([]string, len(values))
-		for i, d := range values {
-			s.Files[i] = d.(string)
+		switch v := dat["files"].(type) {
+		case []interface{}:
+			values := v
+			s.Files = make(map[string]string)
+			for _, d := range values {
+				s.Files[d.(string)] = ""
+			}
+		case map[string]interface{}:
+			values := v
+			s.Files = make(map[string]string)
+			for k, d := range values {
+				s.Files[k] = d.(string)
+			}
 		}
 	}
 	if dat["foreignId"] != nil {
 		s.ForeignId = dat["foreignId"].(string)
 	}
 	if dat["createdAt"] != nil {
-		s.CreatedAt = time.Unix(0, int64(dat["createdAt"].(float64))*int64(time.Millisecond))
+		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 {
-		s.LastModifiedAt = time.Unix(0, int64(dat["lastModifiedAt"].(float64))*int64(time.Millisecond))
+		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)

schematic-service-go/model/tag.go

@@ -0,0 +1,40 @@
+package model
+
+import "go.mongodb.org/mongo-driver/bson/primitive"
+
+type Tag struct {
+	ID    primitive.ObjectID `json:"-" bson:"_id,omitempty"`
+	Name  string             `json:"name" bson:"name,omitempty"`
+	Count int                `json:"count" bson:"count,omitempty"`
+}
+
+type Tags struct {
+	List []Tag
+}
+
+func NewTags() Tags {
+	m := Tags{
+		List: make([]Tag, 0),
+	}
+	return m
+}
+
+//Contains checking if the manufacturer name is present in the list of manufacturers
+func (m *Tags) Contains(name string) bool {
+	for _, a := range m.List {
+		if a.Name == name {
+			return true
+		}
+	}
+	return false
+}
+
+//Add adding a new manufacturer to the list
+func (m *Tags) Add(name string, count int) {
+	if !m.Contains(name) {
+		m.List = append(m.List, Tag{
+			Name:  name,
+			Count: count,
+		})
+	}
+}

schematic-service-go/model/user.go

@@ -8,4 +8,5 @@ type User struct {
 	Password    string             `json:"password" bson:"password,omitempty"`
 	NewPassword string             `json:"newpassword" bson:"-"`
 	Admin       bool               `json:"admin" bson:"admin,omitempty"`
+	Guest       bool               `json:"guest" bson:"guest,omitempty"`
 }

schematic_tools/.vscode/launch.json

@@ -0,0 +1,18 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+
+        {
+            "name": "GoHash",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "program": "${workspaceFolder}/cmd/dublettes.go",
+            "env": {},
+            "args": ["-r", "E:/TEMP/backup/schematic/report.json", "E:/TEMP/backup/schematic/LIVE"]
+        }
+    ]
+}

schematic_tools/cmd/dublettes.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	flag "github.com/spf13/pflag"
+)
+
+var driveLetter string
+var report string
+
+func init() {
+	flag.StringVarP(&report, "report", "r", "", "json formatted report file.")
+}
+
+func main() {
+	log.Println("starting GoHash")
+	flag.Parse()
+
+	index := make(map[string][]string)
+	data, err := ioutil.ReadFile(report)
+	if err != nil {
+		fmt.Print(err)
+	}
+
+	err = json.Unmarshal(data, &index)
+	if err != nil {
+		fmt.Print(err)
+	}
+
+	log.Printf("found %d entries to check.", len(index))
+
+	myFolder := flag.Arg(0)
+	file, err := os.Stat(myFolder)
+	if os.IsNotExist(err) {
+		log.Fatalln("File does not exists:", myFolder)
+	}
+	if file.IsDir() {
+		log.Println("start with folder:", myFolder)
+		driveLetter = ""
+		if runtime.GOOS == "windows" {
+			driveLetter = filepath.VolumeName(myFolder) + "/"
+		}
+		log.Printf("driveletter: %s", driveLetter)
+		doSomething()
+	} else {
+		log.Printf("file %s has hash %s\n", myFolder, getSha256Hash(myFolder))
+	}
+
+	log.Println("done")
+}
+
+func doSomething() {
+
+}
+
+func getSha256Hash(fileStr string) string {
+	f, err := os.Open(fileStr)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+
+	h := sha256.New()
+	if _, err := io.Copy(h, f); err != nil {
+		log.Fatal(err)
+	}
+	return hex.EncodeToString(h.Sum(nil))
+}

schematic_tools/go.mod

@@ -0,0 +1,5 @@
+module github.com/willie68/schematic-tools
+
+go 1.14
+
+require github.com/spf13/pflag v1.0.5

schematic_tools/go.sum

@@ -0,0 +1,2 @@
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=