认证校验修改

@@ -3,6 +3,7 @@ package common
 import (
 import (
 	"oppmg/common/config"
 	"oppmg/common/config"
 	"oppmg/common/log"
 	"oppmg/common/log"
+	"oppmg/common/redis"
 
 
 	"github.com/astaxie/beego"
 	"github.com/astaxie/beego"
 )
 )
@@ -26,4 +27,5 @@ func ResetCommonConfig() {
 		logCallfunc = true
 		logCallfunc = true
 	}
 	}
 	log.ResetLog(setlog, logCallfunc)
 	log.ResetLog(setlog, logCallfunc)
+	redis.SetRedis(mconfig.RedisAddPort, mconfig.RedisAuth, mconfig.RedisDB)
 }
 }

@@ -12,7 +12,7 @@ type MyConfig struct {
 	SqlConn      string //数据库连接
 	SqlConn      string //数据库连接
 	RedisAddPort string //
 	RedisAddPort string //
 	RedisAuth    string
 	RedisAuth    string
-	RedisDB      string
+	RedisDB      int
 	LogOutput    string
 	LogOutput    string
 	LogFilename  string
 	LogFilename  string
 	LogLevel     string
 	LogLevel     string
@@ -35,7 +35,7 @@ func RestMyConfig() *MyConfig {
 		SqlConn:      sqlconn,
 		SqlConn:      sqlconn,
 		RedisAddPort: beego.AppConfig.String("redis_add_port"),
 		RedisAddPort: beego.AppConfig.String("redis_add_port"),
 		RedisAuth:    beego.AppConfig.DefaultString("redis_auth", ""),
 		RedisAuth:    beego.AppConfig.DefaultString("redis_auth", ""),
-		RedisDB:      beego.AppConfig.DefaultString("redis_db", "0"),
+		RedisDB:      beego.AppConfig.DefaultInt("redis_db", 0),
 		LogOutput:    beego.AppConfig.DefaultString("log_output", "console"),
 		LogOutput:    beego.AppConfig.DefaultString("log_output", "console"),
 		LogFilename:  beego.AppConfig.DefaultString("log_filename", "./log/ability.log"),
 		LogFilename:  beego.AppConfig.DefaultString("log_filename", "./log/ability.log"),
 		LogLevel:     beego.AppConfig.DefaultString("log_Level", "debug"),
 		LogLevel:     beego.AppConfig.DefaultString("log_Level", "debug"),

@@ -2,12 +2,9 @@ package controllers
 
 
 import (
 import (
 	"encoding/json"
 	"encoding/json"
-	"fmt"
 	"oppmg/common/log"
 	"oppmg/common/log"
 	"oppmg/protocol"
 	"oppmg/protocol"
-	"oppmg/services/auth"
-
-	"github.com/astaxie/beego/validation"
+	serveauth "oppmg/services/auth"
 )
 )
 
 
 type AuthController struct {
 type AuthController struct {
@@ -16,55 +13,53 @@ type AuthController struct {
 
 
 //URLMapping 实现ControllerInterface中的URLMapping
 //URLMapping 实现ControllerInterface中的URLMapping
 func (c *AuthController) URLMapping() {
 func (c *AuthController) URLMapping() {
-	c.Mapping("AccessToken", c.AccessToken)
 
 
 }
 }
 
 
-// AccessToken ....
-// @router /AccessToken [post]
-func (c *AuthController) AccessToken() {
+// RefreshToken ....
+// @router /refresh_token [get]
+func (c *AuthController) RefreshToken() {
 	log.Debug("运行cotrollers")
 	log.Debug("运行cotrollers")
 	var msg *protocol.ResponseMessage
 	var msg *protocol.ResponseMessage
 	defer func() {
 	defer func() {
 		c.ResposeJson(msg)
 		c.ResposeJson(msg)
 	}()
 	}()
-	var param protocol.RequestCheckSmsCode
-	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
-		log.Error("json 解析失败", err)
-		msg = protocol.BadRequestParam("00001")
-		return
-	}
-	valid := validation.Validation{}
-	ok, err := valid.Valid(&param)
-	if err != nil {
-		//TODO
-		log.Error("系统错误", err)
-	}
-	if !ok {
-		//TODO
-		log.Error("参数错误")
-	}
-	data, commErr := auth.GetAccessToken(param)
-	msg = protocol.NewReturnResponse(data, commErr)
+
+	// data, commErr := auth.GetAccessToken(param)
+	// msg = protocol.NewReturnResponse(data, commErr)
 	return
 	return
 }
 }
 
 
-// Demo 登录
-// @router /demo [post]
-func (c *AuthController) Demo() {
+// Login 登录
+// @router /login [post]
+func (c *AuthController) Login() {
 	var msg *protocol.ResponseMessage
 	var msg *protocol.ResponseMessage
 	defer func() {
 	defer func() {
 		c.ResposeJson(msg)
 		c.ResposeJson(msg)
 	}()
 	}()
-	type Parameter struct {
-	}
-	var param Parameter
+
+	var param protocol.RequestLogin
 	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
 	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
-		fmt.Println("json 解析失败", err)
-		// msg.Code = "1"
+		log.Error("json 解析失败", err)
+		msg = protocol.BadRequestParam("1")
 		return
 		return
 	}
 	}
-	/**/
-
+	if len(param.Account) == 0 || len(param.Password) == 0 {
+		msg = protocol.BadRequestParam("10021")
+		return
+	}
+	logintoken, err := serveauth.LoginAuthByPassword(param.Account, param.Password)
+	if err != nil {
+		msg = protocol.NewReturnResponse(nil, err)
+		return
+	}
+	err = serveauth.ResetLoginToken(logintoken)
+	msg = protocol.NewReturnResponse(logintoken, err)
 	return
 	return
 }
 }
+
+//ChangeCompany 切换公司
+//@Router /change_company [post]
+func (c *AuthController) ChangeCompany() {
+
+}

@@ -3,7 +3,7 @@ module oppmg
 go 1.13
 go 1.13
 
 
 require (
 require (
-	github.com/astaxie/beego v1.10.0
+	github.com/astaxie/beego v1.11.1
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/go-redis/redis v6.15.6+incompatible
 	github.com/go-redis/redis v6.15.6+incompatible
 	github.com/go-sql-driver/mysql v1.4.1
 	github.com/go-sql-driver/mysql v1.4.1

@@ -2,10 +2,13 @@ github.com/Knetic/govaluate v3.0.0+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8L
 github.com/OwnLocal/goes v1.0.0/go.mod h1:8rIFjBGTue3lCU0wplczcUgt9Gxgrkkrw7etMIcn8TM=
 github.com/OwnLocal/goes v1.0.0/go.mod h1:8rIFjBGTue3lCU0wplczcUgt9Gxgrkkrw7etMIcn8TM=
 github.com/astaxie/beego v1.10.0 h1:s0OZ1iUO0rl8+lwWZfPK/0GhQi1tFUcIClTevyz48Pg=
 github.com/astaxie/beego v1.10.0 h1:s0OZ1iUO0rl8+lwWZfPK/0GhQi1tFUcIClTevyz48Pg=
 github.com/astaxie/beego v1.10.0/go.mod h1:0R4++1tUqERR0WYFWdfkcrsyoVBCG4DgpDGokT3yb+U=
 github.com/astaxie/beego v1.10.0/go.mod h1:0R4++1tUqERR0WYFWdfkcrsyoVBCG4DgpDGokT3yb+U=
+github.com/astaxie/beego v1.11.1 h1:6DESefxW5oMcRLFRKi53/6exzup/IR6N4EzzS1n6CnQ=
+github.com/astaxie/beego v1.11.1/go.mod h1:i69hVzgauOPSw5qeyF4GVZhn7Od0yG5bbCGzmhbWxgQ=
 github.com/astaxie/beego v1.12.0 h1:MRhVoeeye5N+Flul5PoVfD9CslfdoH+xqC/xvSQ5u2Y=
 github.com/astaxie/beego v1.12.0 h1:MRhVoeeye5N+Flul5PoVfD9CslfdoH+xqC/xvSQ5u2Y=
 github.com/astaxie/beego v1.12.0/go.mod h1:fysx+LZNZKnvh4GED/xND7jWtjCR6HzydR2Hh2Im57o=
 github.com/astaxie/beego v1.12.0/go.mod h1:fysx+LZNZKnvh4GED/xND7jWtjCR6HzydR2Hh2Im57o=
 github.com/beego/goyaml2 v0.0.0-20130207012346-5545475820dd/go.mod h1:1b+Y/CofkYwXMUU0OhQqGvsY2Bvgr4j6jfT699wyZKQ=
 github.com/beego/goyaml2 v0.0.0-20130207012346-5545475820dd/go.mod h1:1b+Y/CofkYwXMUU0OhQqGvsY2Bvgr4j6jfT699wyZKQ=
 github.com/beego/x2j v0.0.0-20131220205130-a0352aadc542/go.mod h1:kSeGC/p1AbBiEp5kat81+DSQrZenVBZXklMLaELspWU=
 github.com/beego/x2j v0.0.0-20131220205130-a0352aadc542/go.mod h1:kSeGC/p1AbBiEp5kat81+DSQrZenVBZXklMLaELspWU=
+github.com/belogik/goes v0.0.0-20151229125003-e54d722c3aff/go.mod h1:PhH1ZhyCzHKt4uAasyx+ljRCgoezetRNf59CUtwUkqY=
 github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60=
 github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60=
 github.com/casbin/casbin v1.7.0/go.mod h1:c67qKN6Oum3UF5Q1+BByfFxkwKvhwW57ITjqwtzR1KE=
 github.com/casbin/casbin v1.7.0/go.mod h1:c67qKN6Oum3UF5Q1+BByfFxkwKvhwW57ITjqwtzR1KE=
 github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58/go.mod h1:EOBUe0h4xcZ5GoxqC5SDxFQ8gwyZPKQoEzownBlhI80=
 github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58/go.mod h1:EOBUe0h4xcZ5GoxqC5SDxFQ8gwyZPKQoEzownBlhI80=

 package middleware
 package middleware
 
 
 import (
 import (
-	"crypto/sha256"
-	"encoding/hex"
 	"fmt"
 	"fmt"
 	"oppmg/common/log"
 	"oppmg/common/log"
 	"oppmg/protocol"
 	"oppmg/protocol"
-	"strings"
+	serveauth "oppmg/services/auth"
+	"oppmg/storage/redisdata"
 
 
 	"github.com/astaxie/beego/plugins/cors"
 	"github.com/astaxie/beego/plugins/cors"
 
 
@@ -24,34 +23,86 @@ var LogRequestData = func(ctx *context.Context) {
 }
 }
 
 
 //CheckSign Before Router
 //CheckSign Before Router
-var CheckSign = func(ctx *context.Context) {
+// var CheckSign = func(ctx *context.Context) {
+// 	var (
+// 		headTimeStamp   string
+// 		headUuid        string
+// 		headAccessToken string
+// 		headSign        string
+// 		signHex         string
+// 	)
+// 	headTimeStamp = ctx.Input.Header(protocol.HeaderTimestamp)
+// 	headUuid = ctx.Input.Header(protocol.HeaderUUID)
+// 	headSign = ctx.Input.Header(protocol.HeaderSign)
+// 	setsign := fmt.Sprintf("v!(MmM%v%v%vMmM)i^", headTimeStamp, headUuid, headAccessToken)
+// 	sha256 := sha256.New()
+// 	sha256.Write([]byte(setsign))
+// 	signHex = hex.EncodeToString(sha256.Sum(nil))
+// 	if strings.Compare(signHex, headSign) != 0 {
+// 		msg := protocol.BadRequestParam("113")
+// 		ctx.Output.JSON(msg, false, false)
+// 		return
+// 	}
+// 	return
+// }
+
+//AuthToken Before Router
+var AuthToken = func(ctx *context.Context) {
+	log.Debug("执行中间件AuthToken")
 	var (
 	var (
-		headTimeStamp   string
-		headUuid        string
-		headAccessToken string
-		headSign        string
-		signHex         string
+		storetoken protocol.LoginAuthToken
+		msg        *protocol.ResponseMessage
+		err        error
+		mtoken     *serveauth.MyToken
 	)
 	)
-	headTimeStamp = ctx.Input.Header(protocol.HeaderTimestamp)
-	headUuid = ctx.Input.Header(protocol.HeaderUUID)
-	headSign = ctx.Input.Header(protocol.HeaderSign)
-	setsign := fmt.Sprintf("v!(MmM%v%v%vMmM)i^", headTimeStamp, headUuid, headAccessToken)
-	sha256 := sha256.New()
-	sha256.Write([]byte(setsign))
-	signHex = hex.EncodeToString(sha256.Sum(nil))
-	if strings.Compare(signHex, headSign) != 0 {
-		msg := protocol.BadRequestParam("113")
+	accesstoken := ctx.Input.Header(protocol.HeaderAccessToken)
+	refreshToken := ctx.Input.Header(protocol.HeaderRefreshToken)
+	mtoken, err = serveauth.ValidJWTToken(accesstoken)
+	if err == nil {
+		storetoken, err = redisdata.GetLoginToken(mtoken.UID)
+		if err != nil {
+			log.Error("err:%s", err)
+			msg = protocol.NewMesage("10024")
+			ctx.Output.JSON(msg, false, false)
+			return
+		}
+		if storetoken.AccessToken != accesstoken {
+			msg = protocol.NewMesage("10025")
+			ctx.Output.JSON(msg, false, false)
+			return
+		}
+		ctx.Input.SetData(protocol.HeaderCompanyid, mtoken.CompanyID)
+		ctx.Input.SetData(protocol.HeaderUserid, mtoken.UID)
+		return
+	}
+	if ok := serveauth.IsJwtErrorExpired(err); ok {
+		//token过期
+		mtoken, err = serveauth.ValidJWTToken(refreshToken)
+		if err != nil {
+			msg = protocol.NewMesage("10024")
+			ctx.Output.JSON(msg, false, false)
+			return
+		}
+		storetoken, err = redisdata.GetLoginToken(mtoken.UID)
+		if err != nil {
+			log.Error("err:%s", err)
+			msg = protocol.NewMesage("10024")
+			ctx.Output.JSON(msg, false, false)
+			return
+		}
+		if storetoken.AccessToken != accesstoken {
+			msg = protocol.NewMesage("10025")
+			ctx.Output.JSON(msg, false, false)
+			return
+		}
+		logintoken, _ := serveauth.GenerateAuthToken(mtoken.UID, mtoken.CompanyID)
+		serveauth.ResetLoginTokenRedis(logintoken)
+		msg = protocol.NewReturnResponse(logintoken, nil)
 		ctx.Output.JSON(msg, false, false)
 		ctx.Output.JSON(msg, false, false)
 		return
 		return
 	}
 	}
-	return
-}
-
-//AuthToken Before Router
-var AuthToken = func(ctx *context.Context) {
-	log.Debug("执行中间件AuthToken")
-
-	// ctx.Output.Body([]byte("{}"))
+	msg = protocol.NewMesage("10024")
+	ctx.Output.JSON(msg, false, false)
 	return
 	return
 }
 }
 
 

@@ -2,6 +2,7 @@ package models
 
 
 import (
 import (
 	"fmt"
 	"fmt"
+	"oppmg/common/log"
 	"time"
 	"time"
 
 
 	"github.com/astaxie/beego/orm"
 	"github.com/astaxie/beego/orm"
@@ -40,13 +41,6 @@ const (
 	DEVICE_TYPE_WEB
 	DEVICE_TYPE_WEB
 )
 )
 
 
-//过期时长设置，单位：秒
-const (
-	REFRESH_TIME  int64 = 60 * 60 * 4 //4小时
-	ACCESS_TIME   int64 = 60 * 60 * 2 //2小时
-	AUTHCODE_TIME int64 = 60 * 60 * 2 //2小时
-)
-
 // AddUserAuth insert a new UserAuth into database and returns
 // AddUserAuth insert a new UserAuth into database and returns
 // last inserted Id on success.
 // last inserted Id on success.
 func AddUserAuth(m *UserAuth) (id int64, err error) {
 func AddUserAuth(m *UserAuth) (id int64, err error) {
@@ -68,15 +62,12 @@ func GetUserAuthById(id int64) (v *UserAuth, err error) {
 
 
 // UpdateUserAuth updates UserAuth by Id and returns error if
 // UpdateUserAuth updates UserAuth by Id and returns error if
 // the record to be updated doesn't exist
 // the record to be updated doesn't exist
-func UpdateUserAuthById(m *UserAuth) (err error) {
+func UpdateUserAuthById(m *UserAuth, col []string) (err error) {
 	o := orm.NewOrm()
 	o := orm.NewOrm()
-	v := UserAuth{Id: m.Id}
 	// ascertain id exists in the database
 	// ascertain id exists in the database
-	if err = o.Read(&v); err == nil {
-		var num int64
-		if num, err = o.Update(m); err == nil {
-			fmt.Println("Number of records updated in database:", num)
-		}
+	var num int64
+	if num, err = o.Update(m, col...); err == nil {
+		log.Info("Number of records updated in database:", num)
 	}
 	}
 	return
 	return
 }
 }

@@ -4,12 +4,18 @@ package protocol
 const (
 const (
 	HeaderAccessToken  string = "x-mmm-accesstoken"
 	HeaderAccessToken  string = "x-mmm-accesstoken"
 	HeaderRefreshToken string = "x-mmm-refreshtoken"
 	HeaderRefreshToken string = "x-mmm-refreshtoken"
-	HeaderUID          string = "x-mmm-uid"
-	HeaderUUID         string = "x-mmm-uuid"
-	HeaderTimestamp    string = "x-mmm-timestamp"
-	HeaderDevicetype   string = "x-mmm-devicetype"
-	HeaderAppproject   string = "x-mmm-appproject"
-	HeaderSign         string = "x-mmm-sign"
+	// HeaderUID          string = "x-mmm-uid"
+	// HeaderUUID         string = "x-mmm-uuid"
+	// HeaderTimestamp    string = "x-mmm-timestamp"
+	// HeaderDevicetype   string = "x-mmm-devicetype"
+	// HeaderAppproject   string = "x-mmm-appproject"
+	// HeaderSign         string = "x-mmm-sign"
+)
+
+//用来存储从token中解析出来的内容对应的键名
+const (
+	HeaderCompanyid string = "header_companyid"
+	HeaderUserid    string = "header_userid"
 )
 )
 
 
 //BaseHeader 请求的header数据
 //BaseHeader 请求的header数据

@@ -16,4 +16,8 @@ var errmessge ErrorMap = map[string]string{
 	//安全认证相关
 	//安全认证相关
 	"10021": "账号或密码不正确",
 	"10021": "账号或密码不正确",
 	"10022": "账号已被禁用",
 	"10022": "账号已被禁用",
+	"10023": "用户无使用权限",
+	"10024": "登录凭证失效",
+	"10025": "该账号已在其他地方登录",
+	"10026": "登录凭证过期",
 }
 }

@@ -11,7 +11,7 @@ import (
 func init() {
 func init() {
 	nsV1 := beego.NewNamespace("v1",
 	nsV1 := beego.NewNamespace("v1",
 		beego.NSBefore(middleware.AllowOption),
 		beego.NSBefore(middleware.AllowOption),
-		beego.NSBefore(middleware.LogRequestData, middleware.AuthToken),
+		beego.NSBefore(middleware.LogRequestData),
 		beego.NSNamespace("/company",
 		beego.NSNamespace("/company",
 			beego.NSRouter("/:companyid([0-9]+)/department", &controllers.CompanyController{}, "get:DepartmentList"),
 			beego.NSRouter("/:companyid([0-9]+)/department", &controllers.CompanyController{}, "get:DepartmentList"),
 			beego.NSRouter("/department/:id([0-9]+)", &controllers.CompanyController{}, "get:DepartmentOne"),
 			beego.NSRouter("/department/:id([0-9]+)", &controllers.CompanyController{}, "get:DepartmentOne"),
@@ -32,12 +32,17 @@ func init() {
 			beego.NSRouter("/role_group", &controllers.RbacController{}, "delete:RoleGroupDelete"),
 			beego.NSRouter("/role_group", &controllers.RbacController{}, "delete:RoleGroupDelete"),
 			beego.NSRouter("/:companyid([0-9]+)/role", &controllers.RbacController{}, "get:RoleList"),
 			beego.NSRouter("/:companyid([0-9]+)/role", &controllers.RbacController{}, "get:RoleList"),
 		),
 		),
-		beego.NSAfter(middleware.LogRouter),
 	)
 	)
 
 
 	nsAuth := beego.NewNamespace("/auth",
 	nsAuth := beego.NewNamespace("/auth",
-		beego.NSBefore(middleware.LogRequestData, middleware.AuthToken),
-		beego.NSRouter("/accessToken", &controllers.AuthController{}, "post:AccessToken"),
+		beego.NSBefore(middleware.AllowOption),
+		beego.NSBefore(middleware.LogRequestData),
+		beego.NSRouter("/login", &controllers.AuthController{}, "post:Login"),
+		beego.NSNamespace("/token",
+			beego.NSBefore(middleware.AuthToken),
+			beego.NSRouter("/change_company", &controllers.AuthController{}, "post:ChangeCompany"),
+			beego.NSRouter("/refresh_token", &controllers.AuthController{}, "post:RefreshToken"),
+		),
 	)
 	)
 	beego.AddNamespace(nsV1)
 	beego.AddNamespace(nsV1)
 	beego.AddNamespace(nsAuth)
 	beego.AddNamespace(nsAuth)

@@ -9,6 +9,7 @@ import (
 	"oppmg/common/log"
 	"oppmg/common/log"
 	"oppmg/models"
 	"oppmg/models"
 	"oppmg/protocol"
 	"oppmg/protocol"
+	"oppmg/storage/redisdata"
 	"strings"
 	"strings"
 	"time"
 	"time"
 
 
@@ -38,10 +39,9 @@ func validatePassword(from, to string) bool {
 }
 }
 
 
 //LoginAuth 登录认证
 //LoginAuth 登录认证
-func LoginAuthByPassword(account, password string) error {
+func LoginAuthByPassword(account, password string) (protocol.LoginAuthToken, error) {
 	var (
 	var (
 		user       *models.User
 		user       *models.User
-		uAuth      *models.UserAuth
 		companys   []models.Company
 		companys   []models.Company
 		mcompany   models.Company
 		mcompany   models.Company
 		loginToken protocol.LoginAuthToken
 		loginToken protocol.LoginAuthToken
@@ -50,82 +50,56 @@ func LoginAuthByPassword(account, password string) error {
 	user, err = models.GetUserByPhone(account)
 	user, err = models.GetUserByPhone(account)
 	if err != nil {
 	if err != nil {
 		log.Error(err.Error())
 		log.Error(err.Error())
-		return protocol.NewErrWithMessage("10021", err)
+		return loginToken, protocol.NewErrWithMessage("10021", err)
 	}
 	}
 	if ok := validatePassword(password, user.Passwd); !ok {
 	if ok := validatePassword(password, user.Passwd); !ok {
-		return protocol.NewErrWithMessage("10021", err)
+		return loginToken, protocol.NewErrWithMessage("10021", err)
 	}
 	}
 	if ok := user.IsEnable(); !ok {
 	if ok := user.IsEnable(); !ok {
-		return protocol.NewErrWithMessage("10022")
+		return loginToken, protocol.NewErrWithMessage("10022")
 	}
 	}
 	companys, err = models.GetCompanyByUser(user.Id)
 	companys, err = models.GetCompanyByUser(user.Id)
 	if err != nil {
 	if err != nil {
 		e := fmt.Errorf("GetCompanyByUser(%d) err:%s", user.Id, err)
 		e := fmt.Errorf("GetCompanyByUser(%d) err:%s", user.Id, err)
 		log.Error(e.Error())
 		log.Error(e.Error())
-		return protocol.NewErrWithMessage("1")
+		return loginToken, protocol.NewErrWithMessage("1")
 	}
 	}
 	if len(companys) <= 0 {
 	if len(companys) <= 0 {
 		log.Error("can not found company")
 		log.Error("can not found company")
-		return protocol.NewErrWithMessage("1")
+		return loginToken, protocol.NewErrWithMessage("1")
 	}
 	}
 	mcompany = companys[0]
 	mcompany = companys[0]
 	loginToken, err = GenerateAuthToken(user.Id, mcompany.Id)
 	loginToken, err = GenerateAuthToken(user.Id, mcompany.Id)
 	if err != nil {
 	if err != nil {
 		e := fmt.Errorf("GenerateAuthToken err:%s", err)
 		e := fmt.Errorf("GenerateAuthToken err:%s", err)
 		log.Error(e.Error())
 		log.Error(e.Error())
-		return protocol.NewErrWithMessage("1")
+		return loginToken, protocol.NewErrWithMessage("1")
 	}
 	}
-	// uAuth, err = models.ReadUserAuthByDevice(user.Id, models.DEVICE_TYPE_WEB)
-	// if err != nil && err != orm.ErrNoRows {
-	// 	e := fmt.Errorf("ReadUserAuthByDevice(%d,%d) err:%s", user.Id, models.DEVICE_TYPE_WEB, err)
-	// 	log.Error(e.Error())
-	// 	return protocol.NewErrWithMessage("1", e)
-	// }
-	// var (
-	// 	authcode    string
-	// 	authcodeExp time.Time
-	// )
-	// authcode = utils.GenerateIDByUUID()
-	// authcodeExp = time.Now().Add(time.Duration(models.AUTHCODE_TIME) * time.Second)
-	// if err == orm.ErrNoRows {
-	// 	uAuth := &models.UserAuth{
-	// 		UserId:      user.Id,
-	// 		AuthCode:    authcode,
-	// 		AuthCodeExp: authcodeExp,
-	// 		CreateAt:    time.Now(),
-	// 	}
-	// 	_, err = models.AddUserAuth(uAuth)
-	// 	if err != nil {
-	// 		e := fmt.Errorf("AddUserAuth err:%s", err)
-	// 		log.Error(e.Error())
-	// 		return protocol.NewErrWithMessage("1", e)
-	// 	}
-	// }
-	// if err == nil {
-	// 	uAuth.AuthCode = authcode
-	// 	uAuth.AuthCodeExp = authcodeExp
-	// 	uAuth.UpdateAt = time.Now()
-	// 	err = models.UpdateUserAuthById(uAuth)
-	// 	if err != nil {
-	// 		e := fmt.Errorf("UpdateUserAuthById err:%s", err)
-	// 		log.Error(e.Error())
-	// 		return protocol.NewErrWithMessage("1", e)
-	// 	}
-	// }
-
-	return nil
+	return loginToken, nil
 }
 }
 
 
 //ResetLoginToken token存数据库
 //ResetLoginToken token存数据库
-func ResetLoginToken(loginToken protocol.LoginAuthToken, userid int64, companyid int64) error {
+func ResetLoginToken(loginToken protocol.LoginAuthToken) error {
 	var (
 	var (
-		uAuth   *models.UserAuth
-		err     error
-		nowTime = time.Now()
+		uAuth     *models.UserAuth
+		err       error
+		nowTime   = time.Now()
+		userid    int64
+		companyid int64
+		mtoken    *MyToken
 	)
 	)
+	mtoken, err = ValidJWTToken(loginToken.AccessToken)
+	if err != nil {
+		log.Error("jwt err:%s", err)
+		return protocol.NewErrWithMessage("1")
+	}
+	userid = mtoken.UID
+	companyid = mtoken.CompanyID
 	uAuth, err = models.GetUserAuthByUser(userid)
 	uAuth, err = models.GetUserAuthByUser(userid)
 	if err != nil && err != orm.ErrNoRows {
 	if err != nil && err != orm.ErrNoRows {
-		return err
+		e := fmt.Errorf("GetUserAuthByUser err:%s", err)
+		log.Error(e.Error())
+		return protocol.NewErrWithMessage("1", e)
 	}
 	}
 	if err == orm.ErrNoRows {
 	if err == orm.ErrNoRows {
 		//添加用户授权
 		//添加用户授权
@@ -141,11 +115,43 @@ func ResetLoginToken(loginToken protocol.LoginAuthToken, userid int64, companyid
 			DeviceType:       models.DEVICE_TYPE_WEB,
 			DeviceType:       models.DEVICE_TYPE_WEB,
 		}
 		}
 		_, err = models.AddUserAuth(uAuth)
 		_, err = models.AddUserAuth(uAuth)
-		return err
+		if err != nil {
+			e := fmt.Errorf("AddUserAuth err:%s", err)
+			log.Error(e.Error())
+			return protocol.NewErrWithMessage("1", e)
+		}
 	}
 	}
 	//更新用户授权
 	//更新用户授权
-
+	uAuth.CurrentCompanyId = companyid
+	uAuth.AccessToken = loginToken.AccessToken
+	uAuth.AccessTokenExp = time.Unix(loginToken.ExpiresIn, 0)
+	uAuth.RefreshToken = loginToken.RefreshToken
+	uAuth.RefreshTokenExp = time.Unix(loginToken.RefreshExpires, 0)
+	uAuth.UpdateAt = nowTime
+	upCol := []string{"CurrentCompanyId", "AccessToken", "RefreshToken", "RefreshTokenExp", "UpdateAt"}
+	if err = models.UpdateUserAuthById(uAuth, upCol); err != nil {
+		e := fmt.Errorf("UpdateUserAuthById err:%s", err)
+		log.Error(e.Error())
+		return protocol.NewErrWithMessage("1", e)
+	}
 	return nil
 	return nil
 }
 }
 
 
-//TODO token 存redis
+// token 存redis
+func ResetLoginTokenRedis(loginToken protocol.LoginAuthToken) error {
+	var (
+		mtoken *MyToken
+		err    error
+	)
+	mtoken, err = ValidJWTToken(loginToken.AccessToken)
+	if err != nil {
+		log.Error("jwt err:%s", err)
+		return protocol.NewErrWithMessage("1")
+	}
+	err = redisdata.SetLoginToken(loginToken, mtoken.UID)
+	if err != nil {
+		log.Error(" redisdata.SetLoginToken err:%s", err)
+	}
+	return nil
+
+}

@@ -56,6 +56,14 @@ func ValidJWTToken(tokenString string) (*MyToken, error) {
 	return nil, fmt.Errorf("token Valid fail")
 	return nil, fmt.Errorf("token Valid fail")
 }
 }
 
 
+func IsJwtErrorExpired(err error) bool {
+	ve, ok := err.(*jwt.ValidationError)
+	if ok && ve.Errors == jwt.ValidationErrorExpired {
+		return true
+	}
+	return false
+}
+
 func GenerateAuthToken(uid int64, companyid int64) (protocol.LoginAuthToken, error) {
 func GenerateAuthToken(uid int64, companyid int64) (protocol.LoginAuthToken, error) {
 	var (
 	var (
 		authToken      protocol.LoginAuthToken
 		authToken      protocol.LoginAuthToken
@@ -66,11 +74,11 @@ func GenerateAuthToken(uid int64, companyid int64) (protocol.LoginAuthToken, err
 		err            error
 		err            error
 		nowtime        = time.Now()
 		nowtime        = time.Now()
 	)
 	)
-	accesstoken, err = CreateJWTToken(uid, companyid, expiresIn+10)
+	accesstoken, err = CreateJWTToken(uid, companyid, expiresIn+2)
 	if err != nil {
 	if err != nil {
 		return authToken, err
 		return authToken, err
 	}
 	}
-	refreshtoken, err = CreateJWTToken(uid, companyid, refreshExpires+10)
+	refreshtoken, err = CreateJWTToken(uid, companyid, refreshExpires+2)
 	if err != nil {
 	if err != nil {
 		return authToken, err
 		return authToken, err
 	}
 	}

+package ucenter
+
+import (
+	"encoding/json"
+	"errors"
+)
+
+type RequesLogin struct {
+	Password string `json:"password"`
+	Phone    string `json:"phone"`
+}
+
+//Format 实现IUCenterParam接口
+func (r RequesLogin) Format() []byte {
+	var v []byte
+	v, _ = json.Marshal(r)
+	return v
+}
+
+//Format 实现IUCenterParam接口
+func (r RequesLogin) GetPath() (string, string) {
+	return "/auth/login", "POST"
+}
+
+//Format 实现IUCenterParam接口
+func (r RequesLogin) Valid() error {
+	if len(r.Password) == 0 {
+		return errors.New("len(r.Password) == 0")
+	}
+	if len(r.Phone) == 0 {
+		return errors.New("len(r.Phone == 0")
+	}
+	return nil
+}
+
+type RequestAddUser struct {
+	Phone    string `json:"phone"`
+	RegIm    bool   `json:"regIm"`
+	Nickname string `json:"nickname"`
+	Avatar   string `json:"avatar"`
+	Password string `json:"password"`
+}
+
+//Format 实现IUCenterParam接口
+func (r RequestAddUser) Format() []byte {
+	var v []byte
+	v, _ = json.Marshal(r)
+	return v
+}
+
+//Format 实现IUCenterParam接口
+func (r RequestAddUser) GetPath() (string, string) {
+	return "/users", "POST"
+}
+
+//Format 实现IUCenterParam接口
+func (r RequestAddUser) Valid() error {
+	if len(r.Password) == 0 {
+		return errors.New("len(r.Password) == 0")
+	}
+	if len(r.Phone) == 0 {
+		return errors.New("len(r.Phone == 0")
+	}
+	return nil
+}

+package ucenter
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"time"
+)
+
+type IUCenterParam interface {
+	Format() []byte
+	GetPath() (string, string) //返回请求路径path，请求方式mathod
+	Valid() error
+}
+
+type UCenterClient struct {
+	appKey  string
+	baseUrl string
+}
+
+func (client UCenterClient) buildHeader() http.Header {
+	var h = http.Header{}
+	h.Set("Content-Type", "application/json")
+	h.Set("appKey", client.appKey)
+	return h
+}
+
+//httpDo post发送json
+func (client UCenterClient) httpDo(path string, mathod string, posts []byte) ([]byte, error) {
+	httpclient := http.Client{
+		Timeout: 5 * time.Second, //请求超时时间5秒
+	}
+	reqURL := client.baseUrl + path
+	req, err := http.NewRequest(mathod, reqURL, bytes.NewReader(posts))
+	if err != nil {
+		return nil, err
+	}
+	req.Header = client.buildHeader()
+	resp, err := httpclient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	return body, nil
+}
+
+func (client UCenterClient) Call(param IUCenterParam) ([]byte, error) {
+	path, mathod := param.GetPath()
+	return client.httpDo(path, mathod, param.Format())
+}

 package redisdata
 package redisdata
 
 
 const (
 const (
-	Key_App_Switch   string = "app_switch"
-	Value_Switch_On  string = "on"
-	Value_Switch_Off string = "off"
+	KEY_PREFIX     string = "oppmg_"
+	KEY_USER_TOKEN string = "token"
 )
 )

 package redisdata
 package redisdata
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"oppmg/common/log"
+	"oppmg/common/redis"
+	"oppmg/protocol"
+	"time"
+)
+
+func SetLoginToken(param protocol.LoginAuthToken, userid int64) error {
+	client := redis.GetRedis()
+	var (
+		key     string
+		value   []byte
+		err     error
+		exp     int64
+		nowTime = time.Now().Unix()
+	)
+	exp = param.RefreshExpires - nowTime
+	key = fmt.Sprintf("%s%s:%d", KEY_PREFIX, KEY_USER_TOKEN, userid)
+	value, _ = json.Marshal(param)
+	err = client.Set(key, string(value), time.Duration(exp)*time.Second).Err()
+	return err
+}
+
+func GetLoginToken(userid int64) (protocol.LoginAuthToken, error) {
+	client := redis.GetRedis()
+	var (
+		key    string
+		value  string
+		err    error
+		result protocol.LoginAuthToken
+	)
+	key = fmt.Sprintf("%s%s:%d", KEY_PREFIX, KEY_USER_TOKEN, userid)
+	value = client.Get(key).String()
+	if len(value) == 0 {
+		return result, errors.New("Token not found")
+	}
+	err = json.Unmarshal([]byte(value), &result)
+	if err != nil {
+		log.Error("Unmarshal redis value:%s err:%s", value, err)
+		return result, err
+	}
+	return result, nil
+}
+
+func ExistLoginToken(userid int64) bool {
+	client := redis.GetRedis()
+	key := fmt.Sprintf("%s%s:%d", KEY_PREFIX, KEY_USER_TOKEN, userid)
+	value := client.Exists(key).Val()
+	if value > 0 {
+		return true
+	}
+	return false
+}

 language: go
 language: go
 
 
 go:
 go:
-  - "1.9.2"
-  - "1.10.3"
+  - "1.10.x"
+  - "1.11.x"
 services:
 services:
   - redis-server
   - redis-server
   - mysql
   - mysql
@@ -34,6 +34,7 @@ install:
   - go get github.com/gogo/protobuf/proto
   - go get github.com/gogo/protobuf/proto
   - go get github.com/Knetic/govaluate
   - go get github.com/Knetic/govaluate
   - go get github.com/casbin/casbin
   - go get github.com/casbin/casbin
+  - go get github.com/elazarl/go-bindata-assetfs
   - go get -u honnef.co/go/tools/cmd/gosimple
   - go get -u honnef.co/go/tools/cmd/gosimple
   - go get -u github.com/mdempsky/unconvert
   - go get -u github.com/mdempsky/unconvert
   - go get -u github.com/gordonklaus/ineffassign
   - go get -u github.com/gordonklaus/ineffassign
@@ -44,12 +45,12 @@ before_script:
   - sh -c "if [ '$ORM_DRIVER' = 'postgres' ]; then psql -c 'create database orm_test;' -U postgres; fi"
   - sh -c "if [ '$ORM_DRIVER' = 'postgres' ]; then psql -c 'create database orm_test;' -U postgres; fi"
   - sh -c "if [ '$ORM_DRIVER' = 'mysql' ]; then mysql -u root -e 'create database orm_test;'; fi"
   - sh -c "if [ '$ORM_DRIVER' = 'mysql' ]; then mysql -u root -e 'create database orm_test;'; fi"
   - sh -c "if [ '$ORM_DRIVER' = 'sqlite' ]; then touch $TRAVIS_BUILD_DIR/orm_test.db; fi"
   - sh -c "if [ '$ORM_DRIVER' = 'sqlite' ]; then touch $TRAVIS_BUILD_DIR/orm_test.db; fi"
-  - sh -c "if [ $(go version) == *1.[5-9]* ]; then go get github.com/golang/lint/golint; golint ./...; fi"
-  - sh -c "if [ $(go version) == *1.[5-9]* ]; then go tool vet .; fi"
+  - sh -c "go get github.com/golang/lint/golint; golint ./...;"
+  - sh -c "go list ./... | grep -v vendor | xargs go vet -v"
   - mkdir -p res/var
   - mkdir -p res/var
   - ./ssdb/ssdb-server ./ssdb/ssdb.conf -d
   - ./ssdb/ssdb-server ./ssdb/ssdb.conf -d
 after_script:
 after_script:
-  -killall -w ssdb-server
+  - killall -w ssdb-server
   - rm -rf ./res/var/*
   - rm -rf ./res/var/*
 script:
 script:
   - go test -v ./...
   - go test -v ./...
@@ -59,4 +60,4 @@ script:
   - find . ! \( -path './vendor' -prune \) -type f -name '*.go' -print0 | xargs -0 gofmt -l -s
   - find . ! \( -path './vendor' -prune \) -type f -name '*.go' -print0 | xargs -0 gofmt -l -s
   - golint ./...
   - golint ./...
 addons:
 addons:
-  postgresql: "9.4"
+  postgresql: "9.6"

@@ -4,6 +4,8 @@
 beego is used for rapid development of RESTful APIs, web apps and backend services in Go.
 beego is used for rapid development of RESTful APIs, web apps and backend services in Go.
 It is inspired by Tornado, Sinatra and Flask. beego has some Go-specific features such as interfaces and struct embedding.
 It is inspired by Tornado, Sinatra and Flask. beego has some Go-specific features such as interfaces and struct embedding.
 
 
+ Response time ranking: [web-frameworks](https://github.com/the-benchmarker/web-frameworks).
+
 ###### More info at [beego.me](http://beego.me).
 ###### More info at [beego.me](http://beego.me).
 
 
 ## Quick Start
 ## Quick Start

@@ -20,11 +20,10 @@ import (
 	"fmt"
 	"fmt"
 	"net/http"
 	"net/http"
 	"os"
 	"os"
+	"reflect"
 	"text/template"
 	"text/template"
 	"time"
 	"time"
 
 
-	"reflect"
-
 	"github.com/astaxie/beego/grace"
 	"github.com/astaxie/beego/grace"
 	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/toolbox"
 	"github.com/astaxie/beego/toolbox"
@@ -35,7 +34,7 @@ import (
 var beeAdminApp *adminApp
 var beeAdminApp *adminApp
 
 
 // FilterMonitorFunc is default monitor filter when admin module is enable.
 // FilterMonitorFunc is default monitor filter when admin module is enable.
-// if this func returns, admin module records qbs for this request by condition of this function logic.
+// if this func returns, admin module records qps for this request by condition of this function logic.
 // usage:
 // usage:
 // 	func MyFilterMonitor(method, requestPath string, t time.Duration, pattern string, statusCode int) bool {
 // 	func MyFilterMonitor(method, requestPath string, t time.Duration, pattern string, statusCode int) bool {
 //	 	if method == "POST" {
 //	 	if method == "POST" {
@@ -67,18 +66,18 @@ func init() {
 
 
 // AdminIndex is the default http.Handler for admin module.
 // AdminIndex is the default http.Handler for admin module.
 // it matches url pattern "/".
 // it matches url pattern "/".
-func adminIndex(rw http.ResponseWriter, r *http.Request) {
+func adminIndex(rw http.ResponseWriter, _ *http.Request) {
 	execTpl(rw, map[interface{}]interface{}{}, indexTpl, defaultScriptsTpl)
 	execTpl(rw, map[interface{}]interface{}{}, indexTpl, defaultScriptsTpl)
 }
 }
 
 
-// QpsIndex is the http.Handler for writing qbs statistics map result info in http.ResponseWriter.
-// it's registered with url pattern "/qbs" in admin module.
-func qpsIndex(rw http.ResponseWriter, r *http.Request) {
+// QpsIndex is the http.Handler for writing qps statistics map result info in http.ResponseWriter.
+// it's registered with url pattern "/qps" in admin module.
+func qpsIndex(rw http.ResponseWriter, _ *http.Request) {
 	data := make(map[interface{}]interface{})
 	data := make(map[interface{}]interface{})
 	data["Content"] = toolbox.StatisticsMap.GetMap()
 	data["Content"] = toolbox.StatisticsMap.GetMap()
 
 
 	// do html escape before display path, avoid xss
 	// do html escape before display path, avoid xss
-	if content, ok := (data["Content"]).(map[string]interface{}); ok {
+	if content, ok := (data["Content"]).(M); ok {
 		if resultLists, ok := (content["Data"]).([][]string); ok {
 		if resultLists, ok := (content["Data"]).([][]string); ok {
 			for i := range resultLists {
 			for i := range resultLists {
 				if len(resultLists[i]) > 0 {
 				if len(resultLists[i]) > 0 {
@@ -104,7 +103,7 @@ func listConf(rw http.ResponseWriter, r *http.Request) {
 	data := make(map[interface{}]interface{})
 	data := make(map[interface{}]interface{})
 	switch command {
 	switch command {
 	case "conf":
 	case "conf":
-		m := make(map[string]interface{})
+		m := make(M)
 		list("BConfig", BConfig, m)
 		list("BConfig", BConfig, m)
 		m["AppConfigPath"] = appConfigPath
 		m["AppConfigPath"] = appConfigPath
 		m["AppConfigProvider"] = appConfigProvider
 		m["AppConfigProvider"] = appConfigProvider
@@ -128,14 +127,14 @@ func listConf(rw http.ResponseWriter, r *http.Request) {
 		execTpl(rw, data, routerAndFilterTpl, defaultScriptsTpl)
 		execTpl(rw, data, routerAndFilterTpl, defaultScriptsTpl)
 	case "filter":
 	case "filter":
 		var (
 		var (
-			content = map[string]interface{}{
+			content = M{
 				"Fields": []string{
 				"Fields": []string{
 					"Router Pattern",
 					"Router Pattern",
 					"Filter Function",
 					"Filter Function",
 				},
 				},
 			}
 			}
 			filterTypes    = []string{}
 			filterTypes    = []string{}
-			filterTypeData = make(map[string]interface{})
+			filterTypeData = make(M)
 		)
 		)
 
 
 		if BeeApp.Handlers.enableFilter {
 		if BeeApp.Handlers.enableFilter {
@@ -173,7 +172,7 @@ func listConf(rw http.ResponseWriter, r *http.Request) {
 	}
 	}
 }
 }
 
 
-func list(root string, p interface{}, m map[string]interface{}) {
+func list(root string, p interface{}, m M) {
 	pt := reflect.TypeOf(p)
 	pt := reflect.TypeOf(p)
 	pv := reflect.ValueOf(p)
 	pv := reflect.ValueOf(p)
 	if pt.Kind() == reflect.Ptr {
 	if pt.Kind() == reflect.Ptr {
@@ -196,11 +195,11 @@ func list(root string, p interface{}, m map[string]interface{}) {
 }
 }
 
 
 // PrintTree prints all registered routers.
 // PrintTree prints all registered routers.
-func PrintTree() map[string]interface{} {
+func PrintTree() M {
 	var (
 	var (
-		content     = map[string]interface{}{}
+		content     = M{}
 		methods     = []string{}
 		methods     = []string{}
-		methodsData = make(map[string]interface{})
+		methodsData = make(M)
 	)
 	)
 	for method, t := range BeeApp.Handlers.routers {
 	for method, t := range BeeApp.Handlers.routers {
 
 
@@ -291,12 +290,12 @@ func profIndex(rw http.ResponseWriter, r *http.Request) {
 
 
 // Healthcheck is a http.Handler calling health checking and showing the result.
 // Healthcheck is a http.Handler calling health checking and showing the result.
 // it's in "/healthcheck" pattern in admin module.
 // it's in "/healthcheck" pattern in admin module.
-func healthcheck(rw http.ResponseWriter, req *http.Request) {
+func healthcheck(rw http.ResponseWriter, _ *http.Request) {
 	var (
 	var (
 		result     []string
 		result     []string
 		data       = make(map[interface{}]interface{})
 		data       = make(map[interface{}]interface{})
 		resultList = new([][]string)
 		resultList = new([][]string)
-		content    = map[string]interface{}{
+		content    = M{
 			"Fields": []string{"Name", "Message", "Status"},
 			"Fields": []string{"Name", "Message", "Status"},
 		}
 		}
 	)
 	)
@@ -344,7 +343,7 @@ func taskStatus(rw http.ResponseWriter, req *http.Request) {
 	}
 	}
 
 
 	// List Tasks
 	// List Tasks
-	content := make(map[string]interface{})
+	content := make(M)
 	resultList := new([][]string)
 	resultList := new([][]string)
 	var fields = []string{
 	var fields = []string{
 		"Task Name",
 		"Task Name",

@@ -23,7 +23,7 @@ import (
 
 
 const (
 const (
 	// VERSION represent beego web framework version.
 	// VERSION represent beego web framework version.
-	VERSION = "1.10.0"
+	VERSION = "1.11.1"
 
 
 	// DEV is for develop
 	// DEV is for develop
 	DEV = "dev"
 	DEV = "dev"
@@ -31,7 +31,10 @@ const (
 	PROD = "prod"
 	PROD = "prod"
 )
 )
 
 
-//hook function to run
+// M is Map shortcut
+type M map[string]interface{}
+
+// Hook function to run
 type hookfunc func() error
 type hookfunc func() error
 
 
 var (
 var (

@@ -78,15 +78,37 @@ func (ini *IniConfig) parseData(dir string, data []byte) (*IniConfigContainer, e
 		}
 		}
 	}
 	}
 	section := defaultSection
 	section := defaultSection
+	tmpBuf := bytes.NewBuffer(nil)
 	for {
 	for {
-		line, _, err := buf.ReadLine()
-		if err == io.EOF {
-			break
+		tmpBuf.Reset()
+
+		shouldBreak := false
+		for {
+			tmp, isPrefix, err := buf.ReadLine()
+			if err == io.EOF {
+				shouldBreak = true
+				break
+			}
+
+			//It might be a good idea to throw a error on all unknonw errors?
+			if _, ok := err.(*os.PathError); ok {
+				return nil, err
+			}
+
+			tmpBuf.Write(tmp)
+			if isPrefix {
+				continue
+			}
+
+			if !isPrefix {
+				break
+			}
 		}
 		}
-		//It might be a good idea to throw a error on all unknonw errors?
-		if _, ok := err.(*os.PathError); ok {
-			return nil, err
+		if shouldBreak {
+			break
 		}
 		}
+
+		line := tmpBuf.Bytes()
 		line = bytes.TrimSpace(line)
 		line = bytes.TrimSpace(line)
 		if bytes.Equal(line, bEmpty) {
 		if bytes.Equal(line, bEmpty) {
 			continue
 			continue

@@ -38,6 +38,14 @@ import (
 	"github.com/astaxie/beego/utils"
 	"github.com/astaxie/beego/utils"
 )
 )
 
 
+//commonly used mime-types
+const (
+	ApplicationJSON = "application/json"
+	ApplicationXML  = "application/xml"
+	ApplicationYAML = "application/x-yaml"
+	TextXML         = "text/xml"
+)
+
 // NewContext return the Context with Input and Output
 // NewContext return the Context with Input and Output
 func NewContext() *Context {
 func NewContext() *Context {
 	return &Context{
 	return &Context{
@@ -193,6 +201,7 @@ type Response struct {
 	http.ResponseWriter
 	http.ResponseWriter
 	Started bool
 	Started bool
 	Status  int
 	Status  int
+	Elapsed time.Duration
 }
 }
 
 
 func (r *Response) reset(rw http.ResponseWriter) {
 func (r *Response) reset(rw http.ResponseWriter) {
@@ -244,3 +253,11 @@ func (r *Response) CloseNotify() <-chan bool {
 	}
 	}
 	return nil
 	return nil
 }
 }
+
+// Pusher http.Pusher
+func (r *Response) Pusher() (pusher http.Pusher) {
+	if pusher, ok := r.ResponseWriter.(http.Pusher); ok {
+		return pusher
+	}
+	return nil
+}

@@ -206,7 +206,7 @@ func (output *BeegoOutput) JSON(data interface{}, hasIndent bool, encoding bool)
 
 
 // YAML writes yaml to response body.
 // YAML writes yaml to response body.
 func (output *BeegoOutput) YAML(data interface{}) error {
 func (output *BeegoOutput) YAML(data interface{}) error {
-	output.Header("Content-Type", "application/application/x-yaml; charset=utf-8")
+	output.Header("Content-Type", "application/x-yaml; charset=utf-8")
 	var content []byte
 	var content []byte
 	var err error
 	var err error
 	content, err = yaml.Marshal(data)
 	content, err = yaml.Marshal(data)
@@ -260,6 +260,19 @@ func (output *BeegoOutput) XML(data interface{}, hasIndent bool) error {
 	return output.Body(content)
 	return output.Body(content)
 }
 }
 
 
+// ServeFormatted serve YAML, XML OR JSON, depending on the value of the Accept header
+func (output *BeegoOutput) ServeFormatted(data interface{}, hasIndent bool, hasEncode ...bool) {
+	accept := output.Context.Input.Header("Accept")
+	switch accept {
+	case ApplicationYAML:
+		output.YAML(data)
+	case ApplicationXML, TextXML:
+		output.XML(data, hasIndent)
+	default:
+		output.JSON(data, hasIndent, len(hasEncode) > 0 && hasEncode[0])
+	}
+}
+
 // Download forces response for download file.
 // Download forces response for download file.
 // it prepares the download response header automatically.
 // it prepares the download response header automatically.
 func (output *BeegoOutput) Download(file string, filename ...string) {
 func (output *BeegoOutput) Download(file string, filename ...string) {

@@ -32,14 +32,6 @@ import (
 	"github.com/astaxie/beego/session"
 	"github.com/astaxie/beego/session"
 )
 )
 
 
-//commonly used mime-types
-const (
-	applicationJSON = "application/json"
-	applicationXML  = "application/xml"
-	applicationYAML = "application/x-yaml"
-	textXML         = "text/xml"
-)
-
 var (
 var (
 	// ErrAbort custom error when user stop request handler manually.
 	// ErrAbort custom error when user stop request handler manually.
 	ErrAbort = errors.New("User stop run")
 	ErrAbort = errors.New("User stop run")
@@ -47,10 +39,37 @@ var (
 	GlobalControllerRouter = make(map[string][]ControllerComments)
 	GlobalControllerRouter = make(map[string][]ControllerComments)
 )
 )
 
 
+// ControllerFilter store the filter for controller
+type ControllerFilter struct {
+	Pattern        string
+	Pos            int
+	Filter         FilterFunc
+	ReturnOnOutput bool
+	ResetParams    bool
+}
+
+// ControllerFilterComments store the comment for controller level filter
+type ControllerFilterComments struct {
+	Pattern        string
+	Pos            int
+	Filter         string // NOQA
+	ReturnOnOutput bool
+	ResetParams    bool
+}
+
+// ControllerImportComments store the import comment for controller needed
+type ControllerImportComments struct {
+	ImportPath  string
+	ImportAlias string
+}
+
 // ControllerComments store the comment for the controller method
 // ControllerComments store the comment for the controller method
 type ControllerComments struct {
 type ControllerComments struct {
 	Method           string
 	Method           string
 	Router           string
 	Router           string
+	Filters          []*ControllerFilter
+	ImportComments   []*ControllerImportComments
+	FilterComments   []*ControllerFilterComments
 	AllowHTTPMethods []string
 	AllowHTTPMethods []string
 	Params           []map[string]string
 	Params           []map[string]string
 	MethodParams     []*param.MethodParam
 	MethodParams     []*param.MethodParam
@@ -275,16 +294,15 @@ func (c *Controller) viewPath() string {
 func (c *Controller) Redirect(url string, code int) {
 func (c *Controller) Redirect(url string, code int) {
 	logAccess(c.Ctx, nil, code)
 	logAccess(c.Ctx, nil, code)
 	c.Ctx.Redirect(code, url)
 	c.Ctx.Redirect(code, url)
-	panic(ErrAbort)
 }
 }
 
 
-// Set the data depending on the accepted
+// SetData set the data depending on the accepted
 func (c *Controller) SetData(data interface{}) {
 func (c *Controller) SetData(data interface{}) {
 	accept := c.Ctx.Input.Header("Accept")
 	accept := c.Ctx.Input.Header("Accept")
 	switch accept {
 	switch accept {
-	case applicationJSON:
-		c.Data["json"] = data
-	case applicationXML, textXML:
+	case context.ApplicationYAML:
+		c.Data["yaml"] = data
+	case context.ApplicationXML, context.TextXML:
 		c.Data["xml"] = data
 		c.Data["xml"] = data
 	default:
 	default:
 		c.Data["json"] = data
 		c.Data["json"] = data
@@ -333,54 +351,35 @@ func (c *Controller) URLFor(endpoint string, values ...interface{}) string {
 // ServeJSON sends a json response with encoding charset.
 // ServeJSON sends a json response with encoding charset.
 func (c *Controller) ServeJSON(encoding ...bool) {
 func (c *Controller) ServeJSON(encoding ...bool) {
 	var (
 	var (
-		hasIndent   = true
-		hasEncoding = false
+		hasIndent   = BConfig.RunMode != PROD
+		hasEncoding = len(encoding) > 0 && encoding[0]
 	)
 	)
-	if BConfig.RunMode == PROD {
-		hasIndent = false
-	}
-	if len(encoding) > 0 && encoding[0] {
-		hasEncoding = true
-	}
+
 	c.Ctx.Output.JSON(c.Data["json"], hasIndent, hasEncoding)
 	c.Ctx.Output.JSON(c.Data["json"], hasIndent, hasEncoding)
 }
 }
 
 
 // ServeJSONP sends a jsonp response.
 // ServeJSONP sends a jsonp response.
 func (c *Controller) ServeJSONP() {
 func (c *Controller) ServeJSONP() {
-	hasIndent := true
-	if BConfig.RunMode == PROD {
-		hasIndent = false
-	}
+	hasIndent := BConfig.RunMode != PROD
 	c.Ctx.Output.JSONP(c.Data["jsonp"], hasIndent)
 	c.Ctx.Output.JSONP(c.Data["jsonp"], hasIndent)
 }
 }
 
 
 // ServeXML sends xml response.
 // ServeXML sends xml response.
 func (c *Controller) ServeXML() {
 func (c *Controller) ServeXML() {
-	hasIndent := true
-	if BConfig.RunMode == PROD {
-		hasIndent = false
-	}
+	hasIndent := BConfig.RunMode != PROD
 	c.Ctx.Output.XML(c.Data["xml"], hasIndent)
 	c.Ctx.Output.XML(c.Data["xml"], hasIndent)
 }
 }
 
 
-// ServeXML sends xml response.
+// ServeYAML sends yaml response.
 func (c *Controller) ServeYAML() {
 func (c *Controller) ServeYAML() {
 	c.Ctx.Output.YAML(c.Data["yaml"])
 	c.Ctx.Output.YAML(c.Data["yaml"])
 }
 }
 
 
-// ServeFormatted serve Xml OR Json, depending on the value of the Accept header
-func (c *Controller) ServeFormatted() {
-	accept := c.Ctx.Input.Header("Accept")
-	switch accept {
-	case applicationJSON:
-		c.ServeJSON()
-	case applicationXML, textXML:
-		c.ServeXML()
-	case applicationYAML:
-		c.ServeYAML()
-	default:
-		c.ServeJSON()
-	}
+// ServeFormatted serve YAML, XML OR JSON, depending on the value of the Accept header
+func (c *Controller) ServeFormatted(encoding ...bool) {
+	hasIndent := BConfig.RunMode != PROD
+	hasEncoding := len(encoding) > 0 && encoding[0]
+	c.Ctx.Output.ServeFormatted(c.Data, hasIndent, hasEncoding)
 }
 }
 
 
 // Input returns the input data map from POST or PUT request body and query string.
 // Input returns the input data map from POST or PUT request body and query string.

@@ -361,7 +361,7 @@ func gatewayTimeout(rw http.ResponseWriter, r *http.Request) {
 
 
 func responseError(rw http.ResponseWriter, r *http.Request, errCode int, errContent string) {
 func responseError(rw http.ResponseWriter, r *http.Request, errCode int, errContent string) {
 	t, _ := template.New("beegoerrortemp").Parse(errtpl)
 	t, _ := template.New("beegoerrortemp").Parse(errtpl)
-	data := map[string]interface{}{
+	data := M{
 		"Title":        http.StatusText(errCode),
 		"Title":        http.StatusText(errCode),
 		"BeegoVersion": VERSION,
 		"BeegoVersion": VERSION,
 		"Content":      template.HTML(errContent),
 		"Content":      template.HTML(errContent),

+package beego
+
+import (
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+type FileSystem struct {
+}
+
+func (d FileSystem) Open(name string) (http.File, error) {
+	return os.Open(name)
+}
+
+// Walk walks the file tree rooted at root in filesystem, calling walkFn for each file or
+// directory in the tree, including root. All errors that arise visiting files
+// and directories are filtered by walkFn.
+func Walk(fs http.FileSystem, root string, walkFn filepath.WalkFunc) error {
+
+	f, err := fs.Open(root)
+	if err != nil {
+		return err
+	}
+	info, err := f.Stat()
+	if err != nil {
+		err = walkFn(root, nil, err)
+	} else {
+		err = walk(fs, root, info, walkFn)
+	}
+	if err == filepath.SkipDir {
+		return nil
+	}
+	return err
+}
+
+// walk recursively descends path, calling walkFn.
+func walk(fs http.FileSystem, path string, info os.FileInfo, walkFn filepath.WalkFunc) error {
+	var err error
+	if !info.IsDir() {
+		return walkFn(path, info, nil)
+	}
+
+	dir, err := fs.Open(path)
+	defer dir.Close()
+	if err != nil {
+		if err1 := walkFn(path, info, err); err1 != nil {
+			return err1
+		}
+		return err
+	}
+	dirs, err := dir.Readdir(-1)
+	err1 := walkFn(path, info, err)
+	// If err != nil, walk can't walk into this directory.
+	// err1 != nil means walkFn want walk to skip this directory or stop walking.
+	// Therefore, if one of err and err1 isn't nil, walk will return.
+	if err != nil || err1 != nil {
+		// The caller's behavior is controlled by the return value, which is decided
+		// by walkFn. walkFn may ignore err and return nil.
+		// If walkFn returns SkipDir, it will be handled by the caller.
+		// So walk should return whatever walkFn returns.
+		return err1
+	}
+
+	for _, fileInfo := range dirs {
+		filename := filepath.Join(path, fileInfo.Name())
+		if err = walk(fs, filename, fileInfo, walkFn); err != nil {
+			if !fileInfo.IsDir() || err != filepath.SkipDir {
+				return err
+			}
+		}
+	}
+	return nil
+}

+module github.com/astaxie/beego
+
+require (
+	github.com/Knetic/govaluate v3.0.0+incompatible // indirect
+	github.com/beego/goyaml2 v0.0.0-20130207012346-5545475820dd
+	github.com/beego/x2j v0.0.0-20131220205130-a0352aadc542
+	github.com/belogik/goes v0.0.0-20151229125003-e54d722c3aff
+	github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737
+	github.com/casbin/casbin v1.7.0
+	github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58
+	github.com/couchbase/go-couchbase v0.0.0-20181122212707-3e9b6e1258bb
+	github.com/couchbase/gomemcached v0.0.0-20181122193126-5125a94a666c // indirect
+	github.com/couchbase/goutils v0.0.0-20180530154633-e865a1461c8a // indirect
+	github.com/cupcake/rdb v0.0.0-20161107195141-43ba34106c76 // indirect
+	github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 // indirect
+	github.com/elazarl/go-bindata-assetfs v1.0.0
+	github.com/go-redis/redis v6.14.2+incompatible
+	github.com/go-sql-driver/mysql v1.4.1
+	github.com/gogo/protobuf v1.1.1
+	github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
+	github.com/gomodule/redigo v2.0.0+incompatible
+	github.com/lib/pq v1.0.0
+	github.com/mattn/go-sqlite3 v1.10.0
+	github.com/pelletier/go-toml v1.2.0 // indirect
+	github.com/pkg/errors v0.8.0 // indirect
+	github.com/siddontang/go v0.0.0-20180604090527-bdc77568d726 // indirect
+	github.com/siddontang/ledisdb v0.0.0-20181029004158-becf5f38d373
+	github.com/siddontang/rdb v0.0.0-20150307021120-fc89ed2e418d // indirect
+	github.com/ssdb/gossdb v0.0.0-20180723034631-88f6b59b84ec
+	github.com/syndtr/goleveldb v0.0.0-20181127023241-353a9fca669c // indirect
+	github.com/wendal/errors v0.0.0-20130201093226-f66c77a7882b // indirect
+	golang.org/x/crypto v0.0.0-20181127143415-eb0de9b17e85
+	golang.org/x/net v0.0.0-20181114220301-adae6a3d119a // indirect
+	gopkg.in/yaml.v2 v2.2.1
+)
+
+replace golang.org/x/crypto v0.0.0-20181127143415-eb0de9b17e85 => github.com/golang/crypto v0.0.0-20181127143415-eb0de9b17e85
+
+replace gopkg.in/yaml.v2 v2.2.1 => github.com/go-yaml/yaml v0.0.0-20180328195020-5420a8b6744d
+
+go 1.13

+github.com/Knetic/govaluate v3.0.0+incompatible h1:7o6+MAPhYTCF0+fdvoz1xDedhRb4f6s9Tn1Tt7/WTEg=
+github.com/Knetic/govaluate v3.0.0+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
+github.com/beego/goyaml2 v0.0.0-20130207012346-5545475820dd h1:jZtX5jh5IOMu0fpOTC3ayh6QGSPJ/KWOv1lgPvbRw1M=
+github.com/beego/goyaml2 v0.0.0-20130207012346-5545475820dd/go.mod h1:1b+Y/CofkYwXMUU0OhQqGvsY2Bvgr4j6jfT699wyZKQ=
+github.com/beego/x2j v0.0.0-20131220205130-a0352aadc542 h1:nYXb+3jF6Oq/j8R/y90XrKpreCxIalBWfeyeKymgOPk=
+github.com/beego/x2j v0.0.0-20131220205130-a0352aadc542/go.mod h1:kSeGC/p1AbBiEp5kat81+DSQrZenVBZXklMLaELspWU=
+github.com/belogik/goes v0.0.0-20151229125003-e54d722c3aff h1:/kO0p2RTGLB8R5gub7ps0GmYpB2O8LXEoPq8tzFDCUI=
+github.com/belogik/goes v0.0.0-20151229125003-e54d722c3aff/go.mod h1:PhH1ZhyCzHKt4uAasyx+ljRCgoezetRNf59CUtwUkqY=
+github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737 h1:rRISKWyXfVxvoa702s91Zl5oREZTrR3yv+tXrrX7G/g=
+github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60=
+github.com/casbin/casbin v1.7.0 h1:PuzlE8w0JBg/DhIqnkF1Dewf3z+qmUZMVN07PonvVUQ=
+github.com/casbin/casbin v1.7.0/go.mod h1:c67qKN6Oum3UF5Q1+BByfFxkwKvhwW57ITjqwtzR1KE=
+github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58 h1:F1EaeKL/ta07PY/k9Os/UFtwERei2/XzGemhpGnBKNg=
+github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58/go.mod h1:EOBUe0h4xcZ5GoxqC5SDxFQ8gwyZPKQoEzownBlhI80=
+github.com/couchbase/go-couchbase v0.0.0-20181122212707-3e9b6e1258bb h1:w3RapLhkA5+km9Z8vUkC6VCaskduJXvXwJg5neKnfDU=
+github.com/couchbase/go-couchbase v0.0.0-20181122212707-3e9b6e1258bb/go.mod h1:TWI8EKQMs5u5jLKW/tsb9VwauIrMIxQG1r5fMsswK5U=
+github.com/couchbase/gomemcached v0.0.0-20181122193126-5125a94a666c h1:K4FIibkr4//ziZKOKmt4RL0YImuTjLLBtwElf+F2lSQ=
+github.com/couchbase/gomemcached v0.0.0-20181122193126-5125a94a666c/go.mod h1:srVSlQLB8iXBVXHgnqemxUXqN6FCvClgCMPCsjBDR7c=
+github.com/couchbase/goutils v0.0.0-20180530154633-e865a1461c8a h1:Y5XsLCEhtEI8qbD9RP3Qlv5FXdTDHxZM9UPUnMRgBp8=
+github.com/couchbase/goutils v0.0.0-20180530154633-e865a1461c8a/go.mod h1:BQwMFlJzDjFDG3DJUdU0KORxn88UlsOULuxLExMh3Hs=
+github.com/cupcake/rdb v0.0.0-20161107195141-43ba34106c76 h1:Lgdd/Qp96Qj8jqLpq2cI1I1X7BJnu06efS+XkhRoLUQ=
+github.com/cupcake/rdb v0.0.0-20161107195141-43ba34106c76/go.mod h1:vYwsqCOLxGiisLwp9rITslkFNpZD5rz43tf41QFkTWY=
+github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 h1:aaQcKT9WumO6JEJcRyTqFVq4XUZiUcKR2/GI31TOcz8=
+github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/elazarl/go-bindata-assetfs v1.0.0 h1:G/bYguwHIzWq9ZoyUQqrjTmJbbYn3j3CKKpKinvZLFk=
+github.com/elazarl/go-bindata-assetfs v1.0.0/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4=
+github.com/go-redis/redis v6.14.2+incompatible h1:UE9pLhzmWf+xHNmZsoccjXosPicuiNaInPgym8nzfg0=
+github.com/go-redis/redis v6.14.2+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
+github.com/go-sql-driver/mysql v1.4.1 h1:g24URVg0OFbNUTx9qqY1IRZ9D9z3iPyi5zKhQZpNwpA=
+github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-yaml/yaml v0.0.0-20180328195020-5420a8b6744d h1:xy93KVe+KrIIwWDEAfQBdIfsiHJkepbYsDr+VY3g9/o=
+github.com/go-yaml/yaml v0.0.0-20180328195020-5420a8b6744d/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+github.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/golang/crypto v0.0.0-20181127143415-eb0de9b17e85 h1:B7ZbAFz7NOmvpUE5RGtu3u0WIizy5GdvbNpEf4RPnWs=
+github.com/golang/crypto v0.0.0-20181127143415-eb0de9b17e85/go.mod h1:uZvAcrsnNaCxlh1HorK5dUQHGmEKPh2H/Rl1kehswPo=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/gomodule/redigo v2.0.0+incompatible h1:K/R+8tc58AaqLkqG2Ol3Qk+DR/TlNuhuh457pBFPtt0=
+github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
+github.com/lib/pq v1.0.0 h1:X5PMW56eZitiTeO7tKzZxFCSpbFZJtkMMooicw2us9A=
+github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK860o=
+github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/siddontang/go v0.0.0-20180604090527-bdc77568d726 h1:xT+JlYxNGqyT+XcU8iUrN18JYed2TvG9yN5ULG2jATM=
+github.com/siddontang/go v0.0.0-20180604090527-bdc77568d726/go.mod h1:3yhqj7WBBfRhbBlzyOC3gUxftwsU0u8gqevxwIHQpMw=
+github.com/siddontang/ledisdb v0.0.0-20181029004158-becf5f38d373 h1:p6IxqQMjab30l4lb9mmkIkkcE1yv6o0SKbPhW5pxqHI=
+github.com/siddontang/ledisdb v0.0.0-20181029004158-becf5f38d373/go.mod h1:mF1DpOSOUiJRMR+FDqaqu3EBqrybQtrDDszLUZ6oxPg=
+github.com/siddontang/rdb v0.0.0-20150307021120-fc89ed2e418d h1:NVwnfyR3rENtlz62bcrkXME3INVUa4lcdGt+opvxExs=
+github.com/siddontang/rdb v0.0.0-20150307021120-fc89ed2e418d/go.mod h1:AMEsy7v5z92TR1JKMkLLoaOQk++LVnOKL3ScbJ8GNGA=
+github.com/ssdb/gossdb v0.0.0-20180723034631-88f6b59b84ec h1:q6XVwXmKvCRHRqesF3cSv6lNqqHi0QWOvgDlSohg8UA=
+github.com/ssdb/gossdb v0.0.0-20180723034631-88f6b59b84ec/go.mod h1:QBvMkMya+gXctz3kmljlUCu/yB3GZ6oee+dUozsezQE=
+github.com/syndtr/goleveldb v0.0.0-20181127023241-353a9fca669c h1:3eGShk3EQf5gJCYW+WzA0TEJQd37HLOmlYF7N0YJwv0=
+github.com/syndtr/goleveldb v0.0.0-20181127023241-353a9fca669c/go.mod h1:Z4AUp2Km+PwemOoO/VB5AOx9XSsIItzFjoJlOSiYmn0=
+github.com/wendal/errors v0.0.0-20130201093226-f66c77a7882b h1:0Ve0/CCjiAiyKddUMUn3RwIGlq2iTW4GuVzyoKBYO/8=
+github.com/wendal/errors v0.0.0-20130201093226-f66c77a7882b/go.mod h1:Q12BUT7DqIlHRmgv3RskH+UCM/4eqVMgI0EMmlSpAXc=
+golang.org/x/crypto v0.0.0-20181127143415-eb0de9b17e85 h1:et7+NAX3lLIk5qUCTA9QelBjGE/NkhzYw/mhnr0s7nI=
+golang.org/x/crypto v0.0.0-20181127143415-eb0de9b17e85/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a h1:gOpx8G595UYyvj8UK4+OFyY4rx037g3fmfhe5SasG3U=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

@@ -11,7 +11,7 @@ import (
 	"github.com/astaxie/beego/session"
 	"github.com/astaxie/beego/session"
 )
 )
 
 
-//
+// register MIME type with content type
 func registerMime() error {
 func registerMime() error {
 	for k, v := range mimemaps {
 	for k, v := range mimemaps {
 		mime.AddExtensionType(k, v)
 		mime.AddExtensionType(k, v)

@@ -54,6 +54,12 @@ type fileLogWriter struct {
 	dailyOpenDate int
 	dailyOpenDate int
 	dailyOpenTime time.Time
 	dailyOpenTime time.Time
 
 
+	// Rotate hourly
+	Hourly         bool  `json:"hourly"`
+	MaxHours       int64 `json:"maxhours"`
+	hourlyOpenDate int
+	hourlyOpenTime time.Time
+
 	Rotate bool `json:"rotate"`
 	Rotate bool `json:"rotate"`
 
 
 	Level int `json:"level"`
 	Level int `json:"level"`
@@ -70,6 +76,8 @@ func newFileWriter() Logger {
 	w := &fileLogWriter{
 	w := &fileLogWriter{
 		Daily:      true,
 		Daily:      true,
 		MaxDays:    7,
 		MaxDays:    7,
+		Hourly:     false,
+		MaxHours:   168,
 		Rotate:     true,
 		Rotate:     true,
 		RotatePerm: "0440",
 		RotatePerm: "0440",
 		Level:      LevelTrace,
 		Level:      LevelTrace,
@@ -83,15 +91,15 @@ func newFileWriter() Logger {
 
 
 // Init file logger with json config.
 // Init file logger with json config.
 // jsonConfig like:
 // jsonConfig like:
-//	{
-//	"filename":"logs/beego.log",
-//	"maxLines":10000,
-//	"maxsize":1024,
-//	"daily":true,
-//	"maxDays":15,
-//	"rotate":true,
-//  	"perm":"0600"
-//	}
+//  {
+//  "filename":"logs/beego.log",
+//  "maxLines":10000,
+//  "maxsize":1024,
+//  "daily":true,
+//  "maxDays":15,
+//  "rotate":true,
+//      "perm":"0600"
+//  }
 func (w *fileLogWriter) Init(jsonConfig string) error {
 func (w *fileLogWriter) Init(jsonConfig string) error {
 	err := json.Unmarshal([]byte(jsonConfig), w)
 	err := json.Unmarshal([]byte(jsonConfig), w)
 	if err != nil {
 	if err != nil {
@@ -122,10 +130,16 @@ func (w *fileLogWriter) startLogger() error {
 	return w.initFd()
 	return w.initFd()
 }
 }
 
 
-func (w *fileLogWriter) needRotate(size int, day int) bool {
+func (w *fileLogWriter) needRotateDaily(size int, day int) bool {
 	return (w.MaxLines > 0 && w.maxLinesCurLines >= w.MaxLines) ||
 	return (w.MaxLines > 0 && w.maxLinesCurLines >= w.MaxLines) ||
 		(w.MaxSize > 0 && w.maxSizeCurSize >= w.MaxSize) ||
 		(w.MaxSize > 0 && w.maxSizeCurSize >= w.MaxSize) ||
 		(w.Daily && day != w.dailyOpenDate)
 		(w.Daily && day != w.dailyOpenDate)
+}
+
+func (w *fileLogWriter) needRotateHourly(size int, hour int) bool {
+	return (w.MaxLines > 0 && w.maxLinesCurLines >= w.MaxLines) ||
+		(w.MaxSize > 0 && w.maxSizeCurSize >= w.MaxSize) ||
+		(w.Hourly && hour != w.hourlyOpenDate)
 
 
 }
 }
 
 
@@ -134,14 +148,23 @@ func (w *fileLogWriter) WriteMsg(when time.Time, msg string, level int) error {
 	if level > w.Level {
 	if level > w.Level {
 		return nil
 		return nil
 	}
 	}
-	h, d := formatTimeHeader(when)
-	msg = string(h) + msg + "\n"
+	hd, d, h := formatTimeHeader(when)
+	msg = string(hd) + msg + "\n"
 	if w.Rotate {
 	if w.Rotate {
 		w.RLock()
 		w.RLock()
-		if w.needRotate(len(msg), d) {
+		if w.needRotateHourly(len(msg), h) {
+			w.RUnlock()
+			w.Lock()
+			if w.needRotateHourly(len(msg), h) {
+				if err := w.doRotate(when); err != nil {
+					fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
+				}
+			}
+			w.Unlock()
+		} else if w.needRotateDaily(len(msg), d) {
 			w.RUnlock()
 			w.RUnlock()
 			w.Lock()
 			w.Lock()
-			if w.needRotate(len(msg), d) {
+			if w.needRotateDaily(len(msg), d) {
 				if err := w.doRotate(when); err != nil {
 				if err := w.doRotate(when); err != nil {
 					fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
 					fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
 				}
 				}
@@ -189,8 +212,12 @@ func (w *fileLogWriter) initFd() error {
 	w.maxSizeCurSize = int(fInfo.Size())
 	w.maxSizeCurSize = int(fInfo.Size())
 	w.dailyOpenTime = time.Now()
 	w.dailyOpenTime = time.Now()
 	w.dailyOpenDate = w.dailyOpenTime.Day()
 	w.dailyOpenDate = w.dailyOpenTime.Day()
+	w.hourlyOpenTime = time.Now()
+	w.hourlyOpenDate = w.hourlyOpenTime.Hour()
 	w.maxLinesCurLines = 0
 	w.maxLinesCurLines = 0
-	if w.Daily {
+	if w.Hourly {
+		go w.hourlyRotate(w.hourlyOpenTime)
+	} else if w.Daily {
 		go w.dailyRotate(w.dailyOpenTime)
 		go w.dailyRotate(w.dailyOpenTime)
 	}
 	}
 	if fInfo.Size() > 0 && w.MaxLines > 0 {
 	if fInfo.Size() > 0 && w.MaxLines > 0 {
@@ -209,7 +236,22 @@ func (w *fileLogWriter) dailyRotate(openTime time.Time) {
 	tm := time.NewTimer(time.Duration(nextDay.UnixNano() - openTime.UnixNano() + 100))
 	tm := time.NewTimer(time.Duration(nextDay.UnixNano() - openTime.UnixNano() + 100))
 	<-tm.C
 	<-tm.C
 	w.Lock()
 	w.Lock()
-	if w.needRotate(0, time.Now().Day()) {
+	if w.needRotateDaily(0, time.Now().Day()) {
+		if err := w.doRotate(time.Now()); err != nil {
+			fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
+		}
+	}
+	w.Unlock()
+}
+
+func (w *fileLogWriter) hourlyRotate(openTime time.Time) {
+	y, m, d := openTime.Add(1 * time.Hour).Date()
+	h, _, _ := openTime.Add(1 * time.Hour).Clock()
+	nextHour := time.Date(y, m, d, h, 0, 0, 0, openTime.Location())
+	tm := time.NewTimer(time.Duration(nextHour.UnixNano() - openTime.UnixNano() + 100))
+	<-tm.C
+	w.Lock()
+	if w.needRotateHourly(0, time.Now().Hour()) {
 		if err := w.doRotate(time.Now()); err != nil {
 		if err := w.doRotate(time.Now()); err != nil {
 			fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
 			fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
 		}
 		}
@@ -251,6 +293,8 @@ func (w *fileLogWriter) doRotate(logTime time.Time) error {
 	// Find the next available number
 	// Find the next available number
 	num := w.MaxFilesCurFiles + 1
 	num := w.MaxFilesCurFiles + 1
 	fName := ""
 	fName := ""
+	format := ""
+	var openTime time.Time
 	rotatePerm, err := strconv.ParseInt(w.RotatePerm, 8, 64)
 	rotatePerm, err := strconv.ParseInt(w.RotatePerm, 8, 64)
 	if err != nil {
 	if err != nil {
 		return err
 		return err
@@ -262,17 +306,26 @@ func (w *fileLogWriter) doRotate(logTime time.Time) error {
 		goto RESTART_LOGGER
 		goto RESTART_LOGGER
 	}
 	}
 
 
+	if w.Hourly {
+		format = "2006010215"
+		openTime = w.hourlyOpenTime
+	} else if w.Daily {
+		format = "2006-01-02"
+		openTime = w.dailyOpenTime
+	}
+
 	// only when one of them be setted, then the file would be splited
 	// only when one of them be setted, then the file would be splited
 	if w.MaxLines > 0 || w.MaxSize > 0 {
 	if w.MaxLines > 0 || w.MaxSize > 0 {
 		for ; err == nil && num <= w.MaxFiles; num++ {
 		for ; err == nil && num <= w.MaxFiles; num++ {
-			fName = w.fileNameOnly + fmt.Sprintf(".%s.%03d%s", logTime.Format("2006-01-02"), num, w.suffix)
+			fName = w.fileNameOnly + fmt.Sprintf(".%s.%03d%s", logTime.Format(format), num, w.suffix)
 			_, err = os.Lstat(fName)
 			_, err = os.Lstat(fName)
 		}
 		}
 	} else {
 	} else {
-		fName = w.fileNameOnly + fmt.Sprintf(".%s.%03d%s", w.dailyOpenTime.Format("2006-01-02"), num, w.suffix)
+		fName = w.fileNameOnly + fmt.Sprintf(".%s.%03d%s", openTime.Format(format), num, w.suffix)
 		_, err = os.Lstat(fName)
 		_, err = os.Lstat(fName)
 		w.MaxFilesCurFiles = num
 		w.MaxFilesCurFiles = num
 	}
 	}
+
 	// return error if the last file checked still existed
 	// return error if the last file checked still existed
 	if err == nil {
 	if err == nil {
 		return fmt.Errorf("Rotate: Cannot find free log number to rename %s", w.Filename)
 		return fmt.Errorf("Rotate: Cannot find free log number to rename %s", w.Filename)
@@ -316,13 +369,21 @@ func (w *fileLogWriter) deleteOldLog() {
 		if info == nil {
 		if info == nil {
 			return
 			return
 		}
 		}
-
-		if !info.IsDir() && info.ModTime().Add(24 * time.Hour * time.Duration(w.MaxDays)).Before(time.Now()) {
-			if strings.HasPrefix(filepath.Base(path), filepath.Base(w.fileNameOnly)) &&
-				strings.HasSuffix(filepath.Base(path), w.suffix) {
-				os.Remove(path)
-			}
-		}
+        if w.Hourly {
+            if !info.IsDir() && info.ModTime().Add(1 * time.Hour * time.Duration(w.MaxHours)).Before(time.Now()) {
+                if strings.HasPrefix(filepath.Base(path), filepath.Base(w.fileNameOnly)) &&
+                strings.HasSuffix(filepath.Base(path), w.suffix) {
+                    os.Remove(path)
+                }
+            }
+        } else if w.Daily {
+            if !info.IsDir() && info.ModTime().Add(24 * time.Hour * time.Duration(w.MaxDays)).Before(time.Now()) {
+                if strings.HasPrefix(filepath.Base(path), filepath.Base(w.fileNameOnly)) &&
+                strings.HasSuffix(filepath.Base(path), w.suffix) {
+                    os.Remove(path)
+                }
+            }
+        }
 		return
 		return
 	})
 	})
 }
 }

@@ -33,7 +33,7 @@ func newLogWriter(wr io.Writer) *logWriter {
 
 
 func (lg *logWriter) println(when time.Time, msg string) {
 func (lg *logWriter) println(when time.Time, msg string) {
 	lg.Lock()
 	lg.Lock()
-	h, _ := formatTimeHeader(when)
+	h, _, _:= formatTimeHeader(when)
 	lg.writer.Write(append(append(h, msg...), '\n'))
 	lg.writer.Write(append(append(h, msg...), '\n'))
 	lg.Unlock()
 	lg.Unlock()
 }
 }
@@ -90,7 +90,7 @@ const (
 	ns1 = `0123456789`
 	ns1 = `0123456789`
 )
 )
 
 
-func formatTimeHeader(when time.Time) ([]byte, int) {
+func formatTimeHeader(when time.Time) ([]byte, int, int) {
 	y, mo, d := when.Date()
 	y, mo, d := when.Date()
 	h, mi, s := when.Clock()
 	h, mi, s := when.Clock()
 	ns := when.Nanosecond() / 1000000
 	ns := when.Nanosecond() / 1000000
@@ -123,7 +123,7 @@ func formatTimeHeader(when time.Time) ([]byte, int) {
 
 
 	buf[23] = ' '
 	buf[23] = ' '
 
 
-	return buf[0:], d
+	return buf[0:], d, h
 }
 }
 
 
 var (
 var (

@@ -536,6 +536,8 @@ func (d *dbBase) InsertOrUpdate(q dbQuerier, mi *modelInfo, ind reflect.Value, a
 	updates := make([]string, len(names))
 	updates := make([]string, len(names))
 	var conflitValue interface{}
 	var conflitValue interface{}
 	for i, v := range names {
 	for i, v := range names {
+		// identifier in database may not be case-sensitive, so quote it
+		v = fmt.Sprintf("%s%s%s", Q, v, Q)
 		marks[i] = "?"
 		marks[i] = "?"
 		valueStr := argsMap[strings.ToLower(v)]
 		valueStr := argsMap[strings.ToLower(v)]
 		if v == args0 {
 		if v == args0 {
@@ -760,7 +762,13 @@ func (d *dbBase) UpdateBatch(q dbQuerier, qs *querySet, mi *modelInfo, cond *Con
 	}
 	}
 
 
 	d.ins.ReplaceMarks(&query)
 	d.ins.ReplaceMarks(&query)
-	res, err := q.Exec(query, values...)
+	var err error
+	var res sql.Result
+	if qs != nil && qs.forContext {
+		res, err = q.ExecContext(qs.ctx, query, values...)
+	} else {
+		res, err = q.Exec(query, values...)
+	}
 	if err == nil {
 	if err == nil {
 		return res.RowsAffected()
 		return res.RowsAffected()
 	}
 	}
@@ -849,11 +857,16 @@ func (d *dbBase) DeleteBatch(q dbQuerier, qs *querySet, mi *modelInfo, cond *Con
 	for i := range marks {
 	for i := range marks {
 		marks[i] = "?"
 		marks[i] = "?"
 	}
 	}
-	sql := fmt.Sprintf("IN (%s)", strings.Join(marks, ", "))
-	query = fmt.Sprintf("DELETE FROM %s%s%s WHERE %s%s%s %s", Q, mi.table, Q, Q, mi.fields.pk.column, Q, sql)
+	sqlIn := fmt.Sprintf("IN (%s)", strings.Join(marks, ", "))
+	query = fmt.Sprintf("DELETE FROM %s%s%s WHERE %s%s%s %s", Q, mi.table, Q, Q, mi.fields.pk.column, Q, sqlIn)
 
 
 	d.ins.ReplaceMarks(&query)
 	d.ins.ReplaceMarks(&query)
-	res, err := q.Exec(query, args...)
+	var res sql.Result
+	if qs != nil && qs.forContext {
+		res, err = q.ExecContext(qs.ctx, query, args...)
+	} else {
+		res, err = q.Exec(query, args...)
+	}
 	if err == nil {
 	if err == nil {
 		num, err := res.RowsAffected()
 		num, err := res.RowsAffected()
 		if err != nil {
 		if err != nil {
@@ -926,7 +939,7 @@ func (d *dbBase) ReadBatch(q dbQuerier, qs *querySet, mi *modelInfo, cond *Condi
 					maps[fi.column] = true
 					maps[fi.column] = true
 				}
 				}
 			} else {
 			} else {
-				panic(fmt.Errorf("wrong field/column name `%s`", col))
+				return 0, fmt.Errorf("wrong field/column name `%s`", col)
 			}
 			}
 		}
 		}
 		if hasRel {
 		if hasRel {
@@ -976,11 +989,18 @@ func (d *dbBase) ReadBatch(q dbQuerier, qs *querySet, mi *modelInfo, cond *Condi
 	d.ins.ReplaceMarks(&query)
 	d.ins.ReplaceMarks(&query)
 
 
 	var rs *sql.Rows
 	var rs *sql.Rows
-	r, err := q.Query(query, args...)
-	if err != nil {
-		return 0, err
+	var err error
+	if qs != nil && qs.forContext {
+		rs, err = q.QueryContext(qs.ctx, query, args...)
+		if err != nil {
+			return 0, err
+		}
+	} else {
+		rs, err = q.Query(query, args...)
+		if err != nil {
+			return 0, err
+		}
 	}
 	}
-	rs = r
 
 
 	refs := make([]interface{}, colsNum)
 	refs := make([]interface{}, colsNum)
 	for i := range refs {
 	for i := range refs {
@@ -1109,8 +1129,12 @@ func (d *dbBase) Count(q dbQuerier, qs *querySet, mi *modelInfo, cond *Condition
 
 
 	d.ins.ReplaceMarks(&query)
 	d.ins.ReplaceMarks(&query)
 
 
-	row := q.QueryRow(query, args...)
-
+	var row *sql.Row
+	if qs != nil && qs.forContext {
+		row = q.QueryRowContext(qs.ctx, query, args...)
+	} else {
+		row = q.QueryRow(query, args...)
+	}
 	err = row.Scan(&cnt)
 	err = row.Scan(&cnt)
 	return
 	return
 }
 }

@@ -372,7 +372,13 @@ func (t *dbTables) getCondSQL(cond *Condition, sub bool, tz *time.Location) (whe
 				operator = "exact"
 				operator = "exact"
 			}
 			}
 
 
-			operSQL, args := t.base.GenerateOperatorSQL(mi, fi, operator, p.args, tz)
+			var operSQL string
+			var args []interface{}
+			if p.isRaw {
+				operSQL = p.sql
+			} else {
+				operSQL, args = t.base.GenerateOperatorSQL(mi, fi, operator, p.args, tz)
+			}
 
 
 			leftCol := fmt.Sprintf("%s.%s%s%s", index, Q, fi.column, Q)
 			leftCol := fmt.Sprintf("%s.%s%s%s", index, Q, fi.column, Q)
 			t.base.GenerateOperatorLeftCol(fi, operator, &leftCol)
 			t.base.GenerateOperatorLeftCol(fi, operator, &leftCol)

@@ -109,7 +109,7 @@ func getTableUnique(val reflect.Value) [][]string {
 func getColumnName(ft int, addrField reflect.Value, sf reflect.StructField, col string) string {
 func getColumnName(ft int, addrField reflect.Value, sf reflect.StructField, col string) string {
 	column := col
 	column := col
 	if col == "" {
 	if col == "" {
-		column = snakeString(sf.Name)
+		column = nameStrategyMap[nameStrategy](sf.Name)
 	}
 	}
 	switch ft {
 	switch ft {
 	case RelForeignKey, RelOneToOne:
 	case RelForeignKey, RelOneToOne:

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // limitations under the License.
 
 
+// +build go1.8
+
 // Package orm provide ORM for MySQL/PostgreSQL/sqlite
 // Package orm provide ORM for MySQL/PostgreSQL/sqlite
 // Simple Usage
 // Simple Usage
 //
 //
@@ -52,6 +54,7 @@
 package orm
 package orm
 
 
 import (
 import (
+	"context"
 	"database/sql"
 	"database/sql"
 	"errors"
 	"errors"
 	"fmt"
 	"fmt"
@@ -422,7 +425,7 @@ func (o *orm) getRelQs(md interface{}, mi *modelInfo, fi *fieldInfo) *querySet {
 func (o *orm) QueryTable(ptrStructOrTableName interface{}) (qs QuerySeter) {
 func (o *orm) QueryTable(ptrStructOrTableName interface{}) (qs QuerySeter) {
 	var name string
 	var name string
 	if table, ok := ptrStructOrTableName.(string); ok {
 	if table, ok := ptrStructOrTableName.(string); ok {
-		name = snakeString(table)
+		name = nameStrategyMap[defaultNameStrategy](table)
 		if mi, ok := modelCache.get(name); ok {
 		if mi, ok := modelCache.get(name); ok {
 			qs = newQuerySet(o, mi)
 			qs = newQuerySet(o, mi)
 		}
 		}
@@ -458,11 +461,15 @@ func (o *orm) Using(name string) error {
 
 
 // begin transaction
 // begin transaction
 func (o *orm) Begin() error {
 func (o *orm) Begin() error {
+	return o.BeginTx(context.Background(), nil)
+}
+
+func (o *orm) BeginTx(ctx context.Context, opts *sql.TxOptions) error {
 	if o.isTx {
 	if o.isTx {
 		return ErrTxHasBegan
 		return ErrTxHasBegan
 	}
 	}
 	var tx *sql.Tx
 	var tx *sql.Tx
-	tx, err := o.db.(txer).Begin()
+	tx, err := o.db.(txer).BeginTx(ctx, opts)
 	if err != nil {
 	if err != nil {
 		return err
 		return err
 	}
 	}
@@ -541,6 +548,9 @@ func NewOrmWithDB(driverName, aliasName string, db *sql.DB) (Ormer, error) {
 
 
 	al.Name = aliasName
 	al.Name = aliasName
 	al.DriverName = driverName
 	al.DriverName = driverName
+	al.DB = db
+
+	detectTZ(al)
 
 
 	o := new(orm)
 	o := new(orm)
 	o.alias = al
 	o.alias = al

@@ -31,6 +31,8 @@ type condValue struct {
 	isOr   bool
 	isOr   bool
 	isNot  bool
 	isNot  bool
 	isCond bool
 	isCond bool
+	isRaw  bool
+	sql    string
 }
 }
 
 
 // Condition struct.
 // Condition struct.
@@ -45,6 +47,15 @@ func NewCondition() *Condition {
 	return c
 	return c
 }
 }
 
 
+// Raw add raw sql to condition
+func (c Condition) Raw(expr string, sql string) *Condition {
+	if len(sql) == 0 {
+		panic(fmt.Errorf("<Condition.Raw> sql cannot empty"))
+	}
+	c.params = append(c.params, condValue{exprs: strings.Split(expr, ExprSep), sql: sql, isRaw: true})
+	return &c
+}
+
 // And add expression to condition
 // And add expression to condition
 func (c Condition) And(expr string, args ...interface{}) *Condition {
 func (c Condition) And(expr string, args ...interface{}) *Condition {
 	if expr == "" || len(args) == 0 {
 	if expr == "" || len(args) == 0 {

@@ -15,6 +15,7 @@
 package orm
 package orm
 
 
 import (
 import (
+	"context"
 	"database/sql"
 	"database/sql"
 	"fmt"
 	"fmt"
 	"io"
 	"io"
@@ -122,6 +123,13 @@ func (d *dbQueryLog) Prepare(query string) (*sql.Stmt, error) {
 	return stmt, err
 	return stmt, err
 }
 }
 
 
+func (d *dbQueryLog) PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) {
+	a := time.Now()
+	stmt, err := d.db.PrepareContext(ctx, query)
+	debugLogQueies(d.alias, "db.Prepare", query, a, err)
+	return stmt, err
+}
+
 func (d *dbQueryLog) Exec(query string, args ...interface{}) (sql.Result, error) {
 func (d *dbQueryLog) Exec(query string, args ...interface{}) (sql.Result, error) {
 	a := time.Now()
 	a := time.Now()
 	res, err := d.db.Exec(query, args...)
 	res, err := d.db.Exec(query, args...)
@@ -129,6 +137,13 @@ func (d *dbQueryLog) Exec(query string, args ...interface{}) (sql.Result, error)
 	return res, err
 	return res, err
 }
 }
 
 
+func (d *dbQueryLog) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
+	a := time.Now()
+	res, err := d.db.ExecContext(ctx, query, args...)
+	debugLogQueies(d.alias, "db.Exec", query, a, err, args...)
+	return res, err
+}
+
 func (d *dbQueryLog) Query(query string, args ...interface{}) (*sql.Rows, error) {
 func (d *dbQueryLog) Query(query string, args ...interface{}) (*sql.Rows, error) {
 	a := time.Now()
 	a := time.Now()
 	res, err := d.db.Query(query, args...)
 	res, err := d.db.Query(query, args...)
@@ -136,6 +151,13 @@ func (d *dbQueryLog) Query(query string, args ...interface{}) (*sql.Rows, error)
 	return res, err
 	return res, err
 }
 }
 
 
+func (d *dbQueryLog) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
+	a := time.Now()
+	res, err := d.db.QueryContext(ctx, query, args...)
+	debugLogQueies(d.alias, "db.Query", query, a, err, args...)
+	return res, err
+}
+
 func (d *dbQueryLog) QueryRow(query string, args ...interface{}) *sql.Row {
 func (d *dbQueryLog) QueryRow(query string, args ...interface{}) *sql.Row {
 	a := time.Now()
 	a := time.Now()
 	res := d.db.QueryRow(query, args...)
 	res := d.db.QueryRow(query, args...)
@@ -143,6 +165,13 @@ func (d *dbQueryLog) QueryRow(query string, args ...interface{}) *sql.Row {
 	return res
 	return res
 }
 }
 
 
+func (d *dbQueryLog) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
+	a := time.Now()
+	res := d.db.QueryRowContext(ctx, query, args...)
+	debugLogQueies(d.alias, "db.QueryRow", query, a, nil, args...)
+	return res
+}
+
 func (d *dbQueryLog) Begin() (*sql.Tx, error) {
 func (d *dbQueryLog) Begin() (*sql.Tx, error) {
 	a := time.Now()
 	a := time.Now()
 	tx, err := d.db.(txer).Begin()
 	tx, err := d.db.(txer).Begin()
@@ -150,6 +179,13 @@ func (d *dbQueryLog) Begin() (*sql.Tx, error) {
 	return tx, err
 	return tx, err
 }
 }
 
 
+func (d *dbQueryLog) BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error) {
+	a := time.Now()
+	tx, err := d.db.(txer).BeginTx(ctx, opts)
+	debugLogQueies(d.alias, "db.BeginTx", "START TRANSACTION", a, err)
+	return tx, err
+}
+
 func (d *dbQueryLog) Commit() error {
 func (d *dbQueryLog) Commit() error {
 	a := time.Now()
 	a := time.Now()
 	err := d.db.(txEnder).Commit()
 	err := d.db.(txEnder).Commit()

@@ -15,6 +15,7 @@
 package orm
 package orm
 
 
 import (
 import (
+	"context"
 	"fmt"
 	"fmt"
 )
 )
 
 
@@ -55,17 +56,19 @@ func ColValue(opt operator, value interface{}) interface{} {
 
 
 // real query struct
 // real query struct
 type querySet struct {
 type querySet struct {
-	mi        *modelInfo
-	cond      *Condition
-	related   []string
-	relDepth  int
-	limit     int64
-	offset    int64
-	groups    []string
-	orders    []string
-	distinct  bool
-	forupdate bool
-	orm       *orm
+	mi         *modelInfo
+	cond       *Condition
+	related    []string
+	relDepth   int
+	limit      int64
+	offset     int64
+	groups     []string
+	orders     []string
+	distinct   bool
+	forupdate  bool
+	orm        *orm
+	ctx        context.Context
+	forContext bool
 }
 }
 
 
 var _ QuerySeter = new(querySet)
 var _ QuerySeter = new(querySet)
@@ -79,6 +82,15 @@ func (o querySet) Filter(expr string, args ...interface{}) QuerySeter {
 	return &o
 	return &o
 }
 }
 
 
+// add raw sql to querySeter.
+func (o querySet) FilterRaw(expr string, sql string) QuerySeter {
+	if o.cond == nil {
+		o.cond = NewCondition()
+	}
+	o.cond = o.cond.Raw(expr, sql)
+	return &o
+}
+
 // add NOT condition to querySeter.
 // add NOT condition to querySeter.
 func (o querySet) Exclude(expr string, args ...interface{}) QuerySeter {
 func (o querySet) Exclude(expr string, args ...interface{}) QuerySeter {
 	if o.cond == nil {
 	if o.cond == nil {
@@ -198,11 +210,7 @@ func (o *querySet) PrepareInsert() (Inserter, error) {
 // query all data and map to containers.
 // query all data and map to containers.
 // cols means the columns when querying.
 // cols means the columns when querying.
 func (o *querySet) All(container interface{}, cols ...string) (int64, error) {
 func (o *querySet) All(container interface{}, cols ...string) (int64, error) {
-	num, err := o.orm.alias.DbBaser.ReadBatch(o.orm.db, o, o.mi, o.cond, container, o.orm.alias.TZ, cols)
-	if num == 0 {
-		return 0, ErrNoRows
-	}
-	return num, err
+	return o.orm.alias.DbBaser.ReadBatch(o.orm.db, o, o.mi, o.cond, container, o.orm.alias.TZ, cols)
 }
 }
 
 
 // query one row data and map to containers.
 // query one row data and map to containers.
@@ -270,6 +278,13 @@ func (o *querySet) RowsToStruct(ptrStruct interface{}, keyCol, valueCol string)
 	panic(ErrNotImplement)
 	panic(ErrNotImplement)
 }
 }
 
 
+// set context to QuerySeter.
+func (o querySet) WithContext(ctx context.Context) QuerySeter {
+	o.ctx = ctx
+	o.forContext = true
+	return &o
+}
+
 // create new QuerySeter.
 // create new QuerySeter.
 func newQuerySet(orm *orm, mi *modelInfo) QuerySeter {
 func newQuerySet(orm *orm, mi *modelInfo) QuerySeter {
 	o := new(querySet)
 	o := new(querySet)

@@ -358,7 +358,7 @@ func (o *rawSet) QueryRow(containers ...interface{}) error {
 					_, tags := parseStructTag(fe.Tag.Get(defaultStructTagName))
 					_, tags := parseStructTag(fe.Tag.Get(defaultStructTagName))
 					var col string
 					var col string
 					if col = tags["column"]; col == "" {
 					if col = tags["column"]; col == "" {
-						col = snakeString(fe.Name)
+						col = nameStrategyMap[nameStrategy](fe.Name)
 					}
 					}
 					if v, ok := columnsMp[col]; ok {
 					if v, ok := columnsMp[col]; ok {
 						value := reflect.ValueOf(v).Elem().Interface()
 						value := reflect.ValueOf(v).Elem().Interface()
@@ -509,7 +509,7 @@ func (o *rawSet) QueryRows(containers ...interface{}) (int64, error) {
 						_, tags := parseStructTag(fe.Tag.Get(defaultStructTagName))
 						_, tags := parseStructTag(fe.Tag.Get(defaultStructTagName))
 						var col string
 						var col string
 						if col = tags["column"]; col == "" {
 						if col = tags["column"]; col == "" {
-							col = snakeString(fe.Name)
+							col = nameStrategyMap[nameStrategy](fe.Name)
 						}
 						}
 						if v, ok := columnsMp[col]; ok {
 						if v, ok := columnsMp[col]; ok {
 							value := reflect.ValueOf(v).Elem().Interface()
 							value := reflect.ValueOf(v).Elem().Interface()

@@ -15,6 +15,7 @@
 package orm
 package orm
 
 
 import (
 import (
+	"context"
 	"database/sql"
 	"database/sql"
 	"reflect"
 	"reflect"
 	"time"
 	"time"
@@ -106,6 +107,17 @@ type Ormer interface {
 	// 	...
 	// 	...
 	// 	err = o.Rollback()
 	// 	err = o.Rollback()
 	Begin() error
 	Begin() error
+	// begin transaction with provided context and option
+	// the provided context is used until the transaction is committed or rolled back.
+	// if the context is canceled, the transaction will be rolled back.
+	// the provided TxOptions is optional and may be nil if defaults should be used.
+	// if a non-default isolation level is used that the driver doesn't support, an error will be returned.
+	// for example:
+	//  o := NewOrm()
+	// 	err := o.BeginTx(context.Background(), &sql.TxOptions{Isolation: sql.LevelRepeatableRead})
+	//  ...
+	//  err = o.Rollback()
+	BeginTx(ctx context.Context, opts *sql.TxOptions) error
 	// commit transaction
 	// commit transaction
 	Commit() error
 	Commit() error
 	// rollback transaction
 	// rollback transaction
@@ -135,6 +147,11 @@ type QuerySeter interface {
 	// 	 // time compare
 	// 	 // time compare
 	//	qs.Filter("created", time.Now())
 	//	qs.Filter("created", time.Now())
 	Filter(string, ...interface{}) QuerySeter
 	Filter(string, ...interface{}) QuerySeter
+	// add raw sql to querySeter.
+	// for example:
+	// qs.FilterRaw("user_id IN (SELECT id FROM profile WHERE age>=18)")
+	// //sql-> WHERE user_id IN (SELECT id FROM profile WHERE age>=18)
+	FilterRaw(string, string) QuerySeter
 	// add NOT condition to querySeter.
 	// add NOT condition to querySeter.
 	// have the same usage as Filter
 	// have the same usage as Filter
 	Exclude(string, ...interface{}) QuerySeter
 	Exclude(string, ...interface{}) QuerySeter
@@ -378,16 +395,23 @@ type RawSeter interface {
 type stmtQuerier interface {
 type stmtQuerier interface {
 	Close() error
 	Close() error
 	Exec(args ...interface{}) (sql.Result, error)
 	Exec(args ...interface{}) (sql.Result, error)
+	//ExecContext(ctx context.Context, args ...interface{}) (sql.Result, error)
 	Query(args ...interface{}) (*sql.Rows, error)
 	Query(args ...interface{}) (*sql.Rows, error)
+	//QueryContext(args ...interface{}) (*sql.Rows, error)
 	QueryRow(args ...interface{}) *sql.Row
 	QueryRow(args ...interface{}) *sql.Row
+	//QueryRowContext(ctx context.Context, args ...interface{}) *sql.Row
 }
 }
 
 
 // db querier
 // db querier
 type dbQuerier interface {
 type dbQuerier interface {
 	Prepare(query string) (*sql.Stmt, error)
 	Prepare(query string) (*sql.Stmt, error)
+	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
 	Exec(query string, args ...interface{}) (sql.Result, error)
 	Exec(query string, args ...interface{}) (sql.Result, error)
+	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
 	Query(query string, args ...interface{}) (*sql.Rows, error)
 	Query(query string, args ...interface{}) (*sql.Rows, error)
+	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
 	QueryRow(query string, args ...interface{}) *sql.Row
 	QueryRow(query string, args ...interface{}) *sql.Row
+	QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row
 }
 }
 
 
 // type DB interface {
 // type DB interface {
@@ -401,6 +425,7 @@ type dbQuerier interface {
 // transaction beginner
 // transaction beginner
 type txer interface {
 type txer interface {
 	Begin() (*sql.Tx, error)
 	Begin() (*sql.Tx, error)
+	BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)
 }
 }
 
 
 // transaction ending
 // transaction ending

@@ -23,6 +23,18 @@ import (
 	"time"
 	"time"
 )
 )
 
 
+type fn func(string) string
+
+var (
+	nameStrategyMap = map[string]fn{
+		defaultNameStrategy:      snakeString,
+		SnakeAcronymNameStrategy: snakeStringWithAcronym,
+	}
+	defaultNameStrategy      = "snakeString"
+	SnakeAcronymNameStrategy = "snakeStringWithAcronym"
+	nameStrategy             = defaultNameStrategy
+)
+
 // StrTo is the target string
 // StrTo is the target string
 type StrTo string
 type StrTo string
 
 
@@ -198,7 +210,28 @@ func ToInt64(value interface{}) (d int64) {
 	return
 	return
 }
 }
 
 
-// snake string, XxYy to xx_yy , XxYY to xx_yy
+func snakeStringWithAcronym(s string) string {
+	data := make([]byte, 0, len(s)*2)
+	num := len(s)
+	for i := 0; i < num; i++ {
+		d := s[i]
+		before := false
+		after := false
+		if i > 0 {
+			before = s[i-1] >= 'a' && s[i-1] <= 'z'
+		}
+		if i+1 < num {
+			after = s[i+1] >= 'a' && s[i+1] <= 'z'
+		}
+		if i > 0 && d >= 'A' && d <= 'Z' && (before || after) {
+			data = append(data, '_')
+		}
+		data = append(data, d)
+	}
+	return strings.ToLower(string(data[:]))
+}
+
+// snake string, XxYy to xx_yy , XxYY to xx_y_y
 func snakeString(s string) string {
 func snakeString(s string) string {
 	data := make([]byte, 0, len(s)*2)
 	data := make([]byte, 0, len(s)*2)
 	j := false
 	j := false
@@ -216,6 +249,14 @@ func snakeString(s string) string {
 	return strings.ToLower(string(data[:]))
 	return strings.ToLower(string(data[:]))
 }
 }
 
 
+// SetNameStrategy set different name strategy
+func SetNameStrategy(s string) {
+	if SnakeAcronymNameStrategy != s {
+		nameStrategy = defaultNameStrategy
+	}
+	nameStrategy = s
+}
+
 // camel string, xx_yy to XxYy
 // camel string, xx_yy to XxYy
 func camelString(s string) string {
 func camelString(s string) string {
 	data := make([]byte, 0, len(s))
 	data := make([]byte, 0, len(s))

@@ -39,7 +39,7 @@ var globalRouterTemplate = `package routers
 
 
 import (
 import (
 	"github.com/astaxie/beego"
 	"github.com/astaxie/beego"
-	"github.com/astaxie/beego/context/param"
+	"github.com/astaxie/beego/context/param"{{.globalimport}}
 )
 )
 
 
 func init() {
 func init() {
@@ -52,6 +52,22 @@ var (
 	commentFilename    string
 	commentFilename    string
 	pkgLastupdate      map[string]int64
 	pkgLastupdate      map[string]int64
 	genInfoList        map[string][]ControllerComments
 	genInfoList        map[string][]ControllerComments
+
+	routerHooks = map[string]int{
+		"beego.BeforeStatic": BeforeStatic,
+		"beego.BeforeRouter": BeforeRouter,
+		"beego.BeforeExec":   BeforeExec,
+		"beego.AfterExec":    AfterExec,
+		"beego.FinishRouter": FinishRouter,
+	}
+
+	routerHooksMapping = map[int]string{
+		BeforeStatic: "beego.BeforeStatic",
+		BeforeRouter: "beego.BeforeRouter",
+		BeforeExec:   "beego.BeforeExec",
+		AfterExec:    "beego.AfterExec",
+		FinishRouter: "beego.FinishRouter",
+	}
 )
 )
 
 
 const commentPrefix = "commentsRouter_"
 const commentPrefix = "commentsRouter_"
@@ -102,6 +118,20 @@ type parsedComment struct {
 	routerPath string
 	routerPath string
 	methods    []string
 	methods    []string
 	params     map[string]parsedParam
 	params     map[string]parsedParam
+	filters    []parsedFilter
+	imports    []parsedImport
+}
+
+type parsedImport struct {
+	importPath  string
+	importAlias string
+}
+
+type parsedFilter struct {
+	pattern string
+	pos     int
+	filter  string
+	params  []bool
 }
 }
 
 
 type parsedParam struct {
 type parsedParam struct {
@@ -126,6 +156,8 @@ func parserComments(f *ast.FuncDecl, controllerName, pkgpath string) error {
 				cc.Router = parsedComment.routerPath
 				cc.Router = parsedComment.routerPath
 				cc.AllowHTTPMethods = parsedComment.methods
 				cc.AllowHTTPMethods = parsedComment.methods
 				cc.MethodParams = buildMethodParams(f.Type.Params.List, parsedComment)
 				cc.MethodParams = buildMethodParams(f.Type.Params.List, parsedComment)
+				cc.FilterComments = buildFilters(parsedComment.filters)
+				cc.ImportComments = buildImports(parsedComment.imports)
 				genInfoList[key] = append(genInfoList[key], cc)
 				genInfoList[key] = append(genInfoList[key], cc)
 			}
 			}
 		}
 		}
@@ -133,6 +165,48 @@ func parserComments(f *ast.FuncDecl, controllerName, pkgpath string) error {
 	return nil
 	return nil
 }
 }
 
 
+func buildImports(pis []parsedImport) []*ControllerImportComments {
+	var importComments []*ControllerImportComments
+
+	for _, pi := range pis {
+		importComments = append(importComments, &ControllerImportComments{
+			ImportPath:  pi.importPath,
+			ImportAlias: pi.importAlias,
+		})
+	}
+
+	return importComments
+}
+
+func buildFilters(pfs []parsedFilter) []*ControllerFilterComments {
+	var filterComments []*ControllerFilterComments
+
+	for _, pf := range pfs {
+		var (
+			returnOnOutput bool
+			resetParams    bool
+		)
+
+		if len(pf.params) >= 1 {
+			returnOnOutput = pf.params[0]
+		}
+
+		if len(pf.params) >= 2 {
+			resetParams = pf.params[1]
+		}
+
+		filterComments = append(filterComments, &ControllerFilterComments{
+			Filter:         pf.filter,
+			Pattern:        pf.pattern,
+			Pos:            pf.pos,
+			ReturnOnOutput: returnOnOutput,
+			ResetParams:    resetParams,
+		})
+	}
+
+	return filterComments
+}
+
 func buildMethodParams(funcParams []*ast.Field, pc *parsedComment) []*param.MethodParam {
 func buildMethodParams(funcParams []*ast.Field, pc *parsedComment) []*param.MethodParam {
 	result := make([]*param.MethodParam, 0, len(funcParams))
 	result := make([]*param.MethodParam, 0, len(funcParams))
 	for _, fparam := range funcParams {
 	for _, fparam := range funcParams {
@@ -181,6 +255,8 @@ var routeRegex = regexp.MustCompile(`@router\s+(\S+)(?:\s+\[(\S+)\])?`)
 func parseComment(lines []*ast.Comment) (pcs []*parsedComment, err error) {
 func parseComment(lines []*ast.Comment) (pcs []*parsedComment, err error) {
 	pcs = []*parsedComment{}
 	pcs = []*parsedComment{}
 	params := map[string]parsedParam{}
 	params := map[string]parsedParam{}
+	filters := []parsedFilter{}
+	imports := []parsedImport{}
 
 
 	for _, c := range lines {
 	for _, c := range lines {
 		t := strings.TrimSpace(strings.TrimLeft(c.Text, "//"))
 		t := strings.TrimSpace(strings.TrimLeft(c.Text, "//"))
@@ -210,8 +286,68 @@ func parseComment(lines []*ast.Comment) (pcs []*parsedComment, err error) {
 	}
 	}
 
 
 	for _, c := range lines {
 	for _, c := range lines {
+		t := strings.TrimSpace(strings.TrimLeft(c.Text, "//"))
+		if strings.HasPrefix(t, "@Import") {
+			iv := getparams(strings.TrimSpace(strings.TrimLeft(t, "@Import")))
+			if len(iv) == 0 || len(iv) > 2 {
+				logs.Error("Invalid @Import format. Only accepts 1 or 2 parameters")
+				continue
+			}
+
+			p := parsedImport{}
+			p.importPath = iv[0]
+
+			if len(iv) == 2 {
+				p.importAlias = iv[1]
+			}
+
+			imports = append(imports, p)
+		}
+	}
+
+filterLoop:
+	for _, c := range lines {
+		t := strings.TrimSpace(strings.TrimLeft(c.Text, "//"))
+		if strings.HasPrefix(t, "@Filter") {
+			fv := getparams(strings.TrimSpace(strings.TrimLeft(t, "@Filter")))
+			if len(fv) < 3 {
+				logs.Error("Invalid @Filter format. Needs at least 3 parameters")
+				continue filterLoop
+			}
+
+			p := parsedFilter{}
+			p.pattern = fv[0]
+			posName := fv[1]
+			if pos, exists := routerHooks[posName]; exists {
+				p.pos = pos
+			} else {
+				logs.Error("Invalid @Filter pos: ", posName)
+				continue filterLoop
+			}
+
+			p.filter = fv[2]
+			fvParams := fv[3:]
+			for _, fvParam := range fvParams {
+				switch fvParam {
+				case "true":
+					p.params = append(p.params, true)
+				case "false":
+					p.params = append(p.params, false)
+				default:
+					logs.Error("Invalid @Filter param: ", fvParam)
+					continue filterLoop
+				}
+			}
+
+			filters = append(filters, p)
+		}
+	}
+
+	for _, c := range lines {
 		var pc = &parsedComment{}
 		var pc = &parsedComment{}
 		pc.params = params
 		pc.params = params
+		pc.filters = filters
+		pc.imports = imports
 
 
 		t := strings.TrimSpace(strings.TrimLeft(c.Text, "//"))
 		t := strings.TrimSpace(strings.TrimLeft(c.Text, "//"))
 		if strings.HasPrefix(t, "@router") {
 		if strings.HasPrefix(t, "@router") {
@@ -276,8 +412,9 @@ func genRouterCode(pkgRealpath string) {
 	os.Mkdir(getRouterDir(pkgRealpath), 0755)
 	os.Mkdir(getRouterDir(pkgRealpath), 0755)
 	logs.Info("generate router from comments")
 	logs.Info("generate router from comments")
 	var (
 	var (
-		globalinfo string
-		sortKey    []string
+		globalinfo   string
+		globalimport string
+		sortKey      []string
 	)
 	)
 	for k := range genInfoList {
 	for k := range genInfoList {
 		sortKey = append(sortKey, k)
 		sortKey = append(sortKey, k)
@@ -295,6 +432,7 @@ func genRouterCode(pkgRealpath string) {
 				}
 				}
 				allmethod = strings.TrimRight(allmethod, ",") + "}"
 				allmethod = strings.TrimRight(allmethod, ",") + "}"
 			}
 			}
+
 			params := "nil"
 			params := "nil"
 			if len(c.Params) > 0 {
 			if len(c.Params) > 0 {
 				params = "[]map[string]string{"
 				params = "[]map[string]string{"
@@ -305,6 +443,7 @@ func genRouterCode(pkgRealpath string) {
 				}
 				}
 				params = strings.TrimRight(params, ",") + "}"
 				params = strings.TrimRight(params, ",") + "}"
 			}
 			}
+
 			methodParams := "param.Make("
 			methodParams := "param.Make("
 			if len(c.MethodParams) > 0 {
 			if len(c.MethodParams) > 0 {
 				lines := make([]string, 0, len(c.MethodParams))
 				lines := make([]string, 0, len(c.MethodParams))
@@ -316,24 +455,66 @@ func genRouterCode(pkgRealpath string) {
 					",\n			"
 					",\n			"
 			}
 			}
 			methodParams += ")"
 			methodParams += ")"
+
+			imports := ""
+			if len(c.ImportComments) > 0 {
+				for _, i := range c.ImportComments {
+					if i.ImportAlias != "" {
+						imports += fmt.Sprintf(`
+	%s "%s"`, i.ImportAlias, i.ImportPath)
+					} else {
+						imports += fmt.Sprintf(`
+	"%s"`, i.ImportPath)
+					}
+				}
+			}
+
+			filters := ""
+			if len(c.FilterComments) > 0 {
+				for _, f := range c.FilterComments {
+					filters += fmt.Sprintf(`                &beego.ControllerFilter{
+                    Pattern: "%s",
+                    Pos: %s,
+                    Filter: %s,
+                    ReturnOnOutput: %v,
+                    ResetParams: %v,
+                },`, f.Pattern, routerHooksMapping[f.Pos], f.Filter, f.ReturnOnOutput, f.ResetParams)
+				}
+			}
+
+			if filters == "" {
+				filters = "nil"
+			} else {
+				filters = fmt.Sprintf(`[]*beego.ControllerFilter{
+%s
+            }`, filters)
+			}
+
+			globalimport = imports
+
 			globalinfo = globalinfo + `
 			globalinfo = globalinfo + `
-	beego.GlobalControllerRouter["` + k + `"] = append(beego.GlobalControllerRouter["` + k + `"],
-		beego.ControllerComments{
-			Method: "` + strings.TrimSpace(c.Method) + `",
-			` + "Router: `" + c.Router + "`" + `,
-			AllowHTTPMethods: ` + allmethod + `,
-			MethodParams: ` + methodParams + `,
-			Params: ` + params + `})
+    beego.GlobalControllerRouter["` + k + `"] = append(beego.GlobalControllerRouter["` + k + `"],
+        beego.ControllerComments{
+            Method: "` + strings.TrimSpace(c.Method) + `",
+            ` + "Router: `" + c.Router + "`" + `,
+            AllowHTTPMethods: ` + allmethod + `,
+            MethodParams: ` + methodParams + `,
+            Filters: ` + filters + `,
+            Params: ` + params + `})
 `
 `
 		}
 		}
 	}
 	}
+
 	if globalinfo != "" {
 	if globalinfo != "" {
 		f, err := os.Create(filepath.Join(getRouterDir(pkgRealpath), commentFilename))
 		f, err := os.Create(filepath.Join(getRouterDir(pkgRealpath), commentFilename))
 		if err != nil {
 		if err != nil {
 			panic(err)
 			panic(err)
 		}
 		}
 		defer f.Close()
 		defer f.Close()
-		f.WriteString(strings.Replace(globalRouterTemplate, "{{.globalinfo}}", globalinfo, -1))
+
+		content := strings.Replace(globalRouterTemplate, "{{.globalinfo}}", globalinfo, -1)
+		content = strings.Replace(content, "{{.globalimport}}", globalimport, -1)
+		f.WriteString(content)
 	}
 	}
 }
 }
 
 

+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package cors provides handlers to enable CORS support.
+// Usage
+//	import (
+// 		"github.com/astaxie/beego"
+//		"github.com/astaxie/beego/plugins/cors"
+// )
+//
+//	func main() {
+//		// CORS for https://foo.* origins, allowing:
+//		// - PUT and PATCH methods
+//		// - Origin header
+//		// - Credentials share
+//		beego.InsertFilter("*", beego.BeforeRouter, cors.Allow(&cors.Options{
+//			AllowOrigins:     []string{"https://*.foo.com"},
+//			AllowMethods:     []string{"PUT", "PATCH"},
+//			AllowHeaders:     []string{"Origin"},
+//			ExposeHeaders:    []string{"Content-Length"},
+//			AllowCredentials: true,
+//		}))
+//		beego.Run()
+//	}
+package cors
+
+import (
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/context"
+)
+
+const (
+	headerAllowOrigin      = "Access-Control-Allow-Origin"
+	headerAllowCredentials = "Access-Control-Allow-Credentials"
+	headerAllowHeaders     = "Access-Control-Allow-Headers"
+	headerAllowMethods     = "Access-Control-Allow-Methods"
+	headerExposeHeaders    = "Access-Control-Expose-Headers"
+	headerMaxAge           = "Access-Control-Max-Age"
+
+	headerOrigin         = "Origin"
+	headerRequestMethod  = "Access-Control-Request-Method"
+	headerRequestHeaders = "Access-Control-Request-Headers"
+)
+
+var (
+	defaultAllowHeaders = []string{"Origin", "Accept", "Content-Type", "Authorization"}
+	// Regex patterns are generated from AllowOrigins. These are used and generated internally.
+	allowOriginPatterns = []string{}
+)
+
+// Options represents Access Control options.
+type Options struct {
+	// If set, all origins are allowed.
+	AllowAllOrigins bool
+	// A list of allowed origins. Wild cards and FQDNs are supported.
+	AllowOrigins []string
+	// If set, allows to share auth credentials such as cookies.
+	AllowCredentials bool
+	// A list of allowed HTTP methods.
+	AllowMethods []string
+	// A list of allowed HTTP headers.
+	AllowHeaders []string
+	// A list of exposed HTTP headers.
+	ExposeHeaders []string
+	// Max age of the CORS headers.
+	MaxAge time.Duration
+}
+
+// Header converts options into CORS headers.
+func (o *Options) Header(origin string) (headers map[string]string) {
+	headers = make(map[string]string)
+	// if origin is not allowed, don't extend the headers
+	// with CORS headers.
+	if !o.AllowAllOrigins && !o.IsOriginAllowed(origin) {
+		return
+	}
+
+	// add allow origin
+	if o.AllowAllOrigins {
+		headers[headerAllowOrigin] = "*"
+	} else {
+		headers[headerAllowOrigin] = origin
+	}
+
+	// add allow credentials
+	headers[headerAllowCredentials] = strconv.FormatBool(o.AllowCredentials)
+
+	// add allow methods
+	if len(o.AllowMethods) > 0 {
+		headers[headerAllowMethods] = strings.Join(o.AllowMethods, ",")
+	}
+
+	// add allow headers
+	if len(o.AllowHeaders) > 0 {
+		headers[headerAllowHeaders] = strings.Join(o.AllowHeaders, ",")
+	}
+
+	// add exposed header
+	if len(o.ExposeHeaders) > 0 {
+		headers[headerExposeHeaders] = strings.Join(o.ExposeHeaders, ",")
+	}
+	// add a max age header
+	if o.MaxAge > time.Duration(0) {
+		headers[headerMaxAge] = strconv.FormatInt(int64(o.MaxAge/time.Second), 10)
+	}
+	return
+}
+
+// PreflightHeader converts options into CORS headers for a preflight response.
+func (o *Options) PreflightHeader(origin, rMethod, rHeaders string) (headers map[string]string) {
+	headers = make(map[string]string)
+	if !o.AllowAllOrigins && !o.IsOriginAllowed(origin) {
+		return
+	}
+	// verify if requested method is allowed
+	for _, method := range o.AllowMethods {
+		if method == rMethod {
+			headers[headerAllowMethods] = strings.Join(o.AllowMethods, ",")
+			break
+		}
+	}
+
+	// verify if requested headers are allowed
+	var allowed []string
+	for _, rHeader := range strings.Split(rHeaders, ",") {
+		rHeader = strings.TrimSpace(rHeader)
+	lookupLoop:
+		for _, allowedHeader := range o.AllowHeaders {
+			if strings.ToLower(rHeader) == strings.ToLower(allowedHeader) {
+				allowed = append(allowed, rHeader)
+				break lookupLoop
+			}
+		}
+	}
+
+	headers[headerAllowCredentials] = strconv.FormatBool(o.AllowCredentials)
+	// add allow origin
+	if o.AllowAllOrigins {
+		headers[headerAllowOrigin] = "*"
+	} else {
+		headers[headerAllowOrigin] = origin
+	}
+
+	// add allowed headers
+	if len(allowed) > 0 {
+		headers[headerAllowHeaders] = strings.Join(allowed, ",")
+	}
+
+	// add exposed headers
+	if len(o.ExposeHeaders) > 0 {
+		headers[headerExposeHeaders] = strings.Join(o.ExposeHeaders, ",")
+	}
+	// add a max age header
+	if o.MaxAge > time.Duration(0) {
+		headers[headerMaxAge] = strconv.FormatInt(int64(o.MaxAge/time.Second), 10)
+	}
+	return
+}
+
+// IsOriginAllowed looks up if the origin matches one of the patterns
+// generated from Options.AllowOrigins patterns.
+func (o *Options) IsOriginAllowed(origin string) (allowed bool) {
+	for _, pattern := range allowOriginPatterns {
+		allowed, _ = regexp.MatchString(pattern, origin)
+		if allowed {
+			return
+		}
+	}
+	return
+}
+
+// Allow enables CORS for requests those match the provided options.
+func Allow(opts *Options) beego.FilterFunc {
+	// Allow default headers if nothing is specified.
+	if len(opts.AllowHeaders) == 0 {
+		opts.AllowHeaders = defaultAllowHeaders
+	}
+
+	for _, origin := range opts.AllowOrigins {
+		pattern := regexp.QuoteMeta(origin)
+		pattern = strings.Replace(pattern, "\\*", ".*", -1)
+		pattern = strings.Replace(pattern, "\\?", ".", -1)
+		allowOriginPatterns = append(allowOriginPatterns, "^"+pattern+"$")
+	}
+
+	return func(ctx *context.Context) {
+		var (
+			origin           = ctx.Input.Header(headerOrigin)
+			requestedMethod  = ctx.Input.Header(headerRequestMethod)
+			requestedHeaders = ctx.Input.Header(headerRequestHeaders)
+			// additional headers to be added
+			// to the response.
+			headers map[string]string
+		)
+
+		if ctx.Input.Method() == "OPTIONS" &&
+			(requestedMethod != "" || requestedHeaders != "") {
+			headers = opts.PreflightHeader(origin, requestedMethod, requestedHeaders)
+			for key, value := range headers {
+				ctx.Output.Header(key, value)
+			}
+			ctx.ResponseWriter.WriteHeader(http.StatusOK)
+			return
+		}
+		headers = opts.Header(origin)
+
+		for key, value := range headers {
+			ctx.Output.Header(key, value)
+		}
+	}
+}

@@ -43,7 +43,7 @@ const (
 )
 )
 
 
 const (
 const (
-	routerTypeBeego   = iota
+	routerTypeBeego = iota
 	routerTypeRESTFul
 	routerTypeRESTFul
 	routerTypeHandler
 	routerTypeHandler
 )
 )
@@ -133,14 +133,15 @@ type ControllerRegister struct {
 
 
 // NewControllerRegister returns a new ControllerRegister.
 // NewControllerRegister returns a new ControllerRegister.
 func NewControllerRegister() *ControllerRegister {
 func NewControllerRegister() *ControllerRegister {
-	cr := &ControllerRegister{
+	return &ControllerRegister{
 		routers:  make(map[string]*Tree),
 		routers:  make(map[string]*Tree),
 		policies: make(map[string]*Tree),
 		policies: make(map[string]*Tree),
+		pool: sync.Pool{
+			New: func() interface{} {
+				return beecontext.NewContext()
+			},
+		},
 	}
 	}
-	cr.pool.New = func() interface{} {
-		return beecontext.NewContext()
-	}
-	return cr
 }
 }
 
 
 // Add controller handler and pattern rules to ControllerRegister.
 // Add controller handler and pattern rules to ControllerRegister.
@@ -277,6 +278,10 @@ func (p *ControllerRegister) Include(cList ...ControllerInterface) {
 		key := t.PkgPath() + ":" + t.Name()
 		key := t.PkgPath() + ":" + t.Name()
 		if comm, ok := GlobalControllerRouter[key]; ok {
 		if comm, ok := GlobalControllerRouter[key]; ok {
 			for _, a := range comm {
 			for _, a := range comm {
+				for _, f := range a.Filters {
+					p.InsertFilter(f.Pattern, f.Pos, f.Filter, f.ReturnOnOutput, f.ResetParams)
+				}
+
 				p.addWithMethodParams(a.Router, c, a.MethodParams, strings.Join(a.AllowHTTPMethods, ",")+":"+a.Method)
 				p.addWithMethodParams(a.Router, c, a.MethodParams, strings.Join(a.AllowHTTPMethods, ",")+":"+a.Method)
 			}
 			}
 		}
 		}
@@ -794,7 +799,7 @@ func (p *ControllerRegister) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 	if !isRunnable {
 	if !isRunnable {
 		//Invoke the request handler
 		//Invoke the request handler
 		var execController ControllerInterface
 		var execController ControllerInterface
-		if routerInfo.initialize != nil {
+		if routerInfo != nil && routerInfo.initialize != nil {
 			execController = routerInfo.initialize()
 			execController = routerInfo.initialize()
 		} else {
 		} else {
 			vc := reflect.New(runRouter)
 			vc := reflect.New(runRouter)
@@ -877,7 +882,7 @@ func (p *ControllerRegister) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 	}
 	}
 
 
 Admin:
 Admin:
-//admin module record QPS
+	//admin module record QPS
 
 
 	statusCode := context.ResponseWriter.Status
 	statusCode := context.ResponseWriter.Status
 	if statusCode == 0 {
 	if statusCode == 0 {
@@ -886,8 +891,9 @@ Admin:
 
 
 	logAccess(context, &startTime, statusCode)
 	logAccess(context, &startTime, statusCode)
 
 
+	timeDur := time.Since(startTime)
+	context.ResponseWriter.Elapsed = timeDur
 	if BConfig.Listen.EnableAdmin {
 	if BConfig.Listen.EnableAdmin {
-		timeDur := time.Since(startTime)
 		pattern := ""
 		pattern := ""
 		if routerInfo != nil {
 		if routerInfo != nil {
 			pattern = routerInfo.pattern
 			pattern = routerInfo.pattern
@@ -904,7 +910,6 @@ Admin:
 
 
 	if BConfig.RunMode == DEV && !BConfig.Log.AccessLogs {
 	if BConfig.RunMode == DEV && !BConfig.Log.AccessLogs {
 		var devInfo string
 		var devInfo string
-		timeDur := time.Since(startTime)
 		iswin := (runtime.GOOS == "windows")
 		iswin := (runtime.GOOS == "windows")
 		statusColor := logs.ColorByStatus(iswin, statusCode)
 		statusColor := logs.ColorByStatus(iswin, statusCode)
 		methodColor := logs.ColorByMethod(iswin, r.Method)
 		methodColor := logs.ColorByMethod(iswin, r.Method)

@@ -21,6 +21,7 @@ import (
 	"os"
 	"os"
 	"path"
 	"path"
 	"path/filepath"
 	"path/filepath"
+	"strings"
 	"sync"
 	"sync"
 	"time"
 	"time"
 )
 )
@@ -127,6 +128,9 @@ func (fp *FileProvider) SessionInit(maxlifetime int64, savePath string) error {
 // if file is not exist, create it.
 // if file is not exist, create it.
 // the file path is generated from sid string.
 // the file path is generated from sid string.
 func (fp *FileProvider) SessionRead(sid string) (Store, error) {
 func (fp *FileProvider) SessionRead(sid string) (Store, error) {
+	if strings.ContainsAny(sid, "./") {
+		return nil, nil
+	}
 	filepder.lock.Lock()
 	filepder.lock.Lock()
 	defer filepder.lock.Unlock()
 	defer filepder.lock.Unlock()
 
 

@@ -96,6 +96,7 @@ type ManagerConfig struct {
 	EnableSidInHTTPHeader   bool   `json:"EnableSidInHTTPHeader"`
 	EnableSidInHTTPHeader   bool   `json:"EnableSidInHTTPHeader"`
 	SessionNameInHTTPHeader string `json:"SessionNameInHTTPHeader"`
 	SessionNameInHTTPHeader string `json:"SessionNameInHTTPHeader"`
 	EnableSidInURLQuery     bool   `json:"EnableSidInURLQuery"`
 	EnableSidInURLQuery     bool   `json:"EnableSidInURLQuery"`
+	SessionIDPrefix         string `json:"sessionIDPrefix"`
 }
 }
 
 
 // Manager contains Provider and its configuration.
 // Manager contains Provider and its configuration.
@@ -153,6 +154,11 @@ func NewManager(provideName string, cf *ManagerConfig) (*Manager, error) {
 	}, nil
 	}, nil
 }
 }
 
 
+// GetProvider return current manager's provider
+func (manager *Manager) GetProvider() Provider {
+	return manager.provider
+}
+
 // getSid retrieves session identifier from HTTP Request.
 // getSid retrieves session identifier from HTTP Request.
 // First try to retrieve id by reading from cookie, session cookie name is configurable,
 // First try to retrieve id by reading from cookie, session cookie name is configurable,
 // if not exist, then retrieve id from querying parameters.
 // if not exist, then retrieve id from querying parameters.
@@ -331,7 +337,7 @@ func (manager *Manager) sessionID() (string, error) {
 	if n != len(b) || err != nil {
 	if n != len(b) || err != nil {
 		return "", fmt.Errorf("Could not successfully read from the system CSPRNG")
 		return "", fmt.Errorf("Could not successfully read from the system CSPRNG")
 	}
 	}
-	return hex.EncodeToString(b), nil
+	return manager.config.SessionIDPrefix + hex.EncodeToString(b), nil
 }
 }
 
 
 // Set cookie with https.
 // Set cookie with https.

@@ -178,7 +178,7 @@ func searchFile(ctx *context.Context) (string, os.FileInfo, error) {
 		if !strings.Contains(requestPath, prefix) {
 		if !strings.Contains(requestPath, prefix) {
 			continue
 			continue
 		}
 		}
-		if len(requestPath) > len(prefix) && requestPath[len(prefix)] != '/' {
+		if prefix != "/" &&  len(requestPath) > len(prefix) && requestPath[len(prefix)] != '/' {
 			continue
 			continue
 		}
 		}
 		filePath := path.Join(staticDir, requestPath[len(prefix):])
 		filePath := path.Join(staticDir, requestPath[len(prefix):])

@@ -20,6 +20,7 @@ import (
 	"html/template"
 	"html/template"
 	"io"
 	"io"
 	"io/ioutil"
 	"io/ioutil"
+	"net/http"
 	"os"
 	"os"
 	"path/filepath"
 	"path/filepath"
 	"regexp"
 	"regexp"
@@ -40,6 +41,7 @@ var (
 	beeTemplateExt = []string{"tpl", "html"}
 	beeTemplateExt = []string{"tpl", "html"}
 	// beeTemplatePreprocessors stores associations of extension -> preprocessor handler
 	// beeTemplatePreprocessors stores associations of extension -> preprocessor handler
 	beeTemplateEngines = map[string]templatePreProcessor{}
 	beeTemplateEngines = map[string]templatePreProcessor{}
+	beeTemplateFS      = defaultFSFunc
 )
 )
 
 
 // ExecuteTemplate applies the template with name  to the specified data object,
 // ExecuteTemplate applies the template with name  to the specified data object,
@@ -181,12 +183,17 @@ func lockViewPaths() {
 // BuildTemplate will build all template files in a directory.
 // BuildTemplate will build all template files in a directory.
 // it makes beego can render any template file in view directory.
 // it makes beego can render any template file in view directory.
 func BuildTemplate(dir string, files ...string) error {
 func BuildTemplate(dir string, files ...string) error {
-	if _, err := os.Stat(dir); err != nil {
+	var err error
+	fs := beeTemplateFS()
+	f, err := fs.Open(dir)
+	if err != nil {
 		if os.IsNotExist(err) {
 		if os.IsNotExist(err) {
 			return nil
 			return nil
 		}
 		}
 		return errors.New("dir open err")
 		return errors.New("dir open err")
 	}
 	}
+	defer f.Close()
+
 	beeTemplates, ok := beeViewPathTemplates[dir]
 	beeTemplates, ok := beeViewPathTemplates[dir]
 	if !ok {
 	if !ok {
 		panic("Unknown view path: " + dir)
 		panic("Unknown view path: " + dir)
@@ -195,11 +202,11 @@ func BuildTemplate(dir string, files ...string) error {
 		root:  dir,
 		root:  dir,
 		files: make(map[string][]string),
 		files: make(map[string][]string),
 	}
 	}
-	err := filepath.Walk(dir, func(path string, f os.FileInfo, err error) error {
+	err = Walk(fs, dir, func(path string, f os.FileInfo, err error) error {
 		return self.visit(path, f, err)
 		return self.visit(path, f, err)
 	})
 	})
 	if err != nil {
 	if err != nil {
-		fmt.Printf("filepath.Walk() returned %v\n", err)
+		fmt.Printf("Walk() returned %v\n", err)
 		return err
 		return err
 	}
 	}
 	buildAllFiles := len(files) == 0
 	buildAllFiles := len(files) == 0
@@ -210,11 +217,11 @@ func BuildTemplate(dir string, files ...string) error {
 				ext := filepath.Ext(file)
 				ext := filepath.Ext(file)
 				var t *template.Template
 				var t *template.Template
 				if len(ext) == 0 {
 				if len(ext) == 0 {
-					t, err = getTemplate(self.root, file, v...)
+					t, err = getTemplate(self.root, fs, file, v...)
 				} else if fn, ok := beeTemplateEngines[ext[1:]]; ok {
 				} else if fn, ok := beeTemplateEngines[ext[1:]]; ok {
 					t, err = fn(self.root, file, beegoTplFuncMap)
 					t, err = fn(self.root, file, beegoTplFuncMap)
 				} else {
 				} else {
-					t, err = getTemplate(self.root, file, v...)
+					t, err = getTemplate(self.root, fs, file, v...)
 				}
 				}
 				if err != nil {
 				if err != nil {
 					logs.Error("parse template err:", file, err)
 					logs.Error("parse template err:", file, err)
@@ -229,9 +236,10 @@ func BuildTemplate(dir string, files ...string) error {
 	return nil
 	return nil
 }
 }
 
 
-func getTplDeep(root, file, parent string, t *template.Template) (*template.Template, [][]string, error) {
+func getTplDeep(root string, fs http.FileSystem, file string, parent string, t *template.Template) (*template.Template, [][]string, error) {
 	var fileAbsPath string
 	var fileAbsPath string
 	var rParent string
 	var rParent string
+	var err error
 	if filepath.HasPrefix(file, "../") {
 	if filepath.HasPrefix(file, "../") {
 		rParent = filepath.Join(filepath.Dir(parent), file)
 		rParent = filepath.Join(filepath.Dir(parent), file)
 		fileAbsPath = filepath.Join(root, filepath.Dir(parent), file)
 		fileAbsPath = filepath.Join(root, filepath.Dir(parent), file)
@@ -239,10 +247,12 @@ func getTplDeep(root, file, parent string, t *template.Template) (*template.Temp
 		rParent = file
 		rParent = file
 		fileAbsPath = filepath.Join(root, file)
 		fileAbsPath = filepath.Join(root, file)
 	}
 	}
-	if e := utils.FileExists(fileAbsPath); !e {
+	f, err := fs.Open(fileAbsPath)
+	defer f.Close()
+	if err != nil {
 		panic("can't find template file:" + file)
 		panic("can't find template file:" + file)
 	}
 	}
-	data, err := ioutil.ReadFile(fileAbsPath)
+	data, err := ioutil.ReadAll(f)
 	if err != nil {
 	if err != nil {
 		return nil, [][]string{}, err
 		return nil, [][]string{}, err
 	}
 	}
@@ -261,7 +271,7 @@ func getTplDeep(root, file, parent string, t *template.Template) (*template.Temp
 			if !HasTemplateExt(m[1]) {
 			if !HasTemplateExt(m[1]) {
 				continue
 				continue
 			}
 			}
-			_, _, err = getTplDeep(root, m[1], rParent, t)
+			_, _, err = getTplDeep(root, fs, m[1], rParent, t)
 			if err != nil {
 			if err != nil {
 				return nil, [][]string{}, err
 				return nil, [][]string{}, err
 			}
 			}
@@ -270,14 +280,14 @@ func getTplDeep(root, file, parent string, t *template.Template) (*template.Temp
 	return t, allSub, nil
 	return t, allSub, nil
 }
 }
 
 
-func getTemplate(root, file string, others ...string) (t *template.Template, err error) {
+func getTemplate(root string, fs http.FileSystem, file string, others ...string) (t *template.Template, err error) {
 	t = template.New(file).Delims(BConfig.WebConfig.TemplateLeft, BConfig.WebConfig.TemplateRight).Funcs(beegoTplFuncMap)
 	t = template.New(file).Delims(BConfig.WebConfig.TemplateLeft, BConfig.WebConfig.TemplateRight).Funcs(beegoTplFuncMap)
 	var subMods [][]string
 	var subMods [][]string
-	t, subMods, err = getTplDeep(root, file, "", t)
+	t, subMods, err = getTplDeep(root, fs, file, "", t)
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
-	t, err = _getTemplate(t, root, subMods, others...)
+	t, err = _getTemplate(t, root, fs, subMods, others...)
 
 
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
@@ -285,7 +295,7 @@ func getTemplate(root, file string, others ...string) (t *template.Template, err
 	return
 	return
 }
 }
 
 
-func _getTemplate(t0 *template.Template, root string, subMods [][]string, others ...string) (t *template.Template, err error) {
+func _getTemplate(t0 *template.Template, root string, fs http.FileSystem, subMods [][]string, others ...string) (t *template.Template, err error) {
 	t = t0
 	t = t0
 	for _, m := range subMods {
 	for _, m := range subMods {
 		if len(m) == 2 {
 		if len(m) == 2 {
@@ -297,11 +307,11 @@ func _getTemplate(t0 *template.Template, root string, subMods [][]string, others
 			for _, otherFile := range others {
 			for _, otherFile := range others {
 				if otherFile == m[1] {
 				if otherFile == m[1] {
 					var subMods1 [][]string
 					var subMods1 [][]string
-					t, subMods1, err = getTplDeep(root, otherFile, "", t)
+					t, subMods1, err = getTplDeep(root, fs, otherFile, "", t)
 					if err != nil {
 					if err != nil {
 						logs.Trace("template parse file err:", err)
 						logs.Trace("template parse file err:", err)
 					} else if len(subMods1) > 0 {
 					} else if len(subMods1) > 0 {
-						t, err = _getTemplate(t, root, subMods1, others...)
+						t, err = _getTemplate(t, root, fs, subMods1, others...)
 					}
 					}
 					break
 					break
 				}
 				}
@@ -310,8 +320,16 @@ func _getTemplate(t0 *template.Template, root string, subMods [][]string, others
 			for _, otherFile := range others {
 			for _, otherFile := range others {
 				var data []byte
 				var data []byte
 				fileAbsPath := filepath.Join(root, otherFile)
 				fileAbsPath := filepath.Join(root, otherFile)
-				data, err = ioutil.ReadFile(fileAbsPath)
+				f, err := fs.Open(fileAbsPath)
+				if err != nil {
+					f.Close()
+					logs.Trace("template file parse error, not success open file:", err)
+					continue
+				}
+				data, err = ioutil.ReadAll(f)
+				f.Close()
 				if err != nil {
 				if err != nil {
+					logs.Trace("template file parse error, not success read file:", err)
 					continue
 					continue
 				}
 				}
 				reg := regexp.MustCompile(BConfig.WebConfig.TemplateLeft + "[ ]*define[ ]+\"([^\"]+)\"")
 				reg := regexp.MustCompile(BConfig.WebConfig.TemplateLeft + "[ ]*define[ ]+\"([^\"]+)\"")
@@ -319,11 +337,14 @@ func _getTemplate(t0 *template.Template, root string, subMods [][]string, others
 				for _, sub := range allSub {
 				for _, sub := range allSub {
 					if len(sub) == 2 && sub[1] == m[1] {
 					if len(sub) == 2 && sub[1] == m[1] {
 						var subMods1 [][]string
 						var subMods1 [][]string
-						t, subMods1, err = getTplDeep(root, otherFile, "", t)
+						t, subMods1, err = getTplDeep(root, fs, otherFile, "", t)
 						if err != nil {
 						if err != nil {
 							logs.Trace("template parse file err:", err)
 							logs.Trace("template parse file err:", err)
 						} else if len(subMods1) > 0 {
 						} else if len(subMods1) > 0 {
-							t, err = _getTemplate(t, root, subMods1, others...)
+							t, err = _getTemplate(t, root, fs, subMods1, others...)
+							if err != nil {
+								logs.Trace("template parse file err:", err)
+							}
 						}
 						}
 						break
 						break
 					}
 					}
@@ -335,6 +356,17 @@ func _getTemplate(t0 *template.Template, root string, subMods [][]string, others
 	return
 	return
 }
 }
 
 
+type templateFSFunc func() http.FileSystem
+
+func defaultFSFunc() http.FileSystem {
+	return FileSystem{}
+}
+
+// SetTemplateFSFunc set default filesystem function
+func SetTemplateFSFunc(fnt templateFSFunc) {
+	beeTemplateFS = fnt
+}
+
 // SetViewsPath sets view directory path in beego application.
 // SetViewsPath sets view directory path in beego application.
 func SetViewsPath(path string) *App {
 func SetViewsPath(path string) *App {
 	BConfig.WebConfig.ViewsPath = path
 	BConfig.WebConfig.ViewsPath = path

@@ -692,7 +692,7 @@ func ge(arg1, arg2 interface{}) (bool, error) {
 
 
 // MapGet getting value from map by keys
 // MapGet getting value from map by keys
 // usage:
 // usage:
-// Data["m"] = map[string]interface{} {
+// Data["m"] = M{
 //     "a": 1,
 //     "a": 1,
 //     "1": map[string]float64{
 //     "1": map[string]float64{
 //         "c": 4,
 //         "c": 4,

@@ -428,6 +428,9 @@ func run() {
 			continue
 			continue
 		case <-changed:
 		case <-changed:
 			now = time.Now().Local()
 			now = time.Now().Local()
+			for _, t := range AdminTaskList {
+				t.SetNext(now)
+			}
 			continue
 			continue
 		case <-stop:
 		case <-stop:
 			return
 			return
@@ -446,6 +449,7 @@ func StopTask() {
 
 
 // AddTask add task with name
 // AddTask add task with name
 func AddTask(taskname string, t Tasker) {
 func AddTask(taskname string, t Tasker) {
+	t.SetNext(time.Now().Local())
 	AdminTaskList[taskname] = t
 	AdminTaskList[taskname] = t
 	if isstart {
 	if isstart {
 		changed <- true
 		changed <- true

+language: go
+sudo: false
+go:
+    - 1.2
+    - 1.3
+    - 1.4
+    - 1.5
+    - 1.6
+    - 1.7
+    - 1.8
+    - 1.9
+    - tip
+matrix:
+    allow_failures:
+        - go: tip
+    fast_finish: true
+before_install:
+    - go get github.com/mattn/goveralls
+    - go get golang.org/x/tools/cmd/cover
+script:
+    - $HOME/gopath/bin/goveralls -service=travis-ci
+notifications:
+    email: false

+Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+# UUID package for Go language
+
+[![Build Status](https://travis-ci.org/satori/go.uuid.png?branch=master)](https://travis-ci.org/satori/go.uuid)
+[![Coverage Status](https://coveralls.io/repos/github/satori/go.uuid/badge.svg?branch=master)](https://coveralls.io/github/satori/go.uuid)
+[![GoDoc](http://godoc.org/github.com/satori/go.uuid?status.png)](http://godoc.org/github.com/satori/go.uuid)
+
+This package provides pure Go implementation of Universally Unique Identifier (UUID). Supported both creation and parsing of UUIDs.
+
+With 100% test coverage and benchmarks out of box.
+
+Supported versions:
+* Version 1, based on timestamp and MAC address (RFC 4122)
+* Version 2, based on timestamp, MAC address and POSIX UID/GID (DCE 1.1)
+* Version 3, based on MD5 hashing (RFC 4122)
+* Version 4, based on random numbers (RFC 4122)
+* Version 5, based on SHA-1 hashing (RFC 4122)
+
+## Installation
+
+Use the `go` command:
+
+	$ go get github.com/satori/go.uuid
+
+## Requirements
+
+UUID package requires Go >= 1.2.
+
+## Example
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/satori/go.uuid"
+)
+
+func main() {
+	// Creating UUID Version 4
+	u1 := uuid.NewV4()
+	fmt.Printf("UUIDv4: %s\n", u1)
+
+	// Parsing UUID from string input
+	u2, err := uuid.FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+	if err != nil {
+		fmt.Printf("Something gone wrong: %s", err)
+	}
+	fmt.Printf("Successfully parsed: %s", u2)
+}
+```
+
+## Documentation
+
+[Documentation](http://godoc.org/github.com/satori/go.uuid) is hosted at GoDoc project.
+
+## Links
+* [RFC 4122](http://tools.ietf.org/html/rfc4122)
+* [DCE 1.1: Authentication and Security Services](http://pubs.opengroup.org/onlinepubs/9696989899/chap5.htm#tagcjh_08_02_01_01)
+
+## Copyright
+
+Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>.
+
+UUID package released under MIT License.
+See [LICENSE](https://github.com/satori/go.uuid/blob/master/LICENSE) for details.

+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+)
+
+// FromBytes returns UUID converted from raw byte slice input.
+// It will return error if the slice isn't 16 bytes long.
+func FromBytes(input []byte) (u UUID, err error) {
+	err = u.UnmarshalBinary(input)
+	return
+}
+
+// FromBytesOrNil returns UUID converted from raw byte slice input.
+// Same behavior as FromBytes, but returns a Nil UUID on error.
+func FromBytesOrNil(input []byte) UUID {
+	uuid, err := FromBytes(input)
+	if err != nil {
+		return Nil
+	}
+	return uuid
+}
+
+// FromString returns UUID parsed from string input.
+// Input is expected in a form accepted by UnmarshalText.
+func FromString(input string) (u UUID, err error) {
+	err = u.UnmarshalText([]byte(input))
+	return
+}
+
+// FromStringOrNil returns UUID parsed from string input.
+// Same behavior as FromString, but returns a Nil UUID on error.
+func FromStringOrNil(input string) UUID {
+	uuid, err := FromString(input)
+	if err != nil {
+		return Nil
+	}
+	return uuid
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+// The encoding is the same as returned by String.
+func (u UUID) MarshalText() (text []byte, err error) {
+	text = []byte(u.String())
+	return
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// Following formats are supported:
+//   "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+//   "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
+//   "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+//   "6ba7b8109dad11d180b400c04fd430c8"
+// ABNF for supported UUID text representation follows:
+//   uuid := canonical | hashlike | braced | urn
+//   plain := canonical | hashlike
+//   canonical := 4hexoct '-' 2hexoct '-' 2hexoct '-' 6hexoct
+//   hashlike := 12hexoct
+//   braced := '{' plain '}'
+//   urn := URN ':' UUID-NID ':' plain
+//   URN := 'urn'
+//   UUID-NID := 'uuid'
+//   12hexoct := 6hexoct 6hexoct
+//   6hexoct := 4hexoct 2hexoct
+//   4hexoct := 2hexoct 2hexoct
+//   2hexoct := hexoct hexoct
+//   hexoct := hexdig hexdig
+//   hexdig := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |
+//             'a' | 'b' | 'c' | 'd' | 'e' | 'f' |
+//             'A' | 'B' | 'C' | 'D' | 'E' | 'F'
+func (u *UUID) UnmarshalText(text []byte) (err error) {
+	switch len(text) {
+	case 32:
+		return u.decodeHashLike(text)
+	case 36:
+		return u.decodeCanonical(text)
+	case 38:
+		return u.decodeBraced(text)
+	case 41:
+		fallthrough
+	case 45:
+		return u.decodeURN(text)
+	default:
+		return fmt.Errorf("uuid: incorrect UUID length: %s", text)
+	}
+}
+
+// decodeCanonical decodes UUID string in format
+// "6ba7b810-9dad-11d1-80b4-00c04fd430c8".
+func (u *UUID) decodeCanonical(t []byte) (err error) {
+	if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' {
+		return fmt.Errorf("uuid: incorrect UUID format %s", t)
+	}
+
+	src := t[:]
+	dst := u[:]
+
+	for i, byteGroup := range byteGroups {
+		if i > 0 {
+			src = src[1:] // skip dash
+		}
+		_, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
+		if err != nil {
+			return
+		}
+		src = src[byteGroup:]
+		dst = dst[byteGroup/2:]
+	}
+
+	return
+}
+
+// decodeHashLike decodes UUID string in format
+// "6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodeHashLike(t []byte) (err error) {
+	src := t[:]
+	dst := u[:]
+
+	if _, err = hex.Decode(dst, src); err != nil {
+		return err
+	}
+	return
+}
+
+// decodeBraced decodes UUID string in format
+// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}" or in format
+// "{6ba7b8109dad11d180b400c04fd430c8}".
+func (u *UUID) decodeBraced(t []byte) (err error) {
+	l := len(t)
+
+	if t[0] != '{' || t[l-1] != '}' {
+		return fmt.Errorf("uuid: incorrect UUID format %s", t)
+	}
+
+	return u.decodePlain(t[1 : l-1])
+}
+
+// decodeURN decodes UUID string in format
+// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in format
+// "urn:uuid:6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodeURN(t []byte) (err error) {
+	total := len(t)
+
+	urn_uuid_prefix := t[:9]
+
+	if !bytes.Equal(urn_uuid_prefix, urnPrefix) {
+		return fmt.Errorf("uuid: incorrect UUID format: %s", t)
+	}
+
+	return u.decodePlain(t[9:total])
+}
+
+// decodePlain decodes UUID string in canonical format
+// "6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in hash-like format
+// "6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodePlain(t []byte) (err error) {
+	switch len(t) {
+	case 32:
+		return u.decodeHashLike(t)
+	case 36:
+		return u.decodeCanonical(t)
+	default:
+		return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
+	}
+}
+
+// MarshalBinary implements the encoding.BinaryMarshaler interface.
+func (u UUID) MarshalBinary() (data []byte, err error) {
+	data = u.Bytes()
+	return
+}
+
+// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
+// It will return error if the slice isn't 16 bytes long.
+func (u *UUID) UnmarshalBinary(data []byte) (err error) {
+	if len(data) != Size {
+		err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
+		return
+	}
+	copy(u[:], data)
+
+	return
+}

+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+	"crypto/md5"
+	"crypto/rand"
+	"crypto/sha1"
+	"encoding/binary"
+	"hash"
+	"net"
+	"os"
+	"sync"
+	"time"
+)
+
+// Difference in 100-nanosecond intervals between
+// UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970).
+const epochStart = 122192928000000000
+
+var (
+	global = newDefaultGenerator()
+
+	epochFunc = unixTimeFunc
+	posixUID  = uint32(os.Getuid())
+	posixGID  = uint32(os.Getgid())
+)
+
+// NewV1 returns UUID based on current timestamp and MAC address.
+func NewV1() UUID {
+	return global.NewV1()
+}
+
+// NewV2 returns DCE Security UUID based on POSIX UID/GID.
+func NewV2(domain byte) UUID {
+	return global.NewV2(domain)
+}
+
+// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
+func NewV3(ns UUID, name string) UUID {
+	return global.NewV3(ns, name)
+}
+
+// NewV4 returns random generated UUID.
+func NewV4() UUID {
+	return global.NewV4()
+}
+
+// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
+func NewV5(ns UUID, name string) UUID {
+	return global.NewV5(ns, name)
+}
+
+// Generator provides interface for generating UUIDs.
+type Generator interface {
+	NewV1() UUID
+	NewV2(domain byte) UUID
+	NewV3(ns UUID, name string) UUID
+	NewV4() UUID
+	NewV5(ns UUID, name string) UUID
+}
+
+// Default generator implementation.
+type generator struct {
+	storageOnce  sync.Once
+	storageMutex sync.Mutex
+
+	lastTime      uint64
+	clockSequence uint16
+	hardwareAddr  [6]byte
+}
+
+func newDefaultGenerator() Generator {
+	return &generator{}
+}
+
+// NewV1 returns UUID based on current timestamp and MAC address.
+func (g *generator) NewV1() UUID {
+	u := UUID{}
+
+	timeNow, clockSeq, hardwareAddr := g.getStorage()
+
+	binary.BigEndian.PutUint32(u[0:], uint32(timeNow))
+	binary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32))
+	binary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48))
+	binary.BigEndian.PutUint16(u[8:], clockSeq)
+
+	copy(u[10:], hardwareAddr)
+
+	u.SetVersion(V1)
+	u.SetVariant(VariantRFC4122)
+
+	return u
+}
+
+// NewV2 returns DCE Security UUID based on POSIX UID/GID.
+func (g *generator) NewV2(domain byte) UUID {
+	u := UUID{}
+
+	timeNow, clockSeq, hardwareAddr := g.getStorage()
+
+	switch domain {
+	case DomainPerson:
+		binary.BigEndian.PutUint32(u[0:], posixUID)
+	case DomainGroup:
+		binary.BigEndian.PutUint32(u[0:], posixGID)
+	}
+
+	binary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32))
+	binary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48))
+	binary.BigEndian.PutUint16(u[8:], clockSeq)
+	u[9] = domain
+
+	copy(u[10:], hardwareAddr)
+
+	u.SetVersion(V2)
+	u.SetVariant(VariantRFC4122)
+
+	return u
+}
+
+// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
+func (g *generator) NewV3(ns UUID, name string) UUID {
+	u := newFromHash(md5.New(), ns, name)
+	u.SetVersion(V3)
+	u.SetVariant(VariantRFC4122)
+
+	return u
+}
+
+// NewV4 returns random generated UUID.
+func (g *generator) NewV4() UUID {
+	u := UUID{}
+	g.safeRandom(u[:])
+	u.SetVersion(V4)
+	u.SetVariant(VariantRFC4122)
+
+	return u
+}
+
+// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
+func (g *generator) NewV5(ns UUID, name string) UUID {
+	u := newFromHash(sha1.New(), ns, name)
+	u.SetVersion(V5)
+	u.SetVariant(VariantRFC4122)
+
+	return u
+}
+
+func (g *generator) initStorage() {
+	g.initClockSequence()
+	g.initHardwareAddr()
+}
+
+func (g *generator) initClockSequence() {
+	buf := make([]byte, 2)
+	g.safeRandom(buf)
+	g.clockSequence = binary.BigEndian.Uint16(buf)
+}
+
+func (g *generator) initHardwareAddr() {
+	interfaces, err := net.Interfaces()
+	if err == nil {
+		for _, iface := range interfaces {
+			if len(iface.HardwareAddr) >= 6 {
+				copy(g.hardwareAddr[:], iface.HardwareAddr)
+				return
+			}
+		}
+	}
+
+	// Initialize hardwareAddr randomly in case
+	// of real network interfaces absence
+	g.safeRandom(g.hardwareAddr[:])
+
+	// Set multicast bit as recommended in RFC 4122
+	g.hardwareAddr[0] |= 0x01
+}
+
+func (g *generator) safeRandom(dest []byte) {
+	if _, err := rand.Read(dest); err != nil {
+		panic(err)
+	}
+}
+
+// Returns UUID v1/v2 storage state.
+// Returns epoch timestamp, clock sequence, and hardware address.
+func (g *generator) getStorage() (uint64, uint16, []byte) {
+	g.storageOnce.Do(g.initStorage)
+
+	g.storageMutex.Lock()
+	defer g.storageMutex.Unlock()
+
+	timeNow := epochFunc()
+	// Clock changed backwards since last UUID generation.
+	// Should increase clock sequence.
+	if timeNow <= g.lastTime {
+		g.clockSequence++
+	}
+	g.lastTime = timeNow
+
+	return timeNow, g.clockSequence, g.hardwareAddr[:]
+}
+
+// Returns difference in 100-nanosecond intervals between
+// UUID epoch (October 15, 1582) and current time.
+// This is default epoch calculation function.
+func unixTimeFunc() uint64 {
+	return epochStart + uint64(time.Now().UnixNano()/100)
+}
+
+// Returns UUID based on hashing of namespace UUID and name.
+func newFromHash(h hash.Hash, ns UUID, name string) UUID {
+	u := UUID{}
+	h.Write(ns[:])
+	h.Write([]byte(name))
+	copy(u[:], h.Sum(nil))
+
+	return u
+}

+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+	"database/sql/driver"
+	"fmt"
+)
+
+// Value implements the driver.Valuer interface.
+func (u UUID) Value() (driver.Value, error) {
+	return u.String(), nil
+}
+
+// Scan implements the sql.Scanner interface.
+// A 16-byte slice is handled by UnmarshalBinary, while
+// a longer byte slice or a string is handled by UnmarshalText.
+func (u *UUID) Scan(src interface{}) error {
+	switch src := src.(type) {
+	case []byte:
+		if len(src) == Size {
+			return u.UnmarshalBinary(src)
+		}
+		return u.UnmarshalText(src)
+
+	case string:
+		return u.UnmarshalText([]byte(src))
+	}
+
+	return fmt.Errorf("uuid: cannot convert %T to UUID", src)
+}
+
+// NullUUID can be used with the standard sql package to represent a
+// UUID value that can be NULL in the database
+type NullUUID struct {
+	UUID  UUID
+	Valid bool
+}
+
+// Value implements the driver.Valuer interface.
+func (u NullUUID) Value() (driver.Value, error) {
+	if !u.Valid {
+		return nil, nil
+	}
+	// Delegate to UUID Value function
+	return u.UUID.Value()
+}
+
+// Scan implements the sql.Scanner interface.
+func (u *NullUUID) Scan(src interface{}) error {
+	if src == nil {
+		u.UUID, u.Valid = Nil, false
+		return nil
+	}
+
+	// Delegate to UUID Scan function
+	u.Valid = true
+	return u.UUID.Scan(src)
+}

+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// Package uuid provides implementation of Universally Unique Identifier (UUID).
+// Supported versions are 1, 3, 4 and 5 (as specified in RFC 4122) and
+// version 2 (as specified in DCE 1.1).
+package uuid
+
+import (
+	"bytes"
+	"encoding/hex"
+)
+
+// Size of a UUID in bytes.
+const Size = 16
+
+// UUID representation compliant with specification
+// described in RFC 4122.
+type UUID [Size]byte
+
+// UUID versions
+const (
+	_ byte = iota
+	V1
+	V2
+	V3
+	V4
+	V5
+)
+
+// UUID layout variants.
+const (
+	VariantNCS byte = iota
+	VariantRFC4122
+	VariantMicrosoft
+	VariantFuture
+)
+
+// UUID DCE domains.
+const (
+	DomainPerson = iota
+	DomainGroup
+	DomainOrg
+)
+
+// String parse helpers.
+var (
+	urnPrefix  = []byte("urn:uuid:")
+	byteGroups = []int{8, 4, 4, 4, 12}
+)
+
+// Nil is special form of UUID that is specified to have all
+// 128 bits set to zero.
+var Nil = UUID{}
+
+// Predefined namespace UUIDs.
+var (
+	NamespaceDNS  = Must(FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8"))
+	NamespaceURL  = Must(FromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8"))
+	NamespaceOID  = Must(FromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
+	NamespaceX500 = Must(FromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
+)
+
+// Equal returns true if u1 and u2 equals, otherwise returns false.
+func Equal(u1 UUID, u2 UUID) bool {
+	return bytes.Equal(u1[:], u2[:])
+}
+
+// Version returns algorithm version used to generate UUID.
+func (u UUID) Version() byte {
+	return u[6] >> 4
+}
+
+// Variant returns UUID layout variant.
+func (u UUID) Variant() byte {
+	switch {
+	case (u[8] >> 7) == 0x00:
+		return VariantNCS
+	case (u[8] >> 6) == 0x02:
+		return VariantRFC4122
+	case (u[8] >> 5) == 0x06:
+		return VariantMicrosoft
+	case (u[8] >> 5) == 0x07:
+		fallthrough
+	default:
+		return VariantFuture
+	}
+}
+
+// Bytes returns bytes slice representation of UUID.
+func (u UUID) Bytes() []byte {
+	return u[:]
+}
+
+// Returns canonical string representation of UUID:
+// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+func (u UUID) String() string {
+	buf := make([]byte, 36)
+
+	hex.Encode(buf[0:8], u[0:4])
+	buf[8] = '-'
+	hex.Encode(buf[9:13], u[4:6])
+	buf[13] = '-'
+	hex.Encode(buf[14:18], u[6:8])
+	buf[18] = '-'
+	hex.Encode(buf[19:23], u[8:10])
+	buf[23] = '-'
+	hex.Encode(buf[24:], u[10:])
+
+	return string(buf)
+}
+
+// SetVersion sets version bits.
+func (u *UUID) SetVersion(v byte) {
+	u[6] = (u[6] & 0x0f) | (v << 4)
+}
+
+// SetVariant sets variant bits.
+func (u *UUID) SetVariant(v byte) {
+	switch v {
+	case VariantNCS:
+		u[8] = (u[8]&(0xff>>1) | (0x00 << 7))
+	case VariantRFC4122:
+		u[8] = (u[8]&(0xff>>2) | (0x02 << 6))
+	case VariantMicrosoft:
+		u[8] = (u[8]&(0xff>>3) | (0x06 << 5))
+	case VariantFuture:
+		fallthrough
+	default:
+		u[8] = (u[8]&(0xff>>3) | (0x07 << 5))
+	}
+}
+
+// Must is a helper that wraps a call to a function returning (UUID, error)
+// and panics if the error is non-nil. It is intended for use in variable
+// initializations such as
+//	var packageUUID = uuid.Must(uuid.FromString("123e4567-e89b-12d3-a456-426655440000"));
+func Must(u UUID, err error) UUID {
+	if err != nil {
+		panic(err)
+	}
+	return u
+}

+example/sonyflake_server

+language: go
+go:
+  - 1.10.x
+  - 1.11.x
+sudo: false
+before_install:
+  - go get -u golang.org/x/lint/golint
+  - go get github.com/axw/gocov/gocov
+  - go get github.com/mattn/goveralls
+script:
+  - test -z "`gofmt -l .`"
+  - test -z "`golint ./...`"
+  - $GOPATH/bin/goveralls -service=travis-ci
+  - cd example && ./linux64_build.sh

+The MIT License (MIT)
+
+Copyright 2015 Sony Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

+Sonyflake
+=========
+
+[![GoDoc](https://godoc.org/github.com/sony/sonyflake?status.svg)](http://godoc.org/github.com/sony/sonyflake)
+[![Build Status](https://travis-ci.org/sony/sonyflake.svg?branch=master)](https://travis-ci.org/sony/sonyflake)
+[![Coverage Status](https://coveralls.io/repos/sony/sonyflake/badge.svg?branch=master&service=github)](https://coveralls.io/github/sony/sonyflake?branch=master)
+[![Go Report Card](https://goreportcard.com/badge/github.com/sony/sonyflake)](https://goreportcard.com/report/github.com/sony/sonyflake)
+
+Sonyflake is a distributed unique ID generator inspired by [Twitter's Snowflake](https://blog.twitter.com/2010/announcing-snowflake).  
+A Sonyflake ID is composed of
+
+    39 bits for time in units of 10 msec
+     8 bits for a sequence number
+    16 bits for a machine id
+
+Installation
+------------
+
+```
+go get github.com/sony/sonyflake
+```
+
+Usage
+-----
+
+The function NewSonyflake creates a new Sonyflake instance.
+
+```go
+func NewSonyflake(st Settings) *Sonyflake
+```
+
+You can configure Sonyflake by the struct Settings:
+
+```go
+type Settings struct {
+	StartTime      time.Time
+	MachineID      func() (uint16, error)
+	CheckMachineID func(uint16) bool
+}
+```
+
+- StartTime is the time since which the Sonyflake time is defined as the elapsed time.
+  If StartTime is 0, the start time of the Sonyflake is set to "2014-09-01 00:00:00 +0000 UTC".
+  If StartTime is ahead of the current time, Sonyflake is not created.
+
+- MachineID returns the unique ID of the Sonyflake instance.
+  If MachineID returns an error, Sonyflake is not created.
+  If MachineID is nil, default MachineID is used.
+  Default MachineID returns the lower 16 bits of the private IP address.
+
+- CheckMachineID validates the uniqueness of the machine ID.
+  If CheckMachineID returns false, Sonyflake is not created.
+  If CheckMachineID is nil, no validation is done.
+
+In order to get a new unique ID, you just have to call the method NextID.
+
+```go
+func (sf *Sonyflake) NextID() (uint64, error)
+```
+
+NextID can continue to generate IDs for about 174 years from StartTime.
+But after the Sonyflake time is over the limit, NextID returns an error.
+
+AWS VPC and Docker
+------------------
+
+The [awsutil](https://github.com/sony/sonyflake/blob/master/awsutil) package provides
+the function AmazonEC2MachineID that returns the lower 16-bit private IP address of the Amazon EC2 instance.
+It also works correctly on Docker
+by retrieving [instance metadata](http://docs.aws.amazon.com/en_us/AWSEC2/latest/UserGuide/ec2-instance-metadata.html).
+
+[AWS VPC](http://docs.aws.amazon.com/en_us/AmazonVPC/latest/UserGuide/VPC_Subnets.html)
+is assigned a single CIDR with a netmask between /28 and /16.
+So if each EC2 instance has a unique private IP address in AWS VPC,
+the lower 16 bits of the address is also unique.
+In this common case, you can use AmazonEC2MachineID as Settings.MachineID.
+
+See [example](https://github.com/sony/sonyflake/blob/master/example) that runs Sonyflake on AWS Elastic Beanstalk.
+
+License
+-------
+
+The MIT License (MIT)
+
+See [LICENSE](https://github.com/sony/sonyflake/blob/master/LICENSE) for details.

+module github.com/sony/sonyflake
+
+go 1.12
+
+require github.com/deckarep/golang-set v1.7.1

+github.com/deckarep/golang-set v1.7.1 h1:SCQV0S6gTtp6itiFrTqI+pfmJ4LN85S1YzhDf9rTHJQ=
+github.com/deckarep/golang-set v1.7.1/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=

+// Package sonyflake implements Sonyflake, a distributed unique ID generator inspired by Twitter's Snowflake.
+//
+// A Sonyflake ID is composed of
+//     39 bits for time in units of 10 msec
+//      8 bits for a sequence number
+//     16 bits for a machine id
+package sonyflake
+
+import (
+	"errors"
+	"net"
+	"sync"
+	"time"
+)
+
+// These constants are the bit lengths of Sonyflake ID parts.
+const (
+	BitLenTime      = 39                               // bit length of time
+	BitLenSequence  = 8                                // bit length of sequence number
+	BitLenMachineID = 63 - BitLenTime - BitLenSequence // bit length of machine id
+)
+
+// Settings configures Sonyflake:
+//
+// StartTime is the time since which the Sonyflake time is defined as the elapsed time.
+// If StartTime is 0, the start time of the Sonyflake is set to "2014-09-01 00:00:00 +0000 UTC".
+// If StartTime is ahead of the current time, Sonyflake is not created.
+//
+// MachineID returns the unique ID of the Sonyflake instance.
+// If MachineID returns an error, Sonyflake is not created.
+// If MachineID is nil, default MachineID is used.
+// Default MachineID returns the lower 16 bits of the private IP address.
+//
+// CheckMachineID validates the uniqueness of the machine ID.
+// If CheckMachineID returns false, Sonyflake is not created.
+// If CheckMachineID is nil, no validation is done.
+type Settings struct {
+	StartTime      time.Time
+	MachineID      func() (uint16, error)
+	CheckMachineID func(uint16) bool
+}
+
+// Sonyflake is a distributed unique ID generator.
+type Sonyflake struct {
+	mutex       *sync.Mutex
+	startTime   int64
+	elapsedTime int64
+	sequence    uint16
+	machineID   uint16
+}
+
+// NewSonyflake returns a new Sonyflake configured with the given Settings.
+// NewSonyflake returns nil in the following cases:
+// - Settings.StartTime is ahead of the current time.
+// - Settings.MachineID returns an error.
+// - Settings.CheckMachineID returns false.
+func NewSonyflake(st Settings) *Sonyflake {
+	sf := new(Sonyflake)
+	sf.mutex = new(sync.Mutex)
+	sf.sequence = uint16(1<<BitLenSequence - 1)
+
+	if st.StartTime.After(time.Now()) {
+		return nil
+	}
+	if st.StartTime.IsZero() {
+		sf.startTime = toSonyflakeTime(time.Date(2014, 9, 1, 0, 0, 0, 0, time.UTC))
+	} else {
+		sf.startTime = toSonyflakeTime(st.StartTime)
+	}
+
+	var err error
+	if st.MachineID == nil {
+		sf.machineID, err = lower16BitPrivateIP()
+	} else {
+		sf.machineID, err = st.MachineID()
+	}
+	if err != nil || (st.CheckMachineID != nil && !st.CheckMachineID(sf.machineID)) {
+		return nil
+	}
+
+	return sf
+}
+
+// NextID generates a next unique ID.
+// After the Sonyflake time overflows, NextID returns an error.
+func (sf *Sonyflake) NextID() (uint64, error) {
+	const maskSequence = uint16(1<<BitLenSequence - 1)
+
+	sf.mutex.Lock()
+	defer sf.mutex.Unlock()
+
+	current := currentElapsedTime(sf.startTime)
+	if sf.elapsedTime < current {
+		sf.elapsedTime = current
+		sf.sequence = 0
+	} else { // sf.elapsedTime >= current
+		sf.sequence = (sf.sequence + 1) & maskSequence
+		if sf.sequence == 0 {
+			sf.elapsedTime++
+			overtime := sf.elapsedTime - current
+			time.Sleep(sleepTime((overtime)))
+		}
+	}
+
+	return sf.toID()
+}
+
+const sonyflakeTimeUnit = 1e7 // nsec, i.e. 10 msec
+
+func toSonyflakeTime(t time.Time) int64 {
+	return t.UTC().UnixNano() / sonyflakeTimeUnit
+}
+
+func currentElapsedTime(startTime int64) int64 {
+	return toSonyflakeTime(time.Now()) - startTime
+}
+
+func sleepTime(overtime int64) time.Duration {
+	return time.Duration(overtime)*10*time.Millisecond -
+		time.Duration(time.Now().UTC().UnixNano()%sonyflakeTimeUnit)*time.Nanosecond
+}
+
+func (sf *Sonyflake) toID() (uint64, error) {
+	if sf.elapsedTime >= 1<<BitLenTime {
+		return 0, errors.New("over the time limit")
+	}
+
+	return uint64(sf.elapsedTime)<<(BitLenSequence+BitLenMachineID) |
+		uint64(sf.sequence)<<BitLenMachineID |
+		uint64(sf.machineID), nil
+}
+
+func privateIPv4() (net.IP, error) {
+	as, err := net.InterfaceAddrs()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, a := range as {
+		ipnet, ok := a.(*net.IPNet)
+		if !ok || ipnet.IP.IsLoopback() {
+			continue
+		}
+
+		ip := ipnet.IP.To4()
+		if isPrivateIPv4(ip) {
+			return ip, nil
+		}
+	}
+	return nil, errors.New("no private ip address")
+}
+
+func isPrivateIPv4(ip net.IP) bool {
+	return ip != nil &&
+		(ip[0] == 10 || ip[0] == 172 && (ip[1] >= 16 && ip[1] < 32) || ip[0] == 192 && ip[1] == 168)
+}
+
+func lower16BitPrivateIP() (uint16, error) {
+	ip, err := privateIPv4()
+	if err != nil {
+		return 0, err
+	}
+
+	return uint16(ip[2])<<8 + uint16(ip[3]), nil
+}
+
+// Decompose returns a set of Sonyflake ID parts.
+func Decompose(id uint64) map[string]uint64 {
+	const maskSequence = uint64((1<<BitLenSequence - 1) << BitLenMachineID)
+	const maskMachineID = uint64(1<<BitLenMachineID - 1)
+
+	msb := id >> 63
+	time := id >> (BitLenSequence + BitLenMachineID)
+	sequence := id & maskSequence >> BitLenMachineID
+	machineID := id & maskMachineID
+	return map[string]uint64{
+		"id":         id,
+		"msb":        msb,
+		"time":       time,
+		"sequence":   sequence,
+		"machine-id": machineID,
+	}
+}

-# github.com/astaxie/beego v1.10.0
+# github.com/astaxie/beego v1.11.1
 github.com/astaxie/beego
 github.com/astaxie/beego
 github.com/astaxie/beego/config
 github.com/astaxie/beego/config
 github.com/astaxie/beego/context
 github.com/astaxie/beego/context
@@ -6,6 +6,7 @@ github.com/astaxie/beego/context/param
 github.com/astaxie/beego/grace
 github.com/astaxie/beego/grace
 github.com/astaxie/beego/logs
 github.com/astaxie/beego/logs
 github.com/astaxie/beego/orm
 github.com/astaxie/beego/orm
+github.com/astaxie/beego/plugins/cors
 github.com/astaxie/beego/session
 github.com/astaxie/beego/session
 github.com/astaxie/beego/toolbox
 github.com/astaxie/beego/toolbox
 github.com/astaxie/beego/utils
 github.com/astaxie/beego/utils
@@ -22,6 +23,10 @@ github.com/go-redis/redis/internal/proto
 github.com/go-redis/redis/internal/util
 github.com/go-redis/redis/internal/util
 # github.com/go-sql-driver/mysql v1.4.1
 # github.com/go-sql-driver/mysql v1.4.1
 github.com/go-sql-driver/mysql
 github.com/go-sql-driver/mysql
+# github.com/satori/go.uuid v1.2.0
+github.com/satori/go.uuid
+# github.com/sony/sonyflake v1.0.0
+github.com/sony/sonyflake
 # golang.org/x/crypto v0.0.0-20191119213627-4f8c1d86b1ba
 # golang.org/x/crypto v0.0.0-20191119213627-4f8c1d86b1ba
 golang.org/x/crypto/acme
 golang.org/x/crypto/acme
 golang.org/x/crypto/acme/autocert
 golang.org/x/crypto/acme/autocert