(#1)

- refactored User service from IceWhaleTech/CasaOS as first modularized service

route/route.go

@@ -0,0 +1,64 @@
+package route
+
+import (
+	"os"
+
+	"github.com/IceWhaleTech/CasaOS-Common/utils/jwt"
+	"github.com/IceWhaleTech/CasaOS-UserService/middleware"
+	v1 "github.com/IceWhaleTech/CasaOS-UserService/route/v1"
+	"github.com/gin-contrib/gzip"
+	"github.com/gin-gonic/gin"
+)
+
+func InitRouter() *gin.Engine {
+	r := gin.Default()
+	r.Use(middleware.Cors())
+	r.Use(middleware.WriteLog())
+	r.Use(gzip.Gzip(gzip.DefaultCompression))
+
+	// check if environment variable is set
+	if ginMode, success := os.LookupEnv("GIN_MODE"); success {
+		gin.SetMode(ginMode)
+	} else {
+		gin.SetMode(gin.ReleaseMode)
+	}
+
+	r.POST("/v1/users/register", v1.PostUserRegister)
+	r.POST("/v1/users/login", v1.PostUserLogin)
+	r.GET("/v1/users/name", v1.GetUserAllUsername) // all/name
+	r.POST("/v1/users/refresh", v1.PostUserRefreshToken)
+	// No short-term modifications
+	r.GET("/v1/users/image", v1.GetUserImage)
+
+	r.GET("/v1/users/status", v1.GetUserStatus) // init/check
+
+	v1Group := r.Group("/v1")
+
+	v1Group.Use(jwt.JWT())
+	{
+		v1UsersGroup := v1Group.Group("/users")
+		v1UsersGroup.Use()
+		{
+			v1UsersGroup.GET("/current", v1.GetUserInfo)
+			v1UsersGroup.PUT("/current", v1.PutUserInfo)
+			v1UsersGroup.PUT("/current/password", v1.PutUserPassword)
+
+			v1UsersGroup.GET("/current/custom/:key", v1.GetUserCustomConf)
+			v1UsersGroup.POST("/current/custom/:key", v1.PostUserCustomConf)
+			v1UsersGroup.DELETE("/current/custom/:key", v1.DeleteUserCustomConf)
+
+			v1UsersGroup.POST("/current/image/:key", v1.PostUserUploadImage)
+			v1UsersGroup.PUT("/current/image/:key", v1.PutUserImage)
+			// v1UserGroup.POST("/file/image/:key", v1.PostUserFileImage)
+			v1UsersGroup.DELETE("/current/image", v1.DeleteUserImage)
+
+			// v1UserGroup.PUT("/avatar", v1.PutUserAvatar)
+			// v1UserGroup.GET("/avatar", v1.GetUserAvatar)
+			v1UsersGroup.DELETE("/:id", v1.DeleteUser)
+			v1UsersGroup.GET("/:username", v1.GetUserInfoByUsername)
+			v1UsersGroup.DELETE("", v1.DeleteUserAll)
+		}
+	}
+
+	return r
+}

route/v1/user.go

@@ -0,0 +1,679 @@
+package v1
+
+import (
+	json2 "encoding/json"
+	"io/ioutil"
+	"net/http"
+	url2 "net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/IceWhaleTech/CasaOS-Common/utils/common_err"
+	"github.com/IceWhaleTech/CasaOS-Common/utils/jwt"
+	"github.com/IceWhaleTech/CasaOS-UserService/model"
+	"github.com/IceWhaleTech/CasaOS-UserService/model/system_model"
+	"github.com/IceWhaleTech/CasaOS-UserService/pkg/config"
+	"github.com/IceWhaleTech/CasaOS-UserService/pkg/utils/encryption"
+	"github.com/IceWhaleTech/CasaOS-UserService/pkg/utils/file"
+	model2 "github.com/IceWhaleTech/CasaOS-UserService/service/model"
+	uuid "github.com/satori/go.uuid"
+	"github.com/tidwall/gjson"
+
+	"github.com/IceWhaleTech/CasaOS-UserService/service"
+	"github.com/gin-gonic/gin"
+)
+
+// @Summary register user
+// @Router /user/register/ [post]
+func PostUserRegister(c *gin.Context) {
+	json := make(map[string]string)
+	c.ShouldBind(&json)
+
+	username := json["username"]
+	pwd := json["password"]
+	key := json["key"]
+	if _, ok := service.UserRegisterHash[key]; !ok {
+		c.JSON(common_err.CLIENT_ERROR,
+			model.Result{Success: common_err.KEY_NOT_EXIST, Message: common_err.GetMsg(common_err.KEY_NOT_EXIST)})
+		return
+	}
+
+	if len(username) == 0 || len(pwd) == 0 {
+		c.JSON(common_err.CLIENT_ERROR,
+			model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	if len(pwd) < 6 {
+		c.JSON(common_err.CLIENT_ERROR,
+			model.Result{Success: common_err.PWD_IS_TOO_SIMPLE, Message: common_err.GetMsg(common_err.PWD_IS_TOO_SIMPLE)})
+		return
+	}
+	oldUser := service.MyService.User().GetUserInfoByUserName(username)
+	if oldUser.Id > 0 {
+		c.JSON(common_err.CLIENT_ERROR,
+			model.Result{Success: common_err.USER_EXIST, Message: common_err.GetMsg(common_err.USER_EXIST)})
+		return
+	}
+
+	user := model2.UserDBModel{}
+	user.Username = username
+	user.Password = encryption.GetMD5ByStr(pwd)
+	user.Role = "admin"
+
+	user = service.MyService.User().CreateUser(user)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR)})
+		return
+	}
+	file.MkDir(config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id))
+	delete(service.UserRegisterHash, key)
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}
+
+// @Summary login
+// @Produce  application/json
+// @Accept application/json
+// @Tags user
+// @Param user_name query string true "User name"
+// @Param pwd  query string true "password"
+// @Success 200 {string} string "ok"
+// @Router /user/login [post]
+func PostUserLogin(c *gin.Context) {
+	json := make(map[string]string)
+	c.ShouldBind(&json)
+
+	username := json["username"]
+
+	password := json["password"]
+	// check params is empty
+	if len(username) == 0 || len(password) == 0 {
+		c.JSON(common_err.CLIENT_ERROR,
+			model.Result{
+				Success: common_err.CLIENT_ERROR,
+				Message: common_err.GetMsg(common_err.INVALID_PARAMS),
+			})
+		return
+	}
+	user := service.MyService.User().GetUserAllInfoByName(username)
+	if user.Id == 0 {
+		c.JSON(common_err.CLIENT_ERROR,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	if user.Password != encryption.GetMD5ByStr(password) {
+		c.JSON(common_err.CLIENT_ERROR,
+			model.Result{Success: common_err.PWD_INVALID, Message: common_err.GetMsg(common_err.PWD_INVALID)})
+		return
+	}
+	token := system_model.VerifyInformation{}
+	token.AccessToken = jwt.GetAccessToken(user.Username, user.Password, user.Id)
+	token.RefreshToken = jwt.GetRefreshToken(user.Username, user.Password, user.Id)
+	token.ExpiresAt = time.Now().Add(3 * time.Hour * time.Duration(1)).Unix()
+	data := make(map[string]interface{}, 2)
+	user.Password = ""
+	data["token"] = token
+
+	// TODO:1 Database fields cannot be external
+	data["user"] = user
+
+	c.JSON(common_err.SUCCESS,
+		model.Result{
+			Success: common_err.SUCCESS,
+			Message: common_err.GetMsg(common_err.SUCCESS),
+			Data:    data,
+		})
+}
+
+// @Summary edit user head
+// @Produce  application/json
+// @Accept multipart/form-data
+// @Tags user
+// @Param file formData file true "用户头像"
+// @Security ApiKeyAuth
+// @Success 200 {string} string "ok"
+// @Router /user/avatar [put]
+func PutUserAvatar(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	user := service.MyService.User().GetUserInfoById(id)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	f, err := c.FormFile("file")
+	if err != nil {
+		c.JSON(common_err.CLIENT_ERROR,
+			model.Result{Success: common_err.CLIENT_ERROR, Message: common_err.GetMsg(common_err.CLIENT_ERROR), Data: err.Error()})
+		return
+	}
+	if len(user.Avatar) > 0 {
+		os.RemoveAll(config.AppInfo.UserDataPath + "/" + id + "/" + user.Avatar)
+	}
+	ext := filepath.Ext(f.Filename)
+	avatarPath := config.AppInfo.UserDataPath + "/" + id + "/avatar" + ext
+	c.SaveUploadedFile(f, avatarPath)
+	user.Avatar = avatarPath
+	service.MyService.User().UpdateUser(user)
+	c.JSON(http.StatusOK,
+		model.Result{
+			Success: common_err.SUCCESS,
+			Message: common_err.GetMsg(common_err.SUCCESS),
+			Data:    user,
+		})
+}
+
+// @Summary edit user name
+// @Produce  application/json
+// @Accept application/json
+// @Tags user
+// @Param old_name  query string true "Old user name"
+// @Security ApiKeyAuth
+// @Success 200 {string} string "ok"
+// @Router /user/name/:id [put]
+func PutUserInfo(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	json := model2.UserDBModel{}
+	c.ShouldBind(&json)
+	user := service.MyService.User().GetUserInfoById(id)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	if len(json.Username) > 0 {
+		u := service.MyService.User().GetUserInfoByUserName(json.Username)
+		if u.Id > 0 {
+			c.JSON(common_err.CLIENT_ERROR,
+				model.Result{Success: common_err.USER_EXIST, Message: common_err.GetMsg(common_err.USER_EXIST)})
+			return
+		}
+	}
+
+	if len(json.Email) == 0 {
+		json.Email = user.Email
+	}
+	if len(json.Avatar) == 0 {
+		json.Avatar = user.Avatar
+	}
+	if len(json.Role) == 0 {
+		json.Role = user.Role
+	}
+	if len(json.Description) == 0 {
+		json.Description = user.Description
+	}
+	if len(json.Nickname) == 0 {
+		json.Nickname = user.Nickname
+	}
+	service.MyService.User().UpdateUser(json)
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: json})
+}
+
+// @Summary edit user password
+// @Produce  application/json
+// @Accept application/json
+// @Tags user
+// @Security ApiKeyAuth
+// @Success 200 {string} string "ok"
+// @Router /user/password/:id [put]
+func PutUserPassword(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	json := make(map[string]string)
+	c.ShouldBind(&json)
+	oldPwd := json["old_password"]
+	pwd := json["password"]
+	if len(oldPwd) == 0 || len(pwd) == 0 {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	user := service.MyService.User().GetUserAllInfoById(id)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	if user.Password != encryption.GetMD5ByStr(oldPwd) {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.PWD_INVALID_OLD, Message: common_err.GetMsg(common_err.PWD_INVALID_OLD)})
+		return
+	}
+	user.Password = encryption.GetMD5ByStr(pwd)
+	service.MyService.User().UpdateUserPassword(user)
+	user.Password = ""
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: user})
+}
+
+// @Summary edit user nick
+// @Produce  application/json
+// @Accept application/json
+// @Tags user
+// @Param nick_name query string false "nick name"
+// @Security ApiKeyAuth
+// @Success 200 {string} string "ok"
+// @Router /user/nick [put]
+func PutUserNick(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	json := make(map[string]string)
+	c.ShouldBind(&json)
+	Nickname := json["nick_name"]
+	if len(Nickname) == 0 {
+		c.JSON(http.StatusOK, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	user := service.MyService.User().GetUserInfoById(id)
+	if user.Id == 0 {
+		c.JSON(http.StatusOK,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	user.Nickname = Nickname
+	service.MyService.User().UpdateUser(user)
+	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: user})
+}
+
+// @Summary edit user description
+// @Produce  application/json
+// @Accept multipart/form-data
+// @Tags user
+// @Param description formData string false "Description"
+// @Security ApiKeyAuth
+// @Success 200 {string} string "ok"
+// @Router /user/desc [put]
+func PutUserDesc(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	json := make(map[string]string)
+	c.ShouldBind(&json)
+	desc := json["description"]
+	if len(desc) == 0 {
+		c.JSON(http.StatusOK, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	user := service.MyService.User().GetUserInfoById(id)
+	if user.Id == 0 {
+		c.JSON(http.StatusOK,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	user.Description = desc
+
+	service.MyService.User().UpdateUser(user)
+
+	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: user})
+}
+
+// @Summary get user info
+// @Produce  application/json
+// @Accept  application/json
+// @Tags user
+// @Success 200 {string} string "ok"
+// @Router /user/info/:id [get]
+func GetUserInfo(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	user := service.MyService.User().GetUserInfoById(id)
+
+	c.JSON(common_err.SUCCESS,
+		model.Result{
+			Success: common_err.SUCCESS,
+			Message: common_err.GetMsg(common_err.SUCCESS),
+			Data:    user,
+		})
+}
+
+/**
+ * @description:
+ * @param {*gin.Context} c
+ * @param {string} Username
+ * @return {*}
+ * @method:
+ * @router:
+ */
+func GetUserInfoByUsername(c *gin.Context) {
+	username := c.Param("username")
+	if len(username) == 0 {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	user := service.MyService.User().GetUserInfoByUserName(username)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+
+	c.JSON(common_err.SUCCESS,
+		model.Result{
+			Success: common_err.SUCCESS,
+			Message: common_err.GetMsg(common_err.SUCCESS),
+			Data:    user,
+		})
+}
+
+/**
+ * @description: get all Usernames
+ * @method:GET
+ * @router:/user/all/name
+ */
+func GetUserAllUsername(c *gin.Context) {
+	users := service.MyService.User().GetAllUserName()
+	names := []string{}
+	for _, v := range users {
+		names = append(names, v.Username)
+	}
+	c.JSON(common_err.SUCCESS,
+		model.Result{
+			Success: common_err.SUCCESS,
+			Message: common_err.GetMsg(common_err.SUCCESS),
+			Data:    names,
+		})
+}
+
+/**
+ * @description:get custom file by user
+ * @param {path} name string "file name"
+ * @method: GET
+ * @router: /user/custom/:key
+ */
+func GetUserCustomConf(c *gin.Context) {
+	name := c.Param("key")
+	if len(name) == 0 {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	id := c.GetHeader("user_id")
+
+	user := service.MyService.User().GetUserInfoById(id)
+	//	user := service.MyService.User().GetUserInfoByUsername(Username)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	filePath := config.AppInfo.UserDataPath + "/" + id + "/" + name + ".json"
+
+	data := file.ReadFullFile(filePath)
+	if !gjson.ValidBytes(data) {
+		c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: string(data)})
+		return
+	}
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: json2.RawMessage(string(data))})
+}
+
+/**
+ * @description:create or update custom conf by user
+ * @param {path} name string "file name"
+ * @method:POST
+ * @router:/user/custom/:key
+ */
+func PostUserCustomConf(c *gin.Context) {
+	name := c.Param("key")
+	if len(name) == 0 {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	id := c.GetHeader("user_id")
+	user := service.MyService.User().GetUserInfoById(id)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	data, _ := ioutil.ReadAll(c.Request.Body)
+	filePath := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id)
+
+	file.WriteToPath(data, filePath, name+".json")
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: json2.RawMessage(string(data))})
+}
+
+/**
+ * @description: delete user custom config
+ * @param {path} key string
+ * @method:delete
+ * @router:/user/custom/:key
+ */
+func DeleteUserCustomConf(c *gin.Context) {
+	name := c.Param("key")
+	if len(name) == 0 {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	id := c.GetHeader("user_id")
+	user := service.MyService.User().GetUserInfoById(id)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR,
+			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	filePath := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id) + "/" + name + ".json"
+	err := os.Remove(filePath)
+	if err != nil {
+		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR)})
+		return
+	}
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}
+
+/**
+ * @description:
+ * @param {path} id string "user id"
+ * @method:DELETE
+ * @router:/user/delete/:id
+ */
+func DeleteUser(c *gin.Context) {
+	id := c.Param("id")
+	service.MyService.User().DeleteUserById(id)
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: id})
+}
+
+/**
+ * @description:update user image
+ * @method:POST
+ * @router:/user/current/image/:key
+ */
+func PutUserImage(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	json := make(map[string]string)
+	c.ShouldBind(&json)
+
+	path := json["path"]
+	key := c.Param("key")
+	if len(path) == 0 || len(key) == 0 {
+		c.JSON(http.StatusOK, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	if !file.Exists(path) {
+		c.JSON(http.StatusOK, model.Result{Success: common_err.FILE_DOES_NOT_EXIST, Message: common_err.GetMsg(common_err.FILE_DOES_NOT_EXIST)})
+		return
+	}
+
+	_, err := file.GetImageExt(path)
+	if err != nil {
+		c.JSON(http.StatusOK, model.Result{Success: common_err.NOT_IMAGE, Message: common_err.GetMsg(common_err.NOT_IMAGE)})
+		return
+	}
+
+	user := service.MyService.User().GetUserInfoById(id)
+	if user.Id == 0 {
+		c.JSON(http.StatusOK, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	fstat, _ := os.Stat(path)
+	if fstat.Size() > 10<<20 {
+		c.JSON(http.StatusOK, model.Result{Success: common_err.IMAGE_TOO_LARGE, Message: common_err.GetMsg(common_err.IMAGE_TOO_LARGE)})
+		return
+	}
+	ext := file.GetExt(path)
+	filePath := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id) + "/" + key + ext
+	file.CopySingleFile(path, filePath, "overwrite")
+
+	data := make(map[string]string, 3)
+	data["path"] = filePath
+	data["file_name"] = key + ext
+	data["online_path"] = "/v1/users/image?path=" + filePath
+	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
+}
+
+/**
+* @description:
+* @param {*gin.Context} c
+* @param {file} file
+* @param {string} key
+* @param {string} type:avatar,background
+* @return {*}
+* @method:
+* @router:
+ */
+func PostUserUploadImage(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	f, err := c.FormFile("file")
+	key := c.Param("key")
+	t := c.PostForm("type")
+	if len(key) == 0 {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	if err != nil {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.CLIENT_ERROR, Message: common_err.GetMsg(common_err.CLIENT_ERROR), Data: err.Error()})
+		return
+	}
+
+	_, err = file.GetImageExtByName(f.Filename)
+	if err != nil {
+		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.NOT_IMAGE, Message: common_err.GetMsg(common_err.NOT_IMAGE)})
+		return
+	}
+	ext := filepath.Ext(f.Filename)
+	user := service.MyService.User().GetUserInfoById(id)
+
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	if t == "avatar" {
+		key = "avatar"
+	}
+	path := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id) + "/" + key + ext
+
+	c.SaveUploadedFile(f, path)
+	data := make(map[string]string, 3)
+	data["path"] = path
+	data["file_name"] = key + ext
+	data["online_path"] = "/v1/users/image?path=" + path
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
+}
+
+/**
+ * @description: get current user's image
+ * @method:GET
+ * @router:/user/image/:id
+ */
+func GetUserImage(c *gin.Context) {
+	filePath := c.Query("path")
+	if len(filePath) == 0 {
+		c.JSON(http.StatusNotFound, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	if !file.Exists(filePath) {
+		c.JSON(http.StatusNotFound, model.Result{Success: common_err.FILE_DOES_NOT_EXIST, Message: common_err.GetMsg(common_err.FILE_DOES_NOT_EXIST)})
+		return
+	}
+	if !strings.Contains(filePath, config.AppInfo.UserDataPath) {
+		c.JSON(http.StatusNotFound, model.Result{Success: common_err.INSUFFICIENT_PERMISSIONS, Message: common_err.GetMsg(common_err.INSUFFICIENT_PERMISSIONS)})
+		return
+	}
+
+	fileTmp, _ := os.Open(filePath)
+	defer fileTmp.Close()
+
+	fileName := path.Base(filePath)
+
+	// @tiger - RESTful 规范下不应该返回文件本身内容，而是返回文件的静态URL，由前端去解析
+	c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url2.PathEscape(fileName))
+	c.File(filePath)
+}
+
+func DeleteUserImage(c *gin.Context) {
+	id := c.GetHeader("user_id")
+	path := c.Query("path")
+	if len(path) == 0 {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	user := service.MyService.User().GetUserInfoById(id)
+	if user.Id == 0 {
+		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
+		return
+	}
+	if !file.Exists(path) {
+		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.FILE_DOES_NOT_EXIST, Message: common_err.GetMsg(common_err.FILE_DOES_NOT_EXIST)})
+		return
+	}
+	if !strings.Contains(path, config.AppInfo.UserDataPath+"/"+strconv.Itoa(user.Id)) {
+		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.INSUFFICIENT_PERMISSIONS, Message: common_err.GetMsg(common_err.INSUFFICIENT_PERMISSIONS)})
+		return
+	}
+	os.Remove(path)
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}
+
+/**
+ * @description:
+ * @param {*gin.Context} c
+ * @param {string} refresh_token
+ * @return {*}
+ * @method:
+ * @router:
+ */
+func PostUserRefreshToken(c *gin.Context) {
+	js := make(map[string]string)
+	c.ShouldBind(&js)
+	refresh := js["refresh_token"]
+	claims, err := jwt.ParseToken(refresh, true)
+	if err != nil {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.VERIFICATION_FAILURE, Message: common_err.GetMsg(common_err.VERIFICATION_FAILURE), Data: err.Error()})
+		return
+	}
+	if !claims.VerifyExpiresAt(time.Now(), true) || !claims.VerifyIssuer("refresh", true) {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.VERIFICATION_FAILURE, Message: common_err.GetMsg(common_err.VERIFICATION_FAILURE)})
+		return
+	}
+	newToken := jwt.GetAccessToken(claims.Username, claims.Password, claims.ID)
+	verifyInfo := system_model.VerifyInformation{}
+	verifyInfo.AccessToken = newToken
+	verifyInfo.RefreshToken = jwt.GetRefreshToken(claims.Username, claims.Password, claims.ID)
+	verifyInfo.ExpiresAt = time.Now().Add(3 * time.Hour * time.Duration(1)).Unix()
+
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: verifyInfo})
+}
+
+func DeleteUserAll(c *gin.Context) {
+	service.MyService.User().DeleteAllUser()
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}
+
+// @Summary 检查是否进入引导状态
+// @Produce  application/json
+// @Accept application/json
+// @Tags sys
+// @Security ApiKeyAuth
+// @Success 200 {string} string "ok"
+// @Router /sys/init/check [get]
+func GetUserStatus(c *gin.Context) {
+	data := make(map[string]interface{}, 2)
+
+	if service.MyService.User().GetUserCount() > 0 {
+		data["initialized"] = true
+		data["key"] = ""
+	} else {
+		key := uuid.NewV4().String()
+		service.UserRegisterHash[key] = key
+		data["key"] = key
+		data["initialized"] = false
+	}
+	c.JSON(common_err.SUCCESS,
+		model.Result{
+			Success: common_err.SUCCESS,
+			Message: common_err.GetMsg(common_err.SUCCESS),
+			Data:    data,
+		})
+}