WeWorkFinanceSDK

This example demonstrates the full lifecycle: initializing the client, syncing chat data, decrypting an image message, downloading its media chunks, and saving it to a file.

package main

import (
	"bytes"
	"fmt"
	"github.com/NICEXAI/WeWorkFinanceSDK"
	"io/ioutil"
	"os"
	"path"
)

func main() {
	corpID := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
	corpSecret := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
	rsaPrivateKey := `
-----BEGIN RSA PRIVATE KEY-----
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-----END RSA PRIVATE KEY-----
`

	// Initialize client
	client, err := WeWorkFinanceSDK.NewClient(corpID, corpSecret, rsaPrivateKey)
	if err != nil {
		fmt.Printf("SDK 初始化失败：%v \n", err)
		return
	}

	// Sync messages
	chatDataList, err := client.GetChatData(0, 100, "", "", 3)
	if err != nil {
		fmt.Printf("消息同步失败：%v \n", err)
		return
	}

	for _, chatData := range chatDataList {
		// Decrypt message
		chatInfo, err := client.DecryptData(chatData.EncryptRandomKey, chatData.EncryptChatMsg)
		if err != nil {
			fmt.Printf("消息解密失败：%v \n", err)
			return
		}

		if chatInfo.Type == "image" {
			image := chatInfo.GetImageMessage()
			sdkfileid := image.Image.SdkFileID

			isFinish := false
			buffer := bytes.Buffer{}
			index_buf := ""
			for !isFinish {
				// Get media data chunks
				mediaData, err := client.GetMediaData(index_buf, sdkfileid, "", "", 5)
				if err != nil {
					fmt.Printf("媒体数据拉取失败：%v \n", err)
					return
				}
				buffer.Write(mediaData.Data)
				if mediaData.IsFinish {
					isFinish = mediaData.IsFinish
				}
				index_buf = mediaData.OutIndexBuf
			}
			filePath, _ := os.Getwd()
			filePath = path.Join(filePath, "test.png")
			err := ioutil.WriteFile(filePath, buffer.Bytes(), 0666)
			if err != nil {
				fmt.Printf("文件存储失败：%v \n", err)
				return
			}
			break
		}
	}
}

If a decrypted message is an image, you can download the media content using client.GetMediaData. Because media files may be delivered in chunks, you must loop until IsFinish is true.

Workflow:

1. Identify the SdkFileID from the image message object.
2. Call client.GetMediaData using the sdkfileid and the index_buf from the previous call.
3. Append the Data from the response to a buffer.
4. Update your index_buf with mediaData.OutIndexBuf for the next iteration.
5. Stop when mediaData.IsFinish is true.

Parameters for GetMediaData:

• index_buf (string): The index buffer from the previous response.
• sdkfileid (string): The file ID to retrieve.
• search_key (string): Optional search key.
• search_value (string): Optional search value.
• limit (int): Chunk limit.

mediaData, err := client.GetMediaData(index_buf, sdkfileid, "", "", 5)
// ...
index_buf = mediaData.OutIndexBuf

The SDK allows you to retrieve encrypted chat data and decrypt it into readable message information.

1. Get Chat Data

Call client.GetChatData to retrieve a list of encrypted chat messages.

Parameters:

• offset (int): The starting offset for synchronization.
• limit (int): The number of messages to retrieve.
• search_key (string): Search key (optional).
• search_value (string): Search value (optional).
• type (int): Message type filter.

2. Decrypt Data

Iterate through the returned chatDataList and use client.DecryptData to decrypt individual messages.

Parameters:

• encryptRandomKey (string): The random key from the chatData object.
• encryptChatMsg (string): The encrypted message content from the chatData object.

Returns:

• chatInfo: An object containing the decrypted message details (e.g., Type, GetImageMessage()).

chatDataList, err := client.GetChatData(0, 100, "", "", 3)
// ...
chatInfo, err := client.DecryptData(chatData.EncryptRandomKey, chatData.EncryptChatMsg)

Use DecryptData to convert encrypted chat messages into readable ChatMessage objects. This method uses the RSA private key provided during client initialization to decrypt the encrypt_random_key first, then decrypts the actual message.

Parameters:

• encryptRandomKey: The encrypt_random_key value obtained from GetChatData.
• encryptMsg: The encrypt_chat_msg value obtained from GetChatData.
• specificPrivateKey: (Optional) An alternative RSA private key. If an empty string is provided, the client's default privateKey is used.

Returns:

• A ChatMessage object and an error.

ChatMessage Fields:

• Id: Message ID.
• From: Sender ID.
• ToList: Recipient list.
• Action: Message action.
• Type: Message type.

// Assuming 'item' is a ChatData object from GetChatData
msg, err := client.DecryptData(item.EncryptRandomKey, item.EncryptChatMessage, "")
if err != nil {
    // handle error
}
fmt.Printf("Message from %s: %s\n", msg.From, msg.Type)

When receiving raw chat data from the SDK, use ChatRawData to check for errors and access the list of ChatData objects. Each ChatData contains encrypted content that requires decryption using the SDK's DecryptData method.

Decryption Workflow:

1. Identify the PublickeyVer and EncryptRandomKey from the ChatData object.
2. Base64 decode the EncryptRandomKey.
3. Use the decoded key and the EncryptChatMsg (the ciphertext) with the SDK's DecryptData method to obtain the plaintext message.

Key Fields in ChatData:

• Seq: A uint64 message sequence ID. Use the largest seq from your last response to fetch subsequent messages.
• MsgId: A unique identifier for the message, useful for deduplication.
• PublickeyVer: The version of the public key used for encryption.
• EncryptRandomKey: Base64 encoded content that, once decoded and decrypted with the appropriate private key, is used to decrypt the actual message.
• EncryptChatMsg: The encrypted message ciphertext.

// Example structure of ChatRawData
type ChatRawData struct {
	Error
	ChatDataList []ChatData `json:"chatdata,omitempty"` 
}

// Example structure of ChatData
type ChatData struct {
	Seq              uint64 `json:"seq,omitempty"`                
	MsgId            string `json:"msgid,omitempty"`              
	PublickeyVer     uint32 `json:"publickey_ver,omitempty"`      
	EncryptRandomKey string `json:"encrypt_random_key,omitempty"` 
	EncryptChatMsg   string `json:"encrypt_chat_msg,omitempty"`   
}