feat: added modules

core/user/options.go

@@ -0,0 +1,11 @@
+package user
+
+import "github.com/crawlab-team/crawlab/core/interfaces"
+
+type Option func(svc interfaces.UserService)
+
+func WithJwtSecret(secret string) Option {
+	return func(svc interfaces.UserService) {
+		svc.SetJwtSecret(secret)
+	}
+}

core/user/service.go

@@ -0,0 +1,238 @@
+package user
+
+import (
+	mongo2 "github.com/crawlab-team/crawlab-db/mongo"
+	"github.com/crawlab-team/crawlab/core/constants"
+	"github.com/crawlab-team/crawlab/core/container"
+	"github.com/crawlab-team/crawlab/core/errors"
+	"github.com/crawlab-team/crawlab/core/interfaces"
+	"github.com/crawlab-team/crawlab/core/models/delegate"
+	"github.com/crawlab-team/crawlab/core/models/models"
+	"github.com/crawlab-team/crawlab/core/models/service"
+	"github.com/crawlab-team/crawlab/core/utils"
+	"github.com/crawlab-team/go-trace"
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"time"
+)
+
+type Service struct {
+	// settings variables
+	jwtSecret        string
+	jwtSigningMethod jwt.SigningMethod
+
+	// dependencies
+	modelSvc service.ModelService
+}
+
+func (svc *Service) Init() (err error) {
+	_, err = svc.modelSvc.GetUserByUsername(constants.DefaultAdminUsername, nil)
+	if err == nil {
+		return nil
+	}
+	if err.Error() != mongo.ErrNoDocuments.Error() {
+		return err
+	}
+	return svc.Create(&interfaces.UserCreateOptions{
+		Username: constants.DefaultAdminUsername,
+		Password: constants.DefaultAdminPassword,
+		Role:     constants.RoleAdmin,
+	})
+}
+
+func (svc *Service) SetJwtSecret(secret string) {
+	svc.jwtSecret = secret
+}
+
+func (svc *Service) SetJwtSigningMethod(method jwt.SigningMethod) {
+	svc.jwtSigningMethod = method
+}
+
+func (svc *Service) Create(opts *interfaces.UserCreateOptions, args ...interface{}) (err error) {
+	actor := utils.GetUserFromArgs(args...)
+
+	// validate options
+	if opts.Username == "" || opts.Password == "" {
+		return trace.TraceError(errors.ErrorUserMissingRequiredFields)
+	}
+	if len(opts.Password) < 5 {
+		return trace.TraceError(errors.ErrorUserInvalidPassword)
+	}
+
+	// normalize options
+	if opts.Role == "" {
+		opts.Role = constants.RoleNormal
+	}
+
+	// check if user exists
+	if u, err := svc.modelSvc.GetUserByUsername(opts.Username, nil); err == nil && u != nil && !u.Id.IsZero() {
+		return trace.TraceError(errors.ErrorUserAlreadyExists)
+	}
+
+	// transaction
+	return mongo2.RunTransaction(func(ctx mongo.SessionContext) error {
+		// add user
+		u := &models.User{
+			Username: opts.Username,
+			Role:     opts.Role,
+			Email:    opts.Email,
+		}
+		if err := delegate.NewModelDelegate(u, actor).Add(); err != nil {
+			return err
+		}
+
+		// add password
+		p := &models.Password{
+			Id:       u.Id,
+			Password: utils.EncryptMd5(opts.Password),
+		}
+		if err := delegate.NewModelDelegate(p, actor).Add(); err != nil {
+			return err
+		}
+
+		return nil
+	})
+}
+
+func (svc *Service) Login(opts *interfaces.UserLoginOptions) (token string, u interfaces.User, err error) {
+	u, err = svc.modelSvc.GetUserByUsername(opts.Username, nil)
+	if err != nil {
+		return "", nil, err
+	}
+	p, err := svc.modelSvc.GetPasswordById(u.GetId())
+	if err != nil {
+		return "", nil, err
+	}
+	if p.Password != utils.EncryptMd5(opts.Password) {
+		return "", nil, errors.ErrorUserMismatch
+	}
+	token, err = svc.makeToken(u)
+	if err != nil {
+		return "", nil, err
+	}
+	return token, u, nil
+}
+
+func (svc *Service) CheckToken(tokenStr string) (u interfaces.User, err error) {
+	return svc.checkToken(tokenStr)
+}
+
+func (svc *Service) ChangePassword(id primitive.ObjectID, password string, args ...interface{}) (err error) {
+	actor := utils.GetUserFromArgs(args...)
+
+	p, err := svc.modelSvc.GetPasswordById(id)
+	if err != nil {
+		return err
+	}
+	p.Password = utils.EncryptMd5(password)
+	if err := delegate.NewModelDelegate(p, actor).Save(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (svc *Service) MakeToken(user interfaces.User) (tokenStr string, err error) {
+	return svc.makeToken(user)
+}
+
+func (svc *Service) GetCurrentUser(c *gin.Context) (user interfaces.User, err error) {
+	// token string
+	tokenStr := c.GetHeader("Authorization")
+
+	// user
+	u, err := userSvc.CheckToken(tokenStr)
+	if err != nil {
+		return nil, err
+	}
+
+	return u, nil
+}
+
+func (svc *Service) makeToken(user interfaces.User) (tokenStr string, err error) {
+	token := jwt.NewWithClaims(svc.jwtSigningMethod, jwt.MapClaims{
+		"id":       user.GetId(),
+		"username": user.GetUsername(),
+		"nbf":      time.Now().Unix(),
+	})
+	return token.SignedString([]byte(svc.jwtSecret))
+}
+
+func (svc *Service) checkToken(tokenStr string) (user interfaces.User, err error) {
+	token, err := jwt.Parse(tokenStr, svc.getSecretFunc())
+	if err != nil {
+		return
+	}
+
+	claim, ok := token.Claims.(jwt.MapClaims)
+	if !ok {
+		err = errors.ErrorUserInvalidType
+		return
+	}
+
+	if !token.Valid {
+		err = errors.ErrorUserInvalidToken
+		return
+	}
+
+	id, err := primitive.ObjectIDFromHex(claim["id"].(string))
+	if err != nil {
+		return user, err
+	}
+	username := claim["username"].(string)
+	user, err = svc.modelSvc.GetUserById(id)
+	if err != nil {
+		err = errors.ErrorUserNotExists
+		return
+	}
+
+	if username != user.GetUsername() {
+		err = errors.ErrorUserMismatch
+		return
+	}
+
+	return
+}
+
+func (svc *Service) getSecretFunc() jwt.Keyfunc {
+	return func(token *jwt.Token) (interface{}, error) {
+		return []byte(svc.jwtSecret), nil
+	}
+}
+
+func NewUserService() (svc2 interfaces.UserService, err error) {
+	// service
+	svc := &Service{
+		jwtSecret:        "crawlab",
+		jwtSigningMethod: jwt.SigningMethodHS256,
+	}
+
+	// dependency injection
+	if err := container.GetContainer().Invoke(func(modelSvc service.ModelService) {
+		svc.modelSvc = modelSvc
+	}); err != nil {
+		return nil, trace.TraceError(err)
+	}
+
+	// initialize
+	if err := svc.Init(); err != nil {
+		return nil, trace.TraceError(err)
+	}
+
+	return svc, nil
+}
+
+var userSvc interfaces.UserService
+
+func GetUserService() (svc interfaces.UserService, err error) {
+	if userSvc != nil {
+		return userSvc, nil
+	}
+	svc, err = NewUserService()
+	if err != nil {
+		return nil, err
+	}
+	userSvc = svc
+	return svc, nil
+}

core/user/service_v2.go

@@ -0,0 +1,212 @@
+package user
+
+import (
+	mongo2 "github.com/crawlab-team/crawlab-db/mongo"
+	"github.com/crawlab-team/crawlab/core/constants"
+	"github.com/crawlab-team/crawlab/core/errors"
+	"github.com/crawlab-team/crawlab/core/interfaces"
+	"github.com/crawlab-team/crawlab/core/models/models"
+	"github.com/crawlab-team/crawlab/core/models/service"
+	"github.com/crawlab-team/crawlab/core/utils"
+	"github.com/crawlab-team/go-trace"
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"time"
+)
+
+type ServiceV2 struct {
+	jwtSecret        string
+	jwtSigningMethod jwt.SigningMethod
+	modelSvc         *service.ModelServiceV2[models.UserV2]
+}
+
+func (svc *ServiceV2) Init() (err error) {
+	_, err = svc.modelSvc.GetOne(bson.M{"username": constants.DefaultAdminUsername}, nil)
+	if err == nil {
+		return nil
+	}
+	if err.Error() != mongo.ErrNoDocuments.Error() {
+		return err
+	}
+	return svc.Create(
+		constants.DefaultAdminUsername,
+		constants.DefaultAdminPassword,
+		constants.RoleAdmin,
+		"",
+		primitive.NilObjectID,
+	)
+}
+
+func (svc *ServiceV2) SetJwtSecret(secret string) {
+	svc.jwtSecret = secret
+}
+
+func (svc *ServiceV2) SetJwtSigningMethod(method jwt.SigningMethod) {
+	svc.jwtSigningMethod = method
+}
+
+func (svc *ServiceV2) Create(username, password, role, email string, by primitive.ObjectID) (err error) {
+	// validate options
+	if username == "" || password == "" {
+		return trace.TraceError(errors.ErrorUserMissingRequiredFields)
+	}
+	if len(password) < 5 {
+		return trace.TraceError(errors.ErrorUserInvalidPassword)
+	}
+
+	// normalize options
+	if role == "" {
+		role = constants.RoleNormal
+	}
+
+	// check if user exists
+	if u, err := svc.modelSvc.GetOne(bson.M{"username": username}, nil); err == nil && u != nil && !u.Id.IsZero() {
+		return trace.TraceError(errors.ErrorUserAlreadyExists)
+	}
+
+	// transaction
+	return mongo2.RunTransaction(func(ctx mongo.SessionContext) error {
+		// add user
+		u := models.UserV2{
+			Username: username,
+			Role:     role,
+			Password: utils.EncryptMd5(password),
+			Email:    email,
+		}
+		u.SetCreated(by)
+		u.SetUpdated(by)
+		_, err = svc.modelSvc.InsertOne(u)
+
+		return err
+	})
+}
+
+func (svc *ServiceV2) Login(username, password string) (token string, u *models.UserV2, err error) {
+	u, err = svc.modelSvc.GetOne(bson.M{"username": username}, nil)
+	if err != nil {
+		return "", nil, err
+	}
+	if u.Password != utils.EncryptMd5(password) {
+		return "", nil, errors.ErrorUserMismatch
+	}
+	token, err = svc.makeToken(u)
+	if err != nil {
+		return "", nil, err
+	}
+	return token, u, nil
+}
+
+func (svc *ServiceV2) CheckToken(tokenStr string) (u *models.UserV2, err error) {
+	return svc.checkToken(tokenStr)
+}
+
+func (svc *ServiceV2) ChangePassword(id primitive.ObjectID, password string, by primitive.ObjectID) (err error) {
+	u, err := svc.modelSvc.GetById(id)
+	if err != nil {
+		return err
+	}
+	u.Password = utils.EncryptMd5(password)
+	u.SetCreatedBy(by)
+	return svc.modelSvc.ReplaceById(id, *u)
+}
+
+func (svc *ServiceV2) MakeToken(user *models.UserV2) (tokenStr string, err error) {
+	return svc.makeToken(user)
+}
+
+func (svc *ServiceV2) GetCurrentUser(c *gin.Context) (user interfaces.User, err error) {
+	// token string
+	tokenStr := c.GetHeader("Authorization")
+
+	// user
+	u, err := userSvc.CheckToken(tokenStr)
+	if err != nil {
+		return nil, err
+	}
+
+	return u, nil
+}
+
+func (svc *ServiceV2) makeToken(user *models.UserV2) (tokenStr string, err error) {
+	token := jwt.NewWithClaims(svc.jwtSigningMethod, jwt.MapClaims{
+		"id":       user.Id,
+		"username": user.Username,
+		"nbf":      time.Now().Unix(),
+	})
+	return token.SignedString([]byte(svc.jwtSecret))
+}
+
+func (svc *ServiceV2) checkToken(tokenStr string) (user *models.UserV2, err error) {
+	token, err := jwt.Parse(tokenStr, svc.getSecretFunc())
+	if err != nil {
+		return
+	}
+
+	claim, ok := token.Claims.(jwt.MapClaims)
+	if !ok {
+		err = errors.ErrorUserInvalidType
+		return
+	}
+
+	if !token.Valid {
+		err = errors.ErrorUserInvalidToken
+		return
+	}
+
+	id, err := primitive.ObjectIDFromHex(claim["id"].(string))
+	if err != nil {
+		return user, err
+	}
+	username := claim["username"].(string)
+	user, err = svc.modelSvc.GetById(id)
+	if err != nil {
+		err = errors.ErrorUserNotExists
+		return
+	}
+
+	if username != user.Username {
+		err = errors.ErrorUserMismatch
+		return
+	}
+
+	return
+}
+
+func (svc *ServiceV2) getSecretFunc() jwt.Keyfunc {
+	return func(token *jwt.Token) (interface{}, error) {
+		return []byte(svc.jwtSecret), nil
+	}
+}
+
+func NewUserServiceV2() (svc *ServiceV2, err error) {
+	// service
+	svc = &ServiceV2{
+		modelSvc:         service.NewModelServiceV2[models.UserV2](),
+		jwtSecret:        "crawlab",
+		jwtSigningMethod: jwt.SigningMethodHS256,
+	}
+
+	// initialize
+	if err := svc.Init(); err != nil {
+		return nil, trace.TraceError(err)
+	}
+
+	return svc, nil
+}
+
+var userSvcV2 *ServiceV2
+
+func GetUserServiceV2() (svc *ServiceV2, err error) {
+	if userSvcV2 != nil {
+		return userSvcV2, nil
+	}
+	svc, err = NewUserServiceV2()
+	if err != nil {
+		return nil, err
+	}
+	userSvcV2 = svc
+	return svc, nil
+}

core/user/test/base.go

@@ -0,0 +1,65 @@
+package test
+
+import (
+	"github.com/crawlab-team/crawlab/core/interfaces"
+	"github.com/crawlab-team/crawlab/core/models/service"
+	"github.com/crawlab-team/crawlab/core/user"
+	"go.uber.org/dig"
+	"testing"
+)
+
+func init() {
+	var err error
+	T, err = NewTest()
+	if err != nil {
+		panic(err)
+	}
+}
+
+var T *Test
+
+type Test struct {
+	// dependencies
+	modelSvc service.ModelService
+	userSvc  interfaces.UserService
+
+	// test data
+	TestUsername    string
+	TestPassword    string
+	TestNewPassword string
+}
+
+func (t *Test) Setup(t2 *testing.T) {
+	var err error
+	t.userSvc, err = user.NewUserService()
+	if err != nil {
+		panic(err)
+	}
+	t2.Cleanup(t.Cleanup)
+}
+
+func (t *Test) Cleanup() {
+	_ = t.modelSvc.GetBaseService(interfaces.ModelIdUser).DeleteList(nil)
+}
+
+func NewTest() (t *Test, err error) {
+	// test
+	t = &Test{
+		TestUsername:    "test_username",
+		TestPassword:    "test_password",
+		TestNewPassword: "test_new_password",
+	}
+
+	// dependency injection
+	c := dig.New()
+	if err := c.Provide(service.GetService); err != nil {
+		return nil, err
+	}
+	if err := c.Invoke(func(modelSvc service.ModelService) {
+		t.modelSvc = modelSvc
+	}); err != nil {
+		return nil, err
+	}
+
+	return t, nil
+}

core/user/test/user_service_test.go

@@ -0,0 +1,61 @@
+package test
+
+import (
+	"github.com/crawlab-team/crawlab/core/constants"
+	"github.com/crawlab-team/crawlab/core/interfaces"
+	"github.com/crawlab-team/crawlab/core/utils"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestUserService_Init(t *testing.T) {
+	var err error
+	T.Setup(t)
+
+	u, err := T.modelSvc.GetUserByUsernameWithPassword(constants.DefaultAdminUsername, nil)
+	require.Nil(t, err)
+	require.Equal(t, constants.DefaultAdminUsername, u.Username)
+	require.Equal(t, utils.EncryptMd5(constants.DefaultAdminPassword), u.Password)
+}
+
+func TestUserService_Create_Login_CheckToken(t *testing.T) {
+	var err error
+	T.Setup(t)
+
+	err = T.userSvc.Create(&interfaces.UserCreateOptions{
+		Username: T.TestUsername,
+		Password: T.TestPassword,
+	})
+	require.Nil(t, err)
+
+	u, err := T.modelSvc.GetUserByUsernameWithPassword(T.TestUsername, nil)
+	require.Nil(t, err)
+	require.Equal(t, T.TestUsername, u.Username)
+	require.Equal(t, utils.EncryptMd5(T.TestPassword), u.Password)
+
+	token, u2, err := T.userSvc.Login(&interfaces.UserLoginOptions{
+		Username: T.TestUsername,
+		Password: T.TestPassword,
+	})
+	require.Nil(t, err)
+	require.Greater(t, len(token), 10)
+	require.Equal(t, u.Username, u2.GetUsername())
+
+	u3, err := T.userSvc.CheckToken(token)
+	require.Nil(t, err)
+	require.Equal(t, u.Username, u3.GetUsername())
+}
+
+func TestUserService_ChangePassword(t *testing.T) {
+	var err error
+	T.Setup(t)
+
+	u, err := T.modelSvc.GetUserByUsernameWithPassword(constants.DefaultAdminUsername, nil)
+	require.Nil(t, err)
+	err = T.userSvc.ChangePassword(u.Id, T.TestNewPassword)
+	require.Nil(t, err)
+
+	u2, err := T.modelSvc.GetUserByUsernameWithPassword(constants.DefaultAdminUsername, nil)
+	require.Nil(t, err)
+	require.Equal(t, utils.EncryptMd5(T.TestNewPassword), u2.Password)
+}