WilliesSchematicsWorld/schematic-service-go/dao/mongodao.go

package dao

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"strings"
	"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/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/gridfs"
	"go.mongodb.org/mongo-driver/mongo/options"
)

// time to reload all users
const userReloadPeriod = 1 * time.Hour
const timeout = 1 * time.Minute
const attachmentsCollectionName = "attachments"
const schematicsCollectionName = "schematics"
const tagsCollectionName = "tags"
const manufacturersCollectionName = "manufacturers"
const usersCollectionName = "users"

// MongoDAO a mongodb based dao
type MongoDAO struct {
	initialised   bool
	client        *mongo.Client
	mongoConfig   config.MongoDB
	bucket        gridfs.Bucket
	database      mongo.Database
	tags          []string
	manufacturers []string
	users         map[string]string
	ticker        time.Ticker
	done          chan bool
}

// InitDAO initialise the mongodb connection, build up all collections and indexes
func (m *MongoDAO) InitDAO(MongoConfig config.MongoDB) {
	m.initialised = false
	m.mongoConfig = MongoConfig
	//	uri := fmt.Sprintf("mongodb://%s:%s@%s:%d", mongoConfig.Username, mongoConfig.Password, mongoConfig.Host, mongoConfig.Port)
	uri := fmt.Sprintf("mongodb://%s:%d", m.mongoConfig.Host, m.mongoConfig.Port)
	clientOptions := options.Client()
	clientOptions.ApplyURI(uri)
	clientOptions.Auth = &options.Credential{Username: m.mongoConfig.Username, Password: m.mongoConfig.Password, AuthSource: m.mongoConfig.AuthDB}
	var err error
	m.client, err = mongo.NewClient(clientOptions)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
	}
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()
	err = m.client.Connect(ctx)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
	}
	m.database = *m.client.Database(m.mongoConfig.Database)

	myBucket, err := gridfs.NewBucket(&m.database, options.GridFSBucket().SetName(attachmentsCollectionName))
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
	}
	m.bucket = *myBucket

	m.initIndexSchematics()
	m.initIndexTags()
	m.initIndexManufacturers()

	m.tags = make([]string, 0)
	m.manufacturers = make([]string, 0)
	m.users = make(map[string]string)
	m.initTags()
	m.initManufacturers()
	m.initUsers()
	m.initialised = true
}

func (m *MongoDAO) initIndexSchematics() {
	collection := m.database.Collection(schematicsCollectionName)
	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}),
			},
			{
				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
		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) initIndexTags() {
	collection := m.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))
	}

	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 (m *MongoDAO) initIndexManufacturers() {
	collection := m.database.Collection(manufacturersCollectionName)
	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, "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 (m *MongoDAO) initTags() {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	tagsCollection := m.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 {
			m.tags = append(m.tags, tag["name"].(string))
		}
	}
}

func (m *MongoDAO) initManufacturers() {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	manufacturersCollection := m.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 {
			m.manufacturers = append(m.manufacturers, manufacturer["name"].(string))
		}
	}
}

func (m *MongoDAO) initUsers() {
	m.reloadUsers()

	go func() {
		background := time.NewTicker(userReloadPeriod)
		for _ = range background.C {
			m.reloadUsers()
		}
	}()
}

func (m *MongoDAO) reloadUsers() {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	usersCollection := m.database.Collection(usersCollectionName)
	cursor, err := usersCollection.Find(ctx, bson.M{})
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(ctx)
	localUsers := make(map[string]string)
	for cursor.Next(ctx) {
		var user bson.M
		if err = cursor.Decode(&user); err != nil {
			log.Fatal(err)
		} else {
			username := user["name"].(string)
			password := user["password"].(string)
			localUsers[username] = BuildPasswordHash(password)
		}
	}
	m.users = localUsers
}

// AddFile adding a file to the storage, stream like
func (m *MongoDAO) AddFile(filename string, reader io.Reader) (string, error) {
	uploadOpts := options.GridFSUpload().SetMetadata(bson.D{{"tag", "tag"}})

	fileID, err := m.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.Hex()
	return id, nil
}

// CreateSchematic creating a new schematic in the database
func (m *MongoDAO) CreateSchematic(schematic model.Schematic) (string, error) {

	for _, tag := range schematic.Tags {
		if !slicesutils.Contains(m.tags, tag) {
			m.CreateTag(tag)
		}
	}

	if !slicesutils.Contains(m.manufacturers, schematic.Manufacturer) {
		m.CreateManufacturer(schematic.Manufacturer)
	}

	ctx, _ := context.WithTimeout(context.Background(), timeout)
	collection := m.database.Collection(schematicsCollectionName)
	result, err := collection.InsertOne(ctx, schematic)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
		return "", err
	}
	filter := bson.M{"_id": result.InsertedID}
	err = collection.FindOne(ctx, filter).Decode(&schematic)
	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
}

// GetSchematic getting a sdingle schematic
func (m *MongoDAO) GetSchematic(schematicID string) (model.Schematic, error) {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	schematicCollection := m.database.Collection(schematicsCollectionName)
	objectID, _ := primitive.ObjectIDFromHex(schematicID)
	result := schematicCollection.FindOne(ctx, bson.M{"_id": objectID})
	err := result.Err()
	if err == mongo.ErrNoDocuments {
		log.Print(err)
		return model.Schematic{}, ErrNoDocument
	}
	if err != nil {
		log.Print(err)
		return model.Schematic{}, err
	}
	var schematic model.Schematic
	if err := result.Decode(&schematic); err != nil {
		log.Print(err)
		return model.Schematic{}, err
	} else {
		return schematic, nil
	}
}

// DeleteSchematic getting a sdingle schematic
func (m *MongoDAO) DeleteSchematic(schematicID string) error {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	schematicCollection := m.database.Collection(schematicsCollectionName)
	objectID, _ := primitive.ObjectIDFromHex(schematicID)
	result, err := schematicCollection.DeleteOne(ctx, bson.M{"_id": objectID})
	if err != nil {
		log.Print(err)
		return err
	} else {
		if result.DeletedCount > 0 {
			return nil
		}
		return ErrNoDocument
	}
}

//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)
	if err != nil {
		log.Print(err)
		return err
	}
	dStream, err := m.bucket.DownloadToStream(objectID, stream)
	if err != nil {
		log.Print(err)
		return err
	}
	fmt.Printf("File size to download: %v \n", dStream)
	return nil
}

// GetSchematics getting a sdingle schematic
func (m *MongoDAO) GetSchematics(query string, offset int, limit int, owner string) (int64, []model.Schematic, error) {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	schematicCollection := m.database.Collection(schematicsCollectionName)
	var queryM map[string]interface{}
	err := json.Unmarshal([]byte(query), &queryM)
	if err != nil {
		log.Print(err)
		return 0, nil, err
	}
	queryDoc := bson.M{}
	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, nil, err
	}
	cursor, err := schematicCollection.Find(ctx, queryDoc, &options.FindOptions{Collation: &options.Collation{Locale: "en", Strength: 2}})
	if err != nil {
		log.Print(err)
		return 0, 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 0, nil, err
				} else {
					if !schematic.PrivateFile || schematic.Owner == owner {
						schematics = append(schematics, schematic)
						docs++
					}
				}
			} else {
				break
			}
		}
		count++
	}
	return n, schematics, nil
}

// CreateTag create a new tag in the storage
func (m *MongoDAO) CreateTag(tag string) error {
	tag = strings.ToLower(tag)
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	collection := m.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
	}
	m.tags = append(m.tags, tag)
	return nil
}

// CreateManufacturer create a new manufacturer in the storage
func (m *MongoDAO) CreateManufacturer(manufacturer string) error {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	collection := m.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
	}
	m.manufacturers = append(m.manufacturers, manufacturer)
	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)
}

// GetManufacturersCount getting the count of all manufacturers
func (m *MongoDAO) GetManufacturersCount() int {
	return len(m.manufacturers)
}

// 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 {
	pwd, ok := m.users[username]
	if ok {
		if pwd == password {
			return true
		} else {
			user, ok := m.GetUser(username)
			if ok {
				if user.Password == password {
					return true
				}
			}
		}
	}

	if !ok {
		user, ok := m.GetUser(username)
		if ok {
			if user.Password == password {
				return true
			}
		}
	}

	return false
}

// GetUser getting the usermolde
func (m *MongoDAO) GetUser(username string) (model.User, bool) {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	usersCollection := m.database.Collection(usersCollectionName)
	var user model.User
	filter := bson.M{"name": username}
	err := usersCollection.FindOne(ctx, filter).Decode(&user)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
		return model.User{}, false
	}
	password := user.Password
	hash := BuildPasswordHash(password)
	m.users[username] = hash
	return user, true
}

// DropAll dropping all data from the database
func (m *MongoDAO) DropAll() {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	collectionNames, err := m.database.ListCollectionNames(ctx, bson.D{}, &options.ListCollectionsOptions{})
	if err != nil {
		log.Fatal(err)
	}
	for _, name := range collectionNames {
		collection := m.database.Collection(name)
		err = collection.Drop(ctx)
		if err != nil {
			log.Fatal(err)
		}
	}
}

// Stop stopping the mongodao
func (m *MongoDAO) Stop() {
	m.ticker.Stop()
	m.done <- true
}

// AddUser adding a new user to the system
func (m *MongoDAO) AddUser(user model.User) error {
	if user.Name == "" {
		return errors.New("username should not be empty")
	}
	_, ok := m.users[user.Name]
	if ok {
		return errors.New("username already exists")
	}

	user.Password = BuildPasswordHash(user.Password)

	ctx, _ := context.WithTimeout(context.Background(), timeout)
	collection := m.database.Collection(usersCollectionName)
	_, err := collection.InsertOne(ctx, user)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
		return err
	}
	m.users[user.Name] = user.Password
	return nil
}

// DeleteUser deletes one user from the system
func (m *MongoDAO) DeleteUser(username string) error {
	if username == "" {
		return errors.New("username should not be empty")
	}
	_, ok := m.users[username]
	if !ok {
		return errors.New("username not exists")
	}

	ctx, _ := context.WithTimeout(context.Background(), timeout)
	collection := m.database.Collection(usersCollectionName)
	filter := bson.M{"name": username}
	_, err := collection.DeleteOne(ctx, filter)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
		return err
	}
	delete(m.users, username)
	return nil
}

// ChangePWD changes the apssword of a single user
func (m *MongoDAO) ChangePWD(username string, newpassword string, oldpassword string) error {
	if username == "" {
		return errors.New("username should not be empty")
	}
	pwd, ok := m.users[username]
	if !ok {
		return errors.New("username not registered")
	}

	newpassword = BuildPasswordHash(newpassword)
	oldpassword = BuildPasswordHash(oldpassword)
	if pwd != oldpassword {
		return errors.New("actual password incorrect")
	}

	ctx, _ := context.WithTimeout(context.Background(), timeout)
	collection := m.database.Collection(usersCollectionName)
	filter := bson.M{"name": username}
	update := bson.D{{"$set", bson.D{{"password", newpassword}}}}
	result := collection.FindOneAndUpdate(ctx, filter, update)
	if result.Err() != nil {
		fmt.Printf("error: %s\n", result.Err().Error())
		return result.Err()
	}
	m.users[username] = newpassword
	return nil
}

// Ping pinging the mongoDao
func (m *MongoDAO) Ping() error {
	if !m.initialised {
		return errors.New("mongo client not initialised")
	}
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	return m.database.Client().Ping(ctx, nil)
}