tyrel/preorder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor

Browse Source
This commit is contained in:
Tyrel Souza 2024-06-19 22:49:55 -04:00
parent 7902f42c46
commit 231fce5077
No known key found for this signature in database
GPG Key ID: F3614B02ACBE438E
18 changed files with 283 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +1,2 @@
preorder
.idea

65
authors/controllers.go Normal file
View File

@ -0,0 +1,65 @@
package authors
import (
"net/http"
"preorder/config"
"github.com/gin-gonic/gin"
)
func FindAuthors(c *gin.Context) {
var authors []Author
config.DB.Find(&authors)
c.JSON(http.StatusOK, gin.H{"data": authors})
}
func FindAuthor(c *gin.Context) {
var author Author
if err := config.DB.Where("id = ?", c.Param("id")).First(&author).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
c.JSON(http.StatusOK, gin.H{"data": author})
}
func CreateAuthor(c *gin.Context) {
var input CreateAuthorInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
author := NewAuthor(input.ID, input.FullName)
config.DB.Create(&author)
c.JSON(http.StatusOK, gin.H{"data": author})
}
func UpdateAuthor(c *gin.Context) {
var author Author
if err := config.DB.Where("id = ?", c.Param("id")).First(&author).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
var input UpdateAuthorInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
config.DB.Model(&author).Updates(input)
c.JSON(http.StatusOK, gin.H{"data": author})
}
func DeleteAuthor(c *gin.Context) {
var author Author
if err := config.DB.Where("id = ?", c.Param("id")).First(&author).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
return
}
config.DB.Delete(&author)
c.JSON(http.StatusOK, gin.H{"data": true})
}

2
models/author.go → authors/models.go
View File

@ -1,4 +1,4 @@
package models
package authors
type Author struct {
ID uint `json:"id" gorm:"primary_key"`

12
authors/router.go Normal file
View File

@ -0,0 +1,12 @@
package authors
import "github.com/gin-gonic/gin"
func ApplyAuthorRouter(router *gin.Engine) *gin.Engine {
router.GET("/authors", FindAuthors)
router.POST("/authors", CreateAuthor)
router.GET("/authors/:id", FindAuthor)
router.PATCH("/authors/:id", UpdateAuthor)
router.DELETE("/authors/:id", DeleteAuthor)
return router
}

18
config/db.go Normal file
View File

@ -0,0 +1,18 @@
package config
import (
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
var DB *gorm.DB
func ConnectDatabase() {
dsn := "root:password@tcp(db:3306)/db?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
if err != nil {
panic("Failed to connect to database")
}
DB = db
}

74
controllers/author.go
View File

@ -1,74 +0,0 @@
package controllers
import (
"net/http"
"preorder/models"
"github.com/gin-gonic/gin"
)
func FindAuthors(c *gin.Context) {
var Authors []models.Author
models.DB.Find(&Authors)
c.JSON(http.StatusOK, gin.H{"data": Authors})
}
func FindAuthor(c *gin.Context) {
var Author models.Author
if err := models.DB.Where("id = ?", c.Param("id")).First(&Author).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
c.JSON(http.StatusOK, gin.H{"data": Author})
}
func CreateAuthor(c *gin.Context) {
var input models.CreateAuthorInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
author := models.NewAuthor(input.ID, input.FullName)
models.DB.Create(&author)
c.JSON(http.StatusOK, gin.H{"data": author})
}
func UpdateAuthor(c *gin.Context) {
var Author models.Author
if err := models.DB.Where("id = ?", c.Param("id")).First(&Author).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
var input models.UpdateAuthorInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
models.DB.Model(&Author).Updates(input)
c.JSON(http.StatusOK, gin.H{"data": Author})
}
func DeleteAuthor(c *gin.Context) {
var Author models.Author
if err := models.DB.Where("id = ?", c.Param("id")).First(&Author).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
return
}
models.DB.Delete(&Author)
c.JSON(http.StatusOK, gin.H{"data": true})
}
func ApplyAuthorRouter(router *gin.Engine) *gin.Engine {
router.GET("/authors", FindAuthors)
router.POST("/authors", CreateAuthor)
router.GET("/authors/:id", FindAuthor)
router.PATCH("/authors/:id", UpdateAuthor)
router.DELETE("/authors/:id", DeleteAuthor)
return router
}

74
controllers/format.go
View File

@ -1,74 +0,0 @@
package controllers
import (
"net/http"
"preorder/models"
"github.com/gin-gonic/gin"
)
func FindFormats(c *gin.Context) {
var Formats []models.Format
models.DB.Find(&Formats)
c.JSON(http.StatusOK, gin.H{"data": Formats})
}
func FindFormat(c *gin.Context) {
var Format models.Format
if err := models.DB.Where("id = ?", c.Param("id")).First(&Format).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
c.JSON(http.StatusOK, gin.H{"data": Format})
}
func CreateFormat(c *gin.Context) {
var input models.CreateFormatInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
format := models.NewFormat(input.ID, input.Format)
models.DB.Create(&format)
c.JSON(http.StatusOK, gin.H{"data": format})
}
func UpdateFormat(c *gin.Context) {
var Format models.Format
if err := models.DB.Where("id = ?", c.Param("id")).First(&Format).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
var input models.UpdateFormatInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
models.DB.Model(&Format).Updates(input)
c.JSON(http.StatusOK, gin.H{"data": Format})
}
func DeleteFormat(c *gin.Context) {
var Format models.Format
if err := models.DB.Where("id = ?", c.Param("id")).First(&Format).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
return
}
models.DB.Delete(&Format)
c.JSON(http.StatusOK, gin.H{"data": true})
}
func ApplyFormatRouter(router *gin.Engine) *gin.Engine {
router.GET("/formats", FindFormats)
router.POST("/formats", CreateFormat)
router.GET("/formats/:id", FindFormat)
router.PATCH("/formats/:id", UpdateFormat)
router.DELETE("/formats/:id", DeleteFormat)
return router
}

74
controllers/order.go
View File

@ -1,74 +0,0 @@
package controllers
import (
"net/http"
"preorder/models"
"github.com/gin-gonic/gin"
)
func FindOrders(c *gin.Context) {
var Orders []models.Order
models.DB.Find(&Orders)
c.JSON(http.StatusOK, gin.H{"data": Orders})
}
func FindOrder(c *gin.Context) {
var Order models.Order
if err := models.DB.Where("id = ?", c.Param("id")).First(&Order).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
c.JSON(http.StatusOK, gin.H{"data": Order})
}
func CreateOrder(c *gin.Context) {
var input models.CreateOrderInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
order := models.NewOrder(input.ID, input.Title, input.Author, input.Format, input.ISBN13, input.ReleaseDate)
models.DB.Create(&order)
c.JSON(http.StatusOK, gin.H{"data": order})
}
func UpdateOrder(c *gin.Context) {
var Order models.Order
if err := models.DB.Where("id = ?", c.Param("id")).First(&Order).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
var input models.UpdateOrderInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
models.DB.Model(&Order).Updates(input)
c.JSON(http.StatusOK, gin.H{"data": Order})
}
func DeleteOrder(c *gin.Context) {
var Order models.Order
if err := models.DB.Where("id = ?", c.Param("id")).First(&Order).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
return
}
models.DB.Delete(&Order)
c.JSON(http.StatusOK, gin.H{"data": true})
}
func ApplyOrderRouter(router *gin.Engine) *gin.Engine {
router.GET("/orders", FindOrders)
router.POST("/orders", CreateOrder)
router.GET("/orders/:id", FindOrder)
router.PATCH("/orders/:id", UpdateOrder)
router.DELETE("/orders/:id", DeleteOrder)
return router
}

65
formats/controllers.go Normal file
View File

@ -0,0 +1,65 @@
package formats
import (
"net/http"
"preorder/config"
"github.com/gin-gonic/gin"
)
func FindFormats(c *gin.Context) {
var formats []Format
config.DB.Find(&formats)
c.JSON(http.StatusOK, gin.H{"data": formats})
}
func FindFormat(c *gin.Context) {
var format Format
if err := config.DB.Where("id = ?", c.Param("id")).First(&format).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
c.JSON(http.StatusOK, gin.H{"data": format})
}
func CreateFormat(c *gin.Context) {
var input CreateFormatInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
format := NewFormat(input.ID, input.Format)
config.DB.Create(&format)
c.JSON(http.StatusOK, gin.H{"data": format})
}
func UpdateFormat(c *gin.Context) {
var format Format
if err := config.DB.Where("id = ?", c.Param("id")).First(&format).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
var input UpdateFormatInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
config.DB.Model(&format).Updates(input)
c.JSON(http.StatusOK, gin.H{"data": format})
}
func DeleteFormat(c *gin.Context) {
var format Format
if err := config.DB.Where("id = ?", c.Param("id")).First(&format).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
return
}
config.DB.Delete(&format)
c.JSON(http.StatusOK, gin.H{"data": true})
}

2
models/format.go → formats/models.go
View File

@ -1,4 +1,4 @@
package models
package formats
type Format struct {
ID uint `json:"id" gorm:"primary_key"`

12
formats/router.go Normal file
View File

@ -0,0 +1,12 @@
package formats
import "github.com/gin-gonic/gin"
func ApplyFormatRouter(router *gin.Engine) *gin.Engine {
router.GET("/formats", FindFormats)
router.POST("/formats", CreateFormat)
router.GET("/formats/:id", FindFormat)
router.PATCH("/formats/:id", UpdateFormat)
router.DELETE("/formats/:id", DeleteFormat)
return router
}

24
main.go
View File

@ -1,9 +1,13 @@
package main
import (
"gorm.io/gorm"
"net/http"
"preorder/controllers"
"preorder/models"
"preorder/authors"
"preorder/config"
"preorder/formats"
"preorder/orders"
"preorder/users"
"github.com/gin-gonic/gin"
)
@ -13,17 +17,25 @@ func SetupRouter() *gin.Engine {
router.GET("/ping", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "pong"})
})
router = controllers.ApplyAuthorRouter(router)
router = controllers.ApplyFormatRouter(router)
router = controllers.ApplyOrderRouter(router)
router = authors.ApplyAuthorRouter(router)
router = formats.ApplyFormatRouter(router)
router = orders.ApplyOrderRouter(router)
return router
}
func Migrate(db *gorm.DB) {
_ = db.AutoMigrate(&authors.Author{})
_ = db.AutoMigrate(&formats.Format{})
_ = db.AutoMigrate(&orders.Order{})
_ = db.AutoMigrate(&users.User{})
}
func main() {
router := SetupRouter()
models.ConnectDatabase()
config.ConnectDatabase()
Migrate(config.DB)
s := &http.Server{
Addr: ":8123",

27
models/models.go
View File

@ -1,27 +0,0 @@
package models
import (
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
var DB *gorm.DB
func ConnectDatabase() {
// Obviously change this to your settings and get securely.
//dsn := "root@unix(/var/run/mysqld/mysqld.sock)/db?charset=utf8mb4&parseTime=True&loc=Local"
//db, err := gorm.Open(mysql.New(mysql.Config{
// DSN: dsn,
//}), &gorm.Config{})
dsn := "root:password@tcp(db:3306)/db?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
if err != nil {
panic("Failed to connect to database")
}
_ = db.AutoMigrate(&Author{})
_ = db.AutoMigrate(&Format{})
_ = db.AutoMigrate(&Order{})
_ = db.AutoMigrate(&User{})
DB = db
}

65
orders/controllers.go Normal file
View File

@ -0,0 +1,65 @@
package orders
import (
"net/http"
"preorder/config"
"github.com/gin-gonic/gin"
)
func FindOrders(c *gin.Context) {
var Orders []Order
config.DB.Find(&Orders)
c.JSON(http.StatusOK, gin.H{"data": Orders})
}
func FindOrder(c *gin.Context) {
var order Order
if err := config.DB.Where("id = ?", c.Param("id")).First(&order).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
c.JSON(http.StatusOK, gin.H{"data": order})
}
func CreateOrder(c *gin.Context) {
var input CreateOrderInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
order := NewOrder(input.ID, input.Title, input.Author, input.Format, input.ISBN13, input.ReleaseDate)
config.DB.Create(&order)
c.JSON(http.StatusOK, gin.H{"data": order})
}
func UpdateOrder(c *gin.Context) {
var order Order
if err := config.DB.Where("id = ?", c.Param("id")).First(&order).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
}
var input UpdateOrderInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
config.DB.Model(&order).Updates(input)
c.JSON(http.StatusOK, gin.H{"data": order})
}
func DeleteOrder(c *gin.Context) {
var order Order
if err := config.DB.Where("id = ?", c.Param("id")).First(&order).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
return
}
config.DB.Delete(&order)
c.JSON(http.StatusOK, gin.H{"data": true})
}

12
models/order.go → orders/models.go
View File

@ -1,16 +1,20 @@
package models
package orders
import "time"
import (
"preorder/authors"
"preorder/formats"
"time"
)
type Order struct {
ID uint `json:"id" gorm:"primary_key"`
Title string `json:"title"`
AuthorID uint `json:"author"`
Author Author
Author authors.Author
ReleaseDate time.Time `json:"release_date" gorm:"column:release_date"`
ISBN13 uint `json:"isbn_13" gorm:"column:isbn_13"`
FormatID uint `json:"format"`
Format Format
Format formats.Format
}
type CreateOrderInput struct {

12
orders/router.go Normal file
View File

@ -0,0 +1,12 @@
package orders
import "github.com/gin-gonic/gin"
func ApplyOrderRouter(router *gin.Engine) *gin.Engine {
router.GET("/orders", FindOrders)
router.POST("/orders", CreateOrder)
router.GET("/orders/:id", FindOrder)
router.PATCH("/orders/:id", UpdateOrder)
router.DELETE("/orders/:id", DeleteOrder)
return router
}

8
models/user.go → users/models.go
View File

@ -1,4 +1,4 @@
package models
package users
import (
"time"
@ -23,9 +23,9 @@ type UpdateUserInput struct {
func NewUser(id uint, username, password string, createdAt, updatedAt time.Time) User {
user := User{
ID: id,
Username: username,
Password: password,
ID: id,
Username: username,
Password: password,
CreatedAt: createdAt,
UpdatedAt: updatedAt,
}

1
users/router.go Normal file
View File

@ -0,0 +1 @@
package users