Master Go with Gin and GORM: Build Fast, Scalable APIs

Explore go root and go path, create your first go project in IntelliJ, and locate the standard library and workspace. Understand using go env to manage dependencies and deployment.

Explore Go packages and Go modules, learn reuse through libraries, and distinguish packages from modules using a practical project structure with controller, domain, and repo.

Master Go variables by distinguishing local, global, and constant types, applying clear naming conventions, and using capitalization to indicate public versus private access.

Master Go variable declarations with var, new, and make, learning default values, pointers, and memory allocation for maps, slices, and channels.

Learn how to declare and initialize maps in Go using var, make, and shorthand syntax, and understand nil maps, memory allocation, and safe key-value operations.

Learn how to declare Go slices using literals and make, append values, access elements by index, and slice ranges to obtain sub-slices, while handling data types like ints and structs.

Explore Go flow control, including the empty interface, the for loop as a while-like construct, and range on slices and maps, plus switch statements.

Master Golang structs to model custom data, including nesting address fields, using type and struct literals, and accessing struct fields to prepare data for UI and database storage.

Learn how to define golang functions with the func keyword, including parameter lists, return types, and multiple values, and explore passing by value or pointer using examples with structs.

Explore Go interfaces and methods to enable polymorphism in Go. Learn how to declare interfaces, define methods with receivers, and apply them to build reusable API components.

Explore how to convert json to map and to struct in Go using json.Unmarshal, and learn to marshal structs back to json for API responses and persistence.

Go pointers explain how a memory address is stored and dereferenced to modify the same order object across services without copying, illustrating practical use with an order example.

Explore variadic functions in Go, using examples of int arguments, and master exception handling with panic, recover, and defer to ensure robust programs.

Build a real-world e-commerce API in Go using a reusable library for database configuration and HTTP calls to reduce boilerplate, with notes on synchronous vs asynchronous communication.

Build a microservice e-commerce app using six services with separate PostgreSQL databases, employing synchronous HTTP communication for order, customer, product, payment, and notification flows, with shared config and utils libraries.

Build a microservices e-commerce API using Go, Gin, and Postgres. Create a GitHub repo, set up a Postgres database, and implement the customer service with a customer table.

Develop a Go-based customer service with Gin, Gorm, and Postgres, detailing dependency installation and a modular package layout that includes router, controller, service, repository, domain, DTO, and mapper.

Create domain and DTO Go files to mediate data between the database, service, repository, and controller, modeling customer and address with JSON-based DTOs for requests and responses.

Implement a reusable config library in go using viper to read environment variables and yaml config for database connections, support singleton access, and build a postgres dsn for cross-environment deployment.

Configure a postgres database connection in go using the config library, build the DNS, open the connection, and set max lifetime and max open connections.

Implement a config-driven orm database setup by creating a db struct with an orm instance and a database interface, and open a Postgres connection.

Initialize git, commit the go config library, set the main branch, push to remote, copy the config url, and run go get in the customer service module.

Configure the Go config module to use github.com as the module path, aligning with your GitHub repository, then use go get and commit push to manage updates.

Delete dorsum, generate new go config files, push changes, and integrate go config into the Ecomdash app; prepare controller and services using the library for database configuration and environment variables.

Implement a customer repository in go with gorm, defining an interface and impl for create, find all, update, find by id, and delete using the domain model.

Implement a customer service layer in Go using Gin and GORM, including delete and find by id operations, repository patterns, and service integration for scalable APIs.

Implement the customer service layer that maps controller DTOs to domain models and calls repository methods. It supports create, find all, update, and delete operations with proper error handling.

Implement a Gin-based customer controller with endpoints for creating and deleting customers, binding JSON to a create customer request, and delegating to the customer service while returning structured responses.

Implement controller functions for customer service, including update, delete, and find operations, convert IDs from path, bind json to update requests, and handle errors with internal server responses.

Create a customer router using Gin to expose api/customer with get all, create, get by id, update via patch, and delete operations, using path variables and testing with Postman.

Learn to connect a go application to postgres by using a config library to load host, port, user, password, and db name, then wire db open, repository, service, and router.

Fix the postgres driver import in the config library by adding the missing dependency, running go mod tidy, committing changes, and reimporting in the customer service workflow.

Implement a versioning pattern for the go config library to prevent main-branch issues, including cleaning caches, tagging v4.0.0, and updating imports to v4 across services.

Run and test the customer service API using postman, sending JSON to localhost:8080/api/customer to create, retrieve all, retrieve by id, update, and delete customers with embedded address data.

Create product service and domain models in Go, scaffold six packages, and build PostgreSQL category and product tables with sequences and a category_id foreign key.

Define and implement product dto and requests to exchange information between the API and external world, including product request, update, and purchase requests, with generic error and category-based product responses.

Implement a Go product repository using the repository pattern with create, find by ID, update, delete, and find all, powered by GORM and SQL queries joining products with categories.

Build a service layer for the product service project by converting requests to domain models, wiring repository calls, and implementing create, find all, find by id, update, and delete operations.

Implement a product purchase flow by validating requested product ids, checking stock sufficiency, updating the database quantities, and returning a mapped purchase response.

Create a robust product controller using gin in Go, implementing find all, find by id, create, update, delete, and purchase operations, with json binding and structured error handling.

Create a product service router with gin, exposing endpoints for get all products, get product by id via path variable, create, update, delete, and purchase product.

Connect the product service to the database by integrating the reusable go config library, wiring repository, service, and controller, configuring, and running the server on port 8090.

Test the product service by running the app and using postman to create products with name, description, and category id. Fix joins and gorm queries to retrieve all products.

Test the product service by performing purchase, update, and delete by id, exercise get all and get by id, and map aliases like product_name to fields, handling not found errors.

Test budget product purchases via an HTTP request, validating non-existing products, stock checks, and quantity subtraction in the product service; prepare for payment and notification services.

Build your payment service in the Go project by creating a payment_service module with controller, domain, dto, repo, and service, and attach SQL to create a sequence and payment table.

Define payment request and response dtos, set amount as float64, implement a payment method enum in an inner package, and include order id, customer data, and a generic response struct.

Implement the payment repository to insert a payment record into the database after an order is created, returning the payment id using a single function.

Implement a payment service by renaming the payment table column to customer_id, wiring a customer service interface and its implementation, and exposing a create payment controller to handle requests.

Create a payment service router and controller, wire in the config and database, and start an http server on port 8000 to handle a post payment endpoint.

Test the payment service by sending a post request to localhost 8000/api/payment with a json body, and verify the returned payment id along with customer and order details.

Build a reusable Go HTTP service library for inter-service calls, including get/post/put/delete and header handling. Implement authorization token handling and JSON response parsing for order, customer, and payment services.

Commit and tag a Go service library by staging changes, creating a v1.0.0 tag, and pushing to the repository, then update the order service with go get module@v1.0.0.

Build a Go notification service for order and payment confirmations, modeling non-persistent customer, order confirmation, purchase, and payment confirmation data, using mail dev for testing.

Build an email service for order and payment confirmations in a Go Gin GORM API, using an interface, order confirmation email sender, and HTML templates.

Create a payment confirmation email template and sender, renaming payment amount to payment method, and generate an HTML template via AI; prepare to test with controller in the next lecture.

Create a notification controller and router for payment and order confirmations using Gin in a Go microservice, wiring email service and routes for order and payment confirmations.

Create and wire order and payment notification controllers using services, with asynchronous email delivery via a queue such as Kafka or AWS, and configure routing, docker, and port setup.

Set up a docker mail server to test the notification service, configure docker compose for mail db, and validate order confirmations via the mail api in the app.

Debug and fix the payment confirmation email template by ensuring recipient, subject, and mime type, and outline integrating order, payment, and notification services with HTTP utilities.

Build a full order service by modeling orders and order lines, wiring domain, repository, and service layers, and integrating payment, product, and customer service clients.

Build http clients for the order service in Go, integrating customer and payment services, configuring URLs, performing get and post requests, and processing json responses with dto structures.

Improve order creation and product purchase processes by implementing an order request, calling a product service to update stock, and handling errors and responses.

We build the order repository interface and the order line repository, enabling get all, create, and find by order id, and set up the order service in the next lecture.

Implement a service layer for the order service by defining an interface, validating customers, checking stock, creating orders and order lines, and issuing payment requests.

Implement the email component in the order service using synchronous communication with the notification service to send order confirmations.

Implements the find all orders function by querying the order repository, handling errors, and building a concise order response with id, order id, customer id, amount, payment method, and reference.

Implement order controller and service logic to create and retrieve orders, handle errors with internal server error, and respond with order data and IDs.

Build the order router with router.go, connecting the order controller to expose get all and create order at /order. Set up main.go and database connection, and run on port 9000.

Add a payment confirmation workflow by calling the customer service and notification service after a successful payment, sending a payment confirmation email with customer details and order reference.

Fix order and payment services by correcting customer and purchase data structures, updating product and notification client calls, and properly converting values with strconv before testing the full app.

Test the multi-service Go application by running each service, seeding data with SQL, and creating a customer, product, and order via Postman; debug the purchase flow and email notifications.

Verify the order service integration by creating multiple orders, handle product not found errors, and confirm payments and emails when product IDs exist.

Explore miscellaneous topics in Go, including gRPC, serialization, security and authorization, time functions, and channels for concurrency, then learn the Gin web framework, middleware, validators, reusable components, and architecture.