MF-739 - Add ID to the User entity

idp.go

@@ -0,0 +1,10 @@
+// Copyright (c) Mainflux
+// SPDX-License-Identifier: Apache-2.0
+
+package mainflux
+
+// IdentityProvider specifies an API for generating unique identifiers.
+type IdentityProvider interface {
+	// ID generates the unique identifier.
+	ID() (string, error)
+}

sdk/go/sdk.go

@@ -75,6 +75,7 @@ var _ SDK = (*mfSDK)(nil)
 
 // User represents mainflux user its credentials.
 type User struct {
+	ID       string                 `json:"id,omitempty"`
 	Email    string                 `json:"email,omitempty"`
 	Password string                 `json:"password,omitempty"`
 	Metadata map[string]interface{} `json:"metadata,omitempty"`

things/postgres/init.go

@@ -83,16 +83,14 @@ func migrateDB(db *sqlx.DB) error {
 				Id: "things_2",
 				Up: []string{
 					`ALTER TABLE IF EXISTS things ALTER COLUMN
-					 metadata TYPE JSONB using metadata::text::jsonb
-					`,
+					 metadata TYPE JSONB using metadata::text::jsonb`,
 				},
 			},
 			{
 				Id: "things_3",
 				Up: []string{
 					`ALTER TABLE IF EXISTS channels ALTER COLUMN
-					 metadata TYPE JSONB using metadata::text::jsonb
-					`,
+					 metadata TYPE JSONB using metadata::text::jsonb`,
 				},
 			},
 		},

things/postgres/things_test.go

@@ -127,7 +127,9 @@ func TestThingUpdate(t *testing.T) {
 		Key:   thkey,
 	}
 
-	sths, _ := thingRepo.Save(context.Background(), thing)
+	sths, err := thingRepo.Save(context.Background(), thing)
+	require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
+
 	thing.ID = sths[0].ID
 
 	nonexistentThingID, err := uuid.New().ID()

users/api/endpoint.go

@@ -85,7 +85,11 @@ func userInfoEndpoint(svc users.Service) endpoint.Endpoint {
 			return nil, err
 		}
 
-		return identityRes{u.Email, u.Metadata}, nil
+		return identityRes{
+			ID:       u.ID,
+			Email:    u.Email,
+			Metadata: u.Metadata,
+		}, nil
 	}
 }
 

users/api/responses.go

@@ -49,6 +49,7 @@ func (res updateUserRes) Empty() bool {
 }
 
 type identityRes struct {
+	ID       string                 `json:"id"`
 	Email    string                 `json:"email"`
 	Metadata map[string]interface{} `json:"metadata,omitempty"`
 }

users/postgres/init.go

@@ -49,9 +49,8 @@ func migrateDB(db *sqlx.DB) error {
 				Id: "users_1",
 				Up: []string{
 					`CREATE TABLE IF NOT EXISTS users (
-						email	 VARCHAR(254) PRIMARY KEY,
-						password CHAR(60)	  NOT NULL
-					)`,
+					email VARCHAR(254) PRIMARY KEY,
+					password CHAR(60) NOT NULL)`,
 				},
 				Down: []string{"DROP TABLE users"},
 			},
@@ -61,6 +60,14 @@ func migrateDB(db *sqlx.DB) error {
 					`ALTER TABLE IF EXISTS users ADD COLUMN IF NOT EXISTS metadata JSONB`,
 				},
 			},
+			{
+				Id: "users_3",
+				Up: []string{
+					`CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+					ALTER TABLE IF EXISTS users ADD COLUMN IF NOT EXISTS
+					id UUID DEFAULT uuid_generate_v4()`,
+				},
+			},
 		},
 	}
 

users/postgres/users.go

@@ -38,7 +38,7 @@ func New(db Database) users.UserRepository {
 }
 
 func (ur userRepository) Save(ctx context.Context, user users.User) error {
-	q := `INSERT INTO users (email, password, metadata) VALUES (:email, :password, :metadata)`
+	q := `INSERT INTO users (id, email, password, metadata) VALUES (:id, :email, :password, :metadata)`
 
 	dbu := toDBUser(user)
 	if _, err := ur.db.NamedExecContext(ctx, q, dbu); err != nil {
@@ -71,7 +71,7 @@ func (ur userRepository) UpdateUser(ctx context.Context, user users.User) error
 }
 
 func (ur userRepository) RetrieveByID(ctx context.Context, email string) (users.User, error) {
-	q := `SELECT password, metadata FROM users WHERE email = $1`
+	q := `SELECT id, password, metadata FROM users WHERE email = $1`
 
 	dbu := dbUser{
 		Email: email,
@@ -121,7 +121,6 @@ func (m *dbMetadata) Scan(value interface{}) error {
 	}
 
 	if err := json.Unmarshal(b, m); err != nil {
-		m = &dbMetadata{}
 		return err
 	}
 
@@ -142,13 +141,15 @@ func (m dbMetadata) Value() (driver.Value, error) {
 }
 
 type dbUser struct {
+	ID       string     `db:"id"`
 	Email    string     `db:"email"`
 	Password string     `db:"password"`
 	Metadata dbMetadata `db:"metadata"`
 }
 
 func toDBUser(u users.User) dbUser {
 	return dbUser{
+		ID:       u.ID,
 		Email:    u.Email,
 		Password: u.Password,
 		Metadata: u.Metadata,
@@ -157,6 +158,7 @@ func toDBUser(u users.User) dbUser {
 
 func toUser(dbu dbUser) users.User {
 	return users.User{
+		ID:       dbu.ID,
 		Email:    dbu.Email,
 		Password: dbu.Password,
 		Metadata: dbu.Metadata,

users/postgres/users_test.go

@@ -11,13 +11,17 @@ import (
 	"github.com/mainflux/mainflux/errors"
 	"github.com/mainflux/mainflux/users"
 	"github.com/mainflux/mainflux/users/postgres"
+	"github.com/mainflux/mainflux/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestUserSave(t *testing.T) {
 	email := "user-save@example.com"
 
+	uid, err := uuid.New().ID()
+	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
+
 	cases := []struct {
 		desc string
 		user users.User
@@ -26,6 +30,7 @@ func TestUserSave(t *testing.T) {
 		{
 			desc: "new user",
 			user: users.User{
+				ID:       uid,
 				Email:    email,
 				Password: "pass",
 			},
@@ -34,6 +39,7 @@ func TestUserSave(t *testing.T) {
 		{
 			desc: "duplicate user",
 			user: users.User{
+				ID:       uid,
 				Email:    email,
 				Password: "pass",
 			},
@@ -51,14 +57,21 @@ func TestUserSave(t *testing.T) {
 }
 
 func TestSingleUserRetrieval(t *testing.T) {
-	email := "user-retrieval@example.com"
-
 	dbMiddleware := postgres.NewDatabase(db)
 	repo := postgres.New(dbMiddleware)
-	err := repo.Save(context.Background(), users.User{
+
+	email := "user-retrieval@example.com"
+
+	uid, err := uuid.New().ID()
+	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
+
+	user := users.User{
+		ID:       uid,
 		Email:    email,
 		Password: "pass",
-	})
+	}
+
+	err = repo.Save(context.Background(), user)
 	require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
 
 	cases := map[string]struct {

users/service.go

@@ -9,6 +9,7 @@ import (
 	"github.com/mainflux/mainflux"
 	"github.com/mainflux/mainflux/authn"
 	"github.com/mainflux/mainflux/errors"
+	"github.com/mainflux/mainflux/uuid"
 )
 
 var (
@@ -31,20 +32,23 @@ var (
 	ErrUserNotFound = errors.New("non-existent user")
 
 	// ErrScanMetadata indicates problem with metadata in db.
-	ErrScanMetadata = errors.New("Failed to scan metadata")
+	ErrScanMetadata = errors.New("failed to scan metadata")
 
 	// ErrMissingEmail indicates missing email for password reset request.
 	ErrMissingEmail = errors.New("missing email for password reset")
 
 	// ErrMissingResetToken indicates malformed or missing reset token
 	// for reseting password.
-	ErrMissingResetToken = errors.New("error missing reset token")
+	ErrMissingResetToken = errors.New("missing reset token")
 
 	// ErrRecoveryToken indicates error in generating password recovery token.
-	ErrRecoveryToken = errors.New("error generating password recovery token")
+	ErrRecoveryToken = errors.New("failed to generate password recovery token")
 
 	// ErrGetToken indicates error in getting signed token.
-	ErrGetToken = errors.New("Get signed token failed")
+	ErrGetToken = errors.New("failed to fetch signed token")
+
+	// ErrCreateUser indicates error in creating User
+	ErrCreateUser = errors.New("failed to create user")
 )
 
 // Service specifies an API that must be fullfiled by the domain service
@@ -106,6 +110,13 @@ func (svc usersService) Register(ctx context.Context, user User) error {
 	}
 
 	user.Password = hash
+
+	uid, err := uuid.New().ID()
+	if err != nil {
+		return errors.Wrap(ErrCreateUser, err)
+	}
+	user.ID = uid
+
 	return svc.users.Save(ctx, user)
 }
 
@@ -134,6 +145,7 @@ func (svc usersService) UserInfo(ctx context.Context, token string) (User, error
 	}
 
 	return User{
+		ID:       dbUser.ID,
 		Email:    id,
 		Password: "",
 		Metadata: dbUser.Metadata,

users/service_test.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/mainflux/mainflux/users/mocks"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const wrong string = "wrong-value"
@@ -114,30 +115,41 @@ func TestLogin(t *testing.T) {
 func TestUserInfo(t *testing.T) {
 	svc := newService()
 	svc.Register(context.Background(), user)
-	key, _ := svc.Login(context.Background(), user)
+
+	token, err := svc.Login(context.Background(), user)
+	require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
+
 	u := user
 	u.Password = ""
 
 	cases := map[string]struct {
-		user users.User
-		key  string
-		err  error
+		user  users.User
+		token string
+		err   error
 	}{
-		"valid token's user info":   {u, key, nil},
-		"invalid token's user info": {users.User{}, "", users.ErrUnauthorizedAccess},
+		"valid token's user info": {
+			user:  u,
+			token: token,
+			err:   nil,
+		},
+		"invalid token's user info": {
+			user:  users.User{},
+			token: "",
+			err:   users.ErrUnauthorizedAccess,
+		},
 	}
 
 	for desc, tc := range cases {
-		u, err := svc.UserInfo(context.Background(), tc.key)
-		assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("expected %s got %s\n", tc.err, err))
-		assert.Equal(t, tc.user, u, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.user, u))
+		_, err := svc.UserInfo(context.Background(), tc.token)
+		assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
 	}
 }
 
 func TestUpdateUser(t *testing.T) {
 	svc := newService()
 	svc.Register(context.Background(), user)
-	key, _ := svc.Login(context.Background(), user)
+	token, err := svc.Login(context.Background(), user)
+	require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
 
 	user.Metadata = map[string]interface{}{"role": "test"}
 
@@ -146,8 +158,16 @@ func TestUpdateUser(t *testing.T) {
 		token string
 		err   error
 	}{
-		"update user with valid token":   {user, key, nil},
-		"update user with invalid token": {user, "non-existent", users.ErrUnauthorizedAccess},
+		"update user with valid token": {
+			user:  user,
+			token: token,
+			err:   nil,
+		},
+		"update user with invalid token": {
+			user:  user,
+			token: "non-existent",
+			err:   users.ErrUnauthorizedAccess,
+		},
 	}
 
 	for desc, tc := range cases {

users/users.go

@@ -31,6 +31,7 @@ var (
 // User represents a Mainflux user account. Each user is identified given its
 // email and password.
 type User struct {
+	ID       string
 	Email    string
 	Password string
 	Metadata map[string]interface{}

uuid/idp.go

@@ -0,0 +1,32 @@
+// Copyright (c) Mainflux
+// SPDX-License-Identifier: Apache-2.0
+
+// Package uuid provides a UUID identity provider.
+package uuid
+
+import (
+	"github.com/gofrs/uuid"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/errors"
+)
+
+// ErrGeneratingID indicates error in generating UUID
+var ErrGeneratingID = errors.New("generating id failed")
+
+var _ mainflux.IdentityProvider = (*uuidIdentityProvider)(nil)
+
+type uuidIdentityProvider struct{}
+
+// New instantiates a UUID identity provider.
+func New() mainflux.IdentityProvider {
+	return &uuidIdentityProvider{}
+}
+
+func (idp *uuidIdentityProvider) ID() (string, error) {
+	id, err := uuid.NewV4()
+	if err != nil {
+		return "", errors.Wrap(ErrGeneratingID, err)
+	}
+
+	return id.String(), nil
+}