Learn how to build a complete full stack

movie streaming app with AI powered

movie recommendations. You'll use Go

with the Jin Ganic framework on the back

end, React on the front end, and MongoDB

for data storage. For the AI features,

you'll connect your Go backend to OpenAI

using Langchain Go. Along the way,

you'll set up authentication with secure

token handling, making sure access

tokens are stored in HTTPON cookies to

protect against cross-sight scripting

attacks. You'll also learn best

practices for securing client server

communication over HTTPS.

Once the app is built locally, you'll

deploy it to the cloud with MongoDB

Atlas, render for the Go API, and

Verscell for the React client. By the

end, you'll gain experience not just in

Go, MongoDB, and React, but also in

cyber security, AI integration, and

cloud deployment. Gavin lawn developed

this course and MongoDB provided a grant

to make this course possible. Hi

everyone and welcome. I'm Gavin Lawn.

I'm super excited to bring you this

course where we'll build a full stack

web application stepby step using

cuttingedge technologies. We are

developing this application for a

fictional company named Magic Stream

that provides

Why'd you do it?

I didn't.

A movie streaming service as well as an

AI powered personalized movie

recommendation service that leverages a

technology called lang chain go for

interfacing from our go or golang code

with open AI. We are going to use React

on the front end to leverage high

performance front-end user interaction

functionality so as to provide our users

with a superb UX user experience. We'll

create the serverside code for a web API

component using Go also known as Golang.

Go or Golang is a statically typed

compiled programming language created by

Google. It was designed with simplicity,

efficiency, and scalability in mind,

making it well suited for modern systems

programming, cloudnative applications,

and large-scale distributed systems. I

have to say, after working with Go

lately, it has become one of my favorite

programming languages. You'll see it's

just great to work with. It's a great

modern, simple, yet powerful language to

learn, and it also pays really well. For

our data storage facility, we'll use the

awesome MongoDB, a NoSQL

document-oriented database designed to

store, query, and manage large volumes

of data in a flexible and scalable way.

MongoDB is optimized for fast read and

write operations, especially useful for

real-time applications. As mentioned

earlier, for creating a super responsive

front end, we'll use React in order to

provide our users with an excellent UX

user experience. React is a JavaScript

library, not a full framework, used for

building user interfaces, especially

single page applications, SPARS, where

the UI needs to update efficiently in

response to user actions or data

changes. It was originally developed by

Facebook and is now open source and

widely adopted. So this course has a bit

of everything. Learn a modern

cuttingedge programming language like

Go. Create a full stack distributed web

application. Learn important aspects of

cyber security. Learn how to integrate

AI into your applications. And then at

the end of the course when we deploy our

app to the cloud, we engage in aspects

of DevOps. Once we've developed our

application, we'll deploy the serverside

web API component written in Go to

Render, a modern cloud hosting platform

that provides developers with a way to

easily deploy and scale web

applications. We'll deploy the React

client code to Versel, a cloud platform

optimized for front-end development. And

we'll deploy our MongoDB database to

Atlas. Atlas is MongoDB's fully managed

cloudnative database service, sometimes

described as database as a service. So

this web application is a great example

of the implementation of a loosely

coupled architecture where functional

entities on the web, the serverside

component written in Go and the client

written using React interact via HTTP as

one full stack web application. We'll

also include cyber security features

like token authentication over HTTPS to

protect our data. So, as mentioned

earlier, I'm Gavin Lon. I've been

developing software professionally for

decades at this point and love sharing

my knowledge. I run my own YouTube

channel where I teach programming and

discuss technology in general. I'm proud

to say that I've created several courses

for free code camp, most of them

dedicated to teaching programming. But I

must confess that I went to the dark

side last year and taught a course on

video editing using Da Vinci Resolve. So

please check out that course if you want

to add video editing to your skill set.

Okay, so enough about me. Let's discuss

what this course is all about.

I've created a fictional company called

Magic Stream. We are going to develop a

movie streaming service for Magic Stream

in the form of a full stack web

application that provides a special

feature that uses AI to recommend the

top five movies tailored to the user's

specific tastes. This recommendation

service is based on the users's movie

genre preferences and the sentiment

derived from movie reviews created by

the administrators of our system. So the

workflow here is an administrator logs

onto the system and creates a movie

review in natural language for a movie

offered for streaming through magic

stream. When the administrator submits

the movie review, a custom prompt that

we'll create is submitted along with the

movie review to OpenAI via a technology

called Langchain Go. The relevant LLM

large language model returns a response

in one word describing the sentiment

behind the movie review. Our prompt

includes instructions to only return one

word describing the sentiment behind the

movie review. For example, the sentiment

could be excellent, good, okay, bad, or

terrible. This sentiment described in

one word is then saved to our database

along with a unique numeric value

associated with each sentiment. You can

see how it is easy for our system to

include a value for each of these

sentiments. So for example, excellent

can have a value of one, good, two,

okay, three, and so on. The last one,

terrible, has an associated value of

five. We can then query our MongoDB

database for movies and order them by

their values that denote the sentiment

for each of the movies stored in our

database. It is important to note that

these sentiments are extensible. We are

going to architect the application so

that we can extend the number of

possible sentiments associated with

movie reviews. We could later include a

wide spectrum of sentiments and

associated values. For example, you

could include the word unwatchable below

terrible where terrible has an

associated value of five and unwatchable

has an associated value of six. So these

values can be used as a ranking order

for the relevant recommended movies.

This course has pretty much got

everything. I mean we are also going to

include cyber security features like

tokenbased authentication over HTTPS.

I'll firstly show you how the access

token is generated once the user

authenticates with the system i.e by

logging on with the user's credentials.

Then for subsequent HTTP requests the

token is passed through the header of

the relevant HTTP messages so that the

user can be authenticated before

accessing protected endpoints.

But it doesn't stop there. By passing

the token through the header, our

application is still vulnerable to XSS

attacks, cross-sight scripting attacks,

where malicious JavaScript code can

potentially be injected into the client

side and read the access token. An

access token is like a key that can be

used to unlock protected resources. So,

we must protect the key. How can we do

that? I'll show you how you can avoid

storing the tokens on the client side

and passing it through the header by

instead storing the access token as HTTP

only cookies which means the tokens

cannot be read through JavaScript code

and therefore mitigates the risk of the

access token being stolen. I'll show you

how to do that in detail in this course.

So these are very important cyber

security related practices to learn to

leverage Go for our web API component.

We are going to use a web framework

called Genonic. Genonic sometimes

referred to as Jyn is a high performance

HTTP web framework for go Golang.

Gingonic is lightweight and fast,

minimalistic but powerful. Jinggonic. I

know it sounds a bit like jin and tonic.

We're not going to be vibe coding in

this course. Oh, sorry. Whiskers.

I feel it's important to learn to code

at least at the beginning without the

use of AI assistance. So it gives you a

tactile and deep sense of the

development process and building up the

code step by step without AI assistance

in my view is the best way to understand

programming and associated technologies.

So we are going to build this full stack

web application step by step and we are

going to have a great time doing it. So

as I said at the beginning this course

has a bit of everything. Learn a modern

cutting edge programming language like

Go. Create a full stack distributed web

application. Learn important aspects of

cyber security. Learn how to integrate

AI into your applications. And then at

the end of the course when we deploy our

app to the cloud, we dabble with DevOps.

Dabble with DevOps.

We engage with aspects of DevOps. So we

are going to have a great time

developing and deploying our full stack

web application. Right, let's start from

the beginning which involves setting up

our local development machines with the

technologies we'll use to develop and

test the application. Let's get into it.

Right. So to install MongoDB, we need to

navigate to this URL. So let's go

through Chrome. I'm going to use Chrome

as my browser and I'm going to navigate

to this URL.

www.mongodb.com/try/d

download/ community then press the enter

key and you can see the website has

appropriately detected my platform

settings. So we have the platform

setting for Windows x64 which is the

platform I'm using uh which I'll be

using to develop the application for

this course. You have a choice between

MSI and Zip here, but we want the MSI

package. And this is the appropriate

platform for us. But we have a list of

various other platforms. We have Mac

platform and we have various

distributions of Linux available to us

here. But as stated, we want the Windows

x64 platform selected here. So the next

thing we do is just hit the download

button to download the relevant MSI

file. Once it's downloaded, we'll double

click on the relevant MSI file and

run the relevant installation package.

You can see we've got an indication as

to how much longer it will take to

download the full MSI package. So, we

just need to be a little bit patient

here. 2 minutes left. It says not too

long. Let's fast forward. And please

note that this is the community edition

of MongoDB server and it's absolutely

free to use on our local machines. All

right, not long now. 9 seconds, 8

seconds, 7 seconds, 6 5 4 3 2 1. Okay,

great. And now we should have the folder

icon displayed to us. Here it is. And we

can just navigate to our downloads

folder using that there. So to install

MongoDB on our local machines, we simply

doubleclick this file here which has

themsi extension. Excellent. The setup

wizard will install MongoDB 8.0.11

blah blah blah blah blah. Click next

button. Excellent. And then let's accept

the licensing agreement by selecting

this checkbox here. And then let's press

the next button. And we are recommended

to do a complete install here. So let's

hit the complete button. And on this

page, I think we can just leave

everything as is. So let's press the

next button to continue. Now this is a

very important checkbox here. Let's keep

this checked because this will install

automatically a

guey interface for MongoDB. So we'll be

able to use this guey interface to

manipulate our data, create databases,

collections, documents within

collections, etc. and it's a really

great graphical user interface that we

can utilize. Great. So, let's press the

next button here. And then the last step

is to press the install button. I'm not

going to press the install button

because I've already installed uh

MongoDB on my local machine. So, I'm

just going to cancel out of this. But

please go ahead and press the install

button and go through with the

installation process. So, the next step

is we want to verify that we have indeed

installed MongoDB successfully on our

local machine. So to do that we can do

it through the command prompt like this.

So

d-

version like this.

Excellent.

So we've got version 8.0.8 which is the

target version that we installed on our

Windows platform. Excellent.

Then in order to be able to interact

with MongoDB with the MongoDB database

on your local machines, you can run

MongoDB commands like for example query

commands from your command line using

the MongoDB shell. This can be handy for

test purposes. Please note that the

installation of the MongoDB shell

requires a separate installation to the

one for installing MongoDB, i.e. the

installation we have just completed and

verified. So to install MongoDB shell,

it's www.mongodb.com

slashtry

slashd download

and then the word shell slshell like

this. Press the enter key. And you can

see now that the actual website itself

has detected my particular platform,

Windows x64. So, I've got Windows x64

version 10 plus. So, I'm actually on

version 11 of the Windows 6 x64

operating system, which is correct. And

then here, we can download the relevant

MSI file. And then we can just run that

MSI file from our downloads folder by

double clicking on the relevant file and

going through the relevant installation

instructions. Then to verify that

MongoDB shell has actually been

installed and I have actually gone

through the installation process. So

I've got MongoDB shell installed. You

can verify this by typing MongoDB.

So sorry it's not MongoDB, it's Mongsh

version like this

2.5.0. So, I've got the appropriate

version of MongoDB shell

installed on this local machine, and we

verified it with this command.

Excellent. Uh, sometimes it won't

automatically configure your path

environment variable, which can lead to

problems. So to verify that our path

environment variable has indeed been

configured correctly, we can go to this

utility

cis

dm dot

cpl.

Press the enter key. Then we can go to

this tab, the advanced tab, and press

the environment variables button here.

And let's look inside the system

variables list here and navigate to the

path environment variable. Hit the edit

button and let's see if we can find the

MongoDB environment variable that we

want. Sorry, well the path environment

variable and make sure that MongoDB is

appropriately set up within the path

environment variables. And here it is. C

program files MongoDB server 8.0 bin.

And if we copy that to our clipboards

and we press Windows key R here and use

Windows Explorer, we can navigate to

that path. And we can see here that the

relevant files have been appropriately

put into that directory structure and we

are appropriately pointing to that

directory from within the path

environment variable. So that's

excellent. Great. And then the other

verification we should do is check that

MongoDB is actually running in the

background. And we can do that by

running our services. So Windows keyr

type services.msc

like this

and then type select the list and type

mo. And there we are. We can see our

MongoDB server is running in the

background here. And we can use this

facility to stop or start start our

server. But we don't want to stop our

server. We want to keep MongoDB server

running in the background. The next

thing we want to do is launch Compass.

So we can see the graphical user

interface that ships with this

installation of MongoDB.

And then let's press on the connect

button here next to main connection

here.

Excellent. As you can see, I've been

playing around with a number of MongoDB

databases, and this is essentially the

structure we're about to create. So,

we're going to create a new database

next to the main connection node here.

Let's press the plus button, and then

let's

give our database a sensible name. So,

let's call this magic stream movies

like this. And our first collection will

be named movies. So let's enter it here.

Collection name. And then we just press

the create database button to create our

database. Excellent. So I want to create

three other collections within this

database. So let's hit this plus icon

here to create a new collection. And

let's name this collection users. This

will store information regarding the

users of the system. I'm going to import

three data for three users initially so

that we can uh test our application as

we develop it using that data initially

and then we'll also create a

registration facility where we can add

further users but we'll get to importing

the relevant seed data in just a bit. So

let's create a new collection. Let's

call this one genres

like this.

Let's hit the create collection button

here. Excellent. And we've got one last

collection that we need to create. So,

let's hit the plus button here. And this

collection's name is rankings.

And we'll see the data for the rankings

collection in just a bit. But let's

first import the data for movies. Now to

import the seed data you can firstly

download the relevant data from my

GitHub repository. So let's go to my

GitHub repository here. And if we go to

Magic Stream

and this folder, Magic Stream seed data,

you can see a number of JSON files here

that I recommend you download to your

local machine and then you can import

the relevant data into your collection

through a utility within Compass. And

I'll show you how to do that right now.

So, if we go back to Compass, let's

import the data for our movies

collection. And to do that, we hit the

add data button here. Import JSON or CSV

file. Let's select that option and then

doubleclick movies.json here and then

hit the import button. And you can see

I've prepared offcreen 15 data for 15

movies and we've just imported them into

our movies collection here. You got Jack

Reacher, Blitz, Star Trek, The

Undiscovered Country, Star Wars, Empire

Strikes Back. What a classic. And we've

got a few classic movies here. The Good,

the Bad, and the Ugly. Classic from the

' 60s. Unforgiven. Awesome movie. Great.

And then I was talking about the

rankings. Now, we're going to create a

facility that interacts with AI with

OpenAI and it's going to extract

sentiment from movie reviews written in

natural language. You can see here

within each document, each movie has a

movie review.

Um, so for example, this movie is awful.

The AI will extract the sentiment just

in one word, terrible, and the ranking

value makes that sentiment quantifiable.

So, we're taking a movie review written

in natural language and we're

quantifying its sentiment. And you'll

see how useful that can be later on when

we develop that part of the application

relevant to the AI functionality.

Excellent.

And so, let's import the data for the

rankings collection. And it's the same

procedure. We go import JSON like this.

And double click on the rankings.json

file and hit the import button here. And

there we have it. And you can see the AI

will select from the admin review

written in natural language one of these

options, excellent, good, okay, bad or

terrible. And in doing so, the AI is

taking qualitative data written in

natural language and turning it

essentially into quant a quantifiable

value which is represented by each of

these sentiments. So, we've got

excellent, good, okay, bad, and terrible

to choose from here.

Right, let's import the genres. And it's

the same procedure. You click this

dropown, go import JSON or CSV file, and

then double click on genres.json

and click the import button here.

Excellent. And lastly, we have the

users. Let's import the data for the

users collection like this.

Let's hit the import button.

And we've now imported three users, one

of which is an administrator. So Bob

Jones is the only one because he's part

of the admin role. He's the only one who

can actually add reviews to movies.

Okay. So the next thing I'd like to

demonstrate is how we can use the

command prompt to interact with our

MongoDB database. Before we test the

MongoDB shell, I just want to clarify

that this is just one way of interacting

with MongoDB. In fact, in this course,

we are going to use a specific MongoDB

for Go driver from our Go or Golang code

in order to interact with our MongoDB

database. Using the MongoDB shell can be

a convenient way of interacting with our

MongoDB database. For example, during an

appropriate testing phase of your

application or perhaps to diagnose

potential database related issues during

the development phase of your

applications. As stated in this course,

we are going to interact mostly with our

MongoDB database in code via the MongoDB

for Go driver. We'll look at this in

detail a little bit later. So let's fire

up the command prompt like this and then

we need to go into the MongoDB mode if

you like and we can do that with this

command

mongod.

Press the enter key and as you can see

we are automatically

in a database named test here. So it

actually created this database by

default when we went through the

installation process.

So let's create let's run a command that

creates a collection within the test

database. And we can do that with this

command db.create

create collection

and let's name our collection customers

like this and press the enter key. Okay,

one. So that looks good. It should have

created our customers collection and we

can verify that by going into compass

here. Let's go into our test database

customers and there it is. There's our

collection

and let's create let's first clear the

screen and let's create a document

within our customers collection and we

can do that with this command dbc

customers doinsert

one and then we can include the relevant

JSON object like this and we're going to

add a customer named Bob Jones. So let's

give this field

the name name like this. And then let's

include the field value like this within

quotation marks. Bob

Jones.

And the email address email

is Bob

Joneshotmail.com.

Let's press the enter key. Excellent.

So, we've added a document to our

customer's collection. The document is

denoted by the customer, Bob Jones. And

let's verify that Bob Jones has been

added to the customer's collection. And

there's the document for Bob Jones. And

you can see it's added a unique

identifier for this particular document.

And let's for good measure, let's add

another customer to our customers

collection. This time, let's add a

customer called

Sally James.

Let's give Sally a sensible

email address.

Hotmail. Whoops. Should be at

atotmail.com.

And let's press the enter key.

Excellent.

And let's verify that Sally James has

been added to the customer's collection.

And there it is, Sally James. Brilliant.

And then if we want to display, if we

want to query for all of the documents

within our customers collection, we can

run this command. DB.Customers

customers.find

open close brackets press the enter key

and there we have the two documents that

we've just added to the customers

collection displayed to us. Brilliant.

Let's clear the screen

um and let's actually go into the the uh

and let's actually go into our magic

stream movies database. So to do that we

type use magic

stream

movies like this. So we've switched to

Magic Stream movies and then we want to

return all the movies that are saved to

our movies collection. So to do that we

type db dot moviesov

dotfind open and close brackets. Press

the enter key. And there we have our 15

movies. Brilliant.

Excellent. And let's say we wanted to

just return one of those movies. Let's

clear the screen first. We can do that

with this command. DB

dot movies oops movies

dotfind

one and then each movie has a field

named IMDb ID. So you probably know this

but on the internet each movie has a

unique identifier. It's IMDb number. So

I'm using that within our database to

identify them to uniquely identify our

movies. So let's say we wanted to find

the movie called Once Upon a Time in

Hollywood. So we can do that through its

IMDb number or IMDb ID. And to do that

in code, we pass in a JSON object to the

find one method like this. So this field

is called imb_id.

So we don't need the quotations here,

but the field is called IMDb_ID

colon. And then we want to include the

value for the IMDb ID field. TT 713

6 22. And then let's press the enter

key. Excellent. Once upon a time in

Hollywood. The document for Once Upon a

Time in Hollywood is displayed to us.

And our command has executed.

successfully.

Great.

Right. So to install Go on our local

machines, let's navigate

to this URL. So it's https

colon slash slashgo.dev.

It's an easy URL to remember.

Excellent.

And then let's press the get started

button here.

And then let's press the download button

here.

And you can see here we have a number of

installations to choose from. And it all

depends on what platform you are

running. I'm running a Windows platform.

So Windows 10 or later. This will be

compatible with Windows 10 or later. I'm

on Windows 11. So, I'm going to

click on this link here to download the

relevant MSI package.

And then we've of course been through

this before. We got our indicator here

and it's downloading that pretty

quickly. So, we don't have to fast

forward anything. And we're on we've

only got say a few seconds left to go.

That's looking good. Oh,

a bit of a hiccup.

Right, let's fast forward.

And here we go. A few more seconds. Six.

Four. Three. Two. No.

It's another Okay. 4 seconds. 6 seconds.

9 seconds. 8 seconds.

[Music]

Guess my internet's not particularly

good today, but we are getting there.

Nearly there.

Excellent. Done. So now all we need to

do is click on the folder icon here to

go to our downloads folder. And here's

our MSI package. And then to install go

simply double click on the MSI package

and follow the instructions provided to

us in the wizard.

Please wait while setup wizard prepares

to guide you blah blah blah. So the next

button isn't yet enabled. So we can't

click on that just yet. So let's just be

patient here.

Migrating feature states from related

applications. It's doing things behind

the scenes.

Welcome to the Go programming language

AMD 64 Go 1.24.4

setup wizard. The setup wizard will

install Go programming language AMD 64

Go 1.24.4 on your computer. Click next

to continue or cancel to exit the setup

wizard. Let's press next and install

Go. So, what's happening there is it's

detected that I've already got Go on my

machine. So, I'm actually going to exit,

but please go through the instructions,

go through the installation process to

install Go. Right. So, I'm just going to

go no exit here and then finish. And

just going to minimize this. Right. And

then just to verify that I've got Go

installed successfully on my local

machine, I'm going to go into the

command line here and type Go version.

Excellent. So 1.24.2 Windows AMD 64.

That's excellent. So I've got Go

successfully installed on my local

machine. Um just like we did when we

installed MongoDB, we should verify that

Go is appropriately configured within

our path environment variable. So to do

that, we do the same procedure. We type

CIS

DM

CPL here

and we go to advanced and to get to our

environment variables, we hit the

environment variables button here.

So within our system variables, let's

find the path

environment variable settings here.

Press edit and let's see if we can find

go

within the paths configured here. And

here we go. Program files go.bin. And we

can actually copy that to our

clipboards. Go

Windows keyr and navigate

to that directory. And we can see we got

go.exe exe there go FMT.exe. So we've

got the relevant executables in our Go

directory and that has been successfully

configured with for within our path

environment variable. So that's great.

Okay. So let's go out of this here

and the next thing we can do is let's go

to the command line.

I'm actually going to navigate to the C

drive

because we have configured go correctly

within our path environment variable. We

should be able to run our Go commands

from any

directory. So, we're in the C drive here

and let's create our first Go

application. So, to do that, I'm first

going to create a folder. So, I'm just

going to go mk dur and create a folder

called go first

app like this. Press the enter key and

then I'm going to navigate into that

folder that we've just created. Go first

app.

Excellent. And then I'm going to launch

notepad because for this first

application, we're just going to use

Notepad. It's going to be a very simple

traditional Hello World application. So,

we don't need a particularly

sophisticated editor for that. But

when we get down to creating the web API

that we're going to create with Go and

Jenonic, the Genonic web framework,

we'll use Visual Studio code for that.

But for now, let's just use Notepad and

create a basic hello world application.

So, let's initialize our Go application

with this command. go mod init

my app like that. Press the enter key

and then let's launch notepad. So we can

just type notepad. If you've got notepad

appropriately, it's set up. You should

be able to just type notepad to launch

notepad.

And let's save this file

as

main.go. Go.

It's going to go to my C directory.

Go first app. There it is. And then I'm

going to create a file called main.go

here.

Set that to all files so that it doesn't

mess with our extension here. So main.go

is going to be where we write our code.

And let's save that like that. So

firstly we want to designate this go

file as part of a package called main.

So to do that we type package main like

that. Press the enter key. Then we want

to import a particular package that we

can use to write out text to the screen

and we can do that with this package. So

I'm just going to type import

and it's the package we need is called

fmt. Let's press the enter key here. So

every go application has a main entry

point, a method called main and that's

the entry point of the application. So

let's create the function for this

using go. So we type funk and then the

name main like this. Open close brackets

and then we can open and close curly

brackets. And this demarcates where our

go code will be where we're going to

write

some text to the screen functionality

that writes text to screen. So we're

going to use that fmt package

functionality and then the method is

print ln and then we're going to write

uh whoops hello

go world like this.

Let's give it an exclamation mark here.

Let's save that.

And that's our code. That's our first Go

application written. And let's see if we

can run it. Right. So, I've cleared the

screen and let's see if we can compile

our Go application. So, to do that, we

go we type go build like this.

Great. And let's look in that directory

and see if it's created an executable

for us.

And it's created the executable called

my app.exe.

So to run that, we can just type my app

like that. Hello Go world. And we've

written our first Go application.

Brilliant.

Right. So as mentioned earlier, we're

going to be using on both the client and

service side, we're going to be using

Visual Studio Code to develop our

application. So we of course want to

firstly make sure that we have Visual

Studio Code installed on our machine. So

let's type in https/

slash slashcode.visisualstudio.com/d

download

so that we can download Visual Studio if

we don't already have Visual Studio on

our machines. And then it's just a case

of going through the install

instructions as we've done before. So

you want to download the installer by

clicking if you're on a for example on a

Windows 10 or 11 platform, you want to

download this installer here. You want

to click this option here. If you're on

a Mac platform, you want to click this

option here. And of course, this is for

Linux.

So let's click on the Windows option

here.

And we're downloading it. Excellent.

Going very well. Here we've got our

indicator.

And once it's downloaded, of course, all

we do need to do is uh double click on

the relevant file and go through the

installation instructions provided to us

through a wizard.

And that's it. We've got the folder icon

presented to us. And then we've got an

EXE file here which is our installer

executable. And we can just double click

on this

and install. I accept the agreement.

Next. I would actually encourage you to

select this check box here to click on

this checkbox here so that the icon is

readily available on your desktop once

the installation process completes. Then

let's press the next button here. And

then you press the install. I've already

got Visual Studio installed, so I'm not

going to go through this process, but

please go through and install Visual

Studio Code if you haven't yet installed

Visual Studio Code. So, the next thing I

want to do is create a folder on my

local machine. So, cdev

and

Golang.

And you can see I've done a number of

incarnations of the magic stream

application in preparation for this

course. But we're going to create a

fresh new folder where we'll create our

application. And I'm going to call this

folder

magic

stream

movies.

Like that. Press the enter key.

Excellent. So we've got our designated

folder that will house the files for our

application. So we're going to now fire

up Visual Studio Code and firstly create

the infrastructure for our projects. So

we got a React project on the front end,

the client, and we've got a Go which

leverages Jenonic which is a web

framework on the server. Great. So let's

open the folder we've just created, the

fresh new folder. So, open folder

and we want magic movie. No, we don't

want that one. We want magic stream

movies. And let's select that folder.

If you already had Visual Studio Code

installed on your machine, you might not

necessarily have the latest version. And

you can check for updates with through

this menu option here. Check for

updates.

Okay, there are currently no updates

available. So, I've got the latest

version. So, I'm good to go. But if you

haven't yet got the latest version, just

hit the check for updates menu option

here.

Excellent. In this part of the course,

we're going to focus on the server side

code, but just bear in mind, we're going

to then once we finish the server side

code, we're going to come back and

develop the client React code.

Excellent. So, let's create a folder for

the client React code. And we'll call

this folder aptly client. And we'll get

back to this a little bit later. So

let's progress to the server side code.

So let's create a folder called server

which will house our server go code. So

let's create a folder called server. And

then within this folder, let's create a

subfolder

called

magic

stream

movies

server like that. Okay,

excellent. Please note that if you get

stuck at any point or you just want to

reference the final code for the

application, please check out the final

code at this URL. There may be a few

minor differences between, for example,

naming conventions for the files when

comparing the final code to what we've

discussed in the video. But the

differences are very minor. So please

don't be put off by these minor

differences.

Okay. So now let's invoke the terminal

window. You can do that by control back

tick like this. By default, uh it has

selected the root directory of our

solution which will contain both client

and serverside code. So we're in the

magic stream movies folder here. And

we're going to be using PowerShell here.

Okay. So within this directory here, we

want to create a module which will store

all the references to the dependencies

that we will be using in our Go project.

So to do that we first need to be in the

root folder of our serverside code which

is

magic

stream movies server

and then we can type the command to

create our module

our go.mod file. So to do that we type

go mod in it. So we're initializing

our project and this uh file that we're

creating will store all the the

references to the dependencies that we

will be leveraging for our for the

server side part of our application

which will be written in go. Okay. So go

mod init and then the name of our module

this is a best practice will actually be

where our serverside code will be stored

on GitHub. So, we'll be uploading this

serverside code to a designated

location on GitHub. And this is where

our serverside code will reside when we

eventually push it to GitHub. So,

github.com/gavanlon

[Music]

digital.

So, this is my path. So, obviously you

need to upload it to your particular

GitHub path. So you you'll want to

include where your code will be stored

on GitHub. So, github.com/gavlon

digital and then magic

stream movies

and then server

and then magic

stream

movies

server like that. Right. So, Gavinon, so

github.com gavlon digital magic stream

movies server magic stream movies

server. That's where my serverside code

will reside. And as I said, this is just

a best practice. What this will mean is

that for example other users will be

able to import your packages by using

the go get command and then typing the

relevant GitHub path to get your

particular packages to import those

packages into their applications. So

this is why it's a best practice. It

futureproofs your application. Great. So

obviously I haven't yet uploaded

anything to this path but I will be

uploading the relevant code to this path

at the appropriate time. Great. So I'm

going to press the enter key here and

it's created

now the good

file here. Right. So before we start

writing a little bit of code, I suggest

that we firstly install a very handy

extension

that

will enhance our go development

experience basically. So uh to do that

we go to the extensions tab here.

And let's search for Go

like that. And this is the extension we

want to install.

And I've actually already installed it.

That's why this button text is set to

uninstall. So if I press it, it will

uninstall it. But yours might be set to

install, meaning you haven't installed

it yet. And if it's set to install, I

recommend pressing the install button

and installing this very handy extension

here.

So this go extension

contains the following handy

functionality. IntelliSense results

appear for symbols as you type.

Code navigation jump to or peak at a

symbols declaration. Code editing

support for saved snippets, formatting

and code organization and automatic

organization of imports, diagnostics,

build, vet, and lint errors shown as you

type or on save. Enhanced support for

testing and debugging. So, it's well

worth installing this Go extension.

Great. So the next step is to create a

file within the magic stream movies

server folder called main.go. So let's

do that.

main.go.

As discussed earlier when we created our

hello world application,

each go application has its entry point

and the entry point of the application

is denoted by a function called main. So

firstly let's name the package for the

code we're about to write. Let's name it

main like this. Excellent.

Let's import

fmt.

This is the package we are going to use

to write out

our text to the screen within the main

method. And let's now create the

function main

like this.

And let's use the fmt package.

Print line.

And let's print out.

Hello.

Go world. Like that. Okay,

that looks good. Let's make sure we save

our code. Right. And now we want to run

our code. So to do that, we can make

sure firstly make sure you've saved the

code within the main.go file. And then

we can run this command. So it's just go

run dot

and that should run the code within our

main function here. But firstly make

sure that you are in the appropriate

directory the root directory of your

serverside code which in my case is

magic stream movies server like this.

And then go run dot should run our code.

Excellent.

Hello Go world. Great. So now that our

infrastructure is set up appropriately,

we're ready to write our web API code.

Okay. So firstly, we want to make sure

that we're in the same directory as the

go.mod file. So let's navigate to the

appropriate directory. So we want to be

in server slash

magic magic

stream movies server like this and then

we want to type the command that will

import and install the ginonic web

framework package. So to do that, let's

type go

get

dash u like this.

And then we want the path on github to

where the relevant package is. So

github.com

[Music]

jinonic

slashjin like that. Whoops. Jin and then

press the enter key. And it's as simple

as that.

And as always, we have to be a little

bit patient while

the import and installation process is

underway. And we're finished now. That's

brilliant. That wasn't too painful.

Let's clear the screen.

And we're ready to develop basic

functionality using the Genonic web

framework. Excellent. So firstly let's

replace this code within the main

method. Well let's get rid of this code

and then we can start coding the main

method which of course as discussed

earlier is the entry point for our

application. But before we start writing

the code let's have a quick look at

go.mod here. And you can see as

discussed earlier, we have references to

the relevant packages here

from within our gomod file. And we have

this gossum

file which has also been created for us

here since we installed the jinggonic

web framework. Let's go back to the

main.go file and let's write some basic

code. First of all, you can see here

that the FMT package reference here is

underlined. It's got a red squiggly line

under it. And that's just because we've

imported it and we're not currently

using it because we removed our FMT. Ln

code. So, let's write the code for our

Genonic functionality. This is going to

be very basic functionality that we

create just to

test that we've got the Genonic web

framework now installed and is now ready

to use. So firstly let's just write some

basic code using the Genonic

functionality.

Okay. So let's firstly type routter like

that and go rout equals.

So this operator means we are both

establishing or declaring the type for

this variable

as well as assigning a value to it. And

we want to assign jin dot default

to this variable. And you can see here

it's automatically imported gonic.

So

it's automatically imported the jonic

web framework package here.

And the the reason there's a red

underline under router is because we

we've declared and assigned a value to

the routter variable but we haven't yet

done anything with it. Okay. So firstly

we need to actually include open and

close brackets here. And now let's

create an end point a very basic

endpoint initially just for testing

purposes. So this is going to be a get a

HTTP get endpoint. So we go router.get

open and close brackets. And then let's

create the root. So it's going to be for

slashhello

like this. And then let's create a

function

a function handler for our get end

point. So to do that we simply type funk

like this.

open and close brackets. And now we want

to include a parameter within our

function definition. Let's call this

parameter C because it represents the

context of our Jin Gonic web framework.

So this is the context of the incoming

request coming from the client which

allows us to call various functionality

on this C object that is given to us

through the function handler method

automatically.

This is the function handler method for

our for/hello endpoint. Great. So we got

C and then we include the type of C

which is star jin dot context like that.

Excellent. And then let's implement the

code for our function handler method.

So we also want to close the brackets

here. Okay. And all we want to do here

is return C dot string return a string

to the calling code. So we're going to

go C.string 200 which is a restful web

API return value indicating that

the execution of this function handler

method has been successful.

And let's return a message.

Hello.

Magic stream movies like that.

Okay. And we have a little issue here.

And we don't need this bracket here.

That's the problem there. And let's save

that.

And now we need to run the router on a

particular port. So in in go we can do

it like this. We go if

an assignment operator

router.run

and we're going to run

our web framework on this port. So we're

listening on this port port 8080 here on

the server.

And then let's make an assertion. If

error is not equal to null,

let's run

this code which uses now I see that the

FMT package has been removed. We're

going to need the FMT package here

because we're going to write something

to the screen. So if error is not equal

to null, we want to write something to

the screen. And so it's going to be fmt

dot

print ln open and close brackets

and a appropriate message failed to

start server and then comma and the

error like this. And we need to include

FMT here within the imports. FMT.

Excellent.

Um, and nil should just have one L here.

So, let's save that.

And now our server, our web API should

be listening on port 8080. And we should

be able to access through our browsers

this/hello

endpoint and it should return a string

value of hello magic stream movies.

Great. So to run our code,

let's just save that. Make sure that

that is saved first. Then type

go run dot press the enter key.

Great. So it's telling us that it's

listening on port 8080. So we want to go

to localhost port 8080/hello.

And it should return hello magic stream

movies to us through our get request.

And we've got our get request function

handler method which is returning the

relevant status the HTTP status of 200

as well as a message

and that should be printed to our

browsers. So let's go into our browsers.

So I'm going to activate Chrome here.

So I've got Chrome running here and I'm

going to type HTTP.

We're running on HTTP like this

localhost and then we want port 8080

forward slash and we type the name of

our route or the name of our endpoint

hello like this and let's see if that

works. Hello magic stream is printed to

the browser as expected. So our ginonic

functionality in its most basic form is

up and running for us to use. So, we've

created a route and we've been able to

access that route through our browsers

and our function handler method handling

the relevant functionality for our hello

route has been executed and printed the

appropriate text value to our browsers.

It's returned it to the client and

printed the appropriate value to our

browsers. So, great. We're now ready to

write more complex functionality and get

into the substance now of the course.

Excellent.

Okay. So now we are going to get serious

about building our restful web API

solution using Go and Jenonic. So before

we start writing our code, let's firstly

create a basic folder structure so that

we can keep our code neat, clean, and

dry. Of course, dry stands for don't

repeat yourself. So, we want to keep our

code in discrete, easy to find

structures so that as our project

becomes more complex, we don't get lost

when we need to, for example, implement

a piece of reusable code. Right? So,

firstly, let's create a folder named.

So, let's hit this icon here, new

folder, and let's name this folder con

controllers like that. Excellent. This

is where we'll store our controller

code, which will contain endpoint

function handler code used for

implementing logic for our HTTP

endpoints. If this isn't clear to you at

the moment, don't worry. It will become

clearer as we progress with implementing

the functionality for our controllers.

We've actually already created a HTTP

endpoint function handler that handled

the functionality for the hello

endpoint. If you'll recall, it was a

very simple function that returned a

message containing the text hello magic

stream movies to the client.

And the next one we want to create is a

folder called database. So let's select

that. You can rightclick and go new

folder. And let's call this database

like that.

We'll store code here that will leverage

the MongoDB go driver to connect our web

API component to our MongoDB database.

Right. So the next one is middleware.

Whoops. We don't want to create it

there. We want to create it here. So

let's select that folder, right click,

go new folder, and middleware. Like

that. Press the enter key. Got our

middleware folder. We'll implement code

within this middleware folder later when

we implement the authentication and

authorization functionality. The

middleware code is relevant because some

of our endpoints will be protected

meaning only logged on users will have

access to these protected endpoints and

conversely some of our endpoints will be

unprotected meaning a user will not need

to be authenticated before accessing the

unprotected endpoints. The meaning of

the middleware code will become clearer

as we progress with our course and we

get into the authorization and

authentication functionality later in

the course. So the next one we want to

create is a models folder. So let's

select this folder here, the root

folder. Right click new new folder and

let's call this models like that.

Excellent. This is where we'll define

our models which are used to define the

structure of the data that we'll be

handling from within our web API

solution. The structure of the relevant

models will be based on the relevant

document structure seen in our MongoDB

database. For example, we'll create a

movie strct that will be based on the

structure for a movie document stored

within the movies collection in the

MongoDB database. So the movie strct

will represent our movie model which is

based on the movie document structure

implemented within our movies collection

within our MongoDB database.

Great. So the last one actually not the

last one but the next one second to last

one is called roots. So let's create a

roots folder within our root directory.

Okay so here we go roots. Excellent.

Uh here is where we'll write the code

for defining both protected and

unprotected routes. Essentially these

roots define a path that client code for

example JavaScript code running in the

user's browser can use to access the

endpoints defined in our serverside code

our web API code written in Go. As

discussed the unprotected roots pertain

to endpoints that clients can access

without the need to be authenticated

before accessing the relevant

unprotected routes. Protected roots

pertain to endpoints that a user can

access only after being appropriately

authenticated. So the user will need to

successfully log into the system before

accessing protected endpoints. We'll

look at the authentication and

authorization functionality in detail

later in this course. Right. So let's

create the last folder and this is

called the utils folder. So let's

create a folder called utils within the

root directory.

utils. So this is where utility

functionality will be stored. We'll

store code here for reusable helper or

utility functions that can be reused

throughout our web API solution. Great.

So now that we've got our folder

structure in place,

let's create our first file, our first

code file

within one of our newly created folders.

And we're going to create the new file

within our models folder. So to do that,

let's create

a file

called

movie model.go

like this. So we're going to create our

movie strct within this file. To access

our MongoDB database, we'll use a

specific MongoDB go driver. For this

purpose, the ID for our movies model

will be of a data type defined within

this driver. So firstly, we need to

install the MongoDB go driver. So let's

do that. Okay. So firstly, we need to

navigate into the same directory where

the go.mod file is stored. So we need to

navigate to the

server

slash magic stream movies server. magic

stream movies server like that. And now

we just need we can install the MongoDB

driver for go with this command. So the

goget command. So it's goget then go do

db.org org

slash

d-driver

slashv2

slash like that and let's press

the enter key and that should install

the relevant

go driver the mongodb driver for go

as always we need to be a little bit

patient here

while the installation process process

takes place.

Excellent. So now if we look at the

go.mod file,

we should be able to see the reference

here to the new Go driver. And where is

it? There it is. So here's a reference

to the MongoDB driver for Go package

here. Excellent. So we're ready to

create our model now. Let's go to the

movie model.go go file and firstly we

want to define we want to declare the

name for our package that these models

will where these models will reside. So

we're just going to call this package

model

like this.

Excellent. So this means we'll be able

to import the model package which

contains which is going to contain the

various strcts representing our data

models. We'll be able to import the

functionality within this file easily

within other Go files. And you'll see

how we do this in just a bit. The

package declaration at the top of a file

defines the package name to which the

file belongs. A package in Go is a way

to group related files and functions

together. Files that belong to the same

package can share functions, types, and

variables. Note that only exported names

starting with a capital letter are

accessible from outside the package.

Unexported names starting with a

lowercase letter are private to the

package. So these packages can be

imported by other Go programs or

packages. So the name of the package

affects how other Go files or modules

import and use its contents. So this

named package declaration helps us with

the organization of our code. So as our

project grows in size and becomes more

complex, we are able to identify

relevant code efficiently. Now let's

write code to import the relevant data

type information from our MongoDB driver

for Go package. You'll soon see that we

need the BSON.object object ID data type

to define our ID field within the movie

model which is what we're about to

create as a strct. This bson object ID

data type resides within the MongoDB

forgo driver. So let's create an import

block like this. So import like that

then within round brackets we can import

the relevant package. So all we do is we

type

go.mongo

[Music]

db.org

slashgo.mongodb.org

slmongod-driver/v2

slashbson like that. And the only reason

it's got a red squiggly line under it is

because we're not using

the the driver functionality anywhere

yet, but we're about to do that. So

anyway, let's press the enter key and

let's create the movie strct. So let's

uh declare our strruct. And we can do

that with this code here. Type

movie

strct. And that's how we define a strct

and go. Open and close curly braces. And

we want the first field we want to

include is to store a unique identifier

for a movie. So let's call this ID. And

then its type as discussed is

BSON.object

ID. So the first field is called ID and

it's of type BSON.object ID. And this

field is for the purpose of uniquely

identifying a movie document or or movie

data for a particular movie. So, we've

got ID there. And then the next field is

IMDb

ID like this. And it's we're going to

define this as a string like that. Okay.

Just a quick word about the IMDb field.

An IMDb number, often called an IMDb ID,

is a unique identifier assigned by the

Internet Movie Database, IMDb, to a

specific title like a movie, TV show, or

episode or a person like an actor,

director, etc. So, for example, the IMDb

ID for the Clint Eastwood classic

western, Unforgiven, has an IMDb ID of

TT 0105695.

Great. So let's create the next field

which is named title like this and this

will of course store the title of the

movie for example unforgiven the shaw

shank redemption once upon a time in

Hollywood etc. And the next field is

called poster path like this

and it's also defined as a string.

This field is used for storing a

publicly available URL that points to an

appropriate poster image for each of our

movie documents. Shout out to the

movieb.org website. We are using the

poster images available on their website

in our application for this purpose. And

the next field is the YouTube ID field.

So let's create a field called YouTube

ID like this. And it's also of the

string data type.

This field stores a YouTube video ID

that points to a trailer for each movie

document stored within our MongoDB

movies collection. We are using the

trailers on YouTube as a substitute for

streaming the actual movies. You'll see

a bit later how we can use this YouTube

video ID value to run an appropriate

trailer for each of our movies from

within our web application. So let's

include a field named genre like that.

And this field is going to be defined

as a genre strct which we haven't yet

created. And we want an array of genres

stored within the movie strct. Great. So

in this field we are going to store an

array of genres. Each movie can be

associated with one or more genres. For

example, airplane would just have one

associated genre in the array which

would be the comedy genre. Unforgiven

could be associated with more than one

genre. for example, western and drama.

You'll see a bit later in the course how

we are going to use this genre array to

help recommend movies to the user. So we

need to create our own strruct

definition for the genre field which

will store an array of genre strcts. So

let's define the genre strruct like

this.

type

genre

strruct and let's open and close the

brackets like this and then let's create

a field called genre ID and this will be

of the int data type.

So the genre ID field will uniquely

identify each genre within our database.

And then the next field is

genre name and this is defined as

string.

This field will store the actual name of

the genre as a string. For example,

comedy western drama thriller etc.

And then next we have the admin review

field which we'll define as string. This

field stores the movie review associated

with each movie document. So an

administrator which is just a user who

is part of the admin role will create a

review for each movie in natural

language. We'll use open AI through lang

chain go. We'll discuss lang chain go at

the appropriate time and we'll prompt an

LLM through the use of lang chain go to

extract one word to define the sentiment

behind each of the administrators movie

reviews. The sentiment can either be

excellent, good, okay, bad, or terrible.

These options are specified in the

relevant prompt along with the relevant

movie review. The sentiment can then be

stored in a field which we'll name

ranking.

So let's create the ranking field. So

the ranking field here is of type

ranking and we haven't yet created the

strct that represents the ranking type.

and we'll do that now. So let's create

the strct for the ranking data type. So

we do that by typing type and then

ranking

strruct

open and close curly brackets like this.

And this has two fields one named

ranking

value like this

and it is of type int.

So as discussed each sentiment

excellent, good, okay, bad or terrible

has an associated value. For example,

excellent has the associated value of

one. Good has the associated value of

two. Okay has the the associated value

of three. Bad the associated value of

four and terrible has a ranking value of

five. So the next one we want to include

is ranking name and this is defined as a

string data type. So an integer value is

stored in this ranking value field which

is associated with the relevant ranking

name field which as discussed can be one

of the following excellent, good, okay,

bad or terrible. So these fields are

part of functionality that turns a movie

review written in natural language into

a quantifiable value, a ranking if you

like. You'll see later how we can use

these fields to help recommend movies to

users. So the next thing we want to do

is define

how we want our fields to look in BSON

and JSON format. So the BSON format

refers to how the field looks within the

relevant document in the database and

the JSON format is how the data will

look, how the relevant field will be

named. For example, when

the data is returned from our web API

application to calling client code, for

example, to JavaScript code, for

example, running in the browser. So to

do that, we open and close back to

characters like this.

And then for the bon format, we type b.

Then within quotation marks we include

how we want the format to look.

ID like that.

Excellent. And then we can also do the

same for the JSON format. So it's got to

remain within the back characters. And

we type JSON. And in this particular

case,

the ID is represented the same way as

the BON as in the BON format. So it's

underscore lowercase id like that. So we

can define within our strcts how the

fields map to our MongoDB database as

well as to the JSON data that will be

sent to calling client code. So for

example, our ID field must conform to

this BSON format because this is how the

field is defined within our MongoDB

database and we want our ID field to

look the same within the JSON data sent

to calling client code. This may not

always be the case. Sometimes we may

wish a field to look different in JSON

format to what it looks like within the

database.

Therefore, the BSON definition here may

be different to the JSON definition here

in some cases. So, we include these JSON

and BSON definitions within back

characters like this. And let's fill out

the other fields. So bon and we want in

bon format

we want our field represented as imdb

ID and in fact we want the same within

the JSON format.

So we just include the same format here

like that.

And we just really go through here and

do the same sort of thing for each

field. So the title field bson

in quotations title will just be title

like this. And you can see that in all

of the cases so far bon and Jason are

exactly the same.

What have I done wrong there?

Underline bon

genre id.

Okay, so we can't leave gaps like that

or else it complains.

Okay, so interesting. Anyway, let's just

remove that gap

and that s and let's include

the definitions here.

So the last thing we want to do in this

section of the course is create

declarative rules for each of our

fields. we can establish within our

strct rules for each of our fields so

that only valid data is stored within

our strcts. So when for example client

data is passed into our serverside code

at the point where our code maps for

example our movie strct to specific

movie data passed in from the client the

movie data is automatically validated

based on the rules that have been

defined. So establishing these types of

rules can for example protect our

database from being updated with

undesirable data. So let's look at the

IMDb ID field.

So for this field we want to include

validation

whereby this field cannot be left empty.

So validate. So if the client passes in

data representing a movie,

this field is required. So it cannot be

empty. So we include the required

keyword here within quotation marks like

that. So this validate

keyword here

is associated with a comma delimited

string of criteria validation criteria

represented by keywords like for example

the required keyword like that. So we're

only going to include the required

validation criteria for the IMDb ID

field here.

Okay, let's move on to the title field.

And for the title field, we want it to

be required. So we include the same

thing as we did in the other in the IMDb

ID field. So we include required like

this. But we also want the title field

to contain more than two characters. And

we can enforce that rule by using the

min equals 2 code here within

quotations. And we can also include a

max. So we don't want this field to

contain more than 500 characters. So we

can include max equals to 500 to enforce

that rule. Oh, still got a brown

squiggly line there. Can't believe it.

Oh, it's cuz that needs a space there.

Okay, perfect. So that now is formatted

correctly. So the the yellow squiggly

line went away. No more warning. Okay.

Okay. Let's move on to the poster path

field. And we want this to be a valid

URL. So let's include validate

colon within quotation marks. We first

want to include required. This has to be

filled in. This has this poster path

field cannot be empty. and then comma

and then we can include the URL keyword

which means it has to be a valid URL for

this path here. Okay, required URL and

we have problems here. All right, and

it's because we haven't closed off

poster path here. Okay, and now it likes

it. It's okay. All is well. Okay. So

within here validate and we're just

going to include a required

validation criteria here. Okay.

Brilliant.

Genre. So for genre we want it to be

required

but we also want the validation to dive

into the nested array.

So let's first include required here.

Let's first include required and then

dive. This keyword dive ensures that the

nested structure here which is an array

of genres will also be validated. And

we'll include the various validation

criteria in just a bit for the genre

strct. Okay. And this one here, the

admin review will just be

we'll just include the required

keyword

like that. Okay. And we'll just include

required validation

for the ranking field.

Okay.

Required. Right. So let's move on to the

genre strct and we've got as you can see

here we've got the dive keyword. So this

will also be validated. So let's include

the criteria and this must

be required and that's all we need for

the genre ID.

Okay. And then for the genre name

we'll include we'll include the required

criteria

but also min and max

criteria. So min equals to two whoops

max equals to 100.

Lastly we just need to include the

validation criteria. Oh, and we haven't

included the BSON and JSON

definitions here either. So, let's do

that first. So,

so validate,

let's just make this required

like that there. And then let's include

the declarative code for the the

appropriate declarative code for the

ranking name field. So this is just

ranking

name

ranking name. It's a required field. And

now you could establish a little bit

more complex validation for this field

because you might want to include

validation where only

one of the following values

can be stored within this field. So to

do that

you can go comma one

of. So perhaps you don't need the

required because you're already telling

it that one of these must be in the

field. So we go one of

equals

excellent. So this is delimited by a

space these values. Excellent.

Good.

Okay.

bad,

terrible.

But you may want this field ranking name

to be extensible

because the way I've designed this

application is that you could

potentially create a huge spectrum of

sentiments, not just excellent, good,

okay, bad, and terrible. So you must

bear in mind that this functionality can

be be extended in which case you you'll

have to change that here. So in fact I'm

going to remove this because it's a bit

too restrictive especially at this point

in the development process. So I'm just

going to make this required.

Brilliant. And that's it. So in this

part of the course we are going to

create an endpoint and an endpoint

function handler named get movies within

a controller that returns movie data to

a calling client. We'll write code to

query our movie collection from our

MongoDB database and return all the

movie data to a calling client. We'll

use the Jin Gonic web framework to help

with HTTP requests and HTTP responses.

And we'll use the MongoDB driver for Go

to query our movies collection within

our MongoDB database. We'll then send a

HTTP response to the calling client that

will contain a list of movie data. But

firstly, let's get set up with the

basics for our get movies endpoint

function handler and then set up the

endpoint that will make it easy to

invoke the functionality in our get

movies method via HTTP. Okay, so we're

firstly going to create a file within

the controllers folder. So let's select

the controllers folder here and let's

click this icon here to create a new

file. And let's call this file

movie_ontroller.

So we are using a common naming

convention here which is snake case for

the name of our movie controller file.

Excellent. Um and because I'm using

snake case here, we should probably use

snake case everywhere to keep things

consistent. So I'm just going to rename

the movie model.go file to movie

and then a lowercase M here for model.

Great. So that's now consistent. We're

using the same naming convention for

these files. So let's go back to the

movie_controller.go

file and let's name the package. So we

want our package to be named

controllers. Yep.

Like that.

So we've got our models our model

package here. Yes. Okay. So this package

we should have named models. So I'm

going to do that now. I'm going to name

this package models so that we're being

consistent with our naming convention.

So this is a package named models which

contains

movie model and this is the

movie_controller

file and it's part of the controllers

package. Great. Let's create a block for

our imports

like that.

Right out of the gates, I'm going to

include

the gingonic

package.com.

So, this is the package for the gingonic

web framework

for slashjin like that. Let's save it.

Excellent.

And in fact, that should be import not

imports.

Okay. Okay. And this red squiggly line

is just because we're not currently

implementing any code regarding the G

jinggonic web framework. So let's

implement a function called get movies.

And ultimately this function will be

used to return a collection of movie

data queried from our movies collection

that exists within our MongoDB database

and return that to the calling client

code. So let's create the function. We

use the funk keyword and we want this

function to be exportable. So it's going

to the first letter must be capitalized.

If the first letter was not capitalized,

it means the function is a private

function. But we want this to be a

public exportable

function. So we're going to capitalize

the first letter here. Get. And let's

move these like that. And you can see

it's in camel case. And let's open and

close brackets like that. And now this

function must return a jin dot

handler funk type because we're now

going to actually return a function from

the get movies function. And within the

return function will contain our

implemented logic. So let's type return

like this.

funk open and close brackets C and then

star jin dot con

context like that

and then open and close curly brackets

and we're going to then implement

sorry there should be a curly bracket

here

open the first function and then a

closing bracket here to close the nested

or the returned function here. And you

can see now those red squiggly lines

have actually disappeared here because

we're now implementing a function

handler that uses Genonic. This is how

we're hooking into the Genonic web

framework. So here we are able to

interact with the Genonic web framework

through a function that returns a

function. The interaction with Jenonic

is facilitated by our endpoint handler

function that returns a gingonic type

jin. handler funk. So basically get

movies returns a function of type jin

dot handler funk. Through this context

object denoted by the C parameter name

passed to our HTTP endpoint handler

function get movies. We are able to read

incoming HTTP requests as well as create

HTTP responses. So let's create the

relevant response. So we're just going

to create a test response for now and

then after this just so that we can test

our root. We're going to set up our root

for our endpoint and map that route to

the get movies function handler. So

firstly we're just going to create a

basic JSON response here.

So we're keeping this very simple just

so that we can set up. So return 200

HTTP status. Okay. And then we can use

jin.h H to help us return a valid JSON

message to the calling client. So let's

go message

list of movies.

Of course, in the actual end code, we're

going to be we're going to actually

return a list of movies, a list of movie

data. But before we do that, let's just

set up our route correctly so that we

can access the get movies functionality

through an endpoint. So to do that,

let's go to the main.go

method here and let's create a new

endpoint.

Let's go to do that. Let's go rout.get.

We're using an HTTP get request to

access this endpoint. This endpoint is

going to be for slashmov. And then we're

going to map that to to our method. So

firstly, in order to do that, we need to

actually import

our controllers package into the main

package. And to do that, we simply type

the following controller

and then within quotations.

And I'll explain what the controller

keyword here represents in just a bit.

But let's include the path to or the

name of our package, the full name of

our package which includes

github.com/gavanlon

[Music]

digital

slashmagic

streamovserver

slashmic

check stream movies

server and then forward slash

controllers.

So this might look a bit weird to you at

the moment, but let's go back to when we

created the go.mod file. If you look

here, we named this github.com gavanlon

digital magic stream movies server magic

stream movies server. So we want all of

our packages to stem from this root path

basically and this just makes it more

futurep proof our code and ultimately

easier for another developer to import

our packages into their application.

So we're going to keep this path as our

root path and then all the other

packages that we create will stem from

this. So for example, if we wanted to

import our models, you would just

include this root path forward/models

and the same for controllers. So let's

go back to the movie_controller

file here.

And you can see that this package is

named controllers. So if we go to the

main.go file,

we have controllers appended to this

root path if you like. So, github.gavlon

digital magic stream movies server magic

stream movies server controllers and you

can make sure that that's correct by

just copying and pasting that. So if you

copy that, go back to the main method to

the import section here and you can just

paste that in there

forward slash controllers

like that. And we're doing this so that

we can access the get movies endpoint

function handler that we just created in

our controllers package. As mentioned

earlier, this get movies function is

exportable because the first letter of

the function name is capitalized. If get

movies had a lowercase G, it would be

deemed as private and therefore not

exportable. So because it is exportable,

we can access it from within the main

method once the controller package has

been imported. So here we are importing

the controllers package like this. Now

you can see here we are using this

import alias and this is just for

readability. So instead of accessing the

get movies method via controllers, we

are going to use this import alias

controller. So that's why there's a red

squiggly line under it because we're

currently not using it and we're about

to use it here. Great. So now let's

access the get movies

function from the controllers package

and we because because we're using an

alias controller we can type controller

here dot and in intellisense we've got

get movies and that's the one we want.

So we are mapping the for slash movies

endpoint to controller.get movies here.

And if we just go back to get movies, we

can select that and go to

go to reference. Sorry, go to

definition.

Okay. And you can see we are just

sending back a JSON object to the client

message list of movies. So we should be

able to run this, go to our movies

endpoint and receive this message.

Assuming that our route has been set up

as we wish it to be set up and we're

declaring how we wish it to be set up

with this line of code here. So let's

run it. Let's first go into the root

directory. CD server

CD

magic

stream

movies server

and let's type go run dot

okay and it's listening on port 8080. So

if we go to port 8080,

we should be able to.

We want local host, but we don't want

that port. We want 8080,

not hello this time. We want movies.

That's our endpoint. If we click the

enter key, if we hit the enter key

rather,

oops 88

that's not what we want. We want 8080

there. And there we go. Message list of

movies. So this means that our end point

has been successfully mapped to the get

movies method, which is what we want. So

now we are in a position to query our

MongoDB database and return the actual

movie data to the client. So let's get

on with that then. So let's go back to

our code here

and cancel out of that. Clear the

screen.

And now that our route is set up, let's

complete the logic for our get movies

function handler method. Right. So I'm

going to delete that. So now that we

have our for/mov endpoint

and we've mapped it to our get movies uh

function handler, let's create the code

that queries our magic stream movies

database and returns the document data

within the movies collection to the

calling client. But before we do that,

we need to create reusable code that

will connect our web API solution to the

MongoDB database. And that will be done

through the use of the MongoDB for Go

driver. Let's create a file within the

database folder here.

New file and let's name it database

connection.go

like this. Press the enter key. package

database. So the code within this file

will belong to the database package.

Let's include an import block like this.

And we want to import FMT the FMT

package so that we can write certain

values to the screen. This is good for

when we're during the testing phase of

our development during the testing and

development phase. And we want to be

able to log information. So let's

include the log package. And we want to

include the OS package. And this package

will be used for reading environment

variables which we will configure in a

bit within a file called env. And now

very importantly we need to import the

MongoDB for Go driver packages. So if we

go to go.mod,

we can see we've installed

the driver here. So we can

actually just import the packages. We

actually went through the install

process already. Oh yes, and the reason

we've already installed that is because

we needed the bison.object

ID

data type which resides within this

package here. That's why we've already

installed it.

Okay. So let's go back to the main.go

file. Sorry, we want to go back to the

database connection.go file here.

Okay. And let's include the following

imports. So we want go.

MongoDB.org

or

slash

dashd driver/v2

slash

like that.

So go.mongodb.org/mongod

org/mongod

driver/v2/mongo.

And then we want a similar import here,

but this time we include a forward slash

options. And we'll see the package

functionality in action in the context

of our database package in just a bit.

And of course, they have these have all

got red squiggly lines under them

because we're not using any of the

functionality of these packages yet. So

we're going to create a function called

DB instance which will be used for

connecting our Jin Gonic web API

application to our Mongodb database

through the use of the MongoDB forgo

driver. We have already imported these

driver related packages for this

purpose. Okay. So let's create our DB

instance method. So to do that we type

funk DB instance like this open and

close brackets. And we want this to

return a value of type

client like that. Let's open and close

curly brackets.

And the first thing we actually want to

do is read an environment variable.

So to read an environment variable from

av file, we actually need a particular

package and we haven't yet got that

installed. It's called joo/go.env.

So to install it, we use the goget

command. So let's type goget

and then it's github.com/

[Music]

slashjo

slashgo.ev.

So go get github.com/jo/go.env.

Let's press the enter key.

And it's done it for us. Excellent.

So we can verify that. If we look at our

go.mod file, we should be able to see a

reference to it here. It should have

added it.

And there it is. Great. Okay, so let's

create the code for our DB instance

method. So as discussed, we want to

access av file, but we don't yet have an

env file to house our uh various

environment settings. So to do that,

let's rightclick magic stream movies

server here. Let's go new file and then

create a file called

env.

So the first environment variable that I

want to configure is called database

name.

So let's configure our database name

here. And we've called our database

magic

stream

movies. We can verify that. Let's just

save that. And we can verify that by

going to compass. Let's launch compass.

Okay. So, magic-stream.mmov,

that's what we've called it.

Okay. That's what we've called our

database. So, let's go back to

the code

and change this to

magic dashream

dash movies like that.

And then the other environment variable

that we want to create is called

MongoDB

uri. So this is a pointer to our MongoDB

database. This is a connection string to

our MongoDB database and we can

configure it here. And this will make it

easier for when we deploy our

application to the cloud later on. And

we can just configure the new location

of our database here. The new connection

string for our remote deployment

deployed version of our MongoDB

database. We can just configure that

connection string here. So let's

minimize that and go back to compass.

And we can actually get our connection

string

from here like this.

So we can just click on this and copy

the connection string to our clipboard.

So, let's head to this option here

and then we can

then we can just paste it in here.

Excellent.

Okay. And let's go

back to our database connection.go file.

Okay. So, the first thing we want to do

is load our uh file that contains our

environment variables into memory. And

we can do that with this line of code.

[Music]

env.load

and then in quotations env like this.

And oops. And if a error has occurred

while trying to load this file, it means

it might be deployed

to a remote server that doesn't contain

this file. So we're actually just using

our environment variables

locally at the moment and that's why

we're using this particular package. The

environment variables will be configured

differently um when we deploy it to the

cloud. But we need this line of code

here. So in fact this line of code will

return an error in the cloud. So we

don't want it to be a fatal error. We

just want to check for the error and we

can just print it to the screen. Just

print a warning telling us that the env

file does not exist. And this is this

probably is harmless because it means

that it's deployed to the cloud and it's

reading the environment variable a

different way. We'll cover that in more

detail when we deploy the application to

the cloud. So if error does not equal to

null, this means an error has occurred,

which probably means that the env file

does not exist, which probably means

that the version that's running is a

deployed version and the environment

variables are not configured within av

file. But we'll discuss this a bit

later. So I'm just going to print a

warning message to the screen. warning

unable to find.

Envile

like that. Great. So if you had for

example gone log.fatal here, the code

would actually stop. It would print the

the error to the screen, the error

message to the screen and this function

would and the execution of this function

would discontinue

at this point. So, we want to

print it

as a warning message so it's not a fatal

error. Great.

Okay. And then let's read the

environment variable. So, let's include

this line of code

that assigns

that assigns the relevant environment

variable. We're using the OS package

here. Get

env method and we want to read

a particular environment variable. We

want to read the Mongodb

URI environment variable. So let's go

back to that and paste it here. And then

we can check. So if

db

is equal to an empty string then some

sort of issue has occurred

and our application cannot really

continue without this information. So

we're going to log a fatal error this

time. dot fatal. We don't want the code

to continue after this point. So we go

log.fatal fatal and we can output

a message saying MongoDB URI not set

not set that should do okay can't read

the MongoDB URI which contains the

connection string

and we can just make we can just print

that using FMT to the screen we can

actually print the

the relevant environment variable to the

screen using the FMT package like this

comma

db like that.

Excellent.

So now that we've got our URI,

we should be able to connect

our code here, our client code in this

case. Even though it's serverside code,

it's in the context of connecting to the

MongoDB database, it's client code. So

we can go client

options

colon equal options

dot

client

open and close brackets dot apply

uri and then let's include the readin

environment variable which is mongod db.

Excellent.

And then

now that we've read in the actual

connection string,

we want to actually connect to our

database,

our MongoDB database. So let's do that

with this line of code. Client,

error. You see this function that we're

about to to call returns two

values.

one which is a Clyde object and the

other which potentially contains an

error. If the code hasn't been executed

for some reason, if the code could not

be executed for some reason due to an

error, this object will contain a value.

Great. So now we call mongo.connect

connect and we pass in the client

options

to connect to our MongoDB database.

So if error

is not equal to null, we'll cover error

handling in just a bit. We'll cover the

details of error handling in just a bit.

Let's first write our DB instance

method. Let's just get the fundamental

code in place first and we'll look at

some of the details in just a bit.

So if it's not equal to null, I'm

actually just going to return null to

the calling code.

In fact, let's return the in fact.

So if is not equal to null, let's just

return

error to the calling code.

This means the code will cease to

execute after this and it will return

whatever error occurred at this point in

the code. And if no error has occurred,

let's return

the client object.

For now, let's just return null. If the

error occurs at this point, we'll just

return null just to get things up and

running. We can handle the details of

that exception a bit later. So now we

want to create a method which opens the

actual connection to our database.

So let's create a function

called open collection

like this.

And this function contains a collection

name parameter

as a string. So for example, if we are

querying the movies collection, movies

will be passed in here as a string.

Okay. And we want this to return a

collection. So

collection like that open and close

curly brackets. And we can implement the

logic for this method now. Okay. So we

need to firstly load the env file to see

if it exists.

and it will exist if the code is running

locally but perhaps not if but won't

exist if we've deployed it to the cloud.

So let's do a check for that. Let's go

gov.load

and let's load the env

file here like that.

So if uh

is not equal to null,

let's do the same thing. We're just

going to

print a warning.

Okay,

like that

the env file doesn't exist. And then we

want to read the relevance environment

variable at this point. So, and assign

it to a variable called database

name. And you can see that we're using

this special operator here, colon

equals, which means it's actually

declaring the variable and its type.

It's inferring the type by the returned

value here. So, get the get env

method

returns a string data type. Therefore,

database name because we're using this

particular assignment operator, it knows

that database name go knows that

database name is defined as a string at

this point. So, we don't have to

explicitly for example in a line up here

go something like string database name

because it already knows that this is a

string based on what is returned by this

method. Okay, let's go data base

name like this.

Okay. And we can go use fmt

print ln just to for testing purposes to

make sure that the correct database name

is indeed being read from the

environment variable. And we can just

output it here like this.

Okay. And that's just for testing

purposes.

Great. Now we want to actually

load the relevant collection. So to load

the collection we go collection

and once again we are inferring its type

by the returned value from

a method which we'll write

right now and we actually need the

client object at this point.

So outside of all of our methods we want

to create a client object based on the

DB instance.

So the client returned from here will be

our client object.