添加分页

controllers/SystemController.go

@@ -205,10 +205,41 @@ func System_FindUserPage(c *SystemController) {
 	var getpageinfo sysmodel.GetPageInfo
 	c.Ctx.BindJSON(&getpageinfo)
 	__none_func_system__(getpageinfo)
-	fmt.Println(getpageinfo)
-	page := sysmodel.SysUserPageInfo{}
+
+	page := sysmodel.PageResult{}
 	var users []sysmodel.UserInfo
-	err := c.Db.SQL(sysmodel.SqlUserInfoPage).Limit(getpageinfo.PageSize, (getpageinfo.PageNum-1)*getpageinfo.PageSize).Find(&users)
+
+	dbSession := c.Db.Table("sys_user")
+
+	JoinTables := []models.Join{}
+	JoinTables = append(JoinTables, models.Join{TabelName: "sys_user_role", Condition: "sys_user_role.user_id = sys_user.id", JoinOperator: "left"})
+	JoinTables = append(JoinTables, models.Join{TabelName: "sys_role", Condition: "sys_user_role.role_id = sys_role.id", JoinOperator: "left"})
+	JoinTables = append(JoinTables, models.Join{TabelName: "sys_org", Condition: "sys_org.id = sys_user.org_id", JoinOperator: "left"})
+
+	for _, join := range JoinTables {
+		dbSession = dbSession.Join(join.JoinOperator, join.TabelName, join.Condition)
+	}
+
+	whereStr, datas, err := getpageinfo.Filter.Parse("")
+
+	dbSession = dbSession.Where(whereStr, datas...)
+
+	sidx := strings.Split(getpageinfo.Sidx, ",")
+	for _, order := range sidx {
+		order = strings.TrimSpace(order)
+		if len(order) == 0 {
+			continue
+		}
+
+		if strings.ToLower(getpageinfo.Sord) == "desc" {
+			dbSession = dbSession.OrderBy(order + " desc")
+		} else {
+			dbSession = dbSession.OrderBy(order + " asc")
+		}
+
+	}
+
+	dbSession.Limit(getpageinfo.PageSize, (getpageinfo.PageNum-1)*getpageinfo.PageSize).GroupBy("sys_user.id").Find(&users)
 
 	//查找每个用户的角色
 	for i, user := range users {
@@ -220,7 +251,9 @@ func System_FindUserPage(c *SystemController) {
 	page.Content = users
 	page.PageSize = getpageinfo.PageSize
 	page.PageNum = getpageinfo.PageNum
-	page.TotalSize = 1
+	//page.TotalSize = int(totalPage) / getpageinfo.PageSize
+	page.TotalSize = 2
+
 	if err == nil {
 		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", page})
 	} else {

models/ColumnFilter_gen.go

@@ -1,14 +0,0 @@
-
-package models
-import (
-
-)
-
-type ColumnFilter struct {
-	
-	//过滤名称列表
-	Name   string `json:"name"`
-	//过滤值
-	Value   string `json:"value"`
-
-}

models/ColumnFilters_gen.go

@@ -1,12 +0,0 @@
-
-package models
-import (
-
-)
-
-type ColumnFilters struct {
-	
-	//过滤名称列表
-	Name   ColumnFilter `json:"name"`
-
-}

models/Filter.go

@@ -0,0 +1,550 @@
+// Copyright (c) 2015 qianqiusoft.com
+// Licensed to You under the GNU Affero GPL v3
+// See the LICENSE file at git.qianqiusoft.com/qianqiusoft/light-vocation/LICENSE
+// http://www.gnu.org/licenses/why-affero-gpl.en.html
+
+package models
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+)
+
+const (
+	_RULE_DATA_TYPE_FIELD_NAME  = "field_name"
+	_RULE_DATA_TYPE_USER_VALUE  = "user_value"
+	_RULE_DATA_TYPE_FIELD_VALUE = "field_value"
+)
+
+type Filter struct {
+	GroupOp string         `json:"groupOp"`
+	Rules   []*FilterField `json:"rules"`
+	Groups  []*Filter      `json:"groups"`
+}
+
+type FilterField struct {
+	Field string `json:"field"`
+	Op    string `json:"op"`
+	Data  string `json:"data"`
+}
+
+/**
+ * @brief new filter by string
+ * @param filtersStr json data of filter
+ *
+ * @return point of Filter
+ * @return error
+ */
+func NewFilter(filtersStr string) (*Filter, error) {
+	filters := &Filter{}
+	err := json.Unmarshal([]byte(filtersStr), filters)
+	if err != nil {
+		return nil, err
+	}
+	return filters, nil
+}
+
+/**
+ * @brief parse the filter
+ *
+ * @return select querybuilder
+ * @return count select querybuilder
+ * @return error
+ */
+func (this *Filter) Parse(tableName string) (string, []interface{}, error) {
+
+	whereStatement := ""
+	groupWhereStatement := ""
+	datas := make([]interface{}, 0)
+
+	isAnd := true
+	if strings.ToLower(strings.TrimSpace(this.GroupOp)) == "or" {
+		isAnd = false
+	}
+
+	if len(this.Rules) > 0 {
+		whereStr, ruleDatas := this.ParseRule(tableName, this.Rules[0])
+		if whereStr != "" {
+			whereStatement = whereStr
+			for _, ruleData := range ruleDatas {
+				datas = append(datas, ruleData)
+			}
+		} else {
+			return whereStatement, datas, errors.New(fmt.Sprintf("the 0 rule is invalid"))
+		}
+		for i := 1; i < len(this.Rules); i++ {
+			whereStr, ruleDatas = this.ParseRule(tableName, this.Rules[i])
+			if whereStr != "" {
+				if isAnd {
+					whereStatement += " AND " + whereStr
+				} else {
+					whereStatement += " OR " + whereStr
+				}
+				for _, ruleData := range ruleDatas {
+					datas = append(datas, ruleData)
+				}
+			} else {
+				return whereStatement, datas, errors.New(fmt.Sprintf("the %d rule is invalid", i))
+			}
+		}
+	}
+
+	if len(this.Groups) > 0 {
+
+		whereStr, groupDatas, err := this.Groups[0].Parse(tableName)
+		if err != nil {
+			return whereStatement, datas, err
+		}
+		if whereStr != "" {
+			groupWhereStatement = whereStr
+			for _, groupData := range groupDatas {
+				datas = append(datas, groupData)
+			}
+		} else {
+			return whereStatement, datas, errors.New("the 0 group is invalid")
+		}
+		for i := 1; i < len(this.Groups); i++ {
+			whereStr, groupDatas, err := this.Groups[i].Parse(tableName)
+			if err != nil {
+				return whereStatement, datas, err
+			}
+			if whereStr != "" {
+				if isAnd {
+					groupWhereStatement += " AND " + whereStr
+				} else {
+					groupWhereStatement += " OR " + whereStr
+				}
+				for _, groupData := range groupDatas {
+					datas = append(datas, groupData)
+				}
+			} else {
+				return whereStatement, datas, errors.New(fmt.Sprintf("the %d group is invalid", i))
+			}
+		}
+		if groupWhereStatement != "" {
+			groupWhereStatement = "(" + groupWhereStatement + ")"
+		}
+	}
+	if whereStatement == "" {
+		whereStatement = groupWhereStatement
+	} else {
+		whereStatement = "(" + whereStatement + ")"
+		if groupWhereStatement != "" {
+			if isAnd {
+				whereStatement += " AND " + groupWhereStatement
+			} else {
+				whereStatement += " OR " + groupWhereStatement
+			}
+		}
+	}
+
+	return whereStatement, datas, nil
+}
+
+func (this *Filter) ParseRule(tableName string, field *FilterField) (string, []interface{}) {
+	switch ruleDataType(field.Field) {
+	case _RULE_DATA_TYPE_FIELD_NAME:
+		return ParsePureRule(tableName, field)
+	case _RULE_DATA_TYPE_FIELD_VALUE:
+		//		if strings.HasSuffix(field.Field, ".org") {
+		//			a, b, _ := parseFieldOrgRule(field, tableName, nil)
+		//			return a, b
+		//			return "", make([]interface{}, 0)
+		//		} else {
+		//			return "", make([]interface{}, 0)
+		//		}
+		return "", make([]interface{}, 0)
+	default:
+		return "", make([]interface{}, 0)
+	}
+}
+
+func ParsePureRule(tableName string, field *FilterField) (string, []interface{}) {
+	datas := make([]interface{}, 0)
+	if field == nil {
+		return "", datas
+	}
+	fData := FormatData(field.Op, field.Data)
+	switch fData.(type) {
+	case string:
+		{
+			if len(fData.(string)) >= 0 {
+				datas = append(datas, fData)
+			}
+		}
+	case []string:
+		{
+			fDataArr := fData.([]string)
+			for _, arr := range fDataArr {
+				if len(arr) > 0 {
+					datas = append(datas, arr)
+				}
+			}
+		}
+	}
+
+	whereStr := FormatOp(tableName, field.Op, field.Field, field.Data)
+
+	if len(whereStr) > 0 {
+		return whereStr, datas
+	} else {
+		return "", datas
+	}
+}
+
+func FormatOp(table, op, field, data string) string {
+	if strings.Contains(field, ".") {
+		// the field is "talbe.field"
+		switch strings.ToLower(op) {
+		case "eq":
+			{
+				return fmt.Sprintf(" %s = ? ", field)
+			}
+		case "ne":
+			{
+				return fmt.Sprintf(" %s <> ? ", field)
+			}
+		case "lt":
+			{
+				return fmt.Sprintf(" %s < ? ", field)
+			}
+		case "le":
+			{
+				return fmt.Sprintf(" %s <= ? ", field)
+			}
+		case "gt":
+			{
+				return fmt.Sprintf(" %s > ? ", field)
+			}
+		case "ge":
+			{
+				return fmt.Sprintf(" %s >= ? ", field)
+			}
+		case "bw":
+			{
+				return fmt.Sprintf(" %s LIKE ? ", field)
+			}
+		case "bn":
+			{
+				return fmt.Sprintf(" %s NOT LIKE ? ", field)
+			}
+		case "ew":
+			{
+				return fmt.Sprintf(" %s LIKE ? ", field)
+			}
+		case "en":
+			{
+				return fmt.Sprintf(" %s NOT LIKE ? ", field)
+			}
+		case "cn":
+			{
+				return fmt.Sprintf(" %s LIKE ? ", field)
+			}
+		case "nc":
+			{
+				return fmt.Sprintf(" %s NOT LIKE ? ", field)
+			}
+		case "nu":
+			{
+				return fmt.Sprintf(" %s IS NULL ", field)
+			}
+		case "nn":
+			{
+				return fmt.Sprintf(" %s IS NOT NULL ", field)
+			}
+		case "date-cn":
+			{
+				return fmt.Sprintf(" %s >= ? and %s <= ? ", field, field)
+			}
+		case "in":
+			{
+				dataArr := strings.Split(data, ",")
+				params := ""
+				for _, arr := range dataArr {
+					if len(arr) > 0 {
+						params += "?,"
+					}
+				}
+				params = strings.TrimRight(params, ",")
+				if len(params) > 0 {
+					return fmt.Sprintf(" %s IN (%s)", field, params)
+				}
+			}
+		case "ni":
+			{
+				dataArr := strings.Split(data, ",")
+				params := ""
+				for _, arr := range dataArr {
+					if len(arr) > 0 {
+						params += "?,"
+					}
+				}
+				params = strings.TrimRight(params, ",")
+				if len(params) > 0 {
+					return fmt.Sprintf(" %s NOT IN (%s)", field, params)
+				}
+			}
+		}
+	} else {
+		if table == "" {
+			switch strings.ToLower(op) {
+			case "eq":
+				{
+					return fmt.Sprintf(" `%s` = ? ", field)
+				}
+			case "ne":
+				{
+					return fmt.Sprintf(" `%s` <> ? ", field)
+				}
+			case "lt":
+				{
+					return fmt.Sprintf(" `%s` < ? ", field)
+				}
+			case "le":
+				{
+					return fmt.Sprintf(" `%s` <= ? ", field)
+				}
+			case "gt":
+				{
+					return fmt.Sprintf(" `%s` > ? ", field)
+				}
+			case "ge":
+				{
+					return fmt.Sprintf(" `%s` >= ? ", field)
+				}
+			case "bw":
+				{
+					return fmt.Sprintf(" `%s` LIKE ? ", field)
+				}
+			case "bn":
+				{
+					return fmt.Sprintf(" `%s` NOT LIKE ? ", field)
+				}
+			case "ew":
+				{
+					return fmt.Sprintf(" `%s` LIKE ? ", field)
+				}
+			case "en":
+				{
+					return fmt.Sprintf(" `%s` NOT LIKE ? ", field)
+				}
+			case "cn":
+				{
+					return fmt.Sprintf(" `%s` LIKE ? ", field)
+				}
+			case "nc":
+				{
+					return fmt.Sprintf(" `%s` NOT LIKE ? ", field)
+				}
+			case "nu":
+				{
+					return fmt.Sprintf(" `%s` IS NULL ", field)
+				}
+			case "nn":
+				{
+					return fmt.Sprintf(" `%s` IS NOT NULL ", field)
+				}
+			case "date-cn":
+				{
+					return fmt.Sprintf(" %s >= ? and %s <= ? ", field, field)
+				}
+			case "in":
+				{
+					dataArr := strings.Split(data, ",")
+					params := ""
+					for _, arr := range dataArr {
+						if len(arr) > 0 {
+							params += "?,"
+						}
+					}
+					params = strings.TrimRight(params, ",")
+					if len(params) > 0 {
+						return fmt.Sprintf(" `%s` IN (%s)", field, params)
+					}
+				}
+			case "ni":
+				{
+					dataArr := strings.Split(data, ",")
+					params := ""
+					for _, arr := range dataArr {
+						if len(arr) > 0 {
+							params += "?,"
+						}
+					}
+					params = strings.TrimRight(params, ",")
+					if len(params) > 0 {
+						return fmt.Sprintf(" `%s` NOT IN (%s)", field, params)
+					}
+				}
+			}
+		} else {
+			switch strings.ToLower(op) {
+			case "eq":
+				{
+					return fmt.Sprintf(" %s.%s = ? ", table, field)
+				}
+			case "ne":
+				{
+					return fmt.Sprintf(" %s.%s <> ? ", table, field)
+				}
+			case "lt":
+				{
+					return fmt.Sprintf(" %s.%s < ? ", table, field)
+				}
+			case "le":
+				{
+					return fmt.Sprintf(" %s.%s <= ? ", table, field)
+				}
+			case "gt":
+				{
+					return fmt.Sprintf(" %s.%s > ? ", table, field)
+				}
+			case "ge":
+				{
+					return fmt.Sprintf(" %s.%s >= ? ", table, field)
+				}
+			case "bw":
+				{
+					return fmt.Sprintf(" %s.%s LIKE ? ", table, field)
+				}
+			case "bn":
+				{
+					return fmt.Sprintf(" %s.%s NOT LIKE ? ", table, field)
+				}
+			case "ew":
+				{
+					return fmt.Sprintf(" %s.%s LIKE ? ", table, field)
+				}
+			case "en":
+				{
+					return fmt.Sprintf(" %s.%s NOT LIKE ? ", table, field)
+				}
+			case "cn":
+				{
+					return fmt.Sprintf(" %s.%s LIKE ? ", table, field)
+				}
+			case "nc":
+				{
+					return fmt.Sprintf(" %s.%s NOT LIKE ? ", table, field)
+				}
+			case "nu":
+				{
+					return fmt.Sprintf(" %s.%s IS NULL ", table, field)
+				}
+			case "nn":
+				{
+					return fmt.Sprintf(" %s.%s IS NOT NULL ", table, field)
+				}
+			case "date-cn":
+				{
+					return fmt.Sprintf(" %s.%s >= ? and %s.%s <= ? ", table, field, table, field)
+				}
+			case "in":
+				{
+					dataArr := strings.Split(data, ",")
+					params := ""
+					for _, arr := range dataArr {
+						if len(arr) > 0 {
+							params += "?,"
+						}
+					}
+					params = strings.TrimRight(params, ",")
+					if len(params) > 0 {
+						return fmt.Sprintf(" %s.%s IN (%s)", table, field, params)
+					}
+				}
+			case "ni":
+				{
+					dataArr := strings.Split(data, ",")
+					params := ""
+					for _, arr := range dataArr {
+						if len(arr) > 0 {
+							params += "?,"
+						}
+					}
+					params = strings.TrimRight(params, ",")
+					if len(params) > 0 {
+						return fmt.Sprintf(" %s.%s NOT IN (%s)", table, field, params)
+					}
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func FormatData(op, data string) interface{} {
+	switch strings.ToLower(op) {
+	case "eq", "ne", "lt", "le", "gt", "ge":
+		{
+			return data
+		}
+	case "bw":
+		{
+			return fmt.Sprintf("%s%%", data)
+		}
+	case "bn":
+		{
+			return fmt.Sprintf("%s%%", data)
+		}
+	case "ew":
+		{
+			return fmt.Sprintf("%%%s", data)
+		}
+	case "en":
+		{
+			return fmt.Sprintf("%%%s", data)
+		}
+	case "cn":
+		{
+			return fmt.Sprintf("%%%s%%", data)
+		}
+	case "nc":
+		{
+			return fmt.Sprintf("%%%s%%", data)
+		}
+	case "in":
+		{
+			return strings.Split(data, ",")
+		}
+	case "ni":
+		{
+			return strings.Split(data, ",")
+		}
+	case "date-cn":
+		{
+			data = strings.TrimSpace(data)
+			if data == "" {
+				return []string{"", ""}
+			} else {
+				data = data[0:10]
+				return []string{data + " 00:00:00", data + " 23:59:59"}
+			}
+		}
+	}
+	return ""
+}
+
+func formatData(op, data string) interface{} {
+	return FormatData(op, data)
+}
+
+func formatOp(table, op, field, data string) string {
+	return FormatOp(table, op, field, data)
+}
+
+// where the value begin with $, return user_value
+// where the value begin with #, return field_value
+// where the value begin with letter, return value
+func ruleDataType(data string) string {
+	data = strings.TrimSpace(data)
+	if strings.HasPrefix(data, "$") {
+		return _RULE_DATA_TYPE_USER_VALUE
+	} else if strings.HasPrefix(data, "#") {
+		return _RULE_DATA_TYPE_FIELD_VALUE
+	} else {
+		return _RULE_DATA_TYPE_FIELD_NAME
+	}
+}

models/FilterField_gen.go

@@ -0,0 +1,12 @@
+package models
+
+//type FilterField struct {
+
+//	//过滤名称列表
+//	Field   string `json:"field"`
+//	//过滤值
+//	Data   string `json:"data"`
+//	//过类型
+//	Op   string `json:"op"`
+
+//}

models/Filter_gen.go

@@ -0,0 +1,11 @@
+package models
+
+//type Filter struct {
+
+//	//过滤操作(and、or)
+//	GroupOp string `json:"group_op"`
+//	//过滤规则
+//	Rules []FilterField `json:"rules"`
+//	//过滤名称列表
+//	Groups []Filter `json:"groups"`
+//}

models/GetPageInfo_gen.go

@@ -10,7 +10,11 @@ type GetPageInfo struct {
 	PageNum   int `json:"pageNum"`
 	//单页数
 	PageSize   int `json:"pageSize"`
+	//排序字段
+	Sidx   string `json:"sidx"`
+	//排序方式
+	Sord   string `json:"sord"`
 	//过滤条件
-	ColumnFilters   ColumnFilters `json:"columnFilters"`
+	Filter   Filter `json:"filter"`
 
 }

models/Join_gen.go

@@ -0,0 +1,16 @@
+
+package models
+import (
+
+)
+
+type Join struct {
+	
+	//连接方式
+	JoinOperator   string `json:"joinOperator"`
+	//连接表名
+	TabelName   string `json:"tabelName"`
+	//连接条件
+	Condition   string `json:"condition"`
+
+}

models/Local_date.go

@@ -0,0 +1,134 @@
+// Copyright (c) 2015 qianqiusoft.com
+// Licensed to You under the GNU Affero GPL v3
+// See the LICENSE file at git.qianqiusoft.com/qianqiusoft/light-vocation/LICENSE
+// http://www.gnu.org/licenses/why-affero-gpl.en.html
+
+package models
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/astaxie/beego/orm"
+)
+
+// datetime values like 2006-01-02 15:04:05
+type LocalDate time.Time
+
+const formatDate = "2006-01-02"
+const nilDateStr = "0001-01-01"
+
+func CurrentDate() LocalDate {
+	now := time.Now()
+	nowStr := now.Format(formatDateTime)
+
+	nowStr = strings.TrimSpace(nowStr)
+
+	if len(nowStr) > 10 {
+		nowStr = nowStr[0:10]
+	}
+	now, _ = timeParse(nowStr, formatDate) //time.ParseInLocation(formatDate, nowStr, time.Local)
+
+	return LocalDate(now)
+}
+
+func nilDate() LocalDate {
+	nilDate, _ := timeParse(nilDateStr, formatDate) //time.ParseInLocation(formatDate, nilDateStr, time.Local)
+	return LocalDate(nilDate)
+}
+
+func isNilDate(tval time.Time) bool {
+	return tval.Format(formatDate) == nilDateStr
+}
+
+// Value return the time.Time
+func (e LocalDate) IsNilDate() bool {
+	return isNilDate(e.Value())
+}
+
+// Value return the time.Time
+func (e LocalDate) Value() time.Time {
+	return time.Time(e)
+}
+
+// Set set the LocalDate's value
+func (e *LocalDate) Set(d time.Time) {
+	*e = LocalDate(d)
+}
+
+// String convert datatime to string
+func (e *LocalDate) String() string {
+	return e.Value().String()
+}
+
+// FieldType return enum type Date
+func (e *LocalDate) FieldType() int {
+	return orm.TypeDateField
+}
+
+// SetRaw convert the interface to time.Time. Allow string and time.Time
+func (e *LocalDate) SetRaw(value interface{}) error {
+	if value == nil {
+		*e = nilDate()
+		return nil
+	}
+	switch d := value.(type) {
+	case time.Time:
+		if isNilDate(d) {
+			*e = nilDate()
+		} else {
+			e.Set(d)
+		}
+	case string:
+		v, err := timeParse(d, formatDate)
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<LocalDate.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return Date value
+func (e *LocalDate) RawValue() interface{} {
+	return e.Value()
+}
+
+func (t *LocalDate) UnmarshalJSON(data []byte) (err error) {
+	if data[0] == '"' && data[len(data)-1] == '"' {
+		data = data[1 : len(data)-1]
+	}
+	dataStr := strings.TrimSpace(string(data))
+
+	if dataStr == "" {
+		*t = nilDate()
+		return nil
+	}
+
+	if len(dataStr) > 10 {
+		if dataStr == "0000-00-00 00:00:00" {
+			dataStr = nilDateStr
+		} else {
+			dataStr = dataStr[0:10]
+		}
+	}
+	now, err := timeParse(dataStr, formatDate) // time.ParseInLocation(formatDate, dataStr, time.Local)
+	*t = LocalDate(now)
+	return
+}
+
+func (t LocalDate) MarshalJSON() ([]byte, error) {
+	if isNilDate(t.Value()) {
+		return []byte{'"', '"'}, nil
+	}
+	b := make([]byte, 0, len(formatDate)+2)
+	b = append(b, '"')
+	b = append(b, []byte(time.Time(t).Format(formatDate))...)
+	b = append(b, '"')
+	return b, nil
+}
+
+var _ orm.Fielder = new(LocalDate)

models/Local_datetime.go

@@ -0,0 +1,161 @@
+// Copyright (c) 2015 qianqiusoft.com
+// Licensed to You under the GNU Affero GPL v3
+// See the LICENSE file at git.qianqiusoft.com/qianqiusoft/light-vocation/LICENSE
+// http://www.gnu.org/licenses/why-affero-gpl.en.html
+
+package models
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/astaxie/beego/orm"
+)
+
+// datetime values like 2006-01-02 15:04:05
+type LocalDateTime time.Time
+
+const formatDateTime = "2006-01-02 15:04:05"
+const nilDateTimeStr = "0001-01-01 00:00:00"
+
+func NowLocal() LocalDateTime {
+	return LocalDateTime(time.Now())
+}
+
+func nilDateTime() LocalDateTime {
+	nilDateTime, _ := timeParse(formatDateTime, nilDateTimeStr) //time.ParseInLocation(formatDate, nilDateStr, time.Local)
+	return LocalDateTime(nilDateTime)
+}
+
+func isNilDateTime(tval time.Time) bool {
+	return tval.Format(formatDateTime) == nilDateTimeStr
+}
+
+// Value return the datatime value
+func (e LocalDateTime) IsNilDateTime() bool {
+	return isNilDateTime(e.Value())
+}
+
+// Value return the datatime value
+func (e LocalDateTime) Value() time.Time {
+	return time.Time(e)
+}
+
+// Set set the time.Time to datatime
+func (e *LocalDateTime) Set(d time.Time) {
+	//fmt.Println("-------------------- LocalDateTime Set ")
+	*e = LocalDateTime(d)
+}
+
+// String return the time's String
+func (e *LocalDateTime) String() string {
+	return e.Value().String()
+}
+
+// FieldType return the enum TypeDateTimeField
+func (e *LocalDateTime) FieldType() int {
+	return orm.TypeDateTimeField
+}
+
+// SetRaw convert the string or time.Time to DateTimeField
+func (e *LocalDateTime) SetRaw(value interface{}) error {
+	//fmt.Println("-------------------- LocalDateTime SetRaw ")
+	if value == nil {
+		*e = nilDateTime()
+		return nil
+	}
+	switch d := value.(type) {
+	case time.Time:
+		//fmt.Println("--------------------time.time val is ", d.Format(formatDateTime))
+		if isNilDateTime(d) {
+			*e = nilDateTime()
+		} else {
+			e.Set(d)
+		}
+	case string:
+		//fmt.Println("--------------------string val is ", d)
+		v, err := timeParse(d, formatDateTime)
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<DateTimeField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return the datatime value
+func (e *LocalDateTime) RawValue() interface{} {
+	//fmt.Println("-------------------- LocalDateTime RawValue ")
+	//fmt.Println("--------------------RawValue val is ", e.Value().Format(formatDateTime))
+	return e.Value()
+}
+
+// parse time to string with location
+func timeParse(dateString, format string) (time.Time, error) {
+	// this
+	tp, err := time.ParseInLocation(format, dateString, orm.DefaultTimeLoc)
+	return tp, err
+}
+
+func (t *LocalDateTime) UnmarshalJSON(data []byte) (err error) {
+	if data[0] == '"' && data[len(data)-1] == '"' {
+		data = data[1 : len(data)-1]
+	}
+	dataStr := strings.TrimSpace(string(data))
+	if dataStr == "" {
+		*t = nilDateTime()
+		return nil
+	}
+
+	var now time.Time
+	if strings.Index(dataStr, "T") > 0 {
+		// there is t with the date string
+		now, err = time.ParseInLocation(time.RFC3339Nano, dataStr, time.Local)
+		if err != nil {
+			now, err = time.ParseInLocation(time.RFC3339, dataStr, time.Local)
+		}
+		// if t date, we format and parse withe utc againt
+		// special special........
+		if err == nil {
+			now, err = timeParse(now.Format(formatDateTime), formatDateTime)
+		}
+	} else {
+		if len(dataStr) == 19 {
+			if dataStr == "0000-00-00 00:00:00" {
+				dataStr = nilDateTimeStr
+			}
+		} else if len(dataStr) == 10 {
+			// only date
+			dataStr += " 00:00:00"
+		} else if len(dataStr) == 13 {
+			// only hour
+			dataStr += ":00:00"
+		} else if len(dataStr) == 16 {
+			// only hour
+			dataStr += ":00"
+		}
+		//fmt.Println("---------------before json unmarshal ", dataStr)
+		now, err = timeParse(dataStr, formatDateTime) //time.ParseInLocation(formatDateTime, dataStr, time.Local)
+
+		//fmt.Println("---------------after json unmarshal ", now.Format(formatDateTime))
+	}
+
+	*t = LocalDateTime(now)
+	return
+}
+
+func (t LocalDateTime) MarshalJSON() ([]byte, error) {
+	if isNilDateTime(t.Value()) {
+		return []byte{'"', '"'}, nil
+	}
+	b := make([]byte, 0, len(formatDateTime)+2)
+	b = append(b, '"')
+	b = append(b, []byte(time.Time(t).Format(formatDateTime))...)
+	b = append(b, '"')
+	return b, nil
+}
+
+var _ orm.Fielder = new(LocalDateTime)

models/PageResult_gen.go

@@ -0,0 +1,13 @@
+package models
+
+type PageResult struct {
+
+	//页码
+	PageNum int `json:"pageNum"`
+	//单页数
+	PageSize int `json:"pageSize"`
+	//总页数
+	TotalSize int `json:"totalSize"`
+	//内容
+	Content interface{} `json:"content"`
+}

models/StorageResult_gen.go

@@ -1,21 +1,24 @@
+
 package models
+import (
 
-import ()
+)
 
 type StorageResult struct {
-
+	
 	//result
-	Result int32 `json:"result"`
+	Result   int32 `json:"result"`
 	//ip
-	Ip string `json:"ip"`
+	Ip   string `json:"ip"`
 	//port
-	Port int32 `json:"port"`
+	Port   int32 `json:"port"`
 	//id
-	Id int32 `json:"id"`
+	Id   string `json:"id"`
 	//hash
-	Hash string `json:"hash"`
+	Hash   string `json:"hash"`
 	//len
-	Len int32 `json:"len"`
+	Len   int32 `json:"len"`
 	//error
-	Error string `json:"error"`
+	Error   string `json:"error"`
+
 }

models/SysUserPageInfo_gen.go

@@ -1,18 +0,0 @@
-
-package models
-import (
-
-)
-
-type SysUserPageInfo struct {
-	
-	//页码
-	PageNum   int `json:"pageNum"`
-	//单页数
-	PageSize   int `json:"pageSize"`
-	//总页数
-	TotalSize   int `json:"totalSize"`
-	//内容
-	Content   []UserInfo `json:"content"`
-
-}