137 lines
3.4 KiB
Go
137 lines
3.4 KiB
Go
package tongo
|
|
|
|
import (
|
|
"context"
|
|
"log"
|
|
"net/url"
|
|
"reflect"
|
|
"strings"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
)
|
|
|
|
type Database struct {
|
|
database string
|
|
client *mongo.Client
|
|
}
|
|
|
|
func NewConnection(uri string, database string) (*Database, error) {
|
|
client, err := mongo.Connect(context.Background(), options.Client().ApplyURI(uri))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Database{client: client, database: database}, nil
|
|
}
|
|
|
|
func (d *Database) Collection(col string) *mongo.Collection {
|
|
return d.client.Database(d.database).Collection(col)
|
|
}
|
|
|
|
func getFilter(es []primitive.E) bson.D {
|
|
filter := bson.D{}
|
|
for _, e := range es {
|
|
filter = append(filter, e)
|
|
}
|
|
return filter
|
|
}
|
|
|
|
func QueryFilter(q *url.Values) bson.D {
|
|
filter := bson.D{}
|
|
for k, v := range *q {
|
|
var f bson.E
|
|
q := strings.Split(k, "_")
|
|
if len(q) == 1 { // If param is like "name" or "url" we're using exact matching
|
|
f = bson.E{Key: k, Value: v[0]}
|
|
} else {
|
|
if q[1] == "like" { // If it's like "name_like", we're using regex
|
|
f = bson.E{Key: q[0], Value: bson.D{{Key: "$regex", Value: v[0]}}}
|
|
}
|
|
}
|
|
filter = append(filter, f) // Applying query filters to user filter
|
|
}
|
|
return filter
|
|
}
|
|
|
|
func NewStore[T Collectable](db *Database) Store[T] {
|
|
var item T
|
|
coll := item.Coll()
|
|
return Store[T]{
|
|
Db: db.client,
|
|
Coll: db.Collection(coll),
|
|
}
|
|
}
|
|
|
|
type Store[T Collectable] struct {
|
|
Db *mongo.Client
|
|
Coll *mongo.Collection
|
|
}
|
|
|
|
func (s Store[T]) InsertOne(ctx context.Context, item *T) (primitive.ObjectID, error) {
|
|
result, err := s.Coll.InsertOne(ctx, item)
|
|
if err != nil {
|
|
if e, ok := err.(mongo.WriteError); ok {
|
|
log.Printf("Error writing new item of type %v: %v ", reflect.TypeOf(item), e)
|
|
return primitive.NilObjectID, e
|
|
}
|
|
log.Printf("Error creating new item of type %v: %v ", reflect.TypeOf(item), err)
|
|
return primitive.NilObjectID, err
|
|
}
|
|
rid, _ := result.InsertedID.(primitive.ObjectID)
|
|
return rid, nil
|
|
}
|
|
|
|
func (s Store[T]) GetById(ctx context.Context, id primitive.ObjectID) (*T, error) {
|
|
res := s.Coll.FindOne(ctx, bson.D{{Key: "_id", Value: id}})
|
|
if res.Err() != nil {
|
|
return nil, res.Err()
|
|
}
|
|
var item T
|
|
res.Decode(&item)
|
|
return &item, nil
|
|
}
|
|
|
|
func (s Store[T]) GetOne(ctx context.Context, filter ...bson.E) (*T, error) {
|
|
f := getFilter(filter)
|
|
res := s.Coll.FindOne(ctx, f)
|
|
if res.Err() != nil {
|
|
return nil, res.Err()
|
|
}
|
|
var item T
|
|
res.Decode(&item)
|
|
return &item, nil
|
|
}
|
|
|
|
func (s Store[T]) GetMany(ctx context.Context, filter ...bson.E) ([]*T, error) {
|
|
f := getFilter(filter)
|
|
cur, err := s.Coll.Find(ctx, f)
|
|
if err != nil {
|
|
log.Println("Error fetching items: ", err)
|
|
return nil, err
|
|
}
|
|
res := []*T{}
|
|
err = cur.All(ctx, &res)
|
|
if err != nil {
|
|
log.Println("Error collecting items to slice: ", err)
|
|
return nil, err
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (s Store[T]) DeleteByID(ctx context.Context, id primitive.ObjectID) error {
|
|
_, err := s.Coll.DeleteOne(ctx, bson.D{{Key: "_id", Value: id}})
|
|
return err
|
|
}
|
|
|
|
func (s Store[T]) ReplaceItem(ctx context.Context, item T, upsert bool) error {
|
|
_, err := s.Coll.ReplaceOne(ctx, bson.D{{Key: "_id", Value: item.GetID()}}, item, options.Replace().SetUpsert(upsert))
|
|
return err
|
|
}
|
|
|
|
func (s Store[T]) Count(ctx context.Context, filter ...bson.E) (int64, error) {
|
|
f := getFilter(filter)
|
|
return s.Coll.CountDocuments(ctx, f)
|
|
}
|