mirror of
https://github.com/absmach/magistrala.git
synced 2026-06-23 04:10:28 +00:00
Dušan Borovčanin
593 lines
14 KiB
Go
593 lines
14 KiB
Go
// Copyright (c) Abstract Machines
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
package cli
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/url"
|
|
"strconv"
|
|
|
|
smqsdk "github.com/absmach/magistrala/pkg/sdk"
|
|
smqusers "github.com/absmach/magistrala/users"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
const (
|
|
token = "token"
|
|
refreshToken = "refreshtoken"
|
|
profile = "profile"
|
|
resetPasswordRequest = "resetpasswordrequest"
|
|
resetPassword = "resetpassword"
|
|
password = "password"
|
|
search = "search"
|
|
username = "username"
|
|
email = "email"
|
|
role = "role"
|
|
|
|
// Usage strings for user operations.
|
|
usageUserCreate = "cli users create <first_name> <last_name> <email> <username> <password> [user_auth_token]"
|
|
usageUserGet = "cli users <user_id|all> get <user_auth_token>"
|
|
usageUserToken = "cli users token <username> <password>"
|
|
usageUserRefreshToken = "cli users refreshtoken <token>"
|
|
usageUserUpdate = "cli users <user_id> update <JSON_string> <user_auth_token>"
|
|
usageUserUpdateTags = "cli users <user_id> update tags <tags> <user_auth_token>"
|
|
usageUserUpdateUsername = "cli users <user_id> update username <username> <user_auth_token>"
|
|
usageUserUpdateEmail = "cli users <user_id> update email <email> <user_auth_token>"
|
|
usageUserUpdateRole = "cli users <user_id> update role <role> <user_auth_token>"
|
|
usageUserUpdateAll = `cli users <user_id> update <JSON_string|tags|username|email|role> [args...]
|
|
Available update options:
|
|
cli users <user_id> update <JSON_string> <user_auth_token>
|
|
cli users <user_id> update tags <tags> <user_auth_token>
|
|
cli users <user_id> update username <username> <user_auth_token>
|
|
cli users <user_id> update email <email> <user_auth_token>
|
|
cli users <user_id> update role <role> <user_auth_token>`
|
|
usageUserProfile = "cli users profile <user_auth_token>"
|
|
usageUserResetPasswordReq = "cli users resetpasswordrequest <email>"
|
|
usageUserResetPassword = "cli users resetpassword <password> <confpass> <password_request_token>"
|
|
usageUserPassword = "cli users password <old_password> <password> <user_auth_token>"
|
|
usageUserEnable = "cli users <user_id> enable <user_auth_token>"
|
|
usageUserDisable = "cli users <user_id> disable <user_auth_token>"
|
|
usageUserDelete = "cli users <user_id> delete <user_auth_token>"
|
|
usageUserSearch = "cli users search <query> <user_auth_token>\nQuery format: username=<value>|firstname=<value>|lastname=<value>|id=<value>[&offset=<value>][&limit=<value>]\nExample: cli users search \"username=john_doe\" <user_auth_token>"
|
|
usageUserSendVerification = "cli users sendverification <user_auth_token>"
|
|
usageUserVerifyEmail = "cli users verifyemail <verification_token>"
|
|
)
|
|
|
|
func NewUsersCmd() *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "users <user_id|all|create|token|refreshtoken|profile|resetpasswordrequest|resetpassword|password|search|sendverification|verifyemail> [operation] [args...]",
|
|
Short: "Users management",
|
|
Long: `Format:
|
|
users <create|token|refreshtoken|profile|resetpasswordrequest|resetpassword|password|search|sendverification|verifyemail> [args...]
|
|
users <user_id|all> <operation> [args...]
|
|
|
|
Operations (require user_id/all): get, update, enable, disable, delete
|
|
|
|
Examples:
|
|
users create <first_name> <last_name> <email> <username> <password> [user_auth_token]
|
|
users token <username> <password>
|
|
users refreshtoken <refresh_token>
|
|
users profile <user_auth_token>
|
|
users resetpasswordrequest <email>
|
|
users resetpassword <password> <confpass> <password_request_token>
|
|
users password <old_password> <new_password> <user_auth_token>
|
|
users search "username=john_doe" <user_auth_token>
|
|
users search "firstname=john&limit=10" <user_auth_token>
|
|
users sendverification <user_auth_token>
|
|
users verifyemail <verification_token>
|
|
users all get <user_auth_token>
|
|
users <user_id> get <user_auth_token>
|
|
users <user_id> update <JSON_string> <user_auth_token>
|
|
users <user_id> update tags <tags> <user_auth_token>
|
|
users <user_id> update username <username> <user_auth_token>
|
|
users <user_id> update email <email> <user_auth_token>
|
|
users <user_id> enable <user_auth_token>
|
|
users <user_id> disable <user_auth_token>
|
|
users <user_id> delete <user_auth_token>`,
|
|
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
if len(args) == 0 {
|
|
logUsageCmd(*cmd, cmd.Use)
|
|
return
|
|
}
|
|
|
|
switch args[0] {
|
|
case create:
|
|
handleUserCreate(cmd, args[1:])
|
|
return
|
|
case sendVerification:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserSendVerification)
|
|
return
|
|
}
|
|
handleSendVerification(cmd, args[1])
|
|
return
|
|
case verifyEmail:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserVerifyEmail)
|
|
return
|
|
}
|
|
handleVerify(cmd, args[1])
|
|
return
|
|
case token:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserToken)
|
|
return
|
|
}
|
|
if len(args) < 3 {
|
|
logUsageCmd(*cmd, usageUserToken)
|
|
return
|
|
}
|
|
handleUserToken(cmd, args[1], args[2:])
|
|
return
|
|
case refreshToken:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserRefreshToken)
|
|
return
|
|
}
|
|
handleUserRefreshToken(cmd, args[1], args[2:])
|
|
return
|
|
case profile:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserProfile)
|
|
return
|
|
}
|
|
handleUserProfile(cmd, args[1], args[2:])
|
|
return
|
|
case resetPasswordRequest:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserResetPasswordReq)
|
|
return
|
|
}
|
|
handleUserResetPasswordRequest(cmd, args[1], args[2:])
|
|
return
|
|
case resetPassword:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserResetPassword)
|
|
return
|
|
}
|
|
if len(args) < 4 {
|
|
logUsageCmd(*cmd, usageUserResetPassword)
|
|
return
|
|
}
|
|
handleUserResetPassword(cmd, args[1], args[2:])
|
|
return
|
|
case password:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserPassword)
|
|
return
|
|
}
|
|
if len(args) < 4 {
|
|
logUsageCmd(*cmd, usageUserPassword)
|
|
return
|
|
}
|
|
handleUserPassword(cmd, args[1], args[2:])
|
|
return
|
|
case search:
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, usageUserSearch)
|
|
return
|
|
}
|
|
if len(args) < 3 {
|
|
logUsageCmd(*cmd, usageUserSearch)
|
|
return
|
|
}
|
|
handleUserSearch(cmd, args[1], args[2:])
|
|
return
|
|
}
|
|
|
|
if len(args) < 2 {
|
|
logUsageCmd(*cmd, "users <user_id|all> <get|update|enable|disable|delete> [args...]")
|
|
return
|
|
}
|
|
|
|
userParams := args[0]
|
|
operation := args[1]
|
|
opArgs := args[2:]
|
|
|
|
switch operation {
|
|
case get:
|
|
handleUserGet(cmd, userParams, opArgs)
|
|
case update:
|
|
handleUserUpdate(cmd, userParams, opArgs)
|
|
case enable:
|
|
handleUserEnable(cmd, userParams, opArgs)
|
|
case disable:
|
|
handleUserDisable(cmd, userParams, opArgs)
|
|
case delete:
|
|
handleUserDelete(cmd, userParams, opArgs)
|
|
default:
|
|
logErrorCmd(*cmd, fmt.Errorf("unknown operation: %s", operation))
|
|
}
|
|
},
|
|
}
|
|
|
|
return cmd
|
|
}
|
|
|
|
func handleUserCreate(cmd *cobra.Command, args []string) {
|
|
if len(args) < 5 || len(args) > 6 {
|
|
logUsageCmd(*cmd, usageUserCreate)
|
|
return
|
|
}
|
|
if len(args) == 5 {
|
|
args = append(args, "")
|
|
}
|
|
|
|
user := smqsdk.User{
|
|
FirstName: args[0],
|
|
LastName: args[1],
|
|
Email: args[2],
|
|
Credentials: smqsdk.Credentials{
|
|
Username: args[3],
|
|
Secret: args[4],
|
|
},
|
|
Status: smqusers.EnabledStatus.String(),
|
|
}
|
|
user, err := sdk.CreateUser(cmd.Context(), user, args[5])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, user)
|
|
}
|
|
|
|
func handleSendVerification(cmd *cobra.Command, token string) {
|
|
if token == "" {
|
|
logUsageCmd(*cmd, usageUserToken)
|
|
return
|
|
}
|
|
|
|
if err := sdk.SendVerification(cmd.Context(), token); err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, "sent verification successfully")
|
|
}
|
|
|
|
func handleVerify(cmd *cobra.Command, token string) {
|
|
if token == "" {
|
|
logUsageCmd(*cmd, usageUserToken)
|
|
return
|
|
}
|
|
|
|
if err := sdk.VerifyEmail(cmd.Context(), token); err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, "verified successfully")
|
|
}
|
|
|
|
func handleUserGet(cmd *cobra.Command, userParams string, args []string) {
|
|
if len(args) != 1 {
|
|
logUsageCmd(*cmd, usageUserGet)
|
|
return
|
|
}
|
|
|
|
if userParams == all {
|
|
metadata, err := convertMetadata(Metadata)
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
pageMetadata := smqsdk.PageMetadata{
|
|
Username: Username,
|
|
Identity: Identity,
|
|
Offset: Offset,
|
|
Limit: Limit,
|
|
Metadata: metadata,
|
|
Status: Status,
|
|
}
|
|
|
|
l, err := sdk.Users(cmd.Context(), pageMetadata, args[0])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
logJSONCmd(*cmd, l)
|
|
return
|
|
}
|
|
|
|
u, err := sdk.User(cmd.Context(), userParams, args[0])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, u)
|
|
}
|
|
|
|
func handleUserUpdate(cmd *cobra.Command, userID string, args []string) {
|
|
if len(args) < 1 {
|
|
logUsageCmd(*cmd, usageUserUpdateAll)
|
|
return
|
|
}
|
|
|
|
if len(args) < 2 || len(args) > 3 {
|
|
if len(args) >= 1 {
|
|
switch args[0] {
|
|
case tags:
|
|
logUsageCmd(*cmd, usageUserUpdateTags)
|
|
return
|
|
case username:
|
|
logUsageCmd(*cmd, usageUserUpdateUsername)
|
|
return
|
|
case email:
|
|
logUsageCmd(*cmd, usageUserUpdateEmail)
|
|
return
|
|
case role:
|
|
logUsageCmd(*cmd, usageUserUpdateRole)
|
|
return
|
|
}
|
|
}
|
|
logUsageCmd(*cmd, usageUserUpdateAll)
|
|
return
|
|
}
|
|
|
|
var user smqsdk.User
|
|
if args[0] == "tags" {
|
|
if len(args) != 3 {
|
|
logUsageCmd(*cmd, usageUserUpdateTags)
|
|
return
|
|
}
|
|
if err := json.Unmarshal([]byte(args[1]), &user.Tags); err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
user.ID = userID
|
|
user, err := sdk.UpdateUserTags(cmd.Context(), user, args[2])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
logJSONCmd(*cmd, user)
|
|
return
|
|
}
|
|
|
|
if args[0] == "email" {
|
|
if len(args) != 3 {
|
|
logUsageCmd(*cmd, usageUserUpdateEmail)
|
|
return
|
|
}
|
|
user.ID = userID
|
|
user.Email = args[1]
|
|
user, err := sdk.UpdateUserEmail(cmd.Context(), user, args[2])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
logJSONCmd(*cmd, user)
|
|
return
|
|
}
|
|
|
|
if args[0] == "username" {
|
|
if len(args) != 3 {
|
|
logUsageCmd(*cmd, usageUserUpdateUsername)
|
|
return
|
|
}
|
|
user.ID = userID
|
|
user.Credentials.Username = args[1]
|
|
user, err := sdk.UpdateUsername(cmd.Context(), user, args[2])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
logJSONCmd(*cmd, user)
|
|
return
|
|
}
|
|
|
|
if args[0] == "role" {
|
|
if len(args) != 3 {
|
|
logUsageCmd(*cmd, usageUserUpdateRole)
|
|
return
|
|
}
|
|
user.ID = userID
|
|
user.Role = args[1]
|
|
user, err := sdk.UpdateUserRole(cmd.Context(), user, args[2])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
logJSONCmd(*cmd, user)
|
|
return
|
|
}
|
|
|
|
if len(args) != 2 {
|
|
logUsageCmd(*cmd, usageUserUpdate)
|
|
return
|
|
}
|
|
|
|
if err := json.Unmarshal([]byte(args[0]), &user); err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
user.ID = userID
|
|
user, err := sdk.UpdateUser(cmd.Context(), user, args[1])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, user)
|
|
}
|
|
|
|
func handleUserEnable(cmd *cobra.Command, userID string, args []string) {
|
|
if len(args) != 1 {
|
|
logUsageCmd(*cmd, usageUserEnable)
|
|
return
|
|
}
|
|
|
|
user, err := sdk.EnableUser(cmd.Context(), userID, args[0])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, user)
|
|
}
|
|
|
|
func handleUserDisable(cmd *cobra.Command, userID string, args []string) {
|
|
if len(args) != 1 {
|
|
logUsageCmd(*cmd, usageUserDisable)
|
|
return
|
|
}
|
|
|
|
user, err := sdk.DisableUser(cmd.Context(), userID, args[0])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, user)
|
|
}
|
|
|
|
func handleUserDelete(cmd *cobra.Command, userID string, args []string) {
|
|
if len(args) != 1 {
|
|
logUsageCmd(*cmd, usageUserDelete)
|
|
return
|
|
}
|
|
|
|
if err := sdk.DeleteUser(cmd.Context(), userID, args[0]); err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
logOKCmd(*cmd)
|
|
}
|
|
|
|
func handleUserToken(cmd *cobra.Command, username string, args []string) {
|
|
if len(args) != 1 {
|
|
logUsageCmd(*cmd, usageUserToken)
|
|
return
|
|
}
|
|
|
|
loginReq := smqsdk.Login{
|
|
Username: username,
|
|
Password: args[0],
|
|
}
|
|
|
|
token, err := sdk.CreateToken(cmd.Context(), loginReq)
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, token)
|
|
}
|
|
|
|
func handleUserRefreshToken(cmd *cobra.Command, refreshToken string, args []string) {
|
|
if len(args) != 0 {
|
|
logUsageCmd(*cmd, usageUserRefreshToken)
|
|
return
|
|
}
|
|
|
|
token, err := sdk.RefreshToken(cmd.Context(), refreshToken)
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, token)
|
|
}
|
|
|
|
func handleUserProfile(cmd *cobra.Command, token string, args []string) {
|
|
if len(args) != 0 {
|
|
logUsageCmd(*cmd, usageUserProfile)
|
|
return
|
|
}
|
|
|
|
user, err := sdk.UserProfile(cmd.Context(), token)
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, user)
|
|
}
|
|
|
|
func handleUserResetPasswordRequest(cmd *cobra.Command, email string, args []string) {
|
|
if len(args) != 0 {
|
|
logUsageCmd(*cmd, usageUserResetPasswordReq)
|
|
return
|
|
}
|
|
|
|
if err := sdk.ResetPasswordRequest(cmd.Context(), email); err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logOKCmd(*cmd)
|
|
}
|
|
|
|
func handleUserResetPassword(cmd *cobra.Command, password string, args []string) {
|
|
if len(args) != 2 {
|
|
logUsageCmd(*cmd, usageUserResetPassword)
|
|
return
|
|
}
|
|
|
|
if err := sdk.ResetPassword(cmd.Context(), password, args[0], args[1]); err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logOKCmd(*cmd)
|
|
}
|
|
|
|
func handleUserPassword(cmd *cobra.Command, oldPassword string, args []string) {
|
|
if len(args) != 2 {
|
|
logUsageCmd(*cmd, usageUserPassword)
|
|
return
|
|
}
|
|
|
|
user, err := sdk.UpdatePassword(cmd.Context(), oldPassword, args[0], args[1])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, user)
|
|
}
|
|
|
|
func handleUserSearch(cmd *cobra.Command, query string, args []string) {
|
|
if len(args) != 1 {
|
|
logUsageCmd(*cmd, usageUserSearch)
|
|
return
|
|
}
|
|
|
|
values, err := url.ParseQuery(query)
|
|
if err != nil {
|
|
logErrorCmd(*cmd, fmt.Errorf("failed to parse query: %s", err))
|
|
return
|
|
}
|
|
|
|
pm := smqsdk.PageMetadata{
|
|
Offset: Offset,
|
|
Limit: Limit,
|
|
ID: values.Get("id"),
|
|
Username: values.Get("username"),
|
|
FirstName: values.Get("firstname"),
|
|
LastName: values.Get("lastname"),
|
|
}
|
|
|
|
if off, err := strconv.Atoi(values.Get("offset")); err == nil {
|
|
pm.Offset = uint64(off)
|
|
}
|
|
|
|
if lim, err := strconv.Atoi(values.Get("limit")); err == nil {
|
|
pm.Limit = uint64(lim)
|
|
}
|
|
|
|
users, err := sdk.SearchUsers(cmd.Context(), pm, args[0])
|
|
if err != nil {
|
|
logErrorCmd(*cmd, err)
|
|
return
|
|
}
|
|
|
|
logJSONCmd(*cmd, users)
|
|
}
|