Méthode d'implémentation de la fonction de commande de réservation dans un système de commande de nourriture développé avec le langage Go

Avec l'avènement de l'ère numérique, diverses industries accélèrent la transformation numérique, et le secteur de la restauration ne fait pas exception. De plus en plus de restaurants commencent à utiliser des systèmes de commande pour offrir aux clients une expérience culinaire plus pratique et plus efficace. Parmi eux, la commande sur réservation est une méthode de commande très populaire. Elle permet aux clients de passer des commandes et de payer à l'avance avant d'arriver au magasin, réduisant ainsi le temps d'attente des clients et apportant de meilleurs revenus au restaurant.

Cet article présentera comment utiliser le langage Go pour développer un système de commande de réservation, comprenant principalement les aspects suivants : conception de base de données, conception d'interface et exemples de code.

1. Conception de la base de données

La base de données du système doit enregistrer les informations suivantes :

1. Informations sur l'utilisateur (user_info) : y compris le nom d'utilisateur, le mot de passe, le numéro de téléphone portable, l'e-mail et d'autres informations ; ) : y compris le nom du plat, les prix, les photos et d'autres informations ;
2. Informations sur la commande (order_info) : y compris le numéro de commande, l'heure de réservation, l'heure du repas, le nombre de convives et d'autres informations ;
3. Informations sur la commande du plat (menu_order_info) : y compris le numéro de commande ; , ID du plat, quantité et autres informations.
4. 2. Conception de l'interface

Interface de connexion utilisateur

1.     func login(username string, password string) bool {
           // 在数据库中查询是否存在该用户，密码是否正确
           // 如果存在，则返回true，否则返回false
       }

Interface de commande de requête

2.     type Menu struct {
           Id int
           Name string
           Price float64
           Image string
       }
   
       func getMenuList() []Menu {
           // 查询数据库，获取菜品列表信息
           // 将信息封装为Menu类型的slice返回
       }

Interface de réservation

3.     type MenuOrder struct {
           MenuId int
           Count int
       }
   
       func reserve(username string, orderTime string, eatTime string, eatNumber int, menuOrder []MenuOrder) bool {
           // 生成订单编号
           // 在订单表中新增一条订单信息
           // 在菜品订单表中新增相关信息
           // 返回预约结果（成功或失败）
       }

Interface de commande de requête

4.     type OrderInfo struct {
           OrderId int
           OrderTime string
           EatTime string
           EatNumber int
           MenuList []MenuOrder
           Status int   // 1表示预约成功，2表示已就餐，3表示已取消
       }
   
       func getOrderList(username string) []OrderInfo {
           // 查询指定用户的订单信息
           // 将信息封装为OrderInfo类型的slice返回
       }

3. Exemples de code

Connexion utilisateur Interface

1.     func login(username string, password string) bool {
           db, err := sql.Open("mysql", "root:password@tcp(localhost:3306)/restaurant")
           if err != nil {
               log.Fatal(err)
           }
           defer db.Close()
   
           rows, err := db.Query("SELECT * FROM user_info WHERE username = ? AND password = ?", username, password)
           if err != nil {
               log.Fatal(err)
           }
           defer rows.Close()
   
           if rows.Next() {
               return true
           } else {
               return false
           }
       }

Obtenir l'interface de la liste de menus

2.     type Menu struct {
           Id int
           Name string
           Price float64
           Image string
       }
   
       func getMenuList() []Menu {
           db, err := sql.Open("mysql", "root:password@tcp(localhost:3306)/restaurant")
           if err != nil {
               log.Fatal(err)
           }
           defer db.Close()
   
           rows, err := db.Query("SELECT id, name, price, image FROM menu_info")
           if err != nil {
               log.Fatal(err)
           }
           defer rows.Close()
   
           var menuList []Menu
           for rows.Next() {
               var id int
               var name string
               var price float64
               var image string
               err := rows.Scan(&id, &name, &price, &image)
               if err != nil {
                   log.Fatal(err)
               }
   
               menu := Menu{
                   Id: id,
                   Name: name,
                   Price: price,
                   Image: image,
               }
               menuList = append(menuList, menu)
           }
           return menuList
       }

Interface de réservation

3.     type MenuOrder struct {
           MenuId int
           Count int
       }
   
       func reserve(username string, orderTime string, eatTime string, eatNumber int, menuOrder []MenuOrder) bool {
           db, err := sql.Open("mysql", "root:password@tcp(localhost:3306)/restaurant")
           if err != nil {
               log.Fatal(err)
           }
           defer db.Close()
   
           tx, err := db.Begin()
           if err != nil {
               log.Fatal(err)
           }
   
           stmt1, err := tx.Prepare("INSERT INTO order_info(order_time, eat_time, eat_number, status) VALUES (?, ?, ?, ?)")
           if err != nil {
               tx.Rollback()
               log.Fatal(err)
           }
           defer stmt1.Close()
   
           res, err := stmt1.Exec(orderTime, eatTime, eatNumber, 1) // 预约成功
           if err != nil {
               tx.Rollback()
               log.Fatal(err)
           }
   
           orderId, err := res.LastInsertId()
           if err != nil {
               tx.Rollback()
               log.Fatal(err)
           }
   
           stmt2, err := tx.Prepare("INSERT INTO menu_order_info(order_id, menu_id, count) VALUES (?, ?, ?)")
           if err != nil {
               tx.Rollback()
               log.Fatal(err)
           }
           defer stmt2.Close()
   
           for _, menu := range menuOrder {
               _, err := stmt2.Exec(orderId, menu.MenuId, menu.Count)
               if err != nil {
                   tx.Rollback()
                   log.Fatal(err)
               }
           }
   
           err = tx.Commit()
           if err != nil {
               tx.Rollback()
               log.Fatal(err)
           }
   
           return true
       }

Interface de commande de requête

4.     type OrderInfo struct {
           OrderId int
           OrderTime string
           EatTime string
           EatNumber int
           MenuList []MenuOrder
           Status int   // 1表示预约成功，2表示已就餐，3表示已取消
       }
   
       func getOrderList(username string) []OrderInfo {
           db, err := sql.Open("mysql", "root:password@tcp(localhost:3306)/restaurant")
           if err != nil {
               log.Fatal(err)
           }
           defer db.Close()
   
           rows, err := db.Query("SELECT order_info.id, order_time, eat_time, eat_number, status, menu_id, count FROM order_info INNER JOIN menu_order_info ON order_info.id = menu_order_info.order_id WHERE username = ?", username)
           if err != nil {
               log.Fatal(err)
           }
           defer rows.Close()
   
           var orderList []OrderInfo
           for rows.Next() {
               var orderId int
               var orderTime string
               var eatTime string
               var eatNumber int
               var status int
               var menuId int
               var count int
               err := rows.Scan(&orderId, &orderTime, &eatTime, &eatNumber, &status, &menuId, &count)
               if err != nil {
                   log.Fatal(err)
               }
   
               var order *OrderInfo
               for i, item := range orderList {
                   if item.OrderId == orderId {
                       order = &orderList[i]
                       break
                   }
               }
   
               if order == nil {
                   order = &OrderInfo{
                       OrderId: orderId,
                       OrderTime: orderTime,
                       EatTime: eatTime,
                       EatNumber: eatNumber,
                       Status: status,
                       MenuList: make([]MenuOrder, 0),
                   }
                   orderList = append(orderList, *order)
               }
   
               menuOrder := MenuOrder{
                   MenuId: menuId,
                   Count: count,
               }
               order.MenuList = append(order.MenuList, menuOrder)
           }
           return orderList
       }

Résumé

Cet article présente la méthode d'utilisation du langage Go pour développer un système de commande de réservation. , et fournit des exemples de code détaillés. En étudiant cet article, les lecteurs peuvent maîtriser les principes de base et les méthodes de mise en œuvre du système de commande de réservation, et fournir un support technique pour le développement de systèmes similaires. En outre, nous devons également veiller au maintien de la stabilité et de la sécurité du système, par exemple en empêchant l'injection SQL, l'authentification et d'autres problèmes de sécurité.

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!