├── main.go~
├── README.md~
├── jwt_demo
├── README.md
├── conf
└── app.conf
├── models
├── token_io.go
├── apps_io.go
├── user_io.go
├── action.go
├── role_io.go
├── token.go
├── apps.go
├── user.go
└── role.go
├── main.go
├── controllers
├── default.go
├── action
│ └── action.go
├── token
│ └── token.go
├── apps
│ └── apps.go
├── user
│ └── user.go
└── role
│ └── role.go
├── tests
└── default_test.go
├── routers
└── router.go
├── common
└── common.go
└── views
└── index.tpl
/main.go~:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/README.md~:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/jwt_demo:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nan1888/beego_jwt/HEAD/jwt_demo
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 项目说明：http://blog.csdn.net/Manrener/article/details/54342258
2 |
3 |
--------------------------------------------------------------------------------
/conf/app.conf:
--------------------------------------------------------------------------------
1 | appname = jwt_demo
2 | runmode = dev
3 | sessionOn = true
4 | sessionHashKey = "12345678"
5 | [dev]
6 | HTTPPort = 9091
7 |
8 | [prod]
9 | HTTPPort = 9091
--------------------------------------------------------------------------------
/models/token_io.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | // RegisterForm definiton.
4 | type CreateTokenForm struct {
5 | Appid string `form:"appid"`
6 | Secret string `form:"secret"`
7 | }
8 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | _ "jwt_demo/routers"
5 |
6 | "github.com/astaxie/beego"
7 | "github.com/astaxie/beego/orm"
8 | _ "github.com/astaxie/beego/session/redis"
9 | _ "github.com/go-sql-driver/mysql"
10 | )
11 |
12 | func main() {
13 | orm.RegisterDriver("mysql", orm.DRMySQL)
14 | orm.RegisterDataBase("default", "mysql", "root:newpasswd@tcp(localhost:3306)/userrole?charset=utf8", 30, 30)
15 | orm.Debug = true
16 | beego.Run()
17 | }
18 |
--------------------------------------------------------------------------------
/models/apps_io.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | // RegisterForm definiton.
4 | type ChangeappsForm struct {
5 | Id string `form:"id"`
6 | Appname string `form:"appname"`
7 | Appremark string `form:"appremark"`
8 | Token string `form:"token"`
9 | }
10 |
11 | type AddappsForm struct {
12 | Appname string `form:"appname"`
13 | Appremark string `form:"appremark"`
14 | Token string `form:"token"`
15 | }
16 |
17 | type DeleteappsForm struct {
18 | Id string `form:"id"`
19 | Token string `form:"token"`
20 | }
21 |
--------------------------------------------------------------------------------
/models/user_io.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | // RegisterForm definiton.
4 | type RegisterForm struct {
5 | Email string `form:"email" valid:"Required"`
6 | Password string `form:"password" valid:"Required"`
7 | Username string `form:"username"`
8 | }
9 |
10 | // LoginForm definiton.
11 | type LoginForm struct {
12 | Username string `form:"username"`
13 | Password string `form:"password" valid:"Required"`
14 | }
15 | type LoginInfo struct {
16 | Code int `json:"code"`
17 | UserInfo *User `json:"user"`
18 | }
19 | type ChangeuserroleForm struct {
20 | Id string `form:"id"`
21 | Username string `form:"username"`
22 | }
23 |
--------------------------------------------------------------------------------
/controllers/default.go:
--------------------------------------------------------------------------------
1 | package controllers
2 |
3 | import (
4 | "fmt"
5 | "jwt_demo/common"
6 | "jwt_demo/models"
7 |
8 | "github.com/astaxie/beego"
9 | )
10 |
11 | type MainController struct {
12 | beego.Controller
13 | }
14 |
15 | func (c *MainController) Get() {
16 | token := c.GetString("token")
17 | appid, err := user_encode.Token_auth(token, "secret")
18 | if err != nil {
19 |
20 | c.Data["json"] = user_encode.ErrExpired
21 | c.ServeJSON()
22 | return
23 | }
24 | roleid, err := models.Auth_role("2321fd", appid)
25 | if err != nil {
26 | fmt.Println(err)
27 | c.Data["json"] = user_encode.ErrPermission
28 | c.ServeJSON()
29 | return
30 | }
31 | fmt.Println(roleid)
32 | c.Data["Website"] = "beego.me"
33 | c.Data["Email"] = "astaxie@gmail.com"
34 | c.TplName = "index.tpl"
35 | }
36 |
--------------------------------------------------------------------------------
/models/action.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | import (
4 | "github.com/astaxie/beego/orm"
5 | _ "github.com/go-sql-driver/mysql"
6 | )
7 |
8 | // 客户端信息
9 | type Action_user struct {
10 | Username string
11 | Create_time string
12 | Appid string
13 | Secret string
14 | Role_id int
15 | Email string
16 | }
17 |
18 | func Select_all() (u []Action_user, err error) {
19 | o := orm.NewOrm()
20 | o.Using("default")
21 | var action_users []Action_user
22 | _, err = o.Raw("select username,create_time,appid,secrec,email from oauth_token").QueryRows(&action_users)
23 |
24 | return action_users, err
25 | }
26 |
27 | func (u *Action_user) Select_one(username string) (one_user *Action_user, err error) {
28 | o := orm.NewOrm()
29 | o.Using("default")
30 | err = o.Raw("select create_time,express_in from oauth_token where token = ?", username).QueryRow(&u)
31 |
32 | return u, err
33 | }
34 |
--------------------------------------------------------------------------------
/models/role_io.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | // RegisterForm definiton.
4 | type ChangeroleForm struct {
5 | Id string `form:"id"`
6 | Appid string `form:"appid"`
7 | Zoneid string `form:"zoneid"`
8 | Token string `form:"token"`
9 | }
10 |
11 | type AddroleForm struct {
12 | Appid string `form:"appid"`
13 | Zoneid string `form:"zoneid"`
14 | Token string `form:"token"`
15 | }
16 |
17 | type DeleteroleForm struct {
18 | Id string `form:"id"`
19 | Token string `form:"token"`
20 | }
21 |
22 | type ChangezoneForm struct {
23 | Id string `form:"id"`
24 | Zonename string `form:"username"`
25 | Zoneremark string `form:"zoneremark"`
26 | Token string `form:"token"`
27 | }
28 |
29 | type AddzoneForm struct {
30 | Zonename string `form:"zonename"`
31 | Zoneremark string `form:"zoneremark"`
32 | Token string `form:"token"`
33 | }
34 |
35 | type DeletezoneForm struct {
36 | Id string `form:"id"`
37 | Token string `form:"token"`
38 | }
39 |
--------------------------------------------------------------------------------
/controllers/action/action.go:
--------------------------------------------------------------------------------
1 | package action
2 |
3 | import (
4 | "jwt_demo/common"
5 | "jwt_demo/models"
6 |
7 | "github.com/astaxie/beego"
8 | )
9 |
10 | type ReaduserlistController struct {
11 | beego.Controller
12 | }
13 |
14 | type ReadoneuserController struct {
15 | beego.Controller
16 | }
17 |
18 | func (c *ReaduserlistController) Get() {
19 | token := c.GetString("token")
20 | appid, err := user_encode.Token_auth(token, "secret")
21 | if err != nil {
22 | c.Data["json"] = user_encode.ErrExpired
23 | c.ServeJSON()
24 | return
25 | }
26 | _, err = models.Auth_role(user_encode.Select_all_user, appid)
27 | if err != nil {
28 | c.Data["json"] = user_encode.ErrPermission
29 | c.ServeJSON()
30 | return
31 | }
32 | users, err := models.Select_all()
33 | if err == nil {
34 | c.Data["json"] = users
35 | c.ServeJSON()
36 | } else {
37 | c.Data["json"] = user_encode.Err404
38 | c.ServeJSON()
39 | }
40 |
41 | }
42 |
43 | func (c *ReadoneuserController) Get() {
44 |
45 | c.Data["json"] = user_encode.Err404
46 | c.ServeJSON()
47 | }
48 |
--------------------------------------------------------------------------------
/tests/default_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "net/http"
5 | "net/http/httptest"
6 | "testing"
7 | "runtime"
8 | "path/filepath"
9 | _ "jwt_demo/routers"
10 |
11 | "github.com/astaxie/beego"
12 | . "github.com/smartystreets/goconvey/convey"
13 | )
14 |
15 | func init() {
16 | _, file, _, _ := runtime.Caller(1)
17 | apppath, _ := filepath.Abs(filepath.Dir(filepath.Join(file, ".." + string(filepath.Separator))))
18 | beego.TestBeegoInit(apppath)
19 | }
20 |
21 |
22 | // TestMain is a sample to run an endpoint test
23 | func TestMain(t *testing.T) {
24 | r, _ := http.NewRequest("GET", "/", nil)
25 | w := httptest.NewRecorder()
26 | beego.BeeApp.Handlers.ServeHTTP(w, r)
27 |
28 | beego.Trace("testing", "TestMain", "Code[%d]\n%s", w.Code, w.Body.String())
29 |
30 | Convey("Subject: Test Station Endpoint\n", t, func() {
31 | Convey("Status Code Should Be 200", func() {
32 | So(w.Code, ShouldEqual, 200)
33 | })
34 | Convey("The Result Should Not Be Empty", func() {
35 | So(w.Body.Len(), ShouldBeGreaterThan, 0)
36 | })
37 | })
38 | }
39 |
40 |
--------------------------------------------------------------------------------
/controllers/token/token.go:
--------------------------------------------------------------------------------
1 | package token
2 |
3 | import (
4 | "jwt_demo/common"
5 | "jwt_demo/models"
6 | //"fmt"
7 | //"reflect"
8 | "strconv"
9 |
10 | "github.com/astaxie/beego"
11 | )
12 |
13 | type AccesstokenController struct {
14 | beego.Controller
15 | }
16 |
17 | type RefreshtokenController struct {
18 | beego.Controller
19 | }
20 |
21 | type Usertoken struct {
22 | Token string
23 | Appid string
24 | Secret string
25 | Express_in int64
26 | }
27 |
28 | func (c *AccesstokenController) Get() {
29 | /*验证appid 和 secret，下发token*/
30 | form := models.CreateTokenForm{}
31 | if err := c.ParseForm(&form); err != nil {
32 | beego.Debug("errParseRegsiterForm:", err)
33 | c.Data["json"] = user_encode.ErrInputData
34 | c.ServeJSON()
35 | return
36 | }
37 | var T Usertoken
38 | T.Token, T.Express_in = user_encode.Create_token(form.Appid, form.Secret)
39 | express_in := strconv.FormatInt(T.Express_in, 10)
40 | token_model, err := models.NewToken(&form, T.Token, express_in)
41 | if err != nil {
42 | beego.Error("NewUser:", err)
43 | c.Data["json"] = user_encode.ErrSystem
44 | c.ServeJSON()
45 | return
46 | }
47 | beego.Debug("NewUser:", token_model)
48 | token_model.Insert()
49 | T.Appid = form.Appid
50 | T.Secret = form.Secret
51 | //fmt.Println("type:", reflect.TypeOf(express_in))
52 | c.Data["json"] = &T
53 | c.ServeJSON()
54 | }
55 |
--------------------------------------------------------------------------------
/models/token.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | import (
4 | "fmt"
5 | "time"
6 |
7 | "github.com/astaxie/beego/orm"
8 | _ "github.com/go-sql-driver/mysql"
9 | )
10 |
11 | // User_token token message
12 | type User_token struct {
13 | Token string
14 | Express_in string
15 | Appid string
16 | Create_time string
17 | }
18 |
19 | /*
20 | func (u *User_token) FindByID(name string) (result int, err error) {
21 | o := orm.NewOrm()
22 | o.Using("default")
23 | err = o.Raw("select * from user where username = ?", name).QueryRow(&u)
24 |
25 | if err != nil {
26 | fmt.Println(err)
27 | } else {
28 | fmt.Println(u.Passwd)
29 | result = u.Id
30 | }
31 | return
32 | }*/
33 |
34 | func NewToken(r *CreateTokenForm, token string, express_in string) (u *User_token, err error) {
35 | regDate := time.Now().Format("2006-01-02 15:04:05")
36 | if err != nil {
37 | return nil, err
38 | }
39 |
40 | user := User_token{
41 | Appid: r.Appid,
42 | Token: token,
43 | Express_in: express_in,
44 | Create_time: regDate,
45 | }
46 |
47 | return &user, nil
48 | }
49 |
50 | func (u *User_token) Insert() {
51 | o := orm.NewOrm()
52 | o.Using("default")
53 |
54 | fmt.Println("sssss")
55 | fmt.Println(u.Appid)
56 | //_, err = o.Insert(user)
57 |
58 | _, err := o.Raw("replace into oauth_token (id,token,create_time,express_in) values (?,?,?,?)", u.Appid, u.Token, u.Create_time, u.Express_in).Exec()
59 |
60 | if err != nil {
61 | fmt.Println(err)
62 | } else {
63 | fmt.Println("insert ok")
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/routers/router.go:
--------------------------------------------------------------------------------
1 | package routers
2 |
3 | import (
4 | "jwt_demo/controllers"
5 | "jwt_demo/controllers/action"
6 | "jwt_demo/controllers/apps"
7 | "jwt_demo/controllers/role"
8 | "jwt_demo/controllers/token"
9 | "jwt_demo/controllers/user"
10 |
11 | "github.com/astaxie/beego"
12 | )
13 |
14 | func init() {
15 | beego.Router("/", &controllers.MainController{})
16 | /*token*/
17 | beego.Router("/access_token", &token.AccesstokenController{}) //获取token
18 | /*user*/
19 | beego.Router("/login", &user.LoginController{}) //用户登录
20 | beego.Router("/register", &user.RegisterController{}) //用户注册
21 | beego.Router("/findpasswd", &user.FindpasswdController{}) //找回密码
22 | beego.Router("/loginout", &user.LoginoutController{}) //用户退出登录
23 | beego.Router("/changepwsswd", &user.ChangepasswdController{}) //用户更改密码
24 | /*role*/
25 | beego.Router("/addrole", &role.AddroleController{}) //添加模块到用户组
26 | beego.Router("/deleterole", &role.DeleteroleController{}) //删除用户组的模块
27 | beego.Router("/changerole", &role.ChangeroleController{}) //改变用户的用户组
28 | beego.Router("/listrole", &role.ListroleController{}) //列出所有用户组的模块
29 | /*action*/
30 | beego.Router("/read_user_list", &action.ReaduserlistController{}) //查看所有用户的信息
31 | beego.Router("/read_one_user", &action.ReadoneuserController{}) //查看单独用户的信息
32 | /*zone*/
33 | beego.Router("/addzone", &role.AddzoneController{}) //添加用户组
34 | beego.Router("/deletezone", &role.DeletezoneController{}) //删除用户组
35 | beego.Router("/changezone", &role.ChangezoneController{}) //改变用户组
36 | beego.Router("/listzone", &role.ListzoneController{}) //列出所有用户组
37 | /*apps*/
38 | beego.Router("/addapps", &apps.AddappsController{}) //添加模块
39 | beego.Router("/deleteapps", &apps.DeleteappsController{}) //删除模块
40 | beego.Router("/changeapps", &apps.ChangeappsController{}) //改变模块的信息
41 | beego.Router("/listapps", &apps.ListappsController{}) //列出所有模块
42 | }
43 |
--------------------------------------------------------------------------------
/models/apps.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | import (
4 | "fmt"
5 | "time"
6 |
7 | "github.com/astaxie/beego/orm"
8 | _ "github.com/go-sql-driver/mysql"
9 | )
10 |
11 | // Client 客户端信息
12 | type Apps struct {
13 | Id string
14 | App_name string
15 | App_remark string
16 | }
17 |
18 | func NewApp(r *AddappsForm) (u *Apps, err error) {
19 |
20 | apps := Apps{
21 |
22 | App_name: r.Appname,
23 | App_remark: r.Appremark,
24 | }
25 |
26 | return &apps, nil
27 | }
28 |
29 | func (u *Apps) Insert() {
30 | o := orm.NewOrm()
31 | o.Using("default")
32 | //_, err = o.Insert(user)
33 | create_time := time.Now().Format("2006-01-02 15:04:05")
34 | _, err := o.Raw("insert into oauth_modelid (app_name,app_remark,create_time,rewrite_time) values (?,?,?,?)", u.App_name, u.App_remark, create_time, create_time).Exec()
35 |
36 | if err != nil {
37 | fmt.Println(err)
38 | } else {
39 | fmt.Println("insert ok")
40 | }
41 | }
42 |
43 | func Apps_update(id, appname, appremark string) (err error) {
44 | o := orm.NewOrm()
45 | o.Using("default")
46 | //_, err = o.Insert(user)
47 | rewrite_time := time.Now().Format("2006-01-02 15:04:05")
48 | fmt.Println(appname)
49 | _, err = o.Raw("update oauth_modelid set app_name = ?,app_remark = ?,rewrite_time = ? where id = ?", appname, appremark, rewrite_time, id).Exec()
50 |
51 | if err != nil {
52 | fmt.Println(err)
53 | } else {
54 | fmt.Println("insert ok")
55 | }
56 | return
57 | }
58 |
59 | func Apps_delete(id string) (err error) {
60 | o := orm.NewOrm()
61 | o.Using("default")
62 | _, err = o.Raw("delete from oauth_modelid where id = ?", id).Exec()
63 |
64 | if err != nil {
65 | fmt.Println(err)
66 | } else {
67 | fmt.Println("delete apps ok")
68 | }
69 | return
70 | }
71 |
72 | func Applist() ([]Apps, error) {
73 | o := orm.NewOrm()
74 | o.Using("default")
75 | var apps []Apps
76 | _, err := o.Raw("select id,app_name,app_remark from oauth_modelid").QueryRows(&apps)
77 |
78 | return apps, err
79 | }
80 |
--------------------------------------------------------------------------------
/common/common.go:
--------------------------------------------------------------------------------
1 | package user_encode
2 |
3 | import (
4 | "crypto/md5"
5 | "encoding/base64"
6 | "time"
7 |
8 | "github.com/dgrijalva/jwt-go"
9 | )
10 |
11 | type ControllerError struct {
12 | Status int `json:"status"`
13 | Code int `json:"code"`
14 | Message string `json:"message"`
15 | DevInfo string `json:"dev_info"`
16 | MoreInfo string `json:"more_info"`
17 | }
18 |
19 | var (
20 | Err404 = &ControllerError{404, 404, "page not found", "page not found", ""}
21 | ErrInputData = &ControllerError{400, 10001, "数据输入错误", "客户端参数错误", ""}
22 | ErrDatabase = &ControllerError{500, 10002, "服务器错误", "数据库操作错误", ""}
23 | ErrDupUser = &ControllerError{400, 10003, "用户信息已存在", "数据库记录重复", ""}
24 | ErrNoUser = &ControllerError{400, 10004, "用户信息不存在", "数据库记录不存在", ""}
25 | ErrPass = &ControllerError{400, 10005, "用户信息不存在或密码不正确", "密码不正确", ""}
26 | ErrNoUserPass = &ControllerError{400, 10006, "用户信息不存在或密码不正确", "数据库记录不存在或密码不正确", ""}
27 | ErrNoUserChange = &ControllerError{400, 10007, "用户信息不存在或数据未改变", "数据库记录不存在或数据未改变", ""}
28 | ErrInvalidUser = &ControllerError{400, 10008, "用户信息不正确", "Session信息不正确", ""}
29 | ErrOpenFile = &ControllerError{500, 10009, "服务器错误", "打开文件出错", ""}
30 | ErrWriteFile = &ControllerError{500, 10010, "服务器错误", "写文件出错", ""}
31 | ErrSystem = &ControllerError{500, 10011, "服务器错误", "操作系统错误", ""}
32 | ErrExpired = &ControllerError{400, 10012, "登录已过期", "验证token过期", ""}
33 | ErrPermission = &ControllerError{400, 10013, "没有权限", "没有操作权限", ""}
34 | Actionsuccess = &ControllerError{200, 90000, "操作成功", "操作成功", ""}
35 | )
36 |
37 | const (
38 | Select_all_user = "查找全部用户"
39 | )
40 |
41 | type Claims struct {
42 | Appid string `json:"appid"`
43 | // recommended having
44 | jwt.StandardClaims
45 | }
46 |
47 | func base64Encode(src []byte) []byte {
48 | return []byte(base64.StdEncoding.EncodeToString(src))
49 | }
50 | func To_md5(encode string) (decode string) {
51 | md5Ctx := md5.New()
52 | md5Ctx.Write([]byte(encode))
53 | cipherStr := md5Ctx.Sum(nil)
54 | return string(base64Encode(cipherStr))
55 | }
56 |
57 | func Create_token(appid string, secret string) (string, int64) {
58 | expireToken := time.Now().Add(time.Hour * 1).Unix()
59 | claims := Claims{
60 | appid,
61 | jwt.StandardClaims{
62 | ExpiresAt: expireToken,
63 | Issuer: appid,
64 | },
65 | }
66 |
67 | // Create the token using your claims
68 | c_token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
69 |
70 | // Signs the token with a secret.
71 | signedToken, _ := c_token.SignedString([]byte("secret"))
72 |
73 | return signedToken, expireToken
74 | }
75 |
76 | func Token_auth(signedToken, secret string) (string, error) {
77 | token, err := jwt.ParseWithClaims(signedToken, &Claims{}, func(token *jwt.Token) (interface{}, error) {
78 | return []byte(secret), nil
79 | })
80 | if claims, ok := token.Claims.(*Claims); ok && token.Valid {
81 | //fmt.Printf("%v %v", claims.Username, claims.StandardClaims.ExpiresAt)
82 | //fmt.Println(reflect.TypeOf(claims.StandardClaims.ExpiresAt))
83 | //return claims.Appid, err
84 | return claims.Appid, err
85 | }
86 | return "", err
87 | }
88 |
--------------------------------------------------------------------------------
/models/user.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | import (
4 | "crypto/rand"
5 | "fmt"
6 | "io"
7 | "time"
8 |
9 | "github.com/astaxie/beego/orm"
10 | _ "github.com/go-sql-driver/mysql"
11 | "golang.org/x/crypto/scrypt"
12 | )
13 |
14 | // Client 客户端信息
15 | type User struct {
16 | Username string
17 | Passwd string
18 | Salt string
19 | Id int
20 | Create_time string
21 | Appid string
22 | Secret string
23 | Role_id int
24 | Email string
25 | }
26 |
27 | const pwHashBytes = 64
28 |
29 | func generateSalt() (salt string, err error) {
30 | buf := make([]byte, pwHashBytes)
31 | if _, err := io.ReadFull(rand.Reader, buf); err != nil {
32 | return "", err
33 | }
34 |
35 | return fmt.Sprintf("%x", buf), nil
36 | }
37 |
38 | func generatePassHash(password string, salt string) (hash string, err error) {
39 | h, err := scrypt.Key([]byte(password), []byte(salt), 16384, 8, 1, pwHashBytes)
40 | if err != nil {
41 | return "", err
42 | }
43 |
44 | return fmt.Sprintf("%x", h), nil
45 | }
46 |
47 | //验证帐号密码
48 |
49 | func (u *User) CheckPass(pass string) (ok bool, err error) {
50 | hash, err := generatePassHash(pass, u.Salt)
51 | if err != nil {
52 | return false, err
53 | }
54 |
55 | return u.Passwd == hash, nil
56 | }
57 |
58 | func (u *User) FindByID(name string) (result int, err error) {
59 | o := orm.NewOrm()
60 | o.Using("default")
61 | err = o.Raw("select * from oauth_user where username = ?", name).QueryRow(&u)
62 |
63 | if err != nil {
64 | fmt.Println(err)
65 | } else {
66 | fmt.Println(u.Passwd)
67 | result = u.Id
68 | }
69 | return
70 | }
71 |
72 | func NewUser(r *RegisterForm, appid string, secret string) (u *User, err error) {
73 | salt, err := generateSalt()
74 | regDate := time.Now().Format("2006-01-02 15:04:05")
75 | if err != nil {
76 | return nil, err
77 | }
78 | hash, err := generatePassHash(r.Password, salt)
79 | if err != nil {
80 | return nil, err
81 | }
82 |
83 | user := User{
84 | Username: r.Username,
85 | Email: r.Email,
86 | Passwd: hash,
87 | Salt: salt,
88 | Create_time: regDate,
89 | Appid: appid,
90 | Secret: secret,
91 | Role_id: 1,
92 | }
93 |
94 | return &user, nil
95 | }
96 |
97 | func (u *User) Insert() {
98 | o := orm.NewOrm()
99 | o.Using("default")
100 |
101 | fmt.Println("sssss")
102 | fmt.Println(u.Appid)
103 | //_, err = o.Insert(user)
104 |
105 | _, err := o.Raw("insert into oauth_user (username,passwd,email,status,create_time,role_id,appid,secret,salt) values (?,?,?,?,?,?,?,?,?)", u.Username, u.Passwd, u.Email, 1, u.Create_time, u.Role_id, u.Appid, u.Secret, u.Salt).Exec()
106 |
107 | if err != nil {
108 | fmt.Println(err)
109 | } else {
110 | fmt.Println("insert ok")
111 | }
112 | }
113 |
114 | func Update_user_role(role_id, username string) error {
115 | o := orm.NewOrm()
116 | o.Using("default")
117 | _, err := o.Raw("update oauth_user set role_id = ? where username = ?", role_id, username).Exec()
118 |
119 | if err != nil {
120 | fmt.Println(err)
121 | } else {
122 | fmt.Println("insert ok")
123 | }
124 | return err
125 | }
126 |
--------------------------------------------------------------------------------
/models/role.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | import (
4 | "fmt"
5 |
6 | "github.com/astaxie/beego/orm"
7 | _ "github.com/go-sql-driver/mysql"
8 | )
9 |
10 | // Client 客户端信息
11 | type Zone struct {
12 | Id string
13 | Zonename string
14 | Zoneremark string
15 | }
16 |
17 | type Role struct {
18 | Id string
19 | App_id string
20 | Zone_id string
21 | }
22 |
23 | func Zone_insert(zonename, zoneremark string) error {
24 | o := orm.NewOrm()
25 | o.Using("default")
26 | _, err := o.Raw("insert into oauth_zone (zone_name,zone_remark) values (?,?)", zonename, zoneremark).Exec()
27 |
28 | if err != nil {
29 | fmt.Println(err)
30 | } else {
31 | fmt.Println("insert ok")
32 | }
33 | return err
34 | }
35 |
36 | func Role_insert(appid, zoneid string) error {
37 | o := orm.NewOrm()
38 | o.Using("default")
39 | _, err := o.Raw("insert into oauth_roleid (app_id,zone_id) values (?,?)", appid, zoneid).Exec()
40 |
41 | if err != nil {
42 | fmt.Println(err)
43 | } else {
44 | fmt.Println("insert ok")
45 | }
46 | return err
47 | }
48 |
49 | func Zone_update(id, zonename, zoneremark string) error {
50 | o := orm.NewOrm()
51 | o.Using("default")
52 | _, err := o.Raw("update oauth_zone set zone_name = ?,zone_remark = ?,rewrite_time = ? where id = ?", zonename, zoneremark, id).Exec()
53 |
54 | if err != nil {
55 | fmt.Println(err)
56 | } else {
57 | fmt.Println("insert ok")
58 | }
59 | return err
60 | }
61 |
62 | func Role_update(id, appid, zoneid string) error {
63 | o := orm.NewOrm()
64 | o.Using("default")
65 | _, err := o.Raw("update oauth_roleid set app_id = ?,zone_id = ? where id = ?", appid, zoneid, id).Exec()
66 |
67 | if err != nil {
68 | fmt.Println(err)
69 | } else {
70 | fmt.Println("insert ok")
71 | }
72 | return err
73 | }
74 |
75 | func Role_delete(id string) error {
76 | o := orm.NewOrm()
77 | o.Using("default")
78 | _, err := o.Raw("delete from oauth_roleid where id = ?", id).Exec()
79 |
80 | if err != nil {
81 | fmt.Println(err)
82 | } else {
83 | fmt.Println("delete ok")
84 | }
85 | return err
86 | }
87 |
88 | func Zone_delete(id string) error {
89 | o := orm.NewOrm()
90 | o.Using("default")
91 | _, err := o.Raw("delete form oauth_zone where id = ?", id).Exec()
92 |
93 | if err != nil {
94 | fmt.Println(err)
95 | } else {
96 | fmt.Println("delete ok")
97 | }
98 | return err
99 | }
100 |
101 | func Zone_all() ([]Zone, error) {
102 | o := orm.NewOrm()
103 | o.Using("default")
104 | var zones []Zone
105 | _, err := o.Raw("select *from oauth_token").QueryRows(&zones)
106 |
107 | return zones, err
108 | }
109 |
110 | func Role_all() ([]Role, error) {
111 | o := orm.NewOrm()
112 | o.Using("default")
113 | var roles []Role
114 | _, err := o.Raw("select *from oauth_token").QueryRows(&roles)
115 |
116 | return roles, err
117 | }
118 |
119 | func Auth_role(app_name, appid string) (string, error) {
120 | o := orm.NewOrm()
121 | o.Using("default")
122 | var role Role
123 | err := o.Raw("select oauth_roleid.id from oauth_roleid inner join oauth_modelid on (oauth_roleid.app_id=oauth_modelid.id) where oauth_modelid.app_name=? and oauth_roleid.zone_id = (select role_id from oauth_user where appid=?)", app_name, appid).QueryRow(&role)
124 | //fmt.Println(role.Id)
125 | return role.Id, err
126 | }
127 |
--------------------------------------------------------------------------------
/controllers/apps/apps.go:
--------------------------------------------------------------------------------
1 | package apps
2 |
3 | import (
4 | "fmt"
5 | "jwt_demo/common"
6 | "jwt_demo/models"
7 |
8 | "github.com/astaxie/beego"
9 | )
10 |
11 | type AddappsController struct {
12 | beego.Controller
13 | }
14 |
15 | type ChangeappsController struct {
16 | beego.Controller
17 | }
18 |
19 | type DeleteappsController struct {
20 | beego.Controller
21 | }
22 |
23 | type ListappsController struct {
24 | beego.Controller
25 | }
26 |
27 | func (c *AddappsController) Post() {
28 | form := models.AddappsForm{}
29 | if err := c.ParseForm(&form); err != nil {
30 | beego.Debug("ParseLoginForm:", err)
31 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
32 | c.Data["json"] = user_encode.ErrInputData
33 | c.ServeJSON()
34 | return
35 | }
36 | _, err := user_encode.Token_auth(form.Token, "secret")
37 | if err != nil {
38 | c.Data["json"] = user_encode.ErrExpired
39 | c.ServeJSON()
40 | return
41 | }
42 | app, err := models.NewApp(&form)
43 | if err != nil {
44 | beego.Error("NewUser:", err)
45 | c.Data["json"] = user_encode.ErrSystem
46 | c.ServeJSON()
47 | return
48 | }
49 | beego.Debug("NewUser:", app)
50 | app.Insert()
51 | c.Data["json"] = user_encode.Actionsuccess
52 | c.ServeJSON()
53 | }
54 |
55 | func (c *ChangeappsController) Post() {
56 | form := models.ChangeappsForm{}
57 | if err := c.ParseForm(&form); err != nil {
58 | beego.Debug("ParseLoginForm:", err)
59 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
60 | c.Data["json"] = user_encode.ErrInputData
61 | c.ServeJSON()
62 | return
63 | }
64 | _, err := user_encode.Token_auth(form.Token, "secret")
65 | if err != nil {
66 | c.Data["json"] = user_encode.ErrExpired
67 | c.ServeJSON()
68 | return
69 | }
70 | fmt.Println(form.Appname)
71 | err = models.Apps_update(form.Id, form.Appname, form.Appremark)
72 | if err != nil {
73 | beego.Error("NewUser:", err)
74 | c.Data["json"] = user_encode.ErrSystem
75 | c.ServeJSON()
76 | return
77 | }
78 | c.Data["json"] = user_encode.Actionsuccess
79 | c.ServeJSON()
80 | }
81 |
82 | func (c *DeleteappsController) Post() {
83 |
84 | form := models.ChangeappsForm{}
85 | if err := c.ParseForm(&form); err != nil {
86 | beego.Debug("ParseLoginForm:", err)
87 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
88 | c.Data["json"] = user_encode.ErrInputData
89 | c.ServeJSON()
90 | return
91 | }
92 | _, err := user_encode.Token_auth(form.Token, "secret")
93 | if err != nil {
94 | c.Data["json"] = user_encode.ErrExpired
95 | c.ServeJSON()
96 | return
97 | }
98 | err = models.Apps_delete(form.Id)
99 | if err != nil {
100 | beego.Error("NewUser:", err)
101 | c.Data["json"] = user_encode.ErrSystem
102 | c.ServeJSON()
103 | return
104 | }
105 | c.Data["json"] = user_encode.Actionsuccess
106 | c.ServeJSON()
107 | }
108 |
109 | func (c *ListappsController) Get() {
110 | token := c.GetString("token")
111 | _, err := user_encode.Token_auth(token, "secret")
112 | if err != nil {
113 | c.Data["json"] = user_encode.ErrExpired
114 | c.ServeJSON()
115 | return
116 | }
117 | apps, err := models.Applist()
118 | if err == nil {
119 | c.Data["json"] = apps
120 | c.ServeJSON()
121 | } else {
122 | c.Data["json"] = user_encode.Actionsuccess
123 | c.ServeJSON()
124 | }
125 | }
126 |
--------------------------------------------------------------------------------
/controllers/user/user.go:
--------------------------------------------------------------------------------
1 | package user
2 |
3 | import (
4 | // "encoding/hex"
5 | //"strings"
6 | "jwt_demo/common"
7 | "jwt_demo/models"
8 |
9 | "github.com/astaxie/beego"
10 | )
11 |
12 | type LoginController struct {
13 | beego.Controller
14 | }
15 | type RegisterController struct {
16 | beego.Controller
17 | }
18 | type LoginoutController struct {
19 | beego.Controller
20 | }
21 | type FindpasswdController struct {
22 | beego.Controller
23 | }
24 | type ChangepasswdController struct {
25 | beego.Controller
26 | }
27 | type ChangeuserroleController struct {
28 | beego.Controller
29 | }
30 |
31 | func (c *LoginController) Post() {
32 | form := models.LoginForm{}
33 | if err := c.ParseForm(&form); err != nil {
34 | beego.Debug("ParseLoginForm:", err)
35 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
36 | c.Data["json"] = user_encode.ErrInputData
37 | c.ServeJSON()
38 | return
39 | }
40 | beego.Debug("ParseLoginForm:", &form)
41 | user := models.User{}
42 | if _, err := user.FindByID(form.Username); err != nil {
43 | beego.Error("FindUserById:", err)
44 | c.Data["json"] = user_encode.ErrNoUser
45 | c.ServeJSON()
46 | return
47 | }
48 | beego.Debug("UserInfo:", &user)
49 | if ok, err := user.CheckPass(form.Password); err != nil {
50 | beego.Error("CheckUserPass:", err)
51 | c.Data["json"] = user_encode.ErrPass
52 | c.ServeJSON()
53 | return
54 | } else if !ok {
55 | c.Data["json"] = user_encode.ErrSystem
56 | c.ServeJSON()
57 | return
58 | }
59 | c.Data["json"] = &models.LoginInfo{Code: 0, UserInfo: &user}
60 | c.ServeJSON()
61 | }
62 |
63 | func (c *RegisterController) Post() {
64 |
65 | form := models.RegisterForm{}
66 | if err := c.ParseForm(&form); err != nil {
67 | beego.Debug("errParseRegsiterForm:", err)
68 | c.Data["json"] = user_encode.ErrInputData
69 | c.ServeJSON()
70 | return
71 | }
72 | beego.Debug("ParseRegsiterForm:", &form)
73 | appid := user_encode.To_md5(form.Username)
74 | secret := user_encode.To_md5(form.Email)
75 | user, err := models.NewUser(&form, appid, secret)
76 | if err != nil {
77 | beego.Error("NewUser:", err)
78 | c.Data["json"] = user_encode.ErrSystem
79 | c.ServeJSON()
80 | return
81 | }
82 | beego.Debug("NewUser:", user)
83 | user.Insert()
84 | /*if _, err := user.Insert(); err != nil {
85 | beego.Error("InsertUser:", err)
86 | c.Data["json"] = "系统错误"
87 | c.ServeJSON()
88 | }*/
89 | c.Data["json"] = user_encode.Actionsuccess
90 | c.ServeJSON()
91 | }
92 |
93 | func (c *LoginoutController) Post() {
94 | c.Data["json"] = user_encode.Err404
95 | c.ServeJSON()
96 | }
97 |
98 | func (c *FindpasswdController) Post() {
99 |
100 | c.Data["json"] = user_encode.Err404
101 | c.ServeJSON()
102 | }
103 |
104 | func (c *ChangepasswdController) Post() {
105 |
106 | c.Data["json"] = user_encode.Err404
107 | c.ServeJSON()
108 | }
109 |
110 | func (c *ChangeuserroleController) Post() {
111 | form := models.ChangeuserroleForm{}
112 | if err := c.ParseForm(&form); err != nil {
113 | beego.Debug("ParseLoginForm:", err)
114 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
115 | c.Data["json"] = user_encode.ErrInputData
116 | c.ServeJSON()
117 | return
118 | }
119 | err := models.Update_user_role(form.Id, form.Username)
120 | if err != nil {
121 | beego.Error("NewUser:", err)
122 | c.Data["json"] = user_encode.ErrSystem
123 | c.ServeJSON()
124 | return
125 | }
126 | c.Data["json"] = user_encode.Actionsuccess
127 | c.ServeJSON()
128 | }
129 |
--------------------------------------------------------------------------------
/controllers/role/role.go:
--------------------------------------------------------------------------------
1 | package role
2 |
3 | import (
4 | "jwt_demo/common"
5 | "jwt_demo/models"
6 |
7 | "github.com/astaxie/beego"
8 | )
9 |
10 | type AddroleController struct {
11 | beego.Controller
12 | }
13 |
14 | type ChangeroleController struct {
15 | beego.Controller
16 | }
17 |
18 | type DeleteroleController struct {
19 | beego.Controller
20 | }
21 |
22 | type ListroleController struct {
23 | beego.Controller
24 | }
25 |
26 | type AddzoneController struct {
27 | beego.Controller
28 | }
29 |
30 | type DeletezoneController struct {
31 | beego.Controller
32 | }
33 |
34 | type ChangezoneController struct {
35 | beego.Controller
36 | }
37 | type ListzoneController struct {
38 | beego.Controller
39 | }
40 |
41 | func (c *AddroleController) Post() {
42 |
43 | form := models.AddroleForm{}
44 | if err := c.ParseForm(&form); err != nil {
45 | beego.Debug("ParseLoginForm:", err)
46 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
47 | c.Data["json"] = user_encode.ErrInputData
48 | c.ServeJSON()
49 | return
50 | }
51 | _, err := user_encode.Token_auth(form.Token, "secret")
52 | if err != nil {
53 | c.Data["json"] = user_encode.ErrExpired
54 | c.ServeJSON()
55 | return
56 | }
57 | err = models.Role_insert(form.Appid, form.Zoneid)
58 | if err != nil {
59 | beego.Error("NewUser:", err)
60 | c.Data["json"] = user_encode.ErrSystem
61 | c.ServeJSON()
62 | return
63 | }
64 | c.Data["json"] = user_encode.Actionsuccess
65 | c.ServeJSON()
66 | }
67 |
68 | func (c *ChangeroleController) Post() {
69 |
70 | form := models.ChangeroleForm{}
71 | if err := c.ParseForm(&form); err != nil {
72 | beego.Debug("ParseLoginForm:", err)
73 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
74 | c.Data["json"] = user_encode.ErrInputData
75 | c.ServeJSON()
76 | return
77 | }
78 | _, err := user_encode.Token_auth(form.Token, "secret")
79 | if err != nil {
80 | c.Data["json"] = user_encode.ErrExpired
81 | c.ServeJSON()
82 | return
83 | }
84 | err = models.Role_update(form.Id, form.Appid, form.Zoneid)
85 | if err != nil {
86 | beego.Error("NewUser:", err)
87 | c.Data["json"] = user_encode.ErrSystem
88 | c.ServeJSON()
89 | return
90 | }
91 | c.Data["json"] = user_encode.Actionsuccess
92 | c.ServeJSON()
93 | }
94 |
95 | func (c *DeleteroleController) Post() {
96 |
97 | form := models.DeleteroleForm{}
98 | if err := c.ParseForm(&form); err != nil {
99 | beego.Debug("ParseLoginForm:", err)
100 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
101 | c.Data["json"] = user_encode.ErrInputData
102 | c.ServeJSON()
103 | return
104 | }
105 | _, err := user_encode.Token_auth(form.Token, "secret")
106 | if err != nil {
107 | c.Data["json"] = user_encode.ErrExpired
108 | c.ServeJSON()
109 | return
110 | }
111 | err = models.Role_delete(form.Id)
112 | if err != nil {
113 | beego.Error("NewUser:", err)
114 | c.Data["json"] = user_encode.ErrSystem
115 | c.ServeJSON()
116 | return
117 | }
118 | c.Data["json"] = user_encode.Actionsuccess
119 | c.ServeJSON()
120 | }
121 |
122 | func (c *ListroleController) Get() {
123 | token := c.GetString("token")
124 | _, err := user_encode.Token_auth(token, "secret")
125 | if err != nil {
126 | c.Data["json"] = user_encode.ErrExpired
127 | c.ServeJSON()
128 | return
129 | }
130 | roles, err := models.Role_all()
131 | if err == nil {
132 | c.Data["json"] = roles
133 | c.ServeJSON()
134 | } else {
135 | c.Data["json"] = user_encode.Err404
136 | c.ServeJSON()
137 | }
138 | }
139 |
140 | func (c *AddzoneController) Post() {
141 |
142 | form := models.AddzoneForm{}
143 | if err := c.ParseForm(&form); err != nil {
144 | beego.Debug("ParseLoginForm:", err)
145 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
146 | c.Data["json"] = user_encode.ErrInputData
147 | c.ServeJSON()
148 | return
149 | }
150 | _, err := user_encode.Token_auth(form.Token, "secret")
151 | if err != nil {
152 | c.Data["json"] = user_encode.ErrExpired
153 | c.ServeJSON()
154 | return
155 | }
156 | err = models.Zone_insert(form.Zonename, form.Zoneremark)
157 | if err != nil {
158 | beego.Error("NewUser:", err)
159 | c.Data["json"] = user_encode.ErrSystem
160 | c.ServeJSON()
161 | return
162 | }
163 | c.Data["json"] = user_encode.Actionsuccess
164 | c.ServeJSON()
165 | }
166 |
167 | func (c *ChangezoneController) Post() {
168 | form := models.ChangezoneForm{}
169 | if err := c.ParseForm(&form); err != nil {
170 | beego.Debug("ParseLoginForm:", err)
171 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
172 | c.Data["json"] = user_encode.ErrInputData
173 | c.ServeJSON()
174 | return
175 | }
176 | _, err := user_encode.Token_auth(form.Token, "secret")
177 | if err != nil {
178 | c.Data["json"] = user_encode.ErrExpired
179 | c.ServeJSON()
180 | return
181 | }
182 | err = models.Zone_update(form.Id, form.Zonename, form.Zoneremark)
183 | if err != nil {
184 | beego.Error("NewUser:", err)
185 | c.Data["json"] = user_encode.ErrSystem
186 | c.ServeJSON()
187 | return
188 | }
189 | c.Data["json"] = user_encode.Actionsuccess
190 | c.ServeJSON()
191 | }
192 |
193 | func (c *DeletezoneController) Post() {
194 |
195 | form := models.DeletezoneForm{}
196 | if err := c.ParseForm(&form); err != nil {
197 | beego.Debug("ParseLoginForm:", err)
198 | //c.Data["json"] = common.NewErrorInfo(ErrInputData)
199 | c.Data["json"] = user_encode.ErrInputData
200 | c.ServeJSON()
201 | return
202 | }
203 | _, err := user_encode.Token_auth(form.Token, "secret")
204 | if err != nil {
205 | c.Data["json"] = user_encode.ErrExpired
206 | c.ServeJSON()
207 | return
208 | }
209 | err = models.Zone_delete(form.Id)
210 | if err != nil {
211 | beego.Error("NewUser:", err)
212 | c.Data["json"] = user_encode.ErrSystem
213 | c.ServeJSON()
214 | return
215 | }
216 | c.Data["json"] = user_encode.Actionsuccess
217 | c.ServeJSON()
218 | }
219 |
220 | func (c *ListzoneController) Get() {
221 | token := c.GetString("token")
222 | _, err := user_encode.Token_auth(token, "secret")
223 | if err != nil {
224 | c.Data["json"] = user_encode.ErrExpired
225 | c.ServeJSON()
226 | return
227 | }
228 | zones, err := models.Zone_all()
229 | if err == nil {
230 | c.Data["json"] = zones
231 | c.ServeJSON()
232 | } else {
233 | c.Data["json"] = user_encode.Err404
234 | c.ServeJSON()
235 | }
236 | }
237 |
--------------------------------------------------------------------------------
/views/index.tpl:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Beego
6 |
7 |
8 |
9 |
74 |
75 |
76 |
77 |
83 |
91 |
92 |
93 |
94 |
--------------------------------------------------------------------------------