Go développement linguistique du système de cuisson porte-à-porte : comment mettre en œuvre la fonction d'enregistrement de la consommation des utilisateurs ?

Développement linguistique Go du système de cuisson porte-à-porte : Comment mettre en œuvre la fonction d'enregistrement de la consommation des utilisateurs ?

Avec l’amélioration du niveau de vie, la demande alimentaire des gens devient également de plus en plus élevée. De plus en plus de gens commencent à essayer de cuisiner seuls, mais beaucoup n’y parviennent pas à cause d’un travail chargé ou de paresse. C’est ainsi que des services de cuisine à domicile ont vu le jour.

De nos jours, les services de cuisine en porte-à-porte se font généralement via des plateformes en ligne pour effectuer des réservations et des commandes. Les clients sélectionnent les plats et les quantités dont ils ont besoin via la plateforme et, après avoir payé les frais correspondants, ils peuvent attendre un service porte-à-porte. Parmi ces services, la fonction d'enregistrement de la consommation des utilisateurs est particulièrement importante. Pour les prestataires de services, les enregistrements de consommation peuvent les aider à mieux gérer leurs comptes, améliorant ainsi l'efficacité opérationnelle ; pour les utilisateurs, les enregistrements de consommation peuvent vérifier leur situation de consommation récente pour mieux estimer leur capacité de consommation.

Alors, comment mettre en œuvre la fonction d'enregistrement de la consommation des utilisateurs du système de cuisson porte-à-porte ? Jetons un coup d'œil ci-dessous.

1. Concevoir le tableau de données

Avant de penser à la mise en œuvre de la fonction d'enregistrement de la consommation, nous devons d'abord concevoir le tableau de données correspondant. Dans ce cas, nous devons concevoir le tableau des menus, le tableau des commandes, le tableau des détails des commandes et le tableau des enregistrements de consommation.

• Le tableau des menus est conçu comme suit :

CREATE TABLE IF NOT EXISTS `dishes` (
    `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '菜品 ID',
    `name` VARCHAR(50) NOT NULL COMMENT '菜名',
    `image` VARCHAR(100) NOT NULL COMMENT '图片地址',
    `category_id` INT(10) UNSIGNED NOT NULL COMMENT '分类 ID',
    `price` FLOAT(10,2) UNSIGNED NOT NULL COMMENT '价格',
    `created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='菜品表';

• Le tableau des commandes est conçu comme suit :

CREATE TABLE IF NOT EXISTS `orders` (
    `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '订单 ID',
    `user_id` INT(10) UNSIGNED NOT NULL COMMENT '用户 ID',
    `total_price` FLOAT(10,2) UNSIGNED NOT NULL COMMENT '订单总价',
    `status` TINYINT(1) UNSIGNED NOT NULL DEFAULT '0' COMMENT '订单状态，0：未支付，1：已支付，2：已完成，3：已取消',
    `created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

• Le tableau des détails de la commande est conçu comme suit :

CREATE TABLE IF NOT EXISTS `order_items` (
    `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '订单详情 ID',
    `order_id` INT(10) UNSIGNED NOT NULL COMMENT '订单 ID',
    `dish_id` INT(10) UNSIGNED NOT NULL COMMENT '菜品 ID',
    `quantity` SMALLINT(5) UNSIGNED NOT NULL COMMENT '数量',
    `price` FLOAT(10,2) UNSIGNED NOT NULL COMMENT '单价',
    `created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单详情表';

• Le tableau d'enregistrement des consommations est conçu comme suit :

CREATE TABLE IF NOT EXISTS `consumption_records` (
    `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '消费记录 ID',
    `user_id` INT(10) UNSIGNED NOT NULL COMMENT '用户 ID',
    `order_id` INT(10) UNSIGNED NOT NULL COMMENT '订单 ID',
    `money` FLOAT(10,2) UNSIGNED NOT NULL COMMENT '消费金额',
    `created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='消费记录表';

2. Implémenter le code

Après avoir terminé la conception de la table de données, nous devons utiliser le langage Go pour implémenter la logique métier correspondante. Voici le code correspondant :

• Définir la structure :

type ConsumptionRecord struct {
    ID        uint32    `db:"id" json:"id"`
    UserID    uint32    `db:"user_id" json:"user_id"`
    OrderID   uint32    `db:"order_id" json:"order_id"`
    Money     float32   `db:"money" json:"money"`
    CreatedAt time.Time `db:"created_at" json:"created_at"`
    UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
}

type OrderDetail struct {
    ID         uint32    `db:"id" json:"id"`
    OrderID    uint32    `db:"order_id" json:"order_id"`
    DishID     uint32    `db:"dish_id" json:"dish_id"`
    Quantity   uint16    `db:"quantity" json:"quantity"`
    Price      float32   `db:"price" json:"price"`
    CreatedAt  time.Time `db:"created_at" json:"created_at"`
    UpdatedAt  time.Time `db:"updated_at" json:"updated_at"`
    Dish       *Dish     `db:"-" json:"dish"`
}

type Order struct {
    ID         uint32         `db:"id" json:"id"`
    UserID     uint32         `db:"user_id" json:"user_id"`
    TotalPrice float32        `db:"total_price" json:"total_price"`
    Status     OrderStatus    `db:"status" json:"status"`
    CreatedAt  time.Time      `db:"created_at" json:"created_at"`
    UpdatedAt  time.Time      `db:"updated_at" json:"updated_at"`
    Items      []*OrderDetail `db:"-" json:"items"`
}

• Rechercher les détails de la commande :

// GetOrderDetailsByOrderIDs 根据订单 ID 列表查询订单详情
func GetOrderDetailsByOrderIDs(DB *sql.DB, orderIDs []uint32) ([]*OrderDetail, error) {
    details := make([]*OrderDetail, 0)

    if len(orderIDs) == 0 {
        return details, nil
    }

    // 拼接查询 SQL
    var placeHolders strings.Builder
    var args []interface{}
    for i, id := range orderIDs {
        if i != 0 {
            placeHolders.WriteString(", ")
        }
        placeHolders.WriteString("?")
        args = append(args, id)
    }

    query := fmt.Sprintf(`
        SELECT
            id, order_id, dish_id, quantity, price, created_at, updated_at
        FROM
            order_items
        WHERE
            order_id IN (%s)
    `, placeHolders.String())

    rows, err := DB.Query(query, args...)
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    // 遍历查询结果，并填充菜品信息到订单详情结构体
    for rows.Next() {
        detail := &OrderDetail{}
        err := rows.Scan(
            &detail.ID, &detail.OrderID, &detail.DishID, &detail.Quantity,
            &detail.Price, &detail.CreatedAt, &detail.UpdatedAt)
        if err != nil {
            return nil, err
        }

        dish, err := GetDishByID(DB, detail.DishID)
        if err != nil {
            return nil, err
        }
        detail.Dish = dish

        details = append(details, detail)
    }

    return details, nil
}

• Ajouter un enregistrement de consommation :

// AddConsumptionRecord 添加消费记录
func AddConsumptionRecord(
    DB *sql.DB,
    userID uint32,
    orderID uint32,
    money float32) error {

    insertQuery := `
        INSERT INTO consumption_records (user_id, order_id, money)
        VALUES (?, ?, ?)
    `
    _, err := DB.Exec(insertQuery, userID, orderID, money)
    if err != nil {
        return err
    }

    return nil
}

3. Résumé

Ce qui précède est un simple accès à -système de cuisson à porte, un exemple d'utilisation du langage Go pour implémenter la fonction d'enregistrement de la consommation de l'utilisateur. Grâce à ce cas, nous pouvons apprendre à fusionner des requêtes SQL, des requêtes par lots, à parcourir les résultats des requêtes et à insérer des données.

En général, le langage Go présente les avantages de la simplicité, de l'efficacité et de la sécurité, et est apprécié par la majorité des développeurs. Je pense qu'en lisant ce cas, vous pourrez également avoir une compréhension plus approfondie du langage Go. J'espère également qu'il vous sera utile lors de la mise en œuvre de la fonction d'enregistrement de la consommation des utilisateurs.

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!