// 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/recharge"
)

func newRechargeOrder(db *gorm.DB, opts ...gen.DOOption) rechargeOrder {
	_rechargeOrder := rechargeOrder{}

	_rechargeOrder.rechargeOrderDo.UseDB(db, opts...)
	_rechargeOrder.rechargeOrderDo.UseModel(&recharge.RechargeOrder{})

	tableName := _rechargeOrder.rechargeOrderDo.TableName()
	_rechargeOrder.ALL = field.NewAsterisk(tableName)
	_rechargeOrder.ID = field.NewInt64(tableName, "id")
	_rechargeOrder.CreatedAt = field.NewInt64(tableName, "created_at")
	_rechargeOrder.UpdatedAt = field.NewInt64(tableName, "updated_at")
	_rechargeOrder.DeletedAt = field.NewInt64(tableName, "deleted_at")
	_rechargeOrder.Ip = field.NewString(tableName, "ip")
	_rechargeOrder.UserAgent = field.NewString(tableName, "user_agent")
	_rechargeOrder.Fbc = field.NewString(tableName, "fbc")
	_rechargeOrder.Fbp = field.NewString(tableName, "fbp")
	_rechargeOrder.FacebookAdId = field.NewString(tableName, "facebook_ad_id")
	_rechargeOrder.SiteUrl = field.NewString(tableName, "site_url")
	_rechargeOrder.Email = field.NewString(tableName, "email")
	_rechargeOrder.Telephone = field.NewString(tableName, "telephone")
	_rechargeOrder.UserID = field.NewInt64(tableName, "user_id")
	_rechargeOrder.OrderNo = field.NewString(tableName, "order_no")
	_rechargeOrder.OrderId = field.NewString(tableName, "order_id")
	_rechargeOrder.Type = field.NewInt32(tableName, "type")
	_rechargeOrder.ChannelID = field.NewInt64(tableName, "channel_id")
	_rechargeOrder.Amount = field.NewFloat64(tableName, "amount")
	_rechargeOrder.Ratio = field.NewFloat64(tableName, "ratio")
	_rechargeOrder.Coin = field.NewString(tableName, "coin")
	_rechargeOrder.ReturnJson = field.NewString(tableName, "return_json")
	_rechargeOrder.Status = field.NewInt32(tableName, "status")
	_rechargeOrder.DepositTime = field.NewUint32(tableName, "deposit_time")
	_rechargeOrder.TransferReceipt = field.NewString(tableName, "transfer_receipt")
	_rechargeOrder.CustomerInfo = field.NewString(tableName, "customer_info")
	_rechargeOrder.VipLevel = field.NewInt32(tableName, "vip_level")
	_rechargeOrder.BankUpi = field.NewString(tableName, "bank_upi")
	_rechargeOrder.ActualAmount = field.NewFloat64(tableName, "actual_amount")
	_rechargeOrder.GoonStatus = field.NewInt32(tableName, "goon_status")
	_rechargeOrder.DepositType = field.NewInt64(tableName, "deposit_type")
	_rechargeOrder.RefId = field.NewInt64(tableName, "ref_id")
	_rechargeOrder.Domain = field.NewString(tableName, "domain")
	_rechargeOrder.ExpiredTime = field.NewInt64(tableName, "expired_time")

	_rechargeOrder.fillFieldMap()

	return _rechargeOrder
}

type rechargeOrder struct {
	rechargeOrderDo

	ALL             field.Asterisk
	ID              field.Int64
	CreatedAt       field.Int64
	UpdatedAt       field.Int64
	DeletedAt       field.Int64
	Ip              field.String
	UserAgent       field.String
	Fbc             field.String
	Fbp             field.String
	FacebookAdId    field.String
	SiteUrl         field.String
	Email           field.String
	Telephone       field.String
	UserID          field.Int64
	OrderNo         field.String
	OrderId         field.String
	Type            field.Int32
	ChannelID       field.Int64
	Amount          field.Float64
	Ratio           field.Float64
	Coin            field.String
	ReturnJson      field.String
	Status          field.Int32
	DepositTime     field.Uint32
	TransferReceipt field.String
	CustomerInfo    field.String
	VipLevel        field.Int32
	BankUpi         field.String
	ActualAmount    field.Float64
	GoonStatus      field.Int32
	DepositType     field.Int64
	RefId           field.Int64
	Domain          field.String
	ExpiredTime     field.Int64

	fieldMap map[string]field.Expr
}

func (r rechargeOrder) Table(newTableName string) *rechargeOrder {
	r.rechargeOrderDo.UseTable(newTableName)
	return r.updateTableName(newTableName)
}

func (r rechargeOrder) As(alias string) *rechargeOrder {
	r.rechargeOrderDo.DO = *(r.rechargeOrderDo.As(alias).(*gen.DO))
	return r.updateTableName(alias)
}

func (r *rechargeOrder) updateTableName(table string) *rechargeOrder {
	r.ALL = field.NewAsterisk(table)
	r.ID = field.NewInt64(table, "id")
	r.CreatedAt = field.NewInt64(table, "created_at")
	r.UpdatedAt = field.NewInt64(table, "updated_at")
	r.DeletedAt = field.NewInt64(table, "deleted_at")
	r.Ip = field.NewString(table, "ip")
	r.UserAgent = field.NewString(table, "user_agent")
	r.Fbc = field.NewString(table, "fbc")
	r.Fbp = field.NewString(table, "fbp")
	r.FacebookAdId = field.NewString(table, "facebook_ad_id")
	r.SiteUrl = field.NewString(table, "site_url")
	r.Email = field.NewString(table, "email")
	r.Telephone = field.NewString(table, "telephone")
	r.UserID = field.NewInt64(table, "user_id")
	r.OrderNo = field.NewString(table, "order_no")
	r.OrderId = field.NewString(table, "order_id")
	r.Type = field.NewInt32(table, "type")
	r.ChannelID = field.NewInt64(table, "channel_id")
	r.Amount = field.NewFloat64(table, "amount")
	r.Ratio = field.NewFloat64(table, "ratio")
	r.Coin = field.NewString(table, "coin")
	r.ReturnJson = field.NewString(table, "return_json")
	r.Status = field.NewInt32(table, "status")
	r.DepositTime = field.NewUint32(table, "deposit_time")
	r.TransferReceipt = field.NewString(table, "transfer_receipt")
	r.CustomerInfo = field.NewString(table, "customer_info")
	r.VipLevel = field.NewInt32(table, "vip_level")
	r.BankUpi = field.NewString(table, "bank_upi")
	r.ActualAmount = field.NewFloat64(table, "actual_amount")
	r.GoonStatus = field.NewInt32(table, "goon_status")
	r.DepositType = field.NewInt64(table, "deposit_type")
	r.RefId = field.NewInt64(table, "ref_id")
	r.Domain = field.NewString(table, "domain")
	r.ExpiredTime = field.NewInt64(table, "expired_time")

	r.fillFieldMap()

	return r
}

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

func (r *rechargeOrder) fillFieldMap() {
	r.fieldMap = make(map[string]field.Expr, 33)
	r.fieldMap["id"] = r.ID
	r.fieldMap["created_at"] = r.CreatedAt
	r.fieldMap["updated_at"] = r.UpdatedAt
	r.fieldMap["deleted_at"] = r.DeletedAt
	r.fieldMap["ip"] = r.Ip
	r.fieldMap["user_agent"] = r.UserAgent
	r.fieldMap["fbc"] = r.Fbc
	r.fieldMap["fbp"] = r.Fbp
	r.fieldMap["facebook_ad_id"] = r.FacebookAdId
	r.fieldMap["site_url"] = r.SiteUrl
	r.fieldMap["email"] = r.Email
	r.fieldMap["telephone"] = r.Telephone
	r.fieldMap["user_id"] = r.UserID
	r.fieldMap["order_no"] = r.OrderNo
	r.fieldMap["order_id"] = r.OrderId
	r.fieldMap["type"] = r.Type
	r.fieldMap["channel_id"] = r.ChannelID
	r.fieldMap["amount"] = r.Amount
	r.fieldMap["ratio"] = r.Ratio
	r.fieldMap["coin"] = r.Coin
	r.fieldMap["return_json"] = r.ReturnJson
	r.fieldMap["status"] = r.Status
	r.fieldMap["deposit_time"] = r.DepositTime
	r.fieldMap["transfer_receipt"] = r.TransferReceipt
	r.fieldMap["customer_info"] = r.CustomerInfo
	r.fieldMap["vip_level"] = r.VipLevel
	r.fieldMap["bank_upi"] = r.BankUpi
	r.fieldMap["actual_amount"] = r.ActualAmount
	r.fieldMap["goon_status"] = r.GoonStatus
	r.fieldMap["deposit_type"] = r.DepositType
	r.fieldMap["ref_id"] = r.RefId
	r.fieldMap["domain"] = r.Domain
	r.fieldMap["expired_time"] = r.ExpiredTime
}

func (r rechargeOrder) clone(db *gorm.DB) rechargeOrder {
	r.rechargeOrderDo.ReplaceConnPool(db.Statement.ConnPool)
	return r
}

func (r rechargeOrder) replaceDB(db *gorm.DB) rechargeOrder {
	r.rechargeOrderDo.ReplaceDB(db)
	return r
}

type rechargeOrderDo struct{ gen.DO }

type IRechargeOrderDo interface {
	gen.SubQuery
	Debug() IRechargeOrderDo
	WithContext(ctx context.Context) IRechargeOrderDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IRechargeOrderDo
	WriteDB() IRechargeOrderDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IRechargeOrderDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IRechargeOrderDo
	Not(conds ...gen.Condition) IRechargeOrderDo
	Or(conds ...gen.Condition) IRechargeOrderDo
	Select(conds ...field.Expr) IRechargeOrderDo
	Where(conds ...gen.Condition) IRechargeOrderDo
	Order(conds ...field.Expr) IRechargeOrderDo
	Distinct(cols ...field.Expr) IRechargeOrderDo
	Omit(cols ...field.Expr) IRechargeOrderDo
	Join(table schema.Tabler, on ...field.Expr) IRechargeOrderDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IRechargeOrderDo
	RightJoin(table schema.Tabler, on ...field.Expr) IRechargeOrderDo
	Group(cols ...field.Expr) IRechargeOrderDo
	Having(conds ...gen.Condition) IRechargeOrderDo
	Limit(limit int) IRechargeOrderDo
	Offset(offset int) IRechargeOrderDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IRechargeOrderDo
	Unscoped() IRechargeOrderDo
	Create(values ...*recharge.RechargeOrder) error
	CreateInBatches(values []*recharge.RechargeOrder, batchSize int) error
	Save(values ...*recharge.RechargeOrder) error
	First() (*recharge.RechargeOrder, error)
	Take() (*recharge.RechargeOrder, error)
	Last() (*recharge.RechargeOrder, error)
	Find() ([]*recharge.RechargeOrder, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*recharge.RechargeOrder, err error)
	FindInBatches(result *[]*recharge.RechargeOrder, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*recharge.RechargeOrder) (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) IRechargeOrderDo
	Assign(attrs ...field.AssignExpr) IRechargeOrderDo
	Joins(fields ...field.RelationField) IRechargeOrderDo
	Preload(fields ...field.RelationField) IRechargeOrderDo
	FirstOrInit() (*recharge.RechargeOrder, error)
	FirstOrCreate() (*recharge.RechargeOrder, error)
	FindByPage(offset int, limit int) (result []*recharge.RechargeOrder, 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) IRechargeOrderDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

func (r rechargeOrderDo) Debug() IRechargeOrderDo {
	return r.withDO(r.DO.Debug())
}

func (r rechargeOrderDo) WithContext(ctx context.Context) IRechargeOrderDo {
	return r.withDO(r.DO.WithContext(ctx))
}

func (r rechargeOrderDo) ReadDB() IRechargeOrderDo {
	return r.Clauses(dbresolver.Read)
}

func (r rechargeOrderDo) WriteDB() IRechargeOrderDo {
	return r.Clauses(dbresolver.Write)
}

func (r rechargeOrderDo) Session(config *gorm.Session) IRechargeOrderDo {
	return r.withDO(r.DO.Session(config))
}

func (r rechargeOrderDo) Clauses(conds ...clause.Expression) IRechargeOrderDo {
	return r.withDO(r.DO.Clauses(conds...))
}

func (r rechargeOrderDo) Returning(value interface{}, columns ...string) IRechargeOrderDo {
	return r.withDO(r.DO.Returning(value, columns...))
}

func (r rechargeOrderDo) Not(conds ...gen.Condition) IRechargeOrderDo {
	return r.withDO(r.DO.Not(conds...))
}

func (r rechargeOrderDo) Or(conds ...gen.Condition) IRechargeOrderDo {
	return r.withDO(r.DO.Or(conds...))
}

func (r rechargeOrderDo) Select(conds ...field.Expr) IRechargeOrderDo {
	return r.withDO(r.DO.Select(conds...))
}

func (r rechargeOrderDo) Where(conds ...gen.Condition) IRechargeOrderDo {
	return r.withDO(r.DO.Where(conds...))
}

func (r rechargeOrderDo) Order(conds ...field.Expr) IRechargeOrderDo {
	return r.withDO(r.DO.Order(conds...))
}

func (r rechargeOrderDo) Distinct(cols ...field.Expr) IRechargeOrderDo {
	return r.withDO(r.DO.Distinct(cols...))
}

func (r rechargeOrderDo) Omit(cols ...field.Expr) IRechargeOrderDo {
	return r.withDO(r.DO.Omit(cols...))
}

func (r rechargeOrderDo) Join(table schema.Tabler, on ...field.Expr) IRechargeOrderDo {
	return r.withDO(r.DO.Join(table, on...))
}

func (r rechargeOrderDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechargeOrderDo {
	return r.withDO(r.DO.LeftJoin(table, on...))
}

func (r rechargeOrderDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechargeOrderDo {
	return r.withDO(r.DO.RightJoin(table, on...))
}

func (r rechargeOrderDo) Group(cols ...field.Expr) IRechargeOrderDo {
	return r.withDO(r.DO.Group(cols...))
}

func (r rechargeOrderDo) Having(conds ...gen.Condition) IRechargeOrderDo {
	return r.withDO(r.DO.Having(conds...))
}

func (r rechargeOrderDo) Limit(limit int) IRechargeOrderDo {
	return r.withDO(r.DO.Limit(limit))
}

func (r rechargeOrderDo) Offset(offset int) IRechargeOrderDo {
	return r.withDO(r.DO.Offset(offset))
}

func (r rechargeOrderDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechargeOrderDo {
	return r.withDO(r.DO.Scopes(funcs...))
}

func (r rechargeOrderDo) Unscoped() IRechargeOrderDo {
	return r.withDO(r.DO.Unscoped())
}

func (r rechargeOrderDo) Create(values ...*recharge.RechargeOrder) error {
	if len(values) == 0 {
		return nil
	}
	return r.DO.Create(values)
}

func (r rechargeOrderDo) CreateInBatches(values []*recharge.RechargeOrder, batchSize int) error {
	return r.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 (r rechargeOrderDo) Save(values ...*recharge.RechargeOrder) error {
	if len(values) == 0 {
		return nil
	}
	return r.DO.Save(values)
}

func (r rechargeOrderDo) First() (*recharge.RechargeOrder, error) {
	if result, err := r.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*recharge.RechargeOrder), nil
	}
}

func (r rechargeOrderDo) Take() (*recharge.RechargeOrder, error) {
	if result, err := r.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*recharge.RechargeOrder), nil
	}
}

func (r rechargeOrderDo) Last() (*recharge.RechargeOrder, error) {
	if result, err := r.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*recharge.RechargeOrder), nil
	}
}

func (r rechargeOrderDo) Find() ([]*recharge.RechargeOrder, error) {
	result, err := r.DO.Find()
	return result.([]*recharge.RechargeOrder), err
}

func (r rechargeOrderDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*recharge.RechargeOrder, err error) {
	buf := make([]*recharge.RechargeOrder, 0, batchSize)
	err = r.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 (r rechargeOrderDo) FindInBatches(result *[]*recharge.RechargeOrder, batchSize int, fc func(tx gen.Dao, batch int) error) error {
	return r.DO.FindInBatches(result, batchSize, fc)
}

func (r rechargeOrderDo) Attrs(attrs ...field.AssignExpr) IRechargeOrderDo {
	return r.withDO(r.DO.Attrs(attrs...))
}

func (r rechargeOrderDo) Assign(attrs ...field.AssignExpr) IRechargeOrderDo {
	return r.withDO(r.DO.Assign(attrs...))
}

func (r rechargeOrderDo) Joins(fields ...field.RelationField) IRechargeOrderDo {
	for _, _f := range fields {
		r = *r.withDO(r.DO.Joins(_f))
	}
	return &r
}

func (r rechargeOrderDo) Preload(fields ...field.RelationField) IRechargeOrderDo {
	for _, _f := range fields {
		r = *r.withDO(r.DO.Preload(_f))
	}
	return &r
}

func (r rechargeOrderDo) FirstOrInit() (*recharge.RechargeOrder, error) {
	if result, err := r.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*recharge.RechargeOrder), nil
	}
}

func (r rechargeOrderDo) FirstOrCreate() (*recharge.RechargeOrder, error) {
	if result, err := r.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*recharge.RechargeOrder), nil
	}
}

func (r rechargeOrderDo) FindByPage(offset int, limit int) (result []*recharge.RechargeOrder, count int64, err error) {
	result, err = r.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 = r.Offset(-1).Limit(-1).Count()
	return
}

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

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

func (r rechargeOrderDo) Scan(result interface{}) (err error) {
	return r.DO.Scan(result)
}

func (r rechargeOrderDo) Delete(models ...*recharge.RechargeOrder) (result gen.ResultInfo, err error) {
	return r.DO.Delete(models)
}

func (r *rechargeOrderDo) withDO(do gen.Dao) *rechargeOrderDo {
	r.DO = *do.(*gen.DO)
	return r
}