feature(用户): 添加钉钉字段

opms_admin/app/dao/internal/sys_user.go

@@ -38,6 +38,9 @@ type sysUserColumns struct {
 	Password    string // 密码
 	LoginIp     string // 最后登录IP
 	LoginDate   string // 最后登录时间
+	WechatId    string // 微信open_id
+	DingtalkId  string // 钉钉union_id
+	DingtalkUid string // 钉钉用户ID
 	Remark      string // 备注
 	CreatedBy   string // 创建者
 	CreatedName string // 创建人
@@ -69,6 +72,9 @@ var (
 			Password:    "password",
 			LoginIp:     "login_ip",
 			LoginDate:   "login_date",
+			WechatId:    "wechat_id",
+			DingtalkId:  "dingtalk_id",
+			DingtalkUid: "dingtalk_uid",
 			Remark:      "remark",
 			CreatedBy:   "created_by",
 			CreatedName: "created_name",
@@ -102,6 +108,9 @@ func NewSysUserDao(tenant string) SysUserDao {
 			Password:    "password",
 			LoginIp:     "login_ip",
 			LoginDate:   "login_date",
+			WechatId:    "wechat_id",
+			DingtalkId:  "dingtalk_id",
+			DingtalkUid: "dingtalk_uid",
 			Remark:      "remark",
 			CreatedBy:   "created_by",
 			CreatedName: "created_name",
@@ -125,6 +134,12 @@ func (d *SysUserDao) Ctx(ctx context.Context) *SysUserDao {
 	return &SysUserDao{M: d.M.Ctx(ctx)}
 }
 
+// GetCtx returns the context for current Model.
+// It returns "context.Background() i"s there's no context previously set.
+func (d *SysUserDao) GetCtx() context.Context {
+	return d.M.GetCtx()
+}
+
 // As sets an alias name for current table.
 func (d *SysUserDao) As(as string) *SysUserDao {
 	return &SysUserDao{M: d.M.As(as)}
@@ -151,6 +166,12 @@ func (d *SysUserDao) Args(args ...interface{}) *SysUserDao {
 	return &SysUserDao{M: d.M.Args(args...)}
 }
 
+// Handler calls each of "handlers" on current Model and returns a new Model.
+// ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
+func (d *SysUserDao) Handler(handlers ...gdb.ModelHandler) *SysUserDao {
+	return &SysUserDao{M: d.M.Handler(handlers...)}
+}
+
 // LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
 // The parameter <table> can be joined table and its joined condition,
 // and also with its alias name, like:
@@ -190,7 +211,33 @@ func (d *SysUserDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *SysUserDao
 	return &SysUserDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...)}
 }
 
-// Option sets the extra operation option for the model.
+// FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
+func (d *SysUserDao) FieldCount(column string, as ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.FieldCount(column, as...)}
+}
+
+// FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
+func (d *SysUserDao) FieldSum(column string, as ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.FieldSum(column, as...)}
+}
+
+// FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
+func (d *SysUserDao) FieldMin(column string, as ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.FieldMin(column, as...)}
+}
+
+// FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
+func (d *SysUserDao) FieldMax(column string, as ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.FieldMax(column, as...)}
+}
+
+// FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
+func (d *SysUserDao) FieldAvg(column string, as ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.FieldAvg(column, as...)}
+}
+
+// Option adds extra operation option for the model.
+// Deprecated, use separate operations instead.
 func (d *SysUserDao) Option(option int) *SysUserDao {
 	return &SysUserDao{M: d.M.Option(option)}
 }
@@ -201,7 +248,39 @@ func (d *SysUserDao) OmitEmpty() *SysUserDao {
 	return &SysUserDao{M: d.M.OmitEmpty()}
 }
 
+// OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
+// the Where/Having parameters for "empty" values.
+func (d *SysUserDao) OmitEmptyWhere() *SysUserDao {
+	return &SysUserDao{M: d.M.OmitEmptyWhere()}
+}
+
+// OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
+// the Data parameters for "empty" values.
+func (d *SysUserDao) OmitEmptyData() *SysUserDao {
+	return &SysUserDao{M: d.M.OmitEmptyData()}
+}
+
+// OmitNil sets optionOmitNil option for the model, which automatically filers
+// the data and where parameters for "nil" values.
+func (d *SysUserDao) OmitNil() *SysUserDao {
+	return &SysUserDao{M: d.M.OmitNil()}
+}
+
+// OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
+// the Where/Having parameters for "nil" values.
+func (d *SysUserDao) OmitNilWhere() *SysUserDao {
+	return &SysUserDao{M: d.M.OmitNilWhere()}
+}
+
+// OmitNilData sets optionOmitNilData option for the model, which automatically filers
+// the Data parameters for "nil" values.
+func (d *SysUserDao) OmitNilData() *SysUserDao {
+	return &SysUserDao{M: d.M.OmitNilData()}
+}
+
 // Filter marks filtering the fields which does not exist in the fields of the operated table.
+// Note that this function supports only single table operations.
+// Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
 func (d *SysUserDao) Filter() *SysUserDao {
 	return &SysUserDao{M: d.M.Filter()}
 }
@@ -230,18 +309,174 @@ func (d *SysUserDao) WherePri(where interface{}, args ...interface{}) *SysUserDa
 	return &SysUserDao{M: d.M.WherePri(where, args...)}
 }
 
+// Having sets the having statement for the model.
+// The parameters of this function usage are as the same as function Where.
+// See Where.
+func (d *SysUserDao) Having(having interface{}, args ...interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.Having(having, args...)}
+}
+
+// Wheref builds condition string using fmt.Sprintf and arguments.
+// Note that if the number of "args" is more than the place holder in "format",
+// the extra "args" will be used as the where condition arguments of the Model.
+func (d *SysUserDao) Wheref(format string, args ...interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.Wheref(format, args...)}
+}
+
+// WhereLT builds "column < value" statement.
+func (d *SysUserDao) WhereLT(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereLT(column, value)}
+}
+
+// WhereLTE builds "column <= value" statement.
+func (d *SysUserDao) WhereLTE(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereLTE(column, value)}
+}
+
+// WhereGT builds "column > value" statement.
+func (d *SysUserDao) WhereGT(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereGT(column, value)}
+}
+
+// WhereGTE builds "column >= value" statement.
+func (d *SysUserDao) WhereGTE(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereGTE(column, value)}
+}
+
+// WhereBetween builds "column BETWEEN min AND max" statement.
+func (d *SysUserDao) WhereBetween(column string, min, max interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereBetween(column, min, max)}
+}
+
+// WhereLike builds "column LIKE like" statement.
+func (d *SysUserDao) WhereLike(column string, like interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereLike(column, like)}
+}
+
+// WhereIn builds "column IN (in)" statement.
+func (d *SysUserDao) WhereIn(column string, in interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereIn(column, in)}
+}
+
+// WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
+func (d *SysUserDao) WhereNull(columns ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereNull(columns...)}
+}
+
+// WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
+func (d *SysUserDao) WhereNotBetween(column string, min, max interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereNotBetween(column, min, max)}
+}
+
+// WhereNotLike builds "column NOT LIKE like" statement.
+func (d *SysUserDao) WhereNotLike(column string, like interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereNotLike(column, like)}
+}
+
+// WhereNot builds "column != value" statement.
+func (d *SysUserDao) WhereNot(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereNot(column, value)}
+}
+
+// WhereNotIn builds "column NOT IN (in)" statement.
+func (d *SysUserDao) WhereNotIn(column string, in interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereNotIn(column, in)}
+}
+
+// WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
+func (d *SysUserDao) WhereNotNull(columns ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereNotNull(columns...)}
+}
+
+// WhereOr adds "OR" condition to the where statement.
+func (d *SysUserDao) WhereOr(where interface{}, args ...interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOr(where, args...)}
+}
+
+// WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
+func (d *SysUserDao) WhereOrf(format string, args ...interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrf(format, args...)}
+}
+
+// WhereOrLT builds "column < value" statement in "OR" conditions..
+func (d *SysUserDao) WhereOrLT(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrLT(column, value)}
+}
+
+// WhereOrLTE builds "column <= value" statement in "OR" conditions..
+func (d *SysUserDao) WhereOrLTE(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrLTE(column, value)}
+}
+
+// WhereOrGT builds "column > value" statement in "OR" conditions..
+func (d *SysUserDao) WhereOrGT(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrGT(column, value)}
+}
+
+// WhereOrGTE builds "column >= value" statement in "OR" conditions..
+func (d *SysUserDao) WhereOrGTE(column string, value interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrGTE(column, value)}
+}
+
+// WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
+func (d *SysUserDao) WhereOrBetween(column string, min, max interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrBetween(column, min, max)}
+}
+
+// WhereOrLike builds "column LIKE like" statement in "OR" conditions.
+func (d *SysUserDao) WhereOrLike(column string, like interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrLike(column, like)}
+}
+
+// WhereOrIn builds "column IN (in)" statement in "OR" conditions.
+func (d *SysUserDao) WhereOrIn(column string, in interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrIn(column, in)}
+}
+
+// WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
+func (d *SysUserDao) WhereOrNull(columns ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrNull(columns...)}
+}
+
+// WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
+func (d *SysUserDao) WhereOrNotBetween(column string, min, max interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrNotBetween(column, min, max)}
+}
+
+// WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
+func (d *SysUserDao) WhereOrNotLike(column string, like interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrNotLike(column, like)}
+}
+
+// WhereOrNotIn builds "column NOT IN (in)" statement.
+func (d *SysUserDao) WhereOrNotIn(column string, in interface{}) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrNotIn(column, in)}
+}
+
+// WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
+func (d *SysUserDao) WhereOrNotNull(columns ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.WhereOrNotNull(columns...)}
+}
+
+// Group sets the "GROUP BY" statement for the model.
+func (d *SysUserDao) Group(groupBy ...string) *SysUserDao {
+	return &SysUserDao{M: d.M.Group(groupBy...)}
+}
+
 // And adds "AND" condition to the where statement.
+// Deprecated, use Where instead.
 func (d *SysUserDao) And(where interface{}, args ...interface{}) *SysUserDao {
 	return &SysUserDao{M: d.M.And(where, args...)}
 }
 
 // Or adds "OR" condition to the where statement.
+// Deprecated, use WhereOr instead.
 func (d *SysUserDao) Or(where interface{}, args ...interface{}) *SysUserDao {
 	return &SysUserDao{M: d.M.Or(where, args...)}
 }
 
-// Group sets the "GROUP BY" statement for the model.
-func (d *SysUserDao) Group(groupBy string) *SysUserDao {
+// GroupBy sets the "GROUP BY" statement for the model.
+func (d *SysUserDao) GroupBy(groupBy string) *SysUserDao {
 	return &SysUserDao{M: d.M.Group(groupBy)}
 }
 
@@ -250,6 +485,28 @@ func (d *SysUserDao) Order(orderBy ...string) *SysUserDao {
 	return &SysUserDao{M: d.M.Order(orderBy...)}
 }
 
+// OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
+func (d *SysUserDao) OrderAsc(column string) *SysUserDao {
+	return &SysUserDao{M: d.M.OrderAsc(column)}
+}
+
+// OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
+func (d *SysUserDao) OrderDesc(column string) *SysUserDao {
+	return &SysUserDao{M: d.M.OrderDesc(column)}
+}
+
+// OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
+func (d *SysUserDao) OrderRandom() *SysUserDao {
+	return &SysUserDao{M: d.M.OrderRandom()}
+}
+
+// OrderBy is alias of Model.Order.
+// See Model.Order.
+// Deprecated, use Order instead.
+func (d *SysUserDao) OrderBy(orderBy string) *SysUserDao {
+	return &SysUserDao{M: d.M.Order(orderBy)}
+}
+
 // Limit sets the "LIMIT" statement for the model.
 // The parameter <limit> can be either one or two number, if passed two number is passed,
 // it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
@@ -264,6 +521,11 @@ func (d *SysUserDao) Offset(offset int) *SysUserDao {
 	return &SysUserDao{M: d.M.Offset(offset)}
 }
 
+// Distinct forces the query to only return distinct results.
+func (d *SysUserDao) Distinct() *SysUserDao {
+	return &SysUserDao{M: d.M.Distinct()}
+}
+
 // Page sets the paging number for the model.
 // The parameter <page> is started from 1 for paging.
 // Note that, it differs that the Limit function start from 0 for "LIMIT" statement.

opms_admin/app/model/internal/sys_user.go

@@ -14,7 +14,6 @@ type SysUser struct {
 	DeptId      int         `orm:"dept_id"      json:"deptId"`      // 部门ID
 	UserName    string      `orm:"user_name"    json:"userName"`    // 用户账号
 	NickName    string      `orm:"nick_name"    json:"nickName"`    // 用户昵称
-	DingtalkId  string      `orm:"dingtalk_id"  json:"dingtalkId"`  // 关联钉钉用户唯一码（钉钉对外开放的Id）
 	UserType    string      `orm:"user_type"    json:"userType"`    // 用户类型（00系统用户）
 	Email       string      `orm:"email"        json:"email"`       // 用户邮箱
 	Phone       string      `orm:"phone"        json:"phone"`       // 手机号码
@@ -23,6 +22,9 @@ type SysUser struct {
 	Password    string      `orm:"password"     json:"password"`    // 密码
 	LoginIp     string      `orm:"login_ip"     json:"loginIp"`     // 最后登录IP
 	LoginDate   *gtime.Time `orm:"login_date"   json:"loginDate"`   // 最后登录时间
+	WechatId    string      `orm:"wechat_id"    json:"wechatId"`    // 微信open_id
+	DingtalkId  string      `orm:"dingtalk_id"  json:"dingtalkId"`  // 钉钉union_id
+	DingtalkUid string      `orm:"dingtalk_uid" json:"dingtalkUid"` // 钉钉用户ID
 	Remark      string      `orm:"remark"       json:"remark"`      // 备注
 	CreatedBy   int         `orm:"created_by"   json:"createdBy"`   // 创建者
 	CreatedName string      `orm:"created_name" json:"createdName"` // 创建人

opms_libary/.idea/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml
-# Editor-based HTTP Client requests
-/httpRequests/

opms_libary/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/opms_libary.iml" filepath="$PROJECT_DIR$/.idea/opms_libary.iml" />
-    </modules>
-  </component>
-</project>

opms_libary/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
-  </component>
-</project>

opms_libary/myerrors/error.go

@@ -6,6 +6,7 @@ import (
 	"github.com/gogf/gf/errors/gcode"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"github.com/smallnest/rpcx/codec"
 	"github.com/smallnest/rpcx/protocol"
 	"github.com/smallnest/rpcx/share"
@@ -110,7 +111,7 @@ func (p HandleErrorPlugin) PreWriteResponse(ctx context.Context, req *protocol.M
 
 	if err == nil {
 		// todo 正常数据处理
-		if resData["code"] == 0 {
+		if gconv.Int(resData["code"]) == 0 {
 			resData["code"] = 200
 		}
 		if resData["msg"] == "" {

opms_libary/request/request.go

@@ -2,6 +2,7 @@ package request
 
 import (
 	"context"
+	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
 	"github.com/gogf/gf/util/gconv"
 )
@@ -29,15 +30,18 @@ func (p *PageReq) GetPage() (int, int) {
 
 // UserInfo 登录用户信息
 type UserInfo struct {
-	Id         int      `json:"id"`
-	Uuid       string   `json:"uuid"`
-	UserName   string   `json:"userName"`
-	NickName   string   `json:"nickName"`
-	DingtalkId string   `json:"dingtalk_id"`
-	DeptId     int      `json:"deptId"` // 所属部门
-	Roles      []string `json:"roles"`  // 所属角色
-	Posts      []string `json:"posts"`  // 所属岗位
-	Groups     []string `json:"groups"` // 所属用户组
+	Id          int      `json:"id"`
+	Uuid        string   `json:"uuid"`
+	UserName    string   `json:"userName"`
+	NickName    string   `json:"nickName"`
+	WechatId    string   `json:"wechatId"`
+	DingtalkId  string   `json:"dingtalkId"`
+	DingtalkUid string   `json:"dingtalkUid"`
+	DeptId      int      `json:"deptId"`    // 所属部门
+	Roles       []string `json:"roles"`     // 所属角色
+	Posts       []string `json:"posts"`     // 所属岗位
+	Groups      []string `json:"groups"`    // 所属用户组
+	DataScope   g.Map    `json:"dataScope"` // 数据权限
 }
 
 // 设置当前登录用户信息