Opérations CRUD avec Goravel (Laravel pour GO)

À propos de Goravel

Goravel est un framework d'application Web doté de fonctions complètes et d'une excellente évolutivité, comme échafaudage de départ pour aider Gopher à créer rapidement ses propres applications.

Goravel est le clone parfait de Laravel pour les développeurs Go, ce qui signifie qu'un développeur PHP comme moi peut facilement s'identifier au framework et commencer à écrire avec peu d'apprentissage à faire.

Commençons par l'installation, vous pouvez suivre cet article pour installer ou visiter le site de documentation officielle de Goravel.

// Download framework
git clone https://github.com/goravel/goravel.git && rm -rf goravel/.git*

// Install dependencies
cd goravel && go mod tidy

// Create .env environment configuration file
cp .env.example .env

// Generate application key
go run . artisan key:generate

//start the application
go run .

En ouvrant le code dans votre éditeur de texte préféré, vous verrez que la structure du projet est exactement comme celle de Laravel, donc les développeurs de Laravel ne se sentiront pas si perdus.

Modèle, Migration et Contrôleur

Pour créer un modèle, une migration et un contrôleur, nous pouvons utiliser la commande artisan comme nous le faisons dans Laravel.

// create model 
go run . artisan make:model Category

// create migration 
go run . artisan make:migration create_categories_table

// create controller 
go run . artisan make:controller --resource category_controller

Maintenant, si nous vérifions le dossier base de données/migration, nous verrons que des fichiers ont été créés pour nous, le fichier up et down, ouvrez le fichier up migration et collez le code ci-dessous à l'intérieur :

CREATE TABLE categories (
  id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  name varchar(255) NOT NULL,
  created_at datetime(3) NOT NULL,
  updated_at datetime(3) NOT NULL,
  PRIMARY KEY (id),
  KEY idx_categories_created_at (created_at),
  KEY idx_categories_updated_at (updated_at)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;NGINE = InnoDB DEFAULT CHARSET = utf8mb4;

Si nous vérifions dans le dossier app/http/controllers, nous aurons un fichiercategory_controller.go, et le contenu à l'intérieur devrait ressembler à ce que nous avons ci-dessous :

package controllers

import (
 "github.com/goravel/framework/contracts/http"
)

type CategoryController struct {
 //Dependent services
}

func NewCategoryController() *CategoryController {
 return &CategoryController{
  //Inject services
 }
}

func (r *CategoryController) Index(ctx http.Context) http.Response {
 return nil
} 

func (r *CategoryController) Show(ctx http.Context) http.Response {
 return nil
}

func (r *CategoryController) Store(ctx http.Context) http.Response {
 return nil
}

func (r *CategoryController) Update(ctx http.Context) http.Response {
 return nil
}

func (r *CategoryController) Destroy(ctx http.Context) http.Response {
 return nil
}

Ensuite, localisons le fichier de modèle de catégorie dans app/http/model , puis collez le code ci-dessous à l'intérieur :

package models

import (
 "github.com/goravel/framework/database/orm"
)

type Category struct {
 orm.Model
 Name string
}

Il ne se passe pas grand-chose ici, nous déclarons simplement notre remplissage avec leur type de données.

Localisons notre fichier api.php dans le dossier route et mettons à jour le code pour qu'il ressemble à celui ci-dessous :

package routes

import (
 "github.com/goravel/framework/facades"

 "goravel/app/http/controllers"
)

func Api() {
 userController := controllers.NewUserController()
 facades.Route().Get("/users/{id}", userController.Show)

 //Resource route
 categoryController := controllers.NewCategoryController()
 facades.Route().Resource("/category", categoryController)
}

Maintenant, mettons à jour nos importations dans le fichiercategory_controller.go et mettons-le à jour ci-dessous :

import (
 "goravel/app/models"
 "github.com/goravel/framework/contracts/http"
  "github.com/goravel/framework/facades"
)

Nous venons d'importer nos modèles et nos façades, les façades nous permettent d'avoir accès à plein de choses utiles et sympas comme la Validation, orm, etc. orm est l'ORM pour GO.

Il est temps d'écrire du code !

Mettons à jour nos méthodes dans notre contrôleur avec le code ci-dessous :

Méthode d'indexation

// this is just to pull all categories in our database
func (r *CategoryController) Index(ctx http.Context) http.Response {
 var categories []models.Category

 if err := facades.Orm().Query().Find(&categories); err != nil {
  return ctx.Response().Json(http.StatusInternalServerError, http.Json{
   "error": err.Error(),
  })
 }

 return ctx.Response().Success().Json(http.Json{
  "success": true,
  "message": "Data fetch successfully",
  "data":    categories,
 })
} 

Méthode de magasin

func (r *CategoryController) Store(ctx http.Context) http.Response {

// validate the input name that the user is passing
 validation, err := facades.Validation().Make(ctx.Request().All(), map[string]string{
        "name": "required|string",
    })

// check if an error occured, might not be validation error
    if err != nil {
        return ctx.Response().Json(http.StatusInternalServerError, http.Json{
            "success": false,
            "message": "Validation setup failed",
            "error":   err.Error(),
        })
    }

// check for validation errors
    if validation.Fails() {
        return ctx.Response().Json(http.StatusBadRequest, http.Json{
            "success": false,
            "message": "Validation failed",
            "errors":  validation.Errors().All(),
        })
    }

// Create the category
 category := &models.Category{
  Name: ctx.Request().Input("name"),
 }

// save the category and return error if there is any
 if err := facades.Orm().Query().Create(category); err != nil {
  return ctx.Response().Json(http.StatusInternalServerError, http.Json{
   "success": false,
   "errors": err.Error(),
  })
 }

// upon successfull creation return success response with the newly created category
 return ctx.Response().Success().Json(http.Json{
  "success": true,
  "message": "Category created successfully",
  "data":    category,
 })
}

Méthode de mise à jour

func (r *CategoryController) Update(ctx http.Context) http.Response {

    validation, err := facades.Validation().Make(ctx.Request().All(), map[string]string{
        "id":   "required",
        "name": "required|string",
    })

    if err != nil {
        return ctx.Response().Json(http.StatusInternalServerError, http.Json{
            "success": false,
            "message": "Validation setup failed",
            "error":   err.Error(),
        })
    }

    if validation.Fails() {
        return ctx.Response().Json(http.StatusBadRequest, http.Json{
            "success": false,
            "message": "Validation failed",
            "errors":  validation.Errors().All(),
        })
    }

// find the category using the id
    var category models.Category
    if err := facades.Orm().Query().Where("id", ctx.Request().Input("id")).First(&category); err != nil {
        return ctx.Response().Json(http.StatusNotFound, http.Json{
            "success": false,
            "message": "Category not found",
        })
    }

// update or return error if there is any
    category.Name = ctx.Request().Input("name")
    if err := facades.Orm().Query().Save(&category); err != nil {
        return ctx.Response().Json(http.StatusInternalServerError, http.Json{
            "success": false,
            "message": "Failed to update category",
            "error":   err.Error(),
        })
    }

// return success if successfull
    return ctx.Response().Success().Json(http.Json{
        "success": true,
        "message": "Category updated successfully",
        "data":    category,
    })
}

Méthode de destruction

func (r *CategoryController) Destroy(ctx http.Context) http.Response {

// find the category by id
 var category models.Category
 facades.Orm().Query().Find(&category, ctx.Request().Input("id"))
 res, err := facades.Orm().Query().Delete(&category)

// return error if there is any
 if err != nil {
  return ctx.Response().Json(http.StatusInternalServerError, http.Json{
  "error": err.Error(),
  })
 }

// return success if successfull
 return ctx.Response().Success().Json(http.Json{
  "success": true,
  "message": "Category deleted successfully",
  "data":    res,
 })
}

Maintenant, nous devons configurer la base de données, j'utiliserai MySQL, il est important de noter que les graviers sont livrés avec plusieurs pilotes de base de données. localisez votre fichier .env et modifiez cette ligne ci-dessous :

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=DATABASE_NAME
DB_USERNAME=DATABASE_USERNAME
DB_PASSWORD=DATABASE_PASSWORD

Puis dans votre terminal tapez :

go run . artisan migrate

Cela migrera automatiquement notre table de catégories dans notre base de données.

Maintenant, nous devons arrêter notre serveur si vous l'exécutez auparavant et le redémarrer.

Vous pouvez maintenant tester vos points de terminaison depuis Postman. Notez qu'en ajoutant la ressource au point de terminaison de catégorie, vous avez désormais accès aux méthodes GET, POST, PUT ou DELETE pour les points de terminaison de votre catégorie. vous pouvez accéder à vos points de terminaison de cette manière :

// GET category
http://localhost:3000/category

//POST catgory - with payload
http://localhost:3000/category
{
    "name": "goravel"
}

// PUT category - with payload
http://localhost:3000/category/{id}
{
    "id": 1,
    "name": "laravel"
}

//DELETE category
http://localhost:3000/category/{id}

C'est ainsi que vous effectuez des opérations CRUD simples à l'aide de Goravel.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!