error handling, user managment, storage object

schematic-service-go/api/basicauth.go

@@ -1,7 +1,6 @@
 package api
 
 import (
-	"crypto/md5"
 	"fmt"
 	"net/http"
 
@@ -13,14 +12,13 @@ func BasicAuth(realm string) func(next http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			user, pass, ok := r.BasicAuth()
-			hash := md5.Sum([]byte(pass))
-			pass = fmt.Sprintf("md5:%x", hash)
+			pass = dao.BuildPasswordHash(pass)
 			if !ok {
 				basicAuthFailed(w, realm)
 				return
 			}
 			fmt.Printf("user: %s, password: %s\n", user, pass)
-			if !dao.CheckUser(user, pass) {
+			if !dao.GetStorage().CheckUser(user, pass) {
 				basicAuthFailed(w, realm)
 				return
 			}

schematic-service-go/api/endpoints.go

@@ -109,6 +109,6 @@ func getTenant(req *http.Request) string {
 
 //DropAllEndpoint dropping all data
 func DropAllEndpoint(response http.ResponseWriter, req *http.Request) {
-	dao.DropAll()
+	dao.GetStorage().DropAll()
 	render.JSON(response, req, "")
 }

schematic-service-go/api/listsendpoint.go

@@ -26,24 +26,24 @@ func ManufacturersRoutes() *chi.Mux {
 
 //GetTagsEndpoint getting all tags back. No paging...
 func GetTagsEndpoint(response http.ResponseWriter, req *http.Request) {
-	tags := dao.GetTags()
+	tags := dao.GetStorage().GetTags()
 	render.JSON(response, req, tags)
 }
 
 //GetManufacturersEndpoint getting all manufacturers back. No paging...
 func GetManufacturersEndpoint(response http.ResponseWriter, req *http.Request) {
-	manufacturers := dao.GetManufacturers()
+	manufacturers := dao.GetStorage().GetManufacturers()
 	render.JSON(response, req, manufacturers)
 }
 
 //GetTagsCountEndpoint getting all tags back. No paging...
 func GetTagsCountEndpoint(response http.ResponseWriter, req *http.Request) {
-	tagsCount := dao.GetTagsCount()
+	tagsCount := dao.GetStorage().GetTagsCount()
 	render.JSON(response, req, tagsCount)
 }
 
 //GetManufacturersCountEndpoint getting all manufacturers back. No paging...
 func GetManufacturersCountEndpoint(response http.ResponseWriter, req *http.Request) {
-	manufacturersCount := dao.GetManufacturersCount()
+	manufacturersCount := dao.GetStorage().GetManufacturersCount()
 	render.JSON(response, req, manufacturersCount)
 }

schematic-service-go/api/schematicapi.go

@@ -27,10 +27,10 @@ func SchematicsRoutes() *chi.Mux {
 	return router
 }
 
-// GetTenantHandler gets a tenant
+// GetSchematicHandler gets a tenant
 func GetSchematicHandler(response http.ResponseWriter, req *http.Request) {
 	schematicID := chi.URLParam(req, "schematicId")
-	schematic, err := dao.GetSchematic(schematicID)
+	schematic, err := dao.GetStorage().GetSchematic(schematicID)
 	if err != nil {
 		Msg(response, http.StatusBadRequest, err.Error())
 		return
@@ -43,19 +43,17 @@ func GetSchematicHandler(response http.ResponseWriter, req *http.Request) {
 	render.JSON(response, req, schematic)
 }
 
-// GetTenantHandler gets a tenant
+// GetSchematicFileHandler gets a tenant
 func GetSchematicFileHandler(response http.ResponseWriter, req *http.Request) {
-	//schematicID := chi.URLParam(req, "schematicId")
 	fileID := chi.URLParam(req, "fileId")
-	err := dao.GetFile(fileID, response)
+	err := dao.GetStorage().GetFile(fileID, response)
 	if err != nil {
 		Msg(response, http.StatusBadRequest, err.Error())
 		return
 	}
-	//render.JSON(response, req, schematic)
 }
 
-// GetTenantsHandler gets all tenants
+// GetSchematicsEndpoint gets all tenants
 func GetSchematicsEndpoint(response http.ResponseWriter, req *http.Request) {
 	offset := 0
 	limit := 10
@@ -81,12 +79,20 @@ func GetSchematicsEndpoint(response http.ResponseWriter, req *http.Request) {
 	log.Printf("query: %s, offset: %d, limit: %d\n", query, offset, limit)
 	owner, _, _ := req.BasicAuth()
 
-	schematics, err := dao.GetSchematics(query, offset, limit, owner)
+	n, schematics, err := dao.GetStorage().GetSchematics(query, offset, limit, owner)
 	if err != nil {
 		Msg(response, http.StatusBadRequest, err.Error())
 		return
 	}
-	render.JSON(response, req, schematics)
+	m := make(map[string]interface{})
+	m["data"] = schematics
+	m["found"] = n
+	m["count"] = len(schematics)
+	m["query"] = query
+	m["offset"] = offset
+	m["limit"] = limit
+
+	render.JSON(response, req, m)
 }
 
 func PostSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
@@ -102,12 +108,12 @@ func PostSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
 	}
 	schematic.CreatedAt = time.Now()
 	schematic.LastModifiedAt = time.Now()
-	id, err := dao.CreateSchematic(schematic)
+	id, err := dao.GetStorage().CreateSchematic(schematic)
 	if err != nil {
 		Msg(response, http.StatusBadRequest, err.Error())
 		return
 	}
-	schematic, err = dao.GetSchematic(id)
+	schematic, err = dao.GetStorage().GetSchematic(id)
 	if err != nil {
 		Msg(response, http.StatusBadRequest, err.Error())
 		return
@@ -128,7 +134,7 @@ func PostFileEndpoint(response http.ResponseWriter, req *http.Request) {
 	filename := fileHeader.Filename
 	reader := bufio.NewReader(f)
 
-	fileid, err := dao.AddFile(filename, reader)
+	fileid, err := dao.GetStorage().AddFile(filename, reader)
 	if err != nil {
 		fmt.Printf("%v\n", err)
 	} else {
@@ -142,14 +148,23 @@ func PostFileEndpoint(response http.ResponseWriter, req *http.Request) {
 }
 
 func DeleteSchematicEndpoint(response http.ResponseWriter, req *http.Request) {
-	/*
-		schematicID := chi.URLParam(req, "schematicId")
-		if err != nil {
-			Msg(response, http.StatusBadRequest, err.Error())
+	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
 		}
-	*/
-	render.JSON(response, req, "tenant")
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	owner, _, _ := req.BasicAuth()
+	if schematic.PrivateFile && schematic.Owner != owner {
+		Msg(response, http.StatusForbidden, "you don't have the permission to see this file")
+		return
+	}
+	dao.GetStorage().DeleteSchematic(schematic.ID.Hex())
+	render.JSON(response, req, schematic)
 }
 
 func UpdateSchematicEndpoint(response http.ResponseWriter, req *http.Request) {

schematic-service-go/api/userapi.go

@@ -0,0 +1,102 @@
+package api
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+	"github.com/willie68/schematic-service-go/dao"
+	"github.com/willie68/schematic-service-go/model"
+)
+
+// TagsRoutes getting all routes for the tags endpoint
+func UsersRoutes() *chi.Mux {
+	router := chi.NewRouter()
+	router.Post("/", PostUserEndpoint)
+	router.Put("/{username}", PutUserEndpoint)
+	router.Delete("/{username}", DeleteUserEndpoint)
+	return router
+}
+
+//PutUserEndpoint getting all tags back. No paging...
+func PostUserEndpoint(response http.ResponseWriter, req *http.Request) {
+	var user model.User
+	err := render.DefaultDecoder(req, &user)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	adminusername, _, _ := req.BasicAuth()
+	admin, ok := dao.GetStorage().GetUser(adminusername)
+	if !ok {
+		Msg(response, http.StatusInternalServerError, "")
+		return
+	}
+	if !admin.Admin {
+		Msg(response, http.StatusForbidden, "permission denied")
+		return
+	}
+
+	err = dao.GetStorage().AddUser(user)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	Msg(response, http.StatusCreated, fmt.Sprintf("user \"%s\" created sucessfully", user.Name))
+}
+
+//PutUserEndpoint getting all tags back. No paging...
+func PutUserEndpoint(response http.ResponseWriter, req *http.Request) {
+	username := chi.URLParam(req, "username")
+	var user model.User
+	err := render.DefaultDecoder(req, &user)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	if username != user.Name {
+		Msg(response, http.StatusBadRequest, "username should be identically")
+		return
+	}
+	adminusername, _, _ := req.BasicAuth()
+	admin, ok := dao.GetStorage().GetUser(adminusername)
+	if !ok {
+		Msg(response, http.StatusInternalServerError, "")
+		return
+	}
+	if !admin.Admin {
+		Msg(response, http.StatusForbidden, "permission denied")
+		return
+	}
+
+	err = dao.GetStorage().ChangePWD(username, user.NewPassword, user.Password)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	return
+}
+
+//PutUserEndpoint getting all tags back. No paging...
+func DeleteUserEndpoint(response http.ResponseWriter, req *http.Request) {
+	username := chi.URLParam(req, "username")
+	adminusername, _, _ := req.BasicAuth()
+	admin, ok := dao.GetStorage().GetUser(adminusername)
+	if !ok {
+		Msg(response, http.StatusInternalServerError, "")
+		return
+	}
+	if !admin.Admin {
+		Msg(response, http.StatusForbidden, "permission denied")
+		return
+	}
+
+	err := dao.GetStorage().DeleteUser(username)
+	if err != nil {
+		Msg(response, http.StatusBadRequest, err.Error())
+		return
+	}
+	return
+}

schematic-service-go/cmd/service.go

@@ -83,6 +83,7 @@ func routes() *chi.Mux {
 		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("/health", health.Routes())
 	})
 	return router
@@ -117,8 +118,6 @@ func main() {
 
 	healthCheckConfig := health.CheckConfig(serviceConfig.HealthCheck)
 
-	health.InitHealthSystem(healthCheckConfig)
-
 	defer log.Close()
 
 	gc := crypt.GenerateCertificate{
@@ -135,11 +134,17 @@ func main() {
 		log.Info("ssl active")
 	}
 
-	dao.InitDB(config.Get().MongoDB)
+	storage := &dao.MongoDAO{}
+	storage.InitDAO(config.Get().MongoDB)
+	//storage := &dao.SimpleDAO{Path: "E:/temp/schematics/"}
+	dao.Storage = storage
+
 	if importPath != "" {
 		go importData()
 	}
 
+	health.InitHealthSystem(healthCheckConfig)
+
 	apikey = getApikey()
 	api.APIKey = apikey
 	log.Infof("apikey: %s", apikey)
@@ -303,7 +308,7 @@ func importData() {
 						defer f.Close()
 						reader := bufio.NewReader(f)
 
-						fileid, err := dao.AddFile(filename, reader)
+						fileid, err := dao.GetStorage().AddFile(filename, reader)
 						if err != nil {
 							fmt.Printf("%v\n", err)
 						} else {
@@ -312,7 +317,7 @@ func importData() {
 						}
 					}
 					schematic.Files = fileids
-					id, err := dao.CreateSchematic(schematic)
+					id, err := dao.GetStorage().CreateSchematic(schematic)
 					if err != nil {
 						fmt.Printf("%v\n", err)
 					}

schematic-service-go/dao/errors.go

@@ -0,0 +1,5 @@
+package dao
+
+import "errors"
+
+var ErrNoDocument = errors.New("Document not found")

schematic-service-go/dao/mongodao.go

@@ -2,7 +2,8 @@ package dao
 
 import (
 	"context"
-	"crypto/md5"
+	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"log"
@@ -20,6 +21,8 @@ import (
 	"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"
@@ -27,55 +30,63 @@ const tagsCollectionName = "tags"
 const manufacturersCollectionName = "manufacturers"
 const usersCollectionName = "users"
 
-var client *mongo.Client
-var mongoConfig config.MongoDB
-var bucket gridfs.Bucket
-var database mongo.Database
-var tags []string
-var manufacturers []string
-var users map[string]string
-
-// InitDB initialise the mongodb connection, build up all collections and indexes
-func InitDB(MongoConfig config.MongoDB) {
-	mongoConfig = MongoConfig
+// 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", 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: mongoConfig.Username, Password: mongoConfig.Password, AuthSource: mongoConfig.AuthDB}
+	clientOptions.Auth = &options.Credential{Username: m.mongoConfig.Username, Password: m.mongoConfig.Password, AuthSource: m.mongoConfig.AuthDB}
 	var err error
-	client, err = mongo.NewClient(clientOptions)
+	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 = client.Connect(ctx)
+	err = m.client.Connect(ctx)
 	if err != nil {
 		fmt.Printf("error: %s\n", err.Error())
 	}
-	database = *client.Database(mongoConfig.Database)
+	m.database = *m.client.Database(m.mongoConfig.Database)
 
-	myBucket, err := gridfs.NewBucket(&database, options.GridFSBucket().SetName(attachmentsCollectionName))
+	myBucket, err := gridfs.NewBucket(&m.database, options.GridFSBucket().SetName(attachmentsCollectionName))
 	if err != nil {
 		fmt.Printf("error: %s\n", err.Error())
 	}
-	bucket = *myBucket
+	m.bucket = *myBucket
 
-	initIndexSchematics()
-	initIndexTags()
-	initIndexManufacturers()
+	m.initIndexSchematics()
+	m.initIndexTags()
+	m.initIndexManufacturers()
 
-	tags = make([]string, 0)
-	manufacturers = make([]string, 0)
-	users = make(map[string]string)
-	initTags()
-	initManufacturers()
-	initUsers()
+	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 initIndexSchematics() {
-	collection := database.Collection(schematicsCollectionName)
+func (m *MongoDAO) initIndexSchematics() {
+	collection := m.database.Collection(schematicsCollectionName)
 	indexView := collection.Indexes()
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
 	cursor, err := indexView.List(ctx)
@@ -133,8 +144,8 @@ func initIndexSchematics() {
 	}
 }
 
-func initIndexTags() {
-	collection := database.Collection(tagsCollectionName)
+func (m *MongoDAO) initIndexTags() {
+	collection := m.database.Collection(tagsCollectionName)
 	indexView := collection.Indexes()
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
 	cursor, err := indexView.List(ctx)
@@ -176,8 +187,8 @@ func initIndexTags() {
 	}
 }
 
-func initIndexManufacturers() {
-	collection := database.Collection(manufacturersCollectionName)
+func (m *MongoDAO) initIndexManufacturers() {
+	collection := m.database.Collection(manufacturersCollectionName)
 	indexView := collection.Indexes()
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
 	cursor, err := indexView.List(ctx)
@@ -219,9 +230,9 @@ func initIndexManufacturers() {
 	}
 }
 
-func initTags() {
+func (m *MongoDAO) initTags() {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	tagsCollection := database.Collection(tagsCollectionName)
+	tagsCollection := m.database.Collection(tagsCollectionName)
 	cursor, err := tagsCollection.Find(ctx, bson.M{})
 	if err != nil {
 		log.Fatal(err)
@@ -232,14 +243,14 @@ func initTags() {
 		if err = cursor.Decode(&tag); err != nil {
 			log.Fatal(err)
 		} else {
-			tags = append(tags, tag["name"].(string))
+			m.tags = append(m.tags, tag["name"].(string))
 		}
 	}
 }
 
-func initManufacturers() {
+func (m *MongoDAO) initManufacturers() {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	manufacturersCollection := database.Collection(manufacturersCollectionName)
+	manufacturersCollection := m.database.Collection(manufacturersCollectionName)
 	cursor, err := manufacturersCollection.Find(ctx, bson.M{})
 	if err != nil {
 		log.Fatal(err)
@@ -250,19 +261,31 @@ func initManufacturers() {
 		if err = cursor.Decode(&manufacturer); err != nil {
 			log.Fatal(err)
 		} else {
-			manufacturers = append(manufacturers, manufacturer["name"].(string))
+			m.manufacturers = append(m.manufacturers, manufacturer["name"].(string))
 		}
 	}
 }
 
-func initUsers() {
+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 := database.Collection(usersCollectionName)
+	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 {
@@ -270,20 +293,17 @@ func initUsers() {
 		} else {
 			username := user["name"].(string)
 			password := user["password"].(string)
-			if !strings.HasPrefix(password, "md5:") {
-				hash := md5.Sum([]byte(password))
-				password = fmt.Sprintf("md5:%x", hash)
-			}
-			users[username] = password
+			localUsers[username] = BuildPasswordHash(password)
 		}
 	}
+	m.users = localUsers
 }
 
 // AddFile adding a file to the storage, stream like
-func AddFile(filename string, reader io.Reader) (string, error) {
+func (m *MongoDAO) AddFile(filename string, reader io.Reader) (string, error) {
 	uploadOpts := options.GridFSUpload().SetMetadata(bson.D{{"tag", "tag"}})
 
-	fileID, err := bucket.UploadFromStream(filename, reader, uploadOpts)
+	fileID, err := m.bucket.UploadFromStream(filename, reader, uploadOpts)
 	if err != nil {
 		fmt.Printf("error: %s\n", err.Error())
 		return "", err
@@ -294,20 +314,20 @@ func AddFile(filename string, reader io.Reader) (string, error) {
 }
 
 // CreateSchematic creating a new schematic in the database
-func CreateSchematic(schematic model.Schematic) (string, error) {
+func (m *MongoDAO) CreateSchematic(schematic model.Schematic) (string, error) {
 
 	for _, tag := range schematic.Tags {
-		if !slicesutils.Contains(tags, tag) {
-			CreateTag(tag)
+		if !slicesutils.Contains(m.tags, tag) {
+			m.CreateTag(tag)
 		}
 	}
 
-	if !slicesutils.Contains(manufacturers, schematic.Manufacturer) {
-		CreateManufacturer(schematic.Manufacturer)
+	if !slicesutils.Contains(m.manufacturers, schematic.Manufacturer) {
+		m.CreateManufacturer(schematic.Manufacturer)
 	}
 
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	collection := database.Collection(schematicsCollectionName)
+	collection := m.database.Collection(schematicsCollectionName)
 	result, err := collection.InsertOne(ctx, schematic)
 	if err != nil {
 		fmt.Printf("error: %s\n", err.Error())
@@ -327,11 +347,20 @@ func CreateSchematic(schematic model.Schematic) (string, error) {
 }
 
 // GetSchematic getting a sdingle schematic
-func GetSchematic(schematicID string) (model.Schematic, error) {
+func (m *MongoDAO) GetSchematic(schematicID string) (model.Schematic, error) {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	schematicCollection := database.Collection(schematicsCollectionName)
-	objectId, _ := primitive.ObjectIDFromHex(schematicID)
-	result := schematicCollection.FindOne(ctx, bson.M{"_id": objectId})
+	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)
@@ -341,13 +370,31 @@ func GetSchematic(schematicID string) (model.Schematic, error) {
 	}
 }
 
-func GetFile(fileid string, stream io.Writer) error {
+// 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 := bucket.DownloadToStream(objectID, stream)
+	dStream, err := m.bucket.DownloadToStream(objectID, stream)
 	if err != nil {
 		log.Print(err)
 		return err
@@ -357,19 +404,41 @@ func GetFile(fileid string, stream io.Writer) error {
 }
 
 // GetSchematics getting a sdingle schematic
-func GetSchematics(query string, offset int, limit int, owner string) ([]model.Schematic, error) {
+func (m *MongoDAO) GetSchematics(query string, offset int, limit int, owner string) (int64, []model.Schematic, error) {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	schematicCollection := database.Collection(schematicsCollectionName)
+	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{}
-	err := bson.UnmarshalExtJSON([]byte(query), false, queryDoc)
+	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 nil, 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 nil, err
+		return 0, nil, err
 	}
 	defer cursor.Close(ctx)
 	schematics := make([]model.Schematic, 0)
@@ -381,7 +450,7 @@ func GetSchematics(query string, offset int, limit int, owner string) ([]model.S
 				var schematic model.Schematic
 				if err = cursor.Decode(&schematic); err != nil {
 					log.Print(err)
-					return nil, err
+					return 0, nil, err
 				} else {
 					if !schematic.PrivateFile || schematic.Owner == owner {
 						schematics = append(schematics, schematic)
@@ -394,75 +463,204 @@ func GetSchematics(query string, offset int, limit int, owner string) ([]model.S
 		}
 		count++
 	}
-	return schematics, nil
+	return n, schematics, nil
 }
 
 // CreateTag create a new tag in the storage
-func CreateTag(tag string) error {
+func (m *MongoDAO) CreateTag(tag string) error {
 	tag = strings.ToLower(tag)
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	collection := database.Collection(tagsCollectionName)
+	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
 	}
-	tags = append(tags, tag)
+	m.tags = append(m.tags, tag)
 	return nil
 }
 
 // CreateManufacturer create a new manufacturer in the storage
-func CreateManufacturer(manufacturer string) error {
+func (m *MongoDAO) CreateManufacturer(manufacturer string) error {
 	ctx, _ := context.WithTimeout(context.Background(), timeout)
-	collection := database.Collection(manufacturersCollectionName)
+	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
 	}
-	manufacturers = append(manufacturers, manufacturer)
+	m.manufacturers = append(m.manufacturers, manufacturer)
 	return nil
 }
 
-func GetTags() []string {
-	return tags
+//GetTags getting a list of all tags
+func (m *MongoDAO) GetTags() []string {
+	return m.tags
 }
 
-func GetManufacturers() []string {
-	return manufacturers
+// GetManufacturers getting a list of all manufacturers
+func (m *MongoDAO) GetManufacturers() []string {
+	return m.manufacturers
 }
 
-func GetTagsCount() int {
-	return len(tags)
+// GetTagsCount getting the count of all tags
+func (m *MongoDAO) GetTagsCount() int {
+	return len(m.tags)
 }
 
-func GetManufacturersCount() int {
-	return len(manufacturers)
+// GetManufacturersCount getting the count of all manufacturers
+func (m *MongoDAO) GetManufacturersCount() int {
+	return len(m.manufacturers)
 }
 
-func CheckUser(username string, password string) bool {
-	pwd, ok := users[username]
+// 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
 }
 
-func DropAll() {
+// 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 := database.ListCollectionNames(ctx, bson.D{}, &options.ListCollectionsOptions{})
+	collectionNames, err := m.database.ListCollectionNames(ctx, bson.D{}, &options.ListCollectionsOptions{})
 	if err != nil {
 		log.Fatal(err)
 	}
 	for _, name := range collectionNames {
-		collection := database.Collection(name)
+		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)
+}

schematic-service-go/dao/simplefiledao.go

@@ -0,0 +1,147 @@
+package dao
+
+import (
+	"bufio"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/google/uuid"
+	"github.com/willie68/schematic-service-go/model"
+)
+
+// SimpleDAO a file based dao
+type SimpleDAO struct {
+	Path          string
+	initialised   bool
+	tags          []string
+	manufacturers []string
+	users         map[string]string
+}
+
+// AddFile adding a file to the filestorage
+func (s *SimpleDAO) AddFile(filename string, reader io.Reader) (string, error) {
+	id := uuid.New().String()
+	filesPath := s.Path + "/files/" + id
+	err := os.MkdirAll(filesPath, os.ModePerm)
+	if err != nil {
+		return "", err
+	}
+	f, err := os.Create(fmt.Sprintf("%s/%s", filesPath, filename))
+	defer f.Close()
+	writer := bufio.NewWriter(f)
+	_, err = writer.ReadFrom(reader)
+	if err != nil {
+		return "", err
+	}
+	err = writer.Flush()
+	if err != nil {
+		return "", err
+	}
+	fmt.Printf("path %s\n", filesPath)
+	return id, nil
+}
+
+//CreateSchematic creates a new schematic file
+func (s *SimpleDAO) CreateSchematic(schematic model.Schematic) (string, error) {
+	id := uuid.New().String()
+	filesPath := s.Path + "/schematics/" + id
+	err := os.MkdirAll(filesPath, os.ModePerm)
+	if err != nil {
+		return "", err
+	}
+	schematicJson, _ := json.Marshal(schematic)
+	filesPath = filesPath + "/schematic.json"
+	err = ioutil.WriteFile(filesPath, schematicJson, 0644)
+	if err != nil {
+		return "", err
+	}
+	return id, nil
+}
+
+//GetSchematic getting a schematic from an id
+func (s *SimpleDAO) GetSchematic(schematicID string) (model.Schematic, error) {
+	return model.Schematic{}, errors.New("not implemented yet")
+}
+
+//GetFile getting a stream of a file
+func (s *SimpleDAO) GetFile(fileid string, stream io.Writer) error {
+	return errors.New("not implemented yet")
+}
+
+//GetSchematics query the schematics
+func (s *SimpleDAO) GetSchematics(query string, offset int, limit int, owner string) ([]model.Schematic, error) {
+	return nil, errors.New("not implemented yet")
+}
+
+//CreateTag create a new tag
+func (s *SimpleDAO) CreateTag(tag string) error {
+	return errors.New("not implemented yet")
+}
+
+//GetTags getting  all tags
+func (s *SimpleDAO) GetTags() []string {
+	return nil
+}
+
+//GetTagsCount getting the count of all tags
+func (s *SimpleDAO) GetTagsCount() int {
+	return 0
+}
+
+//CreateManufacturer create a new manufacturer
+func (s *SimpleDAO) CreateManufacturer(manufacturer string) error {
+	return errors.New("not implemented yet")
+}
+
+//GetManufacturers getting all manufacturers
+func (s *SimpleDAO) GetManufacturers() []string {
+	return nil
+}
+
+//GetManufacturersCount getting the count of all manufacturers
+func (s *SimpleDAO) GetManufacturersCount() int {
+	return 0
+}
+
+//CheckUser check user password
+func (s *SimpleDAO) CheckUser(username string, password string) bool {
+	return true
+}
+
+//GetUser getting an user model
+func (s *SimpleDAO) GetUser(username string) (model.User, bool) {
+	return model.User{}, false
+}
+
+//AddUser adding a new user
+func (s *SimpleDAO) AddUser(user model.User) error {
+	return errors.New("not implemented yet")
+}
+
+//DeleteUser delete an user
+func (s *SimpleDAO) DeleteUser(username string) error {
+	return errors.New("not implemented yet")
+}
+
+//ChangePWD change the password of a user
+func (s *SimpleDAO) ChangePWD(username string, newpassword string, oldpassword string) error {
+	return errors.New("not implemented yet")
+}
+
+//DropAll drop all data
+func (s *SimpleDAO) DropAll() {
+
+}
+
+//Ping short ping if file system is availble
+func (s *SimpleDAO) Ping() error {
+	return errors.New("not implemented yet")
+}
+
+//Stop this service
+func (s *SimpleDAO) Stop() {
+}

schematic-service-go/dao/storageDao.go

@@ -0,0 +1,54 @@
+package dao
+
+import (
+	"crypto/md5"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/willie68/schematic-service-go/model"
+)
+
+/*
+StorageDao this is the interface which all method implementation of a storage engine has to fulfill
+*/
+type StorageDao interface {
+	AddFile(filename string, reader io.Reader) (string, error)
+	CreateSchematic(schematic model.Schematic) (string, error)
+	GetSchematic(schematicID string) (model.Schematic, error)
+	GetFile(fileid string, stream io.Writer) error
+	GetSchematics(query string, offset int, limit int, owner string) (int64, []model.Schematic, error)
+	DeleteSchematic(schematicID string) error
+	CreateTag(tag string) error
+	GetTags() []string
+	GetTagsCount() int
+	CreateManufacturer(manufacturer string) error
+	GetManufacturers() []string
+	GetManufacturersCount() int
+
+	CheckUser(username string, password string) bool
+	GetUser(username string) (model.User, bool)
+
+	AddUser(user model.User) error
+	DeleteUser(username string) error
+	ChangePWD(username string, newpassword string, oldpassword string) error
+
+	DropAll()
+	Ping() error
+
+	Stop()
+}
+
+var Storage StorageDao
+
+func GetStorage() StorageDao {
+	return Storage
+}
+
+func BuildPasswordHash(password string) string {
+	if !strings.HasPrefix(password, "md5:") {
+		hash := md5.Sum([]byte(password))
+		password = fmt.Sprintf("md5:%x", hash)
+	}
+	return password
+}

schematic-service-go/go.mod

@@ -8,7 +8,7 @@ require (
 	github.com/go-chi/chi v4.0.3+incompatible
 	github.com/go-chi/render v1.0.1
 	github.com/go-delve/delve v1.4.0 // indirect
-	github.com/google/uuid v1.1.1 // indirect
+	github.com/google/uuid v1.1.1
 	github.com/hashicorp/consul v1.7.1 // indirect
 	github.com/hashicorp/consul/api v1.4.0
 	github.com/prometheus/client_golang v1.4.1 // indirect

schematic-service-go/health/health.go

@@ -6,9 +6,11 @@ import (
 	"time"
 
 	"github.com/go-chi/chi"
+	"github.com/willie68/schematic-service-go/dao"
 	"github.com/willie68/schematic-service-go/logging"
 )
 
+// global storage definition
 var myhealthy bool
 var log logging.ServiceLogger
 
@@ -17,13 +19,12 @@ This is the healtchcheck you will have to provide.
 */
 func check() (bool, string) {
 	// TODO implement here your healthcheck.
-	myhealthy = !myhealthy
+	myhealthy = true
 	message := ""
-	if myhealthy {
-		log.Info("healthy")
-	} else {
-		log.Info("not healthy")
-		message = "ungesund"
+	err := dao.GetStorage().Ping()
+	if err != nil {
+		myhealthy = false
+		message = err.Error()
 	}
 	return myhealthy, message
 }

schematic-service-go/model/user.go

@@ -0,0 +1,11 @@
+package model
+
+import "go.mongodb.org/mongo-driver/bson/primitive"
+
+type User struct {
+	ID          primitive.ObjectID `json:"-" bson:"_id,omitempty"`
+	Name        string             `json:"name" bson:"name,omitempty"`
+	Password    string             `json:"password" bson:"password,omitempty"`
+	NewPassword string             `json:"newpassword" bson:"-"`
+	Admin       bool               `json:"admin" bson:"admin,omitempty"`
+}