八.订单微服务API(order-web)

最新推荐文章于 2025-12-16 21:04:50 发布
原创 最新推荐文章于 2025-12-16 21:04:50 发布 · 190 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#golang #微服务

八.订单微服务API(order-web)

1.项目初始化
1.1初始化目录

在这里插入图片描述

1.2添加yaml配置文件

order-web/order-web.yaml

host: '192.168.0.4'
port: 8848
namespace: 'ba14206d-403f-4377-b7e7-70a3e8fa2bbf'
user: 'nacos'
password: 'nacos'
dataid: 'order-web.json'
group: 'dev'
1.3建立全局变量

order-web/global/global.go

package global

import (
   ut "github.com/go-playground/universal-translator"
   goodsProto "mxshop_api/goods-web/proto"
   "mxshop_api/order-web/config"
   "mxshop_api/order-web/proto"
)

var (
   Trans ut.Translator

   ServerConfig *config.ServerConfig = &config.ServerConfig{}

   NacosConfig *config.NacosConfig = &config.NacosConfig{}

   GoodsSrvClient goodsProto.GoodsClient

   OrderSrvClient proto.OrderClient

   InventorySrvClient proto.InventoryClient
)
1.4在nacos建立配置文件

在这里插入图片描述

1.5建立配置文件的映射文件

order-web/config/config.go

package config

type GoodsSrvConfig struct {
   Name string `mapstructure:"name" json:"name"`
}

type JWTConfig struct {
   SigningKey string `mapstructure:"key" json:"key"`
}

type ConsulConfig struct {
   Host string `mapstructure:"host" json:"host"`
   Port int    `mapstructure:"port" json:"port"`
}
type AlipayConfig struct {
   AppID        string `mapstructure:"app_id" json:"app_id"`
   PrivateKey   string `mapstructure:"private_key" json:"private_key"`
   AliPublicKey string `mapstructure:"ali_public_key" json:"ali_public_key"`
   NotifyURL    string `mapstructure:"notify_url" json:"notify_url"`
   ReturnURL    string `mapstructure:"return_url" json:"return_url"`
}

type RedisConfig struct {
   Host   string `mapstructure:"host" json:"host"`
   Port   int    `mapstructure:"port" json:"port"`
   Expire int    `mapstructure:"expire" json:"expire"`
}

type ServerConfig struct {
   Name             string         `mapstructure:"name" json:"name"`
   Host             string         `mapstructure:"host" json:"host"`
   Tags             []string       `mapstructure:"tags" json:"tags"`
   Port             int            `mapstructure:"port" json:"port"`
   GoodsSrvInfo     GoodsSrvConfig `mapstructure:"goods_srv" json:"goods_srv"`
   OrderSrvInfo     GoodsSrvConfig `mapstructure:"order_srv" json:"order_srv"`
   InventorySrvInfo GoodsSrvConfig `mapstructure:"inventory_srv" json:"inventory_srv"`
   JWTInfo          JWTConfig      `mapstructure:"jwt" json:"jwt"`
   RedisInfo        RedisConfig    `mapstructure:"redis" json:"redis"`
   ConsulInfo       ConsulConfig   `mapstructure:"consul" json:"consul"`
   AliPayInfo       AlipayConfig   `mapstructure:"alipay" json:"alipay"`
}

type NacosConfig struct {
   Host      string `mapstructure:"host"`
   Port      uint64 `mapstructure:"port"`
   Namespace string `mapstructure:"namespace"`
   User      string `mapstructure:"user"`
   Password  string `mapstructure:"password"`
   DataId    string `mapstructure:"dataid"`
   Group     string `mapstructure:"group"`
}
1.6配 置文件初始化

order-web/initalize/config.go

package initalize

import (
   "encoding/json"
   "fmt"
   "github.com/nacos-group/nacos-sdk-go/clients"
   "github.com/nacos-group/nacos-sdk-go/common/constant"
   "github.com/nacos-group/nacos-sdk-go/vo"
   "github.com/spf13/viper"
   "go.uber.org/zap"
   "mxshop_api/order-web/global"
)

func GetEnvInfo(env string) bool {
   viper.AutomaticEnv()
   return viper.GetBool(env)
}

func InitConfig() {
   debug := GetEnvInfo("MXSHOP_DEBUG")
   configFilePrefix := "config"
   configFileName := fmt.Sprintf("order-web/%s-pro.yaml", configFilePrefix)
   if debug {
      configFileName = fmt.Sprintf("order-web/%s-debug.yaml", configFilePrefix)
   }
   v := viper.New()
   v.SetConfigFile(configFileName)
   if err := v.ReadInConfig(); err != nil {
      panic(err)
   }
   if err := v.Unmarshal(global.NacosConfig); err != nil {
      panic(err)
   }
   zap.S().Infof("配置信息: &v", global.NacosConfig)
   //viper功能，动态监控变化
   //v.WatchConfig()
   //v.OnConfigChange(func(e fsnotify.Event) {
   // zap.S().Infof("配置信息产生变化:%v", e.Name)
   // _ = v.ReadInConfig()
   // _ = v.Unmarshal(global.ServerConfig)
   // fmt.Println(global.ServerConfig)
   //})
   //从nacos读取信息
   sc := []constant.ServerConfig{
      {
         IpAddr: global.NacosConfig.Host,
         Port:   global.NacosConfig.Port,
      },
   }

   cc := constant.ClientConfig{
      NamespaceId:         global.NacosConfig.Namespace, // 如果需要支持多namespace，我们可以场景多个client,它们有不同的NamespaceId
      TimeoutMs:           5000,
      NotLoadCacheAtStart: true,
      LogDir:              "tmp/nacos/log",
      CacheDir:            "tmp/nacos/cache",
      LogLevel:            "debug",
   }

   configClient, err := clients.CreateConfigClient(map[string]interface{}{
      "serverConfigs": sc,
      "clientConfig":  cc,
   })
   if err != nil {
      panic(err)
   }

   content, err := configClient.GetConfig(vo.ConfigParam{
      DataId: global.NacosConfig.DataId,
      Group:  global.NacosConfig.Group})

   if err != nil {
      panic(err)
   }
   fmt.Println(content) //字符串 - yaml
   //想要将一个json字符串转换成struct，需要去设置这个struct的tag
   err = json.Unmarshal([]byte(content), &global.ServerConfig)
   if err != nil {
      zap.S().Fatalf("读取nacos配置失败： %s", err.Error())
   }
   fmt.Println(&global.ServerConfig)
}

order-web/initalize/srv_conn.go

package initalize

import (
   "fmt"
   _ "github.com/mbobakov/grpc-consul-resolver"
   "go.uber.org/zap"
   "google.golang.org/grpc"
   goodsProto "mxshop_api/goods-web/proto"
   "mxshop_api/order-web/global"
   "mxshop_api/order-web/proto"
)

func InitSrvConn() {
   consulInfo := global.ServerConfig.ConsulInfo
   goodsConn, err := grpc.Dial(
      fmt.Sprintf("consul://%s:%d/%s?wait=14s", consulInfo.Host, consulInfo.Port, global.ServerConfig.GoodsSrvInfo.Name),
      grpc.WithInsecure(),
      grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy": "round_robin"}`),
   )
   if err != nil {
      zap.S().Fatal("[InitSrvConn] 连接 【商品服务失败】")
   }

   global.GoodsSrvClient = goodsProto.NewGoodsClient(goodsConn)

   orderConn, err := grpc.Dial(
      fmt.Sprintf("consul://%s:%d/%s?wait=14s", consulInfo.Host, consulInfo.Port, global.ServerConfig.OrderSrvInfo.Name),
      grpc.WithInsecure(),
      grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy": "round_robin"}`),
   )
   fmt.Println("err", err)
   if err != nil {
      zap.S().Fatal("[InitSrvConn] 连接 【订单服务失败】")
   }

   global.OrderSrvClient = proto.NewOrderClient(orderConn)

   invConn, err := grpc.Dial(
      fmt.Sprintf("consul://%s:%d/%s?wait=14s", consulInfo.Host, consulInfo.Port, global.ServerConfig.InventorySrvInfo.Name),
      grpc.WithInsecure(),
      grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy": "round_robin"}`),
   )
   if err != nil {
      zap.S().Fatal("[InitSrvConn] 连接 【库存服务失败】")
   }

   global.InventorySrvClient = proto.NewInventoryClient(invConn)
}

order-web/initalize/logger.go

package initalize

import "go.uber.org/zap"

func InitLogger() {
   logger, _ := zap.NewDevelopment()
   zap.ReplaceGlobals(logger)
}

order-web/initalize/router.go

package initalize

import (
   "github.com/gin-gonic/gin"
   "mxshop_api/order-web/middlewares"
   "mxshop_api/order-web/router"
   "net/http"
)

func Routers() *gin.Engine {
   Router := gin.Default()
   Router.GET("/health", func(c *gin.Context) {
      c.JSON(http.StatusOK, gin.H{
         "code":    http.StatusOK,
         "success": true,
      })
   })

   //配置跨域
   Router.Use(middlewares.Cors())

   ApiGroup := Router.Group("/o/v1")
   router.InitOrderRouter(ApiGroup)
   router.InitShopCartRouter(ApiGroup)

   return Router
}

order-web/initalize/validator.go

package initalize

import (
   "fmt"
   "mxshop_api/order-web/global"
   "reflect"
   "strings"

   "github.com/gin-gonic/gin/binding"
   "github.com/go-playground/locales/en"
   "github.com/go-playground/locales/zh"
   ut "github.com/go-playground/universal-translator"
   "github.com/go-playground/validator/v10"
   en_translations "github.com/go-playground/validator/v10/translations/en"
   zh_translations "github.com/go-playground/validator/v10/translations/zh"
)

func InitTrans(locale string) (err error) {
   //修改gin框架中的validator引擎属性, 实现定制
   if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
      //注册一个获取json的tag的自定义方法
      v.RegisterTagNameFunc(func(fld reflect.StructField) string {
         name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
         if name == "-" {
            return ""
         }
         return name
      })

      zhT := zh.New() //中文翻译器
      enT := en.New() //英文翻译器
      //第一个参数是备用的语言环境，后面的参数是应该支持的语言环境
      uni := ut.New(enT, zhT, enT)
      global.Trans, ok = uni.GetTranslator(locale)
      if !ok {
         return fmt.Errorf("uni.GetTranslator(%s)", locale)
      }

      switch locale {
      case "en":
         en_translations.RegisterDefaultTranslations(v, global.Trans)
      case "zh":
         zh_translations.RegisterDefaultTranslations(v, global.Trans)
      default:
         en_translations.RegisterDefaultTranslations(v, global.Trans)
      }
      return
   }
   return
}
1.7main.go文件
package main

import (
   "fmt"
   _ "github.com/gin-gonic/gin/binding"
   _ "github.com/go-playground/universal-translator"
   uuid "github.com/satori/go.uuid"
   "github.com/spf13/viper"
   "go.uber.org/zap"
   "mxshop_api/order-web/global"
   "mxshop_api/order-web/initalize"
   "mxshop_api/order-web/utils"
   "mxshop_api/order-web/utils/registry/consul"
   _ "mxshop_api/order-web/validator"
   "os"
   "os/signal"
   "syscall"
)

func main() {
   //1.初始化logger
   initalize.InitLogger()

   //2. 初始化配置文件
   initalize.InitConfig()

   //3.初始化routers
   Router := initalize.Routers()
   zap.S().Debugf("启动服务器，端口:%d", global.ServerConfig.Port)

   //4. 初始化翻译
   if err := initalize.InitTrans("zh"); err != nil {
      panic(err)
   }

   //5.初始化SRV的连接
   initalize.InitSrvConn()

   viper.AutomaticEnv()
   debug := viper.GetBool("MXSHOP_DEBUG")
   if !debug {
      port, err := utils.GetFreePort()
      if err == nil {
         global.ServerConfig.Port = port
      }
   }

   register_client := consul.NewRegistryClient(global.ServerConfig.ConsulInfo.Host, global.ServerConfig.ConsulInfo.Port)
   serviceId := fmt.Sprintf("%s", uuid.NewV4())
   err := register_client.Register(global.ServerConfig.Host, global.ServerConfig.Port, global.ServerConfig.Name, global.ServerConfig.Tags, serviceId)
   if err != nil {
      zap.S().Panic("服务注册失败:", err.Error())
   }
   zap.S().Debugf("启动服务器, 端口： %d", global.ServerConfig.Port)
   go func() {
      if err := Router.Run(fmt.Sprintf(":%d", global.ServerConfig.Port)); err != nil {
         zap.S().Panic("启动失败:", err.Error())
      }
   }()
   //接收终止信号
   quit := make(chan os.Signal)
   signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
   <-quit
   if err = register_client.DeRegister(serviceId); err != nil {
      zap.S().Info("注销失败:", err.Error())
   } else {
      zap.S().Info("注销成功:")
   }
}
2.API接口开发
2.1订单列表开发
func List(ctx *gin.Context) {
   //订单的列表
   userId, _ := ctx.Get("userId")
   claims, _ := ctx.Get("claims")

   request := proto.OrderFilterRequest{}

   //如果是管理员用户则返回所有的订单
   model := claims.(*models.CustomClaims)
   if model.AuthorityId == 1 {
      request.UserId = int32(userId.(uint))
   }

   pages := ctx.DefaultQuery("p", "0")
   pagesInt, _ := strconv.Atoi(pages)
   request.Pages = int32(pagesInt)

   perNums := ctx.DefaultQuery("pnum", "0")
   perNumsInt, _ := strconv.Atoi(perNums)
   request.PagePerNums = int32(perNumsInt)

   request.Pages = int32(pagesInt)
   request.PagePerNums = int32(perNumsInt)

   rsp, err := global.OrderSrvClient.OrderList(context.Background(), &request)
   if err != nil {
      zap.S().Errorw("获取订单列表失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   reMap := gin.H{
      "total": rsp.Total,
   }
   orderList := make([]interface{}, 0)

   for _, item := range rsp.Data {
      tmpMap := map[string]interface{}{}

      tmpMap["id"] = item.Id
      tmpMap["status"] = item.Status
      tmpMap["pay_type"] = item.PayType
      tmpMap["user"] = item.UserId
      tmpMap["post"] = item.Post
      tmpMap["total"] = item.Total
      tmpMap["address"] = item.Address
      tmpMap["name"] = item.Name
      tmpMap["mobile"] = item.Mobile
      tmpMap["order_sn"] = item.OrderSn
      tmpMap["id"] = item.Id
      tmpMap["add_time"] = item.AddTime

      orderList = append(orderList, tmpMap)
   }
   reMap["data"] = orderList
   ctx.JSON(http.StatusOK, reMap)
}
2.2创建订单
func New(ctx *gin.Context) {
   orderForm := forms.CreateOrderForm{}
   if err := ctx.ShouldBindJSON(&orderForm); err != nil {
      api.HandleValidatorError(ctx, err)
   }
   userId, _ := ctx.Get("userId")
   rsp, err := global.OrderSrvClient.CreateOrder(context.WithValue(context.Background(), "ginContext", ctx), &proto.OrderRequest{
      UserId:  int32(userId.(uint)),
      Name:    orderForm.Name,
      Mobile:  orderForm.Mobile,
      Address: orderForm.Address,
      Post:    orderForm.Post,
   })
   if err != nil {
      zap.S().Errorw("新建订单失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   //生成支付宝的支付url
   client, err := alipay.New(global.ServerConfig.AliPayInfo.AppID, global.ServerConfig.AliPayInfo.PrivateKey, false)
   if err != nil {
      zap.S().Errorw("实例化支付宝失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }
   err = client.LoadAliPayPublicKey((global.ServerConfig.AliPayInfo.AliPublicKey))
   if err != nil {
      zap.S().Errorw("加载支付宝的公钥失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }

   var p = alipay.TradePagePay{}
   p.NotifyURL = global.ServerConfig.AliPayInfo.NotifyURL
   p.ReturnURL = global.ServerConfig.AliPayInfo.ReturnURL
   p.Subject = "慕学生鲜订单-" + rsp.OrderSn
   p.OutTradeNo = rsp.OrderSn
   p.TotalAmount = strconv.FormatFloat(float64(rsp.Total), 'f', 2, 64)
   p.ProductCode = "FAST_INSTANT_TRADE_PAY"

   url, err := client.TradePagePay(p)
   if err != nil {
      zap.S().Errorw("生成支付url失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }

   ctx.JSON(http.StatusOK, gin.H{
      "id":         rsp.Id,
      "alipay_url": url.String(),
   })
}
2.3订单详情
func Detail(ctx *gin.Context) {
   id := ctx.Param("id")
   userId, _ := ctx.Get("userId")
   i, err := strconv.Atoi(id)
   if err != nil {
      ctx.JSON(http.StatusNotFound, gin.H{
         "msg": "url格式出错",
      })
      return
   }

   //如果是管理员用户则返回所有的订单
   request := proto.OrderRequest{
      Id: int32(i),
   }
   claims, _ := ctx.Get("claims")
   model := claims.(*models.CustomClaims)
   if model.AuthorityId == 1 {
      request.UserId = int32(userId.(uint))
   }

   rsp, err := global.OrderSrvClient.OrderDetail(context.Background(), &request)
   if err != nil {
      zap.S().Errorw("获取订单详情失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }
   reMap := gin.H{}
   reMap["id"] = rsp.OrderInfo.Id
   reMap["status"] = rsp.OrderInfo.Status
   reMap["user"] = rsp.OrderInfo.UserId
   reMap["post"] = rsp.OrderInfo.Post
   reMap["total"] = rsp.OrderInfo.Total
   reMap["address"] = rsp.OrderInfo.Address
   reMap["name"] = rsp.OrderInfo.Name
   reMap["mobile"] = rsp.OrderInfo.Mobile
   reMap["pay_type"] = rsp.OrderInfo.PayType
   reMap["order_sn"] = rsp.OrderInfo.OrderSn

   goodsList := make([]interface{}, 0)
   for _, item := range rsp.Goods {
      tmpMap := gin.H{
         "id":    item.GoodsId,
         "name":  item.GoodsName,
         "image": item.GoodsImage,
         "price": item.GoodsPrice,
         "nums":  item.Nums,
      }

      goodsList = append(goodsList, tmpMap)
   }
   reMap["goods"] = goodsList

   //生成支付宝的支付url
   client, err := alipay.New(global.ServerConfig.AliPayInfo.AppID, global.ServerConfig.AliPayInfo.PrivateKey, false)
   if err != nil {
      zap.S().Errorw("实例化支付宝失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }
   err = client.LoadAliPayPublicKey((global.ServerConfig.AliPayInfo.AliPublicKey))
   if err != nil {
      zap.S().Errorw("加载支付宝的公钥失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }

   var p = alipay.TradePagePay{}
   p.NotifyURL = global.ServerConfig.AliPayInfo.NotifyURL
   p.ReturnURL = global.ServerConfig.AliPayInfo.ReturnURL
   p.Subject = "慕学生鲜订单-" + rsp.OrderInfo.OrderSn
   p.OutTradeNo = rsp.OrderInfo.OrderSn
   p.TotalAmount = strconv.FormatFloat(float64(rsp.OrderInfo.Total), 'f', 2, 64)
   p.ProductCode = "FAST_INSTANT_TRADE_PAY"

   url, err := client.TradePagePay(p)
   if err != nil {
      zap.S().Errorw("生成支付url失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }
   reMap["alipay_url"] = url.String()

   ctx.JSON(http.StatusOK, reMap)
}
2.4购物车列表
func List(ctx *gin.Context) {
   //获取购物车商品
   userId, _ := ctx.Get("userId")
   rsp, err := global.OrderSrvClient.CartItemList(context.Background(), &proto.UserInfo{
      Id: int32(userId.(uint)),
   })
   if err != nil {
      zap.S().Errorw("[List] 查询 【购物车列表】失败")
      panic(err)
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   ids := make([]int32, 0)
   for _, item := range rsp.Data {
      ids = append(ids, item.GoodsId)
   }
   if len(ids) == 0 {
      ctx.JSON(http.StatusOK, gin.H{
         "total": 0,
      })
      return
   }

   //请求商品服务获取商品信息
   goodsRsp, err := global.GoodsSrvClient.BatchGetGoods(context.Background(), &goodsProto.BatchGoodsIdInfo{
      Id: ids,
   })
   if err != nil {
      zap.S().Errorw("[List] 批量查询【商品列表】失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   reMap := gin.H{
      "total": rsp.Total,
   }

   goodsList := make([]interface{}, 0)
   for _, item := range rsp.Data {
      for _, good := range goodsRsp.Data {
         if good.Id == item.GoodsId {
            tmpMap := map[string]interface{}{}
            tmpMap["id"] = item.Id
            tmpMap["goods_id"] = item.GoodsId
            tmpMap["good_name"] = good.Name
            tmpMap["good_image"] = good.GoodsFrontImage
            tmpMap["good_price"] = good.ShopPrice
            tmpMap["nums"] = item.Nums
            tmpMap["checked"] = item.Checked

            goodsList = append(goodsList, tmpMap)
         }
      }
   }
   reMap["data"] = goodsList
   ctx.JSON(http.StatusOK, reMap)
}
2.5创建购物车
func New(ctx *gin.Context) {
   //添加商品到购物车
   itemForm := forms.ShopCartItemForm{}
   if err := ctx.ShouldBindJSON(&itemForm); err != nil {
      api.HandleValidatorError(ctx, err)
      return
   }

   //为了严谨性，添加商品到购物车之前，记得检查一下商品是否存在
   _, err := global.GoodsSrvClient.GetGoodsDetail(context.Background(), &goodsProto.GoodInfoRequest{
      Id: itemForm.GoodsId,
   })
   if err != nil {
      zap.S().Errorw("[List] 查询【商品信息】失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   //如果现在添加到购物车的数量和库存的数量不一致
   invRsp, err := global.InventorySrvClient.InvDetail(context.Background(), &proto.GoodsInvInfo{
      GoodsId: itemForm.GoodsId,
   })
   if err != nil {
      zap.S().Errorw("[List] 查询【库存信息】失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }
   if invRsp.Num < itemForm.Nums {
      ctx.JSON(http.StatusBadRequest, gin.H{
         "nums": "库存不足",
      })
      return
   }

   userId, _ := ctx.Get("userId")
   rsp, err := global.OrderSrvClient.CreateCartItem(context.Background(), &proto.CartItemRequest{
      GoodsId: itemForm.GoodsId,
      UserId:  int32(userId.(uint)),
      Nums:    itemForm.Nums,
   })

   if err != nil {
      zap.S().Errorw("添加到购物车失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   ctx.JSON(http.StatusOK, gin.H{
      "id": rsp.Id,
   })
}
2.6更新购物车
func Update(ctx *gin.Context) {
   // o/v1/421
   id := ctx.Param("id")
   i, err := strconv.Atoi(id)
   if err != nil {
      ctx.JSON(http.StatusNotFound, gin.H{
         "msg": "url格式出错",
      })
      return
   }

   itemForm := forms.ShopCartItemUpdateForm{}
   if err := ctx.ShouldBindJSON(&itemForm); err != nil {
      api.HandleValidatorError(ctx, err)
      return
   }

   userId, _ := ctx.Get("userId")
   request := proto.CartItemRequest{
      UserId:  int32(userId.(uint)),
      GoodsId: int32(i),
      Nums:    itemForm.Nums,
      Checked: false,
   }
   if itemForm.Checked != nil {
      request.Checked = *itemForm.Checked
   }

   _, err = global.OrderSrvClient.UpdateCartItem(context.Background(), &request)
   if err != nil {
      zap.S().Errorw("更新购物车记录失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }
   ctx.Status(http.StatusOK)
}
2.7删除购物车
func Delete(ctx *gin.Context) {
   id := ctx.Param("id")
   i, err := strconv.Atoi(id)
   if err != nil {
      ctx.JSON(http.StatusNotFound, gin.H{
         "msg": "url格式出错",
      })
      return
   }

   userId, _ := ctx.Get("userId")
   _, err = global.OrderSrvClient.DeleteCartItem(context.Background(), &proto.CartItemRequest{
      UserId:  int32(userId.(uint)),
      GoodsId: int32(i),
   })
   if err != nil {
      zap.S().Errorw("删除购物车记录失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }
   ctx.Status(http.StatusOK)
}

lipay.TradePagePay{}
p.NotifyURL = global.ServerConfig.AliPayInfo.NotifyURL
p.ReturnURL = global.ServerConfig.AliPayInfo.ReturnURL
p.Subject = “慕学生鲜订单-” + rsp.OrderSn
p.OutTradeNo = rsp.OrderSn
p.TotalAmount = strconv.FormatFloat(float64(rsp.Total), ‘f’, 2, 64)
p.ProductCode = “FAST_INSTANT_TRADE_PAY”

url, err := client.TradePagePay§
if err != nil {
zap.S().Errorw(“生成支付url失败”)
ctx.JSON(http.StatusInternalServerError, gin.H{
“msg”: err.Error(),
})
return
}

ctx.JSON(http.StatusOK, gin.H{
“id”: rsp.Id,
“alipay_url”: url.String(),
})
}


##### 2.3订单详情

```go
func Detail(ctx *gin.Context) {
   id := ctx.Param("id")
   userId, _ := ctx.Get("userId")
   i, err := strconv.Atoi(id)
   if err != nil {
      ctx.JSON(http.StatusNotFound, gin.H{
         "msg": "url格式出错",
      })
      return
   }

   //如果是管理员用户则返回所有的订单
   request := proto.OrderRequest{
      Id: int32(i),
   }
   claims, _ := ctx.Get("claims")
   model := claims.(*models.CustomClaims)
   if model.AuthorityId == 1 {
      request.UserId = int32(userId.(uint))
   }

   rsp, err := global.OrderSrvClient.OrderDetail(context.Background(), &request)
   if err != nil {
      zap.S().Errorw("获取订单详情失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }
   reMap := gin.H{}
   reMap["id"] = rsp.OrderInfo.Id
   reMap["status"] = rsp.OrderInfo.Status
   reMap["user"] = rsp.OrderInfo.UserId
   reMap["post"] = rsp.OrderInfo.Post
   reMap["total"] = rsp.OrderInfo.Total
   reMap["address"] = rsp.OrderInfo.Address
   reMap["name"] = rsp.OrderInfo.Name
   reMap["mobile"] = rsp.OrderInfo.Mobile
   reMap["pay_type"] = rsp.OrderInfo.PayType
   reMap["order_sn"] = rsp.OrderInfo.OrderSn

   goodsList := make([]interface{}, 0)
   for _, item := range rsp.Goods {
      tmpMap := gin.H{
         "id":    item.GoodsId,
         "name":  item.GoodsName,
         "image": item.GoodsImage,
         "price": item.GoodsPrice,
         "nums":  item.Nums,
      }

      goodsList = append(goodsList, tmpMap)
   }
   reMap["goods"] = goodsList

   //生成支付宝的支付url
   client, err := alipay.New(global.ServerConfig.AliPayInfo.AppID, global.ServerConfig.AliPayInfo.PrivateKey, false)
   if err != nil {
      zap.S().Errorw("实例化支付宝失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }
   err = client.LoadAliPayPublicKey((global.ServerConfig.AliPayInfo.AliPublicKey))
   if err != nil {
      zap.S().Errorw("加载支付宝的公钥失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }

   var p = alipay.TradePagePay{}
   p.NotifyURL = global.ServerConfig.AliPayInfo.NotifyURL
   p.ReturnURL = global.ServerConfig.AliPayInfo.ReturnURL
   p.Subject = "慕学生鲜订单-" + rsp.OrderInfo.OrderSn
   p.OutTradeNo = rsp.OrderInfo.OrderSn
   p.TotalAmount = strconv.FormatFloat(float64(rsp.OrderInfo.Total), 'f', 2, 64)
   p.ProductCode = "FAST_INSTANT_TRADE_PAY"

   url, err := client.TradePagePay(p)
   if err != nil {
      zap.S().Errorw("生成支付url失败")
      ctx.JSON(http.StatusInternalServerError, gin.H{
         "msg": err.Error(),
      })
      return
   }
   reMap["alipay_url"] = url.String()

   ctx.JSON(http.StatusOK, reMap)
}
2.4购物车列表
func List(ctx *gin.Context) {
   //获取购物车商品
   userId, _ := ctx.Get("userId")
   rsp, err := global.OrderSrvClient.CartItemList(context.Background(), &proto.UserInfo{
      Id: int32(userId.(uint)),
   })
   if err != nil {
      zap.S().Errorw("[List] 查询 【购物车列表】失败")
      panic(err)
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   ids := make([]int32, 0)
   for _, item := range rsp.Data {
      ids = append(ids, item.GoodsId)
   }
   if len(ids) == 0 {
      ctx.JSON(http.StatusOK, gin.H{
         "total": 0,
      })
      return
   }

   //请求商品服务获取商品信息
   goodsRsp, err := global.GoodsSrvClient.BatchGetGoods(context.Background(), &goodsProto.BatchGoodsIdInfo{
      Id: ids,
   })
   if err != nil {
      zap.S().Errorw("[List] 批量查询【商品列表】失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   reMap := gin.H{
      "total": rsp.Total,
   }

   goodsList := make([]interface{}, 0)
   for _, item := range rsp.Data {
      for _, good := range goodsRsp.Data {
         if good.Id == item.GoodsId {
            tmpMap := map[string]interface{}{}
            tmpMap["id"] = item.Id
            tmpMap["goods_id"] = item.GoodsId
            tmpMap["good_name"] = good.Name
            tmpMap["good_image"] = good.GoodsFrontImage
            tmpMap["good_price"] = good.ShopPrice
            tmpMap["nums"] = item.Nums
            tmpMap["checked"] = item.Checked

            goodsList = append(goodsList, tmpMap)
         }
      }
   }
   reMap["data"] = goodsList
   ctx.JSON(http.StatusOK, reMap)
}
2.5创建购物车
func New(ctx *gin.Context) {
   //添加商品到购物车
   itemForm := forms.ShopCartItemForm{}
   if err := ctx.ShouldBindJSON(&itemForm); err != nil {
      api.HandleValidatorError(ctx, err)
      return
   }

   //为了严谨性，添加商品到购物车之前，记得检查一下商品是否存在
   _, err := global.GoodsSrvClient.GetGoodsDetail(context.Background(), &goodsProto.GoodInfoRequest{
      Id: itemForm.GoodsId,
   })
   if err != nil {
      zap.S().Errorw("[List] 查询【商品信息】失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   //如果现在添加到购物车的数量和库存的数量不一致
   invRsp, err := global.InventorySrvClient.InvDetail(context.Background(), &proto.GoodsInvInfo{
      GoodsId: itemForm.GoodsId,
   })
   if err != nil {
      zap.S().Errorw("[List] 查询【库存信息】失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }
   if invRsp.Num < itemForm.Nums {
      ctx.JSON(http.StatusBadRequest, gin.H{
         "nums": "库存不足",
      })
      return
   }

   userId, _ := ctx.Get("userId")
   rsp, err := global.OrderSrvClient.CreateCartItem(context.Background(), &proto.CartItemRequest{
      GoodsId: itemForm.GoodsId,
      UserId:  int32(userId.(uint)),
      Nums:    itemForm.Nums,
   })

   if err != nil {
      zap.S().Errorw("添加到购物车失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }

   ctx.JSON(http.StatusOK, gin.H{
      "id": rsp.Id,
   })
}
2.6更新购物车
func Update(ctx *gin.Context) {
   // o/v1/421
   id := ctx.Param("id")
   i, err := strconv.Atoi(id)
   if err != nil {
      ctx.JSON(http.StatusNotFound, gin.H{
         "msg": "url格式出错",
      })
      return
   }

   itemForm := forms.ShopCartItemUpdateForm{}
   if err := ctx.ShouldBindJSON(&itemForm); err != nil {
      api.HandleValidatorError(ctx, err)
      return
   }

   userId, _ := ctx.Get("userId")
   request := proto.CartItemRequest{
      UserId:  int32(userId.(uint)),
      GoodsId: int32(i),
      Nums:    itemForm.Nums,
      Checked: false,
   }
   if itemForm.Checked != nil {
      request.Checked = *itemForm.Checked
   }

   _, err = global.OrderSrvClient.UpdateCartItem(context.Background(), &request)
   if err != nil {
      zap.S().Errorw("更新购物车记录失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }
   ctx.Status(http.StatusOK)
}
2.7删除购物车
func Delete(ctx *gin.Context) {
   id := ctx.Param("id")
   i, err := strconv.Atoi(id)
   if err != nil {
      ctx.JSON(http.StatusNotFound, gin.H{
         "msg": "url格式出错",
      })
      return
   }

   userId, _ := ctx.Get("userId")
   _, err = global.OrderSrvClient.DeleteCartItem(context.Background(), &proto.CartItemRequest{
      UserId:  int32(userId.(uint)),
      GoodsId: int32(i),
   })
   if err != nil {
      zap.S().Errorw("删除购物车记录失败")
      api.HandleGrpcErrorToHttp(err, ctx)
      return
   }
   ctx.Status(http.StatusOK)
}
25、订单和购物车-web服务
qq23001186的博客
08-13 875
25、订单和购物车-web服务。
02. 微服务 - 示例搭建 - Eureka（一）
丁宿的博客
10-22 1332
eureka Server和Client简单搭建，及互相进行Http调用演示
WebOrder网上乐器订购系统
03-29
乐鸣谷网上乐器订购系统 乐器管理 点击“详细”按钮后可以查看相应乐器的详细信息 可对乐器信息进行增、删、改、查 可添加新乐器
API订单接口分类大全
t79036912的博客
10-13 457
buyer_order_express获取购买到的商品订单物流。buyer_order_detail获取购买到的商品订单详情。buyer_order_list获取购买到的商品订单列表。seller_order_list获取卖出的商品订单列表。buyer_address_list收货地址列表。buyer_address_add添加收货地址。seller_cat_props商品分类属性。buyer_token买家token。custom自定义API操作。参数说明：page:页码。请求参数：page=
weborder什么意思_web是什么意思
weixin_32205057的博客
12-24 354
1. the flattened weblike part of a feather consisting of a series of barbs on either side of the shaftSynonym: vane2. membrane connecting the toes of some aquatic birds and mammals3. an intricate trap...
weborder什么意思_WEB登录方式是什么意思？
weixin_39579127的博客
12-24 499
展开全部WEB登录方式是网页登录的方62616964757a686964616fe78988e69d8331333431373163式，意思是不是在APP上而是在相关的网站上登录。web(World Wide Web)即全球广域网，也称为万维网，它是一种基于超文本和HTTP的、全球性的、动态交互的、跨平台的分布式图形信息系统。是建立在Internet上的一种网络服务，为浏览者在Internet上查...
5. 【.NET 8 实战--孢子记账--从单体到微服务--转向微服务】--微服务基础工具与技术--Nacos
喵叔
02-09 1738
Nacos 是阿里巴巴开源的一款云原生应用基础设施，它旨在简化微服务架构中服务治理和配置管理的复杂性。通过 Nacos，服务在启动时可以自动注册，而其他服务则可以通过名称来查找并访问这些注册好的实例。同时，Nacos 内置了实时健康检查机制，能够监控各个服务实例的状态，确保只有健康的服务节点能够处理请求，从而提升整个系统的可靠性和稳定性。此外，Nacos 还提供了一个集中化的配置管理平台，使得应用能够在运行时动态更新配置而无需重启，这不仅大大降低了运维成本，也避免了因硬编码或分布式文件更新而带来的各种问题。
Springcloud-Alibaba〖二〗微服务cloud-consumer-order80构建与公共类cloud-api-commons
12-21
【Springcloud-Alibaba 二：微服务cloud-consumer-order80构建与公共类cloud-api-commons】 在构建微服务架构时，Springcloud-Alibaba 提供了丰富的组件来帮助开发者搭建和管理分布式系统。本章节主要关注如何构建 ...
04. 微服务 - 示例搭建 - LoadBalancer（一）
丁宿的博客
10-25 2200
基于Spring Cloud Load balancer，将不同的业务请求，根据各自对应的均衡算法，路由到对应节点
4.微服务项目实战---Sentinel--服务容错
王不困的博客
04-24 1314
Sentinel (分布式系统的流量防卫兵是阿里开源的一套用于。
微服务搭建----springboot接入Nacos2.x
m0_74824123的博客
02-07 1029
一开始我是有下载1.x的其他版本，他是需要输入账号密码的，初始账号密码是，nacos acos，然后很操蛋的事情来了，因为是停留在登录页面，所以他是要求你输入密码，但是2.4.3没有初始账号密码，所以点击登录一直提示账号密码失败，当时很纳闷，没改过密码呀，怎么就是不对呀，纳闷了好久，后面不小心关了链接，重新点击http://localhost:8848/nacos，他进去了，他进去了！nacos之前用的版本是1.0的，现在重新搭建一个2.0版本的，学如逆水行舟，不进则退，废话不多说，开搞。
打印机常见六大故障的解决方法
weixin_34259232的博客
09-23 540
一、打印机输出空白纸 对于针式打印机，引起打印纸空白的原因大多是由于色带油墨干涸、色带拉断、打印头损坏等，应及时更换色带或维修打印头；对于喷墨打印机，引起打印空白的故障大多是由于喷嘴堵塞、墨盒没有墨水等，应清洗喷头或更换墨盒；而对于激光打印机，引起该类故障的原因可能是显影辊未吸到墨粉(显影辊的直流偏压未加上)，也可能是感光鼓未接地，使负电荷无法向地释放，激光束不能在感光鼓...
一文搞定接口幂等性架构设计方案
fzlhz的博客
05-09 154
现如今很多系统都会基于分布式或微服务思想完成对系统的架构设计。那么在这一个系统中，就会存在若干个微服务，而且服务间也会产生相互通信调用。那么既然产生了服务调用，就必然会存在服务调用延迟或失败的问题。当出现这种问题，服务端会进行重试等操作或客户端有可能会进行多次点击提交。如果这样请求多次的话，那最终处理的数据结果就一定要保证统一，如支付场景。此时就需要通过保证业务幂等性方案来完成。什么是幂等性幂等是一个数学与计算机学概念，即f(n) = 1^n。
建设营销型网站这6个要点要注意
jxsl6的博客
09-08 659
　　一般来说企业做营销型网站，大多是为了后期的推广优化，因此小编提醒大家在进行营销型网站建设时要注意以下6点问题： 　　1，网站SEO设置 　　网站SEO设置包含：整站伪静态、网站地图、301重定向、404页面设置等，有人就说了我不是专业的推广人员，我只是写程序的，到底应该怎么办，这些基础的教程网上有很多。 　　2，网站TDK设置 　　TDK简单来说就是标题、关键词和描述，虽然说近年来随着百度算法的变化其重要性有所削弱，但是TDK在SEO优化中依然骑着不可代替的作用，所以设置好TDK是网站参与收录和排名必要
web worker的用法及应用场景
热门推荐
讨厌走开啦
04-07 2万+
首先简单介绍一下什么是web worker。我们都知道在浏览器中javascript的执行是单线程的，页面上的javascript在执行时会阻塞浏览器的响应，这非常影响用户体验，所以ajax应运而生了。ajax的出现使得页面在等待服务器响应的这段时间内不再发生阻塞，但是这仍然没有改变代码单线程执行的本质，这也意味着我们依旧不能把耗费时间的复杂运算放在页面上执行。而web worker的出现弥补了这...
什么是WebWorker?
_
03-06 8379
web worker 是运行在后台的 JavaScript，不会影响页面的性能。web worker 无疑是解决 js 计算能力弱的一大利器。 如果将 docs 表格中复杂计算放到主线程中，页面不仅可能卡顿，甚至可能崩溃掉。将计算挪入 web worker 中，将计算结果事件回调的方式返回，可以让用户使用更加流畅。 当然 docs 表格一些复杂的公式计算例如跨表引用 vlookp ，还是要结合服务端计算能力共同解决。 web worker示例： https://jsfiddle.net/z...
golang 发送内网邮件和外网邮件
最新发布
刘永年
12-16 819
Go语言Email包简介 一个功能强大的Go语言邮件发送库，支持SMTP/TLS加密发送，具有以下特性： 支持纯文本/HTML格式邮件 基于域名的智能SMTP配置管理 并发发送机制提升批量邮件效率 完善的错误处理和配置验证 提供TLS加密支持（465/587端口） 安装简单：go get github.com/liu-dc/email。支持多域名配置、自动选择SMTP服务器，并包含详细的API文档和示例代码，适合各类邮件发送需求。
OpenResty与Node.js微服务架构实战
5. **微服务架构模式**：文档中列出的字母组合可能代表不同的微服务，比如 A, B, C, D 等，这些可能是具体的微服务实例，比如用户服务（User Service）、订单服务（Order Service）等。 6. **技术选型**：文档可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值