core

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

type ContextMock struct {
	mock.Mock
	MockRequester *MockRequester
	MockCache     *MockCache
	MockMQ        *MockMQ
	MockLog       *MockLogger
	MockDBMongo   *MockMongoDB
	MockDB        *MockDatabase
}

type ContextOptions struct {
	DB       *gorm.DB
	DBS      map[string]*gorm.DB
	MongoDB  IMongoDB
	MongoDBS map[string]IMongoDB
	Cache    ICache
	Caches   map[string]ICache
	ENV      IENV
	MQ       IMQ

	DATA map[string]interface{}
	// contains filtered or unexported fields
}

type ContextUser struct {
	ID       string            `json:"id,omitempty"`
	Email    string            `json:"email,omitempty"`
	Username string            `json:"username,omitempty"`
	Name     string            `json:"name,omitempty"`
	Segment  string            `json:"segment,omitempty"`
	Data     map[string]string `json:"data,omitempty"`
}

type CronjobContext struct {
	IContext
	// contains filtered or unexported fields
}

type CronjobContextOptions struct {
	ContextOptions *ContextOptions
	TimeLocation   *time.Location
}

type Database struct {
	Driver   string
	DSN      string
	Name     string
	Host     string
	User     string
	Password string
	Port     string
	// contains filtered or unexported fields
}

type DatabaseCache struct {
	Host string
	Port string
}

type DatabaseMongo struct {
	Name     string
	Host     string
	UserName string
	Password string
	Port     string
}

type E2EContext struct {
	IContext
}

type E2EContextOptions struct {
	ContextOptions *ContextOptions
}

type ELS struct {
	Address  string
	User     string
	Password string
}

type ELSCreateCreateOptions struct {
}

type ELSCreateIndexOptions struct {
}

type ELSCreateSearchOptions struct {
}

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

type ELSUpdateOptions struct {
}

type ENVConfig struct {
	LogLevel logrus.Level
	LogHost  string `mapstructure:"log_host"`

	Host    string `mapstructure:"host"`
	ENV     string `mapstructure:"env"`
	Service string `mapstructure:"service"`

	SentryDSN string `mapstructure:"sentry_dsn"`

	DBDriver   string `mapstructure:"db_driver"`
	DBDsn      string `mapstructure:"db_dsn"`
	DBHost     string `mapstructure:"db_host"`
	DBName     string `mapstructure:"db_name"`
	DBUser     string `mapstructure:"db_user"`
	DBPassword string `mapstructure:"db_password"`
	DBPort     string `mapstructure:"db_port"`

	DBMongoHost     string `mapstructure:"db_mongo_host"`
	DBMongoName     string `mapstructure:"db_mongo_name"`
	DBMongoUserName string `mapstructure:"db_mongo_username"`
	DBMongoPassword string `mapstructure:"db_mongo_password"`
	DBMongoPort     string `mapstructure:"db_mongo_port"`

	MQURI      string `mapstructure:"mq_uri"`
	MQHost     string `mapstructure:"mq_host"`
	MQUser     string `mapstructure:"mq_user"`
	MQPassword string `mapstructure:"mq_password"`
	MQPort     string `mapstructure:"mq_port"`

	S3Endpoint  string `mapstructure:"s3_endpoint"`
	S3AccessKey string `mapstructure:"s3_access_key"`
	S3SecretKey string `mapstructure:"s3_secret_key"`
	S3Bucket    string `mapstructure:"s3_bucket"`
	S3Region    string `mapstructure:"s3_region"`
	S3IsHTTPS   bool   `mapstructure:"s3_https"`

	CachePort string `mapstructure:"cache_port"`
	CacheHost string `mapstructure:"cache_host"`

	ELSAddress  string `mapstructure:"els_address"`
	ELSUser     string `mapstructure:"els_user"`
	ELSPassword string `mapstructure:"els_password"`
}

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

type Error struct {
	Status  int         `json:"-"`
	Code    string      `json:"code"`
	Message interface{} `json:"message"`
	Data    interface{} `json:"-"`
	Fields  interface{} `json:"fields,omitempty"`
	// contains filtered or unexported fields
}

type FieldError struct {
	Code    string      `json:"code"`
	Message string      `json:"message"`
	Fields  interface{} `json:"fields,omitempty"`
}

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

type HTTPContext struct {
	echo.Context
	IContext
	// contains filtered or unexported fields
}

type HTTPContextOptions struct {
	ContextOptions *ContextOptions
}

type HandlerFunc func(IHTTPContext) error

type ICache interface {
	Set(key string, value interface{}, expiration time.Duration) error
	SetJSON(key string, value interface{}, expiration time.Duration) error
	Get(dest interface{}, key string) error
	GetJSON(dest interface{}, key string) error
	Del(key string) error
	Close()
}

type IContext interface {
	MQ() IMQ
	DB() *gorm.DB
	DBS(name string) *gorm.DB
	DBMongo() IMongoDB
	DBSMongo(name string) IMongoDB
	ENV() IENV
	Log() ILogger
	Type() consts.ContextType
	NewError(err error, errorType IError, args ...interface{}) IError
	Requester() IRequester
	Cache() ICache
	Caches(name string) ICache
	GetData(name string) interface{}
	GetAllData() map[string]interface{}
	SetData(name string, data interface{})
	SetUser(user *ContextUser)
	GetUser() *ContextUser
}

type ICronjobContext interface {
	IContext
	Job() *gocron.Scheduler
	Start()
	AddJob(job *gocron.Scheduler, handlerFunc func(ctx ICronjobContext) error)
}

type IE2EContext interface {
	IContext
}

type IELS interface {
	Client() *elasticsearch.Client
	CreateIndex(name string, body map[string]interface{}, options *ELSCreateIndexOptions) error
	Create(dest interface{}, index string, id string, body interface{}, options *ELSCreateIndexOptions) (*esapi.Response, error)
	CreateOrUpdate(dest interface{}, index string, id string, body interface{}, options *ELSUpdateOptions) (*esapi.Response, error)
	Update(dest interface{}, index string, id string, body interface{}, options *ELSUpdateOptions) (*esapi.Response, error)
	SearchPagination(dest interface{}, index string, body map[string]interface{}, pageOptions *PageOptions, opts *ELSCreateSearchOptions) (*PageResponse, error)
}

type IELSMigration interface {
	Up() error
}

type IENV interface {
	Config() *ENVConfig
	IsDev() bool
	IsTest() bool
	IsMock() bool
	IsProd() bool
	Bool(key string) bool
	Int(key string) int
	String(key string) string
	All() map[string]string
}

type IError interface {
	Error() string
	GetCode() string
	GetStatus() int
	JSON() interface{}
	OriginalError() error
	GetMessage() interface{}
}

type IFile interface {
	Name() string
	Value() []byte
}

type IHTTPContext interface {
	IContext
	echo.Context
	BindWithValidate(ctx IValidateContext) IError
	BindOnly(i interface{}) IError
	GetPageOptions() *PageOptions
	GetPageOptionsWithOptions(options *PageOptionsOptions) *PageOptions
	GetUserAgent() *user_agent.UserAgent
	WithSaveCache(data interface{}, key string, duration time.Duration) interface{}
}

type ILogger interface {
	Info(args ...interface{})
	Warn(args ...interface{})
	Debug(args ...interface{})
	DebugWithSkip(skip int, args ...interface{})
	Error(message error, args ...interface{})
	ErrorWithSkip(skip int, message error, args ...interface{})
}

type IMQ interface {
	Close()
	PublishJSON(name string, data interface{}, options *MQPublishOptions) error
	Consume(ctx IMQContext, name string, onConsume func(message amqp.Delivery), options *MQConsumeOptions)
	Conn() *amqp.Connection
	ReConnect()
}

type IMQContext interface {
	IContext
	AddConsumer(handlerFunc func(ctx IMQContext))
	Consume(name string, onConsume func(message amqp.Delivery), options *MQConsumeOptions)
	Start()
}

type IMongoDB interface {
	DB() *mongo.Database
	Create(coll string, document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error)
	FindAggregate(dest interface{}, coll string, pipeline interface{}, opts ...*options.AggregateOptions) error
	FindAggregatePagination(dest interface{}, coll string, pipeline interface{}, pageOptions *PageOptions, opts ...*options.AggregateOptions) (*PageResponse, error)
	FindAggregateOne(dest interface{}, coll string, pipeline interface{}, opts ...*options.AggregateOptions) error
	Find(dest interface{}, coll string, filter interface{}, opts ...*options.FindOptions) error
	FindPagination(dest interface{}, coll string, filter interface{}, pageOptions *PageOptions, opts ...*options.FindOptions) (*PageResponse, error)
	FindOne(dest interface{}, coll string, filter interface{}, opts ...*options.FindOneOptions) error
	FindOneAndUpdate(dest interface{}, coll string, filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions) error
	UpdateOne(coll string, filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error)
	Count(coll string, filter interface{}, opts ...*options.CountOptions) (int64, error)
	Drop(coll string) error
	DeleteOne(coll string, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error)
	DeleteMany(coll string, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error)
	FindOneAndDelete(coll string, filter interface{}, opts ...*options.FindOneAndDeleteOptions) error
	Close()
	Helper() IMongoDBHelper
	CreateIndex(coll string, models []mongo.IndexModel, opts ...*options.CreateIndexesOptions) ([]string, error)
	DropIndex(coll string, name string, opts ...*options.DropIndexesOptions) (*MongoDropIndexResult, error)
	DropAll(coll string, opts ...*options.DropIndexesOptions) (*MongoDropIndexResult, error)
	ListIndex(coll string, opts ...*options.ListIndexesOptions) ([]MongoListIndexResult, error)
	FindAggregatePaginationCustomTotal(dest interface{}, coll string, pipeline []bson.M, pipelineTotalCount []bson.M, pageOptions *PageOptions, opts ...*options.AggregateOptions) (*PageResponse, error)
}

type IMongoDBHelper interface {
	Lookup(options *MongoLookupOptions) bson.M
	Set(options bson.M) bson.M
	Sort(options bson.M) bson.M
	Project(options bson.M) bson.M
	Size(expression string) bson.M
	Filter(options *MongoFilterOptions) bson.M
	Match(options bson.M) bson.M
	Unwind(field string) bson.M
	ReplaceRoot(options interface{}) bson.M
	Or(options []bson.M) bson.M
	PushOne(options bson.M) bson.M
	Push(options []bson.M) bson.M
	PullOne(options bson.M) bson.M
	Pull(options []bson.M) bson.M
}

type IMongoIndexBatch interface {
	Name() string
	Run() error
}

type IMongoIndexer interface {
	Add(batch IMongoIndexBatch)
	Execute() error
}

type IRequester interface {
	Get(url string, options *RequesterOptions) (*RequestResponse, error)
	Delete(url string, options *RequesterOptions) (*RequestResponse, error)
	Post(url string, body interface{}, options *RequesterOptions) (*RequestResponse, error)
	Create(method RequesterMethodType, url string, body interface{}, options *RequesterOptions) (*RequestResponse, error)
	Put(url string, body interface{}, options *RequesterOptions) (*RequestResponse, error)
	Patch(url string, body interface{}, options *RequesterOptions) (*RequestResponse, error)
}

type IS3 interface {
	GetObject(path string, opts *ss3.GetObjectInput) (*ss3.GetObjectOutput, error)
	PutObject(objectName string, file io.ReadSeeker, opts *ss3.PutObjectInput, uploadOptions *UploadOptions) (*ss3.PutObjectOutput, error)
	PutObjectByURL(objectName string, url string, opts *ss3.PutObjectInput, uploadOptions *UploadOptions) (*ss3.PutObjectOutput, error)
}

type ISeed interface {
	Run() error
}

type IValidMessage struct {
	Name    string      `json:"-"`
	Code    string      `json:"code"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
}

type IValidate interface {
	Valid() IError
}

type IValidateContext interface {
	Valid(ctx IContext) IError
}

type KeywordCondition string

type KeywordConditionWrapper struct {
	Condition      KeywordCondition
	KeywordOptions []KeywordOptions
}

type KeywordOptions struct {
	Type  KeywordType
	Key   string
	Value string
}

type KeywordType string

type Logger struct {
	RequestID string
	HostName  string

	Type consts.ContextType
	// contains filtered or unexported fields
}

type MQ struct {
	URI      string
	Host     string
	User     string
	Password string
	Port     string
	LogLevel logrus.Level
}

type MQConsumeOptions struct {
	Durable    bool
	AutoDelete bool
	Exclusive  bool
	NoWait     bool
	Args       amqp.Table
	AutoAck    bool
	NoLocal    bool
	Consumer   string
}

type MQContext struct {
	IContext
}

type MQContextOptions struct {
	ContextOptions *ContextOptions
}

type MQPublishOptions struct {
	Exchange     string
	MessageID    string
	Durable      bool
	AutoDelete   bool
	Exclusive    bool
	Mandatory    bool
	Immediate    bool
	NoWait       bool
	DeliveryMode uint8
	Args         amqp.Table
}

type Map map[string]interface{}

type MockCache struct {
	mock.Mock
}

type MockDatabase struct {
	Gorm *gorm.DB
	Mock sqlmock.Sqlmock
}

type MockLogger struct {
	mock.Mock
}

type MockMQ struct {
	mock.Mock
}

type MockMiddlewareManual func(c IHTTPContext) error

type MockMiddlewareOptions struct {
	Wrapper      MockMiddlewareWrapper
	Manual       MockMiddlewareManual
	IsPagination bool
	IsDisabled   bool
}

type MockMiddlewareWrapper func(model interface{}) interface{}

type MockMongoDB struct {
	mock.Mock
}

type MockMongoIndexBatch struct {
	mock.Mock
}

type MockMongoIndexer struct {
	mock.Mock
	Batches []*MockMongoIndexBatch
}

type MockRequester struct {
	mock.Mock
}

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

type MongoDropIndexResult struct {
	DropCount int64 `json:"drop_count" bson:"nIndexesWas"`
}

type MongoFilterOptions struct {
	Input     string
	As        string
	Condition bson.M
}

type MongoIndexer struct {
	Batches []IMongoIndexBatch
	// contains filtered or unexported fields
}

type MongoListIndexResult struct {
	Key     map[string]int64 `json:"key" bson:"key"`
	Name    string           `json:"name" bson:"name"`
	Version int64            `json:"version" bson:"v"`
}

type MongoLookupOptions struct {
	From         string
	LocalField   string
	ForeignField string
	As           string
}

type PageOptions struct {
	Q       string
	Limit   int64
	Page    int64
	OrderBy []string
}

type PageOptionsOptions struct {
	OrderByAllowed []string
}

type PageResponse struct {
	Total   int64
	Limit   int64
	Count   int64
	Page    int64
	Q       string
	OrderBy []string
}

type Pagination struct {
	Page  int64       `json:"page"`
	Total int64       `json:"total"`
	Limit int64       `json:"limit"`
	Count int64       `json:"count"`
	Items interface{} `json:"items"`
}

type RequestResponse struct {
	Data             map[string]interface{}
	RawData          []byte
	ErrorCode        string
	StatusCode       int
	Header           http.Header
	ContentLength    int64
	TransferEncoding []string
	Uncompressed     bool
	Trailer          http.Header
	Request          *http.Request
	TLS              *tls.ConnectionState
}

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

type RequesterMethodType string

type RequesterOptions struct {
	BaseURL         string
	Timeout         *time.Duration
	Headers         http.Header
	Params          xurl.Values
	RetryCount      int
	IsMultipartForm bool
	IsURLEncode     bool
	IsBodyRawByte   bool
}

type S3Config struct {
	Endpoint  string
	AccessKey string
	SecretKey string
	Region    string
	Bucket    string
	IsHTTPS   bool
}

type Seeder struct {
}

type UploadOptions struct {
	Width   int64
	Height  int64
	Quality int64
}

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

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

type Validator struct{}