lark

README

Lark

Prerequisites

Depending on your requirements, you'll need either a custom app or a Lark group chat webhook. The latter is easier to set up, but can only send messages to the group it is in. You may refer to the doc here to set up a webhook bot, and the doc here to set up a custom app.

Usage

Webhook

For webhook bots, we only need the webhook URL, which might look something like https://open.feishu.cn/open-apis/bot/v2/hook/xxx. Note that there is no method to configure receivers, because the webhook bot can only send messages to the group in which it was created.

package main

import (
	"context"
	"log"

	"github.com/nikoksr/notify"
	"github.com/nikoksr/notify/service/lark"
)

// Replace this with your own webhook URL.
const webHookURL = "https://open.feishu.cn/open-apis/bot/v2/hook/xxx"

func main() {
	larkWebhookSvc := lark.NewWebhookService(webHookURL)

	notifier := notify.New()
	notifier.UseServices(larkWebhookSvc)

	if err := notifier.Send(context.Background(), "subject", "message"); err != nil {
		log.Fatalf("notifier.Send() failed: %s", err.Error())
	}

	log.Println("notification sent")
}

Custom App

For custom apps, we need to pass in the App ID and App Secret when creating a new notification service. When adding receivers, the type of the receiver ID must be specified, as shown in the example below. You may refer to the section entitled "Query parameters" in the doc here for more information about the different ID types.

package main

import (
	"context"
	"log"

	"github.com/nikoksr/notify"
	"github.com/nikoksr/notify/service/lark"
)

// Replace these with the credentials from your custom app.
const (
	appId     = "xxx"
	appSecret = "xxx"
)

func main() {
	larkCustomAppService := lark.NewCustomAppService(appId, appSecret)

	// Lark implements five types of receiver IDs. You'll need to specify the
	// type using the respective helper functions when adding them as receivers.
	larkCustomAppService.AddReceivers(
		lark.OpenID("xxx"),
		lark.UserID("xxx"),
		lark.UnionID("xxx"),
		lark.Email("xyz@example.com"),
		lark.ChatID("xxx"),
	)

	notifier := notify.New()
	notifier.UseServices(larkCustomAppService)

	if err := notifier.Send(context.Background(), "subject", "message"); err != nil {
		log.Fatalf("notifier.Send() failed: %s", err.Error())
	}

	log.Println("notification sent")
}

Documentation

Overview

Package lark provides message notification integration for Lark. Two kinds of bots on Lark are supported -- webhooks and custom apps. For information on webhook bots, see https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/bot-v3/use-custom-bots-in-a-group, and for info on custom apps, see https://open.larksuite.com/document/home/develop-a-bot-in-5-minutes/create-an-app.

Usage:

package main

import (
  "context"
  "log"

  "github.com/nikoksr/notify"
  "github.com/nikoksr/notify/service/lark"
)

const (
  webhookURL = "https://open.feishu.cn/open-apis/bot/v2/hook/xxx"
  appId      = "xxx"
  appSecret  = "xxx"
)

func main() {
  // Two types of services are available depending on your requirements.
  larkWebhookService := lark.NewWebhookService(webhookURL)
  larkCustomAppService := lark.NewCustomAppService(appId, appSecret)

  // Lark implements five types of receiver IDs. You'll need to specify the
  // type using the respective helper functions when adding them as receivers
  // for the custom app service.
  larkCustomAppService.AddReceivers(
    lark.OpenID("xxx"),
    lark.UserID("xxx"),
    lark.UnionID("xxx"),
    lark.Email("xyz@example.com"),
    lark.ChatID("xxx"),
  )

  notifier := notify.New()
  notifier.UseServices(larkWebhookService, larkCustomAppService)

  if err := notifier.Send(context.Background(), "subject", "message"); err != nil {
    log.Fatalf("notifier.Send() failed: %s", err.Error())
  }

  log.Println("notification sent")
}

Index

• func ChatID(s string) *receiverID
• func Email(s string) *receiverID
• func NewCustomAppService(appID, appSecret string) *customAppService
• func NewWebhookService(webhookURL string) *webhookService
• func OpenID(s string) *receiverID
• func UnionID(s string) *receiverID
• func UserID(s string) *receiverID
• type NewSendToerT
• type NewSenderT
• type SendToer
  • func NewSendToer(t NewSendToerT) *SendToer
  • func (_m *SendToer) SendTo(subject string, message string, id string, idType string) error
• type Sender
  • func NewSender(t NewSenderT) *Sender
  • func (_m *Sender) Send(subject string, message string) error

Functions

func ChatID

func ChatID(s string) *receiverID

ChatID specifies an ID as a Lark Chat ID.

func Email

func Email(s string) *receiverID

Email specifies a receiver ID as an email.

func NewCustomAppService

func NewCustomAppService(appID, appSecret string) *customAppService

NewCustomAppService returns a new instance of a Lark notify service using a Lark custom app.

func NewWebhookService

func NewWebhookService(webhookURL string) *webhookService

NewWebhookService returns a new instance of a Lark notify service using a Lark group chat webhook. Note that this service does not take any notification receivers because it can only push messages to the group chat it belongs to.

func OpenID

func OpenID(s string) *receiverID

OpenID specifies an ID as a Lark Open ID.

func UnionID

func UnionID(s string) *receiverID

UnionID specifies an ID as a Lark Union ID.

func UserID

func UserID(s string) *receiverID

UserID specifies an ID as a Lark User ID.

Types

type NewSendToerT

type NewSendToerT interface {
	mock.TestingT
	Cleanup(func())
}

type NewSenderT

type NewSenderT interface {
	mock.TestingT
	Cleanup(func())
}

type SendToer

type SendToer struct {
	mock.Mock
}

SendToer is an autogenerated mock type for the sendToer type

func NewSendToer

func NewSendToer(t NewSendToerT) *SendToer

NewSendToer creates a new instance of SendToer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*SendToer) SendTo

func (_m *SendToer) SendTo(subject string, message string, id string, idType string) error

SendTo provides a mock function with given fields: subject, message, id, idType

type Sender

type Sender struct {
	mock.Mock
}

Sender is an autogenerated mock type for the sender type

func NewSender

func NewSender(t NewSenderT) *Sender

NewSender creates a new instance of Sender. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*Sender) Send

func (_m *Sender) Send(subject string, message string) error

Send provides a mock function with given fields: subject, message