Merge branch 'feature/manage-user' into 'develop'

models/manager.go

+package models
+
+import (
+	"bwallet/pkg/setting"
+	"github.com/jinzhu/gorm"
+	"time"
+)
+
+type Manager struct {
+	Uid           int32  `gorm:"type:int(11);primary key" json:"uid,omitempty"`
+	Username      string `gorm:"type:varchar(32);unique;not null" json:"username,omitempty"`
+	Password      string `gorm:"type:varchar(32);not null" json:"password,omitempty"`
+	Salt          string `gorm:"type:varchar(64);not null" json:"salt,omitempty"`
+	RegTime       int64  `gorm:"type:datetime" json:"reg_time,omitempty"`
+	LastLoginTime int64  `gorm:"type:datetime" json:"last_login_time,omitempty"`
+	RegIp         uint32 `gorm:"type:int(10)" json:"reg_ip,omitempty"`
+	LastLoginIp   uint32 `gorm:"type:int(10)" json:"last_login_ip,omitempty"`
+	Status        uint8  `gorm:"not null;default:0" json:"status,omitempty"`
+	Group         string `gorm:"type:varchar(32);not null" json:"group,omitempty"`
+	PlatformId    int32  `gorm:"not null;default:0" json:"platform_id,omitempty"`
+}
+
+type ManagerSearch struct {
+	Uid           int32  `json:"uid,omitempty"`
+	Username      string `json:"username,omitempty"`
+	RegTime       string `json:"reg_time,omitempty"`
+	LastLoginTime string `json:"last_login_time,omitempty"`
+	RegIp         string `json:"reg_ip,omitempty"`
+	LastLoginIp   string `json:"last_login_ip,omitempty"`
+	Status        uint8  `json:"status,omitempty"`
+	Group         string `json:"group,omitempty"`
+	PlatformId    int32  `json:"platform_id,omitempty"`
+}
+
+func (m Manager) TableName() string {
+	return setting.DatabaseSetting.Name_Manage + ".gli_admin"
+}
+
+func GetManager(id int32) (*Manager, error) {
+	var manager Manager
+	err := db.Where("uid = ?", id).First(&manager).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	err = db.Model(&manager).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return &manager, nil
+}
+
+func ExistManagerById(id int32) (bool, error) {
+	var manager Manager
+	err := db.Select("uid").Where("uid = ?", id).First(&manager).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return false, err
+	}
+
+	if manager.Uid > 0 {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func GetManagerTotal(maps interface{}) (int, error) {
+	var count int
+
+	if err := db.Model(&Manager{}).Where(maps).Count(&count).Error; err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+func GetManagers(pageNum, pageSize int, maps interface{}) ([]*Manager, error) {
+	var manager []*Manager
+
+	err := db.Where(maps).Order("uid desc").Offset(pageNum).Limit(pageSize).Find(&manager).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return manager, nil
+}
+
+func AddManager(data map[string]interface{}) (error) {
+	manager := Manager{
+		Username:      data["username"].(string),
+		Password:      data["password"].(string),
+		RegTime:       time.Now().Unix(),
+		LastLoginTime: time.Now().Unix(),
+		RegIp:         data["reg_ip"].(uint32),
+		LastLoginIp:   data["last_login_ip"].(uint32),
+		Group:         data["group"].(string),
+		PlatformId:    data["platform_id"].(int32),
+	}
+
+	if err := db.Create(&manager).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func EditManager(id int32, data interface{}) error {
+	if err := db.Model(&Manager{}).Where("uid = ?", id).Updates(data).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DeleteManager(id int32) error {
+	if err := db.Where("uid = ?", id).Delete(Manager{}).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/errno/errno.go

@@ -127,11 +127,13 @@ var (
 
 	// user errors
 	ErrUserNotFound       = &Errno{Code: 20101, Message: "The user was not found."}
-	ErrAddUser            = &Errno{Code: 20102, Message: "The user add error."}
-	ErrUpdateUser         = &Errno{Code: 20103, Message: "The user update error."}
-	ErrDeleteUser         = &Errno{Code: 20104, Message: "The user delete error."}
-	ErrExistUser          = &Errno{Code: 20105, Message: "The user already exists."}
-	ErrPasswordIncorrect  = &Errno{Code: 20106, Message: "The password was incorrect."}
+	ErrCountUsers         = &Errno{Code: 20102, Message: "The users statistic error."}
+	ErrAddUser            = &Errno{Code: 20103, Message: "The user add error."}
+	ErrUpdateUser         = &Errno{Code: 20104, Message: "The user update error."}
+	ErrDeleteUser         = &Errno{Code: 20105, Message: "The user delete error."}
+	ErrExistUser          = &Errno{Code: 20106, Message: "The user already exists."}
+	ErrDeleteSelf         = &Errno{Code: 20105, Message: "The user can not delete yourself."}
+	ErrPasswordIncorrect  = &Errno{Code: 20107, Message: "The password was incorrect."}
 	ErrUserAuthIncorrect  = &Errno{Code: 40001, Message: "The user auth was incorrect."}
 	ErrUserTokenIncorrect = &Errno{Code: 40001, Message: "The user token was incorrect."}
 

routers/api/backend/manager.go

+package backend
+
+import (
+	"bwallet/pkg/encrypt"
+	"bwallet/pkg/errno"
+	"bwallet/pkg/handler"
+	"bwallet/pkg/util"
+	"bwallet/service/manager_service"
+	"bwallet/validate_service"
+	"fmt"
+	"github.com/Unknwon/com"
+	"github.com/astaxie/beego/validation"
+	"github.com/gin-gonic/gin"
+	"strings"
+)
+
+func AddManager(c *gin.Context) {
+	manager := validate_service.Manager{}
+	c.ShouldBindJSON(&manager)
+
+	token := c.Request.Header.Get("Token")
+	user, _ := util.ParseToken(token)
+	var group string
+	var platform_id int32
+
+	if ("administrator" == user.UserInfo.Group) {
+		group = "admin"
+		platform_id = manager.PlatformId
+	}
+
+	if ("admin" == user.UserInfo.Group) {
+		group = "general"
+		platform_id = int32(user.UserInfo.PlatformId)
+	}
+
+	if ok, errors := validate_service.ValidateInputs(manager); !ok {
+		for _, err := range errors {
+			handler.SendResponse(c, errno.ErrBind, strings.Join(err, " "))
+			return
+		}
+	}
+	manager_service := manager_service.Manager{}
+	manager_service.UserName = manager.UserName
+	count, err := manager_service.Count()
+	if count > 0 || err != nil {
+		fmt.Println(count, err)
+		handler.SendResponse(c, errno.ErrExistUser, nil)
+		return
+	}
+
+	reg_ip := c.ClientIP()
+	ip, _ := util.IPString2Long(reg_ip)
+	password, _ := encrypt.HashPassword(manager.Password)
+
+	manager_service.Password = password
+	manager_service.RegIp = uint32(ip)
+	manager_service.Group = group
+	manager_service.PlatformId = platform_id
+
+	if err := manager_service.Add(); err != nil {
+		handler.SendResponse(c, errno.ErrAddUser, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, nil)
+}
+
+func GetManagers(c *gin.Context) {
+	username := ""
+	if arg := c.Query("username"); arg != "" {
+		username = c.Query("username")
+	}
+
+	var status uint8
+	if arg := c.Query("status"); arg != "" {
+		status = com.StrTo(c.DefaultQuery("status", "0")).MustUint8()
+	}
+
+	token := c.Request.Header.Get("Token")
+	user, _ := util.ParseToken(token)
+
+	var platform_id int32
+	platform_id = int32(user.UserInfo.PlatformId)
+
+	if ("general" == user.UserInfo.Group) {
+		handler.SendResponse(c, errno.ErrUserAuthIncorrect, nil)
+		return
+	}
+
+	if ("administrator" == user.UserInfo.Group) {
+		platform_id = int32(com.StrTo(c.DefaultQuery("platform_id", "0")).MustInt())
+	}
+	manager_service := manager_service.Manager{
+		UserName:   username,
+		Status:     status,
+		PlatformId: platform_id,
+		PageNum:    util.GetPage(c),
+		PageSize:   util.GetLimit(c),
+	}
+
+	total, err := manager_service.Count()
+	if err != nil {
+		handler.SendResponse(c, errno.ErrCountUsers, nil)
+		return
+	}
+
+	managers, err := manager_service.GetAll()
+	if err != nil {
+		handler.SendResponse(c, errno.InternalServerError, nil)
+		return
+	}
+
+	data := make(map[string]interface{})
+	data["items"] = managers
+	data["total"] = total
+
+	handler.SendResponse(c, nil, data)
+}
+
+func DeleteManager(c *gin.Context) {
+	id := int32(com.StrTo(c.DefaultQuery("uid", "0")).MustInt())
+	valid := validation.Validation{}
+	valid.Min(id, 1, "id").Message("ID必须大于0")
+	if valid.HasErrors() {
+		handler.SendResponse(c, errno.ErrValidation, nil)
+		return
+	}
+
+	token := c.Request.Header.Get("Token")
+	user, _ := util.ParseToken(token)
+	group := user.UserInfo.Group
+
+	if int32(user.UserInfo.Uid) == id {
+		handler.SendResponse(c, errno.ErrDeleteSelf, nil)
+		return
+	}
+
+	if ("general" == group) {
+		handler.SendResponse(c, errno.ErrUserAuthIncorrect, nil)
+		return
+	}
+
+	manager_service := manager_service.Manager{Uid: id}
+	manager, err := manager_service.GetManager()
+	if err != nil {
+		handler.SendResponse(c, errno.ErrValidation, nil)
+		return
+	}
+
+	var platform_id int32
+	platform_id = int32(user.UserInfo.PlatformId)
+
+	if "administrator" == manager.Group {
+		handler.SendResponse(c, errno.ErrUserAuthIncorrect, nil)
+		return
+	}
+
+	if "admin" == group && platform_id != manager.PlatformId {
+		handler.SendResponse(c, errno.ErrUserAuthIncorrect, nil)
+		return
+	}
+
+	err = manager_service.Delete()
+	if err != nil {
+		handler.SendResponse(c, errno.ErrDeleteUser, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, nil)
+}

routers/router.go

@@ -132,6 +132,12 @@ func InitRouter() *gin.Engine {
 		api.POST("/live-banner", backend.AddLiveBanner)
 		api.PUT("/live-banner", backend.EditLiveBanner)
 		api.DELETE("/live-banner", backend.DeleteLiveBanner)
+
+		api.GET("/managers", backend.GetManagers)
+		//api.GET("/user", backend.GetUser)
+		api.POST("/manager", backend.AddManager)
+		//api.PUT("/user", backend.EditUser)
+		api.DELETE("/manager", backend.DeleteManager)
 	}
 
 	return r

service/manager_service/manager.go

+package manager_service
+
+import (
+	"bwallet/models"
+	"bwallet/pkg/util"
+	"time"
+)
+
+type Manager struct {
+	Uid           int32
+	UserName      string
+	Password      string
+	Salt          string
+	RegTime       int64
+	LastLoginTime int64
+	RegIp         uint32
+	LastLoginIp   uint32
+	Status        uint8
+	Group         string
+	PlatformId    int32
+
+	PageNum  int
+	PageSize int
+}
+
+func (m *Manager) GetManager() (*models.Manager, error) {
+	manager, err := models.GetManager(m.Uid)
+	if err != nil {
+		return nil, err
+	}
+
+	return manager, nil
+}
+
+func (m *Manager) GetAll() ([]*models.ManagerSearch, error) {
+	var manager []*models.Manager
+
+	manager, err := models.GetManagers(m.PageNum, m.PageSize, m.getMaps())
+	if err != nil {
+		return nil, err
+	}
+
+	var tmp []*models.ManagerSearch
+	for _, value := range manager {
+		ip_reg, _ := util.Long2IPString(uint(value.RegIp))
+		ip_login, _ := util.Long2IPString(uint(value.LastLoginIp))
+
+		m := &models.ManagerSearch{}
+		m.Uid = value.Uid
+		m.Username = value.Username
+		m.PlatformId = value.PlatformId
+		m.Status = value.Status
+		m.Group = value.Group
+		m.RegIp = ip_reg
+		m.LastLoginIp = ip_login
+		m.RegTime = time.Unix(value.RegTime, 0).Format("2006-01-02 15:04:05")
+		m.LastLoginTime = time.Unix(value.LastLoginTime, 0).Format("2006-01-02 15:04:05")
+		tmp = append(tmp, m)
+	}
+
+	return tmp, nil
+}
+
+func (m *Manager) Add() error {
+	manager := map[string]interface{}{
+		"username":      m.UserName,
+		"password":      m.Password,
+		"reg_ip":        m.RegIp,
+		"last_login_ip": m.LastLoginIp,
+		"group":         m.Group,
+		"platform_id":   m.PlatformId,
+	}
+
+	if err := models.AddManager(manager); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *Manager) Edit() error {
+	return models.EditManager(m.Uid, map[string]interface{}{
+		"username":      m.UserName,
+		"password":      m.Password,
+		"reg_ip":        m.RegIp,
+		"last_login_ip": m.LastLoginIp,
+		"status":        m.Status,
+		"group":         m.Group,
+		"platform_id":   m.PlatformId,
+	})
+}
+
+func (m *Manager) ExistById() (bool, error) {
+	return models.ExistManagerById(m.Uid)
+}
+
+func (m *Manager) Count() (int, error) {
+	return models.GetManagerTotal(m.getMaps())
+}
+
+func (m *Manager) Delete() error {
+	return models.DeleteManager(m.Uid)
+}
+
+func (m *Manager) getMaps() (map[string]interface{}) {
+	maps := make(map[string]interface{})
+
+	if m.Uid != 0 {
+		maps["uid"] = m.Uid
+	}
+
+	if m.PlatformId != 0 {
+		maps["platform_id"] = m.PlatformId
+	}
+
+	if m.Status != 0 {
+		maps["status"] = m.Status
+	}
+
+	if m.UserName != "" {
+		maps["username"] = m.UserName
+	}
+
+	if m.Group != "" {
+		maps["group"] = m.Group
+	}
+
+	return maps
+}

validate_service/manager.go

+package validate_service
+
+type Manager struct {
+	UserName   string `json:"username" validate:"required"`
+	Password   string `json:"password" validate:"required"`
+	PlatformId int32  `json:"platform_id" validate:"required"`
+}
+
+func (m Manager) Unique(val string) bool {
+	return len(val) == 4
+}