capture message catalog from whatsapp bussiness

[hrizal]

As we know, we can create a catalog in the WhatsApp business, and those who contact can order products from the catalog into the shopping cart.

When the shopping cart is delivered, the message the API receives is just a blank text, has anyone caught the shopping cart message?

[Romerito007]

As we know, we can create a catalog in the WhatsApp business, and those who contact can order products from the catalog into the shopping cart.

When the shopping cart is delivered, the message the API receives is just a blank text, has anyone caught the shopping cart message?

I implemented message received, I did not test the sending. ProductMessage and OrderMessage

[Romerito007]

this is my implementation

`/ OrderMessage represents a order message. /

type OrderMessage struct { Info MessageInfo OrderId string Thumbnail []byte ItemCount int32 Status proto.OrderMessage_OrderMessageOrderStatus Surface proto.OrderMessage_OrderMessageOrderSurface Message string OrderTitle string SellerJid string Token string ContextInfo ContextInfo }

func getOrderMessage(msg *proto.WebMessageInfo) OrderMessage { order := msg.GetMessage().GetOrderMessage()

orderMessage := OrderMessage{
    Info:        getMessageInfo(msg),
    OrderId:     order.GetOrderId(),
    Thumbnail:   order.GetThumbnail(),
    ItemCount:   order.GetItemCount(),
    Status:      order.GetStatus(),
    Surface:     order.GetSurface(),
    Message:     order.GetMessage(),
    OrderTitle:  order.GetOrderTitle(),
    SellerJid:   order.GetSellerJid(),
    Token:       order.GetToken(),
    ContextInfo: getMessageContext(order.GetContextInfo()),
}

return orderMessage

}

func getOrderMessageProto(msg OrderMessage) *proto.WebMessageInfo { p := getInfoProto(&msg.Info) contextInfo := getContextInfoProto(&msg.ContextInfo)

p.Message = &proto.Message{
    OrderMessage: &proto.OrderMessage{
        Thumbnail:   msg.Thumbnail,
        ItemCount:   &msg.ItemCount,
        Status:      &msg.Status,
        Surface:     &msg.Surface,
        Message:     &msg.Message,
        OrderTitle:  &msg.OrderTitle,
        SellerJid:   &msg.SellerJid,
        Token:       &msg.Token,
        ContextInfo: contextInfo,
    },
}

return p

}`

`/ ProductMessage represents a product message. /

type ProductMessage struct { Info MessageInfo Product proto.ProductSnapshot BusinessOwnerJid string Catalog proto.CatalogSnapshot ContextInfo ContextInfo }

func getProductMessage(msg *proto.WebMessageInfo) ProductMessage { prod := msg.GetMessage().GetProductMessage()

productMessage := ProductMessage{
    Info:             getMessageInfo(msg),
    Product:          prod.GetProduct(),
    BusinessOwnerJid: prod.GetBusinessOwnerJid(),
    Catalog:          prod.GetCatalog(),
    ContextInfo:      getMessageContext(prod.GetContextInfo()),
}

return productMessage

}

func getProductMessageProto(msg ProductMessage) *proto.WebMessageInfo { p := getInfoProto(&msg.Info) contextInfo := getContextInfoProto(&msg.ContextInfo)

p.Message = &proto.Message{
    ProductMessage: &proto.ProductMessage{
        Product:          msg.Product,
        BusinessOwnerJid: &msg.BusinessOwnerJid,
        Catalog:          msg.Catalog,
        ContextInfo:      contextInfo,
    },
}

return p

}`

`func ParseProtoMessage(msg *proto.WebMessageInfo) interface{} {

switch {

......

case msg.GetMessage().GetProductMessage() != nil:
    return getProductMessage(msg)

case msg.GetMessage().GetOrderMessage() != nil:
    return getOrderMessage(msg)

default:
    //cannot match message
    return ErrMessageTypeNotImplemented
}

}`

`/ The ProductMessageHandler interface needs to be implemented to receive product messages dispatched by the dispatcher. / type ProductMessageHandler interface { Handler HandleProductMessage(message ProductMessage) }

/ The OrderMessageHandler interface needs to be implemented to receive order messages dispatched by the dispatcher. / type OrderMessageHandler interface { Handler HandleOrderMessage(message OrderMessage) }`

`func (wac *Conn) handleWithCustomHandlers(message interface{}, handlers []Handler) { switch m := message.(type) { .........

case ProductMessage:
    for _, h := range handlers {
        if x, ok := h.(ProductMessageHandler); ok {
            if wac.shouldCallSynchronously(h) {
                x.HandleProductMessage(m)
            } else {
                go x.HandleProductMessage(m)
            }
        }
    }

case OrderMessage:
    for _, h := range handlers {
        if x, ok := h.(OrderMessageHandler); ok {
            if wac.shouldCallSynchronously(h) {
                x.HandleOrderMessage(m)
            } else {
                go x.HandleOrderMessage(m)
            }
        }
    }

     ........................

}`

[hrizal]

you are amazing bro ..

[beshoo]

@Romerito007 thanks for this great idea. I would like to ask you to create a PL, so we can have this in the lib and all of us will enjoy this great option