go/rano
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feature: verify tokens

Browse Source
This commit is contained in:
Ankit Patial
2024-11-17 22:28:29 +05:30
parent 26a00c9f7c
commit 9d40c9d7ec
57 changed files with 4188 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
db/ent/client.go
View File

@@ -21,6 +21,7 @@ import (
"gitserver.in/patialtech/rano/db/ent/todo"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/usersession"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// Client is the client that holds all ent builders.
@@ -40,6 +41,8 @@ type Client struct {
User *UserClient
// UserSession is the client for interacting with the UserSession builders.
UserSession *UserSessionClient
// VerifyToken is the client for interacting with the VerifyToken builders.
VerifyToken *VerifyTokenClient
}
// NewClient creates a new client configured with the given options.
@@ -57,6 +60,7 @@ func (c *Client) init() {
c.Todo = NewTodoClient(c.config)
c.User = NewUserClient(c.config)
c.UserSession = NewUserSessionClient(c.config)
c.VerifyToken = NewVerifyTokenClient(c.config)
}
type (
@@ -155,6 +159,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
Todo: NewTodoClient(cfg),
User: NewUserClient(cfg),
UserSession: NewUserSessionClient(cfg),
VerifyToken: NewVerifyTokenClient(cfg),
}, nil
}
@@ -180,6 +185,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
Todo: NewTodoClient(cfg),
User: NewUserClient(cfg),
UserSession: NewUserSessionClient(cfg),
VerifyToken: NewVerifyTokenClient(cfg),
}, nil
}
@@ -209,7 +215,7 @@ func (c *Client) Close() error {
// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
func (c *Client) Use(hooks ...Hook) {
for _, n := range []interface{ Use(...Hook) }{
c.AccessControl, c.Audit, c.Role, c.Todo, c.User, c.UserSession,
c.AccessControl, c.Audit, c.Role, c.Todo, c.User, c.UserSession, c.VerifyToken,
} {
n.Use(hooks...)
}
@@ -219,7 +225,7 @@ func (c *Client) Use(hooks ...Hook) {
// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
func (c *Client) Intercept(interceptors ...Interceptor) {
for _, n := range []interface{ Intercept(...Interceptor) }{
c.AccessControl, c.Audit, c.Role, c.Todo, c.User, c.UserSession,
c.AccessControl, c.Audit, c.Role, c.Todo, c.User, c.UserSession, c.VerifyToken,
} {
n.Intercept(interceptors...)
}
@@ -240,6 +246,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
return c.User.mutate(ctx, m)
case *UserSessionMutation:
return c.UserSession.mutate(ctx, m)
case *VerifyTokenMutation:
return c.VerifyToken.mutate(ctx, m)
default:
return nil, fmt.Errorf("ent: unknown mutation type %T", m)
}
@@ -933,6 +941,22 @@ func (c *UserClient) QueryAuditLogs(u *User) *AuditQuery {
return query
}
// QueryVerifyTokens queries the verify_tokens edge of a User.
func (c *UserClient) QueryVerifyTokens(u *User) *VerifyTokenQuery {
query := (&VerifyTokenClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := u.ID
step := sqlgraph.NewStep(
sqlgraph.From(user.Table, user.FieldID, id),
sqlgraph.To(verifytoken.Table, verifytoken.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.VerifyTokensTable, user.VerifyTokensColumn),
)
fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *UserClient) Hooks() []Hook {
return c.hooks.User
@@ -1107,12 +1131,162 @@ func (c *UserSessionClient) mutate(ctx context.Context, m *UserSessionMutation)
}
}
// VerifyTokenClient is a client for the VerifyToken schema.
type VerifyTokenClient struct {
config
}
// NewVerifyTokenClient returns a client for the VerifyToken from the given config.
func NewVerifyTokenClient(c config) *VerifyTokenClient {
return &VerifyTokenClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `verifytoken.Hooks(f(g(h())))`.
func (c *VerifyTokenClient) Use(hooks ...Hook) {
c.hooks.VerifyToken = append(c.hooks.VerifyToken, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `verifytoken.Intercept(f(g(h())))`.
func (c *VerifyTokenClient) Intercept(interceptors ...Interceptor) {
c.inters.VerifyToken = append(c.inters.VerifyToken, interceptors...)
}
// Create returns a builder for creating a VerifyToken entity.
func (c *VerifyTokenClient) Create() *VerifyTokenCreate {
mutation := newVerifyTokenMutation(c.config, OpCreate)
return &VerifyTokenCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of VerifyToken entities.
func (c *VerifyTokenClient) CreateBulk(builders ...*VerifyTokenCreate) *VerifyTokenCreateBulk {
return &VerifyTokenCreateBulk{config: c.config, builders: builders}
}
// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *VerifyTokenClient) MapCreateBulk(slice any, setFunc func(*VerifyTokenCreate, int)) *VerifyTokenCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &VerifyTokenCreateBulk{err: fmt.Errorf("calling to VerifyTokenClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*VerifyTokenCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &VerifyTokenCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for VerifyToken.
func (c *VerifyTokenClient) Update() *VerifyTokenUpdate {
mutation := newVerifyTokenMutation(c.config, OpUpdate)
return &VerifyTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *VerifyTokenClient) UpdateOne(vt *VerifyToken) *VerifyTokenUpdateOne {
mutation := newVerifyTokenMutation(c.config, OpUpdateOne, withVerifyToken(vt))
return &VerifyTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *VerifyTokenClient) UpdateOneID(id int64) *VerifyTokenUpdateOne {
mutation := newVerifyTokenMutation(c.config, OpUpdateOne, withVerifyTokenID(id))
return &VerifyTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for VerifyToken.
func (c *VerifyTokenClient) Delete() *VerifyTokenDelete {
mutation := newVerifyTokenMutation(c.config, OpDelete)
return &VerifyTokenDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *VerifyTokenClient) DeleteOne(vt *VerifyToken) *VerifyTokenDeleteOne {
return c.DeleteOneID(vt.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *VerifyTokenClient) DeleteOneID(id int64) *VerifyTokenDeleteOne {
builder := c.Delete().Where(verifytoken.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &VerifyTokenDeleteOne{builder}
}
// Query returns a query builder for VerifyToken.
func (c *VerifyTokenClient) Query() *VerifyTokenQuery {
return &VerifyTokenQuery{
config: c.config,
ctx: &QueryContext{Type: TypeVerifyToken},
inters: c.Interceptors(),
}
}
// Get returns a VerifyToken entity by its id.
func (c *VerifyTokenClient) Get(ctx context.Context, id int64) (*VerifyToken, error) {
return c.Query().Where(verifytoken.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *VerifyTokenClient) GetX(ctx context.Context, id int64) *VerifyToken {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUser queries the user edge of a VerifyToken.
func (c *VerifyTokenClient) QueryUser(vt *VerifyToken) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := vt.ID
step := sqlgraph.NewStep(
sqlgraph.From(verifytoken.Table, verifytoken.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, verifytoken.UserTable, verifytoken.UserColumn),
)
fromV = sqlgraph.Neighbors(vt.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *VerifyTokenClient) Hooks() []Hook {
return c.hooks.VerifyToken
}
// Interceptors returns the client interceptors.
func (c *VerifyTokenClient) Interceptors() []Interceptor {
return c.inters.VerifyToken
}
func (c *VerifyTokenClient) mutate(ctx context.Context, m *VerifyTokenMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&VerifyTokenCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&VerifyTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&VerifyTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&VerifyTokenDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown VerifyToken mutation op: %q", m.Op())
}
}
// hooks and interceptors per client, for fast access.
type (
hooks struct {
AccessControl, Audit, Role, Todo, User, UserSession []ent.Hook
AccessControl, Audit, Role, Todo, User, UserSession, VerifyToken []ent.Hook
}
inters struct {
AccessControl, Audit, Role, Todo, User, UserSession []ent.Interceptor
AccessControl, Audit, Role, Todo, User, UserSession,
VerifyToken []ent.Interceptor
}
)

2
db/ent/ent.go
View File

@@ -18,6 +18,7 @@ import (
"gitserver.in/patialtech/rano/db/ent/todo"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/usersession"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// ent aliases to avoid import conflicts in user's code.
@@ -84,6 +85,7 @@ func checkColumn(table, column string) error {
todo.Table: todo.ValidColumn,
user.Table: user.ValidColumn,
usersession.Table: usersession.ValidColumn,
verifytoken.Table: verifytoken.ValidColumn,
})
})
return columnCheck(table, column)

12
db/ent/hook/hook.go
View File

@@ -81,6 +81,18 @@ func (f UserSessionFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value,
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserSessionMutation", m)
}
// The VerifyTokenFunc type is an adapter to allow the use of ordinary
// function as VerifyToken mutator.
type VerifyTokenFunc func(context.Context, *ent.VerifyTokenMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f VerifyTokenFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.VerifyTokenMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.VerifyTokenMutation", m)
}
// Condition is a hook condition function.
type Condition func(context.Context, ent.Mutation) bool

29
db/ent/migrate/schema.go
View File

@@ -101,8 +101,8 @@ var (
{Name: "email_verified", Type: field.TypeBool, Default: false},
{Name: "phone", Type: field.TypeString, Nullable: true, Size: 20},
{Name: "phone_verified", Type: field.TypeBool, Default: false},
{Name: "pwd_salt", Type: field.TypeString, Size: 250},
{Name: "pwd_hash", Type: field.TypeString, Size: 250},
{Name: "pwd_salt", Type: field.TypeString, Size: 100},
{Name: "pwd_hash", Type: field.TypeString, Size: 100},
{Name: "login_failed_count", Type: field.TypeUint8, Nullable: true, Default: 0},
{Name: "login_attempt_on", Type: field.TypeTime, Nullable: true},
{Name: "login_locked_until", Type: field.TypeTime, Nullable: true},
@@ -186,6 +186,29 @@ var (
},
},
}
// VerifyTokensColumns holds the columns for the "verify_tokens" table.
VerifyTokensColumns = []*schema.Column{
{Name: "id", Type: field.TypeInt64, Increment: true},
{Name: "created_at", Type: field.TypeTime},
{Name: "expires_at", Type: field.TypeTime},
{Name: "token", Type: field.TypeString, Unique: true, Size: 50},
{Name: "purpose", Type: field.TypeString, Nullable: true, Size: 50},
{Name: "user_id", Type: field.TypeInt64, Nullable: true},
}
// VerifyTokensTable holds the schema information for the "verify_tokens" table.
VerifyTokensTable = &schema.Table{
Name: "verify_tokens",
Columns: VerifyTokensColumns,
PrimaryKey: []*schema.Column{VerifyTokensColumns[0]},
ForeignKeys: []*schema.ForeignKey{
{
Symbol: "verify_tokens_users_verify_tokens",
Columns: []*schema.Column{VerifyTokensColumns[5]},
RefColumns: []*schema.Column{UsersColumns[0]},
OnDelete: schema.SetNull,
},
},
}
// Tables holds all the tables in the schema.
Tables = []*schema.Table{
AccessControlsTable,
@@ -194,10 +217,12 @@ var (
TodosTable,
UsersTable,
UserSessionsTable,
VerifyTokensTable,
}
)
func init() {
AuditsTable.ForeignKeys[0].RefTable = UsersTable
UserSessionsTable.ForeignKeys[0].RefTable = UsersTable
VerifyTokensTable.ForeignKeys[0].RefTable = UsersTable
}

674
db/ent/mutation.go
View File

@@ -17,6 +17,7 @@ import (
"gitserver.in/patialtech/rano/db/ent/role"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/usersession"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
const (
@@ -34,6 +35,7 @@ const (
TypeTodo = "Todo"
TypeUser = "User"
TypeUserSession = "UserSession"
TypeVerifyToken = "VerifyToken"
)
// AccessControlMutation represents an operation that mutates the AccessControl nodes in the graph.
@@ -2225,6 +2227,9 @@ type UserMutation struct {
audit_logs map[int64]struct{}
removedaudit_logs map[int64]struct{}
clearedaudit_logs bool
verify_tokens map[int64]struct{}
removedverify_tokens map[int64]struct{}
clearedverify_tokens bool
done bool
oldValue func(context.Context) (*User, error)
predicates []predicate.User
@@ -3055,6 +3060,60 @@ func (m *UserMutation) ResetAuditLogs() {
m.removedaudit_logs = nil
}
// AddVerifyTokenIDs adds the "verify_tokens" edge to the VerifyToken entity by ids.
func (m *UserMutation) AddVerifyTokenIDs(ids ...int64) {
if m.verify_tokens == nil {
m.verify_tokens = make(map[int64]struct{})
}
for i := range ids {
m.verify_tokens[ids[i]] = struct{}{}
}
}
// ClearVerifyTokens clears the "verify_tokens" edge to the VerifyToken entity.
func (m *UserMutation) ClearVerifyTokens() {
m.clearedverify_tokens = true
}
// VerifyTokensCleared reports if the "verify_tokens" edge to the VerifyToken entity was cleared.
func (m *UserMutation) VerifyTokensCleared() bool {
return m.clearedverify_tokens
}
// RemoveVerifyTokenIDs removes the "verify_tokens" edge to the VerifyToken entity by IDs.
func (m *UserMutation) RemoveVerifyTokenIDs(ids ...int64) {
if m.removedverify_tokens == nil {
m.removedverify_tokens = make(map[int64]struct{})
}
for i := range ids {
delete(m.verify_tokens, ids[i])
m.removedverify_tokens[ids[i]] = struct{}{}
}
}
// RemovedVerifyTokens returns the removed IDs of the "verify_tokens" edge to the VerifyToken entity.
func (m *UserMutation) RemovedVerifyTokensIDs() (ids []int64) {
for id := range m.removedverify_tokens {
ids = append(ids, id)
}
return
}
// VerifyTokensIDs returns the "verify_tokens" edge IDs in the mutation.
func (m *UserMutation) VerifyTokensIDs() (ids []int64) {
for id := range m.verify_tokens {
ids = append(ids, id)
}
return
}
// ResetVerifyTokens resets all changes to the "verify_tokens" edge.
func (m *UserMutation) ResetVerifyTokens() {
m.verify_tokens = nil
m.clearedverify_tokens = false
m.removedverify_tokens = nil
}
// Where appends a list predicates to the UserMutation builder.
func (m *UserMutation) Where(ps ...predicate.User) {
m.predicates = append(m.predicates, ps...)
@@ -3468,13 +3527,16 @@ func (m *UserMutation) ResetField(name string) error {
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *UserMutation) AddedEdges() []string {
edges := make([]string, 0, 2)
edges := make([]string, 0, 3)
if m.sessions != nil {
edges = append(edges, user.EdgeSessions)
}
if m.audit_logs != nil {
edges = append(edges, user.EdgeAuditLogs)
}
if m.verify_tokens != nil {
edges = append(edges, user.EdgeVerifyTokens)
}
return edges
}
@@ -3494,19 +3556,28 @@ func (m *UserMutation) AddedIDs(name string) []ent.Value {
ids = append(ids, id)
}
return ids
case user.EdgeVerifyTokens:
ids := make([]ent.Value, 0, len(m.verify_tokens))
for id := range m.verify_tokens {
ids = append(ids, id)
}
return ids
}
return nil
}
// RemovedEdges returns all edge names that were removed in this mutation.
func (m *UserMutation) RemovedEdges() []string {
edges := make([]string, 0, 2)
edges := make([]string, 0, 3)
if m.removedsessions != nil {
edges = append(edges, user.EdgeSessions)
}
if m.removedaudit_logs != nil {
edges = append(edges, user.EdgeAuditLogs)
}
if m.removedverify_tokens != nil {
edges = append(edges, user.EdgeVerifyTokens)
}
return edges
}
@@ -3526,19 +3597,28 @@ func (m *UserMutation) RemovedIDs(name string) []ent.Value {
ids = append(ids, id)
}
return ids
case user.EdgeVerifyTokens:
ids := make([]ent.Value, 0, len(m.removedverify_tokens))
for id := range m.removedverify_tokens {
ids = append(ids, id)
}
return ids
}
return nil
}
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *UserMutation) ClearedEdges() []string {
edges := make([]string, 0, 2)
edges := make([]string, 0, 3)
if m.clearedsessions {
edges = append(edges, user.EdgeSessions)
}
if m.clearedaudit_logs {
edges = append(edges, user.EdgeAuditLogs)
}
if m.clearedverify_tokens {
edges = append(edges, user.EdgeVerifyTokens)
}
return edges
}
@@ -3550,6 +3630,8 @@ func (m *UserMutation) EdgeCleared(name string) bool {
return m.clearedsessions
case user.EdgeAuditLogs:
return m.clearedaudit_logs
case user.EdgeVerifyTokens:
return m.clearedverify_tokens
}
return false
}
@@ -3572,6 +3654,9 @@ func (m *UserMutation) ResetEdge(name string) error {
case user.EdgeAuditLogs:
m.ResetAuditLogs()
return nil
case user.EdgeVerifyTokens:
m.ResetVerifyTokens()
return nil
}
return fmt.Errorf("unknown User edge %s", name)
}
@@ -4212,3 +4297,586 @@ func (m *UserSessionMutation) ResetEdge(name string) error {
}
return fmt.Errorf("unknown UserSession edge %s", name)
}
// VerifyTokenMutation represents an operation that mutates the VerifyToken nodes in the graph.
type VerifyTokenMutation struct {
config
op Op
typ string
id *int64
created_at *time.Time
expires_at *time.Time
token *string
purpose *string
clearedFields map[string]struct{}
user *int64
cleareduser bool
done bool
oldValue func(context.Context) (*VerifyToken, error)
predicates []predicate.VerifyToken
}
var _ ent.Mutation = (*VerifyTokenMutation)(nil)
// verifytokenOption allows management of the mutation configuration using functional options.
type verifytokenOption func(*VerifyTokenMutation)
// newVerifyTokenMutation creates new mutation for the VerifyToken entity.
func newVerifyTokenMutation(c config, op Op, opts ...verifytokenOption) *VerifyTokenMutation {
m := &VerifyTokenMutation{
config: c,
op: op,
typ: TypeVerifyToken,
clearedFields: make(map[string]struct{}),
}
for _, opt := range opts {
opt(m)
}
return m
}
// withVerifyTokenID sets the ID field of the mutation.
func withVerifyTokenID(id int64) verifytokenOption {
return func(m *VerifyTokenMutation) {
var (
err error
once sync.Once
value *VerifyToken
)
m.oldValue = func(ctx context.Context) (*VerifyToken, error) {
once.Do(func() {
if m.done {
err = errors.New("querying old values post mutation is not allowed")
} else {
value, err = m.Client().VerifyToken.Get(ctx, id)
}
})
return value, err
}
m.id = &id
}
}
// withVerifyToken sets the old VerifyToken of the mutation.
func withVerifyToken(node *VerifyToken) verifytokenOption {
return func(m *VerifyTokenMutation) {
m.oldValue = func(context.Context) (*VerifyToken, error) {
return node, nil
}
m.id = &node.ID
}
}
// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m VerifyTokenMutation) Client() *Client {
client := &Client{config: m.config}
client.init()
return client
}
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m VerifyTokenMutation) Tx() (*Tx, error) {
if _, ok := m.driver.(*txDriver); !ok {
return nil, errors.New("ent: mutation is not running in a transaction")
}
tx := &Tx{config: m.config}
tx.init()
return tx, nil
}
// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of VerifyToken entities.
func (m *VerifyTokenMutation) SetID(id int64) {
m.id = &id
}
// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *VerifyTokenMutation) ID() (id int64, exists bool) {
if m.id == nil {
return
}
return *m.id, true
}
// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *VerifyTokenMutation) IDs(ctx context.Context) ([]int64, error) {
switch {
case m.op.Is(OpUpdateOne | OpDeleteOne):
id, exists := m.ID()
if exists {
return []int64{id}, nil
}
fallthrough
case m.op.Is(OpUpdate | OpDelete):
return m.Client().VerifyToken.Query().Where(m.predicates...).IDs(ctx)
default:
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
}
}
// SetCreatedAt sets the "created_at" field.
func (m *VerifyTokenMutation) SetCreatedAt(t time.Time) {
m.created_at = &t
}
// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *VerifyTokenMutation) CreatedAt() (r time.Time, exists bool) {
v := m.created_at
if v == nil {
return
}
return *v, true
}
// OldCreatedAt returns the old "created_at" field's value of the VerifyToken entity.
// If the VerifyToken object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *VerifyTokenMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
}
return oldValue.CreatedAt, nil
}
// ResetCreatedAt resets all changes to the "created_at" field.
func (m *VerifyTokenMutation) ResetCreatedAt() {
m.created_at = nil
}
// SetExpiresAt sets the "expires_at" field.
func (m *VerifyTokenMutation) SetExpiresAt(t time.Time) {
m.expires_at = &t
}
// ExpiresAt returns the value of the "expires_at" field in the mutation.
func (m *VerifyTokenMutation) ExpiresAt() (r time.Time, exists bool) {
v := m.expires_at
if v == nil {
return
}
return *v, true
}
// OldExpiresAt returns the old "expires_at" field's value of the VerifyToken entity.
// If the VerifyToken object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *VerifyTokenMutation) OldExpiresAt(ctx context.Context) (v time.Time, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldExpiresAt requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldExpiresAt: %w", err)
}
return oldValue.ExpiresAt, nil
}
// ResetExpiresAt resets all changes to the "expires_at" field.
func (m *VerifyTokenMutation) ResetExpiresAt() {
m.expires_at = nil
}
// SetToken sets the "token" field.
func (m *VerifyTokenMutation) SetToken(s string) {
m.token = &s
}
// Token returns the value of the "token" field in the mutation.
func (m *VerifyTokenMutation) Token() (r string, exists bool) {
v := m.token
if v == nil {
return
}
return *v, true
}
// OldToken returns the old "token" field's value of the VerifyToken entity.
// If the VerifyToken object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *VerifyTokenMutation) OldToken(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldToken is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldToken requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldToken: %w", err)
}
return oldValue.Token, nil
}
// ResetToken resets all changes to the "token" field.
func (m *VerifyTokenMutation) ResetToken() {
m.token = nil
}
// SetPurpose sets the "purpose" field.
func (m *VerifyTokenMutation) SetPurpose(s string) {
m.purpose = &s
}
// Purpose returns the value of the "purpose" field in the mutation.
func (m *VerifyTokenMutation) Purpose() (r string, exists bool) {
v := m.purpose
if v == nil {
return
}
return *v, true
}
// OldPurpose returns the old "purpose" field's value of the VerifyToken entity.
// If the VerifyToken object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *VerifyTokenMutation) OldPurpose(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldPurpose is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldPurpose requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldPurpose: %w", err)
}
return oldValue.Purpose, nil
}
// ClearPurpose clears the value of the "purpose" field.
func (m *VerifyTokenMutation) ClearPurpose() {
m.purpose = nil
m.clearedFields[verifytoken.FieldPurpose] = struct{}{}
}
// PurposeCleared returns if the "purpose" field was cleared in this mutation.
func (m *VerifyTokenMutation) PurposeCleared() bool {
_, ok := m.clearedFields[verifytoken.FieldPurpose]
return ok
}
// ResetPurpose resets all changes to the "purpose" field.
func (m *VerifyTokenMutation) ResetPurpose() {
m.purpose = nil
delete(m.clearedFields, verifytoken.FieldPurpose)
}
// SetUserID sets the "user" edge to the User entity by id.
func (m *VerifyTokenMutation) SetUserID(id int64) {
m.user = &id
}
// ClearUser clears the "user" edge to the User entity.
func (m *VerifyTokenMutation) ClearUser() {
m.cleareduser = true
}
// UserCleared reports if the "user" edge to the User entity was cleared.
func (m *VerifyTokenMutation) UserCleared() bool {
return m.cleareduser
}
// UserID returns the "user" edge ID in the mutation.
func (m *VerifyTokenMutation) UserID() (id int64, exists bool) {
if m.user != nil {
return *m.user, true
}
return
}
// UserIDs returns the "user" edge IDs in the mutation.
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
// UserID instead. It exists only for internal usage by the builders.
func (m *VerifyTokenMutation) UserIDs() (ids []int64) {
if id := m.user; id != nil {
ids = append(ids, *id)
}
return
}
// ResetUser resets all changes to the "user" edge.
func (m *VerifyTokenMutation) ResetUser() {
m.user = nil
m.cleareduser = false
}
// Where appends a list predicates to the VerifyTokenMutation builder.
func (m *VerifyTokenMutation) Where(ps ...predicate.VerifyToken) {
m.predicates = append(m.predicates, ps...)
}
// WhereP appends storage-level predicates to the VerifyTokenMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *VerifyTokenMutation) WhereP(ps ...func(*sql.Selector)) {
p := make([]predicate.VerifyToken, len(ps))
for i := range ps {
p[i] = ps[i]
}
m.Where(p...)
}
// Op returns the operation name.
func (m *VerifyTokenMutation) Op() Op {
return m.op
}
// SetOp allows setting the mutation operation.
func (m *VerifyTokenMutation) SetOp(op Op) {
m.op = op
}
// Type returns the node type of this mutation (VerifyToken).
func (m *VerifyTokenMutation) Type() string {
return m.typ
}
// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *VerifyTokenMutation) Fields() []string {
fields := make([]string, 0, 4)
if m.created_at != nil {
fields = append(fields, verifytoken.FieldCreatedAt)
}
if m.expires_at != nil {
fields = append(fields, verifytoken.FieldExpiresAt)
}
if m.token != nil {
fields = append(fields, verifytoken.FieldToken)
}
if m.purpose != nil {
fields = append(fields, verifytoken.FieldPurpose)
}
return fields
}
// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *VerifyTokenMutation) Field(name string) (ent.Value, bool) {
switch name {
case verifytoken.FieldCreatedAt:
return m.CreatedAt()
case verifytoken.FieldExpiresAt:
return m.ExpiresAt()
case verifytoken.FieldToken:
return m.Token()
case verifytoken.FieldPurpose:
return m.Purpose()
}
return nil, false
}
// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *VerifyTokenMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
switch name {
case verifytoken.FieldCreatedAt:
return m.OldCreatedAt(ctx)
case verifytoken.FieldExpiresAt:
return m.OldExpiresAt(ctx)
case verifytoken.FieldToken:
return m.OldToken(ctx)
case verifytoken.FieldPurpose:
return m.OldPurpose(ctx)
}
return nil, fmt.Errorf("unknown VerifyToken field %s", name)
}
// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *VerifyTokenMutation) SetField(name string, value ent.Value) error {
switch name {
case verifytoken.FieldCreatedAt:
v, ok := value.(time.Time)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetCreatedAt(v)
return nil
case verifytoken.FieldExpiresAt:
v, ok := value.(time.Time)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetExpiresAt(v)
return nil
case verifytoken.FieldToken:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetToken(v)
return nil
case verifytoken.FieldPurpose:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetPurpose(v)
return nil
}
return fmt.Errorf("unknown VerifyToken field %s", name)
}
// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *VerifyTokenMutation) AddedFields() []string {
return nil
}
// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *VerifyTokenMutation) AddedField(name string) (ent.Value, bool) {
return nil, false
}
// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *VerifyTokenMutation) AddField(name string, value ent.Value) error {
switch name {
}
return fmt.Errorf("unknown VerifyToken numeric field %s", name)
}
// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *VerifyTokenMutation) ClearedFields() []string {
var fields []string
if m.FieldCleared(verifytoken.FieldPurpose) {
fields = append(fields, verifytoken.FieldPurpose)
}
return fields
}
// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *VerifyTokenMutation) FieldCleared(name string) bool {
_, ok := m.clearedFields[name]
return ok
}
// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *VerifyTokenMutation) ClearField(name string) error {
switch name {
case verifytoken.FieldPurpose:
m.ClearPurpose()
return nil
}
return fmt.Errorf("unknown VerifyToken nullable field %s", name)
}
// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *VerifyTokenMutation) ResetField(name string) error {
switch name {
case verifytoken.FieldCreatedAt:
m.ResetCreatedAt()
return nil
case verifytoken.FieldExpiresAt:
m.ResetExpiresAt()
return nil
case verifytoken.FieldToken:
m.ResetToken()
return nil
case verifytoken.FieldPurpose:
m.ResetPurpose()
return nil
}
return fmt.Errorf("unknown VerifyToken field %s", name)
}
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *VerifyTokenMutation) AddedEdges() []string {
edges := make([]string, 0, 1)
if m.user != nil {
edges = append(edges, verifytoken.EdgeUser)
}
return edges
}
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *VerifyTokenMutation) AddedIDs(name string) []ent.Value {
switch name {
case verifytoken.EdgeUser:
if id := m.user; id != nil {
return []ent.Value{*id}
}
}
return nil
}
// RemovedEdges returns all edge names that were removed in this mutation.
func (m *VerifyTokenMutation) RemovedEdges() []string {
edges := make([]string, 0, 1)
return edges
}
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *VerifyTokenMutation) RemovedIDs(name string) []ent.Value {
return nil
}
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *VerifyTokenMutation) ClearedEdges() []string {
edges := make([]string, 0, 1)
if m.cleareduser {
edges = append(edges, verifytoken.EdgeUser)
}
return edges
}
// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *VerifyTokenMutation) EdgeCleared(name string) bool {
switch name {
case verifytoken.EdgeUser:
return m.cleareduser
}
return false
}
// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *VerifyTokenMutation) ClearEdge(name string) error {
switch name {
case verifytoken.EdgeUser:
m.ClearUser()
return nil
}
return fmt.Errorf("unknown VerifyToken unique edge %s", name)
}
// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *VerifyTokenMutation) ResetEdge(name string) error {
switch name {
case verifytoken.EdgeUser:
m.ResetUser()
return nil
}
return fmt.Errorf("unknown VerifyToken edge %s", name)
}

3
db/ent/predicate/predicate.go
View File

@@ -23,3 +23,6 @@ type User func(*sql.Selector)
// UserSession is the predicate function for usersession builders.
type UserSession func(*sql.Selector)
// VerifyToken is the predicate function for verifytoken builders.
type VerifyToken func(*sql.Selector)

15
db/ent/runtime.go
View File

@@ -10,6 +10,7 @@ import (
"gitserver.in/patialtech/rano/db/ent/schema"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/usersession"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// The init function reads all schema descriptors with runtime code
@@ -176,4 +177,18 @@ func init() {
usersessionDescIP := usersessionFields[5].Descriptor()
// usersession.IPValidator is a validator for the "ip" field. It is called by the builders before save.
usersession.IPValidator = usersessionDescIP.Validators[0].(func(string) error)
verifytokenFields := schema.VerifyToken{}.Fields()
_ = verifytokenFields
// verifytokenDescCreatedAt is the schema descriptor for created_at field.
verifytokenDescCreatedAt := verifytokenFields[1].Descriptor()
// verifytoken.DefaultCreatedAt holds the default value on creation for the created_at field.
verifytoken.DefaultCreatedAt = verifytokenDescCreatedAt.Default.(func() time.Time)
// verifytokenDescToken is the schema descriptor for token field.
verifytokenDescToken := verifytokenFields[3].Descriptor()
// verifytoken.TokenValidator is a validator for the "token" field. It is called by the builders before save.
verifytoken.TokenValidator = verifytokenDescToken.Validators[0].(func(string) error)
// verifytokenDescPurpose is the schema descriptor for purpose field.
verifytokenDescPurpose := verifytokenFields[4].Descriptor()
// verifytoken.PurposeValidator is a validator for the "purpose" field. It is called by the builders before save.
verifytoken.PurposeValidator = verifytokenDescPurpose.Validators[0].(func(string) error)
}

5
db/ent/schema/user.go
View File

@@ -23,8 +23,8 @@ func (User) Fields() []ent.Field {
field.Bool("email_verified").Default(false),
field.String("phone").MaxLen(20).Optional(),
field.Bool("phone_verified").Default(false),
field.String("pwd_salt").MaxLen(250).NotEmpty(),
field.String("pwd_hash").MaxLen(250).NotEmpty(),
field.String("pwd_salt").MaxLen(100).NotEmpty(),
field.String("pwd_hash").MaxLen(100).NotEmpty(),
field.Uint8("login_failed_count").Optional().Default(0),
field.Time("login_attempt_on").Optional().Nillable(),
field.Time("login_locked_until").Optional().Nillable(),
@@ -40,6 +40,7 @@ func (User) Edges() []ent.Edge {
return []ent.Edge{
edge.To("sessions", UserSession.Type).StorageKey(edge.Column("user_id")),
edge.To("audit_logs", Audit.Type).StorageKey(edge.Column("user_id")),
edge.To("verify_tokens", VerifyToken.Type).StorageKey(edge.Column("user_id")),
}
}

29
db/ent/schema/verifyToken.go Normal file
View File

@@ -0,0 +1,29 @@
package schema
import (
"entgo.io/ent"
"entgo.io/ent/schema/edge"
"entgo.io/ent/schema/field"
)
// Verify holds the schema definition for the Verify entity.
type VerifyToken struct {
ent.Schema
}
// Fields of the Verify.
func (VerifyToken) Fields() []ent.Field {
return []ent.Field{
fieldID,
fieldCreated,
field.Time("expires_at").Immutable(),
field.String("token").MaxLen(50).Unique(),
field.String("purpose").MaxLen(50).Optional(),
}
}
func (VerifyToken) Edges() []ent.Edge {
return []ent.Edge{
edge.From("user", User.Type).Ref("verify_tokens").Unique(),
}
}

3
db/ent/tx.go
View File

@@ -24,6 +24,8 @@ type Tx struct {
User *UserClient
// UserSession is the client for interacting with the UserSession builders.
UserSession *UserSessionClient
// VerifyToken is the client for interacting with the VerifyToken builders.
VerifyToken *VerifyTokenClient
// lazily loaded.
client *Client
@@ -161,6 +163,7 @@ func (tx *Tx) init() {
tx.Todo = NewTodoClient(tx.config)
tx.User = NewUserClient(tx.config)
tx.UserSession = NewUserSessionClient(tx.config)
tx.VerifyToken = NewVerifyTokenClient(tx.config)
}
// txDriver wraps the given dialect.Tx with a nop dialect.Driver implementation.

18
db/ent/user.go
View File

@@ -59,9 +59,11 @@ type UserEdges struct {
Sessions []*UserSession `json:"sessions,omitempty"`
// AuditLogs holds the value of the audit_logs edge.
AuditLogs []*Audit `json:"audit_logs,omitempty"`
// VerifyTokens holds the value of the verify_tokens edge.
VerifyTokens []*VerifyToken `json:"verify_tokens,omitempty"`
// loadedTypes holds the information for reporting if a
// type was loaded (or requested) in eager-loading or not.
loadedTypes [2]bool
loadedTypes [3]bool
}
// SessionsOrErr returns the Sessions value or an error if the edge
@@ -82,6 +84,15 @@ func (e UserEdges) AuditLogsOrErr() ([]*Audit, error) {
return nil, &NotLoadedError{edge: "audit_logs"}
}
// VerifyTokensOrErr returns the VerifyTokens value or an error if the edge
// was not loaded in eager-loading.
func (e UserEdges) VerifyTokensOrErr() ([]*VerifyToken, error) {
if e.loadedTypes[2] {
return e.VerifyTokens, nil
}
return nil, &NotLoadedError{edge: "verify_tokens"}
}
// scanValues returns the types for scanning values from sql.Rows.
func (*User) scanValues(columns []string) ([]any, error) {
values := make([]any, len(columns))
@@ -232,6 +243,11 @@ func (u *User) QueryAuditLogs() *AuditQuery {
return NewUserClient(u.config).QueryAuditLogs(u)
}
// QueryVerifyTokens queries the "verify_tokens" edge of the User entity.
func (u *User) QueryVerifyTokens() *VerifyTokenQuery {
return NewUserClient(u.config).QueryVerifyTokens(u)
}
// Update returns a builder for updating this User.
// Note that you need to call User.Unwrap() before calling this method if this User
// was returned from a transaction, and the transaction was committed or rolled back.

30
db/ent/user/user.go
View File

@@ -49,6 +49,8 @@ const (
EdgeSessions = "sessions"
// EdgeAuditLogs holds the string denoting the audit_logs edge name in mutations.
EdgeAuditLogs = "audit_logs"
// EdgeVerifyTokens holds the string denoting the verify_tokens edge name in mutations.
EdgeVerifyTokens = "verify_tokens"
// Table holds the table name of the user in the database.
Table = "users"
// SessionsTable is the table that holds the sessions relation/edge.
@@ -65,6 +67,13 @@ const (
AuditLogsInverseTable = "audits"
// AuditLogsColumn is the table column denoting the audit_logs relation/edge.
AuditLogsColumn = "user_id"
// VerifyTokensTable is the table that holds the verify_tokens relation/edge.
VerifyTokensTable = "verify_tokens"
// VerifyTokensInverseTable is the table name for the VerifyToken entity.
// It exists in this package in order to avoid circular dependency with the "verifytoken" package.
VerifyTokensInverseTable = "verify_tokens"
// VerifyTokensColumn is the table column denoting the verify_tokens relation/edge.
VerifyTokensColumn = "user_id"
)
// Columns holds all SQL columns for user fields.
@@ -263,6 +272,20 @@ func ByAuditLogs(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
sqlgraph.OrderByNeighborTerms(s, newAuditLogsStep(), append([]sql.OrderTerm{term}, terms...)...)
}
}
// ByVerifyTokensCount orders the results by verify_tokens count.
func ByVerifyTokensCount(opts ...sql.OrderTermOption) OrderOption {
return func(s *sql.Selector) {
sqlgraph.OrderByNeighborsCount(s, newVerifyTokensStep(), opts...)
}
}
// ByVerifyTokens orders the results by verify_tokens terms.
func ByVerifyTokens(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
return func(s *sql.Selector) {
sqlgraph.OrderByNeighborTerms(s, newVerifyTokensStep(), append([]sql.OrderTerm{term}, terms...)...)
}
}
func newSessionsStep() *sqlgraph.Step {
return sqlgraph.NewStep(
sqlgraph.From(Table, FieldID),
@@ -277,3 +300,10 @@ func newAuditLogsStep() *sqlgraph.Step {
sqlgraph.Edge(sqlgraph.O2M, false, AuditLogsTable, AuditLogsColumn),
)
}
func newVerifyTokensStep() *sqlgraph.Step {
return sqlgraph.NewStep(
sqlgraph.From(Table, FieldID),
sqlgraph.To(VerifyTokensInverseTable, FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, VerifyTokensTable, VerifyTokensColumn),
)
}

23
db/ent/user/where.go
View File

@@ -906,6 +906,29 @@ func HasAuditLogsWith(preds ...predicate.Audit) predicate.User {
})
}
// HasVerifyTokens applies the HasEdge predicate on the "verify_tokens" edge.
func HasVerifyTokens() predicate.User {
return predicate.User(func(s *sql.Selector) {
step := sqlgraph.NewStep(
sqlgraph.From(Table, FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, VerifyTokensTable, VerifyTokensColumn),
)
sqlgraph.HasNeighbors(s, step)
})
}
// HasVerifyTokensWith applies the HasEdge predicate on the "verify_tokens" edge with a given conditions (other predicates).
func HasVerifyTokensWith(preds ...predicate.VerifyToken) predicate.User {
return predicate.User(func(s *sql.Selector) {
step := newVerifyTokensStep()
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.User) predicate.User {
return predicate.User(sql.AndPredicates(predicates...))

32
db/ent/user_create.go
View File

@@ -13,6 +13,7 @@ import (
"gitserver.in/patialtech/rano/db/ent/audit"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/usersession"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// UserCreate is the builder for creating a User entity.
@@ -220,6 +221,21 @@ func (uc *UserCreate) AddAuditLogs(a ...*Audit) *UserCreate {
return uc.AddAuditLogIDs(ids...)
}
// AddVerifyTokenIDs adds the "verify_tokens" edge to the VerifyToken entity by IDs.
func (uc *UserCreate) AddVerifyTokenIDs(ids ...int64) *UserCreate {
uc.mutation.AddVerifyTokenIDs(ids...)
return uc
}
// AddVerifyTokens adds the "verify_tokens" edges to the VerifyToken entity.
func (uc *UserCreate) AddVerifyTokens(v ...*VerifyToken) *UserCreate {
ids := make([]int64, len(v))
for i := range v {
ids[i] = v[i].ID
}
return uc.AddVerifyTokenIDs(ids...)
}
// Mutation returns the UserMutation object of the builder.
func (uc *UserCreate) Mutation() *UserMutation {
return uc.mutation
@@ -480,6 +496,22 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
}
_spec.Edges = append(_spec.Edges, edge)
}
if nodes := uc.mutation.VerifyTokensIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.VerifyTokensTable,
Columns: []string{user.VerifyTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges = append(_spec.Edges, edge)
}
return _node, _spec
}

103
db/ent/user_query.go
View File

@@ -16,17 +16,19 @@ import (
"gitserver.in/patialtech/rano/db/ent/predicate"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/usersession"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// UserQuery is the builder for querying User entities.
type UserQuery struct {
config
ctx *QueryContext
order []user.OrderOption
inters []Interceptor
predicates []predicate.User
withSessions *UserSessionQuery
withAuditLogs *AuditQuery
ctx *QueryContext
order []user.OrderOption
inters []Interceptor
predicates []predicate.User
withSessions *UserSessionQuery
withAuditLogs *AuditQuery
withVerifyTokens *VerifyTokenQuery
// intermediate query (i.e. traversal path).
sql *sql.Selector
path func(context.Context) (*sql.Selector, error)
@@ -107,6 +109,28 @@ func (uq *UserQuery) QueryAuditLogs() *AuditQuery {
return query
}
// QueryVerifyTokens chains the current query on the "verify_tokens" edge.
func (uq *UserQuery) QueryVerifyTokens() *VerifyTokenQuery {
query := (&VerifyTokenClient{config: uq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := uq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := uq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(user.Table, user.FieldID, selector),
sqlgraph.To(verifytoken.Table, verifytoken.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.VerifyTokensTable, user.VerifyTokensColumn),
)
fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// First returns the first User entity from the query.
// Returns a *NotFoundError when no User was found.
func (uq *UserQuery) First(ctx context.Context) (*User, error) {
@@ -294,13 +318,14 @@ func (uq *UserQuery) Clone() *UserQuery {
return nil
}
return &UserQuery{
config: uq.config,
ctx: uq.ctx.Clone(),
order: append([]user.OrderOption{}, uq.order...),
inters: append([]Interceptor{}, uq.inters...),
predicates: append([]predicate.User{}, uq.predicates...),
withSessions: uq.withSessions.Clone(),
withAuditLogs: uq.withAuditLogs.Clone(),
config: uq.config,
ctx: uq.ctx.Clone(),
order: append([]user.OrderOption{}, uq.order...),
inters: append([]Interceptor{}, uq.inters...),
predicates: append([]predicate.User{}, uq.predicates...),
withSessions: uq.withSessions.Clone(),
withAuditLogs: uq.withAuditLogs.Clone(),
withVerifyTokens: uq.withVerifyTokens.Clone(),
// clone intermediate query.
sql: uq.sql.Clone(),
path: uq.path,
@@ -329,6 +354,17 @@ func (uq *UserQuery) WithAuditLogs(opts ...func(*AuditQuery)) *UserQuery {
return uq
}
// WithVerifyTokens tells the query-builder to eager-load the nodes that are connected to
// the "verify_tokens" edge. The optional arguments are used to configure the query builder of the edge.
func (uq *UserQuery) WithVerifyTokens(opts ...func(*VerifyTokenQuery)) *UserQuery {
query := (&VerifyTokenClient{config: uq.config}).Query()
for _, opt := range opts {
opt(query)
}
uq.withVerifyTokens = query
return uq
}
// GroupBy is used to group vertices by one or more fields/columns.
// It is often used with aggregate functions, like: count, max, mean, min, sum.
//
@@ -407,9 +443,10 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
var (
nodes = []*User{}
_spec = uq.querySpec()
loadedTypes = [2]bool{
loadedTypes = [3]bool{
uq.withSessions != nil,
uq.withAuditLogs != nil,
uq.withVerifyTokens != nil,
}
)
_spec.ScanValues = func(columns []string) ([]any, error) {
@@ -444,6 +481,13 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
return nil, err
}
}
if query := uq.withVerifyTokens; query != nil {
if err := uq.loadVerifyTokens(ctx, query, nodes,
func(n *User) { n.Edges.VerifyTokens = []*VerifyToken{} },
func(n *User, e *VerifyToken) { n.Edges.VerifyTokens = append(n.Edges.VerifyTokens, e) }); err != nil {
return nil, err
}
}
return nodes, nil
}
@@ -509,6 +553,37 @@ func (uq *UserQuery) loadAuditLogs(ctx context.Context, query *AuditQuery, nodes
}
return nil
}
func (uq *UserQuery) loadVerifyTokens(ctx context.Context, query *VerifyTokenQuery, nodes []*User, init func(*User), assign func(*User, *VerifyToken)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int64]*User)
for i := range nodes {
fks = append(fks, nodes[i].ID)
nodeids[nodes[i].ID] = nodes[i]
if init != nil {
init(nodes[i])
}
}
query.withFKs = true
query.Where(predicate.VerifyToken(func(s *sql.Selector) {
s.Where(sql.InValues(s.C(user.VerifyTokensColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
return err
}
for _, n := range neighbors {
fk := n.user_id
if fk == nil {
return fmt.Errorf(`foreign-key "user_id" is nil for node %v`, n.ID)
}
node, ok := nodeids[*fk]
if !ok {
return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) {
_spec := uq.querySpec()

163
db/ent/user_update.go
View File

@@ -15,6 +15,7 @@ import (
"gitserver.in/patialtech/rano/db/ent/predicate"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/usersession"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// UserUpdate is the builder for updating User entities.
@@ -279,6 +280,21 @@ func (uu *UserUpdate) AddAuditLogs(a ...*Audit) *UserUpdate {
return uu.AddAuditLogIDs(ids...)
}
// AddVerifyTokenIDs adds the "verify_tokens" edge to the VerifyToken entity by IDs.
func (uu *UserUpdate) AddVerifyTokenIDs(ids ...int64) *UserUpdate {
uu.mutation.AddVerifyTokenIDs(ids...)
return uu
}
// AddVerifyTokens adds the "verify_tokens" edges to the VerifyToken entity.
func (uu *UserUpdate) AddVerifyTokens(v ...*VerifyToken) *UserUpdate {
ids := make([]int64, len(v))
for i := range v {
ids[i] = v[i].ID
}
return uu.AddVerifyTokenIDs(ids...)
}
// Mutation returns the UserMutation object of the builder.
func (uu *UserUpdate) Mutation() *UserMutation {
return uu.mutation
@@ -326,6 +342,27 @@ func (uu *UserUpdate) RemoveAuditLogs(a ...*Audit) *UserUpdate {
return uu.RemoveAuditLogIDs(ids...)
}
// ClearVerifyTokens clears all "verify_tokens" edges to the VerifyToken entity.
func (uu *UserUpdate) ClearVerifyTokens() *UserUpdate {
uu.mutation.ClearVerifyTokens()
return uu
}
// RemoveVerifyTokenIDs removes the "verify_tokens" edge to VerifyToken entities by IDs.
func (uu *UserUpdate) RemoveVerifyTokenIDs(ids ...int64) *UserUpdate {
uu.mutation.RemoveVerifyTokenIDs(ids...)
return uu
}
// RemoveVerifyTokens removes "verify_tokens" edges to VerifyToken entities.
func (uu *UserUpdate) RemoveVerifyTokens(v ...*VerifyToken) *UserUpdate {
ids := make([]int64, len(v))
for i := range v {
ids[i] = v[i].ID
}
return uu.RemoveVerifyTokenIDs(ids...)
}
// Save executes the query and returns the number of nodes affected by the update operation.
func (uu *UserUpdate) Save(ctx context.Context) (int, error) {
uu.defaults()
@@ -566,6 +603,51 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
}
_spec.Edges.Add = append(_spec.Edges.Add, edge)
}
if uu.mutation.VerifyTokensCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.VerifyTokensTable,
Columns: []string{user.VerifyTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
}
if nodes := uu.mutation.RemovedVerifyTokensIDs(); len(nodes) > 0 && !uu.mutation.VerifyTokensCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.VerifyTokensTable,
Columns: []string{user.VerifyTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
}
if nodes := uu.mutation.VerifyTokensIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.VerifyTokensTable,
Columns: []string{user.VerifyTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges.Add = append(_spec.Edges.Add, edge)
}
if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil {
if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{user.Label}
@@ -835,6 +917,21 @@ func (uuo *UserUpdateOne) AddAuditLogs(a ...*Audit) *UserUpdateOne {
return uuo.AddAuditLogIDs(ids...)
}
// AddVerifyTokenIDs adds the "verify_tokens" edge to the VerifyToken entity by IDs.
func (uuo *UserUpdateOne) AddVerifyTokenIDs(ids ...int64) *UserUpdateOne {
uuo.mutation.AddVerifyTokenIDs(ids...)
return uuo
}
// AddVerifyTokens adds the "verify_tokens" edges to the VerifyToken entity.
func (uuo *UserUpdateOne) AddVerifyTokens(v ...*VerifyToken) *UserUpdateOne {
ids := make([]int64, len(v))
for i := range v {
ids[i] = v[i].ID
}
return uuo.AddVerifyTokenIDs(ids...)
}
// Mutation returns the UserMutation object of the builder.
func (uuo *UserUpdateOne) Mutation() *UserMutation {
return uuo.mutation
@@ -882,6 +979,27 @@ func (uuo *UserUpdateOne) RemoveAuditLogs(a ...*Audit) *UserUpdateOne {
return uuo.RemoveAuditLogIDs(ids...)
}
// ClearVerifyTokens clears all "verify_tokens" edges to the VerifyToken entity.
func (uuo *UserUpdateOne) ClearVerifyTokens() *UserUpdateOne {
uuo.mutation.ClearVerifyTokens()
return uuo
}
// RemoveVerifyTokenIDs removes the "verify_tokens" edge to VerifyToken entities by IDs.
func (uuo *UserUpdateOne) RemoveVerifyTokenIDs(ids ...int64) *UserUpdateOne {
uuo.mutation.RemoveVerifyTokenIDs(ids...)
return uuo
}
// RemoveVerifyTokens removes "verify_tokens" edges to VerifyToken entities.
func (uuo *UserUpdateOne) RemoveVerifyTokens(v ...*VerifyToken) *UserUpdateOne {
ids := make([]int64, len(v))
for i := range v {
ids[i] = v[i].ID
}
return uuo.RemoveVerifyTokenIDs(ids...)
}
// Where appends a list predicates to the UserUpdate builder.
func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne {
uuo.mutation.Where(ps...)
@@ -1152,6 +1270,51 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
}
_spec.Edges.Add = append(_spec.Edges.Add, edge)
}
if uuo.mutation.VerifyTokensCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.VerifyTokensTable,
Columns: []string{user.VerifyTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
}
if nodes := uuo.mutation.RemovedVerifyTokensIDs(); len(nodes) > 0 && !uuo.mutation.VerifyTokensCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.VerifyTokensTable,
Columns: []string{user.VerifyTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
}
if nodes := uuo.mutation.VerifyTokensIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.VerifyTokensTable,
Columns: []string{user.VerifyTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges.Add = append(_spec.Edges.Add, edge)
}
_node = &User{config: uuo.config}
_spec.Assign = _node.assignValues
_spec.ScanValues = _node.scanValues

178
db/ent/verifytoken.go Normal file
View File

@@ -0,0 +1,178 @@
// Code generated by ent, DO NOT EDIT.
package ent
import (
"fmt"
"strings"
"time"
"entgo.io/ent"
"entgo.io/ent/dialect/sql"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// VerifyToken is the model entity for the VerifyToken schema.
type VerifyToken struct {
config `json:"-"`
// ID of the ent.
ID int64 `json:"id,omitempty"`
// CreatedAt holds the value of the "created_at" field.
CreatedAt time.Time `json:"createdAt"`
// ExpiresAt holds the value of the "expires_at" field.
ExpiresAt time.Time `json:"expires_at,omitempty"`
// Token holds the value of the "token" field.
Token string `json:"token,omitempty"`
// Purpose holds the value of the "purpose" field.
Purpose string `json:"purpose,omitempty"`
// Edges holds the relations/edges for other nodes in the graph.
// The values are being populated by the VerifyTokenQuery when eager-loading is set.
Edges VerifyTokenEdges `json:"edges"`
user_id *int64
selectValues sql.SelectValues
}
// VerifyTokenEdges holds the relations/edges for other nodes in the graph.
type VerifyTokenEdges struct {
// User holds the value of the user edge.
User *User `json:"user,omitempty"`
// loadedTypes holds the information for reporting if a
// type was loaded (or requested) in eager-loading or not.
loadedTypes [1]bool
}
// UserOrErr returns the User value or an error if the edge
// was not loaded in eager-loading, or loaded but was not found.
func (e VerifyTokenEdges) UserOrErr() (*User, error) {
if e.User != nil {
return e.User, nil
} else if e.loadedTypes[0] {
return nil, &NotFoundError{label: user.Label}
}
return nil, &NotLoadedError{edge: "user"}
}
// scanValues returns the types for scanning values from sql.Rows.
func (*VerifyToken) scanValues(columns []string) ([]any, error) {
values := make([]any, len(columns))
for i := range columns {
switch columns[i] {
case verifytoken.FieldID:
values[i] = new(sql.NullInt64)
case verifytoken.FieldToken, verifytoken.FieldPurpose:
values[i] = new(sql.NullString)
case verifytoken.FieldCreatedAt, verifytoken.FieldExpiresAt:
values[i] = new(sql.NullTime)
case verifytoken.ForeignKeys[0]: // user_id
values[i] = new(sql.NullInt64)
default:
values[i] = new(sql.UnknownType)
}
}
return values, nil
}
// assignValues assigns the values that were returned from sql.Rows (after scanning)
// to the VerifyToken fields.
func (vt *VerifyToken) assignValues(columns []string, values []any) error {
if m, n := len(values), len(columns); m < n {
return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
}
for i := range columns {
switch columns[i] {
case verifytoken.FieldID:
value, ok := values[i].(*sql.NullInt64)
if !ok {
return fmt.Errorf("unexpected type %T for field id", value)
}
vt.ID = int64(value.Int64)
case verifytoken.FieldCreatedAt:
if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field created_at", values[i])
} else if value.Valid {
vt.CreatedAt = value.Time
}
case verifytoken.FieldExpiresAt:
if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field expires_at", values[i])
} else if value.Valid {
vt.ExpiresAt = value.Time
}
case verifytoken.FieldToken:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field token", values[i])
} else if value.Valid {
vt.Token = value.String
}
case verifytoken.FieldPurpose:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field purpose", values[i])
} else if value.Valid {
vt.Purpose = value.String
}
case verifytoken.ForeignKeys[0]:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for edge-field user_id", value)
} else if value.Valid {
vt.user_id = new(int64)
*vt.user_id = int64(value.Int64)
}
default:
vt.selectValues.Set(columns[i], values[i])
}
}
return nil
}
// Value returns the ent.Value that was dynamically selected and assigned to the VerifyToken.
// This includes values selected through modifiers, order, etc.
func (vt *VerifyToken) Value(name string) (ent.Value, error) {
return vt.selectValues.Get(name)
}
// QueryUser queries the "user" edge of the VerifyToken entity.
func (vt *VerifyToken) QueryUser() *UserQuery {
return NewVerifyTokenClient(vt.config).QueryUser(vt)
}
// Update returns a builder for updating this VerifyToken.
// Note that you need to call VerifyToken.Unwrap() before calling this method if this VerifyToken
// was returned from a transaction, and the transaction was committed or rolled back.
func (vt *VerifyToken) Update() *VerifyTokenUpdateOne {
return NewVerifyTokenClient(vt.config).UpdateOne(vt)
}
// Unwrap unwraps the VerifyToken entity that was returned from a transaction after it was closed,
// so that all future queries will be executed through the driver which created the transaction.
func (vt *VerifyToken) Unwrap() *VerifyToken {
_tx, ok := vt.config.driver.(*txDriver)
if !ok {
panic("ent: VerifyToken is not a transactional entity")
}
vt.config.driver = _tx.drv
return vt
}
// String implements the fmt.Stringer.
func (vt *VerifyToken) String() string {
var builder strings.Builder
builder.WriteString("VerifyToken(")
builder.WriteString(fmt.Sprintf("id=%v, ", vt.ID))
builder.WriteString("created_at=")
builder.WriteString(vt.CreatedAt.Format(time.ANSIC))
builder.WriteString(", ")
builder.WriteString("expires_at=")
builder.WriteString(vt.ExpiresAt.Format(time.ANSIC))
builder.WriteString(", ")
builder.WriteString("token=")
builder.WriteString(vt.Token)
builder.WriteString(", ")
builder.WriteString("purpose=")
builder.WriteString(vt.Purpose)
builder.WriteByte(')')
return builder.String()
}
// VerifyTokens is a parsable slice of VerifyToken.
type VerifyTokens []*VerifyToken

117
db/ent/verifytoken/verifytoken.go Normal file
View File

@@ -0,0 +1,117 @@
// Code generated by ent, DO NOT EDIT.
package verifytoken
import (
"time"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
)
const (
// Label holds the string label denoting the verifytoken type in the database.
Label = "verify_token"
// FieldID holds the string denoting the id field in the database.
FieldID = "id"
// FieldCreatedAt holds the string denoting the created_at field in the database.
FieldCreatedAt = "created_at"
// FieldExpiresAt holds the string denoting the expires_at field in the database.
FieldExpiresAt = "expires_at"
// FieldToken holds the string denoting the token field in the database.
FieldToken = "token"
// FieldPurpose holds the string denoting the purpose field in the database.
FieldPurpose = "purpose"
// EdgeUser holds the string denoting the user edge name in mutations.
EdgeUser = "user"
// Table holds the table name of the verifytoken in the database.
Table = "verify_tokens"
// UserTable is the table that holds the user relation/edge.
UserTable = "verify_tokens"
// UserInverseTable is the table name for the User entity.
// It exists in this package in order to avoid circular dependency with the "user" package.
UserInverseTable = "users"
// UserColumn is the table column denoting the user relation/edge.
UserColumn = "user_id"
)
// Columns holds all SQL columns for verifytoken fields.
var Columns = []string{
FieldID,
FieldCreatedAt,
FieldExpiresAt,
FieldToken,
FieldPurpose,
}
// ForeignKeys holds the SQL foreign-keys that are owned by the "verify_tokens"
// table and are not defined as standalone fields in the schema.
var ForeignKeys = []string{
"user_id",
}
// ValidColumn reports if the column name is valid (part of the table columns).
func ValidColumn(column string) bool {
for i := range Columns {
if column == Columns[i] {
return true
}
}
for i := range ForeignKeys {
if column == ForeignKeys[i] {
return true
}
}
return false
}
var (
// DefaultCreatedAt holds the default value on creation for the "created_at" field.
DefaultCreatedAt func() time.Time
// TokenValidator is a validator for the "token" field. It is called by the builders before save.
TokenValidator func(string) error
// PurposeValidator is a validator for the "purpose" field. It is called by the builders before save.
PurposeValidator func(string) error
)
// OrderOption defines the ordering options for the VerifyToken queries.
type OrderOption func(*sql.Selector)
// ByID orders the results by the id field.
func ByID(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldID, opts...).ToFunc()
}
// ByCreatedAt orders the results by the created_at field.
func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
}
// ByExpiresAt orders the results by the expires_at field.
func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
}
// ByToken orders the results by the token field.
func ByToken(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldToken, opts...).ToFunc()
}
// ByPurpose orders the results by the purpose field.
func ByPurpose(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldPurpose, opts...).ToFunc()
}
// ByUserField orders the results by user field.
func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
return func(s *sql.Selector) {
sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
}
}
func newUserStep() *sqlgraph.Step {
return sqlgraph.NewStep(
sqlgraph.From(Table, FieldID),
sqlgraph.To(UserInverseTable, FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
)
}

334
db/ent/verifytoken/where.go Normal file
View File

@@ -0,0 +1,334 @@
// Code generated by ent, DO NOT EDIT.
package verifytoken
import (
"time"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"gitserver.in/patialtech/rano/db/ent/predicate"
)
// ID filters vertices based on their ID field.
func ID(id int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldID, id))
}
// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldID, id))
}
// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNEQ(FieldID, id))
}
// IDIn applies the In predicate on the ID field.
func IDIn(ids ...int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldIn(FieldID, ids...))
}
// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNotIn(FieldID, ids...))
}
// IDGT applies the GT predicate on the ID field.
func IDGT(id int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGT(FieldID, id))
}
// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGTE(FieldID, id))
}
// IDLT applies the LT predicate on the ID field.
func IDLT(id int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLT(FieldID, id))
}
// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id int64) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLTE(FieldID, id))
}
// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
func CreatedAt(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldCreatedAt, v))
}
// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
func ExpiresAt(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldExpiresAt, v))
}
// Token applies equality check predicate on the "token" field. It's identical to TokenEQ.
func Token(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldToken, v))
}
// Purpose applies equality check predicate on the "purpose" field. It's identical to PurposeEQ.
func Purpose(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldPurpose, v))
}
// CreatedAtEQ applies the EQ predicate on the "created_at" field.
func CreatedAtEQ(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldCreatedAt, v))
}
// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
func CreatedAtNEQ(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNEQ(FieldCreatedAt, v))
}
// CreatedAtIn applies the In predicate on the "created_at" field.
func CreatedAtIn(vs ...time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldIn(FieldCreatedAt, vs...))
}
// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
func CreatedAtNotIn(vs ...time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNotIn(FieldCreatedAt, vs...))
}
// CreatedAtGT applies the GT predicate on the "created_at" field.
func CreatedAtGT(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGT(FieldCreatedAt, v))
}
// CreatedAtGTE applies the GTE predicate on the "created_at" field.
func CreatedAtGTE(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGTE(FieldCreatedAt, v))
}
// CreatedAtLT applies the LT predicate on the "created_at" field.
func CreatedAtLT(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLT(FieldCreatedAt, v))
}
// CreatedAtLTE applies the LTE predicate on the "created_at" field.
func CreatedAtLTE(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLTE(FieldCreatedAt, v))
}
// ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
func ExpiresAtEQ(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldExpiresAt, v))
}
// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
func ExpiresAtNEQ(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNEQ(FieldExpiresAt, v))
}
// ExpiresAtIn applies the In predicate on the "expires_at" field.
func ExpiresAtIn(vs ...time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldIn(FieldExpiresAt, vs...))
}
// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
func ExpiresAtNotIn(vs ...time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNotIn(FieldExpiresAt, vs...))
}
// ExpiresAtGT applies the GT predicate on the "expires_at" field.
func ExpiresAtGT(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGT(FieldExpiresAt, v))
}
// ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
func ExpiresAtGTE(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGTE(FieldExpiresAt, v))
}
// ExpiresAtLT applies the LT predicate on the "expires_at" field.
func ExpiresAtLT(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLT(FieldExpiresAt, v))
}
// ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
func ExpiresAtLTE(v time.Time) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLTE(FieldExpiresAt, v))
}
// TokenEQ applies the EQ predicate on the "token" field.
func TokenEQ(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldToken, v))
}
// TokenNEQ applies the NEQ predicate on the "token" field.
func TokenNEQ(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNEQ(FieldToken, v))
}
// TokenIn applies the In predicate on the "token" field.
func TokenIn(vs ...string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldIn(FieldToken, vs...))
}
// TokenNotIn applies the NotIn predicate on the "token" field.
func TokenNotIn(vs ...string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNotIn(FieldToken, vs...))
}
// TokenGT applies the GT predicate on the "token" field.
func TokenGT(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGT(FieldToken, v))
}
// TokenGTE applies the GTE predicate on the "token" field.
func TokenGTE(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGTE(FieldToken, v))
}
// TokenLT applies the LT predicate on the "token" field.
func TokenLT(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLT(FieldToken, v))
}
// TokenLTE applies the LTE predicate on the "token" field.
func TokenLTE(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLTE(FieldToken, v))
}
// TokenContains applies the Contains predicate on the "token" field.
func TokenContains(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldContains(FieldToken, v))
}
// TokenHasPrefix applies the HasPrefix predicate on the "token" field.
func TokenHasPrefix(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldHasPrefix(FieldToken, v))
}
// TokenHasSuffix applies the HasSuffix predicate on the "token" field.
func TokenHasSuffix(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldHasSuffix(FieldToken, v))
}
// TokenEqualFold applies the EqualFold predicate on the "token" field.
func TokenEqualFold(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEqualFold(FieldToken, v))
}
// TokenContainsFold applies the ContainsFold predicate on the "token" field.
func TokenContainsFold(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldContainsFold(FieldToken, v))
}
// PurposeEQ applies the EQ predicate on the "purpose" field.
func PurposeEQ(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEQ(FieldPurpose, v))
}
// PurposeNEQ applies the NEQ predicate on the "purpose" field.
func PurposeNEQ(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNEQ(FieldPurpose, v))
}
// PurposeIn applies the In predicate on the "purpose" field.
func PurposeIn(vs ...string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldIn(FieldPurpose, vs...))
}
// PurposeNotIn applies the NotIn predicate on the "purpose" field.
func PurposeNotIn(vs ...string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNotIn(FieldPurpose, vs...))
}
// PurposeGT applies the GT predicate on the "purpose" field.
func PurposeGT(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGT(FieldPurpose, v))
}
// PurposeGTE applies the GTE predicate on the "purpose" field.
func PurposeGTE(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldGTE(FieldPurpose, v))
}
// PurposeLT applies the LT predicate on the "purpose" field.
func PurposeLT(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLT(FieldPurpose, v))
}
// PurposeLTE applies the LTE predicate on the "purpose" field.
func PurposeLTE(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldLTE(FieldPurpose, v))
}
// PurposeContains applies the Contains predicate on the "purpose" field.
func PurposeContains(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldContains(FieldPurpose, v))
}
// PurposeHasPrefix applies the HasPrefix predicate on the "purpose" field.
func PurposeHasPrefix(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldHasPrefix(FieldPurpose, v))
}
// PurposeHasSuffix applies the HasSuffix predicate on the "purpose" field.
func PurposeHasSuffix(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldHasSuffix(FieldPurpose, v))
}
// PurposeIsNil applies the IsNil predicate on the "purpose" field.
func PurposeIsNil() predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldIsNull(FieldPurpose))
}
// PurposeNotNil applies the NotNil predicate on the "purpose" field.
func PurposeNotNil() predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldNotNull(FieldPurpose))
}
// PurposeEqualFold applies the EqualFold predicate on the "purpose" field.
func PurposeEqualFold(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldEqualFold(FieldPurpose, v))
}
// PurposeContainsFold applies the ContainsFold predicate on the "purpose" field.
func PurposeContainsFold(v string) predicate.VerifyToken {
return predicate.VerifyToken(sql.FieldContainsFold(FieldPurpose, v))
}
// HasUser applies the HasEdge predicate on the "user" edge.
func HasUser() predicate.VerifyToken {
return predicate.VerifyToken(func(s *sql.Selector) {
step := sqlgraph.NewStep(
sqlgraph.From(Table, FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
)
sqlgraph.HasNeighbors(s, step)
})
}
// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
func HasUserWith(preds ...predicate.User) predicate.VerifyToken {
return predicate.VerifyToken(func(s *sql.Selector) {
step := newUserStep()
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.VerifyToken) predicate.VerifyToken {
return predicate.VerifyToken(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.VerifyToken) predicate.VerifyToken {
return predicate.VerifyToken(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.VerifyToken) predicate.VerifyToken {
return predicate.VerifyToken(sql.NotPredicates(p))
}

305
db/ent/verifytoken_create.go Normal file
View File

@@ -0,0 +1,305 @@
// Code generated by ent, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"time"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// VerifyTokenCreate is the builder for creating a VerifyToken entity.
type VerifyTokenCreate struct {
config
mutation *VerifyTokenMutation
hooks []Hook
}
// SetCreatedAt sets the "created_at" field.
func (vtc *VerifyTokenCreate) SetCreatedAt(t time.Time) *VerifyTokenCreate {
vtc.mutation.SetCreatedAt(t)
return vtc
}
// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (vtc *VerifyTokenCreate) SetNillableCreatedAt(t *time.Time) *VerifyTokenCreate {
if t != nil {
vtc.SetCreatedAt(*t)
}
return vtc
}
// SetExpiresAt sets the "expires_at" field.
func (vtc *VerifyTokenCreate) SetExpiresAt(t time.Time) *VerifyTokenCreate {
vtc.mutation.SetExpiresAt(t)
return vtc
}
// SetToken sets the "token" field.
func (vtc *VerifyTokenCreate) SetToken(s string) *VerifyTokenCreate {
vtc.mutation.SetToken(s)
return vtc
}
// SetPurpose sets the "purpose" field.
func (vtc *VerifyTokenCreate) SetPurpose(s string) *VerifyTokenCreate {
vtc.mutation.SetPurpose(s)
return vtc
}
// SetNillablePurpose sets the "purpose" field if the given value is not nil.
func (vtc *VerifyTokenCreate) SetNillablePurpose(s *string) *VerifyTokenCreate {
if s != nil {
vtc.SetPurpose(*s)
}
return vtc
}
// SetID sets the "id" field.
func (vtc *VerifyTokenCreate) SetID(i int64) *VerifyTokenCreate {
vtc.mutation.SetID(i)
return vtc
}
// SetUserID sets the "user" edge to the User entity by ID.
func (vtc *VerifyTokenCreate) SetUserID(id int64) *VerifyTokenCreate {
vtc.mutation.SetUserID(id)
return vtc
}
// SetNillableUserID sets the "user" edge to the User entity by ID if the given value is not nil.
func (vtc *VerifyTokenCreate) SetNillableUserID(id *int64) *VerifyTokenCreate {
if id != nil {
vtc = vtc.SetUserID(*id)
}
return vtc
}
// SetUser sets the "user" edge to the User entity.
func (vtc *VerifyTokenCreate) SetUser(u *User) *VerifyTokenCreate {
return vtc.SetUserID(u.ID)
}
// Mutation returns the VerifyTokenMutation object of the builder.
func (vtc *VerifyTokenCreate) Mutation() *VerifyTokenMutation {
return vtc.mutation
}
// Save creates the VerifyToken in the database.
func (vtc *VerifyTokenCreate) Save(ctx context.Context) (*VerifyToken, error) {
vtc.defaults()
return withHooks(ctx, vtc.sqlSave, vtc.mutation, vtc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
func (vtc *VerifyTokenCreate) SaveX(ctx context.Context) *VerifyToken {
v, err := vtc.Save(ctx)
if err != nil {
panic(err)
}
return v
}
// Exec executes the query.
func (vtc *VerifyTokenCreate) Exec(ctx context.Context) error {
_, err := vtc.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (vtc *VerifyTokenCreate) ExecX(ctx context.Context) {
if err := vtc.Exec(ctx); err != nil {
panic(err)
}
}
// defaults sets the default values of the builder before save.
func (vtc *VerifyTokenCreate) defaults() {
if _, ok := vtc.mutation.CreatedAt(); !ok {
v := verifytoken.DefaultCreatedAt()
vtc.mutation.SetCreatedAt(v)
}
}
// check runs all checks and user-defined validators on the builder.
func (vtc *VerifyTokenCreate) check() error {
if _, ok := vtc.mutation.CreatedAt(); !ok {
return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "VerifyToken.created_at"`)}
}
if _, ok := vtc.mutation.ExpiresAt(); !ok {
return &ValidationError{Name: "expires_at", err: errors.New(`ent: missing required field "VerifyToken.expires_at"`)}
}
if _, ok := vtc.mutation.Token(); !ok {
return &ValidationError{Name: "token", err: errors.New(`ent: missing required field "VerifyToken.token"`)}
}
if v, ok := vtc.mutation.Token(); ok {
if err := verifytoken.TokenValidator(v); err != nil {
return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "VerifyToken.token": %w`, err)}
}
}
if v, ok := vtc.mutation.Purpose(); ok {
if err := verifytoken.PurposeValidator(v); err != nil {
return &ValidationError{Name: "purpose", err: fmt.Errorf(`ent: validator failed for field "VerifyToken.purpose": %w`, err)}
}
}
return nil
}
func (vtc *VerifyTokenCreate) sqlSave(ctx context.Context) (*VerifyToken, error) {
if err := vtc.check(); err != nil {
return nil, err
}
_node, _spec := vtc.createSpec()
if err := sqlgraph.CreateNode(ctx, vtc.driver, _spec); err != nil {
if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
return nil, err
}
if _spec.ID.Value != _node.ID {
id := _spec.ID.Value.(int64)
_node.ID = int64(id)
}
vtc.mutation.id = &_node.ID
vtc.mutation.done = true
return _node, nil
}
func (vtc *VerifyTokenCreate) createSpec() (*VerifyToken, *sqlgraph.CreateSpec) {
var (
_node = &VerifyToken{config: vtc.config}
_spec = sqlgraph.NewCreateSpec(verifytoken.Table, sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64))
)
if id, ok := vtc.mutation.ID(); ok {
_node.ID = id
_spec.ID.Value = id
}
if value, ok := vtc.mutation.CreatedAt(); ok {
_spec.SetField(verifytoken.FieldCreatedAt, field.TypeTime, value)
_node.CreatedAt = value
}
if value, ok := vtc.mutation.ExpiresAt(); ok {
_spec.SetField(verifytoken.FieldExpiresAt, field.TypeTime, value)
_node.ExpiresAt = value
}
if value, ok := vtc.mutation.Token(); ok {
_spec.SetField(verifytoken.FieldToken, field.TypeString, value)
_node.Token = value
}
if value, ok := vtc.mutation.Purpose(); ok {
_spec.SetField(verifytoken.FieldPurpose, field.TypeString, value)
_node.Purpose = value
}
if nodes := vtc.mutation.UserIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: verifytoken.UserTable,
Columns: []string{verifytoken.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_node.user_id = &nodes[0]
_spec.Edges = append(_spec.Edges, edge)
}
return _node, _spec
}
// VerifyTokenCreateBulk is the builder for creating many VerifyToken entities in bulk.
type VerifyTokenCreateBulk struct {
config
err error
builders []*VerifyTokenCreate
}
// Save creates the VerifyToken entities in the database.
func (vtcb *VerifyTokenCreateBulk) Save(ctx context.Context) ([]*VerifyToken, error) {
if vtcb.err != nil {
return nil, vtcb.err
}
specs := make([]*sqlgraph.CreateSpec, len(vtcb.builders))
nodes := make([]*VerifyToken, len(vtcb.builders))
mutators := make([]Mutator, len(vtcb.builders))
for i := range vtcb.builders {
func(i int, root context.Context) {
builder := vtcb.builders[i]
builder.defaults()
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*VerifyTokenMutation)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
if err := builder.check(); err != nil {
return nil, err
}
builder.mutation = mutation
var err error
nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, vtcb.builders[i+1].mutation)
} else {
spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
// Invoke the actual operation on the latest mutation in the chain.
if err = sqlgraph.BatchCreate(ctx, vtcb.driver, spec); err != nil {
if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
}
}
if err != nil {
return nil, err
}
mutation.id = &nodes[i].ID
if specs[i].ID.Value != nil && nodes[i].ID == 0 {
id := specs[i].ID.Value.(int64)
nodes[i].ID = int64(id)
}
mutation.done = true
return nodes[i], nil
})
for i := len(builder.hooks) - 1; i >= 0; i-- {
mut = builder.hooks[i](mut)
}
mutators[i] = mut
}(i, ctx)
}
if len(mutators) > 0 {
if _, err := mutators[0].Mutate(ctx, vtcb.builders[0].mutation); err != nil {
return nil, err
}
}
return nodes, nil
}
// SaveX is like Save, but panics if an error occurs.
func (vtcb *VerifyTokenCreateBulk) SaveX(ctx context.Context) []*VerifyToken {
v, err := vtcb.Save(ctx)
if err != nil {
panic(err)
}
return v
}
// Exec executes the query.
func (vtcb *VerifyTokenCreateBulk) Exec(ctx context.Context) error {
_, err := vtcb.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (vtcb *VerifyTokenCreateBulk) ExecX(ctx context.Context) {
if err := vtcb.Exec(ctx); err != nil {
panic(err)
}
}

88
db/ent/verifytoken_delete.go Normal file
View File

@@ -0,0 +1,88 @@
// Code generated by ent, DO NOT EDIT.
package ent
import (
"context"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
"gitserver.in/patialtech/rano/db/ent/predicate"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// VerifyTokenDelete is the builder for deleting a VerifyToken entity.
type VerifyTokenDelete struct {
config
hooks []Hook
mutation *VerifyTokenMutation
}
// Where appends a list predicates to the VerifyTokenDelete builder.
func (vtd *VerifyTokenDelete) Where(ps ...predicate.VerifyToken) *VerifyTokenDelete {
vtd.mutation.Where(ps...)
return vtd
}
// Exec executes the deletion query and returns how many vertices were deleted.
func (vtd *VerifyTokenDelete) Exec(ctx context.Context) (int, error) {
return withHooks(ctx, vtd.sqlExec, vtd.mutation, vtd.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
func (vtd *VerifyTokenDelete) ExecX(ctx context.Context) int {
n, err := vtd.Exec(ctx)
if err != nil {
panic(err)
}
return n
}
func (vtd *VerifyTokenDelete) sqlExec(ctx context.Context) (int, error) {
_spec := sqlgraph.NewDeleteSpec(verifytoken.Table, sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64))
if ps := vtd.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
affected, err := sqlgraph.DeleteNodes(ctx, vtd.driver, _spec)
if err != nil && sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
vtd.mutation.done = true
return affected, err
}
// VerifyTokenDeleteOne is the builder for deleting a single VerifyToken entity.
type VerifyTokenDeleteOne struct {
vtd *VerifyTokenDelete
}
// Where appends a list predicates to the VerifyTokenDelete builder.
func (vtdo *VerifyTokenDeleteOne) Where(ps ...predicate.VerifyToken) *VerifyTokenDeleteOne {
vtdo.vtd.mutation.Where(ps...)
return vtdo
}
// Exec executes the deletion query.
func (vtdo *VerifyTokenDeleteOne) Exec(ctx context.Context) error {
n, err := vtdo.vtd.Exec(ctx)
switch {
case err != nil:
return err
case n == 0:
return &NotFoundError{verifytoken.Label}
default:
return nil
}
}
// ExecX is like Exec, but panics if an error occurs.
func (vtdo *VerifyTokenDeleteOne) ExecX(ctx context.Context) {
if err := vtdo.Exec(ctx); err != nil {
panic(err)
}
}

614
db/ent/verifytoken_query.go Normal file
View File

@@ -0,0 +1,614 @@
// Code generated by ent, DO NOT EDIT.
package ent
import (
"context"
"fmt"
"math"
"entgo.io/ent"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
"gitserver.in/patialtech/rano/db/ent/predicate"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// VerifyTokenQuery is the builder for querying VerifyToken entities.
type VerifyTokenQuery struct {
config
ctx *QueryContext
order []verifytoken.OrderOption
inters []Interceptor
predicates []predicate.VerifyToken
withUser *UserQuery
withFKs bool
// intermediate query (i.e. traversal path).
sql *sql.Selector
path func(context.Context) (*sql.Selector, error)
}
// Where adds a new predicate for the VerifyTokenQuery builder.
func (vtq *VerifyTokenQuery) Where(ps ...predicate.VerifyToken) *VerifyTokenQuery {
vtq.predicates = append(vtq.predicates, ps...)
return vtq
}
// Limit the number of records to be returned by this query.
func (vtq *VerifyTokenQuery) Limit(limit int) *VerifyTokenQuery {
vtq.ctx.Limit = &limit
return vtq
}
// Offset to start from.
func (vtq *VerifyTokenQuery) Offset(offset int) *VerifyTokenQuery {
vtq.ctx.Offset = &offset
return vtq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (vtq *VerifyTokenQuery) Unique(unique bool) *VerifyTokenQuery {
vtq.ctx.Unique = &unique
return vtq
}
// Order specifies how the records should be ordered.
func (vtq *VerifyTokenQuery) Order(o ...verifytoken.OrderOption) *VerifyTokenQuery {
vtq.order = append(vtq.order, o...)
return vtq
}
// QueryUser chains the current query on the "user" edge.
func (vtq *VerifyTokenQuery) QueryUser() *UserQuery {
query := (&UserClient{config: vtq.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := vtq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := vtq.sqlQuery(ctx)
if err := selector.Err(); err != nil {
return nil, err
}
step := sqlgraph.NewStep(
sqlgraph.From(verifytoken.Table, verifytoken.FieldID, selector),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, verifytoken.UserTable, verifytoken.UserColumn),
)
fromU = sqlgraph.SetNeighbors(vtq.driver.Dialect(), step)
return fromU, nil
}
return query
}
// First returns the first VerifyToken entity from the query.
// Returns a *NotFoundError when no VerifyToken was found.
func (vtq *VerifyTokenQuery) First(ctx context.Context) (*VerifyToken, error) {
nodes, err := vtq.Limit(1).All(setContextOp(ctx, vtq.ctx, ent.OpQueryFirst))
if err != nil {
return nil, err
}
if len(nodes) == 0 {
return nil, &NotFoundError{verifytoken.Label}
}
return nodes[0], nil
}
// FirstX is like First, but panics if an error occurs.
func (vtq *VerifyTokenQuery) FirstX(ctx context.Context) *VerifyToken {
node, err := vtq.First(ctx)
if err != nil && !IsNotFound(err) {
panic(err)
}
return node
}
// FirstID returns the first VerifyToken ID from the query.
// Returns a *NotFoundError when no VerifyToken ID was found.
func (vtq *VerifyTokenQuery) FirstID(ctx context.Context) (id int64, err error) {
var ids []int64
if ids, err = vtq.Limit(1).IDs(setContextOp(ctx, vtq.ctx, ent.OpQueryFirstID)); err != nil {
return
}
if len(ids) == 0 {
err = &NotFoundError{verifytoken.Label}
return
}
return ids[0], nil
}
// FirstIDX is like FirstID, but panics if an error occurs.
func (vtq *VerifyTokenQuery) FirstIDX(ctx context.Context) int64 {
id, err := vtq.FirstID(ctx)
if err != nil && !IsNotFound(err) {
panic(err)
}
return id
}
// Only returns a single VerifyToken entity found by the query, ensuring it only returns one.
// Returns a *NotSingularError when more than one VerifyToken entity is found.
// Returns a *NotFoundError when no VerifyToken entities are found.
func (vtq *VerifyTokenQuery) Only(ctx context.Context) (*VerifyToken, error) {
nodes, err := vtq.Limit(2).All(setContextOp(ctx, vtq.ctx, ent.OpQueryOnly))
if err != nil {
return nil, err
}
switch len(nodes) {
case 1:
return nodes[0], nil
case 0:
return nil, &NotFoundError{verifytoken.Label}
default:
return nil, &NotSingularError{verifytoken.Label}
}
}
// OnlyX is like Only, but panics if an error occurs.
func (vtq *VerifyTokenQuery) OnlyX(ctx context.Context) *VerifyToken {
node, err := vtq.Only(ctx)
if err != nil {
panic(err)
}
return node
}
// OnlyID is like Only, but returns the only VerifyToken ID in the query.
// Returns a *NotSingularError when more than one VerifyToken ID is found.
// Returns a *NotFoundError when no entities are found.
func (vtq *VerifyTokenQuery) OnlyID(ctx context.Context) (id int64, err error) {
var ids []int64
if ids, err = vtq.Limit(2).IDs(setContextOp(ctx, vtq.ctx, ent.OpQueryOnlyID)); err != nil {
return
}
switch len(ids) {
case 1:
id = ids[0]
case 0:
err = &NotFoundError{verifytoken.Label}
default:
err = &NotSingularError{verifytoken.Label}
}
return
}
// OnlyIDX is like OnlyID, but panics if an error occurs.
func (vtq *VerifyTokenQuery) OnlyIDX(ctx context.Context) int64 {
id, err := vtq.OnlyID(ctx)
if err != nil {
panic(err)
}
return id
}
// All executes the query and returns a list of VerifyTokens.
func (vtq *VerifyTokenQuery) All(ctx context.Context) ([]*VerifyToken, error) {
ctx = setContextOp(ctx, vtq.ctx, ent.OpQueryAll)
if err := vtq.prepareQuery(ctx); err != nil {
return nil, err
}
qr := querierAll[[]*VerifyToken, *VerifyTokenQuery]()
return withInterceptors[[]*VerifyToken](ctx, vtq, qr, vtq.inters)
}
// AllX is like All, but panics if an error occurs.
func (vtq *VerifyTokenQuery) AllX(ctx context.Context) []*VerifyToken {
nodes, err := vtq.All(ctx)
if err != nil {
panic(err)
}
return nodes
}
// IDs executes the query and returns a list of VerifyToken IDs.
func (vtq *VerifyTokenQuery) IDs(ctx context.Context) (ids []int64, err error) {
if vtq.ctx.Unique == nil && vtq.path != nil {
vtq.Unique(true)
}
ctx = setContextOp(ctx, vtq.ctx, ent.OpQueryIDs)
if err = vtq.Select(verifytoken.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
}
// IDsX is like IDs, but panics if an error occurs.
func (vtq *VerifyTokenQuery) IDsX(ctx context.Context) []int64 {
ids, err := vtq.IDs(ctx)
if err != nil {
panic(err)
}
return ids
}
// Count returns the count of the given query.
func (vtq *VerifyTokenQuery) Count(ctx context.Context) (int, error) {
ctx = setContextOp(ctx, vtq.ctx, ent.OpQueryCount)
if err := vtq.prepareQuery(ctx); err != nil {
return 0, err
}
return withInterceptors[int](ctx, vtq, querierCount[*VerifyTokenQuery](), vtq.inters)
}
// CountX is like Count, but panics if an error occurs.
func (vtq *VerifyTokenQuery) CountX(ctx context.Context) int {
count, err := vtq.Count(ctx)
if err != nil {
panic(err)
}
return count
}
// Exist returns true if the query has elements in the graph.
func (vtq *VerifyTokenQuery) Exist(ctx context.Context) (bool, error) {
ctx = setContextOp(ctx, vtq.ctx, ent.OpQueryExist)
switch _, err := vtq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
case err != nil:
return false, fmt.Errorf("ent: check existence: %w", err)
default:
return true, nil
}
}
// ExistX is like Exist, but panics if an error occurs.
func (vtq *VerifyTokenQuery) ExistX(ctx context.Context) bool {
exist, err := vtq.Exist(ctx)
if err != nil {
panic(err)
}
return exist
}
// Clone returns a duplicate of the VerifyTokenQuery builder, including all associated steps. It can be
// used to prepare common query builders and use them differently after the clone is made.
func (vtq *VerifyTokenQuery) Clone() *VerifyTokenQuery {
if vtq == nil {
return nil
}
return &VerifyTokenQuery{
config: vtq.config,
ctx: vtq.ctx.Clone(),
order: append([]verifytoken.OrderOption{}, vtq.order...),
inters: append([]Interceptor{}, vtq.inters...),
predicates: append([]predicate.VerifyToken{}, vtq.predicates...),
withUser: vtq.withUser.Clone(),
// clone intermediate query.
sql: vtq.sql.Clone(),
path: vtq.path,
}
}
// WithUser tells the query-builder to eager-load the nodes that are connected to
// the "user" edge. The optional arguments are used to configure the query builder of the edge.
func (vtq *VerifyTokenQuery) WithUser(opts ...func(*UserQuery)) *VerifyTokenQuery {
query := (&UserClient{config: vtq.config}).Query()
for _, opt := range opts {
opt(query)
}
vtq.withUser = query
return vtq
}
// GroupBy is used to group vertices by one or more fields/columns.
// It is often used with aggregate functions, like: count, max, mean, min, sum.
//
// Example:
//
// var v []struct {
// CreatedAt time.Time `json:"createdAt"`
// Count int `json:"count,omitempty"`
// }
//
// client.VerifyToken.Query().
// GroupBy(verifytoken.FieldCreatedAt).
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (vtq *VerifyTokenQuery) GroupBy(field string, fields ...string) *VerifyTokenGroupBy {
vtq.ctx.Fields = append([]string{field}, fields...)
grbuild := &VerifyTokenGroupBy{build: vtq}
grbuild.flds = &vtq.ctx.Fields
grbuild.label = verifytoken.Label
grbuild.scan = grbuild.Scan
return grbuild
}
// Select allows the selection one or more fields/columns for the given query,
// instead of selecting all fields in the entity.
//
// Example:
//
// var v []struct {
// CreatedAt time.Time `json:"createdAt"`
// }
//
// client.VerifyToken.Query().
// Select(verifytoken.FieldCreatedAt).
// Scan(ctx, &v)
func (vtq *VerifyTokenQuery) Select(fields ...string) *VerifyTokenSelect {
vtq.ctx.Fields = append(vtq.ctx.Fields, fields...)
sbuild := &VerifyTokenSelect{VerifyTokenQuery: vtq}
sbuild.label = verifytoken.Label
sbuild.flds, sbuild.scan = &vtq.ctx.Fields, sbuild.Scan
return sbuild
}
// Aggregate returns a VerifyTokenSelect configured with the given aggregations.
func (vtq *VerifyTokenQuery) Aggregate(fns ...AggregateFunc) *VerifyTokenSelect {
return vtq.Select().Aggregate(fns...)
}
func (vtq *VerifyTokenQuery) prepareQuery(ctx context.Context) error {
for _, inter := range vtq.inters {
if inter == nil {
return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
}
if trv, ok := inter.(Traverser); ok {
if err := trv.Traverse(ctx, vtq); err != nil {
return err
}
}
}
for _, f := range vtq.ctx.Fields {
if !verifytoken.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
}
if vtq.path != nil {
prev, err := vtq.path(ctx)
if err != nil {
return err
}
vtq.sql = prev
}
return nil
}
func (vtq *VerifyTokenQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*VerifyToken, error) {
var (
nodes = []*VerifyToken{}
withFKs = vtq.withFKs
_spec = vtq.querySpec()
loadedTypes = [1]bool{
vtq.withUser != nil,
}
)
if vtq.withUser != nil {
withFKs = true
}
if withFKs {
_spec.Node.Columns = append(_spec.Node.Columns, verifytoken.ForeignKeys...)
}
_spec.ScanValues = func(columns []string) ([]any, error) {
return (*VerifyToken).scanValues(nil, columns)
}
_spec.Assign = func(columns []string, values []any) error {
node := &VerifyToken{config: vtq.config}
nodes = append(nodes, node)
node.Edges.loadedTypes = loadedTypes
return node.assignValues(columns, values)
}
for i := range hooks {
hooks[i](ctx, _spec)
}
if err := sqlgraph.QueryNodes(ctx, vtq.driver, _spec); err != nil {
return nil, err
}
if len(nodes) == 0 {
return nodes, nil
}
if query := vtq.withUser; query != nil {
if err := vtq.loadUser(ctx, query, nodes, nil,
func(n *VerifyToken, e *User) { n.Edges.User = e }); err != nil {
return nil, err
}
}
return nodes, nil
}
func (vtq *VerifyTokenQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*VerifyToken, init func(*VerifyToken), assign func(*VerifyToken, *User)) error {
ids := make([]int64, 0, len(nodes))
nodeids := make(map[int64][]*VerifyToken)
for i := range nodes {
if nodes[i].user_id == nil {
continue
}
fk := *nodes[i].user_id
if _, ok := nodeids[fk]; !ok {
ids = append(ids, fk)
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
if len(ids) == 0 {
return nil
}
query.Where(user.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
return err
}
for _, n := range neighbors {
nodes, ok := nodeids[n.ID]
if !ok {
return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
}
for i := range nodes {
assign(nodes[i], n)
}
}
return nil
}
func (vtq *VerifyTokenQuery) sqlCount(ctx context.Context) (int, error) {
_spec := vtq.querySpec()
_spec.Node.Columns = vtq.ctx.Fields
if len(vtq.ctx.Fields) > 0 {
_spec.Unique = vtq.ctx.Unique != nil && *vtq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, vtq.driver, _spec)
}
func (vtq *VerifyTokenQuery) querySpec() *sqlgraph.QuerySpec {
_spec := sqlgraph.NewQuerySpec(verifytoken.Table, verifytoken.Columns, sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64))
_spec.From = vtq.sql
if unique := vtq.ctx.Unique; unique != nil {
_spec.Unique = *unique
} else if vtq.path != nil {
_spec.Unique = true
}
if fields := vtq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, verifytoken.FieldID)
for i := range fields {
if fields[i] != verifytoken.FieldID {
_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
}
}
}
if ps := vtq.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
if limit := vtq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
if offset := vtq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := vtq.order; len(ps) > 0 {
_spec.Order = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
return _spec
}
func (vtq *VerifyTokenQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(vtq.driver.Dialect())
t1 := builder.Table(verifytoken.Table)
columns := vtq.ctx.Fields
if len(columns) == 0 {
columns = verifytoken.Columns
}
selector := builder.Select(t1.Columns(columns...)...).From(t1)
if vtq.sql != nil {
selector = vtq.sql
selector.Select(selector.Columns(columns...)...)
}
if vtq.ctx.Unique != nil && *vtq.ctx.Unique {
selector.Distinct()
}
for _, p := range vtq.predicates {
p(selector)
}
for _, p := range vtq.order {
p(selector)
}
if offset := vtq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
if limit := vtq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
}
// VerifyTokenGroupBy is the group-by builder for VerifyToken entities.
type VerifyTokenGroupBy struct {
selector
build *VerifyTokenQuery
}
// Aggregate adds the given aggregation functions to the group-by query.
func (vtgb *VerifyTokenGroupBy) Aggregate(fns ...AggregateFunc) *VerifyTokenGroupBy {
vtgb.fns = append(vtgb.fns, fns...)
return vtgb
}
// Scan applies the selector query and scans the result into the given value.
func (vtgb *VerifyTokenGroupBy) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, vtgb.build.ctx, ent.OpQueryGroupBy)
if err := vtgb.build.prepareQuery(ctx); err != nil {
return err
}
return scanWithInterceptors[*VerifyTokenQuery, *VerifyTokenGroupBy](ctx, vtgb.build, vtgb, vtgb.build.inters, v)
}
func (vtgb *VerifyTokenGroupBy) sqlScan(ctx context.Context, root *VerifyTokenQuery, v any) error {
selector := root.sqlQuery(ctx).Select()
aggregation := make([]string, 0, len(vtgb.fns))
for _, fn := range vtgb.fns {
aggregation = append(aggregation, fn(selector))
}
if len(selector.SelectedColumns()) == 0 {
columns := make([]string, 0, len(*vtgb.flds)+len(vtgb.fns))
for _, f := range *vtgb.flds {
columns = append(columns, selector.C(f))
}
columns = append(columns, aggregation...)
selector.Select(columns...)
}
selector.GroupBy(selector.Columns(*vtgb.flds...)...)
if err := selector.Err(); err != nil {
return err
}
rows := &sql.Rows{}
query, args := selector.Query()
if err := vtgb.build.driver.Query(ctx, query, args, rows); err != nil {
return err
}
defer rows.Close()
return sql.ScanSlice(rows, v)
}
// VerifyTokenSelect is the builder for selecting fields of VerifyToken entities.
type VerifyTokenSelect struct {
*VerifyTokenQuery
selector
}
// Aggregate adds the given aggregation functions to the selector query.
func (vts *VerifyTokenSelect) Aggregate(fns ...AggregateFunc) *VerifyTokenSelect {
vts.fns = append(vts.fns, fns...)
return vts
}
// Scan applies the selector query and scans the result into the given value.
func (vts *VerifyTokenSelect) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, vts.ctx, ent.OpQuerySelect)
if err := vts.prepareQuery(ctx); err != nil {
return err
}
return scanWithInterceptors[*VerifyTokenQuery, *VerifyTokenSelect](ctx, vts.VerifyTokenQuery, vts, vts.inters, v)
}
func (vts *VerifyTokenSelect) sqlScan(ctx context.Context, root *VerifyTokenQuery, v any) error {
selector := root.sqlQuery(ctx)
aggregation := make([]string, 0, len(vts.fns))
for _, fn := range vts.fns {
aggregation = append(aggregation, fn(selector))
}
switch n := len(*vts.selector.flds); {
case n == 0 && len(aggregation) > 0:
selector.Select(aggregation...)
case n != 0 && len(aggregation) > 0:
selector.AppendSelect(aggregation...)
}
rows := &sql.Rows{}
query, args := selector.Query()
if err := vts.driver.Query(ctx, query, args, rows); err != nil {
return err
}
defer rows.Close()
return sql.ScanSlice(rows, v)
}

406
db/ent/verifytoken_update.go Normal file
View File

@@ -0,0 +1,406 @@
// Code generated by ent, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
"gitserver.in/patialtech/rano/db/ent/predicate"
"gitserver.in/patialtech/rano/db/ent/user"
"gitserver.in/patialtech/rano/db/ent/verifytoken"
)
// VerifyTokenUpdate is the builder for updating VerifyToken entities.
type VerifyTokenUpdate struct {
config
hooks []Hook
mutation *VerifyTokenMutation
}
// Where appends a list predicates to the VerifyTokenUpdate builder.
func (vtu *VerifyTokenUpdate) Where(ps ...predicate.VerifyToken) *VerifyTokenUpdate {
vtu.mutation.Where(ps...)
return vtu
}
// SetToken sets the "token" field.
func (vtu *VerifyTokenUpdate) SetToken(s string) *VerifyTokenUpdate {
vtu.mutation.SetToken(s)
return vtu
}
// SetNillableToken sets the "token" field if the given value is not nil.
func (vtu *VerifyTokenUpdate) SetNillableToken(s *string) *VerifyTokenUpdate {
if s != nil {
vtu.SetToken(*s)
}
return vtu
}
// SetPurpose sets the "purpose" field.
func (vtu *VerifyTokenUpdate) SetPurpose(s string) *VerifyTokenUpdate {
vtu.mutation.SetPurpose(s)
return vtu
}
// SetNillablePurpose sets the "purpose" field if the given value is not nil.
func (vtu *VerifyTokenUpdate) SetNillablePurpose(s *string) *VerifyTokenUpdate {
if s != nil {
vtu.SetPurpose(*s)
}
return vtu
}
// ClearPurpose clears the value of the "purpose" field.
func (vtu *VerifyTokenUpdate) ClearPurpose() *VerifyTokenUpdate {
vtu.mutation.ClearPurpose()
return vtu
}
// SetUserID sets the "user" edge to the User entity by ID.
func (vtu *VerifyTokenUpdate) SetUserID(id int64) *VerifyTokenUpdate {
vtu.mutation.SetUserID(id)
return vtu
}
// SetNillableUserID sets the "user" edge to the User entity by ID if the given value is not nil.
func (vtu *VerifyTokenUpdate) SetNillableUserID(id *int64) *VerifyTokenUpdate {
if id != nil {
vtu = vtu.SetUserID(*id)
}
return vtu
}
// SetUser sets the "user" edge to the User entity.
func (vtu *VerifyTokenUpdate) SetUser(u *User) *VerifyTokenUpdate {
return vtu.SetUserID(u.ID)
}
// Mutation returns the VerifyTokenMutation object of the builder.
func (vtu *VerifyTokenUpdate) Mutation() *VerifyTokenMutation {
return vtu.mutation
}
// ClearUser clears the "user" edge to the User entity.
func (vtu *VerifyTokenUpdate) ClearUser() *VerifyTokenUpdate {
vtu.mutation.ClearUser()
return vtu
}
// Save executes the query and returns the number of nodes affected by the update operation.
func (vtu *VerifyTokenUpdate) Save(ctx context.Context) (int, error) {
return withHooks(ctx, vtu.sqlSave, vtu.mutation, vtu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
func (vtu *VerifyTokenUpdate) SaveX(ctx context.Context) int {
affected, err := vtu.Save(ctx)
if err != nil {
panic(err)
}
return affected
}
// Exec executes the query.
func (vtu *VerifyTokenUpdate) Exec(ctx context.Context) error {
_, err := vtu.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (vtu *VerifyTokenUpdate) ExecX(ctx context.Context) {
if err := vtu.Exec(ctx); err != nil {
panic(err)
}
}
// check runs all checks and user-defined validators on the builder.
func (vtu *VerifyTokenUpdate) check() error {
if v, ok := vtu.mutation.Token(); ok {
if err := verifytoken.TokenValidator(v); err != nil {
return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "VerifyToken.token": %w`, err)}
}
}
if v, ok := vtu.mutation.Purpose(); ok {
if err := verifytoken.PurposeValidator(v); err != nil {
return &ValidationError{Name: "purpose", err: fmt.Errorf(`ent: validator failed for field "VerifyToken.purpose": %w`, err)}
}
}
return nil
}
func (vtu *VerifyTokenUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := vtu.check(); err != nil {
return n, err
}
_spec := sqlgraph.NewUpdateSpec(verifytoken.Table, verifytoken.Columns, sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64))
if ps := vtu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
if value, ok := vtu.mutation.Token(); ok {
_spec.SetField(verifytoken.FieldToken, field.TypeString, value)
}
if value, ok := vtu.mutation.Purpose(); ok {
_spec.SetField(verifytoken.FieldPurpose, field.TypeString, value)
}
if vtu.mutation.PurposeCleared() {
_spec.ClearField(verifytoken.FieldPurpose, field.TypeString)
}
if vtu.mutation.UserCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: verifytoken.UserTable,
Columns: []string{verifytoken.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
}
if nodes := vtu.mutation.UserIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: verifytoken.UserTable,
Columns: []string{verifytoken.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges.Add = append(_spec.Edges.Add, edge)
}
if n, err = sqlgraph.UpdateNodes(ctx, vtu.driver, _spec); err != nil {
if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{verifytoken.Label}
} else if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
return 0, err
}
vtu.mutation.done = true
return n, nil
}
// VerifyTokenUpdateOne is the builder for updating a single VerifyToken entity.
type VerifyTokenUpdateOne struct {
config
fields []string
hooks []Hook
mutation *VerifyTokenMutation
}
// SetToken sets the "token" field.
func (vtuo *VerifyTokenUpdateOne) SetToken(s string) *VerifyTokenUpdateOne {
vtuo.mutation.SetToken(s)
return vtuo
}
// SetNillableToken sets the "token" field if the given value is not nil.
func (vtuo *VerifyTokenUpdateOne) SetNillableToken(s *string) *VerifyTokenUpdateOne {
if s != nil {
vtuo.SetToken(*s)
}
return vtuo
}
// SetPurpose sets the "purpose" field.
func (vtuo *VerifyTokenUpdateOne) SetPurpose(s string) *VerifyTokenUpdateOne {
vtuo.mutation.SetPurpose(s)
return vtuo
}
// SetNillablePurpose sets the "purpose" field if the given value is not nil.
func (vtuo *VerifyTokenUpdateOne) SetNillablePurpose(s *string) *VerifyTokenUpdateOne {
if s != nil {
vtuo.SetPurpose(*s)
}
return vtuo
}
// ClearPurpose clears the value of the "purpose" field.
func (vtuo *VerifyTokenUpdateOne) ClearPurpose() *VerifyTokenUpdateOne {
vtuo.mutation.ClearPurpose()
return vtuo
}
// SetUserID sets the "user" edge to the User entity by ID.
func (vtuo *VerifyTokenUpdateOne) SetUserID(id int64) *VerifyTokenUpdateOne {
vtuo.mutation.SetUserID(id)
return vtuo
}
// SetNillableUserID sets the "user" edge to the User entity by ID if the given value is not nil.
func (vtuo *VerifyTokenUpdateOne) SetNillableUserID(id *int64) *VerifyTokenUpdateOne {
if id != nil {
vtuo = vtuo.SetUserID(*id)
}
return vtuo
}
// SetUser sets the "user" edge to the User entity.
func (vtuo *VerifyTokenUpdateOne) SetUser(u *User) *VerifyTokenUpdateOne {
return vtuo.SetUserID(u.ID)
}
// Mutation returns the VerifyTokenMutation object of the builder.
func (vtuo *VerifyTokenUpdateOne) Mutation() *VerifyTokenMutation {
return vtuo.mutation
}
// ClearUser clears the "user" edge to the User entity.
func (vtuo *VerifyTokenUpdateOne) ClearUser() *VerifyTokenUpdateOne {
vtuo.mutation.ClearUser()
return vtuo
}
// Where appends a list predicates to the VerifyTokenUpdate builder.
func (vtuo *VerifyTokenUpdateOne) Where(ps ...predicate.VerifyToken) *VerifyTokenUpdateOne {
vtuo.mutation.Where(ps...)
return vtuo
}
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (vtuo *VerifyTokenUpdateOne) Select(field string, fields ...string) *VerifyTokenUpdateOne {
vtuo.fields = append([]string{field}, fields...)
return vtuo
}
// Save executes the query and returns the updated VerifyToken entity.
func (vtuo *VerifyTokenUpdateOne) Save(ctx context.Context) (*VerifyToken, error) {
return withHooks(ctx, vtuo.sqlSave, vtuo.mutation, vtuo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
func (vtuo *VerifyTokenUpdateOne) SaveX(ctx context.Context) *VerifyToken {
node, err := vtuo.Save(ctx)
if err != nil {
panic(err)
}
return node
}
// Exec executes the query on the entity.
func (vtuo *VerifyTokenUpdateOne) Exec(ctx context.Context) error {
_, err := vtuo.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (vtuo *VerifyTokenUpdateOne) ExecX(ctx context.Context) {
if err := vtuo.Exec(ctx); err != nil {
panic(err)
}
}
// check runs all checks and user-defined validators on the builder.
func (vtuo *VerifyTokenUpdateOne) check() error {
if v, ok := vtuo.mutation.Token(); ok {
if err := verifytoken.TokenValidator(v); err != nil {
return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "VerifyToken.token": %w`, err)}
}
}
if v, ok := vtuo.mutation.Purpose(); ok {
if err := verifytoken.PurposeValidator(v); err != nil {
return &ValidationError{Name: "purpose", err: fmt.Errorf(`ent: validator failed for field "VerifyToken.purpose": %w`, err)}
}
}
return nil
}
func (vtuo *VerifyTokenUpdateOne) sqlSave(ctx context.Context) (_node *VerifyToken, err error) {
if err := vtuo.check(); err != nil {
return _node, err
}
_spec := sqlgraph.NewUpdateSpec(verifytoken.Table, verifytoken.Columns, sqlgraph.NewFieldSpec(verifytoken.FieldID, field.TypeInt64))
id, ok := vtuo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "VerifyToken.id" for update`)}
}
_spec.Node.ID.Value = id
if fields := vtuo.fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, verifytoken.FieldID)
for _, f := range fields {
if !verifytoken.ValidColumn(f) {
return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
if f != verifytoken.FieldID {
_spec.Node.Columns = append(_spec.Node.Columns, f)
}
}
}
if ps := vtuo.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
if value, ok := vtuo.mutation.Token(); ok {
_spec.SetField(verifytoken.FieldToken, field.TypeString, value)
}
if value, ok := vtuo.mutation.Purpose(); ok {
_spec.SetField(verifytoken.FieldPurpose, field.TypeString, value)
}
if vtuo.mutation.PurposeCleared() {
_spec.ClearField(verifytoken.FieldPurpose, field.TypeString)
}
if vtuo.mutation.UserCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: verifytoken.UserTable,
Columns: []string{verifytoken.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
}
if nodes := vtuo.mutation.UserIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: verifytoken.UserTable,
Columns: []string{verifytoken.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
},
}
for _, k := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
_spec.Edges.Add = append(_spec.Edges.Add, edge)
}
_node = &VerifyToken{config: vtuo.config}
_spec.Assign = _node.assignValues
_spec.ScanValues = _node.scanValues
if err = sqlgraph.UpdateNode(ctx, vtuo.driver, _spec); err != nil {
if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{verifytoken.Label}
} else if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
return nil, err
}
vtuo.mutation.done = true
return _node, nil
}