-
Notifications
You must be signed in to change notification settings - Fork 0
/
main.go
152 lines (132 loc) · 3.46 KB
/
main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/joho/godotenv"
"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 Task struct {
Id primitive.ObjectID `bson:"_id,omitempty"`
Title string `bson:"title"`
Completed bool `bson:"completed"`
}
func (t Task) String() string {
return fmt.Sprintf(
"Task{_id='%s', Title='%s', Completed='%t'}",
t.Id, t.Title, t.Completed)
}
var (
databaseName = "todo"
collTask = "tasks"
)
func init() {
if err := godotenv.Load(); err != nil {
log.Println("No .env file found")
}
}
func main() {
uri := os.Getenv("MONGODB_URI")
ctx := context.Background()
client, err := mongo.Connect(ctx, options.Client().ApplyURI(uri))
if err != nil {
log.Fatal(err)
}
if err := client.Ping(ctx, nil); err != nil {
log.Fatal(err)
}
fmt.Println("Mongo Connected.")
coll := client.Database(databaseName).Collection(collTask)
DeleteMany(ctx, coll, bson.D{})
InsertOne(ctx, coll)
InsertMany(ctx, coll)
// Update(ctx, coll, "66377fde0a64de919e76e735")
// Delete(ctx, coll, "6637f5e2c8849ab3cd545a21")
FindOne(ctx, coll, bson.D{{Key: "title", Value: "hug cat"}})
Find(ctx, coll, bson.D{})
// jsonData, err := json.MarshalIndent(cursors, "", " ")
// if err != nil {
// panic(err)
// }
// fmt.Printf("%s\n", jsonData)
defer func() {
if err := client.Disconnect(ctx); err != nil {
log.Fatal(err)
}
fmt.Println("Mongo Disconnected.")
}()
}
func InsertOne(ctx context.Context, coll *mongo.Collection) {
task := Task{Title: "play with cat"}
result, err := coll.InsertOne(ctx, task)
if err != nil {
log.Fatal(err)
}
fmt.Println(result.InsertedID)
}
func InsertMany(ctx context.Context, coll *mongo.Collection) {
tasks := []interface{}{
Task{Title: "hug cat", Completed: false},
Task{Title: "feed cat", Completed: false},
}
results, err := coll.InsertMany(ctx, tasks)
if err != nil {
log.Fatal(err)
}
fmt.Println(results.InsertedIDs)
}
func FindOne(ctx context.Context, coll *mongo.Collection, filter interface{}) {
var task Task
if err := coll.FindOne(ctx, filter).Decode(&task); err != nil {
if err == mongo.ErrNoDocuments {
// fmt.Println("no documents in result")
log.Fatal("no documents in result")
} else {
log.Fatal(err)
}
}
fmt.Println(task)
}
func Find(ctx context.Context, coll *mongo.Collection, filter interface{}) {
cursor, err := coll.Find(ctx, filter)
if err != nil {
log.Fatal(err)
}
for cursor.Next(ctx) {
var task Task
if err := cursor.Decode(&task); err != nil {
log.Fatal(err)
}
fmt.Println(task)
}
}
func Update(ctx context.Context, coll *mongo.Collection, id string) {
objectID, _ := primitive.ObjectIDFromHex(id)
filter := bson.D{{Key: "_id", Value: objectID}}
update := bson.D{{Key: "$set", Value: bson.D{{Key: "completed", Value: true}}}}
result, err := coll.UpdateOne(ctx, filter, update)
if err != nil {
log.Fatal(err)
}
fmt.Println(result)
}
func Delete(ctx context.Context, coll *mongo.Collection, id string) {
objectID, _ := primitive.ObjectIDFromHex(id)
filter := bson.D{{Key: "_id", Value: objectID}}
result, err := coll.DeleteOne(ctx, filter)
if err != nil {
log.Fatal(err)
}
fmt.Println(result)
}
func DeleteMany(ctx context.Context, coll *mongo.Collection, filter interface{}) {
result, err := coll.DeleteMany(ctx, filter)
if err != nil {
log.Fatal(err)
}
fmt.Println(result)
}