db

type AllDatabases struct {
	// contains filtered or unexported fields
}

type BetweenFields struct {
	FromField string
	ToField   string
	Value     interface{}
	FromOpen  bool
	ToOpen    bool
}

type Cursor interface {
	Next(ctx logger.WithLogger) (bool, error)
	Close(ctx logger.WithLogger) error
	Scan(ctx logger.WithLogger, obj interface{}) error
}

type DB interface {
	WithFilterParser

	ID() string
	Clone() DB

	InitWithConfig(ctx logger.WithLogger, vld validator.Validator, cfg *DBConfig) error

	DBHandlers

	EnableVerboseErrors(bool)

	AutoMigrate(ctx logger.WithLogger, models []interface{}) error
	MigrateDropIndex(ctx logger.WithLogger, model interface{}, indexName string) error

	PartitionedMonthAutoMigrate(ctx logger.WithLogger, models []interface{}) error
	PartitionedMonthsDetach(ctx logger.WithLogger, table string, months []utils.Month) error
	PartitionedMonthsDelete(ctx logger.WithLogger, table string, months []utils.Month) error

	NativeHandler() interface{}

	Close()
}

type DBConfig struct {
	DB_PROVIDER     string `gorm:"index"`
	DB_HOST         string `gorm:"index"`
	DB_PORT         uint16 `gorm:"index"`
	DB_NAME         string `gorm:"index"`
	DB_USER         string `gorm:"index"`
	DB_PASSWORD     string `mask:"true"`
	DB_EXTRA_CONFIG string
	DB_DSN          string
}

type DBHandlers interface {
	FindByField(ctx logger.WithLogger, field string, value interface{}, obj interface{}, dest ...interface{}) (found bool, err error)
	FindByFields(ctx logger.WithLogger, fields Fields, obj interface{}, dest ...interface{}) (found bool, err error)
	FindWithFilter(ctx logger.WithLogger, filter *Filter, docs interface{}, dest ...interface{}) (int64, error)
	FindForUpdate(ctx logger.WithLogger, fields Fields, obj interface{}) (bool, error)
	FindForShare(ctx logger.WithLogger, fields Fields, obj interface{}) (bool, error)
	Exists(ctx logger.WithLogger, filter *Filter, doc interface{}) (bool, error)

	Create(ctx logger.WithLogger, obj interface{}) error
	CreateDup(ctx logger.WithLogger, obj interface{}, ignoreConflict ...bool) (bool, error)

	Delete(ctx logger.WithLogger, obj common.Object) error
	DeleteByField(ctx logger.WithLogger, field string, value interface{}, model interface{}) error
	DeleteByFields(ctx logger.WithLogger, fields Fields, obj interface{}) error

	RowsWithFilter(ctx logger.WithLogger, filter *Filter, obj interface{}) (Cursor, error)
	AllRows(ctx logger.WithLogger, obj interface{}) (Cursor, error)

	Update(ctx logger.WithLogger, obj interface{}, filter Fields, fields Fields) error
	UpdateAll(ctx logger.WithLogger, obj interface{}, newFields Fields) error
	UpdateWithFilter(ctx logger.WithLogger, obj interface{}, filter *Filter, newFields Fields) error

	Join(ctx logger.WithLogger, joinConfig *JoinQueryConfig, filter *Filter, dest interface{}) (int64, error)

	Joiner() Joiner

	CreateDatabase(ctx logger.WithLogger, dbName string) error
	MakeExpression(expr string, args ...interface{}) interface{}

	Sum(ctx logger.WithLogger, groupFields []string, sumFields []string, filter *Filter, model interface{}, dest ...interface{}) (int64, error)

	Transaction(handler TransactionHandler) error
	EnableDebug(bool)
}

type Fields = map[string]interface{}

type Filter struct {
	FilterConfig
	Fields        Fields
	FieldsIn      map[string][]interface{}
	FieldsNotIn   map[string][]interface{}
	Intervals     map[string]*Interval
	BetweenFields []*BetweenFields
	OrFields      []*OrFields

	PresetFields []Fields

	NoLimit bool
}

type FilterConfig struct {
	SortField     string `json:"sort_field,omitempty"`
	SortDirection string `json:"sort_direction,omitempty" validate:"omitempty,oneof=ASC DESC" vmessage:"Sort direction can be either ASC or DESC"`
	Offset        int    `json:"offset,omitempty" validate:"gte=0" vmessage:"Offset can not be negative"`
	Limit         int    `json:"limit,omitempty" validate:"gte=0" vmessage:"Limit can not be negative"`
	Count         bool   `json:"count,omitempty"`
}

type FilterParser interface {
	Parse(query *Query) (*Filter, error)
}

type FilterValidator struct {
	Validator       validator.Validator
	Rules           map[string]string
	PlainFieldNames bool
}

type Interval struct {
	From     interface{}
	To       interface{}
	FromOpen bool
	ToOpen   bool
}

type JoinBegin interface {
	On(model interface{}, field string) JoinEnd
}

type JoinEnd interface {
	Joiner
	Sum(groupFields []string, sumFields []string) JoinEnd
	Destination(dst interface{}) (JoinQuery, error)
}

type JoinPairBase struct {
	JoinPairData
}

type JoinPairData struct {
	LeftField  string
	RightField string
}

type JoinQueries struct {
	// contains filtered or unexported fields
}

type JoinQuery interface {
	Join(ctx logger.WithLogger, filter *Filter, dest interface{}) (int64, error)
}

type JoinQueryBase struct {
	JoinQueryData
}

type JoinQueryBuilder = func() (JoinQuery, error)

type JoinQueryConfig struct {
	Builder JoinQueryBuilder
	Name    string
	Nocache bool
}

type JoinQueryData struct {
	// contains filtered or unexported fields
}

type JoinTableBase struct {
	JoinTableData
}

type JoinTableData struct {
	Model interface{}
}

type Joiner interface {
	Join(model interface{}, field string) JoinBegin
}

type ModelStore interface {
	RegisterModel(model interface{})
	FindModel(name string) interface{}
	AllModels() []interface{}
}

type MonthPartition struct {
	common.ObjectBase
	Table string      `gorm:"index;uniqueIndex:u_month_partition"`
	Month utils.Month `gorm:"index;uniqueIndex:u_month_partition"`
}

type OrFields struct {
	Value  interface{}
	Fields []string
}

type Query struct {
	FilterConfig

	Fields        map[string]string        `json:"fields,omitempty"`
	FieldsIn      map[string][]string      `json:"fields_in,omitempty"`
	FieldsNotIn   map[string][]string      `json:"fields_not_in,omitempty"`
	Intervals     map[string]QueryInterval `json:"intervals,omitempty"`
	BetweenFields []QueryBetweenFields     `json:"betwees_fields,omitempty"`
	OrFields      []QueryOrFields          `json:"or_fields,omitempty"`
}

type QueryBetweenFields struct {
	FromField string `json:"from_field,omitempty"`
	ToField   string `json:"to_field,omitempty"`
	Value     string `json:"value"`
	FromOpen  bool   `json:"from_open,omitempty"`
	ToOpen    bool   `json:"to_open,omitempty"`
}

type QueryInterval struct {
	From     optional.String `json:"from,omitempty"`
	To       optional.String `json:"to,omitempty"`
	FromOpen bool            `json:"from_open,omitempty"`
	ToOpen   bool            `json:"to_open,omitempty"`
}

type QueryOrFields struct {
	Value  string   `json:"value"`
	Fields []string `json:"fields"`
}

type Transaction interface {
	DBHandlers
}

type TransactionHandler = func(tx Transaction) error

type WithDB interface {
	Db() DB
}

type WithDBBase struct {
	// contains filtered or unexported fields
}

type WithFilterParser interface {
	PrepareFilterParser(model interface{}, name string, validator ...*FilterValidator) (FilterParser, error)
	ParseFilter(query *Query, parserName string) (*Filter, error)
	ParseFilterDirect(query *Query, model interface{}, name string, validator ...*FilterValidator) (*Filter, error)
}