Comment utiliser le langage Go pour développer la fonction de réservation de restaurant du système de commande

Comment utiliser le langage Go pour développer la fonction de réservation de restaurant du système de commande. Des exemples de code spécifiques sont nécessaires

La fonction de réservation de restaurant est une partie très importante du système de commande moderne. Elle permet aux clients de réserver l'heure du repas. du restaurant à l'avance, évitant ainsi efficacement Cela élimine le besoin d'attendre une table et améliore l'expérience culinaire des clients. Dans cet article, nous utiliserons le langage Go pour développer une fonction simple de réservation de restaurant.

Tout d'abord, nous devons créer une base de données pour stocker les informations sur les restaurants et les données de commande de réservation. Nous pouvons utiliser MySQL comme système de gestion de base de données, créer une base de données nommée « restaurant » et y créer deux tables appelées « restaurants » et « réservations ». La structure de la table

restaurants est la suivante :

CREATE TABLE restaurants (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255) NOT NULL,
    address VARCHAR(255) NOT NULL,
    capacity INT NOT NULL,
    available_time_start TIME NOT NULL,
    available_time_end TIME NOT NULL
);

La structure de la table des réservations est la suivante :

CREATE TABLE reservations (
    id INT PRIMARY KEY AUTO_INCREMENT,
    restaurant_id INT NOT NULL,
    guest_name VARCHAR(255) NOT NULL,
    reservation_time DATETIME NOT NULL,
    FOREIGN KEY (restaurant_id) REFERENCES restaurants(id)
);

Ensuite, nous utiliserons le langage Go pour développer la fonction de réservation de restaurant du système de commande. Tout d’abord, nous devons créer une structure de restaurant pour représenter les informations du restaurant, notamment son nom, son adresse, sa capacité et les périodes disponibles.

type Restaurant struct {
    ID               int
    Name             string
    Address          string
    Capacity         int
    AvailableTimeStart time.Time
    AvailableTimeEnd   time.Time
}

Nous devons également créer une structure de réservation pour représenter les informations de la commande de réservation, y compris l'identifiant du restaurant réservé, le nom du client, l'heure de la réservation, etc.

type Reservation struct {
    ID               int
    RestaurantID     int
    GuestName        string
    ReservationTime  time.Time
}

Ensuite, nous devons implémenter certaines fonctions d'exploitation de la base de données, notamment interroger tous les restaurants, interroger les restaurants disponibles, interroger les commandes de réservation, ajouter des commandes de réservation, etc.

Tout d'abord, nous créons une variable db pour stocker la connexion à la base de données.

var db *sql.DB

Dans la fonction principale, nous devons ouvrir la connexion à la base de données.

func main() {
    var err error
    db, err = sql.Open("mysql", "root:password@tcp(localhost:3306)/restaurant")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 运行HTTP服务器
    http.HandleFunc("/restaurants", getRestaurantsHandler)
    http.HandleFunc("/available-restaurants", getAvailableRestaurantsHandler)
    http.HandleFunc("/reservations", getReservationsHandler)
    http.HandleFunc("/reserve", addReservationHandler)

    log.Fatal(http.ListenAndServe(":8080", nil))
}

Ensuite, implémentons quelques fonctions d'exploitation de base de données.

Premièrement, la fonction pour interroger tous les restaurants est la suivante :

func getRestaurantsHandler(w http.ResponseWriter, r *http.Request) {
    rows, err := db.Query("SELECT * FROM restaurants")
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    var restaurants []Restaurant
    for rows.Next() {
        var restaurant Restaurant
        err := rows.Scan(&restaurant.ID, &restaurant.Name, &restaurant.Address, &restaurant.Capacity, &restaurant.AvailableTimeStart, &restaurant.AvailableTimeEnd)
        if err != nil {
            log.Fatal(err)
        }
        restaurants = append(restaurants, restaurant)
    }

    json.NewEncoder(w).Encode(restaurants)
}

Ensuite, la fonction pour interroger les restaurants disponibles est la suivante :

func getAvailableRestaurantsHandler(w http.ResponseWriter, r *http.Request) {
    currentTime := time.Now()
    rows, err := db.Query("SELECT * FROM restaurants WHERE available_time_start <= ? AND available_time_end >= ?", currentTime, currentTime)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    var restaurants []Restaurant
    for rows.Next() {
        var restaurant Restaurant
        err := rows.Scan(&restaurant.ID, &restaurant.Name, &restaurant.Address, &restaurant.Capacity, &restaurant.AvailableTimeStart, &restaurant.AvailableTimeEnd)
        if err != nil {
            log.Fatal(err)
        }
        restaurants = append(restaurants, restaurant)
    }

    json.NewEncoder(w).Encode(restaurants)
}

Ensuite, la fonction pour interroger les commandes réservées est la suivante :

func getReservationsHandler(w http.ResponseWriter, r *http.Request) {
    rows, err := db.Query("SELECT * FROM reservations")
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    var reservations []Reservation
    for rows.Next() {
        var reservation Reservation
        err := rows.Scan(&reservation.ID, &reservation.RestaurantID, &reservation.GuestName, &reservation.ReservationTime)
        if err != nil {
            log.Fatal(err)
        }
        reservations = append(reservations, reservation)
    }

    json.NewEncoder(w).Encode(reservations)
}

Enfin, la La fonction pour ajouter des commandes réservées est la suivante :

func addReservationHandler(w http.ResponseWriter, r *http.Request) {
    var reservation Reservation
    err := json.NewDecoder(r.Body).Decode(&reservation)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    stmt, err := db.Prepare("INSERT INTO reservations (restaurant_id, guest_name, reservation_time) VALUES (?, ?, ?)")
    if err != nil {
        log.Fatal(err)
    }
    defer stmt.Close()

    _, err = stmt.Exec(reservation.RestaurantID, reservation.GuestName, reservation.ReservationTime)
    if err != nil {
        log.Fatal(err)
    }

    w.WriteHeader(http.StatusOK)
}

Grâce aux étapes ci-dessus, nous avons complété la fonction de réservation de restaurant en développant le système de commande en utilisant le langage Go. Nous pouvons utiliser des outils tels que Postman pour tester ces interfaces HTTP, et pouvons également fournir les interfaces de données correspondantes pour le développement front-end. Bien entendu, il ne s’agit que d’un exemple simple, qui doit être amélioré et perfectionné en fonction des besoins spécifiques du développement réel.

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!