Como construir um aplicativo web Go com Gi, MongoDB e AI

1
mkdir mflix
2
cd mflix

1
go mod init mflix

1
go get github.com/gin-gonic/gin
2
go get go.mongodb.org/mongo-driver/mongo

1
package main
2
3
import (
4
    "github.com/gin-gonic/gin"
5
)
6
7
func main() {
8
    r := gin.Default()
9
    r.GET("/", func(c *gin.Context) {
10
        c.JSON(200, gin.H{
11
            "message": "Hello World",
12
        })
13
    })
14
15
    r.Run()
16
}

1
package main
2
3
import (
4
    // Add required Go packages
5
    "context"
6
    "log"
7
8
    "github.com/gin-gonic/gin"
9
10
    // Add the MongoDB driver packages 
11
    "go.mongodb.org/mongo-driver/mongo"
12
    "go.mongodb.org/mongo-driver/mongo/options"
13
)
14
15
// Your MongoDB Atlas Connection String
16
const uri = "YOUR-CONNECTION-STRING-HERE"
17
18
// A global variable that will hold a reference to the MongoDB client
19
var mongoClient *mongo.Client
20
21
22
// The init function will run before our main function to establish a connection to MongoDB. If it cannot connect it will fail and the program will exit.
23
func init() {
24
    if err := connect_to_mongodb(); err != nil {
25
        log.Fatal("Could not connect to MongoDB")
26
    }
27
}
28
29
func main() {
30
    r := gin.Default()
31
    r.GET("/", func(c *gin.Context) {
32
        c.JSON(200, gin.H{
33
            "message": "Hello World",
34
        })
35
    })
36
37
    r.Run()
38
}
39
40
// Our implementation logic for connecting to MongoDB
41
func connect_to_mongodb() error {
42
    serverAPI := options.ServerAPI(options.ServerAPIVersion1)
43
    opts := options.Client().ApplyURI(uri).SetServerAPIOptions(serverAPI)
44
45
    client, err := mongo.Connect(context.TODO(), opts)
46
    if err != nil {
47
        panic(err)
48
    }
49
    err = client.Ping(context.TODO(), nil)
50
    mongoClient = client
51
    return err
52
}

1
// GET /movies - Get all movies
2
func getMovies(c *gin.Context) {
3
    // Find movies
4
    cursor, err := mongoClient.Database("sample_mflix").Collection("movies").Find(context.TODO(), bson.D{{}})
5
    if err != nil {
6
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
7
        return
8
    }
9
10
    // Map results
11
    var movies []bson.M
12
    if err = cursor.All(context.TODO(), &movies); err != nil {
13
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
14
        return
15
    }
16
17
    // Return movies
18
    c.JSON(http.StatusOK, movies)
19
}

1
// GET /movies/:id - Get movie by ID
2
func getMovieByID(c *gin.Context) {
3
    // Get movie ID from URL
4
    id := c.Param("id")
5
6
    // Find movie by ID
7
    var movie bson.M
8
    err := mongoClient.Database("sample_mflix").Collection("movies").FindOne(context.TODO(), bson.D{{"_id", id}}).Decode(&movie)
9
    if err != nil {
10
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
11
        return
12
    }
13
14
    // Return movie
15
    c.JSON(http.StatusOK, movie)
16
}

1
// POST /movies/aggregations - Run aggregations on movies
2
func aggregateMovies(c *gin.Context) {
3
    // Get aggregation pipeline from request body
4
    var pipeline interface{}
5
    if err := c.ShouldBindJSON(&pipeline); err != nil {
6
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
7
        return
8
    }
9
    
10
    // Run aggregations
11
    cursor, err := mongoClient.Database("sample_mflix").Collection("movies").Aggregate(context.TODO(), pipeline)
12
    if err != nil {
13
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
14
        return
15
    }
16
17
    // Map results
18
    var result []bson.M
19
    if err = cursor.All(context.TODO(), &result); err != nil {
20
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
21
        return
22
    }
23
24
    // Return result
25
    c.JSON(http.StatusOK, result)
26
}

1
func main() {
2
	r := gin.Default()
3
	r.GET("/", func(c *gin.Context) {
4
		c.JSON(200, gin.H{
5
			"message": "Hello World",
6
		})
7
	})
8
	r.GET("/movies", getMovies)
9
	r.GET("/movies/:id", getMovieByID)
10
	r.POST("/movies/aggregations", aggregateMovies)
11
12
	r.Run()
13
}

1
func getMovieByID(c *gin.Context) {
2
3
	// Get movie ID from URL
4
	idStr := c.Param("id")
5
6
	// Convert id string to ObjectId
7
	id, err := primitive.ObjectIDFromHex(idStr)
8
	if err != nil {
9
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
10
		return
11
	}
12
13
	// Find movie by ObjectId
14
	var movie bson.M
15
	err = mongoClient.Database("sample_mflix").Collection("movies").FindOne(context.TODO(), bson.D{{"_id", id}}).Decode(&movie)
16
	if err != nil {
17
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
18
		return
19
	}
20
21
	// Return movie
22
	c.JSON(http.StatusOK, movie)
23
}

1
import (
2
	"context"
3
	"log"
4
	"net/http"
5
6
	"github.com/gin-gonic/gin"
7
	"go.mongodb.org/mongo-driver/bson"
8
	"go.mongodb.org/mongo-driver/bson/primitive"
9
	"go.mongodb.org/mongo-driver/mongo"
10
	"go.mongodb.org/mongo-driver/mongo/options"
11
)

1
[
2
    {"$match": {"genres": "Comedy"}},
3
    {"$group": {
4
        "_id": "$year", 
5
        "count": {"$sum": 1}
6
    }},
7
    {"$sort": {"count": -1}}
8
]

1
[
2
    {
3
        "_id": 2014,
4
        "count": 287
5
    },
6
    {
7
        "_id": 2013,
8
        "count": 286
9
    },
10
    {
11
        "_id": 2009,
12
        "count": 268
13
    },
14
    {
15
        "_id": 2011,
16
        "count": 263
17
    },
18
    {
19
        "_id": 2006,
20
        "count": 260
21
    },
22
    ...
23
]

1
// Declare the entry point into our application
2
package main
3
4
// Add our dependencies from the standard library, Gin, and MongoDB
5
import (
6
    "context"
7
    "fmt"
8
    "log"
9
    "net/http"
10
11
    "github.com/gin-gonic/gin"
12
    "go.mongodb.org/mongo-driver/bson"
13
    "go.mongodb.org/mongo-driver/bson/primitive"
14
    "go.mongodb.org/mongo-driver/mongo"
15
    "go.mongodb.org/mongo-driver/mongo/options"
16
)
17
18
// Define your MongoDB connection string
19
const uri = "{YOUR-CONNECTION-STRING-HERE}"
20
21
// Create a global variable to hold our MongoDB connection
22
var mongoClient *mongo.Client
23
24
// This function runs before we call our main function and connects to our MongoDB database. If it cannot connect, the application stops.
25
func init() {
26
    if err := connect_to_mongodb(); err != nil {
27
        log.Fatal("Could not connect to MongoDB")
28
    }
29
}
30
31
32
// Our entry point into our application
33
func main() {
34
    // The simplest way to start a Gin application using the frameworks defaults
35
    r := gin.Default()
36
37
    // Our route definitions
38
    r.GET("/", func(c *gin.Context) {
39
        c.JSON(200, gin.H{
40
            "message": "Hello World",
41
        })
42
    })
43
    r.GET("/movies", getMovies)
44
    r.GET("/movies/:id", getMovieByID)
45
    r.POST("/movies/aggregations", aggregateMovies)
46
47
    // The Run() method starts our Gin server
48
    r.Run()
49
}
50
51
// Implemention of the /movies route that returns all of the movies from our movies collection.
52
func getMovies(c *gin.Context) {
53
    // Find movies
54
    cursor, err := mongoClient.Database("sample_mflix").Collection("movies").Find(context.TODO(), bson.D{{}})
55
    if err != nil {
56
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
57
        return
58
    }
59
60
    // Map results
61
    var movies []bson.M
62
    if err = cursor.All(context.TODO(), &movies); err != nil {
63
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
64
        return
65
    }
66
67
    // Return movies
68
    c.JSON(http.StatusOK, movies)
69
}
70
71
72
// The implementation of our /movies/{id} endpoint that returns a single movie based on the provided ID
73
func getMovieByID(c *gin.Context) {
74
75
    // Get movie ID from URL
76
    idStr := c.Param("id")
77
78
    // Convert id string to ObjectId
79
    id, err := primitive.ObjectIDFromHex(idStr)
80
    if err != nil {
81
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
82
        return
83
    }
84
85
    // Find movie by ObjectId
86
    var movie bson.M
87
    err = mongoClient.Database("sample_mflix").Collection("movies").FindOne(context.TODO(), bson.D{{"_id", id}}).Decode(&movie)
88
    if err != nil {
89
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
90
        return
91
    }
92
93
    // Return movie
94
    c.JSON(http.StatusOK, movie)
95
}
96
97
// The implementation of our /movies/aggregations endpoint that allows a user to pass in an aggregation to run our the movies collection.
98
func aggregateMovies(c *gin.Context) {
99
    // Get aggregation pipeline from request body
100
    var pipeline interface{}
101
    if err := c.ShouldBindJSON(&pipeline); err != nil {
102
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
103
        return
104
    }
105
106
    // Run aggregations
107
    cursor, err := mongoClient.Database("sample_mflix").Collection("movies").Aggregate(context.TODO(), pipeline)
108
    if err != nil {
109
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
110
        return
111
    }
112
113
    // Map results
114
    var result []bson.M
115
    if err = cursor.All(context.TODO(), &result); err != nil {
116
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
117
        return
118
    }
119
120
    // Return result
121
    c.JSON(http.StatusOK, result)
122
}
123
124
125
// Our implementation code to connect to MongoDB at startup
126
func connect_to_mongodb() error {
127
    serverAPI := options.ServerAPI(options.ServerAPIVersion1)
128
    opts := options.Client().ApplyURI(uri).SetServerAPIOptions(serverAPI)
129
130
    client, err := mongo.Connect(context.TODO(), opts)
131
    if err != nil {
132
        panic(err)
133
    }
134
    err = client.Ping(context.TODO(), nil)
135
    mongoClient = client
136
    return err
137
}