// 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 dao

import (
	"context"

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

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

	"gorm.io/plugin/dbresolver"

	"joybuywork/internal/repository/model"
)

func newFissionUser(db *gorm.DB, opts ...gen.DOOption) fissionUser {
	_fissionUser := fissionUser{}

	_fissionUser.fissionUserDo.UseDB(db, opts...)
	_fissionUser.fissionUserDo.UseModel(&model.FissionUser{})

	tableName := _fissionUser.fissionUserDo.TableName()
	_fissionUser.ALL = field.NewAsterisk(tableName)
	_fissionUser.ID = field.NewInt64(tableName, "id")
	_fissionUser.CreatedAt = field.NewInt64(tableName, "created_at")
	_fissionUser.UpdatedAt = field.NewInt64(tableName, "updated_at")
	_fissionUser.IsDel = field.NewInt8(tableName, "is_del")
	_fissionUser.HashID = field.NewString(tableName, "hash_id")
	_fissionUser.CampaignID = field.NewInt64(tableName, "campaign_id")
	_fissionUser.ChannelID = field.NewInt64(tableName, "channel_id")
	_fissionUser.ParentID = field.NewInt64(tableName, "parent_id")
	_fissionUser.Deep = field.NewInt32(tableName, "deep")
	_fissionUser.IsNew = field.NewInt8(tableName, "is_new")
	_fissionUser.SubUserID = field.NewString(tableName, "sub_user_id")
	_fissionUser.DeviceID = field.NewString(tableName, "device_id")
	_fissionUser.UserMark = field.NewString(tableName, "user_mark")
	_fissionUser.UserType = field.NewInt8(tableName, "user_type")
	_fissionUser.ParentIds = field.NewString(tableName, "parent_ids")
	_fissionUser.IsView = field.NewInt8(tableName, "is_view")
	_fissionUser.ShareLink = field.NewString(tableName, "share_link")
	_fissionUser.Source = field.NewInt8(tableName, "source")
	_fissionUser.IsHelp = field.NewInt8(tableName, "is_help")
	_fissionUser.LangMark = field.NewString(tableName, "lang_mark")
	_fissionUser.LevelMark = field.NewString(tableName, "level_mark")
	_fissionUser.UserLevelMark = field.NewString(tableName, "user_level_mark")
	_fissionUser.UserLevel = field.NewInt64(tableName, "user_level")
	_fissionUser.FixedUserLevel = field.NewInt8(tableName, "fixed_user_level")
	_fissionUser.UserLang = field.NewString(tableName, "user_lang")
	_fissionUser.UserCountry = field.NewString(tableName, "user_country")
	_fissionUser.JoinAt = field.NewInt64(tableName, "join_at")
	_fissionUser.InstallAt = field.NewInt64(tableName, "install_at")
	_fissionUser.RegisterAt = field.NewInt64(tableName, "register_at")

	_fissionUser.fillFieldMap()

	return _fissionUser
}

type fissionUser struct {
	fissionUserDo fissionUserDo

	ALL            field.Asterisk
	ID             field.Int64
	CreatedAt      field.Int64
	UpdatedAt      field.Int64
	IsDel          field.Int8   // 是否已删除（1-是，0-否）
	HashID         field.String // 对外hash_id
	CampaignID     field.Int64  // 活动ID（campaign表主键）
	ChannelID      field.Int64  // 渠道id（fission_campaign_channel表）
	ParentID       field.Int64  // 上级ID
	Deep           field.Int32  // 推广深度
	IsNew          field.Int8   // 是否新安装用户（1-是，0-否）
	SubUserID      field.String // 关注用户ID
	DeviceID       field.String // 设备ID
	UserMark       field.String // 用户标识（当sub_user_id为空取device_id）
	UserType       field.Int8   // 用户类型（1-访客，2-参与用户）
	ParentIds      field.String // 祖上ID（父级以上，不包括父级）
	IsView         field.Int8   // 是否为预览用户（1-是，0-否）
	ShareLink      field.String // 分享链接
	Source         field.Int8   // 来源（1-直接访问，2-打开事件，3-安装事件，4-注册事件，5-自定义事件，6-动态下载页，7-网页端首次打开，8-支付事件）
	IsHelp         field.Int8   // 是否助力成功（0-否，1-是）
	LangMark       field.String // 活动语言标识
	LevelMark      field.String // 请求带过来的等级标识
	UserLevelMark  field.String // 用户等级标识
	UserLevel      field.Int64  // 用户等级id标识
	FixedUserLevel field.Int8   // 用户等级是否已经固定（0-否，1-是）
	UserLang       field.String // 用户语言标识
	UserCountry    field.String // 用户国家标识
	JoinAt         field.Int64  // 进入活动的时间
	InstallAt      field.Int64  // 首次安装时间
	RegisterAt     field.Int64  // 首次注册时间

	fieldMap map[string]field.Expr
}

func (f fissionUser) Table(newTableName string) *fissionUser {
	f.fissionUserDo.UseTable(newTableName)
	return f.updateTableName(newTableName)
}

func (f fissionUser) As(alias string) *fissionUser {
	f.fissionUserDo.DO = *(f.fissionUserDo.As(alias).(*gen.DO))
	return f.updateTableName(alias)
}

func (f *fissionUser) updateTableName(table string) *fissionUser {
	f.ALL = field.NewAsterisk(table)
	f.ID = field.NewInt64(table, "id")
	f.CreatedAt = field.NewInt64(table, "created_at")
	f.UpdatedAt = field.NewInt64(table, "updated_at")
	f.IsDel = field.NewInt8(table, "is_del")
	f.HashID = field.NewString(table, "hash_id")
	f.CampaignID = field.NewInt64(table, "campaign_id")
	f.ChannelID = field.NewInt64(table, "channel_id")
	f.ParentID = field.NewInt64(table, "parent_id")
	f.Deep = field.NewInt32(table, "deep")
	f.IsNew = field.NewInt8(table, "is_new")
	f.SubUserID = field.NewString(table, "sub_user_id")
	f.DeviceID = field.NewString(table, "device_id")
	f.UserMark = field.NewString(table, "user_mark")
	f.UserType = field.NewInt8(table, "user_type")
	f.ParentIds = field.NewString(table, "parent_ids")
	f.IsView = field.NewInt8(table, "is_view")
	f.ShareLink = field.NewString(table, "share_link")
	f.Source = field.NewInt8(table, "source")
	f.IsHelp = field.NewInt8(table, "is_help")
	f.LangMark = field.NewString(table, "lang_mark")
	f.LevelMark = field.NewString(table, "level_mark")
	f.UserLevelMark = field.NewString(table, "user_level_mark")
	f.UserLevel = field.NewInt64(table, "user_level")
	f.FixedUserLevel = field.NewInt8(table, "fixed_user_level")
	f.UserLang = field.NewString(table, "user_lang")
	f.UserCountry = field.NewString(table, "user_country")
	f.JoinAt = field.NewInt64(table, "join_at")
	f.InstallAt = field.NewInt64(table, "install_at")
	f.RegisterAt = field.NewInt64(table, "register_at")

	f.fillFieldMap()

	return f
}

func (f *fissionUser) WithContext(ctx context.Context) *fissionUserDo {
	return f.fissionUserDo.WithContext(ctx)
}

func (f fissionUser) TableName() string { return f.fissionUserDo.TableName() }

func (f fissionUser) Alias() string { return f.fissionUserDo.Alias() }

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

func (f *fissionUser) fillFieldMap() {
	f.fieldMap = make(map[string]field.Expr, 29)
	f.fieldMap["id"] = f.ID
	f.fieldMap["created_at"] = f.CreatedAt
	f.fieldMap["updated_at"] = f.UpdatedAt
	f.fieldMap["is_del"] = f.IsDel
	f.fieldMap["hash_id"] = f.HashID
	f.fieldMap["campaign_id"] = f.CampaignID
	f.fieldMap["channel_id"] = f.ChannelID
	f.fieldMap["parent_id"] = f.ParentID
	f.fieldMap["deep"] = f.Deep
	f.fieldMap["is_new"] = f.IsNew
	f.fieldMap["sub_user_id"] = f.SubUserID
	f.fieldMap["device_id"] = f.DeviceID
	f.fieldMap["user_mark"] = f.UserMark
	f.fieldMap["user_type"] = f.UserType
	f.fieldMap["parent_ids"] = f.ParentIds
	f.fieldMap["is_view"] = f.IsView
	f.fieldMap["share_link"] = f.ShareLink
	f.fieldMap["source"] = f.Source
	f.fieldMap["is_help"] = f.IsHelp
	f.fieldMap["lang_mark"] = f.LangMark
	f.fieldMap["level_mark"] = f.LevelMark
	f.fieldMap["user_level_mark"] = f.UserLevelMark
	f.fieldMap["user_level"] = f.UserLevel
	f.fieldMap["fixed_user_level"] = f.FixedUserLevel
	f.fieldMap["user_lang"] = f.UserLang
	f.fieldMap["user_country"] = f.UserCountry
	f.fieldMap["join_at"] = f.JoinAt
	f.fieldMap["install_at"] = f.InstallAt
	f.fieldMap["register_at"] = f.RegisterAt
}

func (f fissionUser) clone(db *gorm.DB) fissionUser {
	f.fissionUserDo.ReplaceConnPool(db.Statement.ConnPool)
	return f
}

func (f fissionUser) replaceDB(db *gorm.DB) fissionUser {
	f.fissionUserDo.ReplaceDB(db)
	return f
}

type fissionUserDo struct{ gen.DO }

func (f fissionUserDo) Debug() *fissionUserDo {
	return f.withDO(f.DO.Debug())
}

func (f fissionUserDo) WithContext(ctx context.Context) *fissionUserDo {
	return f.withDO(f.DO.WithContext(ctx))
}

func (f fissionUserDo) ReadDB() *fissionUserDo {
	return f.Clauses(dbresolver.Read)
}

func (f fissionUserDo) WriteDB() *fissionUserDo {
	return f.Clauses(dbresolver.Write)
}

func (f fissionUserDo) Session(config *gorm.Session) *fissionUserDo {
	return f.withDO(f.DO.Session(config))
}

func (f fissionUserDo) Clauses(conds ...clause.Expression) *fissionUserDo {
	return f.withDO(f.DO.Clauses(conds...))
}

func (f fissionUserDo) Returning(value interface{}, columns ...string) *fissionUserDo {
	return f.withDO(f.DO.Returning(value, columns...))
}

func (f fissionUserDo) Not(conds ...gen.Condition) *fissionUserDo {
	return f.withDO(f.DO.Not(conds...))
}

func (f fissionUserDo) Or(conds ...gen.Condition) *fissionUserDo {
	return f.withDO(f.DO.Or(conds...))
}

func (f fissionUserDo) Select(conds ...field.Expr) *fissionUserDo {
	return f.withDO(f.DO.Select(conds...))
}

func (f fissionUserDo) Where(conds ...gen.Condition) *fissionUserDo {
	return f.withDO(f.DO.Where(conds...))
}

func (f fissionUserDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) *fissionUserDo {
	return f.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
}

func (f fissionUserDo) Order(conds ...field.Expr) *fissionUserDo {
	return f.withDO(f.DO.Order(conds...))
}

func (f fissionUserDo) Distinct(cols ...field.Expr) *fissionUserDo {
	return f.withDO(f.DO.Distinct(cols...))
}

func (f fissionUserDo) Omit(cols ...field.Expr) *fissionUserDo {
	return f.withDO(f.DO.Omit(cols...))
}

func (f fissionUserDo) Join(table schema.Tabler, on ...field.Expr) *fissionUserDo {
	return f.withDO(f.DO.Join(table, on...))
}

func (f fissionUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) *fissionUserDo {
	return f.withDO(f.DO.LeftJoin(table, on...))
}

func (f fissionUserDo) RightJoin(table schema.Tabler, on ...field.Expr) *fissionUserDo {
	return f.withDO(f.DO.RightJoin(table, on...))
}

func (f fissionUserDo) Group(cols ...field.Expr) *fissionUserDo {
	return f.withDO(f.DO.Group(cols...))
}

func (f fissionUserDo) Having(conds ...gen.Condition) *fissionUserDo {
	return f.withDO(f.DO.Having(conds...))
}

func (f fissionUserDo) Limit(limit int) *fissionUserDo {
	return f.withDO(f.DO.Limit(limit))
}

func (f fissionUserDo) Offset(offset int) *fissionUserDo {
	return f.withDO(f.DO.Offset(offset))
}

func (f fissionUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *fissionUserDo {
	return f.withDO(f.DO.Scopes(funcs...))
}

func (f fissionUserDo) Unscoped() *fissionUserDo {
	return f.withDO(f.DO.Unscoped())
}

func (f fissionUserDo) Create(values ...*model.FissionUser) error {
	if len(values) == 0 {
		return nil
	}
	return f.DO.Create(values)
}

func (f fissionUserDo) CreateInBatches(values []*model.FissionUser, batchSize int) error {
	return f.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 (f fissionUserDo) Save(values ...*model.FissionUser) error {
	if len(values) == 0 {
		return nil
	}
	return f.DO.Save(values)
}

func (f fissionUserDo) First() (*model.FissionUser, error) {
	if result, err := f.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*model.FissionUser), nil
	}
}

func (f fissionUserDo) Take() (*model.FissionUser, error) {
	if result, err := f.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*model.FissionUser), nil
	}
}

func (f fissionUserDo) Last() (*model.FissionUser, error) {
	if result, err := f.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*model.FissionUser), nil
	}
}

func (f fissionUserDo) Find() ([]*model.FissionUser, error) {
	result, err := f.DO.Find()
	return result.([]*model.FissionUser), err
}

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

func (f fissionUserDo) Attrs(attrs ...field.AssignExpr) *fissionUserDo {
	return f.withDO(f.DO.Attrs(attrs...))
}

func (f fissionUserDo) Assign(attrs ...field.AssignExpr) *fissionUserDo {
	return f.withDO(f.DO.Assign(attrs...))
}

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

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

func (f fissionUserDo) FirstOrInit() (*model.FissionUser, error) {
	if result, err := f.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*model.FissionUser), nil
	}
}

func (f fissionUserDo) FirstOrCreate() (*model.FissionUser, error) {
	if result, err := f.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*model.FissionUser), nil
	}
}

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

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

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

func (f fissionUserDo) Scan(result interface{}) (err error) {
	return f.DO.Scan(result)
}

func (f fissionUserDo) Delete(models ...*model.FissionUser) (result gen.ResultInfo, err error) {
	return f.DO.Delete(models)
}

func (f *fissionUserDo) withDO(do gen.Dao) *fissionUserDo {
	f.DO = *do.(*gen.DO)
	return f
}