// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.

package query

import (
	"context"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"

	"gorm.io/gen"
	"gorm.io/gen/field"

	"gorm.io/plugin/dbresolver"

	"gitee.com/liuxuezhan/ar-platform/assets-rpc/internal/dao/schema/withdraw"
)

func newWithdrawChannel(db *gorm.DB, opts ...gen.DOOption) withdrawChannel {
	_withdrawChannel := withdrawChannel{}

	_withdrawChannel.withdrawChannelDo.UseDB(db, opts...)
	_withdrawChannel.withdrawChannelDo.UseModel(&withdraw.WithdrawChannel{})

	tableName := _withdrawChannel.withdrawChannelDo.TableName()
	_withdrawChannel.ALL = field.NewAsterisk(tableName)
	_withdrawChannel.ID = field.NewInt64(tableName, "id")
	_withdrawChannel.CreatedAt = field.NewInt64(tableName, "created_at")
	_withdrawChannel.UpdatedAt = field.NewInt64(tableName, "updated_at")
	_withdrawChannel.DeletedAt = field.NewInt64(tableName, "deleted_at")
	_withdrawChannel.MappingCode = field.NewString(tableName, "mapping_code")
	_withdrawChannel.AppId = field.NewString(tableName, "app_id")
	_withdrawChannel.AppCode = field.NewString(tableName, "app_code")
	_withdrawChannel.Type = field.NewInt32(tableName, "type")
	_withdrawChannel.Name = field.NewString(tableName, "name")
	_withdrawChannel.URL = field.NewString(tableName, "url")
	_withdrawChannel.ReturnUrl = field.NewString(tableName, "return_url")
	_withdrawChannel.NotifyUrl = field.NewString(tableName, "notify_url")
	_withdrawChannel.MinAmount = field.NewFloat64(tableName, "min_amount")
	_withdrawChannel.MaxAmount = field.NewFloat64(tableName, "max_amount")
	_withdrawChannel.MerchantID = field.NewString(tableName, "merchant_id")
	_withdrawChannel.SecretKey = field.NewString(tableName, "secret_key")
	_withdrawChannel.PubKey = field.NewString(tableName, "pub_key")
	_withdrawChannel.PrivateKey = field.NewString(tableName, "private_key")
	_withdrawChannel.Sort = field.NewInt32(tableName, "sort")
	_withdrawChannel.Status = field.NewInt32(tableName, "status")
	_withdrawChannel.WhiteList = field.NewString(tableName, "white_list")
	_withdrawChannel.Remark = field.NewString(tableName, "remark")
	_withdrawChannel.ChannelName = field.NewString(tableName, "channel_name")
	_withdrawChannel.INR = field.NewString(tableName, "inr")
	_withdrawChannel.Country = field.NewString(tableName, "country")

	_withdrawChannel.fillFieldMap()

	return _withdrawChannel
}

type withdrawChannel struct {
	withdrawChannelDo

	ALL         field.Asterisk
	ID          field.Int64
	CreatedAt   field.Int64
	UpdatedAt   field.Int64
	DeletedAt   field.Int64
	MappingCode field.String
	AppId       field.String
	AppCode     field.String
	Type        field.Int32
	Name        field.String
	URL         field.String
	ReturnUrl   field.String
	NotifyUrl   field.String
	MinAmount   field.Float64
	MaxAmount   field.Float64
	MerchantID  field.String
	SecretKey   field.String
	PubKey      field.String
	PrivateKey  field.String
	Sort        field.Int32
	Status      field.Int32
	WhiteList   field.String
	Remark      field.String
	ChannelName field.String
	INR         field.String
	Country     field.String

	fieldMap map[string]field.Expr
}

func (w withdrawChannel) Table(newTableName string) *withdrawChannel {
	w.withdrawChannelDo.UseTable(newTableName)
	return w.updateTableName(newTableName)
}

func (w withdrawChannel) As(alias string) *withdrawChannel {
	w.withdrawChannelDo.DO = *(w.withdrawChannelDo.As(alias).(*gen.DO))
	return w.updateTableName(alias)
}

func (w *withdrawChannel) updateTableName(table string) *withdrawChannel {
	w.ALL = field.NewAsterisk(table)
	w.ID = field.NewInt64(table, "id")
	w.CreatedAt = field.NewInt64(table, "created_at")
	w.UpdatedAt = field.NewInt64(table, "updated_at")
	w.DeletedAt = field.NewInt64(table, "deleted_at")
	w.MappingCode = field.NewString(table, "mapping_code")
	w.AppId = field.NewString(table, "app_id")
	w.AppCode = field.NewString(table, "app_code")
	w.Type = field.NewInt32(table, "type")
	w.Name = field.NewString(table, "name")
	w.URL = field.NewString(table, "url")
	w.ReturnUrl = field.NewString(table, "return_url")
	w.NotifyUrl = field.NewString(table, "notify_url")
	w.MinAmount = field.NewFloat64(table, "min_amount")
	w.MaxAmount = field.NewFloat64(table, "max_amount")
	w.MerchantID = field.NewString(table, "merchant_id")
	w.SecretKey = field.NewString(table, "secret_key")
	w.PubKey = field.NewString(table, "pub_key")
	w.PrivateKey = field.NewString(table, "private_key")
	w.Sort = field.NewInt32(table, "sort")
	w.Status = field.NewInt32(table, "status")
	w.WhiteList = field.NewString(table, "white_list")
	w.Remark = field.NewString(table, "remark")
	w.ChannelName = field.NewString(table, "channel_name")
	w.INR = field.NewString(table, "inr")
	w.Country = field.NewString(table, "country")

	w.fillFieldMap()

	return w
}

func (w *withdrawChannel) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
	_f, ok := w.fieldMap[fieldName]
	if !ok || _f == nil {
		return nil, false
	}
	_oe, ok := _f.(field.OrderExpr)
	return _oe, ok
}

func (w *withdrawChannel) fillFieldMap() {
	w.fieldMap = make(map[string]field.Expr, 25)
	w.fieldMap["id"] = w.ID
	w.fieldMap["created_at"] = w.CreatedAt
	w.fieldMap["updated_at"] = w.UpdatedAt
	w.fieldMap["deleted_at"] = w.DeletedAt
	w.fieldMap["mapping_code"] = w.MappingCode
	w.fieldMap["app_id"] = w.AppId
	w.fieldMap["app_code"] = w.AppCode
	w.fieldMap["type"] = w.Type
	w.fieldMap["name"] = w.Name
	w.fieldMap["url"] = w.URL
	w.fieldMap["return_url"] = w.ReturnUrl
	w.fieldMap["notify_url"] = w.NotifyUrl
	w.fieldMap["min_amount"] = w.MinAmount
	w.fieldMap["max_amount"] = w.MaxAmount
	w.fieldMap["merchant_id"] = w.MerchantID
	w.fieldMap["secret_key"] = w.SecretKey
	w.fieldMap["pub_key"] = w.PubKey
	w.fieldMap["private_key"] = w.PrivateKey
	w.fieldMap["sort"] = w.Sort
	w.fieldMap["status"] = w.Status
	w.fieldMap["white_list"] = w.WhiteList
	w.fieldMap["remark"] = w.Remark
	w.fieldMap["channel_name"] = w.ChannelName
	w.fieldMap["inr"] = w.INR
	w.fieldMap["country"] = w.Country
}

func (w withdrawChannel) clone(db *gorm.DB) withdrawChannel {
	w.withdrawChannelDo.ReplaceConnPool(db.Statement.ConnPool)
	return w
}

func (w withdrawChannel) replaceDB(db *gorm.DB) withdrawChannel {
	w.withdrawChannelDo.ReplaceDB(db)
	return w
}

type withdrawChannelDo struct{ gen.DO }

type IWithdrawChannelDo interface {
	gen.SubQuery
	Debug() IWithdrawChannelDo
	WithContext(ctx context.Context) IWithdrawChannelDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IWithdrawChannelDo
	WriteDB() IWithdrawChannelDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IWithdrawChannelDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IWithdrawChannelDo
	Not(conds ...gen.Condition) IWithdrawChannelDo
	Or(conds ...gen.Condition) IWithdrawChannelDo
	Select(conds ...field.Expr) IWithdrawChannelDo
	Where(conds ...gen.Condition) IWithdrawChannelDo
	Order(conds ...field.Expr) IWithdrawChannelDo
	Distinct(cols ...field.Expr) IWithdrawChannelDo
	Omit(cols ...field.Expr) IWithdrawChannelDo
	Join(table schema.Tabler, on ...field.Expr) IWithdrawChannelDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IWithdrawChannelDo
	RightJoin(table schema.Tabler, on ...field.Expr) IWithdrawChannelDo
	Group(cols ...field.Expr) IWithdrawChannelDo
	Having(conds ...gen.Condition) IWithdrawChannelDo
	Limit(limit int) IWithdrawChannelDo
	Offset(offset int) IWithdrawChannelDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IWithdrawChannelDo
	Unscoped() IWithdrawChannelDo
	Create(values ...*withdraw.WithdrawChannel) error
	CreateInBatches(values []*withdraw.WithdrawChannel, batchSize int) error
	Save(values ...*withdraw.WithdrawChannel) error
	First() (*withdraw.WithdrawChannel, error)
	Take() (*withdraw.WithdrawChannel, error)
	Last() (*withdraw.WithdrawChannel, error)
	Find() ([]*withdraw.WithdrawChannel, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*withdraw.WithdrawChannel, err error)
	FindInBatches(result *[]*withdraw.WithdrawChannel, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*withdraw.WithdrawChannel) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IWithdrawChannelDo
	Assign(attrs ...field.AssignExpr) IWithdrawChannelDo
	Joins(fields ...field.RelationField) IWithdrawChannelDo
	Preload(fields ...field.RelationField) IWithdrawChannelDo
	FirstOrInit() (*withdraw.WithdrawChannel, error)
	FirstOrCreate() (*withdraw.WithdrawChannel, error)
	FindByPage(offset int, limit int) (result []*withdraw.WithdrawChannel, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IWithdrawChannelDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

func (w withdrawChannelDo) Debug() IWithdrawChannelDo {
	return w.withDO(w.DO.Debug())
}

func (w withdrawChannelDo) WithContext(ctx context.Context) IWithdrawChannelDo {
	return w.withDO(w.DO.WithContext(ctx))
}

func (w withdrawChannelDo) ReadDB() IWithdrawChannelDo {
	return w.Clauses(dbresolver.Read)
}

func (w withdrawChannelDo) WriteDB() IWithdrawChannelDo {
	return w.Clauses(dbresolver.Write)
}

func (w withdrawChannelDo) Session(config *gorm.Session) IWithdrawChannelDo {
	return w.withDO(w.DO.Session(config))
}

func (w withdrawChannelDo) Clauses(conds ...clause.Expression) IWithdrawChannelDo {
	return w.withDO(w.DO.Clauses(conds...))
}

func (w withdrawChannelDo) Returning(value interface{}, columns ...string) IWithdrawChannelDo {
	return w.withDO(w.DO.Returning(value, columns...))
}

func (w withdrawChannelDo) Not(conds ...gen.Condition) IWithdrawChannelDo {
	return w.withDO(w.DO.Not(conds...))
}

func (w withdrawChannelDo) Or(conds ...gen.Condition) IWithdrawChannelDo {
	return w.withDO(w.DO.Or(conds...))
}

func (w withdrawChannelDo) Select(conds ...field.Expr) IWithdrawChannelDo {
	return w.withDO(w.DO.Select(conds...))
}

func (w withdrawChannelDo) Where(conds ...gen.Condition) IWithdrawChannelDo {
	return w.withDO(w.DO.Where(conds...))
}

func (w withdrawChannelDo) Order(conds ...field.Expr) IWithdrawChannelDo {
	return w.withDO(w.DO.Order(conds...))
}

func (w withdrawChannelDo) Distinct(cols ...field.Expr) IWithdrawChannelDo {
	return w.withDO(w.DO.Distinct(cols...))
}

func (w withdrawChannelDo) Omit(cols ...field.Expr) IWithdrawChannelDo {
	return w.withDO(w.DO.Omit(cols...))
}

func (w withdrawChannelDo) Join(table schema.Tabler, on ...field.Expr) IWithdrawChannelDo {
	return w.withDO(w.DO.Join(table, on...))
}

func (w withdrawChannelDo) LeftJoin(table schema.Tabler, on ...field.Expr) IWithdrawChannelDo {
	return w.withDO(w.DO.LeftJoin(table, on...))
}

func (w withdrawChannelDo) RightJoin(table schema.Tabler, on ...field.Expr) IWithdrawChannelDo {
	return w.withDO(w.DO.RightJoin(table, on...))
}

func (w withdrawChannelDo) Group(cols ...field.Expr) IWithdrawChannelDo {
	return w.withDO(w.DO.Group(cols...))
}

func (w withdrawChannelDo) Having(conds ...gen.Condition) IWithdrawChannelDo {
	return w.withDO(w.DO.Having(conds...))
}

func (w withdrawChannelDo) Limit(limit int) IWithdrawChannelDo {
	return w.withDO(w.DO.Limit(limit))
}

func (w withdrawChannelDo) Offset(offset int) IWithdrawChannelDo {
	return w.withDO(w.DO.Offset(offset))
}

func (w withdrawChannelDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IWithdrawChannelDo {
	return w.withDO(w.DO.Scopes(funcs...))
}

func (w withdrawChannelDo) Unscoped() IWithdrawChannelDo {
	return w.withDO(w.DO.Unscoped())
}

func (w withdrawChannelDo) Create(values ...*withdraw.WithdrawChannel) error {
	if len(values) == 0 {
		return nil
	}
	return w.DO.Create(values)
}

func (w withdrawChannelDo) CreateInBatches(values []*withdraw.WithdrawChannel, batchSize int) error {
	return w.DO.CreateInBatches(values, batchSize)
}

// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (w withdrawChannelDo) Save(values ...*withdraw.WithdrawChannel) error {
	if len(values) == 0 {
		return nil
	}
	return w.DO.Save(values)
}

func (w withdrawChannelDo) First() (*withdraw.WithdrawChannel, error) {
	if result, err := w.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*withdraw.WithdrawChannel), nil
	}
}

func (w withdrawChannelDo) Take() (*withdraw.WithdrawChannel, error) {
	if result, err := w.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*withdraw.WithdrawChannel), nil
	}
}

func (w withdrawChannelDo) Last() (*withdraw.WithdrawChannel, error) {
	if result, err := w.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*withdraw.WithdrawChannel), nil
	}
}

func (w withdrawChannelDo) Find() ([]*withdraw.WithdrawChannel, error) {
	result, err := w.DO.Find()
	return result.([]*withdraw.WithdrawChannel), err
}

func (w withdrawChannelDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*withdraw.WithdrawChannel, err error) {
	buf := make([]*withdraw.WithdrawChannel, 0, batchSize)
	err = w.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
		defer func() { results = append(results, buf...) }()
		return fc(tx, batch)
	})
	return results, err
}

func (w withdrawChannelDo) FindInBatches(result *[]*withdraw.WithdrawChannel, batchSize int, fc func(tx gen.Dao, batch int) error) error {
	return w.DO.FindInBatches(result, batchSize, fc)
}

func (w withdrawChannelDo) Attrs(attrs ...field.AssignExpr) IWithdrawChannelDo {
	return w.withDO(w.DO.Attrs(attrs...))
}

func (w withdrawChannelDo) Assign(attrs ...field.AssignExpr) IWithdrawChannelDo {
	return w.withDO(w.DO.Assign(attrs...))
}

func (w withdrawChannelDo) Joins(fields ...field.RelationField) IWithdrawChannelDo {
	for _, _f := range fields {
		w = *w.withDO(w.DO.Joins(_f))
	}
	return &w
}

func (w withdrawChannelDo) Preload(fields ...field.RelationField) IWithdrawChannelDo {
	for _, _f := range fields {
		w = *w.withDO(w.DO.Preload(_f))
	}
	return &w
}

func (w withdrawChannelDo) FirstOrInit() (*withdraw.WithdrawChannel, error) {
	if result, err := w.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*withdraw.WithdrawChannel), nil
	}
}

func (w withdrawChannelDo) FirstOrCreate() (*withdraw.WithdrawChannel, error) {
	if result, err := w.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*withdraw.WithdrawChannel), nil
	}
}

func (w withdrawChannelDo) FindByPage(offset int, limit int) (result []*withdraw.WithdrawChannel, count int64, err error) {
	result, err = w.Offset(offset).Limit(limit).Find()
	if err != nil {
		return
	}

	if size := len(result); 0 < limit && 0 < size && size < limit {
		count = int64(size + offset)
		return
	}

	count, err = w.Offset(-1).Limit(-1).Count()
	return
}

func (w withdrawChannelDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
	count, err = w.Count()
	if err != nil {
		return
	}

	err = w.Offset(offset).Limit(limit).Scan(result)
	return
}

func (w withdrawChannelDo) Scan(result interface{}) (err error) {
	return w.DO.Scan(result)
}

func (w withdrawChannelDo) Delete(models ...*withdraw.WithdrawChannel) (result gen.ResultInfo, err error) {
	return w.DO.Delete(models)
}

func (w *withdrawChannelDo) withDO(do gen.Dao) *withdrawChannelDo {
	w.DO = *do.(*gen.DO)
	return w
}