msb-public
/
Open-IM-Server
mirror of https://github.com/OpenIMSDK/Open-IM-Server
2
0
Code Issues Projects Releases Wiki Activity

Merge branch 'del' of github.com:OpenIMSDK/Open-IM-Server into del

Browse Source 
# Conflicts:
#	pkg/common/db/mysql_model/im_mysql_model/ip_model.go
pull/267/head
wangchuxiao 3 years ago
parent 05d45c94d5 44e4c59493
commit 9b86a18752
5 changed files with 137 additions and 27 deletions
Show Stats Download Patch File Download Diff File

9
cmd/open_im_demo/main.go
Unescape View File

@ -40,11 +40,18 @@ func main() {
demoRouterGroup.POST("/login", register.Login)
demoRouterGroup.POST("/reset_password", register.ResetPassword)
}
cmsRouterGroup := r.Group("/cms")
cmsRouterGroup := r.Group("/cms_admin")
{
cmsRouterGroup.POST("/generate_invitation_code", register.GenerateInvitationCode)
cmsRouterGroup.POST("/query_invitation_code", register.QueryInvitationCode)
cmsRouterGroup.POST("/get_invitation_codes", register.GetInvitationCodes)
cmsRouterGroup.POST("/query_user_ip_limit_login", register.QueryUserIPLimitLogin)
cmsRouterGroup.POST("/add_user_ip_limit_login", register.AddUserIPLimitLogin)
cmsRouterGroup.POST("/remove_user_ip_limit_login", register.RemoveUserIPLimitLogin)
cmsRouterGroup.POST("/query_ip_register", register.QueryIPRegister)
cmsRouterGroup.POST("/add_ip_limit", register.AddIPLimit)
cmsRouterGroup.POST("/remove_ip_Limit", register.RemoveIPLimit)
}
defaultPorts := config.Config.Demo.Port
ginPort := flag.Int("port", defaultPorts[0], "get ginServerPort from cmd,default 10004 as port")

110
internal/demo/register/ip_limit.go
Unescape View File

@ -20,8 +20,8 @@ type QueryIPRegisterReq struct {
type QueryIPRegisterResp struct {
IP string `json:"ip"`
RegisterNum int `json:"num"`
UserIDList []string `json:"userIDList"`
Status int `json:"status"`
UserIDList []string `json:"userIDList"`
}
func QueryIPRegister(c *gin.Context) {
@ -32,18 +32,24 @@ func QueryIPRegister(c *gin.Context) {
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
ips, err := imdb.QueryUserIPLimits(req.IP)
userIDList, err := imdb.GetRegisterUserNum(req.IP)
if err != nil {
log.NewError(req.OperationID, "GetInvitationCode failed", req.IP)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "QueryUserIPLimits error!"})
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "GetRegisterUserNum error!"})
return
}
resp.IP = req.IP
resp.RegisterNum = len(ips)
for _, ip := range ips {
resp.UserIDList = append(resp.UserIDList, ip.UserID)
resp.RegisterNum = len(userIDList)
resp.UserIDList = userIDList
ipLimits, err := imdb.QueryIPLimits(req.IP)
if err != nil {
log.NewError(req.OperationID, "QueryIPLimits failed", req.IP)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "QueryIPLimits error!"})
return
}
if ipLimits.Ip != "" {
resp.Status = 1
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp:", resp)
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
}
@ -73,53 +79,113 @@ func AddIPLimit(c *gin.Context) {
LimitTime: time.Time{},
}); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.IP, req.LimitTime)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "InsertOneIntoIpLimits error!"})
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "InsertOneIntoIpLimits error!"})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": ""})
}
type RemoveIPLimitReq struct {
OperationID string `json:"operationID"`
IP string `json:"ip"`
}
type RemoveIPLimitResp struct {
}
func RemoveIPLimit(c *gin.Context) {
//DeleteOneFromIpLimits
req := AddIPLimitReq{}
//resp := AddIPLimitResp{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
if err := imdb.DeleteOneFromIpLimits(req.IP); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.IP, req.LimitTime)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "InsertOneIntoIpLimits error!"})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": ""})
}
// ===========================================sk 写
type QueryUserIDIPLimitReq struct {
UserID string `json:"userID" binding:"required"`
}
// ===========================================sk ==========================
type QueryUserIDIPLimitResp struct {
type QueryUserIDIPLimitLoginReq struct {
UserID string `json:"userID" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
}
func QueryUserIDIPLimit(c *gin.Context) {
//type QueryUserIDIPLimitLoginResp struct {
// UserIpLimit []db.UserIpLimit `json:"userIpLimit"`
//}
func QueryUserIPLimitLogin(c *gin.Context) {
req := QueryUserIDIPLimitLoginReq{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
resp, err := imdb.GetIpLimitsLoginByUserID(req.UserID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "GetIpLimitsByUserID error!"})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp:", resp)
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
}
type AddUserIPLimitReq struct {
type AddUserIPLimitLoginReq struct {
UserID string `json:"userID" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
IP string `json:"ip"`
}
type AddUserIPLimitResp struct {
type AddUserIPLimitLoginResp struct {
}
// 添加ip 特定用户才能登录 user_ip_limits 表
func AddUserIPLimit(c *gin.Context) {
func AddUserIPLimitLogin(c *gin.Context) {
req := AddUserIPLimitLoginReq{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
userIp := db.UserIpLimit{UserID: req.UserID, Ip: req.IP}
err := imdb.InsertUserIpLimitsLogin(&userIp)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "InsertUserIpLimitsLogin error!"})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": ""})
}
type RemoveUserIPLimitReq struct {
UserID string `json:"userID" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
IP string `json:"ip"`
}
type RemoveUserIPLimitResp struct {
}
// 删除ip 特定用户才能登录 user_ip_limits 表
func RemoveUserIPLimit(c *gin.Context) {
func RemoveUserIPLimitLogin(c *gin.Context) {
req := RemoveUserIPLimitReq{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
err := imdb.DeleteUserIpLimitsLogin(req.UserID, req.IP)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "DeleteUserIpLimitsLogin error!"})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": ""})
}

7
internal/demo/register/set_password.go
Unescape View File

@ -8,7 +8,6 @@ import (
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
http2 "Open_IM/pkg/common/http"
"Open_IM/pkg/common/log"
pbAuth "Open_IM/pkg/proto/auth"
pbFriend "Open_IM/pkg/proto/friend"
"Open_IM/pkg/utils"
"encoding/json"
@ -47,10 +46,12 @@ func SetPassword(c *gin.Context) {
Limited, LimitError := imdb.IsLimitRegisterIp(ip)
if LimitError != nil {
log.Error(params.OperationID, utils.GetSelfFuncName(), LimitError, ip)
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": LimitError.Error()})
return
}
if Limited {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.RegisterLimit, "errMsg": "limited"})
return
}
var account string

1
pkg/common/db/model_struct.go
Unescape View File

@ -9,6 +9,7 @@ type Register struct {
UserID string `gorm:"column:user_id;type:varchar(255)" json:"userID"`
AreaCode string `gorm:"column:area_code;type:varchar(255)"`
InvitationCode string `gorm:"column:invitation_code;type:varchar(255)"`
RegisterIP string `gorm:"column:register_ip;type:varchar(255)"`
}
type Invitation struct {

37
pkg/common/db/mysql_model/im_mysql_model/ip_model.go
Unescape View File

@ -1,6 +1,10 @@
package im_mysql_model
import "Open_IM/pkg/common/db"
import (
"Open_IM/pkg/common/db"
"github.com/jinzhu/gorm"
"time"
)
func IsLimitRegisterIp(RegisterIp string) (bool, error) {
//如果已经存在则限制
@ -29,6 +33,15 @@ func IsLimitUserLoginIp(userID string, LoginIp string) (bool, error) {
return count == 0, nil
}
func QueryIPLimits(ip string) (*db.IpLimit, error) {
var ipLimit db.IpLimit
err := db.DB.MysqlDB.DefaultGormDB().Model(&db.IpLimit{}).Where("ip=?", ip).Take(&ip).Error
if gorm.IsRecordNotFoundError(err) {
return nil, nil
}
return &ipLimit, err
}
func QueryUserIPLimits(ip string) ([]db.UserIpLimit, error) {
var ips []db.UserIpLimit
err := db.DB.MysqlDB.DefaultGormDB().Model(&db.UserIpLimit{}).Where("ip=?", ip).Find(&ips).Error
@ -43,3 +56,25 @@ func DeleteOneFromIpLimits(ip string) error {
ipLimits := &db.IpLimit{}
return db.DB.MysqlDB.DefaultGormDB().Model(ipLimits).Where("ip=?", ip).Delete(ipLimits).Error
}
func GetIpLimitsLoginByUserID(userID string) ([]db.UserIpLimit, error) {
var ips []db.UserIpLimit
err := db.DB.MysqlDB.DefaultGormDB().Model(&db.UserIpLimit{}).Where("user_id=?", userID).Take(&ips).Error
return ips, err
}
func InsertUserIpLimitsLogin(userIp *db.UserIpLimit) error {
userIp.CreateTime = time.Now()
return db.DB.MysqlDB.DefaultGormDB().Model(&db.UserIpLimit{}).Create(userIp).Error
}
func DeleteUserIpLimitsLogin(userID, ip string) error {
userIp := db.UserIpLimit{UserID: userID, Ip: ip}
return db.DB.MysqlDB.DefaultGormDB().Model(&db.UserIpLimit{}).Delete(&userIp).Error
}
func GetRegisterUserNum(ip string) ([]string, error) {
var userIDList []string
err := db.DB.MysqlDB.DefaultGormDB().Model(&db.Register{}).Where("register_ip=?", ip).Pluck("user_id", &userIDList).Error
return userIDList, err
}

Write Preview
Loading…
Cancel
Save