lxDb

Documentation

Index

• Constants
• Variables
• func GetMongoDbClient(uri string) (client *mongo.Client, err error)
• func ToBsonDoc(v interface{}) (doc *bson.D, err error)
• func ToBsonMap(v interface{}) (doc bson.M, err error)
• type AuditAuth
  • func SetAuditAuth(user interface{}) *AuditAuth
• type AuditEntry
• type DeleteManyResult
• type IBaseRepo
  • func NewMongoBaseRepo(collection *mongo.Collection, baseRepoAudit ...IBaseRepoAudit) IBaseRepo
• type IBaseRepoAudit
• type InsertManyResult
• type UpdateManyResult

Constants

const (
	DefaultTimeout = time.Second * 30
	Insert         = "insert"
	Update         = "update"
	Delete         = "delete"
)

Variables

var ErrIndexConvert = errors.New("can't convert index models")

Error by convert index model

var ErrNotFound = errors.New("not found")

Not Found error

Functions

func GetMongoDbClient

func GetMongoDbClient(uri string) (client *mongo.Client, err error)

GetMongoDbClient, return new mongo driver client

func ToBsonDoc

func ToBsonDoc(v interface{}) (doc *bson.D, err error)

ToBsonDoc, convert interface to bson.D

func ToBsonMap

func ToBsonMap(v interface{}) (doc bson.M, err error)

ToBsonMap, convert interface to bson.M

Types

type AuditAuth

type AuditAuth struct {
	User interface{}
}

AuthAudit, auth user for audit

func SetAuditAuth

func SetAuditAuth(user interface{}) *AuditAuth

SetAuditAuthUser, returns AuditAuth with user

type AuditEntry

type AuditEntry struct {
	Collection string      `json:"collection"`
	Action     string      `json:"action"`
	User       interface{} `json:"user"`
	Data       interface{} `json:"data"`
}

type DeleteManyResult

type DeleteManyResult struct {
	DeletedCount int64
}

type IBaseRepo

type IBaseRepo interface {
	CreateIndexes(indexes interface{}, args ...interface{}) ([]string, error)
	InsertOne(doc interface{}, args ...interface{}) (interface{}, error)
	InsertMany(docs []interface{}, args ...interface{}) (*InsertManyResult, error)
	CountDocuments(filter interface{}, args ...interface{}) (int64, error)
	EstimatedDocumentCount(args ...interface{}) (int64, error)
	Find(filter interface{}, result interface{}, args ...interface{}) error
	FindOne(filter interface{}, result interface{}, args ...interface{}) error
	FindOneAndDelete(filter interface{}, result interface{}, args ...interface{}) error
	FindOneAndReplace(filter, replacement, result interface{}, args ...interface{}) error
	FindOneAndUpdate(filter, update, result interface{}, args ...interface{}) error
	UpdateOne(filter interface{}, update interface{}, args ...interface{}) error
	UpdateMany(filter interface{}, update interface{}, args ...interface{}) (*UpdateManyResult, error)
	DeleteOne(filter interface{}, args ...interface{}) error
	DeleteMany(filter interface{}, args ...interface{}) (*DeleteManyResult, error)
	GetCollection() interface{}
	GetDb() interface{}
	GetRepoName() string
	SetLocale(code string)
	Aggregate(pipeline interface{}, result interface{}, args ...interface{}) error
}

IBaseRepo

func NewMongoBaseRepo

func NewMongoBaseRepo(collection *mongo.Collection, baseRepoAudit ...IBaseRepoAudit) IBaseRepo

NewMongoBaseRepo, return base repo instance

type IBaseRepoAudit

type IBaseRepoAudit interface {
	Send(elem interface{})
	IsActive() bool
}

type InsertManyResult

type InsertManyResult struct {
	FailedCount int64
	InsertedIDs []interface{}
}

type UpdateManyResult

type UpdateManyResult struct {
	MatchedCount  int64
	ModifiedCount int64
	FailedCount   int64
	FailedIDs     []interface{}
	UpsertedCount int64
	UpsertedID    interface{}
}