sugarBecomer
946 lines
33 KiB
Go
946 lines
33 KiB
Go
// ENT数据库文件，请勿编辑。
|
|
|
|
package sysuser
|
|
|
|
import (
|
|
"likedream-goframe/internal/ent/predicate"
|
|
"likedream-goframe/internal/framework/ent2"
|
|
|
|
"entgo.io/ent/dialect/sql"
|
|
"entgo.io/ent/dialect/sql/sqlgraph"
|
|
"github.com/shopspring/decimal"
|
|
)
|
|
|
|
// ID filters vertices based on their ID field.
|
|
func ID(id int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldID, id))
|
|
}
|
|
|
|
// IDEQ applies the EQ predicate on the ID field.
|
|
func IDEQ(id int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldID, id))
|
|
}
|
|
|
|
// IDNEQ applies the NEQ predicate on the ID field.
|
|
func IDNEQ(id int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldID, id))
|
|
}
|
|
|
|
// IDIn applies the In predicate on the ID field.
|
|
func IDIn(ids ...int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldID, ids...))
|
|
}
|
|
|
|
// IDNotIn applies the NotIn predicate on the ID field.
|
|
func IDNotIn(ids ...int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldID, ids...))
|
|
}
|
|
|
|
// IDGT applies the GT predicate on the ID field.
|
|
func IDGT(id int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldID, id))
|
|
}
|
|
|
|
// IDGTE applies the GTE predicate on the ID field.
|
|
func IDGTE(id int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldID, id))
|
|
}
|
|
|
|
// IDLT applies the LT predicate on the ID field.
|
|
func IDLT(id int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldID, id))
|
|
}
|
|
|
|
// IDLTE applies the LTE predicate on the ID field.
|
|
func IDLTE(id int64) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldID, id))
|
|
}
|
|
|
|
// CreateTime applies equality check predicate on the "create_time" field. It's identical to CreateTimeEQ.
|
|
func CreateTime(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldCreateTime, v))
|
|
}
|
|
|
|
// UpdateTime applies equality check predicate on the "update_time" field. It's identical to UpdateTimeEQ.
|
|
func UpdateTime(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldUpdateTime, v))
|
|
}
|
|
|
|
// Username applies equality check predicate on the "username" field. It's identical to UsernameEQ.
|
|
func Username(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldUsername, v))
|
|
}
|
|
|
|
// Password applies equality check predicate on the "password" field. It's identical to PasswordEQ.
|
|
func Password(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldPassword, v))
|
|
}
|
|
|
|
// Email applies equality check predicate on the "email" field. It's identical to EmailEQ.
|
|
func Email(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldEmail, v))
|
|
}
|
|
|
|
// InviteCode applies equality check predicate on the "invite_code" field. It's identical to InviteCodeEQ.
|
|
func InviteCode(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldInviteCode, v))
|
|
}
|
|
|
|
// Balance applies equality check predicate on the "balance" field. It's identical to BalanceEQ.
|
|
func Balance(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldBalance, v))
|
|
}
|
|
|
|
// Block applies equality check predicate on the "block" field. It's identical to BlockEQ.
|
|
func Block(v bool) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldBlock, v))
|
|
}
|
|
|
|
// Verify applies equality check predicate on the "verify" field. It's identical to VerifyEQ.
|
|
func Verify(v bool) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldVerify, v))
|
|
}
|
|
|
|
// InviteCashback applies equality check predicate on the "invite_cashback" field. It's identical to InviteCashbackEQ.
|
|
func InviteCashback(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldInviteCashback, v))
|
|
}
|
|
|
|
// CreateTimeEQ applies the EQ predicate on the "create_time" field.
|
|
func CreateTimeEQ(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldCreateTime, v))
|
|
}
|
|
|
|
// CreateTimeNEQ applies the NEQ predicate on the "create_time" field.
|
|
func CreateTimeNEQ(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldCreateTime, v))
|
|
}
|
|
|
|
// CreateTimeIn applies the In predicate on the "create_time" field.
|
|
func CreateTimeIn(vs ...*ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldCreateTime, vs...))
|
|
}
|
|
|
|
// CreateTimeNotIn applies the NotIn predicate on the "create_time" field.
|
|
func CreateTimeNotIn(vs ...*ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldCreateTime, vs...))
|
|
}
|
|
|
|
// CreateTimeGT applies the GT predicate on the "create_time" field.
|
|
func CreateTimeGT(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldCreateTime, v))
|
|
}
|
|
|
|
// CreateTimeGTE applies the GTE predicate on the "create_time" field.
|
|
func CreateTimeGTE(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldCreateTime, v))
|
|
}
|
|
|
|
// CreateTimeLT applies the LT predicate on the "create_time" field.
|
|
func CreateTimeLT(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldCreateTime, v))
|
|
}
|
|
|
|
// CreateTimeLTE applies the LTE predicate on the "create_time" field.
|
|
func CreateTimeLTE(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldCreateTime, v))
|
|
}
|
|
|
|
// CreateTimeContains applies the Contains predicate on the "create_time" field.
|
|
func CreateTimeContains(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldContains(FieldCreateTime, vc))
|
|
}
|
|
|
|
// CreateTimeHasPrefix applies the HasPrefix predicate on the "create_time" field.
|
|
func CreateTimeHasPrefix(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldHasPrefix(FieldCreateTime, vc))
|
|
}
|
|
|
|
// CreateTimeHasSuffix applies the HasSuffix predicate on the "create_time" field.
|
|
func CreateTimeHasSuffix(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldHasSuffix(FieldCreateTime, vc))
|
|
}
|
|
|
|
// CreateTimeEqualFold applies the EqualFold predicate on the "create_time" field.
|
|
func CreateTimeEqualFold(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldEqualFold(FieldCreateTime, vc))
|
|
}
|
|
|
|
// CreateTimeContainsFold applies the ContainsFold predicate on the "create_time" field.
|
|
func CreateTimeContainsFold(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldContainsFold(FieldCreateTime, vc))
|
|
}
|
|
|
|
// UpdateTimeEQ applies the EQ predicate on the "update_time" field.
|
|
func UpdateTimeEQ(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldUpdateTime, v))
|
|
}
|
|
|
|
// UpdateTimeNEQ applies the NEQ predicate on the "update_time" field.
|
|
func UpdateTimeNEQ(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldUpdateTime, v))
|
|
}
|
|
|
|
// UpdateTimeIn applies the In predicate on the "update_time" field.
|
|
func UpdateTimeIn(vs ...*ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldUpdateTime, vs...))
|
|
}
|
|
|
|
// UpdateTimeNotIn applies the NotIn predicate on the "update_time" field.
|
|
func UpdateTimeNotIn(vs ...*ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldUpdateTime, vs...))
|
|
}
|
|
|
|
// UpdateTimeGT applies the GT predicate on the "update_time" field.
|
|
func UpdateTimeGT(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldUpdateTime, v))
|
|
}
|
|
|
|
// UpdateTimeGTE applies the GTE predicate on the "update_time" field.
|
|
func UpdateTimeGTE(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldUpdateTime, v))
|
|
}
|
|
|
|
// UpdateTimeLT applies the LT predicate on the "update_time" field.
|
|
func UpdateTimeLT(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldUpdateTime, v))
|
|
}
|
|
|
|
// UpdateTimeLTE applies the LTE predicate on the "update_time" field.
|
|
func UpdateTimeLTE(v *ent2.CustomTime) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldUpdateTime, v))
|
|
}
|
|
|
|
// UpdateTimeContains applies the Contains predicate on the "update_time" field.
|
|
func UpdateTimeContains(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldContains(FieldUpdateTime, vc))
|
|
}
|
|
|
|
// UpdateTimeHasPrefix applies the HasPrefix predicate on the "update_time" field.
|
|
func UpdateTimeHasPrefix(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldHasPrefix(FieldUpdateTime, vc))
|
|
}
|
|
|
|
// UpdateTimeHasSuffix applies the HasSuffix predicate on the "update_time" field.
|
|
func UpdateTimeHasSuffix(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldHasSuffix(FieldUpdateTime, vc))
|
|
}
|
|
|
|
// UpdateTimeEqualFold applies the EqualFold predicate on the "update_time" field.
|
|
func UpdateTimeEqualFold(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldEqualFold(FieldUpdateTime, vc))
|
|
}
|
|
|
|
// UpdateTimeContainsFold applies the ContainsFold predicate on the "update_time" field.
|
|
func UpdateTimeContainsFold(v *ent2.CustomTime) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldContainsFold(FieldUpdateTime, vc))
|
|
}
|
|
|
|
// UsernameEQ applies the EQ predicate on the "username" field.
|
|
func UsernameEQ(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameNEQ applies the NEQ predicate on the "username" field.
|
|
func UsernameNEQ(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameIn applies the In predicate on the "username" field.
|
|
func UsernameIn(vs ...string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldUsername, vs...))
|
|
}
|
|
|
|
// UsernameNotIn applies the NotIn predicate on the "username" field.
|
|
func UsernameNotIn(vs ...string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldUsername, vs...))
|
|
}
|
|
|
|
// UsernameGT applies the GT predicate on the "username" field.
|
|
func UsernameGT(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameGTE applies the GTE predicate on the "username" field.
|
|
func UsernameGTE(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameLT applies the LT predicate on the "username" field.
|
|
func UsernameLT(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameLTE applies the LTE predicate on the "username" field.
|
|
func UsernameLTE(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameContains applies the Contains predicate on the "username" field.
|
|
func UsernameContains(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldContains(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameHasPrefix applies the HasPrefix predicate on the "username" field.
|
|
func UsernameHasPrefix(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldHasPrefix(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameHasSuffix applies the HasSuffix predicate on the "username" field.
|
|
func UsernameHasSuffix(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldHasSuffix(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameEqualFold applies the EqualFold predicate on the "username" field.
|
|
func UsernameEqualFold(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEqualFold(FieldUsername, v))
|
|
}
|
|
|
|
// UsernameContainsFold applies the ContainsFold predicate on the "username" field.
|
|
func UsernameContainsFold(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldContainsFold(FieldUsername, v))
|
|
}
|
|
|
|
// PasswordEQ applies the EQ predicate on the "password" field.
|
|
func PasswordEQ(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordNEQ applies the NEQ predicate on the "password" field.
|
|
func PasswordNEQ(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordIn applies the In predicate on the "password" field.
|
|
func PasswordIn(vs ...string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldPassword, vs...))
|
|
}
|
|
|
|
// PasswordNotIn applies the NotIn predicate on the "password" field.
|
|
func PasswordNotIn(vs ...string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldPassword, vs...))
|
|
}
|
|
|
|
// PasswordGT applies the GT predicate on the "password" field.
|
|
func PasswordGT(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordGTE applies the GTE predicate on the "password" field.
|
|
func PasswordGTE(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordLT applies the LT predicate on the "password" field.
|
|
func PasswordLT(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordLTE applies the LTE predicate on the "password" field.
|
|
func PasswordLTE(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordContains applies the Contains predicate on the "password" field.
|
|
func PasswordContains(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldContains(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordHasPrefix applies the HasPrefix predicate on the "password" field.
|
|
func PasswordHasPrefix(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldHasPrefix(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordHasSuffix applies the HasSuffix predicate on the "password" field.
|
|
func PasswordHasSuffix(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldHasSuffix(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordEqualFold applies the EqualFold predicate on the "password" field.
|
|
func PasswordEqualFold(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEqualFold(FieldPassword, v))
|
|
}
|
|
|
|
// PasswordContainsFold applies the ContainsFold predicate on the "password" field.
|
|
func PasswordContainsFold(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldContainsFold(FieldPassword, v))
|
|
}
|
|
|
|
// EmailEQ applies the EQ predicate on the "email" field.
|
|
func EmailEQ(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldEmail, v))
|
|
}
|
|
|
|
// EmailNEQ applies the NEQ predicate on the "email" field.
|
|
func EmailNEQ(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldEmail, v))
|
|
}
|
|
|
|
// EmailIn applies the In predicate on the "email" field.
|
|
func EmailIn(vs ...string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldEmail, vs...))
|
|
}
|
|
|
|
// EmailNotIn applies the NotIn predicate on the "email" field.
|
|
func EmailNotIn(vs ...string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldEmail, vs...))
|
|
}
|
|
|
|
// EmailGT applies the GT predicate on the "email" field.
|
|
func EmailGT(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldEmail, v))
|
|
}
|
|
|
|
// EmailGTE applies the GTE predicate on the "email" field.
|
|
func EmailGTE(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldEmail, v))
|
|
}
|
|
|
|
// EmailLT applies the LT predicate on the "email" field.
|
|
func EmailLT(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldEmail, v))
|
|
}
|
|
|
|
// EmailLTE applies the LTE predicate on the "email" field.
|
|
func EmailLTE(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldEmail, v))
|
|
}
|
|
|
|
// EmailContains applies the Contains predicate on the "email" field.
|
|
func EmailContains(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldContains(FieldEmail, v))
|
|
}
|
|
|
|
// EmailHasPrefix applies the HasPrefix predicate on the "email" field.
|
|
func EmailHasPrefix(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldHasPrefix(FieldEmail, v))
|
|
}
|
|
|
|
// EmailHasSuffix applies the HasSuffix predicate on the "email" field.
|
|
func EmailHasSuffix(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldHasSuffix(FieldEmail, v))
|
|
}
|
|
|
|
// EmailEqualFold applies the EqualFold predicate on the "email" field.
|
|
func EmailEqualFold(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEqualFold(FieldEmail, v))
|
|
}
|
|
|
|
// EmailContainsFold applies the ContainsFold predicate on the "email" field.
|
|
func EmailContainsFold(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldContainsFold(FieldEmail, v))
|
|
}
|
|
|
|
// InviteCodeEQ applies the EQ predicate on the "invite_code" field.
|
|
func InviteCodeEQ(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeNEQ applies the NEQ predicate on the "invite_code" field.
|
|
func InviteCodeNEQ(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeIn applies the In predicate on the "invite_code" field.
|
|
func InviteCodeIn(vs ...string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldInviteCode, vs...))
|
|
}
|
|
|
|
// InviteCodeNotIn applies the NotIn predicate on the "invite_code" field.
|
|
func InviteCodeNotIn(vs ...string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldInviteCode, vs...))
|
|
}
|
|
|
|
// InviteCodeGT applies the GT predicate on the "invite_code" field.
|
|
func InviteCodeGT(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeGTE applies the GTE predicate on the "invite_code" field.
|
|
func InviteCodeGTE(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeLT applies the LT predicate on the "invite_code" field.
|
|
func InviteCodeLT(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeLTE applies the LTE predicate on the "invite_code" field.
|
|
func InviteCodeLTE(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeContains applies the Contains predicate on the "invite_code" field.
|
|
func InviteCodeContains(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldContains(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeHasPrefix applies the HasPrefix predicate on the "invite_code" field.
|
|
func InviteCodeHasPrefix(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldHasPrefix(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeHasSuffix applies the HasSuffix predicate on the "invite_code" field.
|
|
func InviteCodeHasSuffix(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldHasSuffix(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeIsNil applies the IsNil predicate on the "invite_code" field.
|
|
func InviteCodeIsNil() predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIsNull(FieldInviteCode))
|
|
}
|
|
|
|
// InviteCodeNotNil applies the NotNil predicate on the "invite_code" field.
|
|
func InviteCodeNotNil() predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotNull(FieldInviteCode))
|
|
}
|
|
|
|
// InviteCodeEqualFold applies the EqualFold predicate on the "invite_code" field.
|
|
func InviteCodeEqualFold(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEqualFold(FieldInviteCode, v))
|
|
}
|
|
|
|
// InviteCodeContainsFold applies the ContainsFold predicate on the "invite_code" field.
|
|
func InviteCodeContainsFold(v string) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldContainsFold(FieldInviteCode, v))
|
|
}
|
|
|
|
// BalanceEQ applies the EQ predicate on the "balance" field.
|
|
func BalanceEQ(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldBalance, v))
|
|
}
|
|
|
|
// BalanceNEQ applies the NEQ predicate on the "balance" field.
|
|
func BalanceNEQ(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldBalance, v))
|
|
}
|
|
|
|
// BalanceIn applies the In predicate on the "balance" field.
|
|
func BalanceIn(vs ...decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldBalance, vs...))
|
|
}
|
|
|
|
// BalanceNotIn applies the NotIn predicate on the "balance" field.
|
|
func BalanceNotIn(vs ...decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldBalance, vs...))
|
|
}
|
|
|
|
// BalanceGT applies the GT predicate on the "balance" field.
|
|
func BalanceGT(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldBalance, v))
|
|
}
|
|
|
|
// BalanceGTE applies the GTE predicate on the "balance" field.
|
|
func BalanceGTE(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldBalance, v))
|
|
}
|
|
|
|
// BalanceLT applies the LT predicate on the "balance" field.
|
|
func BalanceLT(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldBalance, v))
|
|
}
|
|
|
|
// BalanceLTE applies the LTE predicate on the "balance" field.
|
|
func BalanceLTE(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldBalance, v))
|
|
}
|
|
|
|
// BalanceContains applies the Contains predicate on the "balance" field.
|
|
func BalanceContains(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldContains(FieldBalance, vc))
|
|
}
|
|
|
|
// BalanceHasPrefix applies the HasPrefix predicate on the "balance" field.
|
|
func BalanceHasPrefix(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldHasPrefix(FieldBalance, vc))
|
|
}
|
|
|
|
// BalanceHasSuffix applies the HasSuffix predicate on the "balance" field.
|
|
func BalanceHasSuffix(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldHasSuffix(FieldBalance, vc))
|
|
}
|
|
|
|
// BalanceEqualFold applies the EqualFold predicate on the "balance" field.
|
|
func BalanceEqualFold(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldEqualFold(FieldBalance, vc))
|
|
}
|
|
|
|
// BalanceContainsFold applies the ContainsFold predicate on the "balance" field.
|
|
func BalanceContainsFold(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldContainsFold(FieldBalance, vc))
|
|
}
|
|
|
|
// BlockEQ applies the EQ predicate on the "block" field.
|
|
func BlockEQ(v bool) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldBlock, v))
|
|
}
|
|
|
|
// BlockNEQ applies the NEQ predicate on the "block" field.
|
|
func BlockNEQ(v bool) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldBlock, v))
|
|
}
|
|
|
|
// VerifyEQ applies the EQ predicate on the "verify" field.
|
|
func VerifyEQ(v bool) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldVerify, v))
|
|
}
|
|
|
|
// VerifyNEQ applies the NEQ predicate on the "verify" field.
|
|
func VerifyNEQ(v bool) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldVerify, v))
|
|
}
|
|
|
|
// InviteCashbackEQ applies the EQ predicate on the "invite_cashback" field.
|
|
func InviteCashbackEQ(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldEQ(FieldInviteCashback, v))
|
|
}
|
|
|
|
// InviteCashbackNEQ applies the NEQ predicate on the "invite_cashback" field.
|
|
func InviteCashbackNEQ(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNEQ(FieldInviteCashback, v))
|
|
}
|
|
|
|
// InviteCashbackIn applies the In predicate on the "invite_cashback" field.
|
|
func InviteCashbackIn(vs ...decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldIn(FieldInviteCashback, vs...))
|
|
}
|
|
|
|
// InviteCashbackNotIn applies the NotIn predicate on the "invite_cashback" field.
|
|
func InviteCashbackNotIn(vs ...decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldNotIn(FieldInviteCashback, vs...))
|
|
}
|
|
|
|
// InviteCashbackGT applies the GT predicate on the "invite_cashback" field.
|
|
func InviteCashbackGT(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGT(FieldInviteCashback, v))
|
|
}
|
|
|
|
// InviteCashbackGTE applies the GTE predicate on the "invite_cashback" field.
|
|
func InviteCashbackGTE(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldGTE(FieldInviteCashback, v))
|
|
}
|
|
|
|
// InviteCashbackLT applies the LT predicate on the "invite_cashback" field.
|
|
func InviteCashbackLT(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLT(FieldInviteCashback, v))
|
|
}
|
|
|
|
// InviteCashbackLTE applies the LTE predicate on the "invite_cashback" field.
|
|
func InviteCashbackLTE(v decimal.Decimal) predicate.SysUser {
|
|
return predicate.SysUser(sql.FieldLTE(FieldInviteCashback, v))
|
|
}
|
|
|
|
// InviteCashbackContains applies the Contains predicate on the "invite_cashback" field.
|
|
func InviteCashbackContains(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldContains(FieldInviteCashback, vc))
|
|
}
|
|
|
|
// InviteCashbackHasPrefix applies the HasPrefix predicate on the "invite_cashback" field.
|
|
func InviteCashbackHasPrefix(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldHasPrefix(FieldInviteCashback, vc))
|
|
}
|
|
|
|
// InviteCashbackHasSuffix applies the HasSuffix predicate on the "invite_cashback" field.
|
|
func InviteCashbackHasSuffix(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldHasSuffix(FieldInviteCashback, vc))
|
|
}
|
|
|
|
// InviteCashbackEqualFold applies the EqualFold predicate on the "invite_cashback" field.
|
|
func InviteCashbackEqualFold(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldEqualFold(FieldInviteCashback, vc))
|
|
}
|
|
|
|
// InviteCashbackContainsFold applies the ContainsFold predicate on the "invite_cashback" field.
|
|
func InviteCashbackContainsFold(v decimal.Decimal) predicate.SysUser {
|
|
vc := v.String()
|
|
return predicate.SysUser(sql.FieldContainsFold(FieldInviteCashback, vc))
|
|
}
|
|
|
|
// HasParent applies the HasEdge predicate on the "parent" edge.
|
|
func HasParent() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasParentWith applies the HasEdge predicate on the "parent" edge with a given conditions (other predicates).
|
|
func HasParentWith(preds ...predicate.SysUser) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newParentStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasChildren applies the HasEdge predicate on the "children" edge.
|
|
func HasChildren() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasChildrenWith applies the HasEdge predicate on the "children" edge with a given conditions (other predicates).
|
|
func HasChildrenWith(preds ...predicate.SysUser) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newChildrenStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasRoles applies the HasEdge predicate on the "roles" edge.
|
|
func HasRoles() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.M2M, false, RolesTable, RolesPrimaryKey...),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasRolesWith applies the HasEdge predicate on the "roles" edge with a given conditions (other predicates).
|
|
func HasRolesWith(preds ...predicate.SysRole) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newRolesStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasAgent applies the HasEdge predicate on the "agent" edge.
|
|
func HasAgent() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2O, false, AgentTable, AgentColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasAgentWith applies the HasEdge predicate on the "agent" edge with a given conditions (other predicates).
|
|
func HasAgentWith(preds ...predicate.SysAgent) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newAgentStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasImages applies the HasEdge predicate on the "images" edge.
|
|
func HasImages() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, ImagesTable, ImagesColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasImagesWith applies the HasEdge predicate on the "images" edge with a given conditions (other predicates).
|
|
func HasImagesWith(preds ...predicate.CpImage) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newImagesStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasCpuser applies the HasEdge predicate on the "cpuser" edge.
|
|
func HasCpuser() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, CpuserTable, CpuserColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasCpuserWith applies the HasEdge predicate on the "cpuser" edge with a given conditions (other predicates).
|
|
func HasCpuserWith(preds ...predicate.CpUser) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newCpuserStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasCpTask applies the HasEdge predicate on the "cp_task" edge.
|
|
func HasCpTask() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, CpTaskTable, CpTaskColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasCpTaskWith applies the HasEdge predicate on the "cp_task" edge with a given conditions (other predicates).
|
|
func HasCpTaskWith(preds ...predicate.CpTask) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newCpTaskStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasCpTaskLogs applies the HasEdge predicate on the "cp_task_logs" edge.
|
|
func HasCpTaskLogs() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, CpTaskLogsTable, CpTaskLogsColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasCpTaskLogsWith applies the HasEdge predicate on the "cp_task_logs" edge with a given conditions (other predicates).
|
|
func HasCpTaskLogsWith(preds ...predicate.CpTaskLog) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newCpTaskLogsStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasCreatedCards applies the HasEdge predicate on the "created_cards" edge.
|
|
func HasCreatedCards() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, CreatedCardsTable, CreatedCardsColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasCreatedCardsWith applies the HasEdge predicate on the "created_cards" edge with a given conditions (other predicates).
|
|
func HasCreatedCardsWith(preds ...predicate.SysCard) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newCreatedCardsStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasUsedCards applies the HasEdge predicate on the "used_cards" edge.
|
|
func HasUsedCards() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, UsedCardsTable, UsedCardsColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasUsedCardsWith applies the HasEdge predicate on the "used_cards" edge with a given conditions (other predicates).
|
|
func HasUsedCardsWith(preds ...predicate.SysCard) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newUsedCardsStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// HasCashbackCards applies the HasEdge predicate on the "cashback_cards" edge.
|
|
func HasCashbackCards() predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(Table, FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, CashbackCardsTable, CashbackCardsColumn),
|
|
)
|
|
sqlgraph.HasNeighbors(s, step)
|
|
})
|
|
}
|
|
|
|
// HasCashbackCardsWith applies the HasEdge predicate on the "cashback_cards" edge with a given conditions (other predicates).
|
|
func HasCashbackCardsWith(preds ...predicate.SysCard) predicate.SysUser {
|
|
return predicate.SysUser(func(s *sql.Selector) {
|
|
step := newCashbackCardsStep()
|
|
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
|
|
for _, p := range preds {
|
|
p(s)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// And groups predicates with the AND operator between them.
|
|
func And(predicates ...predicate.SysUser) predicate.SysUser {
|
|
return predicate.SysUser(sql.AndPredicates(predicates...))
|
|
}
|
|
|
|
// Or groups predicates with the OR operator between them.
|
|
func Or(predicates ...predicate.SysUser) predicate.SysUser {
|
|
return predicate.SysUser(sql.OrPredicates(predicates...))
|
|
}
|
|
|
|
// Not applies the not operator on the given predicate.
|
|
func Not(p predicate.SysUser) predicate.SysUser {
|
|
return predicate.SysUser(sql.NotPredicates(p))
|
|
}
|