lark Go SDK

Use lark.New with functional options to configure the client based on your application type and region.

Common configurations include:

• Standard App/Bot: Use lark.WithAppCredential("<APP_ID>", "<APP_SECRET>").
• Larksuite (Non-China): Set the base URLs using lark.WithOpenBaseURL("https://open.larksuite.com") and lark.WithWWWBaseURL("https://www.larksuite.com").
• Event Callbacks: Provide encryption keys and verification tokens using lark.WithEventCallbackVerify("<ENCRYPT_KEY>", "<VERIFICATION_TOKEN>").
• Helpdesk App: Use lark.WithHelpdeskCredential("<HELPDESK_ID>", "HELPDESK_TOKEN").
• ISV App: Enable ISV mode with lark.WithISV(true) and specify a store with lark.WithStore("<NEW_STORE>").

// Standard App
cli := lark.New(lark.WithAppCredential("<APP_ID>", "<APP_SECRET>"))

// Larksuite (non-China region)
cli := lark.New(
    lark.WithAppCredential("<APP_ID>", "<APP_SECRET>"),
    lark.WithOpenBaseURL("https://open.larksuite.com"),
    lark.WithWWWBaseURL("https://www.larksuite.com"),
)

// Helpdesk
cli := lark.New(
    lark.WithAppCredential("<APP_ID>", "<APP_SECRET>"),
    lark.WithHelpdeskCredential("<HELPDESK_ID>", "HELPDESK_TOKEN"),
)

To handle incoming events (like receiving a message), register a handler using the EventCallback service and then use ListenCallback within an HTTP server to process the requests.

1. Initialize the client with lark.WithEventCallbackVerify.
2. Use a specific handler method (e.g., HandlerEventIMMessageReceiveV1) to define the logic for a specific event type.
3. Use cli.EventCallback.ListenCallback inside an HTTP handler to route the request body to the registered event handlers.

cli := lark.New(
    lark.WithAppCredential("<APP_ID>", "<APP_SECRET>"),
    lark.WithEventCallbackVerify("<ENCRYPT_KEY>", "<VERIFICATION_TOKEN>"),
)

// handle message callback
cli.EventCallback.HandlerEventIMMessageReceiveV1(func(ctx context.Context, cli *lark.Lark, schema string, header *lark.EventV2Header, event *lark.EventV2IMMessageReceiveV1) (string, error) {
    _, _, err := cli.Message.Reply(event.Message.MessageID).SendText(ctx, "hi, "+event.Message.Content)
    return "", err
})

http.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
    cli.EventCallback.ListenCallback(r.Context(), r.Body, w)
})

log.Fatal(http.ListenAndServe(":9726", nil))

The response object containing user attendance statistics.

Top-level fields:

• UserDatas: A list of GetAttendanceUserStatsDataRespUserData (max 1000).
• InvalidUserList: A list of user IDs that the caller does not have permission to access.

User Data (GetAttendanceUserStatsDataRespUserData):

• Name: User's name.
• UserID: User's ID.
• Datas: A list of statistical data points (GetAttendanceUserStatsDataRespUserDataData).

Statistical Data Point (GetAttendanceUserStatsDataRespUserDataData):

• Code: Field identifier.
• Value: The data value.
• Title: The field title.
• Features: Additional attributes (e.g., clock-in results, leave application times).
• DurationNum: A map of time units (Day, HalfDay, Hour, HalfHour, Minute) to duration values.

type GetAttendanceUserStatsDataResp struct {
	UserDatas       []*GetAttendanceUserStatsDataRespUserData `json:"user_datas,omitempty"` 
	InvalidUserList []string                                  `json:"invalid_user_list,omitempty"` 
}

type GetAttendanceUserStatsDataRespUserData struct {
	Name   string                                        `json:"name,omitempty"`    
	UserID string                                        `json:"user_id,omitempty"` 
	Datas  []*GetAttendanceUserStatsDataRespUserDataData `json:"datas,omitempty"`   
}

type GetAttendanceUserStatsDataRespUserDataData struct {
	Code        string                                                 `json:"code,omitempty"`         
	Value       string                                                 `json:"value,omitempty"`        
	Features    []*GetAttendanceUserStatsDataRespUserDataDataFeature   `json:"features,omitempty"`     
	Title       string                                                 `json:"title,omitempty"`       
	DurationNum *GetAttendanceUserStatsDataRespUserDataDataDurationNum `json:"duration_num,omitempty"` 
}

When updating a badge grant, you can use the UpdateAdminBadgeGrantReqRuleDetail struct to manage the timing and lifecycle of the grant. This is particularly important when GrantType is set to manual selection.

Fields in UpdateAdminBadgeGrantReqRuleDetail:

• EffectiveTime: The start timestamp. For manual types, this must be the midnight timestamp of the day in the specified TimeZone (e.g., 1649606400 for Asia/Shanghai).
• ExpirationTime: The end timestamp.
  • Must not exceed EffectiveTime + 100 years.
  • For non-permanent grants, this must be the 23:59:59 timestamp of the day in the specified TimeZone (e.g., 1649692799).
  • For permanent grants, set this to 0.
• Anniversary: The work anniversary day (range 1 to 60) used for grants based on hire date.
• EffectivePeriod: The validity period for hire-date-based grants (e.g., 1 for one year, 2 for permanent).

rule := &lark.UpdateAdminBadgeGrantReqRuleDetail{
    EffectiveTime:  ptrString("1649606400"),
    ExpirationTime: ptrString("1649692799"),
}

req := &lark.UpdateAdminBadgeGrantReq{
    // ... other fields
    RuleDetail: rule,
}