Merge branch 'develop'

Fix :supervisor work dir

README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://travis-ci.org/astaxie/beego.svg?branch=master)](https://travis-ci.org/astaxie/beego)
 [![GoDoc](http://godoc.org/github.com/astaxie/beego?status.svg)](http://godoc.org/github.com/astaxie/beego)
+[![Foundation](https://img.shields.io/badge/Golang-Foundation-green.svg)](http://golangfoundation.org)
 
 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.

admin_test.go

@@ -65,6 +65,7 @@ func oldMap() map[string]interface{} {
 	m["BConfig.WebConfig.Session.SessionCookieLifeTime"] = BConfig.WebConfig.Session.SessionCookieLifeTime
 	m["BConfig.WebConfig.Session.SessionAutoSetCookie"] = BConfig.WebConfig.Session.SessionAutoSetCookie
 	m["BConfig.WebConfig.Session.SessionDomain"] = BConfig.WebConfig.Session.SessionDomain
+	m["BConfig.WebConfig.Session.SessionDisableHTTPOnly"] = BConfig.WebConfig.Session.SessionDisableHTTPOnly
 	m["BConfig.Log.AccessLogs"] = BConfig.Log.AccessLogs
 	m["BConfig.Log.FileLineNum"] = BConfig.Log.FileLineNum
 	m["BConfig.Log.Outputs"] = BConfig.Log.Outputs

adminui.go

@@ -78,13 +78,14 @@ var qpsTpl = `{{define "content"}}
 	{{range $i, $elem := .Content.Data}}
 
 	<tr>
-		{{range $elem}}
-			<td>
-			{{.}}
-			</td>
-		{{end}}
+	    <td>{{index $elem 0}}</td>
+	    <td>{{index $elem 1}}</td>
+	    <td>{{index $elem 2}}</td>
+	    <td data-order="{{index $elem 3}}">{{index $elem 4}}</td>
+	    <td data-order="{{index $elem 5}}">{{index $elem 6}}</td>
+	    <td data-order="{{index $elem 7}}">{{index $elem 8}}</td>
+	    <td data-order="{{index $elem 9}}">{{index $elem 10}}</td>
 	</tr>
-
 	{{end}}
 	</tbody>
 

beego.go

@@ -23,7 +23,7 @@ import (
 
 const (
 	// VERSION represent beego web framework version.
-	VERSION = "1.7.0"
+	VERSION = "1.7.2"
 
 	// DEV is for develop
 	DEV = "dev"
@@ -85,8 +85,13 @@ func initBeforeHTTPRun() {
 
 // TestBeegoInit is for test package init
 func TestBeegoInit(ap string) {
-	appConfigPath = filepath.Join(ap, "conf", "app.conf")
+	path := filepath.Join(ap, "conf", "app.conf")
 	os.Chdir(ap)
+	InitBeegoBeforeTest(path)
+}
+
+// InitBeegoBeforeTest is for test package init
+func InitBeegoBeforeTest(appConfigPath string) {
 	if err := LoadAppConfig(appConfigProvider, appConfigPath); err != nil {
 		panic(err)
 	}

cache/memcache/memcache.go

@@ -33,12 +33,10 @@ import (
 	"encoding/json"
 	"errors"
 	"strings"
-
-	"github.com/bradfitz/gomemcache/memcache"
-
 	"time"
 
 	"github.com/astaxie/beego/cache"
+	"github.com/bradfitz/gomemcache/memcache"
 )
 
 // Cache Memcache adapter.
@@ -60,7 +58,7 @@ func (rc *Cache) Get(key string) interface{} {
 		}
 	}
 	if item, err := rc.conn.Get(key); err == nil {
-		return string(item.Value)
+		return item.Value
 	}
 	return nil
 }
@@ -80,7 +78,7 @@ func (rc *Cache) GetMulti(keys []string) []interface{} {
 	mv, err := rc.conn.GetMulti(keys)
 	if err == nil {
 		for _, v := range mv {
-			rv = append(rv, string(v.Value))
+			rv = append(rv, v.Value)
 		}
 		return rv
 	}
@@ -90,18 +88,21 @@ func (rc *Cache) GetMulti(keys []string) []interface{} {
 	return rv
 }
 
-// Put put value to memcache. only support string.
+// Put put value to memcache.
 func (rc *Cache) Put(key string, val interface{}, timeout time.Duration) error {
 	if rc.conn == nil {
 		if err := rc.connectInit(); err != nil {
 			return err
 		}
 	}
-	v, ok := val.(string)
-	if !ok {
-		return errors.New("val must string")
+	item := memcache.Item{Key: key, Expiration: int32(timeout / time.Second)}
+	if v, ok := val.([]byte); ok {
+		item.Value = v
+	} else if str, ok := val.(string); ok {
+		item.Value = []byte(str)
+	} else {
+		return errors.New("val only support string and []byte")
 	}
-	item := memcache.Item{Key: key, Value: []byte(v), Expiration: int32(timeout / time.Second)}
 	return rc.conn.Set(&item)
 }
 

cache/memcache/memcache_test.go

@@ -46,7 +46,7 @@ func TestMemcacheCache(t *testing.T) {
 		t.Error("set Error", err)
 	}
 
-	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 1 {
+	if v, err := strconv.Atoi(string(bm.Get("astaxie").([]byte))); err != nil || v != 1 {
 		t.Error("get err")
 	}
 
@@ -54,7 +54,7 @@ func TestMemcacheCache(t *testing.T) {
 		t.Error("Incr Error", err)
 	}
 
-	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 2 {
+	if v, err := strconv.Atoi(string(bm.Get("astaxie").([]byte))); err != nil || v != 2 {
 		t.Error("get err")
 	}
 
@@ -62,7 +62,7 @@ func TestMemcacheCache(t *testing.T) {
 		t.Error("Decr Error", err)
 	}
 
-	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 1 {
+	if v, err := strconv.Atoi(string(bm.Get("astaxie").([]byte))); err != nil || v != 1 {
 		t.Error("get err")
 	}
 	bm.Delete("astaxie")
@@ -78,7 +78,7 @@ func TestMemcacheCache(t *testing.T) {
 		t.Error("check err")
 	}
 
-	if v := bm.Get("astaxie").(string); v != "author" {
+	if v := bm.Get("astaxie").([]byte); string(v) != "author" {
 		t.Error("get err")
 	}
 
@@ -94,10 +94,10 @@ func TestMemcacheCache(t *testing.T) {
 	if len(vv) != 2 {
 		t.Error("GetMulti ERROR")
 	}
-	if vv[0].(string) != "author" && vv[0].(string) != "author1" {
+	if string(vv[0].([]byte)) != "author" && string(vv[0].([]byte)) != "author1" {
 		t.Error("GetMulti ERROR")
 	}
-	if vv[1].(string) != "author1" && vv[1].(string) != "author" {
+	if string(vv[1].([]byte)) != "author1" && string(vv[1].([]byte)) != "author" {
 		t.Error("GetMulti ERROR")
 	}
 

config.go

@@ -19,9 +19,11 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
+	"runtime"
 	"strings"
 
 	"github.com/astaxie/beego/config"
+	"github.com/astaxie/beego/context"
 	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/session"
 	"github.com/astaxie/beego/utils"
@@ -34,6 +36,7 @@ type Config struct {
 	RouterCaseSensitive bool
 	ServerName          string
 	RecoverPanic        bool
+	RecoverFunc         func(*context.Context)
 	CopyRequestBody     bool
 	EnableGzip          bool
 	MaxMemory           int64
@@ -83,17 +86,18 @@ type WebConfig struct {
 
 // SessionConfig holds session related config
 type SessionConfig struct {
-	SessionOn               bool
-	SessionProvider         string
-	SessionName             string
-	SessionGCMaxLifetime    int64
-	SessionProviderConfig   string
-	SessionCookieLifeTime   int
-	SessionAutoSetCookie    bool
-	SessionDomain           string
-	EnableSidInHttpHeader   bool //	enable store/get the sessionId into/from http headers
-	SessionNameInHttpHeader string
-	EnableSidInUrlQuery     bool //	enable get the sessionId from Url Query params
+	SessionOn                    bool
+	SessionProvider              string
+	SessionName                  string
+	SessionGCMaxLifetime         int64
+	SessionProviderConfig        string
+	SessionCookieLifeTime        int
+	SessionAutoSetCookie         bool
+	SessionDomain                string
+	SessionDisableHTTPOnly       bool // used to allow for cross domain cookies/javascript cookies.
+	SessionEnableSidInHTTPHeader bool //	enable store/get the sessionId into/from http headers
+	SessionNameInHTTPHeader      string
+	SessionEnableSidInURLQuery   bool //	enable get the sessionId from Url Query params
 }
 
 // LogConfig holds Log related config
@@ -140,6 +144,40 @@ func init() {
 	if err = parseConfig(appConfigPath); err != nil {
 		panic(err)
 	}
+	if err = os.Chdir(AppPath); err != nil {
+		panic(err)
+	}
+}
+
+func recoverPanic(ctx *context.Context) {
+	if err := recover(); err != nil {
+		if err == ErrAbort {
+			return
+		}
+		if !BConfig.RecoverPanic {
+			panic(err)
+		}
+		if BConfig.EnableErrorsShow {
+			if _, ok := ErrorMaps[fmt.Sprint(err)]; ok {
+				exception(fmt.Sprint(err), ctx)
+				return
+			}
+		}
+		var stack string
+		logs.Critical("the request url is ", ctx.Input.URL())
+		logs.Critical("Handler crashed with error", err)
+		for i := 1; ; i++ {
+			_, file, line, ok := runtime.Caller(i)
+			if !ok {
+				break
+			}
+			logs.Critical(fmt.Sprintf("%s:%d", file, line))
+			stack = stack + fmt.Sprintln(fmt.Sprintf("%s:%d", file, line))
+		}
+		if BConfig.RunMode == DEV {
+			showErr(err, ctx, stack)
+		}
+	}
 }
 
 func newBConfig() *Config {
@@ -149,6 +187,7 @@ func newBConfig() *Config {
 		RouterCaseSensitive: true,
 		ServerName:          "beegoServer:" + VERSION,
 		RecoverPanic:        true,
+		RecoverFunc:         recoverPanic,
 		CopyRequestBody:     false,
 		EnableGzip:          false,
 		MaxMemory:           1 << 26, //64MB
@@ -186,17 +225,18 @@ func newBConfig() *Config {
 			XSRFKey:                "beegoxsrf",
 			XSRFExpire:             0,
 			Session: SessionConfig{
-				SessionOn:               false,
-				SessionProvider:         "memory",
-				SessionName:             "beegosessionID",
-				SessionGCMaxLifetime:    3600,
-				SessionProviderConfig:   "",
-				SessionCookieLifeTime:   0, //set cookie default is the browser life
-				SessionAutoSetCookie:    true,
-				SessionDomain:           "",
-				EnableSidInHttpHeader:   false, //	enable store/get the sessionId into/from http headers
-				SessionNameInHttpHeader: "Beegosessionid",
-				EnableSidInUrlQuery:     false, //	enable get the sessionId from Url Query params
+				SessionOn:                    false,
+				SessionProvider:              "memory",
+				SessionName:                  "beegosessionID",
+				SessionGCMaxLifetime:         3600,
+				SessionProviderConfig:        "",
+				SessionDisableHTTPOnly:       false,
+				SessionCookieLifeTime:        0, //set cookie default is the browser life
+				SessionAutoSetCookie:         true,
+				SessionDomain:                "",
+				SessionEnableSidInHTTPHeader: false, //	enable store/get the sessionId into/from http headers
+				SessionNameInHTTPHeader:      "Beegosessionid",
+				SessionEnableSidInURLQuery:   false, //	enable get the sessionId from Url Query params
 			},
 		},
 		Log: LogConfig{
@@ -259,6 +299,10 @@ func assignConfig(ac config.Configer) error {
 	}
 
 	if lo := ac.String("LogOutputs"); lo != "" {
+		// if lo is not nil or empty
+		// means user has set his own LogOutputs
+		// clear the default setting to BConfig.Log.Outputs
+		BConfig.Log.Outputs = make(map[string]string)
 		los := strings.Split(lo, ";")
 		for _, v := range los {
 			if logType2Config := strings.SplitN(v, ",", 2); len(logType2Config) == 2 {

config/config.go

@@ -43,6 +43,8 @@ package config
 import (
 	"fmt"
 	"os"
+	"reflect"
+	"time"
 )
 
 // Configer defines how to get and set value from configuration raw data.
@@ -204,3 +206,37 @@ func ParseBool(val interface{}) (value bool, err error) {
 	}
 	return false, fmt.Errorf("parsing <nil>: invalid syntax")
 }
+
+// ToString converts values of any type to string.
+func ToString(x interface{}) string {
+	switch y := x.(type) {
+
+	// Handle dates with special logic
+	// This needs to come above the fmt.Stringer
+	// test since time.Time's have a .String()
+	// method
+	case time.Time:
+		return y.Format("A Monday")
+
+	// Handle type string
+	case string:
+		return y
+
+	// Handle type with .String() method
+	case fmt.Stringer:
+		return y.String()
+
+	// Handle type with .Error() method
+	case error:
+		return y.Error()
+
+	}
+
+	// Handle named string type
+	if v := reflect.ValueOf(x); v.Kind() == reflect.String {
+		return v.String()
+	}
+
+	// Fallback to fmt package for anything else like numeric types
+	return fmt.Sprint(x)
+}

config/ini.go

@@ -23,6 +23,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"sync"
@@ -132,8 +133,8 @@ func (ini *IniConfig) parseFile(name string) (*IniConfigContainer, error) {
 			includefiles := strings.Fields(key)
 			if includefiles[0] == "include" && len(includefiles) == 2 {
 				otherfile := strings.Trim(includefiles[1], "\"")
-				if !path.IsAbs(otherfile) {
-					otherfile = path.Join(path.Dir(name), otherfile)
+				if !filepath.IsAbs(otherfile) {
+					otherfile = filepath.Join(filepath.Dir(name), otherfile)
 				}
 				i, err := ini.parseFile(otherfile)
 				if err != nil {

config/xml/xml.go

@@ -193,10 +193,14 @@ func (c *ConfigContainer) DefaultStrings(key string, defaultval []string) []stri
 
 // GetSection returns map for the given section
 func (c *ConfigContainer) GetSection(section string) (map[string]string, error) {
-	if v, ok := c.data[section]; ok {
-		return v.(map[string]string), nil
+	if v, ok := c.data[section].(map[string]interface{}); ok {
+		mapstr := make(map[string]string)
+		for k, val := range v {
+			mapstr[k] = config.ToString(val)
+		}
+		return mapstr, nil
 	}
-	return nil, errors.New("not exist setction")
+	return nil, fmt.Errorf("section '%s' not found", section)
 }
 
 // SaveConfigFile save the config into file

config/xml/xml_test.go

@@ -37,6 +37,10 @@ func TestXML(t *testing.T) {
 <copyrequestbody>true</copyrequestbody>
 <path1>${GOPATH}</path1>
 <path2>${GOPATH||/home/go}</path2>
+<mysection>
+<id>1</id>
+<name>MySection</name>
+</mysection>
 </config>
 `
 		keyValue = map[string]interface{}{
@@ -65,11 +69,22 @@ func TestXML(t *testing.T) {
 	}
 	f.Close()
 	defer os.Remove("testxml.conf")
+
 	xmlconf, err := config.NewConfig("xml", "testxml.conf")
 	if err != nil {
 		t.Fatal(err)
 	}
 
+	var xmlsection map[string]string
+	xmlsection, err = xmlconf.GetSection("mysection")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(xmlsection) == 0 {
+		t.Error("section should not be empty")
+	}
+
 	for k, v := range keyValue {
 
 		var (

context/input.go

@@ -40,12 +40,14 @@ var (
 // BeegoInput operates the http request header, data, cookie and body.
 // it also contains router params and current session.
 type BeegoInput struct {
-	Context     *Context
-	CruSession  session.Store
-	pnames      []string
-	pvalues     []string
-	data        map[interface{}]interface{} // store some values in this context when calling context in filter or controller.
-	RequestBody []byte
+	Context       *Context
+	CruSession    session.Store
+	pnames        []string
+	pvalues       []string
+	data          map[interface{}]interface{} // store some values in this context when calling context in filter or controller.
+	RequestBody   []byte
+	RunMethod     string
+	RunController reflect.Type
 }
 
 // NewInput return BeegoInput generated by Context.

controller.go

@@ -399,6 +399,16 @@ func (c *Controller) GetInt8(key string, def ...int8) (int8, error) {
 	return int8(i64), err
 }
 
+// GetUint8 return input as an uint8 or the default value while it's present and input is blank
+func (c *Controller) GetUint8(key string, def ...uint8) (uint8, error) {
+	strv := c.Ctx.Input.Query(key)
+	if len(strv) == 0 && len(def) > 0 {
+		return def[0], nil
+	}
+	u64, err := strconv.ParseUint(strv, 10, 8)
+	return uint8(u64), err
+}
+
 // GetInt16 returns input as an int16 or the default value while it's present and input is blank
 func (c *Controller) GetInt16(key string, def ...int16) (int16, error) {
 	strv := c.Ctx.Input.Query(key)
@@ -409,6 +419,16 @@ func (c *Controller) GetInt16(key string, def ...int16) (int16, error) {
 	return int16(i64), err
 }
 
+// GetUint16 returns input as an uint16 or the default value while it's present and input is blank
+func (c *Controller) GetUint16(key string, def ...uint16) (uint16, error) {
+	strv := c.Ctx.Input.Query(key)
+	if len(strv) == 0 && len(def) > 0 {
+		return def[0], nil
+	}
+	u64, err := strconv.ParseUint(strv, 10, 16)
+	return uint16(u64), err
+}
+
 // GetInt32 returns input as an int32 or the default value while it's present and input is blank
 func (c *Controller) GetInt32(key string, def ...int32) (int32, error) {
 	strv := c.Ctx.Input.Query(key)
@@ -419,6 +439,16 @@ func (c *Controller) GetInt32(key string, def ...int32) (int32, error) {
 	return int32(i64), err
 }
 
+// GetUint32 returns input as an uint32 or the default value while it's present and input is blank
+func (c *Controller) GetUint32(key string, def ...uint32) (uint32, error) {
+	strv := c.Ctx.Input.Query(key)
+	if len(strv) == 0 && len(def) > 0 {
+		return def[0], nil
+	}
+	u64, err := strconv.ParseUint(strv, 10, 32)
+	return uint32(u64), err
+}
+
 // GetInt64 returns input value as int64 or the default value while it's present and input is blank.
 func (c *Controller) GetInt64(key string, def ...int64) (int64, error) {
 	strv := c.Ctx.Input.Query(key)
@@ -428,6 +458,15 @@ func (c *Controller) GetInt64(key string, def ...int64) (int64, error) {
 	return strconv.ParseInt(strv, 10, 64)
 }
 
+// GetUint64 returns input value as uint64 or the default value while it's present and input is blank.
+func (c *Controller) GetUint64(key string, def ...uint64) (uint64, error) {
+	strv := c.Ctx.Input.Query(key)
+	if len(strv) == 0 && len(def) > 0 {
+		return def[0], nil
+	}
+	return strconv.ParseUint(strv, 10, 64)
+}
+
 // GetBool returns input value as bool or the default value while it's present and input is blank.
 func (c *Controller) GetBool(key string, def ...bool) (bool, error) {
 	strv := c.Ctx.Input.Query(key)
@@ -453,7 +492,7 @@ func (c *Controller) GetFile(key string) (multipart.File, *multipart.FileHeader,
 }
 
 // GetFiles return multi-upload files
-// files, err:=c.Getfiles("myfiles")
+// files, err:=c.GetFiles("myfiles")
 //	if err != nil {
 //		http.Error(w, err.Error(), http.StatusNoContent)
 //		return

controller_test.go

@@ -15,6 +15,8 @@
 package beego
 
 import (
+	"math"
+	"strconv"
 	"testing"
 
 	"github.com/astaxie/beego/context"
@@ -75,3 +77,47 @@ func TestGetInt64(t *testing.T) {
 		t.Errorf("TestGeetInt64 expect 40,get %T,%v", val, val)
 	}
 }
+
+func TestGetUint8(t *testing.T) {
+	i := context.NewInput()
+	i.SetParam("age", strconv.FormatUint(math.MaxUint8, 10))
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+	val, _ := ctrlr.GetUint8("age")
+	if val != math.MaxUint8 {
+		t.Errorf("TestGetUint8 expect %v,get %T,%v", math.MaxUint8, val, val)
+	}
+}
+
+func TestGetUint16(t *testing.T) {
+	i := context.NewInput()
+	i.SetParam("age", strconv.FormatUint(math.MaxUint16, 10))
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+	val, _ := ctrlr.GetUint16("age")
+	if val != math.MaxUint16 {
+		t.Errorf("TestGetUint16 expect %v,get %T,%v", math.MaxUint16, val, val)
+	}
+}
+
+func TestGetUint32(t *testing.T) {
+	i := context.NewInput()
+	i.SetParam("age", strconv.FormatUint(math.MaxUint32, 10))
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+	val, _ := ctrlr.GetUint32("age")
+	if val != math.MaxUint32 {
+		t.Errorf("TestGetUint32 expect %v,get %T,%v", math.MaxUint32, val, val)
+	}
+}
+
+func TestGetUint64(t *testing.T) {
+	i := context.NewInput()
+	i.SetParam("age", strconv.FormatUint(math.MaxUint64, 10))
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+	val, _ := ctrlr.GetUint64("age")
+	if val != math.MaxUint64 {
+		t.Errorf("TestGetUint64 expect %v,get %T,%v", uint64(math.MaxUint64), val, val)
+	}
+}

error.go

@@ -93,7 +93,11 @@ func showErr(err interface{}, ctx *context.Context, stack string) {
 		"BeegoVersion":  VERSION,
 		"GoVersion":     runtime.Version(),
 	}
-	ctx.ResponseWriter.WriteHeader(500)
+	if ctx.Output.Status != 0 {
+		ctx.ResponseWriter.WriteHeader(ctx.Output.Status)
+	} else {
+		ctx.ResponseWriter.WriteHeader(500)
+	}
 	t.Execute(ctx.ResponseWriter, data)
 }
 

hooks.go

@@ -53,10 +53,11 @@ func registerSession() error {
 			conf.Secure = BConfig.Listen.EnableHTTPS
 			conf.CookieLifeTime = BConfig.WebConfig.Session.SessionCookieLifeTime
 			conf.ProviderConfig = filepath.ToSlash(BConfig.WebConfig.Session.SessionProviderConfig)
+			conf.DisableHTTPOnly = BConfig.WebConfig.Session.SessionDisableHTTPOnly
 			conf.Domain = BConfig.WebConfig.Session.SessionDomain
-			conf.EnableSidInHttpHeader = BConfig.WebConfig.Session.EnableSidInHttpHeader
-			conf.SessionNameInHttpHeader = BConfig.WebConfig.Session.SessionNameInHttpHeader
-			conf.EnableSidInUrlQuery = BConfig.WebConfig.Session.EnableSidInUrlQuery
+			conf.EnableSidInHttpHeader = BConfig.WebConfig.Session.SessionEnableSidInHTTPHeader
+			conf.SessionNameInHttpHeader = BConfig.WebConfig.Session.SessionNameInHTTPHeader
+			conf.EnableSidInUrlQuery = BConfig.WebConfig.Session.SessionEnableSidInURLQuery
 		} else {
 			if err = json.Unmarshal([]byte(sessionConfig), conf); err != nil {
 				return err

httplib/httplib.go

@@ -136,6 +136,7 @@ type BeegoHTTPSettings struct {
 	TLSClientConfig  *tls.Config
 	Proxy            func(*http.Request) (*url.URL, error)
 	Transport        http.RoundTripper
+	CheckRedirect    func(req *http.Request, via []*http.Request) error
 	EnableCookie     bool
 	Gzip             bool
 	DumpBody         bool
@@ -265,6 +266,15 @@ func (b *BeegoHTTPRequest) SetProxy(proxy func(*http.Request) (*url.URL, error))
 	return b
 }
 
+// SetCheckRedirect specifies the policy for handling redirects.
+//
+// If CheckRedirect is nil, the Client uses its default policy,
+// which is to stop after 10 consecutive requests.
+func (b *BeegoHTTPRequest) SetCheckRedirect(redirect func(req *http.Request, via []*http.Request) error) *BeegoHTTPRequest {
+	b.setting.CheckRedirect = redirect
+	return b
+}
+
 // Param adds query param in to request.
 // params build query string as ?key1=value1&key2=value2...
 func (b *BeegoHTTPRequest) Param(key, value string) *BeegoHTTPRequest {
@@ -446,6 +456,10 @@ func (b *BeegoHTTPRequest) DoRequest() (*http.Response, error) {
 		b.req.Header.Set("User-Agent", b.setting.UserAgent)
 	}
 
+	if b.setting.CheckRedirect != nil {
+		client.CheckRedirect = b.setting.CheckRedirect
+	}
+
 	if b.setting.ShowDebug {
 		dump, err := httputil.DumpRequest(b.req, b.setting.DumpBody)
 		if err != nil {

logs/jianliao.go

@@ -0,0 +1,78 @@
+package logs
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// JLWriter implements beego LoggerInterface and is used to send jiaoliao webhook
+type JLWriter struct {
+	AuthorName  string `json:"authorname"`
+	Title       string `json:"title"`
+	WebhookURL  string `json:"webhookurl"`
+	RedirectURL string `json:"redirecturl,omitempty"`
+	ImageURL    string `json:"imageurl,omitempty"`
+	Level       int    `json:"level"`
+}
+
+// newJLWriter create jiaoliao writer.
+func newJLWriter() Logger {
+	return &JLWriter{Level: LevelTrace}
+}
+
+// Init JLWriter with json config string
+func (s *JLWriter) Init(jsonconfig string) error {
+	err := json.Unmarshal([]byte(jsonconfig), s)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// WriteMsg write message in smtp writer.
+// it will send an email with subject and only this message.
+func (s *JLWriter) WriteMsg(when time.Time, msg string, level int) error {
+	if level > s.Level {
+		return nil
+	}
+
+	text := fmt.Sprintf("%s %s", when.Format("2006-01-02 15:04:05"), msg)
+
+	form := url.Values{}
+	form.Add("authorName", s.AuthorName)
+	form.Add("title", s.Title)
+	form.Add("text", text)
+	if s.RedirectURL != "" {
+		form.Add("redirectUrl", s.RedirectURL)
+	}
+	if s.ImageURL != "" {
+		form.Add("imageUrl", s.ImageURL)
+	}
+
+	resp, err := http.PostForm(s.WebhookURL, form)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Post webhook failed %s %d", resp.Status, resp.StatusCode)
+	}
+	return nil
+}
+
+// Flush implementing method. empty.
+func (s *JLWriter) Flush() {
+	return
+}
+
+// Destroy implementing method. empty.
+func (s *JLWriter) Destroy() {
+	return
+}
+
+func init() {
+	Register(AdapterJianLiao, newJLWriter)
+}

logs/log.go

@@ -66,9 +66,11 @@ const (
 	AdapterConsole   = "console"
 	AdapterFile      = "file"
 	AdapterMultiFile = "multifile"
-	AdapterMail      = "stmp"
+	AdapterMail      = "smtp"
 	AdapterConn      = "conn"
 	AdapterEs        = "es"
+	AdapterJianLiao  = "jianliao"
+	AdapterSlack     = "slack"
 )
 
 // Legacy log level constants to ensure backwards compatibility.
@@ -378,7 +380,10 @@ func (bl *BeeLogger) Error(format string, v ...interface{}) {
 
 // Warning Log WARNING level message.
 func (bl *BeeLogger) Warning(format string, v ...interface{}) {
-	bl.Warn(format, v...)
+	if LevelWarn > bl.level {
+		return
+	}
+	bl.writeMsg(LevelWarn, format, v...)
 }
 
 // Notice Log NOTICE level message.
@@ -391,7 +396,10 @@ func (bl *BeeLogger) Notice(format string, v ...interface{}) {
 
 // Informational Log INFORMATIONAL level message.
 func (bl *BeeLogger) Informational(format string, v ...interface{}) {
-	bl.Info(format, v...)
+	if LevelInfo > bl.level {
+		return
+	}
+	bl.writeMsg(LevelInfo, format, v...)
 }
 
 // Debug Log DEBUG level message.
@@ -423,7 +431,10 @@ func (bl *BeeLogger) Info(format string, v ...interface{}) {
 // Trace Log TRACE level message.
 // compatibility alias for Debug()
 func (bl *BeeLogger) Trace(format string, v ...interface{}) {
-	bl.Debug(format, v...)
+	if LevelDebug > bl.level {
+		return
+	}
+	bl.writeMsg(LevelDebug, format, v...)
 }
 
 // Flush flush all chan data.

logs/slack.go

@@ -0,0 +1,66 @@
+package logs
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// SLACKWriter implements beego LoggerInterface and is used to send jiaoliao webhook
+type SLACKWriter struct {
+	WebhookURL string `json:"webhookurl"`
+	Level      int    `json:"level"`
+}
+
+// newSLACKWriter create jiaoliao writer.
+func newSLACKWriter() Logger {
+	return &SLACKWriter{Level: LevelTrace}
+}
+
+// Init SLACKWriter with json config string
+func (s *SLACKWriter) Init(jsonconfig string) error {
+	err := json.Unmarshal([]byte(jsonconfig), s)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// WriteMsg write message in smtp writer.
+// it will send an email with subject and only this message.
+func (s *SLACKWriter) WriteMsg(when time.Time, msg string, level int) error {
+	if level > s.Level {
+		return nil
+	}
+
+	text := fmt.Sprintf("{\"text\": \"%s %s\"}", when.Format("2006-01-02 15:04:05"), msg)
+
+	form := url.Values{}
+	form.Add("payload", text)
+
+	resp, err := http.PostForm(s.WebhookURL, form)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Post webhook failed %s %d", resp.Status, resp.StatusCode)
+	}
+	return nil
+}
+
+// Flush implementing method. empty.
+func (s *SLACKWriter) Flush() {
+	return
+}
+
+// Destroy implementing method. empty.
+func (s *SLACKWriter) Destroy() {
+	return
+}
+
+func init() {
+	Register(AdapterSlack, newSLACKWriter)
+}

orm/db.go

@@ -310,7 +310,7 @@ func (d *dbBase) InsertStmt(stmt stmtQuerier, mi *modelInfo, ind reflect.Value,
 }
 
 // query sql ,read records and persist in dbBaser.
-func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location, cols []string) error {
+func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location, cols []string, isForUpdate bool) error {
 	var whereCols []string
 	var args []interface{}
 
@@ -341,7 +341,12 @@ func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Lo
 	sep = fmt.Sprintf("%s = ? AND %s", Q, Q)
 	wheres := strings.Join(whereCols, sep)
 
-	query := fmt.Sprintf("SELECT %s%s%s FROM %s%s%s WHERE %s%s%s = ?", Q, sels, Q, Q, mi.table, Q, Q, wheres, Q)
+	forUpdate := ""
+	if isForUpdate {
+		forUpdate = "FOR UPDATE"
+	}
+
+	query := fmt.Sprintf("SELECT %s%s%s FROM %s%s%s WHERE %s%s%s = ? %s", Q, sels, Q, Q, mi.table, Q, Q, wheres, Q, forUpdate)
 
 	refs := make([]interface{}, colsNum)
 	for i := range refs {
@@ -634,18 +639,36 @@ func (d *dbBase) Update(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.
 
 // execute delete sql dbQuerier with given struct reflect.Value.
 // delete index is pk.
-func (d *dbBase) Delete(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location) (int64, error) {
-	pkName, pkValue, ok := getExistPk(mi, ind)
-	if ok == false {
-		return 0, ErrMissPK
+func (d *dbBase) Delete(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location, cols []string) (int64, error) {
+	var whereCols []string
+	var args []interface{}
+	// if specify cols length > 0, then use it for where condition.
+	if len(cols) > 0 {
+		var err error
+		whereCols = make([]string, 0, len(cols))
+		args, _, err = d.collectValues(mi, ind, cols, false, false, &whereCols, tz)
+		if err != nil {
+			return 0, err
+		}
+	} else {
+		// default use pk value as where condtion.
+		pkColumn, pkValue, ok := getExistPk(mi, ind)
+		if ok == false {
+			return 0, ErrMissPK
+		}
+		whereCols = []string{pkColumn}
+		args = append(args, pkValue)
 	}
 
 	Q := d.ins.TableQuote()
 
-	query := fmt.Sprintf("DELETE FROM %s%s%s WHERE %s%s%s = ?", Q, mi.table, Q, Q, pkName, Q)
+	sep := fmt.Sprintf("%s = ? AND %s", Q, Q)
+	wheres := strings.Join(whereCols, sep)
+
+	query := fmt.Sprintf("DELETE FROM %s%s%s WHERE %s%s%s = ?", Q, mi.table, Q, Q, wheres, Q)
 
 	d.ins.ReplaceMarks(&query)
-	res, err := q.Exec(query, pkValue)
+	res, err := q.Exec(query, args...)
 	if err == nil {
 		num, err := res.RowsAffected()
 		if err != nil {
@@ -659,7 +682,7 @@ func (d *dbBase) Delete(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.
 					ind.FieldByIndex(mi.fields.pk.fieldIndex).SetInt(0)
 				}
 			}
-			err := d.deleteRels(q, mi, []interface{}{pkValue}, tz)
+			err := d.deleteRels(q, mi, args, tz)
 			if err != nil {
 				return num, err
 			}

orm/db_alias.go

@@ -80,7 +80,7 @@ type _dbCache struct {
 func (ac *_dbCache) add(name string, al *alias) (added bool) {
 	ac.mux.Lock()
 	defer ac.mux.Unlock()
-	if _, ok := ac.cache[name]; ok == false {
+	if _, ok := ac.cache[name]; !ok {
 		ac.cache[name] = al
 		added = true
 	}

orm/db_mysql.go

@@ -16,6 +16,8 @@ package orm
 
 import (
 	"fmt"
+	"reflect"
+	"strings"
 )
 
 // mysql operators.
@@ -96,6 +98,83 @@ func (d *dbBaseMysql) IndexExists(db dbQuerier, table string, name string) bool
 	return cnt > 0
 }
 
+// InsertOrUpdate a row
+// If your primary key or unique column conflict will update
+// If no will insert
+// Add "`" for mysql sql building
+func (d *dbBaseMysql) InsertOrUpdate(q dbQuerier, mi *modelInfo, ind reflect.Value, a *alias, args ...string) (int64, error) {
+
+	iouStr := ""
+	argsMap := map[string]string{}
+
+	iouStr = "ON DUPLICATE KEY UPDATE"
+
+	//Get on the key-value pairs
+	for _, v := range args {
+		kv := strings.Split(v, "=")
+		if len(kv) == 2 {
+			argsMap[strings.ToLower(kv[0])] = kv[1]
+		}
+	}
+
+	isMulti := false
+	names := make([]string, 0, len(mi.fields.dbcols)-1)
+	Q := d.ins.TableQuote()
+	values, _, err := d.collectValues(mi, ind, mi.fields.dbcols, true, true, &names, a.TZ)
+
+	if err != nil {
+		return 0, err
+	}
+
+	marks := make([]string, len(names))
+	updateValues := make([]interface{}, 0)
+	updates := make([]string, len(names))
+
+	for i, v := range names {
+		marks[i] = "?"
+		valueStr := argsMap[strings.ToLower(v)]
+		if valueStr != "" {
+			updates[i] = "`" + v + "`" + "=" + valueStr
+		} else {
+			updates[i] = "`" + v + "`" + "=?"
+			updateValues = append(updateValues, values[i])
+		}
+	}
+
+	values = append(values, updateValues...)
+
+	sep := fmt.Sprintf("%s, %s", Q, Q)
+	qmarks := strings.Join(marks, ", ")
+	qupdates := strings.Join(updates, ", ")
+	columns := strings.Join(names, sep)
+
+	multi := len(values) / len(names)
+
+	if isMulti {
+		qmarks = strings.Repeat(qmarks+"), (", multi-1) + qmarks
+	}
+	//conflitValue maybe is a int,can`t use fmt.Sprintf
+	query := fmt.Sprintf("INSERT INTO %s%s%s (%s%s%s) VALUES (%s) %s "+qupdates, Q, mi.table, Q, Q, columns, Q, qmarks, iouStr)
+
+	d.ins.ReplaceMarks(&query)
+
+	if isMulti || !d.ins.HasReturningID(mi, &query) {
+		res, err := q.Exec(query, values...)
+		if err == nil {
+			if isMulti {
+				return res.RowsAffected()
+			}
+			return res.LastInsertId()
+		}
+		return 0, err
+	}
+
+	row := q.QueryRow(query, values...)
+	var id int64
+	err = row.Scan(&id)
+	return id, err
+}
+
 // create new mysql dbBaser.
 func newdbBaseMysql() dbBaser {
 	b := new(dbBaseMysql)

orm/db_utils.go

@@ -145,16 +145,18 @@ outFor:
 			if v, ok := arg.(time.Time); ok {
 				if fi != nil && fi.fieldType == TypeDateField {
 					arg = v.In(tz).Format(formatDate)
-				} else if fi.fieldType == TypeDateTimeField {
+				} else if fi != nil && fi.fieldType == TypeDateTimeField {
 					arg = v.In(tz).Format(formatDateTime)
-				} else {
+				} else if fi != nil && fi.fieldType == TypeTimeField {
 					arg = v.In(tz).Format(formatTime)
+				} else {
+					arg = v.In(tz).Format(formatDateTime)
 				}
 			} else {
 				typ := val.Type()
 				name := getFullName(typ)
 				var value interface{}
-				if mmi, ok := modelCache.getByFN(name); ok {
+				if mmi, ok := modelCache.getByFullName(name); ok {
 					if _, vu, exist := getExistPk(mmi, val); exist {
 						value = vu
 					}

orm/models.go

@@ -29,39 +29,18 @@ const (
 
 var (
 	modelCache = &_modelCache{
-		cache:     make(map[string]*modelInfo),
-		cacheByFN: make(map[string]*modelInfo),
-	}
-	supportTag = map[string]int{
-		"-":            1,
-		"null":         1,
-		"index":        1,
-		"unique":       1,
-		"pk":           1,
-		"auto":         1,
-		"auto_now":     1,
-		"auto_now_add": 1,
-		"size":         2,
-		"column":       2,
-		"default":      2,
-		"rel":          2,
-		"reverse":      2,
-		"rel_table":    2,
-		"rel_through":  2,
-		"digits":       2,
-		"decimals":     2,
-		"on_delete":    2,
-		"type":         2,
+		cache:           make(map[string]*modelInfo),
+		cacheByFullName: make(map[string]*modelInfo),
 	}
 )
 
 // model info collection
 type _modelCache struct {
-	sync.RWMutex
-	orders    []string
-	cache     map[string]*modelInfo
-	cacheByFN map[string]*modelInfo
-	done      bool
+	sync.RWMutex    // only used outsite for bootStrap
+	orders          []string
+	cache           map[string]*modelInfo
+	cacheByFullName map[string]*modelInfo
+	done            bool
 }
 
 // get all model info
@@ -88,9 +67,9 @@ func (mc *_modelCache) get(table string) (mi *modelInfo, ok bool) {
 	return
 }
 
-// get model info by field name
-func (mc *_modelCache) getByFN(name string) (mi *modelInfo, ok bool) {
-	mi, ok = mc.cacheByFN[name]
+// get model info by full name
+func (mc *_modelCache) getByFullName(name string) (mi *modelInfo, ok bool) {
+	mi, ok = mc.cacheByFullName[name]
 	return
 }
 
@@ -98,7 +77,7 @@ func (mc *_modelCache) getByFN(name string) (mi *modelInfo, ok bool) {
 func (mc *_modelCache) set(table string, mi *modelInfo) *modelInfo {
 	mii := mc.cache[table]
 	mc.cache[table] = mi
-	mc.cacheByFN[mi.fullName] = mi
+	mc.cacheByFullName[mi.fullName] = mi
 	if mii == nil {
 		mc.orders = append(mc.orders, table)
 	}
@@ -109,7 +88,7 @@ func (mc *_modelCache) set(table string, mi *modelInfo) *modelInfo {
 func (mc *_modelCache) clean() {
 	mc.orders = make([]string, 0)
 	mc.cache = make(map[string]*modelInfo)
-	mc.cacheByFN = make(map[string]*modelInfo)
+	mc.cacheByFullName = make(map[string]*modelInfo)
 	mc.done = false
 }
 

orm/models_boot.go

@@ -15,7 +15,6 @@
 package orm
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"reflect"
@@ -23,24 +22,34 @@ import (
 )
 
 // register models.
-// prefix means table name prefix.
-func registerModel(prefix string, model interface{}) {
+// PrefixOrSuffix means table name prefix or suffix.
+// isPrefix whether the prefix is prefix or suffix
+func registerModel(PrefixOrSuffix string, model interface{}, isPrefix bool) {
 	val := reflect.ValueOf(model)
-	ind := reflect.Indirect(val)
-	typ := ind.Type()
+	typ := reflect.Indirect(val).Type()
 
 	if val.Kind() != reflect.Ptr {
 		panic(fmt.Errorf("<orm.RegisterModel> cannot use non-ptr model struct `%s`", getFullName(typ)))
 	}
+	// For this case:
+	// u := &User{}
+	// registerModel(&u)
+	if typ.Kind() == reflect.Ptr {
+		panic(fmt.Errorf("<orm.RegisterModel> only allow ptr model struct, it looks you use two reference to the struct `%s`", typ))
+	}
 
 	table := getTableName(val)
 
-	if prefix != "" {
-		table = prefix + table
+	if PrefixOrSuffix != "" {
+		if isPrefix {
+			table = PrefixOrSuffix + table
+		} else {
+			table = table + PrefixOrSuffix
+		}
 	}
-
+	// models's fullname is pkgpath + struct name
 	name := getFullName(typ)
-	if _, ok := modelCache.getByFN(name); ok {
+	if _, ok := modelCache.getByFullName(name); ok {
 		fmt.Printf("<orm.RegisterModel> model `%s` repeat register, must be unique\n", name)
 		os.Exit(2)
 	}
@@ -50,34 +59,34 @@ func registerModel(prefix string, model interface{}) {
 		os.Exit(2)
 	}
 
-	info := newModelInfo(val)
-	if info.fields.pk == nil {
+	mi := newModelInfo(val)
+	if mi.fields.pk == nil {
 	outFor:
-		for _, fi := range info.fields.fieldsDB {
+		for _, fi := range mi.fields.fieldsDB {
 			if strings.ToLower(fi.name) == "id" {
 				switch fi.addrValue.Elem().Kind() {
 				case reflect.Int, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint32, reflect.Uint64:
 					fi.auto = true
 					fi.pk = true
-					info.fields.pk = fi
+					mi.fields.pk = fi
 					break outFor
 				}
 			}
 		}
 
-		if info.fields.pk == nil {
+		if mi.fields.pk == nil {
 			fmt.Printf("<orm.RegisterModel> `%s` need a primary key field, default use 'id' if not set\n", name)
 			os.Exit(2)
 		}
 
 	}
 
-	info.table = table
-	info.pkg = typ.PkgPath()
-	info.model = model
-	info.manual = true
+	mi.table = table
+	mi.pkg = typ.PkgPath()
+	mi.model = model
+	mi.manual = true
 
-	modelCache.set(table, info)
+	modelCache.set(table, mi)
 }
 
 // boostrap models
@@ -85,30 +94,29 @@ func bootStrap() {
 	if modelCache.done {
 		return
 	}
-
 	var (
 		err    error
 		models map[string]*modelInfo
 	)
-
 	if dataBaseCache.getDefault() == nil {
 		err = fmt.Errorf("must have one register DataBase alias named `default`")
 		goto end
 	}
 
+	// set rel and reverse model
+	// RelManyToMany set the relTable
 	models = modelCache.all()
 	for _, mi := range models {
 		for _, fi := range mi.fields.columns {
 			if fi.rel || fi.reverse {
 				elm := fi.addrValue.Type().Elem()
-				switch fi.fieldType {
-				case RelReverseMany, RelManyToMany:
+				if fi.fieldType == RelReverseMany || fi.fieldType == RelManyToMany {
 					elm = elm.Elem()
 				}
-
+				// check the rel or reverse model already register
 				name := getFullName(elm)
-				mii, ok := modelCache.getByFN(name)
-				if ok == false || mii.pkg != elm.PkgPath() {
+				mii, ok := modelCache.getByFullName(name)
+				if !ok || mii.pkg != elm.PkgPath() {
 					err = fmt.Errorf("can not found rel in field `%s`, `%s` may be miss register", fi.fullName, elm.String())
 					goto end
 				}
@@ -117,20 +125,17 @@ func bootStrap() {
 				switch fi.fieldType {
 				case RelManyToMany:
 					if fi.relThrough != "" {
-						msg := fmt.Sprintf("field `%s` wrong rel_through value `%s`", fi.fullName, fi.relThrough)
 						if i := strings.LastIndex(fi.relThrough, "."); i != -1 && len(fi.relThrough) > (i+1) {
 							pn := fi.relThrough[:i]
-							rmi, ok := modelCache.getByFN(fi.relThrough)
+							rmi, ok := modelCache.getByFullName(fi.relThrough)
 							if ok == false || pn != rmi.pkg {
-								err = errors.New(msg + " cannot find table")
+								err = fmt.Errorf("field `%s` wrong rel_through value `%s` cannot find table", fi.fullName, fi.relThrough)
 								goto end
 							}
-
 							fi.relThroughModelInfo = rmi
 							fi.relTable = rmi.table
-
 						} else {
-							err = errors.New(msg)
+							err = fmt.Errorf("field `%s` wrong rel_through value `%s`", fi.fullName, fi.relThrough)
 							goto end
 						}
 					} else {
@@ -138,7 +143,6 @@ func bootStrap() {
 						if fi.relTable != "" {
 							i.table = fi.relTable
 						}
-
 						if v := modelCache.set(i.table, i); v != nil {
 							err = fmt.Errorf("the rel table name `%s` already registered, cannot be use, please change one", fi.relTable)
 							goto end
@@ -153,6 +157,8 @@ func bootStrap() {
 		}
 	}
 
+	// check the rel filed while the relModelInfo also has filed point to current model
+	// if not exist, add a new field to the relModelInfo
 	models = modelCache.all()
 	for _, mi := range models {
 		for _, fi := range mi.fields.fieldsRel {
@@ -165,7 +171,6 @@ func bootStrap() {
 						break
 					}
 				}
-
 				if inModel == false {
 					rmi := fi.relModelInfo
 					ffi := new(fieldInfo)
@@ -216,7 +221,6 @@ func bootStrap() {
 						}
 					}
 				}
-
 				if fi.reverseFieldInfoTwo == nil {
 					err = fmt.Errorf("can not find m2m field for m2m model `%s`, ensure your m2m model defined correct",
 						fi.relThroughModelInfo.fullName)
@@ -300,17 +304,31 @@ end:
 
 // RegisterModel register models
 func RegisterModel(models ...interface{}) {
+	if modelCache.done {
+		panic(fmt.Errorf("RegisterModel must be run before BootStrap"))
+	}
 	RegisterModelWithPrefix("", models...)
 }
 
 // RegisterModelWithPrefix register models with a prefix
 func RegisterModelWithPrefix(prefix string, models ...interface{}) {
 	if modelCache.done {
-		panic(fmt.Errorf("RegisterModel must be run before BootStrap"))
+		panic(fmt.Errorf("RegisterModelWithPrefix must be run before BootStrap"))
 	}
 
 	for _, model := range models {
-		registerModel(prefix, model)
+		registerModel(prefix, model, true)
+	}
+}
+
+// RegisterModelWithSuffix register models with a suffix
+func RegisterModelWithSuffix(suffix string, models ...interface{}) {
+	if modelCache.done {
+		panic(fmt.Errorf("RegisterModelWithSuffix must be run before BootStrap"))
+	}
+
+	for _, model := range models {
+		registerModel(suffix, model, false)
 	}
 }
 
@@ -320,7 +338,6 @@ func BootStrap() {
 	if modelCache.done {
 		return
 	}
-
 	modelCache.Lock()
 	defer modelCache.Unlock()
 	bootStrap()

orm/models_info_f.go

@@ -104,7 +104,7 @@ type fieldInfo struct {
 	mi                  *modelInfo
 	fieldIndex          []int
 	fieldType           int
-	dbcol               bool
+	dbcol               bool // table column fk and onetoone
 	inModel             bool
 	name                string
 	fullName            string
@@ -116,13 +116,13 @@ type fieldInfo struct {
 	null                bool
 	index               bool
 	unique              bool
-	colDefault          bool
-	initial             StrTo
+	colDefault          bool  // whether has default tag
+	initial             StrTo // store the default value
 	size                int
 	toText              bool
 	autoNow             bool
 	autoNowAdd          bool
-	rel                 bool
+	rel                 bool // if type equal to RelForeignKey, RelOneToOne, RelManyToMany then true
 	reverse             bool
 	reverseField        string
 	reverseFieldInfo    *fieldInfo
@@ -134,7 +134,7 @@ type fieldInfo struct {
 	relModelInfo        *modelInfo
 	digits              int
 	decimals            int
-	isFielder           bool
+	isFielder           bool // implement Fielder interface
 	onDelete            string
 }
 
@@ -143,7 +143,7 @@ func newFieldInfo(mi *modelInfo, field reflect.Value, sf reflect.StructField, mN
 	var (
 		tag       string
 		tagValue  string
-		initial   StrTo
+		initial   StrTo // store the default value
 		fieldType int
 		attrs     map[string]bool
 		tags      map[string]string
@@ -152,6 +152,10 @@ func newFieldInfo(mi *modelInfo, field reflect.Value, sf reflect.StructField, mN
 
 	fi = new(fieldInfo)
 
+	// if field which CanAddr is the follow type
+	//  A value is addressable if it is an element of a slice,
+	//  an element of an addressable array, a field of an
+	//  addressable struct, or the result of dereferencing a pointer.
 	addrField = field
 	if field.CanAddr() && field.Kind() != reflect.Ptr {
 		addrField = field.Addr()
@@ -162,7 +166,7 @@ func newFieldInfo(mi *modelInfo, field reflect.Value, sf reflect.StructField, mN
 		}
 	}
 
-	parseStructTag(sf.Tag.Get(defaultStructTagName), &attrs, &tags)
+	attrs, tags = parseStructTag(sf.Tag.Get(defaultStructTagName))
 
 	if _, ok := attrs["-"]; ok {
 		return nil, errSkipField
@@ -188,7 +192,7 @@ checkType:
 		}
 		fieldType = f.FieldType()
 		if fieldType&IsRelField > 0 {
-			err = fmt.Errorf("unsupport rel type custom field")
+			err = fmt.Errorf("unsupport type custom field, please refer to https://github.com/astaxie/beego/blob/master/orm/models_fields.go#L24-L42")
 			goto end
 		}
 	default:
@@ -211,7 +215,7 @@ checkType:
 				}
 				break checkType
 			default:
-				err = fmt.Errorf("error")
+				err = fmt.Errorf("rel only allow these value: fk, one, m2m")
 				goto wrongTag
 			}
 		}
@@ -231,7 +235,7 @@ checkType:
 				}
 				break checkType
 			default:
-				err = fmt.Errorf("error")
+				err = fmt.Errorf("reverse only allow these value: one, many")
 				goto wrongTag
 			}
 		}
@@ -261,6 +265,9 @@ checkType:
 		}
 	}
 
+	// check the rel and reverse type
+	// rel should Ptr
+	// reverse should slice []*struct
 	switch fieldType {
 	case RelForeignKey, RelOneToOne, RelReverseOne:
 		if field.Kind() != reflect.Ptr {
@@ -399,14 +406,12 @@ checkType:
 
 	if fi.auto || fi.pk {
 		if fi.auto {
-
 			switch addrField.Elem().Kind() {
 			case reflect.Int, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint32, reflect.Uint64:
 			default:
 				err = fmt.Errorf("auto primary key only support int, int32, int64, uint, uint32, uint64 but found `%s`", addrField.Elem().Kind())
 				goto end
 			}
-
 			fi.pk = true
 		}
 		fi.null = false
@@ -418,8 +423,8 @@ checkType:
 		fi.index = false
 	}
 
+	// can not set default for these type
 	if fi.auto || fi.pk || fi.unique || fieldType == TypeTimeField || fieldType == TypeDateField || fieldType == TypeDateTimeField {
-		// can not set default
 		initial.Clear()
 	}
 

orm/models_info_m.go

@@ -29,31 +29,25 @@ type modelInfo struct {
 	model     interface{}
 	fields    *fields
 	manual    bool
-	addrField reflect.Value
+	addrField reflect.Value //store the original struct value
 	uniques   []string
 	isThrough bool
 }
 
 // new model info
-func newModelInfo(val reflect.Value) (info *modelInfo) {
-
-	info = &modelInfo{}
-	info.fields = newFields()
-
+func newModelInfo(val reflect.Value) (mi *modelInfo) {
+	mi = &modelInfo{}
+	mi.fields = newFields()
 	ind := reflect.Indirect(val)
-	typ := ind.Type()
-
-	info.addrField = val
-
-	info.name = typ.Name()
-	info.fullName = getFullName(typ)
-
-	addModelFields(info, ind, "", []int{})
-
+	mi.addrField = val
+	mi.name = ind.Type().Name()
+	mi.fullName = getFullName(ind.Type())
+	addModelFields(mi, ind, "", []int{})
 	return
 }
 
-func addModelFields(info *modelInfo, ind reflect.Value, mName string, index []int) {
+// index: FieldByIndex returns the nested field corresponding to index
+func addModelFields(mi *modelInfo, ind reflect.Value, mName string, index []int) {
 	var (
 		err error
 		fi  *fieldInfo
@@ -63,43 +57,39 @@ func addModelFields(info *modelInfo, ind reflect.Value, mName string, index []in
 	for i := 0; i < ind.NumField(); i++ {
 		field := ind.Field(i)
 		sf = ind.Type().Field(i)
+		// if the field is unexported skip
 		if sf.PkgPath != "" {
 			continue
 		}
 		// add anonymous struct fields
 		if sf.Anonymous {
-			addModelFields(info, field, mName+"."+sf.Name, append(index, i))
+			addModelFields(mi, field, mName+"."+sf.Name, append(index, i))
 			continue
 		}
 
-		fi, err = newFieldInfo(info, field, sf, mName)
-
-		if err != nil {
-			if err == errSkipField {
-				err = nil
-				continue
-			}
+		fi, err = newFieldInfo(mi, field, sf, mName)
+		if err == errSkipField {
+			err = nil
+			continue
+		} else if err != nil {
 			break
 		}
-
-		added := info.fields.Add(fi)
-		if added == false {
+		//record current field index
+		fi.fieldIndex = append(index, i)
+		fi.mi = mi
+		fi.inModel = true
+		if mi.fields.Add(fi) == false {
 			err = fmt.Errorf("duplicate column name: %s", fi.column)
 			break
 		}
-
 		if fi.pk {
-			if info.fields.pk != nil {
+			if mi.fields.pk != nil {
 				err = fmt.Errorf("one model must have one pk field only")
 				break
 			} else {
-				info.fields.pk = fi
+				mi.fields.pk = fi
 			}
 		}
-
-		fi.fieldIndex = append(index, i)
-		fi.mi = info
-		fi.inModel = true
 	}
 
 	if err != nil {
@@ -110,23 +100,23 @@ func addModelFields(info *modelInfo, ind reflect.Value, mName string, index []in
 
 // combine related model info to new model info.
 // prepare for relation models query.
-func newM2MModelInfo(m1, m2 *modelInfo) (info *modelInfo) {
-	info = new(modelInfo)
-	info.fields = newFields()
-	info.table = m1.table + "_" + m2.table + "s"
-	info.name = camelString(info.table)
-	info.fullName = m1.pkg + "." + info.name
+func newM2MModelInfo(m1, m2 *modelInfo) (mi *modelInfo) {
+	mi = new(modelInfo)
+	mi.fields = newFields()
+	mi.table = m1.table + "_" + m2.table + "s"
+	mi.name = camelString(mi.table)
+	mi.fullName = m1.pkg + "." + mi.name
 
-	fa := new(fieldInfo)
-	f1 := new(fieldInfo)
-	f2 := new(fieldInfo)
+	fa := new(fieldInfo) // pk
+	f1 := new(fieldInfo) // m1 table RelForeignKey
+	f2 := new(fieldInfo) // m2 table RelForeignKey
 	fa.fieldType = TypeBigIntegerField
 	fa.auto = true
 	fa.pk = true
 	fa.dbcol = true
 	fa.name = "Id"
 	fa.column = "id"
-	fa.fullName = info.fullName + "." + fa.name
+	fa.fullName = mi.fullName + "." + fa.name
 
 	f1.dbcol = true
 	f2.dbcol = true
@@ -134,8 +124,8 @@ func newM2MModelInfo(m1, m2 *modelInfo) (info *modelInfo) {
 	f2.fieldType = RelForeignKey
 	f1.name = camelString(m1.table)
 	f2.name = camelString(m2.table)
-	f1.fullName = info.fullName + "." + f1.name
-	f2.fullName = info.fullName + "." + f2.name
+	f1.fullName = mi.fullName + "." + f1.name
+	f2.fullName = mi.fullName + "." + f2.name
 	f1.column = m1.table + "_id"
 	f2.column = m2.table + "_id"
 	f1.rel = true
@@ -144,14 +134,14 @@ func newM2MModelInfo(m1, m2 *modelInfo) (info *modelInfo) {
 	f2.relTable = m2.table
 	f1.relModelInfo = m1
 	f2.relModelInfo = m2
-	f1.mi = info
-	f2.mi = info
+	f1.mi = mi
+	f2.mi = mi
 
-	info.fields.Add(fa)
-	info.fields.Add(f1)
-	info.fields.Add(f2)
-	info.fields.pk = fa
+	mi.fields.Add(fa)
+	mi.fields.Add(f1)
+	mi.fields.Add(f2)
+	mi.fields.pk = fa
 
-	info.uniques = []string{f1.column, f2.column}
+	mi.uniques = []string{f1.column, f2.column}
 	return
 }

orm/models_utils.go

@@ -22,25 +22,47 @@ import (
 	"time"
 )
 
+// 1 is attr
+// 2 is tag
+var supportTag = map[string]int{
+	"-":            1,
+	"null":         1,
+	"index":        1,
+	"unique":       1,
+	"pk":           1,
+	"auto":         1,
+	"auto_now":     1,
+	"auto_now_add": 1,
+	"size":         2,
+	"column":       2,
+	"default":      2,
+	"rel":          2,
+	"reverse":      2,
+	"rel_table":    2,
+	"rel_through":  2,
+	"digits":       2,
+	"decimals":     2,
+	"on_delete":    2,
+	"type":         2,
+}
+
 // get reflect.Type name with package path.
 func getFullName(typ reflect.Type) string {
 	return typ.PkgPath() + "." + typ.Name()
 }
 
-// get table name. method, or field name. auto snaked.
+// getTableName get struct table name.
+// If the struct implement the TableName, then get the result as tablename
+// else use the struct name which will apply snakeString.
 func getTableName(val reflect.Value) string {
-	ind := reflect.Indirect(val)
-	fun := val.MethodByName("TableName")
-	if fun.IsValid() {
+	if fun := val.MethodByName("TableName"); fun.IsValid() {
 		vals := fun.Call([]reflect.Value{})
-		if len(vals) > 0 {
-			val := vals[0]
-			if val.Kind() == reflect.String {
-				return val.String()
-			}
+		// has return and the first val is string
+		if len(vals) > 0 && vals[0].Kind() == reflect.String {
+			return vals[0].String()
 		}
 	}
-	return snakeString(ind.Type().Name())
+	return snakeString(reflect.Indirect(val).Type().Name())
 }
 
 // get table engine, mysiam or innodb.
@@ -48,11 +70,8 @@ func getTableEngine(val reflect.Value) string {
 	fun := val.MethodByName("TableEngine")
 	if fun.IsValid() {
 		vals := fun.Call([]reflect.Value{})
-		if len(vals) > 0 {
-			val := vals[0]
-			if val.Kind() == reflect.String {
-				return val.String()
-			}
+		if len(vals) > 0 && vals[0].Kind() == reflect.String {
+			return vals[0].String()
 		}
 	}
 	return ""
@@ -63,12 +82,9 @@ func getTableIndex(val reflect.Value) [][]string {
 	fun := val.MethodByName("TableIndex")
 	if fun.IsValid() {
 		vals := fun.Call([]reflect.Value{})
-		if len(vals) > 0 {
-			val := vals[0]
-			if val.CanInterface() {
-				if d, ok := val.Interface().([][]string); ok {
-					return d
-				}
+		if len(vals) > 0 && vals[0].CanInterface() {
+			if d, ok := vals[0].Interface().([][]string); ok {
+				return d
 			}
 		}
 	}
@@ -80,12 +96,9 @@ func getTableUnique(val reflect.Value) [][]string {
 	fun := val.MethodByName("TableUnique")
 	if fun.IsValid() {
 		vals := fun.Call([]reflect.Value{})
-		if len(vals) > 0 {
-			val := vals[0]
-			if val.CanInterface() {
-				if d, ok := val.Interface().([][]string); ok {
-					return d
-				}
+		if len(vals) > 0 && vals[0].CanInterface() {
+			if d, ok := vals[0].Interface().([][]string); ok {
+				return d
 			}
 		}
 	}
@@ -189,21 +202,25 @@ func getFieldType(val reflect.Value) (ft int, err error) {
 }
 
 // parse struct tag string
-func parseStructTag(data string, attrs *map[string]bool, tags *map[string]string) {
-	attr := make(map[string]bool)
-	tag := make(map[string]string)
+func parseStructTag(data string) (attrs map[string]bool, tags map[string]string) {
+	attrs = make(map[string]bool)
+	tags = make(map[string]string)
 	for _, v := range strings.Split(data, defaultStructTagDelim) {
+		if v == "" {
+			continue
+		}
 		v = strings.TrimSpace(v)
 		if t := strings.ToLower(v); supportTag[t] == 1 {
-			attr[t] = true
+			attrs[t] = true
 		} else if i := strings.Index(v, "("); i > 0 && strings.Index(v, ")") == len(v)-1 {
 			name := t[:i]
 			if supportTag[name] == 2 {
 				v = v[i+1 : len(v)-1]
-				tag[name] = v
+				tags[name] = v
 			}
+		} else {
+			DebugLog.Println("unsupport orm tag", v)
 		}
 	}
-	*attrs = attr
-	*tags = tag
+	return
 }

orm/orm.go

@@ -68,7 +68,7 @@ const (
 // Define common vars
 var (
 	Debug            = false
-	DebugLog         = NewLog(os.Stderr)
+	DebugLog         = NewLog(os.Stdout)
 	DefaultRowsLimit = 1000
 	DefaultRelsDepth = 2
 	DefaultTimeLoc   = time.Local
@@ -104,7 +104,7 @@ func (o *orm) getMiInd(md interface{}, needPtr bool) (mi *modelInfo, ind reflect
 		panic(fmt.Errorf("<Ormer> cannot use non-ptr model struct `%s`", getFullName(typ)))
 	}
 	name := getFullName(typ)
-	if mi, ok := modelCache.getByFN(name); ok {
+	if mi, ok := modelCache.getByFullName(name); ok {
 		return mi, ind
 	}
 	panic(fmt.Errorf("<Ormer> table: `%s` not found, maybe not RegisterModel", name))
@@ -122,7 +122,17 @@ func (o *orm) getFieldInfo(mi *modelInfo, name string) *fieldInfo {
 // read data to model
 func (o *orm) Read(md interface{}, cols ...string) error {
 	mi, ind := o.getMiInd(md, true)
-	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols)
+	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols, false)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// read data to model, like Read(), but use "SELECT FOR UPDATE" form
+func (o *orm) ReadForUpdate(md interface{}, cols ...string) error {
+	mi, ind := o.getMiInd(md, true)
+	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols, true)
 	if err != nil {
 		return err
 	}
@@ -133,7 +143,7 @@ func (o *orm) Read(md interface{}, cols ...string) error {
 func (o *orm) ReadOrCreate(md interface{}, col1 string, cols ...string) (bool, int64, error) {
 	cols = append([]string{col1}, cols...)
 	mi, ind := o.getMiInd(md, true)
-	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols)
+	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols, false)
 	if err == ErrNoRows {
 		// Create
 		id, err := o.Insert(md)
@@ -234,9 +244,10 @@ func (o *orm) Update(md interface{}, cols ...string) (int64, error) {
 }
 
 // delete model in database
-func (o *orm) Delete(md interface{}) (int64, error) {
+// cols shows the delete conditions values read from. deafult is pk
+func (o *orm) Delete(md interface{}, cols ...string) (int64, error) {
 	mi, ind := o.getMiInd(md, true)
-	num, err := o.alias.DbBaser.Delete(o.db, mi, ind, o.alias.TZ)
+	num, err := o.alias.DbBaser.Delete(o.db, mi, ind, o.alias.TZ, cols)
 	if err != nil {
 		return num, err
 	}
@@ -427,7 +438,7 @@ func (o *orm) QueryTable(ptrStructOrTableName interface{}) (qs QuerySeter) {
 		}
 	} else {
 		name = getFullName(indirectType(reflect.TypeOf(ptrStructOrTableName)))
-		if mi, ok := modelCache.getByFN(name); ok {
+		if mi, ok := modelCache.getByFullName(name); ok {
 			qs = newQuerySet(o, mi)
 		}
 	}

orm/orm_conds.go

@@ -75,6 +75,19 @@ func (c *Condition) AndCond(cond *Condition) *Condition {
 	return c
 }
 
+// AndNotCond combine a AND NOT condition to current condition
+func (c *Condition) AndNotCond(cond *Condition) *Condition {
+	c = c.clone()
+	if c == cond {
+		panic(fmt.Errorf("<Condition.AndNotCond> cannot use self as sub cond"))
+	}
+
+	if cond != nil {
+		c.params = append(c.params, condValue{cond: cond, isCond: true, isNot: true})
+	}
+	return c
+}
+
 // Or add OR expression to condition
 func (c Condition) Or(expr string, args ...interface{}) *Condition {
 	if expr == "" || len(args) == 0 {
@@ -105,6 +118,19 @@ func (c *Condition) OrCond(cond *Condition) *Condition {
 	return c
 }
 
+// OrNotCond combine a OR NOT condition to current condition
+func (c *Condition) OrNotCond(cond *Condition) *Condition {
+	c = c.clone()
+	if c == cond {
+		panic(fmt.Errorf("<Condition.OrNotCond> cannot use self as sub cond"))
+	}
+
+	if cond != nil {
+		c.params = append(c.params, condValue{cond: cond, isCond: true, isNot: true, isOr: true})
+	}
+	return c
+}
+
 // IsEmpty check the condition arguments are empty or not.
 func (c *Condition) IsEmpty() bool {
 	return len(c.params) == 0

orm/orm_log.go

@@ -42,7 +42,7 @@ func debugLogQueies(alias *alias, operaton, query string, t time.Time, err error
 	if err != nil {
 		flag = "FAIL"
 	}
-	con := fmt.Sprintf(" - %s - [Queries/%s] - [%s / %11s / %7.1fms] - [%s]", t.Format(formatDateTime), alias.Name, flag, operaton, elsp, query)
+	con := fmt.Sprintf(" -[Queries/%s] - [%s / %11s / %7.1fms] - [%s]", alias.Name, flag, operaton, elsp, query)
 	cons := make([]string, 0, len(args))
 	for _, arg := range args {
 		cons = append(cons, fmt.Sprintf("%v", arg))

orm/orm_raw.go

@@ -286,7 +286,7 @@ func (o *rawSet) QueryRow(containers ...interface{}) error {
 
 			structMode = true
 			fn := getFullName(typ)
-			if mi, ok := modelCache.getByFN(fn); ok {
+			if mi, ok := modelCache.getByFullName(fn); ok {
 				sMi = mi
 			}
 		} else {
@@ -355,12 +355,9 @@ func (o *rawSet) QueryRow(containers ...interface{}) error {
 				for i := 0; i < ind.NumField(); i++ {
 					f := ind.Field(i)
 					fe := ind.Type().Field(i)
-
-					var attrs map[string]bool
-					var tags map[string]string
-					parseStructTag(fe.Tag.Get("orm"), &attrs, &tags)
+					_, tags := parseStructTag(fe.Tag.Get(defaultStructTagName))
 					var col string
-					if col = tags["column"]; len(col) == 0 {
+					if col = tags["column"]; col == "" {
 						col = snakeString(fe.Name)
 					}
 					if v, ok := columnsMp[col]; ok {
@@ -422,7 +419,7 @@ func (o *rawSet) QueryRows(containers ...interface{}) (int64, error) {
 
 			structMode = true
 			fn := getFullName(typ)
-			if mi, ok := modelCache.getByFN(fn); ok {
+			if mi, ok := modelCache.getByFullName(fn); ok {
 				sMi = mi
 			}
 		} else {
@@ -499,12 +496,9 @@ func (o *rawSet) QueryRows(containers ...interface{}) (int64, error) {
 				for i := 0; i < ind.NumField(); i++ {
 					f := ind.Field(i)
 					fe := ind.Type().Field(i)
-
-					var attrs map[string]bool
-					var tags map[string]string
-					parseStructTag(fe.Tag.Get("orm"), &attrs, &tags)
+					_, tags := parseStructTag(fe.Tag.Get(defaultStructTagName))
 					var col string
-					if col = tags["column"]; len(col) == 0 {
+					if col = tags["column"]; col == "" {
 						col = snakeString(fe.Name)
 					}
 					if v, ok := columnsMp[col]; ok {

orm/orm_test.go

@@ -227,7 +227,7 @@ func TestModelSyntax(t *testing.T) {
 	user := &User{}
 	ind := reflect.ValueOf(user).Elem()
 	fn := getFullName(ind.Type())
-	mi, ok := modelCache.getByFN(fn)
+	mi, ok := modelCache.getByFullName(fn)
 	throwFail(t, AssertIs(ok, true))
 
 	mi, ok = modelCache.get("user")
@@ -577,6 +577,10 @@ func TestCRUD(t *testing.T) {
 	err = dORM.Read(&ub)
 	throwFail(t, err)
 	throwFail(t, AssertIs(ub.Name, "name"))
+
+	num, err = dORM.Delete(&ub, "name")
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 1))
 }
 
 func TestInsertTestData(t *testing.T) {
@@ -905,6 +909,16 @@ func TestSetCond(t *testing.T) {
 	num, err = qs.SetCond(cond2).Count()
 	throwFail(t, err)
 	throwFail(t, AssertIs(num, 2))
+
+	cond3 := cond.AndNotCond(cond.And("status__in", 1))
+	num, err = qs.SetCond(cond3).Count()
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 2))
+
+	cond4 := cond.And("user_name", "slene").OrNotCond(cond.And("user_name", "slene"))
+	num, err = qs.SetCond(cond4).Count()
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 3))
 }
 
 func TestLimit(t *testing.T) {

orm/qb.go

@@ -19,6 +19,7 @@ import "errors"
 // QueryBuilder is the Query builder interface
 type QueryBuilder interface {
 	Select(fields ...string) QueryBuilder
+	ForUpdate() QueryBuilder
 	From(tables ...string) QueryBuilder
 	InnerJoin(table string) QueryBuilder
 	LeftJoin(table string) QueryBuilder

orm/qb_mysql.go

@@ -34,6 +34,12 @@ func (qb *MySQLQueryBuilder) Select(fields ...string) QueryBuilder {
 	return qb
 }
 
+// ForUpdate add the FOR UPDATE clause
+func (qb *MySQLQueryBuilder) ForUpdate() QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "FOR UPDATE")
+	return qb
+}
+
 // From join the tables
 func (qb *MySQLQueryBuilder) From(tables ...string) QueryBuilder {
 	qb.Tokens = append(qb.Tokens, "FROM", strings.Join(tables, CommaSpace))

orm/qb_tidb.go

@@ -31,6 +31,12 @@ func (qb *TiDBQueryBuilder) Select(fields ...string) QueryBuilder {
 	return qb
 }
 
+// ForUpdate add the FOR UPDATE clause
+func (qb *TiDBQueryBuilder) ForUpdate() QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "FOR UPDATE")
+	return qb
+}
+
 // From join the tables
 func (qb *TiDBQueryBuilder) From(tables ...string) QueryBuilder {
 	qb.Tokens = append(qb.Tokens, "FROM", strings.Join(tables, CommaSpace))

orm/types.go

@@ -45,6 +45,9 @@ type Ormer interface {
 	// 	u = &User{UserName: "astaxie", Password: "pass"}
 	//	err = Ormer.Read(u, "UserName")
 	Read(md interface{}, cols ...string) error
+	// Like Read(), but with "FOR UPDATE" clause, useful in transaction.
+	// Some databases are not support this feature.
+	ReadForUpdate(md interface{}, cols ...string) error
 	// Try to read a row from the database, or insert one if it doesn't exist
 	ReadOrCreate(md interface{}, col1 string, cols ...string) (bool, int64, error)
 	// insert model data to database
@@ -71,7 +74,7 @@ type Ormer interface {
 	//	num, err = Ormer.Update(&user, "Langs", "Extra")
 	Update(md interface{}, cols ...string) (int64, error)
 	// delete model in database
-	Delete(md interface{}) (int64, error)
+	Delete(md interface{}, cols ...string) (int64, error)
 	// load related models to md model.
 	// args are limit, offset int and order string.
 	//
@@ -394,14 +397,14 @@ type txEnder interface {
 
 // base database struct
 type dbBaser interface {
-	Read(dbQuerier, *modelInfo, reflect.Value, *time.Location, []string) error
+	Read(dbQuerier, *modelInfo, reflect.Value, *time.Location, []string, bool) error
 	Insert(dbQuerier, *modelInfo, reflect.Value, *time.Location) (int64, error)
 	InsertOrUpdate(dbQuerier, *modelInfo, reflect.Value, *alias, ...string) (int64, error)
 	InsertMulti(dbQuerier, *modelInfo, reflect.Value, int, *time.Location) (int64, error)
 	InsertValue(dbQuerier, *modelInfo, bool, []string, []interface{}) (int64, error)
 	InsertStmt(stmtQuerier, *modelInfo, reflect.Value, *time.Location) (int64, error)
 	Update(dbQuerier, *modelInfo, reflect.Value, *time.Location, []string) (int64, error)
-	Delete(dbQuerier, *modelInfo, reflect.Value, *time.Location) (int64, error)
+	Delete(dbQuerier, *modelInfo, reflect.Value, *time.Location, []string) (int64, error)
 	ReadBatch(dbQuerier, *querySet, *modelInfo, *Condition, interface{}, *time.Location, []string) (int64, error)
 	SupportUpdateJoin() bool
 	UpdateBatch(dbQuerier, *querySet, *modelInfo, *Condition, Params, *time.Location) (int64, error)

orm/utils.go

@@ -16,6 +16,7 @@ package orm
 
 import (
 	"fmt"
+	"math/big"
 	"reflect"
 	"strconv"
 	"strings"
@@ -87,6 +88,14 @@ func (f StrTo) Int32() (int32, error) {
 // Int64 string to int64
 func (f StrTo) Int64() (int64, error) {
 	v, err := strconv.ParseInt(f.String(), 10, 64)
+	if err != nil {
+		i := new(big.Int)
+		ni, ok := i.SetString(f.String(), 10) // octal
+		if !ok {
+			return int64(v), err
+		}
+		return ni.Int64(), nil
+	}
 	return int64(v), err
 }
 
@@ -117,6 +126,14 @@ func (f StrTo) Uint32() (uint32, error) {
 // Uint64 string to uint64
 func (f StrTo) Uint64() (uint64, error) {
 	v, err := strconv.ParseUint(f.String(), 10, 64)
+	if err != nil {
+		i := new(big.Int)
+		ni, ok := i.SetString(f.String(), 10)
+		if !ok {
+			return uint64(v), err
+		}
+		return ni.Uint64(), nil
+	}
 	return uint64(v), err
 }
 

parser.go

@@ -49,7 +49,7 @@ var (
 	genInfoList        map[string][]ControllerComments
 )
 
-const coomentPrefix = "commentsRouter_"
+const commentPrefix = "commentsRouter_"
 
 func init() {
 	pkgLastupdate = make(map[string]int64)
@@ -58,7 +58,7 @@ func init() {
 func parserPkg(pkgRealpath, pkgpath string) error {
 	rep := strings.NewReplacer("\\", "_", "/", "_", ".", "_")
 	commentFilename, _ = filepath.Rel(AppPath, pkgRealpath)
-	commentFilename = coomentPrefix + rep.Replace(commentFilename) + ".go"
+	commentFilename = commentPrefix + rep.Replace(commentFilename) + ".go"
 	if !compareFile(pkgRealpath) {
 		logs.Info(pkgRealpath + " no changed")
 		return nil

plugins/apiauth/apiauth.go

@@ -119,7 +119,7 @@ func APISecretAuth(f AppIDToAppSecret, timeout int) beego.FilterFunc {
 			return
 		}
 		if ctx.Input.Query("signature") !=
-			Signature(appsecret, ctx.Input.Method(), ctx.Request.Form, ctx.Input.URI()) {
+			Signature(appsecret, ctx.Input.Method(), ctx.Request.Form, ctx.Input.URL()) {
 			ctx.ResponseWriter.WriteHeader(403)
 			ctx.WriteString("auth failed")
 		}
@@ -127,7 +127,7 @@ func APISecretAuth(f AppIDToAppSecret, timeout int) beego.FilterFunc {
 }
 
 // Signature used to generate signature with the appsecret/method/params/RequestURI
-func Signature(appsecret, method string, params url.Values, RequestURI string) (result string) {
+func Signature(appsecret, method string, params url.Values, RequestURL string) (result string) {
 	var query string
 	pa := make(map[string]string)
 	for k, v := range params {
@@ -143,7 +143,7 @@ func Signature(appsecret, method string, params url.Values, RequestURI string) (
 			query = fmt.Sprintf("%v%v%v", query, vs.Keys[i], vs.Vals[i])
 		}
 	}
-	stringToSign := fmt.Sprintf("%v\n%v\n%v\n", method, query, RequestURI)
+	stringToSign := fmt.Sprintf("%v\n%v\n%v\n", method, query, RequestURL)
 
 	sha256 := sha256.New
 	hash := hmac.New(sha256, []byte(appsecret))

policy.go

@@ -0,0 +1,97 @@
+// Copyright 2016 beego authors. 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 beego
+
+import (
+	"strings"
+
+	"github.com/astaxie/beego/context"
+)
+
+// PolicyFunc defines a policy function which is invoked before the controller handler is executed.
+type PolicyFunc func(*context.Context)
+
+// FindRouter Find Router info for URL
+func (p *ControllerRegister) FindPolicy(cont *context.Context) []PolicyFunc {
+	var urlPath = cont.Input.URL()
+	if !BConfig.RouterCaseSensitive {
+		urlPath = strings.ToLower(urlPath)
+	}
+	httpMethod := cont.Input.Method()
+	isWildcard := false
+	// Find policy for current method
+	t, ok := p.policies[httpMethod]
+	// If not found - find policy for whole controller
+	if !ok {
+		t, ok = p.policies["*"]
+		isWildcard = true
+	}
+	if ok {
+		runObjects := t.Match(urlPath, cont)
+		if r, ok := runObjects.([]PolicyFunc); ok {
+			return r
+		} else if !isWildcard {
+			// If no policies found and we checked not for "*" method - try to find it
+			t, ok = p.policies["*"]
+			if ok {
+				runObjects = t.Match(urlPath, cont)
+				if r, ok = runObjects.([]PolicyFunc); ok {
+					return r
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (p *ControllerRegister) addToPolicy(method, pattern string, r ...PolicyFunc) {
+	method = strings.ToUpper(method)
+	p.enablePolicy = true
+	if !BConfig.RouterCaseSensitive {
+		pattern = strings.ToLower(pattern)
+	}
+	if t, ok := p.policies[method]; ok {
+		t.AddRouter(pattern, r)
+	} else {
+		t := NewTree()
+		t.AddRouter(pattern, r)
+		p.policies[method] = t
+	}
+}
+
+// Register new policy in beego
+func Policy(pattern, method string, policy ...PolicyFunc) {
+	BeeApp.Handlers.addToPolicy(method, pattern, policy...)
+}
+
+// Find policies and execute if were found
+func (p *ControllerRegister) execPolicy(cont *context.Context, urlPath string) (started bool) {
+	if !p.enablePolicy {
+		return false
+	}
+	// Find Policy for method
+	policyList := p.FindPolicy(cont)
+	if len(policyList) > 0 {
+		// Run policies
+		for _, runPolicy := range policyList {
+			runPolicy(cont)
+			if cont.ResponseWriter.Started {
+				return true
+			}
+		}
+		return false
+	}
+	return false
+}

router.go

@@ -114,6 +114,8 @@ type controllerInfo struct {
 // ControllerRegister containers registered router rules, controller handlers and filters.
 type ControllerRegister struct {
 	routers      map[string]*Tree
+	enablePolicy bool
+	policies     map[string]*Tree
 	enableFilter bool
 	filters      [FinishRouter + 1][]*FilterRouter
 	pool         sync.Pool
@@ -122,7 +124,8 @@ type ControllerRegister struct {
 // NewControllerRegister returns a new ControllerRegister.
 func NewControllerRegister() *ControllerRegister {
 	cr := &ControllerRegister{
-		routers: make(map[string]*Tree),
+		routers:  make(map[string]*Tree),
+		policies: make(map[string]*Tree),
 	}
 	cr.pool.New = func() interface{} {
 		return beecontext.NewContext()
@@ -626,7 +629,9 @@ func (p *ControllerRegister) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 	context.Reset(rw, r)
 
 	defer p.pool.Put(context)
-	defer p.recoverPanic(context)
+	if BConfig.RecoverFunc != nil {
+		defer BConfig.RecoverFunc(context)
+	}
 
 	context.Output.EnableGzip = BConfig.EnableGzip
 
@@ -683,8 +688,16 @@ func (p *ControllerRegister) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 	if len(p.filters[BeforeRouter]) > 0 && p.execFilter(context, urlPath, BeforeRouter) {
 		goto Admin
 	}
+	// User can define RunController and RunMethod in filter
+	if context.Input.RunController != nil && context.Input.RunMethod != "" {
+		findRouter = true
+		isRunnable = true
+		runMethod = context.Input.RunMethod
+		runRouter = context.Input.RunController
+	} else {
+		routerInfo, findRouter = p.FindRouter(context)
+	}
 
-	routerInfo, findRouter = p.FindRouter(context)
 	//if no matches to url, throw a not found exception
 	if !findRouter {
 		exception("404", context)
@@ -696,15 +709,19 @@ func (p *ControllerRegister) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 		}
 	}
 
-	//store router pattern into context
-	context.Input.SetData("RouterPattern", routerInfo.pattern)
-
 	//execute middleware filters
 	if len(p.filters[BeforeExec]) > 0 && p.execFilter(context, urlPath, BeforeExec) {
 		goto Admin
 	}
 
+	//check policies
+	if p.execPolicy(context, urlPath) {
+		goto Admin
+	}
+
 	if routerInfo != nil {
+		//store router pattern into context
+		context.Input.SetData("RouterPattern", routerInfo.pattern)
 		if routerInfo.routerType == routerTypeRESTFul {
 			if _, ok := routerInfo.methods[r.Method]; ok {
 				isRunnable = true
@@ -838,16 +855,16 @@ Admin:
 
 		if findRouter {
 			if routerInfo != nil {
-				devInfo = fmt.Sprintf("|%s %3d %s|%13s|%8s|%s %s %-7s %-3s   r:%s", statusColor, statusCode,
-					resetColor, timeDur.String(), "match", methodColor, resetColor, r.Method, r.URL.Path,
+				devInfo = fmt.Sprintf("|%15s|%s %3d %s|%13s|%8s|%s %-7s %s %-3s   r:%s", context.Input.IP(), statusColor, statusCode,
+					resetColor, timeDur.String(), "match", methodColor, r.Method, resetColor, r.URL.Path,
 					routerInfo.pattern)
 			} else {
-				devInfo = fmt.Sprintf("|%s %3d %s|%13s|%8s|%s %s %-7s %-3s", statusColor, statusCode, resetColor,
-					timeDur.String(), "match", methodColor, resetColor, r.Method, r.URL.Path)
+				devInfo = fmt.Sprintf("|%15s|%s %3d %s|%13s|%8s|%s %-7s %s %-3s", context.Input.IP(), statusColor, statusCode, resetColor,
+					timeDur.String(), "match", methodColor, r.Method, resetColor, r.URL.Path)
 			}
 		} else {
-			devInfo = fmt.Sprintf("|%s %3d %s|%13s|%8s|%s %s %-7s %-3s", statusColor, statusCode, resetColor,
-				timeDur.String(), "nomatch", methodColor, resetColor, r.Method, r.URL.Path)
+			devInfo = fmt.Sprintf("|%15s|%s %3d %s|%13s|%8s|%s %-7s %s %-3s", context.Input.IP(), statusColor, statusCode, resetColor,
+				timeDur.String(), "nomatch", methodColor, r.Method, resetColor, r.URL.Path)
 		}
 		if iswin {
 			logs.W32Debug(devInfo)
@@ -878,37 +895,6 @@ func (p *ControllerRegister) FindRouter(context *beecontext.Context) (routerInfo
 	return
 }
 
-func (p *ControllerRegister) recoverPanic(context *beecontext.Context) {
-	if err := recover(); err != nil {
-		if err == ErrAbort {
-			return
-		}
-		if !BConfig.RecoverPanic {
-			panic(err)
-		}
-		if BConfig.EnableErrorsShow {
-			if _, ok := ErrorMaps[fmt.Sprint(err)]; ok {
-				exception(fmt.Sprint(err), context)
-				return
-			}
-		}
-		var stack string
-		logs.Critical("the request url is ", context.Input.URL())
-		logs.Critical("Handler crashed with error", err)
-		for i := 1; ; i++ {
-			_, file, line, ok := runtime.Caller(i)
-			if !ok {
-				break
-			}
-			logs.Critical(fmt.Sprintf("%s:%d", file, line))
-			stack = stack + fmt.Sprintln(fmt.Sprintf("%s:%d", file, line))
-		}
-		if BConfig.RunMode == DEV {
-			showErr(err, context, stack)
-		}
-	}
-}
-
 func toURL(params map[string]string) string {
 	if len(params) == 0 {
 		return ""

session/sess_file.go

@@ -88,10 +88,9 @@ func (fs *FileSessionStore) SessionRelease(w http.ResponseWriter) {
 	var f *os.File
 	if err == nil {
 		f, err = os.OpenFile(path.Join(filepder.savePath, string(fs.sid[0]), string(fs.sid[1]), fs.sid), os.O_RDWR, 0777)
-		SLogger.Println(err)
 	} else if os.IsNotExist(err) {
 		f, err = os.Create(path.Join(filepder.savePath, string(fs.sid[0]), string(fs.sid[1]), fs.sid))
-		SLogger.Println(err)
+
 	} else {
 		return
 	}

session/session.go

@@ -86,6 +86,7 @@ type ManagerConfig struct {
 	EnableSetCookie         bool   `json:"enableSetCookie,omitempty"`
 	Gclifetime              int64  `json:"gclifetime"`
 	Maxlifetime             int64  `json:"maxLifetime"`
+	DisableHTTPOnly         bool   `json:"disableHTTPOnly"`
 	Secure                  bool   `json:"secure"`
 	CookieLifeTime          int    `json:"cookieLifeTime"`
 	ProviderConfig          string `json:"providerConfig"`
@@ -206,13 +207,13 @@ func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (se
 
 	session, err = manager.provider.SessionRead(sid)
 	if err != nil {
-		return nil, errs
+		return nil, err
 	}
 	cookie := &http.Cookie{
 		Name:     manager.config.CookieName,
 		Value:    url.QueryEscape(sid),
 		Path:     "/",
-		HttpOnly: true,
+		HttpOnly: !manager.config.DisableHTTPOnly,
 		Secure:   manager.isSecure(r),
 		Domain:   manager.config.Domain,
 	}
@@ -251,7 +252,7 @@ func (manager *Manager) SessionDestroy(w http.ResponseWriter, r *http.Request) {
 		expiration := time.Now()
 		cookie = &http.Cookie{Name: manager.config.CookieName,
 			Path:     "/",
-			HttpOnly: true,
+			HttpOnly: !manager.config.DisableHTTPOnly,
 			Expires:  expiration,
 			MaxAge:   -1}
 
@@ -285,7 +286,7 @@ func (manager *Manager) SessionRegenerateID(w http.ResponseWriter, r *http.Reque
 		cookie = &http.Cookie{Name: manager.config.CookieName,
 			Value:    url.QueryEscape(sid),
 			Path:     "/",
-			HttpOnly: true,
+			HttpOnly: !manager.config.DisableHTTPOnly,
 			Secure:   manager.isSecure(r),
 			Domain:   manager.config.Domain,
 		}

staticfile.go

@@ -196,9 +196,11 @@ func lookupFile(ctx *context.Context) (bool, string, os.FileInfo, error) {
 	if !fi.IsDir() {
 		return false, fp, fi, err
 	}
-	ifp := filepath.Join(fp, "index.html")
-	if ifi, _ := os.Stat(ifp); ifi != nil && ifi.Mode().IsRegular() {
-		return false, ifp, ifi, err
+	if requestURL := ctx.Input.URL(); requestURL[len(requestURL)-1] == '/' {
+		ifp := filepath.Join(fp, "index.html")
+		if ifi, _ := os.Stat(ifp); ifi != nil && ifi.Mode().IsRegular() {
+			return false, ifp, ifi, err
+		}
 	}
 	return !BConfig.WebConfig.DirectoryIndex, fp, fi, err
 }

swagger/swagger.go

@@ -22,149 +22,150 @@ package swagger
 
 // Swagger list the resource
 type Swagger struct {
-	SwaggerVersion      string              `json:"swagger,omitempty"`
-	Infos               Information         `json:"info"`
-	Host                string              `json:"host,omitempty"`
-	BasePath            string              `json:"basePath,omitempty"`
-	Schemes             []string            `json:"schemes,omitempty"`
-	Consumes            []string            `json:"consumes,omitempty"`
-	Produces            []string            `json:"produces,omitempty"`
-	Paths               map[string]*Item    `json:"paths"`
-	Definitions         map[string]Schema   `json:"definitions,omitempty"`
-	SecurityDefinitions map[string]Scurity  `json:"securityDefinitions,omitempty"`
-	Security            map[string][]string `json:"security,omitempty"`
-	Tags                []Tag               `json:"tags,omitempty"`
-	ExternalDocs        *ExternalDocs       `json:"externalDocs,omitempty"`
+	SwaggerVersion      string              `json:"swagger,omitempty" yaml:"swagger,omitempty"`
+	Infos               Information         `json:"info" yaml:"info"`
+	Host                string              `json:"host,omitempty" yaml:"host,omitempty"`
+	BasePath            string              `json:"basePath,omitempty" yaml:"basePath,omitempty"`
+	Schemes             []string            `json:"schemes,omitempty" yaml:"schemes,omitempty"`
+	Consumes            []string            `json:"consumes,omitempty" yaml:"consumes,omitempty"`
+	Produces            []string            `json:"produces,omitempty" yaml:"produces,omitempty"`
+	Paths               map[string]*Item    `json:"paths" yaml:"paths"`
+	Definitions         map[string]Schema   `json:"definitions,omitempty" yaml:"definitions,omitempty"`
+	SecurityDefinitions map[string]Security `json:"securityDefinitions,omitempty" yaml:"securityDefinitions,omitempty"`
+	Security            map[string][]string `json:"security,omitempty" yaml:"security,omitempty"`
+	Tags                []Tag               `json:"tags,omitempty" yaml:"tags,omitempty"`
+	ExternalDocs        *ExternalDocs       `json:"externalDocs,omitempty" yaml:"externalDocs,omitempty"`
 }
 
 // Information Provides metadata about the API. The metadata can be used by the clients if needed.
 type Information struct {
-	Title          string `json:"title,omitempty"`
-	Description    string `json:"description,omitempty"`
-	Version        string `json:"version,omitempty"`
-	TermsOfService string `json:"termsOfService,omitempty"`
+	Title          string `json:"title,omitempty" yaml:"title,omitempty"`
+	Description    string `json:"description,omitempty" yaml:"description,omitempty"`
+	Version        string `json:"version,omitempty" yaml:"version,omitempty"`
+	TermsOfService string `json:"termsOfService,omitempty" yaml:"termsOfService,omitempty"`
 
-	Contact Contact `json:"contact,omitempty"`
-	License License `json:"license,omitempty"`
+	Contact Contact  `json:"contact,omitempty" yaml:"contact,omitempty"`
+	License *License `json:"license,omitempty" yaml:"license,omitempty"`
 }
 
 // Contact information for the exposed API.
 type Contact struct {
-	Name  string `json:"name,omitempty"`
-	URL   string `json:"url,omitempty"`
-	EMail string `json:"email,omitempty"`
+	Name  string `json:"name,omitempty" yaml:"name,omitempty"`
+	URL   string `json:"url,omitempty" yaml:"url,omitempty"`
+	EMail string `json:"email,omitempty" yaml:"email,omitempty"`
 }
 
 // License information for the exposed API.
 type License struct {
-	Name string `json:"name,omitempty"`
-	URL  string `json:"url,omitempty"`
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+	URL  string `json:"url,omitempty" yaml:"url,omitempty"`
 }
 
 // Item Describes the operations available on a single path.
 type Item struct {
-	Ref     string     `json:"$ref,omitempty"`
-	Get     *Operation `json:"get,omitempty"`
-	Put     *Operation `json:"put,omitempty"`
-	Post    *Operation `json:"post,omitempty"`
-	Delete  *Operation `json:"delete,omitempty"`
-	Options *Operation `json:"options,omitempty"`
-	Head    *Operation `json:"head,omitempty"`
-	Patch   *Operation `json:"patch,omitempty"`
+	Ref     string     `json:"$ref,omitempty" yaml:"$ref,omitempty"`
+	Get     *Operation `json:"get,omitempty" yaml:"get,omitempty"`
+	Put     *Operation `json:"put,omitempty" yaml:"put,omitempty"`
+	Post    *Operation `json:"post,omitempty" yaml:"post,omitempty"`
+	Delete  *Operation `json:"delete,omitempty" yaml:"delete,omitempty"`
+	Options *Operation `json:"options,omitempty" yaml:"options,omitempty"`
+	Head    *Operation `json:"head,omitempty" yaml:"head,omitempty"`
+	Patch   *Operation `json:"patch,omitempty" yaml:"patch,omitempty"`
 }
 
 // Operation Describes a single API operation on a path.
 type Operation struct {
-	Tags        []string            `json:"tags,omitempty"`
-	Summary     string              `json:"summary,omitempty"`
-	Description string              `json:"description,omitempty"`
-	OperationID string              `json:"operationId,omitempty"`
-	Consumes    []string            `json:"consumes,omitempty"`
-	Produces    []string            `json:"produces,omitempty"`
-	Schemes     []string            `json:"schemes,omitempty"`
-	Parameters  []Parameter         `json:"parameters,omitempty"`
-	Responses   map[string]Response `json:"responses,omitempty"`
-	Deprecated  bool                `json:"deprecated,omitempty"`
+	Tags        []string            `json:"tags,omitempty" yaml:"tags,omitempty"`
+	Summary     string              `json:"summary,omitempty" yaml:"summary,omitempty"`
+	Description string              `json:"description,omitempty" yaml:"description,omitempty"`
+	OperationID string              `json:"operationId,omitempty" yaml:"operationId,omitempty"`
+	Consumes    []string            `json:"consumes,omitempty" yaml:"consumes,omitempty"`
+	Produces    []string            `json:"produces,omitempty" yaml:"produces,omitempty"`
+	Schemes     []string            `json:"schemes,omitempty" yaml:"schemes,omitempty"`
+	Parameters  []Parameter         `json:"parameters,omitempty" yaml:"parameters,omitempty"`
+	Responses   map[string]Response `json:"responses,omitempty" yaml:"responses,omitempty"`
+	Deprecated  bool                `json:"deprecated,omitempty" yaml:"deprecated,omitempty"`
 }
 
 // Parameter Describes a single operation parameter.
 type Parameter struct {
-	In          string          `json:"in,omitempty"`
-	Name        string          `json:"name,omitempty"`
-	Description string          `json:"description,omitempty"`
-	Required    bool            `json:"required,omitempty"`
-	Schema      *Schema         `json:"schema,omitempty"`
-	Type        string          `json:"type,omitempty"`
-	Format      string          `json:"format,omitempty"`
-	Items       *ParameterItems `json:"items,omitempty"`
+	In          string          `json:"in,omitempty" yaml:"in,omitempty"`
+	Name        string          `json:"name,omitempty" yaml:"name,omitempty"`
+	Description string          `json:"description,omitempty" yaml:"description,omitempty"`
+	Required    bool            `json:"required,omitempty" yaml:"required,omitempty"`
+	Schema      *Schema         `json:"schema,omitempty" yaml:"schema,omitempty"`
+	Type        string          `json:"type,omitempty" yaml:"type,omitempty"`
+	Format      string          `json:"format,omitempty" yaml:"format,omitempty"`
+	Items       *ParameterItems `json:"items,omitempty" yaml:"items,omitempty"`
+	Default     interface{}     `json:"default,omitempty" yaml:"default,omitempty"`
 }
 
 // A limited subset of JSON-Schema's items object. It is used by parameter definitions that are not located in "body".
 // http://swagger.io/specification/#itemsObject
 type ParameterItems struct {
-	Type             string            `json:"type,omitempty"`
-	Format           string            `json:"format,omitempty"`
-	Items            []*ParameterItems `json:"items,omitempty"` //Required if type is "array". Describes the type of items in the array.
-	CollectionFormat string            `json:"collectionFormat,omitempty"`
-	Default          string            `json:"default,omitempty"`
+	Type             string            `json:"type,omitempty" yaml:"type,omitempty"`
+	Format           string            `json:"format,omitempty" yaml:"format,omitempty"`
+	Items            []*ParameterItems `json:"items,omitempty" yaml:"items,omitempty"` //Required if type is "array". Describes the type of items in the array.
+	CollectionFormat string            `json:"collectionFormat,omitempty" yaml:"collectionFormat,omitempty"`
+	Default          string            `json:"default,omitempty" yaml:"default,omitempty"`
 }
 
 // Schema Object allows the definition of input and output data types.
 type Schema struct {
-	Ref         string               `json:"$ref,omitempty"`
-	Title       string               `json:"title,omitempty"`
-	Format      string               `json:"format,omitempty"`
-	Description string               `json:"description,omitempty"`
-	Required    []string             `json:"required,omitempty"`
-	Type        string               `json:"type,omitempty"`
-	Items       *Schema              `json:"items,omitempty"`
-	Properties  map[string]Propertie `json:"properties,omitempty"`
+	Ref         string               `json:"$ref,omitempty" yaml:"$ref,omitempty"`
+	Title       string               `json:"title,omitempty" yaml:"title,omitempty"`
+	Format      string               `json:"format,omitempty" yaml:"format,omitempty"`
+	Description string               `json:"description,omitempty" yaml:"description,omitempty"`
+	Required    []string             `json:"required,omitempty" yaml:"required,omitempty"`
+	Type        string               `json:"type,omitempty" yaml:"type,omitempty"`
+	Items       *Schema              `json:"items,omitempty" yaml:"items,omitempty"`
+	Properties  map[string]Propertie `json:"properties,omitempty" yaml:"properties,omitempty"`
 }
 
 // Propertie are taken from the JSON Schema definition but their definitions were adjusted to the Swagger Specification
 type Propertie struct {
-	Ref                  string               `json:"$ref,omitempty"`
-	Title                string               `json:"title,omitempty"`
-	Description          string               `json:"description,omitempty"`
-	Default              string               `json:"default,omitempty"`
-	Type                 string               `json:"type,omitempty"`
-	Example              string               `json:"example,omitempty"`
-	Required             []string             `json:"required,omitempty"`
-	Format               string               `json:"format,omitempty"`
-	ReadOnly             bool                 `json:"readOnly,omitempty"`
-	Properties           map[string]Propertie `json:"properties,omitempty"`
-	Items                *Propertie           `json:"items,omitempty"`
-	AdditionalProperties *Propertie           `json:"additionalProperties,omitempty"`
+	Ref                  string               `json:"$ref,omitempty" yaml:"$ref,omitempty"`
+	Title                string               `json:"title,omitempty" yaml:"title,omitempty"`
+	Description          string               `json:"description,omitempty" yaml:"description,omitempty"`
+	Default              interface{}          `json:"default,omitempty" yaml:"default,omitempty"`
+	Type                 string               `json:"type,omitempty" yaml:"type,omitempty"`
+	Example              string               `json:"example,omitempty" yaml:"example,omitempty"`
+	Required             []string             `json:"required,omitempty" yaml:"required,omitempty"`
+	Format               string               `json:"format,omitempty" yaml:"format,omitempty"`
+	ReadOnly             bool                 `json:"readOnly,omitempty" yaml:"readOnly,omitempty"`
+	Properties           map[string]Propertie `json:"properties,omitempty" yaml:"properties,omitempty"`
+	Items                *Propertie           `json:"items,omitempty" yaml:"items,omitempty"`
+	AdditionalProperties *Propertie           `json:"additionalProperties,omitempty" yaml:"additionalProperties,omitempty"`
 }
 
 // Response as they are returned from executing this operation.
 type Response struct {
-	Description string  `json:"description,omitempty"`
-	Schema      *Schema `json:"schema,omitempty"`
-	Ref         string  `json:"$ref,omitempty"`
+	Description string  `json:"description,omitempty" yaml:"description,omitempty"`
+	Schema      *Schema `json:"schema,omitempty" yaml:"schema,omitempty"`
+	Ref         string  `json:"$ref,omitempty" yaml:"$ref,omitempty"`
 }
 
-// Scurity Allows the definition of a security scheme that can be used by the operations
-type Scurity struct {
-	Type             string            `json:"type,omitempty"` // Valid values are "basic", "apiKey" or "oauth2".
-	Description      string            `json:"description,omitempty"`
-	Name             string            `json:"name,omitempty"`
-	In               string            `json:"in,omitempty"`   // Valid values are "query" or "header".
-	Flow             string            `json:"flow,omitempty"` // Valid values are "implicit", "password", "application" or "accessCode".
-	AuthorizationURL string            `json:"authorizationUrl,omitempty"`
-	TokenURL         string            `json:"tokenUrl,omitempty"`
-	Scopes           map[string]string `json:"scopes,omitempty"` // The available scopes for the OAuth2 security scheme.
+// Security Allows the definition of a security scheme that can be used by the operations
+type Security struct {
+	Type             string            `json:"type,omitempty" yaml:"type,omitempty"` // Valid values are "basic", "apiKey" or "oauth2".
+	Description      string            `json:"description,omitempty" yaml:"description,omitempty"`
+	Name             string            `json:"name,omitempty" yaml:"name,omitempty"`
+	In               string            `json:"in,omitempty" yaml:"in,omitempty"`     // Valid values are "query" or "header".
+	Flow             string            `json:"flow,omitempty" yaml:"flow,omitempty"` // Valid values are "implicit", "password", "application" or "accessCode".
+	AuthorizationURL string            `json:"authorizationUrl,omitempty" yaml:"authorizationUrl,omitempty"`
+	TokenURL         string            `json:"tokenUrl,omitempty" yaml:"tokenUrl,omitempty"`
+	Scopes           map[string]string `json:"scopes,omitempty" yaml:"scopes,omitempty"` // The available scopes for the OAuth2 security scheme.
 }
 
 // Tag Allows adding meta data to a single tag that is used by the Operation Object
 type Tag struct {
-	Name         string        `json:"name,omitempty"`
-	Description  string        `json:"description,omitempty"`
-	ExternalDocs *ExternalDocs `json:"externalDocs,omitempty"`
+	Name         string        `json:"name,omitempty" yaml:"name,omitempty"`
+	Description  string        `json:"description,omitempty" yaml:"description,omitempty"`
+	ExternalDocs *ExternalDocs `json:"externalDocs,omitempty" yaml:"externalDocs,omitempty"`
 }
 
 // ExternalDocs include Additional external documentation
 type ExternalDocs struct {
-	Description string `json:"description,omitempty"`
-	URL         string `json:"url,omitempty"`
+	Description string `json:"description,omitempty" yaml:"description,omitempty"`
+	URL         string `json:"url,omitempty" yaml:"url,omitempty"`
 }

templatefunc.go

@@ -280,15 +280,8 @@ func AssetsCSS(src string) template.HTML {
 }
 
 // ParseForm will parse form values to struct via tag.
-func ParseForm(form url.Values, obj interface{}) error {
-	objT := reflect.TypeOf(obj)
-	objV := reflect.ValueOf(obj)
-	if !isStructPtr(objT) {
-		return fmt.Errorf("%v must be  a struct pointer", obj)
-	}
-	objT = objT.Elem()
-	objV = objV.Elem()
-
+// Support for anonymous struct.
+func parseFormToStruct(form url.Values, objT reflect.Type, objV reflect.Value) error {
 	for i := 0; i < objT.NumField(); i++ {
 		fieldV := objV.Field(i)
 		if !fieldV.CanSet() {
@@ -296,6 +289,14 @@ func ParseForm(form url.Values, obj interface{}) error {
 		}
 
 		fieldT := objT.Field(i)
+		if fieldT.Anonymous && fieldT.Type.Kind() == reflect.Struct {
+			err := parseFormToStruct(form, fieldT.Type, fieldV)
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
 		tags := strings.Split(fieldT.Tag.Get("form"), ",")
 		var tag string
 		if len(tags) == 0 || len(tags[0]) == 0 {
@@ -384,6 +385,19 @@ func ParseForm(form url.Values, obj interface{}) error {
 	return nil
 }
 
+// ParseForm will parse form values to struct via tag.
+func ParseForm(form url.Values, obj interface{}) error {
+	objT := reflect.TypeOf(obj)
+	objV := reflect.ValueOf(obj)
+	if !isStructPtr(objT) {
+		return fmt.Errorf("%v must be  a struct pointer", obj)
+	}
+	objT = objT.Elem()
+	objV = objV.Elem()
+
+	return parseFormToStruct(form, objT, objV)
+}
+
 var sliceOfInts = reflect.TypeOf([]int(nil))
 var sliceOfStrings = reflect.TypeOf([]string(nil))
 

templatefunc_test.go

@@ -110,6 +110,17 @@ func TestHtmlunquote(t *testing.T) {
 }
 
 func TestParseForm(t *testing.T) {
+	type ExtendInfo struct {
+		Hobby string `form:"hobby"`
+		Memo  string
+	}
+
+	type OtherInfo struct {
+		Organization string `form:"organization"`
+		Title        string `form:"title"`
+		ExtendInfo
+	}
+
 	type user struct {
 		ID      int         `form:"-"`
 		tag     string      `form:"tag"`
@@ -119,19 +130,24 @@ func TestParseForm(t *testing.T) {
 		Intro   string    `form:",textarea"`
 		StrBool bool      `form:"strbool"`
 		Date    time.Time `form:"date,2006-01-02"`
+		OtherInfo
 	}
 
 	u := user{}
 	form := url.Values{
-		"ID":       []string{"1"},
-		"-":        []string{"1"},
-		"tag":      []string{"no"},
-		"username": []string{"test"},
-		"age":      []string{"40"},
-		"Email":    []string{"test@gmail.com"},
-		"Intro":    []string{"I am an engineer!"},
-		"strbool":  []string{"yes"},
-		"date":     []string{"2014-11-12"},
+		"ID":           []string{"1"},
+		"-":            []string{"1"},
+		"tag":          []string{"no"},
+		"username":     []string{"test"},
+		"age":          []string{"40"},
+		"Email":        []string{"test@gmail.com"},
+		"Intro":        []string{"I am an engineer!"},
+		"strbool":      []string{"yes"},
+		"date":         []string{"2014-11-12"},
+		"organization": []string{"beego"},
+		"title":        []string{"CXO"},
+		"hobby":        []string{"Basketball"},
+		"memo":         []string{"nothing"},
 	}
 	if err := ParseForm(form, u); err == nil {
 		t.Fatal("nothing will be changed")
@@ -164,6 +180,18 @@ func TestParseForm(t *testing.T) {
 	if y != 2014 || m.String() != "November" || d != 12 {
 		t.Errorf("Date should equal `2014-11-12`, but got `%v`", u.Date.String())
 	}
+	if u.Organization != "beego" {
+		t.Errorf("Organization should equal `beego`, but got `%v`", u.Organization)
+	}
+	if u.Title != "CXO" {
+		t.Errorf("Title should equal `CXO`, but got `%v`", u.Title)
+	}
+	if u.Hobby != "Basketball" {
+		t.Errorf("Hobby should equal `Basketball`, but got `%v`", u.Hobby)
+	}
+	if len(u.Memo) != 0 {
+		t.Errorf("Memo's length should equal 0 but got %v", len(u.Memo))
+	}
 }
 
 func TestRenderForm(t *testing.T) {

toolbox/statistics.go

@@ -99,9 +99,13 @@ func (m *URLMap) GetMap() map[string]interface{} {
 				fmt.Sprintf("% -50s", k),
 				fmt.Sprintf("% -10s", kk),
 				fmt.Sprintf("% -16d", vv.RequestNum),
+				fmt.Sprintf("%d", vv.TotalTime),
 				fmt.Sprintf("% -16s", toS(vv.TotalTime)),
+				fmt.Sprintf("%d", vv.MaxTime),
 				fmt.Sprintf("% -16s", toS(vv.MaxTime)),
+				fmt.Sprintf("%d", vv.MinTime),
 				fmt.Sprintf("% -16s", toS(vv.MinTime)),
+				fmt.Sprintf("%d", time.Duration(int64(vv.TotalTime)/vv.RequestNum)),
 				fmt.Sprintf("% -16s", toS(time.Duration(int64(vv.TotalTime)/vv.RequestNum))),
 			}
 			resultLists = append(resultLists, result)

utils/captcha/image.go

@@ -359,6 +359,9 @@ func (m *Image) calculateSizes(width, height, ncount int) {
 	}
 	// Calculate dot size.
 	m.dotSize = int(nh / fh)
+	if m.dotSize < 1 {
+		m.dotSize = 1
+	}
 	// Save everything, making the actual width smaller by 1 dot to account
 	// for spacing between digits.
 	m.numWidth = int(nw) - m.dotSize

utils/mail.go

@@ -232,14 +232,16 @@ func (e *Email) Send() error {
 		return errors.New("Must specify at least one To address")
 	}
 
-	from, err := mail.ParseAddress(e.Username)
+	// Use the username if no From is provided
+	if len(e.From) == 0 {
+		e.From = e.Username
+	}
+
+	from, err := mail.ParseAddress(e.From)
 	if err != nil {
 		return err
 	}
 
-	if len(e.From) == 0 {
-		e.From = e.Username
-	}
 	// use mail's RFC 2047 to encode any string
 	e.Subject = qEncode("utf-8", e.Subject)