larkgin

README

Lark Gin

Gin Middlewares for go-lark.

Middlewares

• LarkChallengeHandler: URL challenge for general events and card callback
• LarkEventHandler: Incoming events (schema 2.0)
• LarkCardHandler: Card callback
• LarkMessageHandler (Legacy): Incoming message event (schema 1.0)

Installation

go get -u github.com/go-lark/lark-gin/v2

Usage

package main

import (
    "fmt"

    "github.com/gin-gonic/gin"
    "github.com/go-lark/lark/v2"
    larkgin "github.com/go-lark/lark-gin/v2"
)

func main() {
    r := gin.Default()
    middleware := larkgin.NewLarkMiddleware()

    // lark server challenge
    r.Use(middleware.LarkChallengeHandler())

    // all supported events
    eventGroup := r.Group("/event")
    {
        eventGroup.Use(middleware.LarkEventHandler())
        eventGroup.POST("/", func(c *gin.Context) {
            if evt, ok := middleware.GetEvent(e); ok { // => returns `*lark.EventV2`
                if evt.Header.EventType == lark.EventTypeMessageReceived {
                    // message received event
                    // you may also parse other events
                    if msg, err := evt.GetMessageReceived(); err == nil {
                        fmt.Println(msg.Message.Content)
                    }
                }
            }
        })
    }

    // card callback only
    cardGroup := r.Group("/card")
    {
        cardGroup.Use(middleware.LarkCardHandler())
        cardGroup.POST("/callback", func(c *gin.Context) {
            if card, ok := middleware.GetCardCallback(c); ok { // => returns `*lark.EventCardCallback`
            }
        })
    }

    r.Run(":8080")
}

Example: examples/gin-middleware

Card Callback

We may also setup callback for card actions (e.g. button). The URL challenge part is the same.

We may use LarkCardHandler to handle the actions:

r.Use(middleware.LarkCardHandler())
r.POST("/callback", func(c *gin.Context) {
    if card, ok := middleware.GetCardCallback(c); ok {
    }
})

Token Verification

middleware.WithTokenVerfication("yourVerificationToken")

Encryption

Notice: encryption is not available for card callback, due to restriction from Lark Open Platform.

middleware.WithEncryption("yourEncryptionKey")

URL Binding

Only bind specific URL for events:

middleware.BindURLPrefix("/abc")

Logger

lark-gin implements and uses lark.LogWrapper. You may set your own logger:

middleware.SetLogger(yourOwnLogger)

About

Copyright (c) go-lark Developers, 2018-2025.

Documentation

Overview

Package larkgin is gin middleware for go-lark/lark

Index

• Constants
• type LarkMiddleware
  • func NewLarkMiddleware() *LarkMiddleware
  • func (opt *LarkMiddleware) BindURLPrefix(prefix string) *LarkMiddleware
  • func (opt LarkMiddleware) GetCardCallback(c *gin.Context) (*lark.EventCardCallback, bool)
  • func (opt LarkMiddleware) GetEvent(c *gin.Context) (*lark.EventV2, bool)
  • func (opt LarkMiddleware) GetMessage(c *gin.Context) (*lark.EventMessage, bool)
  • func (opt LarkMiddleware) LarkCardHandler() gin.HandlerFunc
  • func (opt LarkMiddleware) LarkChallengeHandler() gin.HandlerFunc
  • func (opt LarkMiddleware) LarkEventHandler() gin.HandlerFunc
  • func (opt LarkMiddleware) LarkMessageHandler() gin.HandlerFunc
  • func (opt *LarkMiddleware) SetCardKey(key string) *LarkMiddleware
  • func (opt *LarkMiddleware) SetLogger(logger lark.LogWrapper)
  • func (opt *LarkMiddleware) SetMessageKey(key string) *LarkMiddleware
  • func (opt *LarkMiddleware) WithEncryption(key string) *LarkMiddleware
  • func (opt *LarkMiddleware) WithTokenVerification(token string) *LarkMiddleware

Constants

const DefaultLarkMessageKey = "go-lark-message"

DefaultLarkMessageKey compat legacy versions not use in this repo right now

Types

type LarkMiddleware

type LarkMiddleware struct {
	// contains filtered or unexported fields
}

LarkMiddleware .

func NewLarkMiddleware

func NewLarkMiddleware() *LarkMiddleware

NewLarkMiddleware .

func (*LarkMiddleware) BindURLPrefix

func (opt *LarkMiddleware) BindURLPrefix(prefix string) *LarkMiddleware

BindURLPrefix .

func (LarkMiddleware) GetCardCallback

func (opt LarkMiddleware) GetCardCallback(c *gin.Context) (*lark.EventCardCallback, bool)

GetCardCallback from gin context

func (LarkMiddleware) GetEvent

func (opt LarkMiddleware) GetEvent(c *gin.Context) (*lark.EventV2, bool)

GetEvent should call GetEvent if you're using EventV2

func (LarkMiddleware) GetMessage

func (opt LarkMiddleware) GetMessage(c *gin.Context) (*lark.EventMessage, bool)

GetMessage from gin context

func (LarkMiddleware) LarkCardHandler

func (opt LarkMiddleware) LarkCardHandler() gin.HandlerFunc

LarkCardHandler card callback handler Encryption is automatically ignored, because it's not supported officially

func (LarkMiddleware) LarkChallengeHandler

func (opt LarkMiddleware) LarkChallengeHandler() gin.HandlerFunc

LarkChallengeHandler Lark challenge handler

func (LarkMiddleware) LarkEventHandler

func (opt LarkMiddleware) LarkEventHandler() gin.HandlerFunc

LarkEventHandler handle lark event v2

func (LarkMiddleware) LarkMessageHandler

func (opt LarkMiddleware) LarkMessageHandler() gin.HandlerFunc

LarkMessageHandler Lark message handler

func (*LarkMiddleware) SetCardKey

func (opt *LarkMiddleware) SetCardKey(key string) *LarkMiddleware

SetCardKey .

func (*LarkMiddleware) SetLogger

func (opt *LarkMiddleware) SetLogger(logger lark.LogWrapper)

SetLogger set a new logger

func (*LarkMiddleware) SetMessageKey

func (opt *LarkMiddleware) SetMessageKey(key string) *LarkMiddleware

SetMessageKey .

func (*LarkMiddleware) WithEncryption

func (opt *LarkMiddleware) WithEncryption(key string) *LarkMiddleware

WithEncryption .

func (*LarkMiddleware) WithTokenVerification

func (opt *LarkMiddleware) WithTokenVerification(token string) *LarkMiddleware

WithTokenVerification .