Dev

.gitignore

@@ -32,4 +32,4 @@ go.work.sum
 .vscode/
 .trae/
 
-./config.json
+*config.json

appControllor/getCharacterMetaData.go

@@ -0,0 +1,29 @@
+package appControllor
+
+import (
+	"net/http"
+
+	sqlOperator "github.com/TrafficLight6/GoAccountHub/sql"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type GetCharacterMetaDataRequestBody struct {
+	Token string `json:"token"`
+}
+
+func GetCharacterMetaData(c *gin.Context) {
+	var body GetCharacterMetaDataRequestBody
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": http.StatusBadRequest, "error": "invalid request"})
+		return
+	}
+	//Get db
+	db := c.Value("db").(*gorm.DB)
+	character, err := sqlOperator.GetCharacterByToken(db, body.Token)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": http.StatusBadRequest, "error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": http.StatusOK, "message": "success", "meta_data": character.MetaData})
+}

appControllor/getUserMetaData.go

@@ -0,0 +1,30 @@
+package appControllor
+
+import (
+	"net/http"
+
+	sqlOperator "github.com/TrafficLight6/GoAccountHub/sql"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type GetUserMetaDataRequestBody struct {
+	Token string `json:"token"`
+}
+
+func GetUserMetaData(c *gin.Context) {
+	var body GetUserMetaDataRequestBody
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": http.StatusBadRequest, "message": "Invalid body"})
+		return
+	}
+	//Get db
+	db := c.Value("db").(*gorm.DB)
+	//Get user by token
+	user, err := sqlOperator.GetUserByToken(db, body.Token)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": http.StatusInternalServerError, "message": "Internal server error"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": http.StatusOK, "message": "Success", "meta_data": user.MetaData})
+}

userControllor/login.go → appControllor/login.go

@@ -1,4 +1,4 @@
-package userControllor
+package appControllor
 
 import (
 	"errors"
@@ -94,12 +94,6 @@ func Login(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"code": http.StatusInternalServerError, "message": "Add token failed"})
 		return
 	}
-	//Set cookie (must be before c.JSON, otherwise headers are already flushed)
-	if body.IsRemember {
-		c.SetCookie("user_token", token, 30*24*60*60, "/", "", false, true)
-	} else {
-		c.SetCookie("user_token", token, 0, "/", "", false, true)
-	}
 	//Return token
 	c.JSON(http.StatusOK, gin.H{"code": http.StatusOK, "message": "Login success", "token": token})
 	return

userControllor/logout.go → appControllor/logout.go

@@ -1,4 +1,4 @@
-package userControllor
+package appControllor
 
 import (
 	"net/http"

cliAction/addApplicationKey.go

@@ -0,0 +1,54 @@
+package action
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/TrafficLight6/GoAccountHub/config"
+	"github.com/TrafficLight6/GoAccountHub/hash"
+	sqlOperator "github.com/TrafficLight6/GoAccountHub/sql"
+	"github.com/TrafficLight6/GoAccountHub/sqlTable"
+	"github.com/urfave/cli/v2"
+)
+
+func AddApplicationKeyAction() *cli.Command {
+	return &cli.Command{
+		Name:  "add-key",
+		Usage: "Add Application Key",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "config",
+				Aliases: []string{"c"},
+				Value:   "./config.json",
+				Usage:   "Config File",
+			},
+			&cli.StringFlag{
+				Name:    "site",
+				Aliases: []string{"s"},
+				Value:   "default",
+				Usage:   "Application Site Site",
+			},
+		},
+		Action: func(c *cli.Context) error {
+			appConfig := config.GetConfig(c.String("config"))
+			db := sqlOperator.ConnectDB(appConfig)
+			defer func() {
+				sqlDB, err := db.DB()
+				if err != nil {
+					fmt.Println("Error when Close DB:", err)
+					return
+				}
+				sqlDB.Close()
+			}()
+			var applicationKey sqlTable.ApplicationKey
+			applicationKey.ApplicationUsingSite = c.String("site")
+			applicationKey.Key = hash.SHA256(c.String("site") + time.Now().String())
+			err := sqlOperator.AddApplicationKey(db, applicationKey)
+			if err != nil {
+				return err
+			}
+			fmt.Println("✅ Add Key Success")
+			return err
+		},
+	}
+}

cliAction/deleteApplicationkey.go

@@ -0,0 +1,49 @@
+package action
+
+import (
+	"fmt"
+
+	"github.com/TrafficLight6/GoAccountHub/config"
+	sqlOperator "github.com/TrafficLight6/GoAccountHub/sql"
+	"github.com/urfave/cli/v2"
+)
+
+func DeleteApplicationKeyAction() *cli.Command {
+	return &cli.Command{
+		Name:  "del-key",
+		Usage: "Delete Application Key",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "config",
+				Aliases: []string{"c"},
+				Value:   "./config.json",
+				Usage:   "Config File",
+			},
+			&cli.StringFlag{
+				Name:    "key",
+				Aliases: []string{"k"},
+				Value:   "default",
+				Usage:   "Application Key",
+			},
+		},
+		Action: func(c *cli.Context) error {
+			appConfig := config.GetConfig(c.String("config"))
+			db := sqlOperator.ConnectDB(appConfig)
+			defer func() {
+				sqlDB, err := db.DB()
+				if err != nil {
+					fmt.Println("Error when Close DB:", err)
+					return
+				}
+				sqlDB.Close()
+			}()
+			key := c.String("key")
+			err := sqlOperator.DeleteApplicationKey(db, key)
+			if err != nil {
+				return err
+			}
+			fmt.Println("✅ Delete Key Success")
+			return err
+		},
+	}
+}

main.go

@@ -17,6 +17,9 @@ func main() {
 			action.EditPasswordAction(),
 			action.GenerateConfigAction(),
 			action.GenerateTestConfigAction(),
+
+			action.AddApplicationKeyAction(),
+			action.DeleteApplicationKeyAction(),
 		},
 	}
 

middleware/applicationKeyCheck.go

@@ -0,0 +1,33 @@
+package middleware
+
+import (
+	"net/http"
+
+	sqlOperator "github.com/TrafficLight6/GoAccountHub/sql"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func ApplicationKeyCheckMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		key, err := c.Cookie("app_key")
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"code":  http.StatusBadRequest,
+				"error": "app_key cookie is required",
+			})
+			c.Abort()
+			return
+		}
+		db := c.Value("db").(*gorm.DB)
+		if !sqlOperator.CheckApplicationKey(db, key) {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"code":  http.StatusBadRequest,
+				"error": "app_key cookie is invalid",
+			})
+			c.Abort()
+			return
+		}
+		c.Next()
+	}
+}

router/router.go

@@ -2,10 +2,10 @@ package router
 
 import (
 	"github.com/TrafficLight6/GoAccountHub/adminControllor"
+	"github.com/TrafficLight6/GoAccountHub/appControllor"
 	"github.com/TrafficLight6/GoAccountHub/config"
 	"github.com/TrafficLight6/GoAccountHub/middleware"
 	sqlOperator "github.com/TrafficLight6/GoAccountHub/sql"
-	"github.com/TrafficLight6/GoAccountHub/userControllor"
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
@@ -62,10 +62,25 @@ func ReturnRouter(config config.Config) (*gin.Engine, *gorm.DB) {
 
 	{
 		//USER ONLY
-		export := v1.Group("/export")
+		app := v1.Group("/app")
 		//Login & Logout
-		export.POST("/user/login", userControllor.Login)
-		export.DELETE("/user/logout", userControllor.Logout)
+		app.POST("/user/login", middleware.ApplicationKeyCheckMiddleware(), appControllor.Login)
+		app.DELETE("/user/logout", middleware.ApplicationKeyCheckMiddleware(), appControllor.Logout)
+		//User Operation
+		app.POST("/user/add", middleware.ApplicationKeyCheckMiddleware(), adminControllor.UserAdd)
+		app.DELETE("/user/delete", middleware.ApplicationKeyCheckMiddleware(), adminControllor.UserDelete)
+		app.PUT("/user/edit", middleware.ApplicationKeyCheckMiddleware(), adminControllor.UserEdit)
+		app.GET("/user/get", middleware.ApplicationKeyCheckMiddleware(), adminControllor.UserGet)
+		app.GET("/user/range", middleware.ApplicationKeyCheckMiddleware(), adminControllor.UserRange)
+		//Character Operation
+		app.POST("/character/add", middleware.ApplicationKeyCheckMiddleware(), adminControllor.CharacterAdd)
+		app.DELETE("/character/delete", middleware.ApplicationKeyCheckMiddleware(), adminControllor.CharacterDelete)
+		app.PUT("/character/edit", middleware.ApplicationKeyCheckMiddleware(), adminControllor.CharacterEdit)
+		app.GET("/character/get", middleware.ApplicationKeyCheckMiddleware(), adminControllor.CharacterGet)
+		app.GET("/character/range", middleware.ApplicationKeyCheckMiddleware(), adminControllor.CharacterRange)
+		//Get Metadata
+		app.GET("/user/get/metadata", appControllor.GetUserMetaData)
+		app.GET("/character/get/metadata", appControllor.GetCharacterMetaData)
 	}
 	return router, db
 }

sql/getCharacterByToken.go

@@ -0,0 +1,18 @@
+package sqlOperator
+
+import (
+	"github.com/TrafficLight6/GoAccountHub/sqlTable"
+	"gorm.io/gorm"
+)
+
+func GetCharacterByToken(db *gorm.DB, token string) (sqlTable.Character, error) {
+	var userLoginToken sqlTable.UserLoginToken
+	if err := db.Where("token = ?", token).First(&userLoginToken).Error; err != nil {
+		return sqlTable.Character{}, err
+	}
+	var character sqlTable.Character
+	if err := db.Where("uu_hash = ? AND user_uu_hash = ?", userLoginToken.CharacterUUHash, userLoginToken.UUHash).First(&character).Error; err != nil {
+		return sqlTable.Character{}, err
+	}
+	return character, nil
+}

sql/getUserByToken.go

@@ -0,0 +1,18 @@
+package sqlOperator
+
+import (
+	"github.com/TrafficLight6/GoAccountHub/sqlTable"
+	"gorm.io/gorm"
+)
+
+func GetUserByToken(db *gorm.DB, token string) (sqlTable.User, error) {
+	var userLoginToken sqlTable.UserLoginToken
+	if err := db.Where("token = ?", token).First(&userLoginToken).Error; err != nil {
+		return sqlTable.User{}, err
+	}
+	var user sqlTable.User
+	if err := db.Where("uu_hash = ?", userLoginToken.UUHash).First(&user).Error; err != nil {
+		return sqlTable.User{}, err
+	}
+	return user, nil
+}

sql/init.go

@@ -17,6 +17,8 @@ var (
 		&sqlTable.UserLoginToken{},
 
 		&sqlTable.Character{},
+
+		&sqlTable.ApplicationKey{},
 	}
 )
 

sql/key.go

@@ -0,0 +1,30 @@
+package sqlOperator
+
+import (
+	"github.com/TrafficLight6/GoAccountHub/sqlTable"
+	"gorm.io/gorm"
+)
+
+func AddApplicationKey(db *gorm.DB, keyRow sqlTable.ApplicationKey) error {
+	return db.Create(&keyRow).Error
+}
+
+func GetApplicationKey(db *gorm.DB, keyRow string) (sqlTable.ApplicationKey, error) {
+	var key sqlTable.ApplicationKey
+	if err := db.Where("key = ?", keyRow).First(&key).Error; err != nil {
+		return key, err
+	}
+	return key, nil
+}
+
+func CheckApplicationKey(db *gorm.DB, keyRow string) bool {
+	var key sqlTable.ApplicationKey
+	if err := db.Where("key = ?", keyRow).First(&key).Error; err != nil {
+		return false
+	}
+	return true
+}
+
+func DeleteApplicationKey(db *gorm.DB, key string) error {
+	return db.Where("key = ?", key).Delete(&sqlTable.ApplicationKey{}).Error
+}

sqlTable/applicationKey.go

@@ -0,0 +1,10 @@
+package sqlTable
+
+import "gorm.io/gorm"
+
+type ApplicationKey struct {
+	gorm.Model
+	ID                   int64  `gorm:"primaryKey"`
+	ApplicationUsingSite string `gorm:"column:application_using_site"`
+	Key                  string `gorm:"column:key"`
+}

todo/target.md

@@ -1,5 +1,4 @@
-# Character & User Model  
-- login  
+# Character & User Model   
 - signup  
 
 # Add Normal User Api