larksuite / oapi-sdk-go Goto Github PK

func CreateLarkTable(ctx *core.Context, title string, folderToken string) (path string, err error) {
	httpPath := "https://open.feishu.cn/open-apis/sheets/v3/spreadsheets"
	httpMethod := "POST"
	requestParam := request.SetQueryParams(map[string]interface{}{"title": title, "folder_token": folderToken})
	ret := make(map[string]interface{})
	req := request.NewRequestWithNative(httpPath, httpMethod, accessTokenType, nil, &ret, requestParam)

	err = api.Send(ctx, conf, req)
	if err != nil {
		return "", err
	}

	if _, ok := ret["spreadsheet"]; !ok {
		return "", fmt.Errorf("响应不存在spreadsheet字段")
	}
	spreadsheet := ret["spreadsheet"]
	if _, ok := spreadsheet.(map[string]interface{}); !ok {
		return "", fmt.Errorf("响应的spreadsheet字段不能转换为map[string]interface{}")
	}
	params := spreadsheet.(map[string]interface{})
	if _, ok := params["url"]; !ok {
		return "", fmt.Errorf("响应不存在url字段")
	}
	if _, ok := params["url"].(string); !ok {
		return "", fmt.Errorf("响应的url字段不是string")
	}
	url := params["url"].(string)
	return url, nil
}

2023/04/27 13:54:07 [Error] [handle event,path:/event,err: json: cannot unmarshal number into Go struct field P2BotMenuV6Data.event.timestamp of type string]

  CodeError: {
    Code: 19002,
    Msg: "params error, unknown card value"
  }

type Cache interface {
	Set(ctx context.Context, key string, value string, expireTime time.Duration) error
	Get(ctx context.Context, key string) (string, error)
}

  func (c cmdable) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {
	  args := make([]interface{}, 3, 5)
	  args[0] = "set"
	  args[1] = key
	  args[2] = value
	  if expiration > 0 {
		  if usePrecise(expiration) {
			  args = append(args, "px", formatMs(ctx, expiration))
		  } else {
			  args = append(args, "ex", formatSec(ctx, expiration))
		  }
	  } else if expiration == KeepTTL {
		  args = append(args, "keepttl")
	  }
  
	  cmd := NewStatusCmd(ctx, args...)
	  _ = c(ctx, cmd)
	  return cmd
  }

/ Cache 缓存相关的实现 .
type Cache interface {
	// Set .
	Set(ctx context.Context, key string, value interface{}, expiration time.Duration) error

	// Get .
	Get(ctx context.Context, key string) (string, error)
}

func (r *Redis) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) error {
	err := r.client.Set(ctx, key, value, expiration).Err()
	return err
}

func (r *Redis) Get(ctx context.Context, key string) (string, error) {
	value, err := r.client.Get(ctx, key).Result()
	if err != nil && err == redis.Nil {
		return "", errors.ERRMissingCacheKey
	}
	return value, nil
}

package main

import (
	"fmt"
	"github.com/larksuite/oapi-sdk-go/v2"
)

func main() {
	card := lark.MessageCard{
		Header: &lark.MessageCardHeader{
			Title:    &lark.MessageCardPlainText{Content: "k8s ticket"},
			Template: lark.StringPtr("indigo"),
		},
	}
	element := &lark.MessageCardAction{}
	cluster := &lark.MessageCardEmbedSelectMenuStatic{
		&lark.MessageCardEmbedSelectMenuBase{
			Placeholder: &lark.MessageCardPlainText{
				Content: "choose cluster",
			},
			InitialOption: "dev",
		},
	}
	element.Actions = append(element.Actions, cluster)
	card.Elements = append(card.Elements, element)
	content, err := card.JSON()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("card:%s\n", content)
}

im.SetMessageReceiveEventHandler(FeiShuConf, func(ctx *core.Context, event *im.MessageReceiveEvent) error {
	fmt.Println("**************** SetMessageReceiveEventHandler ****************")
	fmt.Println("GetID: ", ctx.GetRequestID())
	fmt.Println("SetMessageReceiveEventHandler", tools.Prettify(event))
	return nil
})
eventhttp.Handle(FeiShuConf, ctx.Request, ctx.Writer)

func OpenLarkTableEditAuthority(ctx *core.Context, token string) (err error) {
	httpPath := "https://open.feishu.cn/open-apis/drive/v1/permissions/:token/public"
	httpMethod := "PATCH"
	requestParam := request.SetQueryParams(map[string]interface{}{"type": "sheet"})
        //路径参数设置生效
	pathParam:=request.SetPathParams(map[string]interface{}{"token":token})
	body := map[string]interface{}{
		"external_access":   true,              //是否允许分享到租户外开关
		"security_entity":   "anyone_can_view", //可创建副本/打印/导出/复制设置 所有可访问此文档的用户
		"comment_entity":    "anyone_can_view", //可评论设置 所有可访问此文档的用户
		"share_entity":      "anyone",          //谁可以添加和管理协作者 所有可阅读或编辑此文档的用户
		"link_share_entity": "anyone_editable", //链接共享 得链接的任何人可编辑（仅external_access=“true”时有效）
		"invite_external":   true,              //非所有权限者/所有者是否允许邀请外部人
	}
	req := request.NewRequestWithNative(httpPath, httpMethod, accessTokenType, body, nil,requestParam,pathParam)

	err = api.Send(ctx, conf, req)

	if err != nil {
		return err
	}
	return nil
}


执行报错：path:https://open.feishu.cn/open-apis/drive/v1/permissions/:token/public, var name: not find value

func doProcess(writer http.ResponseWriter, req *http.Request, reqHandler larkevent.IReqHandler) {
	// 转换http请求对象为标准请求对象
	ctx := context.Background()
	eventReq, err := translate(ctx, req)
	if err != nil {
		writer.WriteHeader(http.StatusInternalServerError)
		writer.Write([]byte(err.Error()))
		return
	}

	// 处理请求
	eventResp := reqHandler.Handle(ctx, eventReq)

	// 回写结果
	err = write(ctx, writer, eventResp)
	if err != nil {
		reqHandler.Logger().Error(ctx, fmt.Sprintf("write resp result error:%s", err.Error()))
	}
}

body := map[string]interface{}{
	"user_id_type": "open_id",
	"department_id_type": "open_department_id",
	"parent_department_id": "",
	"fetch_child":true,
	//"page_token":"",
	//"page_size":50,
}

//接收返回
ret := make(map[string]interface{})

    //构建访问
req := request.NewRequestWithNative("/open-apis/contact/v3/departments", "GET", request.AccessTokenTypeTenant, body, &ret)

//上下文
coreCtx := core.WrapContext(context.Background())

    //发送数据
err := api.Send(coreCtx, FeiShuConf, req)
if err != nil{
	e := err.(*response.Error)
	fmt.Println("发送给自己错误：", e, tools.Prettify(err))
	return
}
fmt.Println("发送给自己：", tools.Prettify(ret))