import and create index onmongodb

schematic-service-go/cmd/service.go

@@ -133,6 +133,7 @@ func main() {
 		log.Info("ssl active")
 	}
 
+	dao.InitDB(config.Get().MongoDB)
 	importData()
 
 	api.SystemID = serviceConfig.SystemID
@@ -282,7 +283,7 @@ func getApikey() string {
 
 func importData() {
 	count := 0
-	dir := "Y:/temp/backup/schematic/LIVE/"
+	dir := "E:/temp/backup/schematic/LIVE/"
 	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
 		if info != nil {
 			if info.IsDir() {
@@ -291,6 +292,17 @@ func importData() {
 				if !os.IsNotExist(err) {
 					count++
 					schematic := getSchematic(filepath)
+					fileids := make([]string, 0)
+					for _, f := range schematic.Files {
+						fileid, err := dao.AddFile(path + "/" + f)
+						if err != nil {
+							fmt.Printf("%v\n", err)
+						} else {
+							fmt.Printf("fileid: %s\n", fileid)
+							fileids = append(fileids, fileid)
+						}
+					}
+					schematic.Files = fileids
 					id, err := dao.CreateSchematic(schematic)
 					fmt.Printf("%v\n", err)
 					fmt.Printf("%d: found %s: man: %s, model: %s\n", count, id, schematic.Manufacturer, schematic.Model)

schematic-service-go/config/config.go

@@ -17,6 +17,8 @@ type Config struct {
 	Logging    Logging `yaml:"logging"`
 
 	HealthCheck HealthCheck `yaml:"healthcheck"`
+
+	MongoDB MongoDB `yaml: "mongodb"`
 }
 
 type Logging struct {
@@ -27,3 +29,12 @@ type Logging struct {
 type HealthCheck struct {
 	Period int `yaml:"period"`
 }
+
+type MongoDB struct {
+	Host     string `yaml:"host"`
+	Port     int    `yaml:"port"`
+	Username string `yaml:"username"`
+	Password string `yaml:"password"`
+	AuthDB   string `yaml:"authdb"`
+	Database string `yaml:"database"`
+}

schematic-service-go/config/loader.go

@@ -3,6 +3,7 @@ package config
 import (
 	"fmt"
 	"io/ioutil"
+	"log"
 	"os"
 
 	"gopkg.in/yaml.v3"
@@ -40,7 +41,10 @@ func Load() error {
 	if err != nil {
 		return fmt.Errorf("can't unmarshal config file: %s", err.Error())
 	}
-	return readSecret()
+	readSecret()
+	value, _ := yaml.Marshal(config)
+	log.Printf("using configfile %s. \nconfiguration:\n%s\n", File, string(value))
+	return nil
 }
 
 func readSecret() error {
@@ -61,6 +65,6 @@ func readSecret() error {
 }
 
 func mergeSecret(secret Secret) {
-	//	config.MongoDB.Username = secret.MongoDB.Username
-	//	config.MongoDB.Password = secret.MongoDB.Password
+	config.MongoDB.Username = secret.MongoDB.Username
+	config.MongoDB.Password = secret.MongoDB.Password
 }

schematic-service-go/configs/secret.yaml

@@ -0,0 +1,3 @@
+mongodb:
+    username: schematic
+    password: schematic

schematic-service-go/configs/serviceLocal.yaml

@@ -17,3 +17,11 @@ logging:
 
 healthcheck:
     period: 30
+
+mongodb:
+    host: 127.0.0.1
+    port: 27017
+    username:
+    password:
+    authdb: schematic
+    database: schematic

schematic-service-go/dao/mongodao.go

@@ -1,30 +1,38 @@
 package dao
 
 import (
+	"bufio"
 	"context"
 	"fmt"
+	"log"
+	"os"
+	"path/filepath"
 	"time"
 
+	"github.com/willie68/schematic-service-go/config"
+	slicesutils "github.com/willie68/schematic-service-go/internal"
 	"github.com/willie68/schematic-service-go/model"
+
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/gridfs"
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
-const dbPort = 32768
-const host = "192.168.178.12"
-const username = "admin"
-const password = "akteon00"
-const database = "schematic"
 const timeout = 1 * time.Minute
 
 var client *mongo.Client
+var mongoConfig config.MongoDB
+var bucket gridfs.Bucket
+var database mongo.Database
 
-func init() {
-	uri := fmt.Sprintf("mongodb://%s:%s@%s:%d", username, password, host, dbPort)
+func InitDB(MongoConfig config.MongoDB) {
+	mongoConfig = MongoConfig
+	//	uri := fmt.Sprintf("mongodb://%s:%s@%s:%d", mongoConfig.Username, mongoConfig.Password, mongoConfig.Host, mongoConfig.Port)
+	uri := fmt.Sprintf("mongodb://%s:%d", mongoConfig.Host, mongoConfig.Port)
 	clientOptions := options.Client()
 	clientOptions.ApplyURI(uri)
-	clientOptions.Auth = &options.Credential{Username: username, Password: password, AuthSource: "admin"}
+	clientOptions.Auth = &options.Credential{Username: mongoConfig.Username, Password: mongoConfig.Password, AuthSource: mongoConfig.AuthDB}
 	var err error
 	client, err = mongo.NewClient(clientOptions)
 	if err != nil {
@@ -36,11 +44,104 @@ func init() {
 	if err != nil {
 		fmt.Printf("error: %s\n", err.Error())
 	}
+	database = *client.Database(mongoConfig.Database)
+
+	myBucket, err := gridfs.NewBucket(&database, options.GridFSBucket().SetName("attachment"))
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+	}
+	bucket = *myBucket
+
+	initIndex()
+}
+
+func initIndex() {
+	collection := database.Collection("schematic")
+	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))
+	}
+
+	for _, name := range myIndexes {
+		log.Println(name)
+	}
+	if !slicesutils.Contains(myIndexes, "manufaturer") {
+		ctx, _ = context.WithTimeout(context.Background(), timeout)
+		models := []mongo.IndexModel{
+			{
+				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{{"subtitle", 1}},
+				Options: options.Index().SetName("subtitle").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)
+		}
+		for _, name := range names {
+			log.Println(name)
+		}
+	}
+	/*
+	   	db.collection.createIndex( { "key" : 1 },
+	                              { collation: {
+	                                  locale : <locale>,
+	                                  strength : <strength>
+	                                }
+	                              } )
+	*/
+}
+
+func AddFile(File string) (string, error) {
+	filename := filepath.Base(File)
+	uploadOpts := options.GridFSUpload().SetMetadata(bson.D{{"tag", "tag"}})
+
+	f, err := os.Open(File)
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+		return "", err
+	}
+	defer f.Close()
+	reader := bufio.NewReader(f)
+
+	fileID, err := bucket.UploadFromStream(filename, reader, uploadOpts)
+	if err != nil {
+		fmt.Printf("error: %s\n", err.Error())
+		return "", err
+	}
+	log.Printf("Write file to DB was successful. File id: %s \n", fileID)
+	id := fileID.String()
+	return id, nil
 }
 
 func CreateSchematic(schematic model.Schematic) (string, error) {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	collection := client.Database(database).Collection("schematic")
+	collection := database.Collection("schematic")
 	result, err := collection.InsertOne(ctx, schematic)
 	if err != nil {
 		fmt.Printf("error: %s\n", err.Error())

schematic-service-go/devdata/mongo.txt

@@ -0,0 +1,2 @@
+use schematic
+db.createUser({ user: "schematic", pwd: "schematic", roles: [ "readWrite", "dbAdmin", { role: "dbOwner", db: "schematic" } ]})

schematic-service-go/internal/slicesutils.go

@@ -0,0 +1,45 @@
+package slicesutils
+
+/*
+Contains checking if the e string is present in the slice s
+*/
+func Contains(s []string, e string) bool {
+	for _, a := range s {
+		if a == e {
+			return true
+		}
+	}
+	return false
+}
+
+/*
+Remove removes the entry with the index i from the slice
+*/
+func Remove(s []string, i int) []string {
+	s[i] = s[len(s)-1]
+	// We do not need to put s[i] at the end, as it will be discarded anyway
+	return s[:len(s)-1]
+}
+
+/*
+Remove removes the e entry from the s slice, if e is not present in the slice, nothing will happen
+*/
+func RemoveString(s []string, e string) []string {
+	index := Find(s, e)
+	if index >= 0 {
+		return Remove(s, index)
+	}
+	return s
+}
+
+/*
+Find finding the index of the e string in the s slice
+*/
+func Find(s []string, e string) int {
+	for i, n := range s {
+		if e == n {
+			return i
+		}
+	}
+	return -1
+}

schematic-service-go/internal/slicesutils_test.go

@@ -0,0 +1,58 @@
+package slicesutils_test
+
+import (
+	"testing"
+
+	slicesutils "github.com/willie68/schematic-service-go/internal"
+)
+
+func TestContains(t *testing.T) {
+	mySlice := []string{"Willie", "Arthur", "Till"}
+	value := slicesutils.Contains(mySlice, "Willie")
+	if value != true {
+		t.Errorf("Willie was not in the slice")
+	}
+}
+func TestRemoveString(t *testing.T) {
+	mySlice := []string{"Willie", "Arthur", "Till"}
+	value := slicesutils.RemoveString(mySlice, "Willie")
+	if slicesutils.Contains(value, "Willie") {
+		t.Errorf("Willie was not removed from the slice")
+	}
+	value = slicesutils.RemoveString(mySlice, "Herman")
+	if len(value) != 3 {
+		t.Errorf("slice not unchanged")
+	}
+}
+
+func TestRemove(t *testing.T) {
+	mySlice := []string{"Willie", "Arthur", "Till"}
+	value := slicesutils.Remove(mySlice, 0)
+	if slicesutils.Contains(value, "Willie") {
+		t.Errorf("Willie was not removed from the slice")
+	}
+}
+
+func TestFind(t *testing.T) {
+	mySlice := []string{"Willie", "Arthur", "Till"}
+	value := slicesutils.Find(mySlice, "Willie")
+	if value != 0 {
+		t.Errorf("Willie was not found in the slice: index: %d", value)
+	}
+	value = slicesutils.Find(mySlice, "Arthur")
+	if value != 1 {
+		t.Errorf("Arthur was not found in the slice: index: %d", value)
+	}
+	value = slicesutils.Find(mySlice, "Till")
+	if value != 2 {
+		t.Errorf("Till was not found in the slice: index: %d", value)
+	}
+	value = slicesutils.Find(mySlice, "till")
+	if value >= 0 {
+		t.Errorf("till was wrongly found in the slice: index: %d", value)
+	}
+	value = slicesutils.Find(mySlice, "Herman")
+	if value >= 0 {
+		t.Errorf("Herman was wrongly found in the slice: index: %d", value)
+	}
+}