Go développement linguistique du système de cuisson porte-à-porte : comment mettre en œuvre la fonction de suivi de l'état des commandes ?

Go développement linguistique du système de cuisine porte-à-porte : comment mettre en œuvre la fonction de suivi de l'état des commandes ?

Avec l'amélioration du niveau de vie, de plus en plus de personnes choisissent de commander des plats à emporter ou de cuisiner à la maison. Les services de cuisine à domicile offrent aux personnes occupées une option de restauration pratique et confortable. Lors du développement d’un système de cuisson porte-à-porte, une fonction importante est le suivi de l’état des commandes. Cet article explique comment utiliser le langage Go pour implémenter la fonction de suivi de l'état des commandes et fournit des exemples de code spécifiques.

Le suivi du statut de la commande signifie qu'une fois que l'utilisateur a passé une commande, le système peut enregistrer et mettre à jour les différents statuts de la commande, tels que la commande reçue, en livraison, terminée, etc. Afin d'implémenter cette fonction, nous devons d'abord concevoir la table de la base de données, puis écrire la logique de code correspondante dans le langage Go.

Tout d’abord, nous créons une table nommée commandes pour stocker les informations et le statut des commandes. La structure du tableau peut contenir les champs suivants : identifiant de commande, identifiant utilisateur, nom du plat, statut de la commande, identifiant du livreur, etc.

CREATE TABLE orders (
  id INT PRIMARY KEY AUTO_INCREMENT,
  user_id INT,
  dish_name VARCHAR(255),
  status VARCHAR(20),
  courier_id INT,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Ensuite, nous écrivons le code de langue Go pour gérer la fonction de suivi de l'état des commandes. Nous utilisons le framework Web de Go, gin, pour gérer les requêtes HTTP et GORM comme outil ORM pour les opérations de base de données.

Tout d'abord, nous devons créer une interface API qui gère le suivi de l'état des commandes. Créez un fichier nommé main.go et écrivez-y le code suivant :

package main

import (
  "github.com/gin-gonic/gin"
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
)

type Order struct {
  ID        int
  UserID    int
  DishName  string
  Status    string
  CourierID int
  CreatedAt time.Time
}

func main() {
  // 连接数据库
  dsn := "<username>:<password>@tcp(<host>:<port>)/<database>?charset=utf8mb4&parseTime=True&loc=Local"
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  if err != nil {
    panic("数据库连接失败")
  }

  // 创建订单表
  db.AutoMigrate(&Order{})

  // 创建gin实例
  r := gin.Default()

  // 创建订单接口
  r.POST("/orders", func(c *gin.Context) {
    var order Order
    c.BindJSON(&order)

    // 将订单信息保存到数据库
    result := db.Create(&order)
    if result.Error != nil {
      c.JSON(500, gin.H{"error": "保存订单失败"})
    } else {
      c.JSON(200, order)
    }
  })

  // 更新订单状态接口
  r.PUT("/orders/:id/status", func(c *gin.Context) {
    id := c.Param("id")
    status := c.Query("status")

    // 更新订单状态
    result := db.Model(&Order{}).Where("id = ?", id).Update("status", status)
    if result.RowsAffected == 0 {
      c.JSON(404, gin.H{"error": "订单不存在"})
    } else {
      c.JSON(200, gin.H{"status": "订单状态更新成功"})
    }
  })

  // 启动服务
  r.Run(":8080")
}

Dans le code ci-dessus, nous nous connectons d'abord à la base de données et créons la table des commandes. Ensuite, nous avons créé deux interfaces API, une pour créer des commandes et l'autre pour mettre à jour le statut des commandes. Dans l'interface de création de commande, nous récupérons les données de commande de la demande et les enregistrons dans la base de données. Dans l'interface de mise à jour du statut de la commande, nous mettons à jour le statut de la commande correspondant en fonction de l'ID de la commande et des paramètres de statut.

Enfin, nous utilisons la méthode Run de gin pour démarrer le service et écouter le port 8080.

En utilisant le code ci-dessus, nous pouvons démarrer un service de suivi de l'état des commandes. En accédant à l'interface API correspondante, nous pouvons créer des commandes et mettre à jour le statut des commandes. Voici un exemple d'utilisation de la commande curl pour accéder à l'interface API :

Créer une commande :

curl -X POST -H "Content-Type: application/json" -d '{"user_id": 1, "dish_name": "宫保鸡丁"}' http://localhost:8080/orders

Mettre à jour le statut de la commande :

curl -X PUT "http://localhost:8080/orders/1/status?status=已接单"

Grâce aux opérations ci-dessus, nous pouvons implémenter la fonction de suivi du statut de la commande. Les utilisateurs peuvent créer des commandes et mettre à jour le statut de la commande via l'interface de mise à jour du statut de la commande, visualisant ainsi les changements de statut de la commande en temps réel.

Il convient de noter que ce qui précède n’est qu’un exemple simple et n’inclut pas la gestion complète des erreurs ni les mesures de sécurité. Dans le développement actuel, nous devons encore améliorer le code, gérer les situations anormales et assurer la sécurité du système.

Pour résumer, cet article présente comment utiliser le langage Go pour développer la fonction de suivi de l'état des commandes dans le système de cuisson porte-à-porte. Nous avons implémenté l'interface API pour créer des commandes et mettre à jour le statut des commandes en concevant des tables de base de données et en écrivant le code en langage Go correspondant. En accédant à ces interfaces, les utilisateurs peuvent facilement créer des commandes et suivre les changements de statut des commandes en temps réel. J'espère que cet article vous sera utile pour le développement de votre langage Go.

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!