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

	"git.rtzhtech.cn/iss/public-lib/model"
)

func newAlarmEvent(db *gorm.DB) alarmEvent {
	_alarmEvent := alarmEvent{}

	_alarmEvent.alarmEventDo.UseDB(db)
	_alarmEvent.alarmEventDo.UseModel(&model.AlarmEvent{})

	tableName := _alarmEvent.alarmEventDo.TableName()
	_alarmEvent.ALL = field.NewField(tableName, "*")
	_alarmEvent.ID = field.NewInt32(tableName, "id")
	_alarmEvent.Eventid = field.NewInt64(tableName, "eventid")
	_alarmEvent.Subeventid = field.NewInt64(tableName, "subeventid")
	_alarmEvent.Eventdesc = field.NewString(tableName, "eventdesc")
	_alarmEvent.Eventtype = field.NewInt32(tableName, "eventtype")
	_alarmEvent.Timestamp = field.NewInt64(tableName, "timestamp")
	_alarmEvent.Strategyid = field.NewInt64(tableName, "strategyid")
	_alarmEvent.Confirm = field.NewInt32(tableName, "confirm")
	_alarmEvent.Confirmtime = field.NewTime(tableName, "confirmtime")
	_alarmEvent.Result = field.NewString(tableName, "result")
	_alarmEvent.Appid = field.NewInt32(tableName, "appid")
	_alarmEvent.CreateAt = field.NewTime(tableName, "create_at")
	_alarmEvent.UpdateAt = field.NewTime(tableName, "update_at")

	_alarmEvent.fillFieldMap()

	_alarmEvent.Base = newBase(tableName, db)

	return _alarmEvent
}

type alarmEvent struct {
	alarmEventDo

	ALL         field.Field
	ID          field.Int32
	Eventid     field.Int64
	Subeventid  field.Int64
	Eventdesc   field.String
	Eventtype   field.Int32
	Timestamp   field.Int64
	Strategyid  field.Int64
	Confirm     field.Int32
	Confirmtime field.Time
	Result      field.String
	Appid       field.Int32
	CreateAt    field.Time
	UpdateAt    field.Time

	fieldMap map[string]field.Expr
}

func (a alarmEvent) Table(newTableName string) *alarmEvent {
	a.alarmEventDo.UseTable(newTableName)
	return a.updateTableName(newTableName)
}

func (a alarmEvent) As(alias string) *alarmEvent {
	a.alarmEventDo.DO = *(a.alarmEventDo.As(alias).(*gen.DO))
	return a.updateTableName(alias)
}

func (a *alarmEvent) updateTableName(table string) *alarmEvent {
	a.ALL = field.NewField(table, "*")
	a.ID = field.NewInt32(table, "id")
	a.Eventid = field.NewInt64(table, "eventid")
	a.Subeventid = field.NewInt64(table, "subeventid")
	a.Eventdesc = field.NewString(table, "eventdesc")
	a.Eventtype = field.NewInt32(table, "eventtype")
	a.Timestamp = field.NewInt64(table, "timestamp")
	a.Strategyid = field.NewInt64(table, "strategyid")
	a.Confirm = field.NewInt32(table, "confirm")
	a.Confirmtime = field.NewTime(table, "confirmtime")
	a.Result = field.NewString(table, "result")
	a.Appid = field.NewInt32(table, "appid")
	a.CreateAt = field.NewTime(table, "create_at")
	a.UpdateAt = field.NewTime(table, "update_at")

	a.fillFieldMap()

	return a
}

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

func (a *alarmEvent) fillFieldMap() {
	a.fieldMap = make(map[string]field.Expr, 13)
	a.fieldMap["id"] = a.ID
	a.fieldMap["eventid"] = a.Eventid
	a.fieldMap["subeventid"] = a.Subeventid
	a.fieldMap["eventdesc"] = a.Eventdesc
	a.fieldMap["eventtype"] = a.Eventtype
	a.fieldMap["timestamp"] = a.Timestamp
	a.fieldMap["strategyid"] = a.Strategyid
	a.fieldMap["confirm"] = a.Confirm
	a.fieldMap["confirmtime"] = a.Confirmtime
	a.fieldMap["result"] = a.Result
	a.fieldMap["appid"] = a.Appid
	a.fieldMap["create_at"] = a.CreateAt
	a.fieldMap["update_at"] = a.UpdateAt
}

func (a alarmEvent) clone(db *gorm.DB) alarmEvent {
	a.alarmEventDo.ReplaceDB(db)
	return a
}

type alarmEventDo struct {
	gen.DO
	Base *Base
}

func (a alarmEventDo) Debug() *alarmEventDo {
	return a.withDO(a.DO.Debug())
}

func (a alarmEventDo) WithContext(ctx context.Context) *alarmEventDo {
	return a.withDO(a.DO.WithContext(ctx))
}

func (a alarmEventDo) ReadDB() *alarmEventDo {
	return a.Clauses(dbresolver.Read)
}

func (a alarmEventDo) WriteDB() *alarmEventDo {
	return a.Clauses(dbresolver.Write)
}

func (a alarmEventDo) Clauses(conds ...clause.Expression) *alarmEventDo {
	return a.withDO(a.DO.Clauses(conds...))
}

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

func (a alarmEventDo) Not(conds ...gen.Condition) *alarmEventDo {
	return a.withDO(a.DO.Not(conds...))
}

func (a alarmEventDo) Or(conds ...gen.Condition) *alarmEventDo {
	return a.withDO(a.DO.Or(conds...))
}

func (a alarmEventDo) Select(conds ...field.Expr) *alarmEventDo {
	return a.withDO(a.DO.Select(conds...))
}

func (a alarmEventDo) Where(conds ...gen.Condition) *alarmEventDo {
	return a.withDO(a.DO.Where(conds...))
}

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

func (a alarmEventDo) Order(conds ...field.Expr) *alarmEventDo {
	return a.withDO(a.DO.Order(conds...))
}

func (a alarmEventDo) Distinct(cols ...field.Expr) *alarmEventDo {
	return a.withDO(a.DO.Distinct(cols...))
}

func (a alarmEventDo) Omit(cols ...field.Expr) *alarmEventDo {
	return a.withDO(a.DO.Omit(cols...))
}

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

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

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

func (a alarmEventDo) Group(cols ...field.Expr) *alarmEventDo {
	return a.withDO(a.DO.Group(cols...))
}

func (a alarmEventDo) Having(conds ...gen.Condition) *alarmEventDo {
	return a.withDO(a.DO.Having(conds...))
}

func (a alarmEventDo) Limit(limit int) *alarmEventDo {
	return a.withDO(a.DO.Limit(limit))
}

func (a alarmEventDo) Offset(offset int) *alarmEventDo {
	return a.withDO(a.DO.Offset(offset))
}

func (a alarmEventDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *alarmEventDo {
	return a.withDO(a.DO.Scopes(funcs...))
}

func (a alarmEventDo) Unscoped() *alarmEventDo {
	return a.withDO(a.DO.Unscoped())
}

func (a alarmEventDo) Create(values ...*model.AlarmEvent) error {
	if len(values) == 0 {
		return nil
	}
	return a.DO.Create(values)
}

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

func (a alarmEventDo) First() (*model.AlarmEvent, error) {
	if result, err := a.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*model.AlarmEvent), nil
	}
}

func (a alarmEventDo) Take() (*model.AlarmEvent, error) {
	if result, err := a.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*model.AlarmEvent), nil
	}
}

func (a alarmEventDo) Last() (*model.AlarmEvent, error) {
	if result, err := a.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*model.AlarmEvent), nil
	}
}

func (a alarmEventDo) Find() ([]*model.AlarmEvent, error) {
	result, err := a.DO.Find()
	return result.([]*model.AlarmEvent), err
}

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

func (a alarmEventDo) Attrs(attrs ...field.AssignExpr) *alarmEventDo {
	return a.withDO(a.DO.Attrs(attrs...))
}

func (a alarmEventDo) Assign(attrs ...field.AssignExpr) *alarmEventDo {
	return a.withDO(a.DO.Assign(attrs...))
}

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

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

func (a alarmEventDo) FirstOrInit() (*model.AlarmEvent, error) {
	if result, err := a.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*model.AlarmEvent), nil
	}
}

func (a alarmEventDo) FirstOrCreate() (*model.AlarmEvent, error) {
	if result, err := a.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*model.AlarmEvent), nil
	}
}

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

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

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

func (a alarmEventDo) Scan(result interface{}) (err error) {
	return a.DO.Scan(result)
}

func (a alarmEventDo) Delete(models ...*model.AlarmEvent) (result gen.ResultInfo, err error) {
	return a.DO.Delete(models)
}

func (a *alarmEventDo) withDO(do gen.Dao) *alarmEventDo {
	a.DO = *do.(*gen.DO)
	return a
}