|
|
@@ -1,12 +1,11 @@
|
|
|
package dao
|
|
|
|
|
|
import (
|
|
|
- "bufio"
|
|
|
"context"
|
|
|
"fmt"
|
|
|
+ "io"
|
|
|
"log"
|
|
|
- "os"
|
|
|
- "path/filepath"
|
|
|
+ "strings"
|
|
|
"time"
|
|
|
|
|
|
"github.com/willie68/schematic-service-go/config"
|
|
|
@@ -20,12 +19,19 @@ import (
|
|
|
)
|
|
|
|
|
|
const timeout = 1 * time.Minute
|
|
|
+const attachmentsCollectionName = "attachments"
|
|
|
+const schematicsCollectionName = "schematics"
|
|
|
+const tagsCollectionName = "tags"
|
|
|
+const manufacturersCollectionName = "manufacturers"
|
|
|
|
|
|
var client *mongo.Client
|
|
|
var mongoConfig config.MongoDB
|
|
|
var bucket gridfs.Bucket
|
|
|
var database mongo.Database
|
|
|
+var tags []string
|
|
|
+var manufacturers []string
|
|
|
|
|
|
+// InitDB initialise the mongodb connection, build up all collections and indexes
|
|
|
func InitDB(MongoConfig config.MongoDB) {
|
|
|
mongoConfig = MongoConfig
|
|
|
// uri := fmt.Sprintf("mongodb://%s:%s@%s:%d", mongoConfig.Username, mongoConfig.Password, mongoConfig.Host, mongoConfig.Port)
|
|
|
@@ -46,17 +52,24 @@ func InitDB(MongoConfig config.MongoDB) {
|
|
|
}
|
|
|
database = *client.Database(mongoConfig.Database)
|
|
|
|
|
|
- myBucket, err := gridfs.NewBucket(&database, options.GridFSBucket().SetName("attachment"))
|
|
|
+ myBucket, err := gridfs.NewBucket(&database, options.GridFSBucket().SetName(attachmentsCollectionName))
|
|
|
if err != nil {
|
|
|
fmt.Printf("error: %s\n", err.Error())
|
|
|
}
|
|
|
bucket = *myBucket
|
|
|
|
|
|
- initIndex()
|
|
|
+ initIndexSchematics()
|
|
|
+ initIndexTags()
|
|
|
+ initIndexManufacturers()
|
|
|
+
|
|
|
+ tags = make([]string, 0)
|
|
|
+ manufacturers = make([]string, 0)
|
|
|
+ initTags()
|
|
|
+ initManufacturers()
|
|
|
}
|
|
|
|
|
|
-func initIndex() {
|
|
|
- collection := database.Collection("schematic")
|
|
|
+func initIndexSchematics() {
|
|
|
+ collection := database.Collection(schematicsCollectionName)
|
|
|
indexView := collection.Indexes()
|
|
|
ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
cursor, err := indexView.List(ctx)
|
|
|
@@ -103,31 +116,138 @@ func initIndex() {
|
|
|
if err != nil {
|
|
|
log.Fatal(err)
|
|
|
}
|
|
|
+ log.Print("create indexes:")
|
|
|
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"}})
|
|
|
+func initIndexTags() {
|
|
|
+ collection := database.Collection(tagsCollectionName)
|
|
|
+ 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))
|
|
|
+ }
|
|
|
|
|
|
- f, err := os.Open(File)
|
|
|
+ for _, name := range myIndexes {
|
|
|
+ log.Println(name)
|
|
|
+ }
|
|
|
+ if !slicesutils.Contains(myIndexes, "name") {
|
|
|
+ ctx, _ = context.WithTimeout(context.Background(), timeout)
|
|
|
+ models := []mongo.IndexModel{
|
|
|
+ {
|
|
|
+ Keys: bson.D{{"name", 1}},
|
|
|
+ Options: options.Index().SetUnique(true).SetName("name").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 initIndexManufacturers() {
|
|
|
+ collection := database.Collection(manufacturersCollectionName)
|
|
|
+ indexView := collection.Indexes()
|
|
|
+ ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
+ cursor, err := indexView.List(ctx)
|
|
|
if err != nil {
|
|
|
- fmt.Printf("error: %s\n", err.Error())
|
|
|
- return "", err
|
|
|
+ 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, "name") {
|
|
|
+ ctx, _ = context.WithTimeout(context.Background(), timeout)
|
|
|
+ models := []mongo.IndexModel{
|
|
|
+ {
|
|
|
+ Keys: bson.D{{"name", 1}},
|
|
|
+ Options: options.Index().SetUnique(true).SetName("name").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 initTags() {
|
|
|
+ ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
+ tagsCollection := database.Collection(tagsCollectionName)
|
|
|
+ cursor, err := tagsCollection.Find(ctx, bson.M{})
|
|
|
+ if err != nil {
|
|
|
+ log.Fatal(err)
|
|
|
+ }
|
|
|
+ defer cursor.Close(ctx)
|
|
|
+ for cursor.Next(ctx) {
|
|
|
+ var tag bson.M
|
|
|
+ if err = cursor.Decode(&tag); err != nil {
|
|
|
+ log.Fatal(err)
|
|
|
+ } else {
|
|
|
+ tags = append(tags, tag["name"].(string))
|
|
|
+ }
|
|
|
}
|
|
|
- defer f.Close()
|
|
|
- reader := bufio.NewReader(f)
|
|
|
+}
|
|
|
+
|
|
|
+func initManufacturers() {
|
|
|
+ ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
+ manufacturersCollection := database.Collection(manufacturersCollectionName)
|
|
|
+ cursor, err := manufacturersCollection.Find(ctx, bson.M{})
|
|
|
+ if err != nil {
|
|
|
+ log.Fatal(err)
|
|
|
+ }
|
|
|
+ defer cursor.Close(ctx)
|
|
|
+ for cursor.Next(ctx) {
|
|
|
+ var manufacturer bson.M
|
|
|
+ if err = cursor.Decode(&manufacturer); err != nil {
|
|
|
+ log.Fatal(err)
|
|
|
+ } else {
|
|
|
+ manufacturers = append(manufacturers, manufacturer["name"].(string))
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// AddFile adding a file to the storage, stream like
|
|
|
+func AddFile(filename string, reader io.Reader) (string, error) {
|
|
|
+ uploadOpts := options.GridFSUpload().SetMetadata(bson.D{{"tag", "tag"}})
|
|
|
|
|
|
fileID, err := bucket.UploadFromStream(filename, reader, uploadOpts)
|
|
|
if err != nil {
|
|
|
@@ -139,9 +259,21 @@ func AddFile(File string) (string, error) {
|
|
|
return id, nil
|
|
|
}
|
|
|
|
|
|
+// CreateSchematic creating a new schematic in the database
|
|
|
func CreateSchematic(schematic model.Schematic) (string, error) {
|
|
|
+
|
|
|
+ for _, tag := range schematic.Tags {
|
|
|
+ if !slicesutils.Contains(tags, tag) {
|
|
|
+ CreateTag(tag)
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if !slicesutils.Contains(manufacturers, schematic.Manufacturer) {
|
|
|
+ CreateManufacturer(schematic.Manufacturer)
|
|
|
+ }
|
|
|
+
|
|
|
ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
- collection := database.Collection("schematic")
|
|
|
+ collection := database.Collection(schematicsCollectionName)
|
|
|
result, err := collection.InsertOne(ctx, schematic)
|
|
|
if err != nil {
|
|
|
fmt.Printf("error: %s\n", err.Error())
|
|
|
@@ -155,3 +287,63 @@ func CreateSchematic(schematic model.Schematic) (string, error) {
|
|
|
}
|
|
|
return result.InsertedID.(string), nil
|
|
|
}
|
|
|
+
|
|
|
+// CreateTag create a new tag in the storage
|
|
|
+func CreateTag(tag string) error {
|
|
|
+ tag = strings.ToLower(tag)
|
|
|
+ ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
+ collection := database.Collection(tagsCollectionName)
|
|
|
+ tagModel := bson.M{"name": tag}
|
|
|
+ _, err := collection.InsertOne(ctx, tagModel)
|
|
|
+ if err != nil {
|
|
|
+ fmt.Printf("error: %s\n", err.Error())
|
|
|
+ return err
|
|
|
+ }
|
|
|
+ tags = append(tags, tag)
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// CreateManufacturer create a new manufacturer in the storage
|
|
|
+func CreateManufacturer(manufacturer string) error {
|
|
|
+ ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
+ collection := database.Collection(manufacturersCollectionName)
|
|
|
+ manufacturerModel := bson.M{"name": manufacturer}
|
|
|
+ _, err := collection.InsertOne(ctx, manufacturerModel)
|
|
|
+ if err != nil {
|
|
|
+ fmt.Printf("error: %s\n", err.Error())
|
|
|
+ return err
|
|
|
+ }
|
|
|
+ manufacturers = append(manufacturers, manufacturer)
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+func GetTags() []string {
|
|
|
+ return tags
|
|
|
+}
|
|
|
+
|
|
|
+func GetManufacturers() []string {
|
|
|
+ return manufacturers
|
|
|
+}
|
|
|
+
|
|
|
+func GetTagsCount() int {
|
|
|
+ return len(tags)
|
|
|
+}
|
|
|
+
|
|
|
+func GetManufacturersCount() int {
|
|
|
+ return len(manufacturers)
|
|
|
+}
|
|
|
+
|
|
|
+func DropAll() {
|
|
|
+ ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
+ collectionNames, err := database.ListCollectionNames(ctx, bson.D{}, &options.ListCollectionsOptions{})
|
|
|
+ if err != nil {
|
|
|
+ log.Fatal(err)
|
|
|
+ }
|
|
|
+ for _, name := range collectionNames {
|
|
|
+ collection := database.Collection(name)
|
|
|
+ err = collection.Drop(ctx)
|
|
|
+ if err != nil {
|
|
|
+ log.Fatal(err)
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
